Mercurial Repository: p/roundup/code: roundup/hyperdb.py comparison

comparison roundup/hyperdb.py @ 6006:cf800f1febe6

Flake8 fixes; use isinstance rather than type equality. Also remove assignment for unused variable. Replace x with _x in for loop variables that are not used but required to unpack tuple.

author	John Rouillard <rouilj@ieee.org>
date	Sat, 28 Dec 2019 14:41:55 -0500
parents	acc4a128ab9b
children	8497bf3f23a1

comparison

equal deleted inserted replaced

-:292c9dfd06bd
+:cf800f1febe6
 from roundup.anypy.cmp_ import NoneAndDictComparable
 from roundup.anypy.strings import eval_import
 logger = logging.getLogger('roundup.hyperdb')
 #
 # Types
 #
 class _Type(object):
 """A roundup property type."""
-def __init__(self, required=False, default_value = None, quiet=False):
+def __init__(self, required=False, default_value=None, quiet=False):
 self.required = required
 self.__default_value = default_value
 self.quiet = quiet
 def __repr__(self):
 ' more useful for dumps '
-return '<%s.%s>'%(self.__class__.__module__, self.__class__.__name__)
+return '<%s.%s>' % (self.__class__.__module__, self.__class__.__name__)
 def get_default_value(self):
 """The default value when creating a new instance of this property."""
 return self.__default_value
-def sort_repr (self, cls, val, name):
+def sort_repr(self, cls, val, name):
 """Representation used for sorting. This should be a python
 built-in type, otherwise sorting will take ages. Note that
 individual backends may chose to use something different for
 sorting as long as the outcome is the same.
 """
 return val
 class String(_Type):
 """An object designating a String property."""
-def __init__(self, indexme='no', required=False, default_value = "", quiet=False):
+def __init__(self, indexme='no', required=False, default_value="",
+quiet=False):
 super(String, self).__init__(required, default_value, quiet)
 self.indexme = indexme == 'yes'
 def from_raw(self, value, propname='', **kw):
 """fix the CRLF/CR -> LF stuff"""
 if propname == 'content':
 # Why oh why wasn't the FileClass content property a File
 # type from the beginning?
 return value
 return fixNewlines(value)
-def sort_repr (self, cls, val, name):
+def sort_repr(self, cls, val, name):
 if not val:
 return val
 if name == 'id':
 return int(val)
 return val.lower()
 class Password(_Type):
 """An object designating a Password property."""
-def __init__(self, scheme=None, required=False, default_value = None, quiet=False):
+def __init__(self, scheme=None, required=False, default_value=None,
+quiet=False):
 super(Password, self).__init__(required, default_value, quiet)
 self.scheme = scheme
 def from_raw(self, value, **kw):
 if not value:
 return None
 try:
-return password.Password(encrypted=value, scheme=self.scheme, strict=True)
+return password.Password(encrypted=value, scheme=self.scheme,
+strict=True)
 except password.PasswordValueError as message:
-raise HyperdbValueError(_('property %s: %s')%(kw['propname'], message))
+raise HyperdbValueError(_('property %s: %s') %
+(kw['propname'], message))
-def sort_repr (self, cls, val, name):
+def sort_repr(self, cls, val, name):
 if not val:
 return val
 return str(val)
 class Date(_Type):
 """An object designating a Date property."""
