/ - Diff - Synnefo - Greek Research and Technology Network's projects

     from django.utils.encoding import smart_str
     from xml.dom import minidom
     from pithos.lib.filter import parse_filters
     from pithos.api.faults import (Fault, NotModified, BadRequest, Unauthorized, Forbidden, ItemNotFound, Conflict,
         LengthRequired, PreconditionFailed, RequestEntityTooLarge, RangeNotSatisfiable, UnprocessableEntity)
     from pithos.api.util import (rename_meta_key, format_header_key, printable_header_dict, get_account_headers,
-...
         keys = request.GET.get('meta')
         if keys:
             keys = keys.split(',')
             l = [smart_str(x) for x in keys if x.strip() != '']
             keys = [format_header_key('X-Object-Meta-' + x.strip()) for x in l]
             keys = [smart_str(x.strip()) for x in keys.split(',') if x.strip() != '']
             included, excluded, opers = parse_filters(keys)
             keys = []
             keys += [format_header_key('X-Object-Meta-' + x) for x in included]
             keys += [format_header_key('!X-Object-Meta-' + x) for x in excluded]
             keys += ['%s%s%s' % (format_header_key('X-Object-Meta-' + k), o, v) for k, o, v in opers]
         else:
             keys = []

                 'keys': Include objects that satisfy the key queries in the list.
                         Use 'key', '!key' for existence queries, 'key op value' for
                         value queries, where 'op' can be one of ==, != <=, >=, <, >
                         value queries, where 'op' can be one of =, != <=, >=, <, >
                 'shared': Only list objects with permissions set

     # interpreted as representing official policies, either expressed
     # or implied, of GRNET S.A.
     import re
     from time import time
     from dbworker import DBWorker
     from pithos.lib.filter import parse_filters
     ROOTNODE  = 0
-...
         return s
     _regexfilter = re.compile('(!?)\s*([\w-]+)\s*(==|!=|<=|>=|<|>)?\s*(.*)$', re.UNICODE)
     _propnames = {
         'serial'    : 0,
         'node'      : 1,
-...
                  "where serial = ?")
             self.execute(q, (dest, source))
         def _parse_filters(self, filterq):
             preterms = filterq.split(',')
             included = []
             excluded = []
             opers = []
             match = _regexfilter.match
             for term in preterms:
                 m = match(term)
                 if m is None:
                     continue
                 neg, key, op, value = m.groups()
                 if neg:
                     excluded.append(key)
                 elif not value:
                     included.append(key)
                 elif op:
                     opers.append((key, op, value))
             return included, excluded, opers
         def _construct_filters(self, filterq):
             if not filterq:
                 return None, None
             subqlist = []
             append = subqlist.append
             included, excluded, opers = self._parse_filters(filterq)
             included, excluded, opers = parse_filters(filterq.split(','))
             args = []
             if included:
-...
                        key ?op value
                            the attribute with this key satisfies the value
                            where ?op is one of ==, != <=, >=, <, >.
                            where ?op is one of =, != <=, >=, <, >.
                The list of common prefixes includes the prefixes
                matching up to the first delimiter after prefix,

     # Copyright 2011 GRNET S.A. All rights reserved.
+    #
     # Redistribution and use in source and binary forms, with or
     # without modification, are permitted provided that the following
     # conditions are met:
+    #
     #   1. Redistributions of source code must retain the above
     #      copyright notice, this list of conditions and the following
     #      disclaimer.
+    #
     #   2. Redistributions in binary form must reproduce the above
     #      copyright notice, this list of conditions and the following
     #      disclaimer in the documentation and/or other materials
     #      provided with the distribution.
+    #
     # THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
     # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
     # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
     # USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
     # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
     # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     # POSSIBILITY OF SUCH DAMAGE.
+    #
     # The views and conclusions contained in the software and
     # documentation are those of the authors and should not be
     # interpreted as representing official policies, either expressed
     # or implied, of GRNET S.A.
     import re
     _regexfilter = re.compile('(!?)\s*([\w-]+)\s*(=|!=|<=|>=|<|>)?\s*(.*)$', re.UNICODE)
     def parse_filters(terms):
         included = []
         excluded = []
         opers = []
         match = _regexfilter.match
         for term in terms:
             m = match(term)
             if m is None:
                 continue
             neg, key, op, value = m.groups()
             if neg:
                 excluded.append(key)
             elif not value:
                 included.append(key)
             elif op:
                 opers.append((key, op, value))
         return included, excluded, opers

Synnefo

Revision 1713c946