Mercurial Repository: p/roundup/code: roundup/cgi/templating.py comparison

comparison roundup/cgi/templating.py @ 7037:22183e7d1443

flake8 whitepace, indents, var names address: B007 Loop control variable 'id' not used within the loop body. If this is intended, start the name with an underscore. E122 continuation line missing indentation or outdented E127 continuation line over-indented for visual indent E128 continuation line under-indented for visual indent E129 visually indented line with same indent as next logical line E701 multiple statements on one line (colon) E703 statement ends with a semicolon E741 ambiguous variable name 'l'

author	John Rouillard <rouilj@ieee.org>
date	Mon, 10 Oct 2022 15:43:13 -0400
parents	7847c9bdb631
children	ca90f7270cd4 2c89bdc88923

comparison

equal deleted inserted replaced

-:7847c9bdb631
+:22183e7d1443
 def is_restore_ok(self):
 """ Is the user allowed to restore this item?
 """
 perm = self._db.security.hasPermission
-return perm('Web Access', self._client.userid) and perm('Restore',
+return perm('Web Access', self._client.userid) and perm(
-self._client.userid, self._classname, itemid=self._nodeid)
+'Restore', self._client.userid, self._classname,
+itemid=self._nodeid)
 def is_view_ok(self):
 """ Is the user allowed to View this item?
 """
 perm = self._db.security.hasPermission
 timezone = self._db.getUserTimezone()
 l = []
 current = {}
 comments = {}
-for id, evt_date, user, action, args in history:
+for _id, evt_date, user, action, args in history:
 date_s = str(evt_date.local(timezone)).replace(".", " ")
 arg_s = ''
 if action in ['link', 'unlink'] and isinstance(args, tuple):
 if len(args) == 3:
 linkcl, linkid, key = args
-arg_s += '<a rel="nofollow noopener" href="%s%s">%s%s %s</a>' % (linkcl, linkid,
+arg_s += '<a rel="nofollow noopener" href="%s%s">%s%s %s</a>' % (
-linkcl, linkid, key)
+linkcl, linkid, linkcl, linkid, key)
 else:
 arg_s = str(args)
 elif isinstance(args, dict):
 cell = []
 for k in args.keys():
 if prop is None:
 # property no longer exists
 comments['no_exist'] = self._(
 "<em>The indicated property no longer exists</em>")
 cell.append(self._('<em>%s: %s</em>\n')
 % (self._(k), str(args[k])))
 continue
 # load the current state for the property (if we
 # haven't already)
 if k not in current:
 linkid = self._klass.get(self._nodeid, k, None)
 current[k] = '<a rel="nofollow noopener" href="%s%s">%s</a>' % (
 classname, linkid, current[k])
 if args[k] and (isinstance(prop, hyperdb.Multilink) or
 isinstance(prop, hyperdb.Link)):
 # figure what the link class is
 classname = prop.classname
 try:
 linkcl = self._db.getclass(classname)
 except KeyError:
 "The linked class %(classname)s no longer exists"
 ) % locals()
 labelprop = linkcl.labelprop(1)
 try:
 template = self._client.selectTemplate(classname,
 'item')
 if template.startswith('_generic.'):
 raise NoTemplate('not really...')
 hrefable = 1
 except NoTemplate:
 hrefable = 0
 # TODO: test for node existence even when
 # there's no labelprop!
 try:
 if labelprop is not None and \
 labelprop != 'id':
-label = linkcl.get(linkid, labelprop,
+label = linkcl.get(
-default=self._(
+linkid, labelprop,
-"[label is missing]"))
+default=self._(
+"[label is missing]"))
 label = html_escape(label)
 except IndexError:
 comments['no_link'] = self._(
 "<strike>The linked node"
 " no longer exists</strike>")
 subml.append('<strike>%s</strike>' % label)
 else:
 if hrefable:
-subml.append('<a rel="nofollow noopener" '
+subml.append(
-'href="%s%s">%s</a>' % (
+'<a rel="nofollow noopener" '
-classname, linkid, label))
+'href="%s%s">%s</a>' % (
+classname, linkid, label))
 elif label is None:
 subml.append('%s%s' % (classname,
 linkid))
 else:
 subml.append(label)
 ml.append(sublabel + ', '.join(subml))
 cell.append('%s:\n  %s' % (self._(k), ', '.join(ml)))
 elif isinstance(prop, hyperdb.Link) and args[k]:
 # if we have a label property, try to use it
 # TODO: test for node existence even when
 # there's no labelprop!
 if labelprop is not None and labelprop != 'id':
 try:
