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

comparison roundup/hyperdb.py @ 6967:8473039648da

inital flake8 cleanups Replaced some calls to re.compile with module level variable. Renamed some variables.

author	John Rouillard <rouilj@ieee.org>
date	Tue, 13 Sep 2022 17:42:32 -0400
parents	8ab98de22df0
children	ca90f7270cd4 9b4bd9bc9bdc

comparison

equal deleted inserted replaced

-:8733aa2a8e40
+:8473039648da
 """Hyperdatabase implementation, especially field types.
 """
 __docformat__ = 'restructuredtext'
 # standard python modules
-import os, re, shutil, sys, weakref
+import logging
+import os
+import re
+import shutil
+import sys
 import traceback
-import logging
+import weakref
 # roundup modules
 from . import date, password
 from .support import ensureParentsExist, PrioList
 from roundup.mlink_expr import Expression
 def get_default_value(self):
 """The default value when creating a new instance of this property."""
 return self.__default_value
-def register (self, cls, propname):
+def register(self, cls, propname):
 """Register myself to the class of which we are a property
 the given propname is the name we have in our class.
 """
 assert not getattr(self, 'cls', None)
 self.name = propname
-self.cls  = cls
+self.cls = cls
 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
 do_journal,
 required=required,
 default_value=[], quiet=quiet,
 try_id_parsing=try_id_parsing,
 rev_multilink=rev_multilink)
-self.rev_property  = rev_property
+self.rev_property = rev_property
 self.rev_classname = None
-self.rev_propname  = None
+self.rev_propname = None
-self.table_name    = None # computed in 'register' below
+self.table_name = None  # computed in 'register' below
-self.linkid_name   = 'linkid'
+self.linkid_name = 'linkid'
-self.nodeid_name   = 'nodeid'
+self.nodeid_name = 'nodeid'
 if self.rev_property:
 # Do not allow updates if this is a reverse multilink
 self.computed = True
 self.rev_classname = rev_property.cls.classname
-self.rev_propname  = rev_property.name
+self.rev_propname = rev_property.name
 if isinstance(self.rev_property, Link):
-self.table_name  = '_' + self.rev_classname
+self.table_name = '_' + self.rev_classname
 self.linkid_name = 'id'
 self.nodeid_name = '_' + self.rev_propname
 else:
-self.table_name  = self.rev_classname + '_' + self.rev_propname
+self.table_name = self.rev_classname + '_' + self.rev_propname
 self.linkid_name = 'nodeid'
 self.nodeid_name = 'linkid'
 def from_raw(self, value, db, klass, propname, itemid, **kw):
 if not value:
 newvalue = []
 for item in value:
 item = item.strip()
 # skip blanks
-if not item: continue
+if not item: continue                                # noqa: E701
 # handle +/-
 remove = 0
 if item.startswith('-'):
 remove = 1
 #
 class DesignatorError(ValueError):
 pass
+dre = re.compile(r'^([A-Za-z](?:[A-Za-z_0-9]*[A-Za-z_]+)?)(\d+)$')
 def splitDesignator(designator,
-dre=re.compile(r'^([A-Za-z](?:[A-Za-z_0-9]*[A-Za-z_]+)?)(\d+)$')):
+dre=dre):
 """ Take a foo123 and return ('foo', 123)
 """
 m = dre.match(designator)
 if m is None:
 raise DesignatorError(_('"%s" not a node designator') % designator)
 """
 if name in self.propdict:
 pt = self.propdict[name]
 pt.need_for[need_for] = True
 # For now we do not recursively retrieve Link properties
-#if retr and isinstance(pt.propclass, Link):
+# if retr and isinstance(pt.propclass, Link):
 #    pt.append_retr_props()
 return pt
 propclass = self.props[name]
 cls = None
 props = None
 else:
 child.need_child_retired = True
 self.children.append(child)
 self.propdict[name] = child
 # For now we do not recursively retrieve Link properties
-#if retr and isinstance(child.propclass, Link):
+# if retr and isinstance(child.propclass, Link):
 #    child.append_retr_props()
 return child
 def append_retr_props(self):
 """Append properties for retrieval."""
 for p in self.children:
 if 'search' in p.need_for:
 x = [c for c in p.children if 'search' in c.need_for]
 if x:
 p.search(sort=False)
-if getattr(p.propclass,'rev_property',None):
+if getattr(p.propclass, 'rev_property', None):
 pn = p.propclass.rev_property.name
 cl = p.propclass.rev_property.cls
 if not isinstance(p.val, type([])):
 p.val = [p.val]
 nval = [int(i) for i in p.val]
 else:
 s2.add(node[pn])
 items |= s1.difference(s2)
 if isinstance(p.propclass.rev_property, Link):
 items |= set(cl.get(x, pn) for x in pval
 if not cl.is_retired(x))
 else:
 items |= set().union(*(cl.get(x, pn) for x in pval
 if not cl.is_retired(x)))
 else:
 # Expression: materialize rev multilinks and run
 # expression on them
 expr = Expression(nval)
 by_id = {}
 subst.append(v)
 if exact:
 exact_match_spec[p.name] = exact
 if subst:
 filterspec[p.name] = subst
-elif not exact: # don't set if we have exact criteria
+elif not exact:  # don't set if we have exact criteria
 if p.has_result:
 # A subquery already has found nothing. So
 # it doesn't make sense to search further.
 self.set_val([], force=True)
 return self.val
 else:
-filterspec[p.name] = ['-1'] # no match was found
+filterspec[p.name] = ['-1']  # no match was found
 else:
 assert not isinstance(p.val, Exact_Match)
 filterspec[p.name] = p.val
 self.set_val(self.cls._filter(search_matches, filterspec, sort and self,
 retired=retired,
 is_expression = \
 self.val and min(int(i) for i in self.val) < -1
 if is_expression:
 # Tag on the ORed values with an AND
 l = val
-for i in range(len(val)-1):
+for _i in range(len(val)-1):
 l.append('-4')
 l.append('-3')
 self.val = self.val + l
 else:
 vals.intersection_update(val)
 # This will change properties if a back-multilink happens to
 # have the same class, so we need to iterate over a list made
 # from .keys()
 for p in list(cl.properties.keys()):
 prop = cl.properties[p]
-if not isinstance (prop, (Link, Multilink)):
+if not isinstance(prop, (Link, Multilink)):
 continue
 if prop.rev_multilink:
 linkcls = self.getclass(prop.classname)
 if prop.rev_multilink in linkcls.properties:
 if not done:
 raise ValueError(
-"%s already a property of class %s"%
+"%s already a property of class %s" %
 (prop.rev_multilink, linkcls.classname))
 else:
 linkcls.properties[prop.rev_multilink] = Multilink(
 cl.classname, rev_property=prop)
 self.post_init_done = True
 This method must be called at the end of processing.
 """
 raise NotImplementedError
 def iter_roles(roles):
 ''' handle the text processing of turning the roles list
 into something python can use more easily
 '''
 """Slightly more useful representation
 Note that an error message can be raised at a point
 where self.classname isn't known yet if the error
 occurs during schema parsing.
 """