-def __init__(self, offset=None, required=False, default_value = None, quiet=False):
+def __init__(self, offset=None, required=False, default_value=None,
-super(Date, self).__init__(required = required,
+quiet=False):
-default_value = default_value,
+super(Date, self).__init__(required=required,
+default_value=default_value,
 quiet=quiet)
 self._offset = offset
 def offset(self, db):
 if self._offset is not None:
 return self._offset
 return db.getUserTimezone()
 def from_raw(self, value, db, **kw):
 try:
 value = date.Date(value, self.offset(db))
 except ValueError as message:
-raise HyperdbValueError(_('property %s: %r is an invalid '\
+raise HyperdbValueError(_('property %s: %r is an invalid '
-'date (%s)')%(kw['propname'], value, message))
+'date (%s)') % (kw['propname'],
+value, message))
 return value
 def range_from_raw(self, value, db):
 """return Range value from given raw value with offset correction"""
 return date.Range(value, date.Date, offset=self.offset(db))
-def sort_repr (self, cls, val, name):
+def sort_repr(self, cls, val, name):
 if not val:
 return val
 return str(val)
 class Interval(_Type):
 """An object designating an Interval property."""
 def from_raw(self, value, **kw):
 try:
 value = date.Interval(value)
 except ValueError as message:
-raise HyperdbValueError(_('property %s: %r is an invalid '\
+raise HyperdbValueError(_('property %s: %r is an invalid '
-'date interval (%s)')%(kw['propname'], value, message))
+'date interval (%s)') %
+(kw['propname'], value, message))
 return value
-def sort_repr (self, cls, val, name):
+def sort_repr(self, cls, val, name):
 if not val:
 return val
 return val.as_seconds()
 class _Pointer(_Type):
 """An object designating a Pointer property that links or multilinks
 to a node in a specified class."""
 def __init__(self, classname, do_journal='yes', try_id_parsing='yes',
 required=False, default_value=None,
-msg_header_property = None, quiet=False):
+msg_header_property=None, quiet=False):
 """ Default is to journal link and unlink events.
 When try_id_parsing is false, we don't allow IDs in input
 fields (the key of the Link or Multilink property must be
 given instead). This is useful when the name of a property
 can be numeric. It will only work if the linked item has a
 'X-Roundup-issue-assigned_to: joe_user'.
 """
 super(_Pointer, self).__init__(required, default_value, quiet)
 self.classname = classname
 self.do_journal = do_journal == 'yes'
-self.try_id_parsing      = try_id_parsing == 'yes'
+self.try_id_parsing = try_id_parsing == 'yes'
 self.msg_header_property = msg_header_property
 def __repr__(self):
 """more useful for dumps. But beware: This is also used in schema
 storage in SQL backends!
 """