-label = html_escape(linkcl.get(args[k],
+label = html_escape(
-labelprop, default=self._(
+linkcl.get(args[k],
-"[label is missing]")))
+labelprop, default=self._(
+"[label is missing]")))
 except IndexError:
 comments['no_link'] = self._(
 "<strike>The linked node"
 " no longer exists</strike>")
 cell.append(' <strike>%s</strike>,\n' % label)
 # "flag" this is done .... euwww
 label = None
 if label is not None:
 if hrefable:
-old = '<a rel="nofollow noopener" href="%s%s">%s</a>' % (classname,
+old = '<a rel="nofollow noopener" href="%s%s">%s</a>' % (
-args[k], label)
+classname, args[k], label)
 else:
-old = label;
+old = label
 cell.append('%s: %s' % (self._(k), old))
 if k in current and current[k] is not None:
 cell[-1] += ' -> %s' % current[k]
 current[k] = old
 elif isinstance(prop, hyperdb.Date) and args[k]:
 if args[k] is None:
 d = ''
 else:
-d = date.Date(args[k],
+d = date.Date(
+args[k],
 translator=self._client).local(timezone)
 cell.append('%s: %s' % (self._(k), str(d)))
 if k in current and current[k] is not None:
 cell[-1] += ' -> %s' % current[k]
 current[k] = str(d)
 elif isinstance(prop, hyperdb.Interval) and args[k]:
 val = str(date.Interval(args[k],
 translator=self._client))
 cell.append('%s: %s' % (self._(k), val))
 if k in current and current[k] is not None:
 cell[-1] += ' -> %s' % current[k]
 current[k] = val
 if direction == 'ascending':
 l.reverse()
 l[0:0] = ['<table class="history table table-condensed table-striped">'
 '<tr><th colspan="4" class="header">',
 self._('History'),
 '</th></tr><tr>',
 self._('<th>Date</th>'),
 self._('<th>User</th>'),
 self._('<th>Action</th>'),
 self._('<th>Args</th>'),
 '</tr>']
 l.append('</table>')
 self._client.form_wins = orig_form_wins
 return '\n'.join(l)
 # create a new request and override the specified args
 req = HTMLRequest(self._client)
 req.classname = self._klass.get(self._nodeid, 'klass')
 name = self._klass.get(self._nodeid, 'name')
 req.updateFromURL(self._klass.get(self._nodeid, 'url') +
 '&@queryname=%s' % urllib_.quote(name))
 # new template, using the specified classname and request
 # [ ] the custom logic for search page doesn't belong to
 #     generic templating module (techtonik)
 tplname = self._client.selectTemplate(req.classname, 'search')
 """Add ability to check for permissions on users.
 """
 _marker = []
 def hasPermission(self, permission, classname=_marker,
 property=None, itemid=None):
 """Determine if the user has the Permission.
 The class being tested defaults to the template's class, but may
 be overidden for this test by suppling an alternate classname.
 """
 if classname is self._marker:
 classname = self._client.classname
-return self._db.security.hasPermission(permission,
+return self._db.security.hasPermission(
-self._nodeid, classname, property, itemid)
+permission, self._nodeid, classname, property, itemid)
 def hasRole(self, *rolenames):
 """Determine whether the user has any role in rolenames."""
 return self._db.user.has_role(self._nodeid, *rolenames)
 _value the value of the property if any
 A wrapper object which may be stringified for the plain() behaviour.
 """
 def __init__(self, client, classname, nodeid, prop, name, value,
 anonymous=0):
 self._client = client
 self._db = client.db
 self._ = client._
 self._classname = classname
 self._nodeid = nodeid
 userid = self._client.userid
 if self._nodeid:
 if not perm('Web Access', userid):
 return False
 return perm('Edit', userid, self._classname, self._name,
 self._nodeid)
 return perm('Create', userid, self._classname, self._name) or \
 perm('Register', userid, self._classname, self._name)
 def is_view_ok(self):
 """ Is the user allowed to View the current class?
 """
 perm = self._db.security.hasPermission
-if perm('Web Access',  self._client.userid) and perm('View',
+if perm('Web Access',  self._client.userid) and perm(
-self._client.userid, self._classname, self._name, self._nodeid):
+'View', self._client.userid, self._classname,
+self._name, self._nodeid):
 return 1
 return self.is_edit_ok()
 class StringHTMLProperty(HTMLProperty):
 if match.group('url'):
 return self._hyper_repl_url(match, '<a href="%s" rel="nofollow noopener">%s</a>%s')
 elif match.group('email'):
 return self._hyper_repl_email(match, '<a href="mailto:%s">%s</a>')
 elif len(match.group('id')) < 10:
-return self._hyper_repl_item(match,
+return self._hyper_repl_item(
-'<a href="%(cls)s%(id)s%(fragment)s">%(item)s</a>')
+match, '<a href="%(cls)s%(id)s%(fragment)s">%(item)s</a>')
 else:
 # just return the matched text
 return match.group(0)
 def _hyper_repl_url(self, match, replacement):
 if sch in self.valid_schemes:
 pass
 else:
 raise
-return u2s(ReStructuredText(s, writer_name="html",
+return u2s(ReStructuredText(
-settings_overrides=self.rst_defaults)["html_body"])
+s, writer_name="html",
+settings_overrides=self.rst_defaults)["html_body"])
 def markdown(self, hyperlink=1):
 """ Render the value of the property as markdown.
 This requires markdown2 or markdown to be installed separately.
 value = '&quot;'.join(value.split('"'))
 name = self._formname
 passthrough_args = self.cgi_escape_attrs(**kwargs)
 return ('<textarea %(passthrough_args)s name="%(name)s" id="%(name)s"'
 ' rows="%(rows)s" cols="%(cols)s">'
 '%(value)s</textarea>') % locals()
 def email(self, escape=1):
 """ Render the value of the property as an obscured email address
 """
 if not self.is_view_ok():
 return self.plain(escape=1)
 value = self._value
 if is_us(value):
 value = value.strip().lower() in ('checked', 'yes', 'true',
 'on', '1')
 if (not y_label):
 y_label = '<label class="rblabel" for="%s_%s">' % (
 self._formname, 'yes')
 y_label += self._('Yes')
 n_label += '</label>'
 checked = value and "checked" or ""
 if value:
 y_rb = self.input(type="radio", name=self._formname, value="yes",
 checked="checked", id="%s_%s" % (
 self._formname, 'yes'), **kwargs)
 n_rb = self.input(type="radio", name=self._formname,  value="no",
 id="%s_%s" % (
 self._formname, 'no'), **kwargs)
 else:
 y_rb = self.input(type="radio", name=self._formname, value="yes",
 id="%s_%s" % (self._formname, 'yes'), **kwargs)
 n_rb = self.input(type="radio", name=self._formname,  value="no",
 checked="checked", id="%s_%s" % (
 self._formname, 'no'), **kwargs)
 if (u_label):
 if (u_label is True):  # it was set via u_label=True
 u_label = ''       # make it empty but a string not boolean
 u_rb = self.input(type="radio", name=self._formname,  value="",
 id="%s_%s" % (self._formname, 'unk'), **kwargs)
 else:
 # don't generate a trivalue radiobutton.
 u_label = ''
 u_rb = ''
 class DateHTMLProperty(HTMLProperty):
 _marker = []
 def __init__(self, client, classname, nodeid, prop, name, value,
 anonymous=0, offset=None):
 HTMLProperty.__init__(self, client, classname, nodeid, prop, name,
 value, anonymous=anonymous)
 if self._value and not is_us(self._value):
 self._value.setTranslator(self._client.translator)
 self._offset = offset
 if self._offset is None:
 self._offset = self._prop.offset(self._db)
 ret = ret + interval
 else:
 ret = ret - interval
 return DateHTMLProperty(self._client, self._classname, self._nodeid,
 self._prop, self._formname, ret)
 def field(self, size=30, default=None, format=_marker, popcal=True,
 **kwargs):
 """Render a form edit field for the property
 elif isinstance(default, date.Date):
 raw_value = default
 elif isinstance(default, DateHTMLProperty):
 raw_value = default._value
 else:
-raise ValueError(self._('default value for '
+raise ValueError(self._(
+'default value for '
 'DateHTMLProperty must be either DateHTMLProperty '
 'or string date representation.'))
 elif is_us(value):
 # most likely erroneous input to be passed back to user
 value = us2s(value)
 s = self.input(name=self._formname, value=value, size=size,
 **kwargs)
 if popcal:
 s += self.popcal()
 return s
 else:
 raw_value = value
 """
 if not self.is_view_ok():
 return self._('[hidden]')
 return DateHTMLProperty(self._client, self._classname, self._nodeid,
-self._prop, self._formname, self._value, offset=offset)
+self._prop, self._formname, self._value,
+offset=offset)
 def popcal(self, width=300, height=200, label="(cal)",
 form="itemSynopsis"):
 """Generate a link to a calendar pop-up window.
 item: HTMLProperty e.g.: context.deadline
 """
 if self.isset():
 "data-width": width,
 "data-height": height
 }
 return ('<a class="classhelp" %s href="javascript:help_window('
 "'%s?@template=calendar&amp;property=%s&amp;form=%s%s', %d, %d)"
 '">%s</a>' % (self.cgi_escape_attrs(**data_attr),
 self._classname, self._name, form, date, width,
 height, label))
 class IntervalHTMLProperty(HTMLProperty):
 def __init__(self, client, classname, nodeid, prop, name, value,
 anonymous=0):
 HTMLProperty.__init__(self, client, classname, nodeid, prop,
 name, value, anonymous)
 if self._value and not is_us(self._value):
 self._value.setTranslator(self._client.translator)
 def plain(self, escape=0):
 """ Render a "plain" representation of the property
 value = self._value
 elif value == '-1':
 value = None
 linkcl = self._db.getclass(self._prop.classname)
-l = ['<select %s>' % self.cgi_escape_attrs(name=self._formname,
+html = ['<select %s>' % self.cgi_escape_attrs(name=self._formname,
 **html_kwargs)]
 k = linkcl.labelprop(1)
 s = ''
 if value is None:
 s = 'selected="selected" '
-l.append(self._('<option %svalue="-1">- no selection -</option>') % s)
+html.append(self._(
+'<option %svalue="-1">- no selection -</option>') % s)
 if sort_on is not None:
 if not isinstance(sort_on, tuple):
 if sort_on[0] in '+-':
 sort_on = (sort_on[0], sort_on[1:])
 sort_on = ('+', sort_on)
 else:
 sort_on = ('+', linkcl.orderprop())
 options = [opt
-for opt in linkcl.filter(None, conditions, sort_on, (None, None))
+for opt in linkcl.filter(
-if self._db.security.hasPermission("View", self._client.userid,
+None, conditions, sort_on, (None, None))
-linkcl.classname, itemid=opt)]
+if self._db.security.hasPermission(
+"View", self._client.userid, linkcl.classname,
+itemid=opt)]
 # make sure we list the current value if it's retired
 if value and value not in options:
 options.insert(0, value)
 # and generate
 tr = str
 if translate:
 tr = self._
 lab = html_escape(tr(lab))
-l.append('<option %svalue="%s">%s</option>' % (s, optionid, lab))
+html.append(
-l.append('</select>')
+'<option %svalue="%s">%s</option>' % (s, optionid, lab))
-return '\n'.join(l)
+html.append('</select>')
+return '\n'.join(html)
 #    def checklist(self, ...)
 class MultilinkHTMLProperty(HTMLProperty):
 """
 def __init__(self, *args, **kwargs):
 HTMLProperty.__init__(self, *args, **kwargs)
 if self._value:
 display_value = lookupIds(self._db, self._prop, self._value,
 fail_ok=1, do_lookup=False)
 keyfun = make_key_function(self._db, self._prop.classname)
 # sorting fails if the value contains
 # items not yet stored in the database
 # ignore these errors to preserve user input
 try:
 return self.viewableGenerator(self._value)
 def reverse(self):
 """ return the list in reverse order
 """
