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

comparison roundup/hyperdb.py @ 7045:ca90f7270cd4 issue2550923_computed_property

merge from main tip. This should fix test failure in Markdown2TestCase.test_string_markdown_code_block_attribute by merging html diff method used in tests.

author	John Rouillard <rouilj@ieee.org>
date	Mon, 07 Nov 2022 22:58:38 -0500
parents	e1588ae185dc 8473039648da
children	82bbb95e5690

comparison

equal deleted inserted replaced

-:e1588ae185dc
+:ca90f7270cd4
 """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('.')
 p = proptree
 def _sortattr(self, sort=[], group=[]):
 """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)]
+if group is None:
+group = [(None, None)]
 seen = {}
 sortattr = []
 for srt in group, sort:
 if not isinstance(srt, list):
 srt = [srt]
 respectively. These can be used when displaying a number of
 items in a pagination application or similar. A common use-case
 is returning the first item of a sorted search by specifying
 limit=1 (i.e. the maximum or minimum depending on sort order).
-The filter must match all properties specificed. If the property
+The filter must match all properties specified. If the property
 value to match is a list:
 1. String properties must match all elements in the list, and
 2. Other properties must match any of the elements in the list.
 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 @ 7045:ca90f7270cd4 issue2550923_computed_property