-cn = getattr (self, 'classname', 'Unknown')
+cn = getattr(self, 'classname', 'Unknown')
 return '<hyperdb.Class "%s">' % cn
 # Editing nodes:
 def create(self, **propvalues):
 """For some backends this implements the non-transitive
 search, for more information see the filter method.
 """
 raise NotImplementedError
-def _proptree(self, filterspec, exact_match_spec={}, sortattr=[],
+def _proptree(self, filterspec, exact_match_spec=None, sortattr=None,
 retr=False):
 """Build a tree of all transitive properties in the given
 exact_match_spec/filterspec.
 If we retrieve (retr is True) linked items we don't follow
 across multilinks or links.
 """
 if filterspec is None:
 filterspec = {}
+if exact_match_spec is None:
+exact_match_spec = {}
+if sortattr is None:
+sortattr = []
 proptree = Proptree(self.db, self, '', self.getprops(), retr=retr)
 for exact, spec in enumerate((filterspec, exact_match_spec)):
 for key, v in spec.items():
 keys = key.split('.')
 """Build a single list of sort attributes in the correct order
 with sanity checks (no duplicate properties) included. Always
 sort last by id -- if id is not already in sortattr.
 """
 if sort is None:
-sort = [(None,None)]
+sort = [(None, None)]
 if group is None:
 group = [(None, None)]
 seen = {}
 sortattr = []
 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=None):
 """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.
 """
+if propnames is None:
+propnames = []
 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
 each id, this way the memory footprint is a lot smaller than the
 initial implementation which stored everything in a big hash by
 id and then proceeded to import journals for each id."""
 properties = self.getprops()
 a = []
-for l in entries:
+for entry 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(entry[0].strip("'")), entry))
 a.sort()
 last = 0
 r = []
 for n, l in a:
 class HyperdbValueError(ValueError):
 """ Error converting a raw value into a Hyperdb value """
 pass
-def convertLinkValue(db, propname, prop, value, idre=re.compile(r'^\d+$')):
+id_regex = re.compile(r'^\d+$')
+def convertLinkValue(db, propname, prop, value, idre=id_regex):
 """ 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:
 def keys(self, protected=1):
 return list(self.cl.getprops(protected=protected).keys())
 def values(self, protected=1):
-l = []
+value_list = []
 for name in self.cl.getprops(protected=protected).keys():
-l.append(self.cl.get(self.nodeid, name))
+value_list.append(self.cl.get(self.nodeid, name))
-return l
+return value_list
 def items(self, protected=1):
-l = []
+item_list = []
 for name in self.cl.getprops(protected=protected).keys():
-l.append((name, self.cl.get(self.nodeid, name)))
+item_list.append((name, self.cl.get(self.nodeid, name)))
-return l
+return item_list
 def has_key(self, name):
 return name in self.cl.getprops()
 def get(self, name, default=None):
 """
 cl = Class(db, name, name=String(), order=String())
 for i in range(len(options)):
 cl.create(name=options[i], order=i)
 return Link(name)

Mercurial > p > roundup > code

comparison roundup/hyperdb.py @ 6967:8473039648da