-l = self._value[:]
+mylist = self._value[:]
-l.reverse()
+mylist.reverse()
-return self.viewableGenerator(l)
+return self.viewableGenerator(mylist)
 def sorted(self, property, reverse=False, NoneFirst=False):
 """ Return this multilink sorted by the given property
 Set Nonefirst to True to sort None/unset property
 label = linkcl.get(v, k,
 default=self._("[label is missing]"))
 except IndexError:
 label = None
 # fall back to designator if label is None
-if label is None: label = '%s%s' % (self._prop.classname, k)
+if label is None:
+label = '%s%s' % (self._prop.classname, k)
 else:
 label = v
 labels.append(label)
 value = ', '.join(labels)
 if escape:
 sort_on = ('+', sort_on)
 else:
 sort_on = ('+', linkcl.orderprop())
 options = [opt
 for opt in linkcl.filter(None, conditions, sort_on)
-if self._db.security.hasPermission("View", self._client.userid,
+if self._db.security.hasPermission(
-linkcl.classname, itemid=opt)]
+"View", self._client.userid, linkcl.classname,
+itemid=opt)]
 # make sure we list the current values if they're retired
 for val in value:
 if val not in options:
 options.insert(0, val)
 height = len(options)
 if value:
 # The "no selection" option.
 height += 1
 height = min(height, 7)
-l = ['<select multiple %s>' % self.cgi_escape_attrs(
+html = ['<select multiple %s>' % self.cgi_escape_attrs(
 name=self._formname, size=height, **html_kwargs)]
 k = linkcl.labelprop(1)
 if value:  # FIXME '- no selection -' mark for translation
-l.append('<option value="%s">- no selection -</option>'
+html.append('<option value="%s">- no selection -</option>'
 % ','.join(['-' + v for v in value]))
 if additional:
 additional_fns = []
 props = linkcl.getprops()
 for propname in additional:
 # and generate
 tr = str
 if translate:
 tr = self._
 lab = html_escape(tr(lab))
-l.append('<option %svalue="%s">%s</option>' % (s, optionid,
+html.append('<option %svalue="%s">%s</option>' % (s, optionid,
 lab))
-l.append('</select>')
+html.append('</select>')
-return '\n'.join(l)
+return '\n'.join(html)
 # set the propclasses for HTMLItem
 propclasses = [
 (hyperdb.String, StringHTMLProperty),
 prop = cls.get_transitive_prop(name)
 fv = self.form[name]
 if (isinstance(prop, hyperdb.Link) or
 isinstance(prop, hyperdb.Multilink)):
 self.filterspec[name] = lookupIds(db, prop,
 handleListCGIValue(fv))
 else:
 if isinstance(fv, type([])):
 self.filterspec[name] = [v.value for v in fv]
 elif name == 'id':
 # special case "id" property
 self.filterspec[name] = handleListCGIValue(fv)
 else:
 self.filterspec[name] = fv.value
 self.filterspec = security.filterFilterspec(userid, self.classname,
 self.filterspec)
 # full-text search argument
 self.search_text = None
 for name in ':search_text @search_text'.split():
 if self._form_has_key(name):
 startwith: %(startwith)r
 env: %(env)s
 """ % d
 def indexargs_form(self, columns=1, sort=1, group=1, filter=1,
 filterspec=1, search_text=1, exclude=[]):
 """ return the current index args as form elements
 This routine generates an html form with hidden elements.
 If you want to have visible form elements in your tal/jinja
 generated templates use the exclude aray to list the names for
 these elements. This wll prevent the function from creating
 these elements in its output.
 """