-return '<%s.%s to "%s">'%(self.__class__.__module__,
+return '<%s.%s to "%s">' % (self.__class__.__module__,
 self.__class__.__name__, self.classname)
 class Link(_Pointer):
 """An object designating a Link property that links to a
 node in a specified class."""
 def from_raw(self, value, db, propname, **kw):
 if self.try_id_parsing:
 value = convertLinkValue(db, propname, self, value)
 else:
 value = convertLinkValue(db, propname, self, value, None)
 return value
-def sort_repr (self, cls, val, name):
+def sort_repr(self, cls, val, name):
 if not val:
 return val
 op = cls.labelprop()
 if op == 'id':
 return int(cls.get(val, op))
 return cls.get(val, op)
 class Multilink(_Pointer):
 """An object designating a Multilink property that links
 to nodes in a specified class.
 "classname" indicates the class to link to
 "do_journal" indicates whether the linked-to nodes should have
 'link' and 'unlink' events placed in their journal
 """
-def __init__(self, classname, do_journal = 'yes', required = False, quiet=False, try_id_parsing='yes'):
+def __init__(self, classname, do_journal='yes', required=False,
+quiet=False, try_id_parsing='yes'):
 super(Multilink, self).__init__(classname,
 do_journal,
-required = required,
+required=required,
-default_value = [], quiet=quiet,
+default_value=[], quiet=quiet,
 try_id_parsing=try_id_parsing)
 def from_raw(self, value, db, klass, propname, itemid, **kw):
 if not value:
 return []
 value = [int(x) for x in value]
 value.sort()
 value = [str(x) for x in value]
 return value
-def sort_repr (self, cls, val, name):
+def sort_repr(self, cls, val, name):
 if not val:
 return val
 op = cls.labelprop()
 if op == 'id':
 return [int(cls.get(v, op)) for v in val]
 return [cls.get(v, op) for v in val]
 class Boolean(_Type):
 """An object designating a boolean property"""
 def from_raw(self, value, **kw):
 value = value.strip()
 # checked is a common HTML checkbox value
 value = value.lower() in ('checked', 'yes', 'true', 'on', '1')
 return value
 class Number(_Type):
 """An object designating a numeric property"""
-def __init__(self, use_double = False, **kw):
+def __init__(self, use_double=False, **kw):
 """ The value use_double tells the database backend to use a
 floating-point format with more precision than the default.
 Usually implemented by type 'double precision' in the sql
 backend. The default is to use single-precision float (aka
 'real') in the db. Note that sqlite already uses 8-byte for
 floating point numbers.
 """
 self.use_double = use_double
 super(Number, self).__init__(**kw)
 def from_raw(self, value, **kw):
 value = value.strip()
 try:
 value = float(value)
 except ValueError:
-raise HyperdbValueError(_('property %s: %r is not a number')%(
+raise HyperdbValueError(_('property %s: %r is not a number') %
-kw['propname'], value))
+(kw['propname'], value))
 return value
 class Integer(_Type):
 """An object designating an integer property"""
 def from_raw(self, value, **kw):
 value = value.strip()
 try:
 value = int(value)
 except ValueError:
-raise HyperdbValueError(_('property %s: %r is not an integer')%(
+raise HyperdbValueError(_('property %s: %r is not an integer') %
-kw['propname'], value))
+(kw['propname'], value))
 return value
 #
 # Support for splitting designators
 #
 class DesignatorError(ValueError):
 pass
 def splitDesignator(designator, dre=re.compile(r'([^\d]+)(\d+)')):
 """ Take a foo123 and return ('foo', 123)
 """
 m = dre.match(designator)
 if m is None:
-raise DesignatorError(_('"%s" not a node designator')%designator)
+raise DesignatorError(_('"%s" not a node designator') % designator)
 return m.group(1), m.group(2)
 class Exact_Match(object):
 """ Used to encapsulate exact match semantics search values
 """
 def __init__(self, value):
 self.value = value
 class Proptree(object):
 """ Simple tree data structure for property lookup. Each node in
 the tree is a roundup Class Property that has to be navigated to
 find given property. The need_for attribute is used to mark nodes
 self.classname = None
 self.uniqname = None
 self.children = []
 self.sortattr = []
 self.propdict = {}
-self.need_for = {'search' : True}
+self.need_for = {'search': True}
 self.sort_direction = None
 self.sort_ids = None
 self.sort_ids_needed = False
 self.sort_result = None
 self.attr_sort_done = False
 self.tree_sort_done = False
 self.propclass = None
 self.orderby = []
-self.sql_idx = None # index of retrieved column in sql result
+self.sql_idx = None  # index of retrieved column in sql result
 if parent:
 self.root = parent.root
 self.depth = parent.depth + 1
 else:
 self.root = self
 cls = None
 props = None
 if isinstance(propclass, (Link, Multilink)):
 cls = self.db.getclass(propclass.classname)
 props = cls.getprops()
-child = self.__class__(self.db, cls, name, props, parent = self)
+child = self.__class__(self.db, cls, name, props, parent=self)
-child.need_for = {need_for : True}
+child.need_for = {need_for: True}
 child.propclass = propclass
 self.children.append(child)
 self.propdict[name] = child
 if retr and isinstance(child.propclass, Link):
 child.append_retr_props()
 ('sort' in self.need_for) or all children have tree_sort_done set and
 sort_ids_needed unset: set self.tree_sort_done if one of the conditions
 holds. Also remove sort_ids_needed recursively once having seen a
 Multilink that is used for sorting.
 """
-if isinstance (self.propclass, Multilink) and 'sort' in self.need_for:
+if isinstance(self.propclass, Multilink) and 'sort' in self.need_for:
 mlseen = True
 if mlseen:
 self.sort_ids_needed = False
 self.tree_sort_done = True
 for p in self.children:
 filterspec = {}
 exact_match_spec = {}
 for p in self.children:
 if 'search' in p.need_for:
 if p.children:
-p.search(sort = False)
+p.search(sort=False)
 if isinstance(p.val, type([])):
 exact = []
 subst = []
 for v in p.val:
 if isinstance(v, Exact_Match):
 self.val = self.cls._filter(search_matches, filterspec, sort and self,
 retired=retired,
 exact_match_spec=exact_match_spec)
 return self.val
-def sort (self, ids=None):
+def sort(self, ids=None):
 """ Sort ids by the order information stored in self. With
 optimisations: Some order attributes may be precomputed (by the
 backend) and some properties may already be sorted.
 """
 if ids is None:
 ids = self.val
-if self.sortattr and [s for s in self.sortattr if not s.attr_sort_done]:
+if self.sortattr and [s for s in self.sortattr
+if not s.attr_sort_done]:
 return self._searchsort(ids, True, True)
 return ids
 def sortable_children(self, intermediate=False):
 """ All children needed for sorting. If intermediate is True,
 for p in self.children:
 yield p
 for c in p:
 yield c
-def _get (self, ids):
+def _get(self, ids):
 """Lookup given ids -- possibly a list of list. We recurse until
 we have a list of ids.
 """
 if not ids:
 return ids
-if isinstance (ids[0], list):
+if isinstance(ids[0], list):
 cids = [self._get(i) for i in ids]
 else:
 cids = [i and self.parent.cls.get(i, self.name) for i in ids]
 if self.sortattr:
 cids = [self._searchsort(i, False, True) for i in cids]
 issues are sorted by author and then by the time of the messages
 *of this author*. Probably what the user intends in that case,
 so we do *not* use two sorted lists of messages, one sorted by
 author and one sorted by date for sorting issues.
 """
-for pt in self.sortable_children(intermediate = True):
+for pt in self.sortable_children(intermediate=True):
 # ids can be an empty list
 if pt.tree_sort_done or not ids:
 continue
-if pt.sort_ids: # cached or computed by backend
+if pt.sort_ids:  # cached or computed by backend
 cids = pt.sort_ids
 else:
 cids = pt._get(ids)
 if pt.sort_direction and not pt.sort_result:
 sortrep = pt.propclass.sort_repr
 if pt.children:
 pt._searchsort(cids, update, False)
 if self.sortattr and dosort:
 ids = self._sort(ids)
 if not update:
-for pt in self.sortable_children(intermediate = True):
+for pt in self.sortable_children(intermediate=True):
 pt.sort_ids = None
 for pt in self.sortattr:
 pt.sort_result = None
 return ids
 for sa in self.sortattr:
 if sa.attr_sort_done:
 break
 if sortattr:
 assert len(sortattr[0]) == len(sa.sort_result)
-sortattr.append (sa.sort_result)
+sortattr.append(sa.sort_result)
 if curdir != sa.sort_direction:
-dir_idx.append (idx)
+dir_idx.append(idx)
-directions.append (sa.sort_direction)
+directions.append(sa.sort_direction)
 curdir = sa.sort_direction
 idx += 1
-sortattr.append (val)
+sortattr.append(val)
-sortattr = zip (*sortattr)
+sortattr = zip(*sortattr)
 for dir, i in reversed(list(zip(directions, dir_idx))):
 rev = dir == '-'
-sortattr = sorted (sortattr,
+sortattr = sorted(sortattr,
-key = lambda x: NoneAndDictComparable(x[i:idx]),
+key=lambda x: NoneAndDictComparable(x[i:idx]),
-reverse = rev)
+reverse=rev)
 idx = i
 return [x[-1] for x in sortattr]
 def _sort_repr(self, sortrep, ids):
 """Call sortrep for given ids -- possibly a list of list. We
 recurse until we have a list of ids.
 """
 if not ids:
 return ids
-if isinstance (ids[0], list):
+if isinstance(ids[0], list):
 res = [self._sort_repr(sortrep, i) for i in ids]
 else:
 res = [sortrep(self.cls, i, self.name) for i in ids]
 return res
 r = ["proptree:" + self.name]
 for n in self:
 r.append("proptree:" + "    " * n.depth + n.name)
 return '\n'.join(r)
 __str__ = __repr__
 #
 # the base Database class
 #
 class DatabaseError(ValueError):
 """Error to be raised when there is some problem in the database code
 """
 pass
 class Database:
 """A database for storing records containing flexible data types.
 This class defines a hyperdatabase storage layer, which the Classes use to
 store their data.
 """Close the database.
 This method must be called at the end of processing.
 """
 def iter_roles(roles):
 ''' handle the text processing of turning the roles list
 into something python can use more easily
 '''
 or a ValueError is raised.  The keyword arguments in 'properties'
 must map names to property objects, or a TypeError is raised.
 """
 for name in 'creation activity creator actor'.split():
 if name in properties:
-raise ValueError('"creation", "activity", "creator" and '\
+raise ValueError('"creation", "activity", "creator" and '
 '"actor" are reserved')
 self.classname = classname
 self.properties = properties
 self.db = weakref.proxy(db)       # use a weak ref to avoid circularity
 self.key = ''
 self.reactors = dict([(a, PrioList()) for a in actions])
 def __repr__(self):
 """Slightly more useful representation
 """
-return '<hyperdb.Class "%s">'%self.classname
+return '<hyperdb.Class "%s">' % self.classname
 # Editing nodes:
 def create(self, **propvalues):
 """Create a new node of this class and return its id.
 node, an IndexError is raised.
 """
 raise NotImplementedError
 _marker = []
 def get(self, nodeid, propname, default=_marker, cache=1):
 """Get the value of a property on an existing node of this class.
 'nodeid' must be the id of an existing node of this class or an
 IndexError is raised.  'propname' must be the name of a property
 raise ValueError('Journalling is disabled for this class')
 perm = self.db.security.hasPermission
 journal = []
-uid=self.db.getuid() # id of the person requesting the history
+uid = self.db.getuid()  # id of the person requesting the history
 # Roles of the user and the configured obsolete_history_roles
 hr = set(iter_roles(self.db.config.OBSOLETE_HISTORY_ROLES))
 ur = set(self.db.user.get_roles(uid))
 allow_obsolete = bool(hr & ur)
 #   property is quiet
 #   property is not (viewable or editable)
 #   property is obsolete and not allow_obsolete
 id, evt_date, user, action, args = j
 if logger.isEnabledFor(logging.DEBUG):
-j_repr = "%s"%(j,)
+j_repr = "%s" % (j,)
 else:
-j_repr=''
+j_repr = ''
-if args and type(args) == type({}):
+if args and isinstance(args, type({})):
 for key in list(args.keys()):
-if key not in self.properties :
+if key not in self.properties:
 if enforceperm and not allow_obsolete:
 del args[key]
 continue
 if skipquiet and self.properties[key].quiet:
 logger.debug("skipping quiet property"
 " %s::%s in %s",
 self.classname, key, j_repr)
 del args[key]
 continue
-if enforceperm and not ( perm("View",
+if enforceperm and not (perm("View",
 uid,
 self.classname,
-property=key ) or perm("Edit",
+property=key) or
-uid,
+perm("Edit",
-self.classname,
+uid,
-property=key )):
+self.classname,
+property=key)):
 logger.debug("skipping unaccessible property "
 "%s::%s seen by user%s in %s",
 self.classname, key, uid, j_repr)
 del args[key]
 continue
 if not args:
 logger.debug("Omitting journal entry for  %s%s"
 " all props removed in: %s",
 self.classname, nodeid, j_repr)
 continue
 journal.append(j)
-elif action in ['link', 'unlink' ] and type(args) == type(()):
+elif action in ['link', 'unlink'] and isinstance(args, type(())):
 # definitions:
 # myself - object whose history is being filtered
 # linkee - object/class whose property is changing to
 #          include/remove myself
 # link property - property of the linkee class that is changing
 if not enforceperm or allow_obsolete:
 journal.append(j)
 continue
 # obsolete linked-to item
 try:
-k = cls.get (linkid, key)
+cls.get(linkid, key)  # does linkid exist
 except IndexError:
 if not enforceperm or allow_obsolete:
 journal.append(j)
 continue
 # is the updated property quiet?
 "%s %sed %s%s",
 j_repr, action, self.classname, nodeid)
 continue
 # can user view the property in linkee class
 if enforceperm and not (perm("View",
 uid,
 linkcl,
-property=key) or perm("Edit",
+property=key) or
-uid,
+perm("Edit",
-linkcl,
+uid,
-property=key)):
+linkcl,
+property=key)):
 logger.debug("skipping unaccessible property: "
 "%s with uid %s %sed %s%s",
 j_repr, uid, action,
 self.classname, nodeid)
 continue
 # check access to linkee object
 if enforceperm and not (perm("View",
 uid,
 cls.classname,
-itemid=linkid) or perm("Edit",
+itemid=linkid) or
-uid,
+perm("Edit",
-cls.classname,
+uid,
-itemid=linkid)):
+cls.classname,
+itemid=linkid)):
 logger.debug("skipping unaccessible object: "
 "%s uid %s %sed %s%s",
 j_repr, uid, action,
 self.classname, nodeid)
 continue
 4. first property from the sorted property name list
 """
 if hasattr(self, '_labelprop'):
 return self._labelprop
 k = self.getkey()
-if  k:
+if k:
 return k
 props = self.getprops()
 if 'name' in props:
 return 'name'
 elif 'title' in props:
 db.issue.find(messages={'1':1,'3':1}, files={'7':1})
 """
 raise NotImplementedError
-def _filter(self, search_matches, filterspec, sort=(None,None),
+def _filter(self, search_matches, filterspec, sort=(None, None),
-group=(None,None), retired=False, exact_match_spec={}):
+group=(None, None), retired=False, exact_match_spec={}):
 """For some backends this implements the non-transitive
 search, for more information see the filter method.
 """
 raise NotImplementedError
 for key, v in spec.items():
 keys = key.split('.')
 p = proptree
 mlseen = False
 for k in keys:
-if isinstance (p.propclass, Multilink):
+if isinstance(p.propclass, Multilink):
 mlseen = True
 isnull = v == '-1' or v is None
 islist = isinstance(v, type([]))
 nullin = islist and ('-1' in v or None in v)
 r = retr and not mlseen and not isnull and not nullin
 for s in sortattr:
 keys = s[1].split('.')
 p = proptree
 mlseen = False
 for k in keys:
-if isinstance (p.propclass, Multilink):
+if isinstance(p.propclass, Multilink):
 mlseen = True
 r = retr and not mlseen
 p = p.append(k, need_for='sort', retr=r)
-if isinstance (p.propclass, Multilink):
+if isinstance(p.propclass, Multilink):
 multilinks[p] = True
 if p.cls:
 p = p.append(p.cls.orderprop(), need_for='sort')
-if p.sort_direction: # if an orderprop is also specified explicitly
+if p.sort_direction:  # if orderprop is also specified explicitly
 continue
 p.sort_direction = s[0]
-proptree.sortattr.append (p)
+proptree.sortattr.append(p)
 for p in multilinks.keys():
 sattr = {}
 for c in p:
 if c.sort_direction:
-sattr [c] = True
+sattr[c] = True
 for sa in proptree.sortattr:
 if sa in sattr:
-p.sortattr.append (sa)
+p.sortattr.append(sa)
 return proptree
-def get_transitive_prop(self, propname_path, default = None):
+def get_transitive_prop(self, propname_path, default=None):
 """Expand a transitive property (individual property names
 separated by '.' into a new property at the end of the path. If
 one of the names does not refer to a valid property, we return
 None.
 Example propname_path (for class issue): "messages.author"
 srt = [srt]
 for s in srt:
 if s[1] and s[1] not in seen:
 sortattr.append((s[0] or '+', s[1]))
 seen[s[1]] = True
-if 'id' not in seen :
+if 'id' not in seen:
 sortattr.append(('+', 'id'))
 return sortattr
 def filter(self, search_matches, filterspec, sort=[], group=[],
 retired=False, exact_match_spec={}, limit=None, offset=None):
 using _filter implemented in a backend class. A more efficient
 version can be implemented in the individual backends -- e.g.,
 an SQL backend will want to create a single SQL statement and
 override the filter method instead of implementing _filter.
 """
-sortattr = self._sortattr(sort = sort, group = group)
+sortattr = self._sortattr(sort=sort, group=group)
 proptree = self._proptree(filterspec, exact_match_spec, sortattr)
 proptree.search(search_matches, retired=retired)
 if offset is not None or limit is not None:
 items = proptree.sort()
 if limit and offset:
 return items[offset:]
 else:
 return items[:limit]
 return proptree.sort()
 # non-optimized filter_iter, a backend may chose to implement a
 # better version that provides a real iterator that pre-fills the
 # cache for each id returned. Note that the filter_iter doesn't
 # promise to correctly sort by multilink (which isn't sane to do
 # anyway).
 If the "protected" flag is true, we include protected properties -
 those which may not be modified.
 """
 raise NotImplementedError
-def get_required_props(self, propnames = []):
+def get_required_props(self, propnames=[]):
 """Return a dict of property names mapping to property objects.
 All properties that have the "required" flag set will be
 returned in addition to all properties in the propnames
 parameter.
 """
-props = self.getprops(protected = False)
+props = self.getprops(protected=False)
 pdict = dict([(p, props[p]) for p in propnames])
 pdict.update([(k, v) for k, v in props.items() if v.required])
 return pdict
 def addprop(self, **properties):
 raise NotImplementedError
 #
 # Detector interface
 #
-def audit(self, event, detector, priority = 100):
+def audit(self, event, detector, priority=100):
 """Register an auditor detector"""
 self.auditors[event].append((priority, detector.__name__, detector))
 def fireAuditors(self, event, nodeid, newvalues):
 """Fire all registered auditors"""
-for prio, name, audit in self.auditors[event]:
+for _prio, _name, audit in self.auditors[event]:
 try:
 audit(self.db, self, nodeid, newvalues)
 except (EnvironmentError, ArithmeticError) as e:
 tb = traceback.format_exc()
 html = ("<h1>Traceback</h1>" + str(tb).replace('\n', '<br>').
 txt = 'Caught exception %s: %s\n%s' % (str(type(e)), e, tb)
 exc_info = sys.exc_info()
 subject = "Error: %s" % exc_info[1]
 raise DetectorError(subject, html, txt)
-def react(self, event, detector, priority = 100):
+def react(self, event, detector, priority=100):
 """Register a reactor detector"""
 self.reactors[event].append((priority, detector.__name__, detector))
 def fireReactors(self, event, nodeid, oldvalues):
 """Fire all registered reactors"""
-for prio, name, react in self.reactors[event]:
+for _prio, _name, react in self.reactors[event]:
 try:
 react(self.db, self, nodeid, oldvalues)
 except (EnvironmentError, ArithmeticError) as e:
 tb = traceback.format_exc()
 html = ("<h1>Traceback</h1>" + str(tb).replace('\n', '<br>').
 properties = self.getprops()
 a = []
 for l in entries:
 # first element in sorted list is the (numeric) id
 # in python2.4 and up we would use sorted with a key...
-a.append ((int (l [0].strip ("'")), l))
+a.append((int(l[0].strip("'")), l))
-a.sort ()
+a.sort()
 last = 0
 r = []
 for n, l in a:
 nodeid, jdate, user, action, params = map(eval_import, l)
 For convenience reasons we take a list.
 In standard schemas only a user has a roles property but
 this may be different in customized schemas.
 '''
-roles = dict.fromkeys ([r.strip().lower() for r in roles])
+roles = dict.fromkeys([r.strip().lower() for r in roles])
 for role in self.get_roles(nodeid):
 if role in roles:
 return True
 return False
 class HyperdbValueError(ValueError):
 """ Error converting a raw value into a Hyperdb value """
 pass
 def convertLinkValue(db, propname, prop, value, idre=re.compile(r'^\d+$')):
 """ Convert the link value (may be id or key value) to an id value. """
 linkcl = db.classes[prop.classname]
 if not idre or not idre.match(value):
 if linkcl.getkey():
 try:
 value = linkcl.lookup(value)
-except KeyError as message:
+except KeyError:
-raise HyperdbValueError(_('property %s: %r is not a %s.')%(
+raise HyperdbValueError(_('property %s: %r is not a %s.') % (
 propname, value, prop.classname))
 else:
-raise HyperdbValueError(_('you may only enter ID values '\
+raise HyperdbValueError(_('you may only enter ID values '
-'for property %s')%propname)
+'for property %s') % propname)
 return value
 def fixNewlines(text):
 """ Homogenise line endings.
 Different web clients send different line ending values, but
 if text is not None:
 text = text.replace('\r\n', '\n')
 return text.replace('\r', '\n')
 return text
 def rawToHyperdb(db, klass, itemid, propname, value, **kw):
 """ Convert the raw (user-input) value to a hyperdb-storable value. The
 value is for the "propname" property on itemid (may be None for a
 new item) of "klass" in "db".
 properties = klass.getprops()
 # ensure it's a valid property name
 propname = propname.strip()
 try:
-proptype =  properties[propname]
+proptype = properties[propname]
 except KeyError:
-raise HyperdbValueError(_('%r is not a property of %s')%(propname,
+raise HyperdbValueError(_('%r is not a property of %s') % (
-klass.classname))
+propname, klass.classname))
 # if we got a string, strip it now
 if isinstance(value, type('')):
 value = value.strip()
 # convert the input value to a real property value
 value = proptype.from_raw(value, db=db, klass=klass,
 propname=propname, itemid=itemid, **kw)
 return value
 class FileClass:
 """ A class that requires the "content" property and stores it on
 disk.
 """
 index_content = index_content.decode('utf-8', errors='ignore')
 # indexer will only index text mime type. It will skip
 # other types. So if mime type of file is correct, we
 # call add_text on content.
 self.db.indexer.add_text((self.classname, nodeid, 'content'),
 index_content, mime_type)
 class Node:
 """ A convenience wrapper for the given node
 """
 def __init__(self, cl, nodeid, cache=1):
 self.__dict__['cl'] = cl
 self.__dict__['nodeid'] = nodeid
 def keys(self, protected=1):
 return list(self.cl.getprops(protected=protected).keys())
 def values(self, protected=1):
 l = []
 for name in self.cl.getprops(protected=protected).keys():
 l.append(self.cl.get(self.nodeid, name))
 return l
 def items(self, protected=1):
 l = []
 for name in self.cl.getprops(protected=protected).keys():
 l.append((name, self.cl.get(self.nodeid, name)))
 return l
 def has_key(self, name):
 return name in self.cl.getprops()
 def get(self, name, default=None):
 if name in self:
 return self[name]
 else:
 return default
 def __getattr__(self, name):
 if name in self.__dict__:
 return self.__dict__[name]
 try:
 return self.cl.get(self.nodeid, name)
 except KeyError as value:
 # we trap this but re-raise it as AttributeError - all other
 # exceptions should pass through untrapped
 raise AttributeError(str(value))
 def __getitem__(self, name):
 return self.cl.get(self.nodeid, name)
 def __setattr__(self, name, value):
 try:
 return self.cl.set(self.nodeid, **{name: value})
 except KeyError as value:
 # we trap this but re-raise it as AttributeError - all other
 # exceptions should pass through untrapped
 raise AttributeError(str(value))
 def __setitem__(self, name, value):
 self.cl.set(self.nodeid, **{name: value})
 def history(self, enforceperm=True, skipquiet=True):
 return self.cl.history(self.nodeid,
 enforceperm=enforceperm,
-skipquiet=skipquiet )
+skipquiet=skipquiet)
 def retire(self):
 return self.cl.retire(self.nodeid)
 def Choice(name, db, *options):

Mercurial > p > roundup > code

comparison roundup/hyperdb.py @ 6006:cf800f1febe6