-l = []
+html = []
 sc = self.special_char
 def add(k, v):
-l.append(self.input(type="hidden", name=k, value=v))
+html.append(self.input(type="hidden", name=k, value=v))
 if columns and self.columns:
 add(sc+'columns', ','.join(self.columns))
 if sort:
 val = []
 for dir, attr in self.sort:
 continue
 if isinstance(v, list):
 # id's are stored as strings but should be treated
 # as integers in lists.
 if (isinstance(cls.get_transitive_prop(k), hyperdb.String)
 and k != 'id'):
 add(k, ' '.join(v))
 else:
 add(k, ','.join(v))
 else:
 add(k, v)
 if search_text and self.search_text:
 add(sc+'search_text', self.search_text)
 add(sc+'pagesize', self.pagesize)
 add(sc+'startwith', self.startwith)
-return '\n'.join(l)
+return '\n'.join(html)
 def indexargs_url(self, url, args):
 """ Embed the current index args in a URL
 If the value of an arg (in args dict) is None,
 """
 check = self._client.db.security.hasPermission
 userid = self._client.userid
 if not check('Web Access', userid):
 return Batch(self.client, [], self.pagesize, self.startwith,
 classname=self.classname)
 filterspec = self.filterspec
 sort = self.sort
 group = self.group
 )], klass)
 else:
 matches = None
 # filter for visibility
-l = [id for id in klass.filter(matches, filterspec, sort, group)
+allowed = [id for id in klass.filter(matches, filterspec, sort, group)
 if check(permission, userid, self.classname, itemid=id)]
 # return the batch object, using IDs only
-return Batch(self.client, l, self.pagesize, self.startwith,
+return Batch(self.client, allowed, self.pagesize, self.startwith,
 classname=self.classname)
 # extend the standard ZTUtils Batch object to remove dependency on
 # Acquisition and add a couple of useful methods
 class Batch(ZTUtils.Batch):
 the batch.
 "sequence_length" is the length of the original, unbatched, sequence.
 """
 def __init__(self, client, sequence, size, start, end=0, orphan=0,
 overlap=0, classname=None):
 self.client = client
 self.last_index = self.last_item = None
 self.current_item = None
 self.classname = classname
 self.sequence_length = len(sequence)
 ZTUtils.Batch.__init__(self, sequence, size, start, end, orphan,
 overlap)
 # overwrite so we can late-instantiate the HTMLItem instance
 def __getitem__(self, index):
 if index < 0:
-if index + self.end < self.first: raise IndexError(index)
+if index + self.end < self.first:
+raise IndexError(index)
 return self._sequence[index + self.end]
 if index >= self.length:
 raise IndexError(index)
 return 1
 for property in properties:
 if property == 'id' or property.endswith('.id')\
 or isinstance(self.last_item[property], list):
 if (str(self.last_item[property]) !=
 str(self.current_item[property])):
 return 1
 else:
 if (self.last_item[property]._value !=
 self.current_item[property]._value):
 return 1
 return 0
 # override these 'cos we don't have access to acquisition
 def previous(self):
 if self.start == 1:
 return None
 return Batch(self.client, self._sequence, self.size,
 self.first - self._size + self.overlap, 0, self.orphan,
 self.overlap)
 def next(self):
 try:
 self._sequence[self.end]
 except IndexError:
 return None
 return Batch(self.client, self._sequence, self.size,
 self.end - self.overlap, 0, self.orphan, self.overlap)
 class TemplatingUtils:
 """ Utilities for templating
 """
 def __init__(self, client):
 self.client = client
 def Batch(self, sequence, size, start, end=0, orphan=0, overlap=0):
 return Batch(self.client, sequence, size, start, end, orphan,
 overlap)
 def anti_csrf_nonce(self, lifetime=None):
 return anti_csrf_nonce(self.client, lifetime=lifetime)
 def timestamp(self):
 res.append('<table class="calendar"><tr><td>')
 res.append(' <table width="100%" class="calendar_nav"><tr>')
 link = "&display=%s" % date_prev_month
 if date_prev_month:
 res.append('  <td><a href="%s&display=%s">&lt;</a></td>'
 % (base_link, date_prev_month))
 else:
 res.append('  <td></td>')
 res.append('  <td>%s</td>' % calendar.month_name[display.month])
 if date_next_month:
 res.append('  <td><a href="%s&display=%s">&gt;</a></td>'
 % (base_link, date_next_month))
 else:
 res.append('  <td></td>')
 # spacer
 res.append('  <td width="100%"></td>')
 # year
 if date_prev_year:
 res.append('  <td><a href="%s&display=%s">&lt;</a></td>'
 % (base_link, date_prev_year))
 else:
 res.append('  <td></td>')
 res.append('  <td>%s</td>' % display.year)
 if date_next_year:
 res.append('  <td><a href="%s&display=%s">&gt;</a></td>'
 % (base_link, date_next_year))
 else:
 res.append('  <td></td>')
 res.append(' </tr></table>')
 res.append(' </td></tr>')

Mercurial > p > roundup > code

comparison roundup/cgi/templating.py @ 7037:22183e7d1443