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

comparison roundup/admin.py @ 5250:ac7fe3483206

Make admin.py 2/3-agnostic.

author	Eric S. Raymond <esr@thyrsus.com>
date	Sat, 26 Aug 2017 00:24:01 -0400
parents	198b6e810c67
children	4cf48ff01e04 bed579f654ee

comparison

equal deleted inserted replaced

-:bc250b4fb4c5
+:ac7fe3483206
 # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 #
 """Administration commands for maintaining Roundup trackers.
 """
+from __future__ import print_function
 __docformat__ = 'restructuredtext'
 import csv, getopt, getpass, os, re, shutil, sys, UserDict, operator
 from roundup import date, hyperdb, roundupdb, init, password, token
 from roundup import __version__ as roundup_version
 import roundup.instance
 from roundup.configuration import CoreConfig, NoConfigError
 from roundup.i18n import _
 from roundup.exceptions import UsageError
+# Polyglot code
+try:
+my_input = raw_input
+except NameError:
+my_input = input
 class CommandDict(UserDict.UserDict):
 """Simple dictionary that lets us do lookups using partial keys.
 Original code submitted by Engelbert Gruber.
 def help_commands(self):
 """List the commands available with their help summary.
 """
 sys.stdout.write( _('Commands: '))
 commands = ['']
-for command in self.commands.itervalues():
+for command in self.commands.values():
 h = _(command.__doc__).split('\n')[0]
 commands.append(' '+h[7:])
 commands.sort()
 commands.append(_(
 """Commands may be abbreviated as long as the abbreviation
 sys.stdout.write('\n'.join(commands) + '\n\n')
 def help_commands_html(self, indent_re=re.compile(r'^(\s+)\S+')):
 """ Produce an HTML command list.
 """
-commands = sorted(self.commands.itervalues(),
+commands = sorted(iter(self.commands.values()),
 operator.attrgetter('__name__'))
 for command in commands:
 h = _(command.__doc__).split('\n')
 name = command.__name__[3:]
 usage = h[0]
-print """
+print("""
 <tr><td valign=top><strong>%(name)s</strong></td>
 <td><tt>%(usage)s</tt><p>
-<pre>""" % locals()
+<pre>""" % locals())
 indent = indent_re.match(h[3])
 if indent: indent = len(indent.group(1))
 for line in h[3:]:
 if indent:
-print line[indent:]
+print(line[indent:])
 else:
-print line
+print(line)
-print '</pre></td></tr>\n'
+print('</pre></td></tr>\n')
 def help_all(self):
-print _("""
+print(_("""
 All commands (except help) require a tracker specifier. This is just
 the path to the roundup tracker you're working with. A roundup tracker
 is where roundup keeps the database and configuration file that defines
 an issue tracker. It may be thought of as the issue tracker's "home
 directory". It may be specified in the environment variable TRACKER_HOME
 "14:25" means <Date yyyy-mm-dd.19:25:00>
 "8:47:11" means <Date yyyy-mm-dd.13:47:11>
 "." means "right now"
 Command help:
-""")
+"""))
-for name, command in self.commands.items():
+for name, command in list(self.commands.items()):
-print _('%s:')%name
+print(_('%s:')%name)
-print '   ', _(command.__doc__)
+print('   ', _(command.__doc__))
 def do_help(self, args, nl_re=re.compile('[\r\n]'),
 indent_re=re.compile(r'^(\s+)\S+')):
 ''"""Usage: help topic
 Give help about topic.
 # try command docstrings
 try:
 l = self.commands.get(topic)
 except KeyError:
-print _('Sorry, no help for "%(topic)s"')%locals()
+print(_('Sorry, no help for "%(topic)s"')%locals())
 return 1
 # display the help for each match, removing the docsring indent
 for name, help in l:
 lines = nl_re.split(_(help.__doc__))
-print lines[0]
+print(lines[0])
 indent = indent_re.match(lines[1])
 if indent: indent = len(indent.group(1))
 for line in lines[1:]:
 if indent:
-print line[indent:]
+print(line[indent:])
 else:
-print line
+print(line)
 return 0
 def listTemplates(self):
 """ List all the available templates.
 return templates
 def help_initopts(self):
 templates = self.listTemplates()
-print _('Templates:'), ', '.join(templates)
+print(_('Templates:'), ', '.join(templates))
 import roundup.backends
 backends = roundup.backends.list_backends()
-print _('Back ends:'), ', '.join(backends)
+print(_('Back ends:'), ', '.join(backends))
 def do_install(self, tracker_home, args):
 ''"""Usage: install [template [backend [key=val[,key=val]]]]
 Install a new Roundup tracker.
 config_ini_file = os.path.join(tracker_home, CoreConfig.INI_FILE)
 # check for both old- and new-style configs
 if list(filter(os.path.exists, [config_ini_file,
 os.path.join(tracker_home, 'config.py')])):
 if not self.force:
-ok = raw_input(_(
+ok = my_input(_(
 """WARNING: There appears to be a tracker in "%(tracker_home)s"!
 If you re-install it, you will lose all the data!
 Erase it? Y/N: """) % locals())
 if ok.strip().lower() != 'y':
 return 0
 # Process configuration file definitions
 if len(args) > 3:
 try:
 defns = dict([item.split("=") for item in args[3].split(",")])
 except:
-print _('Error in configuration settings: "%s"') % args[3]
+print(_('Error in configuration settings: "%s"') % args[3])
 raise
 else:
 defns = {}
 defns['rdbms_backend'] = backend
 # install!
 init.install(tracker_home, templates[template]['path'], settings=defns)
-print _("""
+print(_("""
 ---------------------------------------------------------------------------
 You should now edit the tracker configuration file:
-%(config_file)s""") % {"config_file": config_ini_file}
+%(config_file)s""") % {"config_file": config_ini_file})
 # find list of options that need manual adjustments
 # XXX config._get_unset_options() is marked as private
 #   (leading underscore).  make it public or don't care?
 need_set = CoreConfig(tracker_home)._get_unset_options()
 if need_set:
-print _(" ... at a minimum, you must set following options:")
+print(_(" ... at a minimum, you must set following options:"))
 for section in need_set:
-print "   [%s]: %s" % (section, ", ".join(need_set[section]))
+print("   [%s]: %s" % (section, ", ".join(need_set[section])))
 # note about schema modifications
-print _("""
+print(_("""
 If you wish to modify the database schema,
 you should also edit the schema file:
 %(database_config_file)s
 You may also change the database initialisation file:
 %(database_init_file)s
 the above steps.
 ---------------------------------------------------------------------------
 """) % {
 'database_config_file': os.path.join(tracker_home, 'schema.py'),
 'database_init_file': os.path.join(tracker_home, 'initial_data.py'),
-}
+})
 return 0
 def _get_choice(self, list_name, prompt, options, argument, default=None):
 if default is None:
 default = options[0]  # just pick the first one
 return argument
 if self.force:
 return default
 sys.stdout.write('%s: %s\n' % (list_name, ', '.join(options)))
 while argument not in options:
-argument = raw_input('%s [%s]: ' % (prompt, default))
+argument = my_input('%s [%s]: ' % (prompt, default))
 if not argument:
 return default
 return argument
 def do_genconfig(self, args, update=False):
 raise UsageError(_('Instance has not been installed')%locals())
 # is there already a database?
 if tracker.exists():
 if not self.force:
-ok = raw_input(_(
+ok = my_input(_(
 """WARNING: The database is already initialised!
 If you re-initialise it, you will lose all the data!
 Erase it? Y/N: """))
 if ok.strip().lower() != 'y':
 return 0
 ' Multilink or Link so -d flag does not '
 'apply.')%propname)
 propclassname = self.db.getclass(property.classname).classname
 id = cl.get(nodeid, propname)
 for i in id:
-print propclassname + i
+print(propclassname + i)
 else:
-print cl.get(nodeid, propname)
+print(cl.get(nodeid, propname))
 except IndexError:
 raise UsageError(_('no such %(classname)s node '
 '"%(nodeid)s"')%locals())
 except KeyError:
 raise UsageError(_('no such %(classname)s property '
 '"%(propname)s"')%locals())
 if self.separator:
-print self.separator.join(l)
+print(self.separator.join(l))
 return 0
 def do_set(self, args):
 # now do the set for all the nodes
 for classname, itemid in designators:
 props = copy.copy(propset) # make a new copy for every designator
 cl = self.get_class(classname)
-for key, value in props.items():
+for key, value in list(props.items()):
 try:
 # You must reinitialize the props every time though.
 # if props['nosy'] = '+admin' initally, it gets
 # set to 'demo,admin' (assuming it was set to demo
 # in the db) after rawToHyperdb returns.
 # handle the propname=value argument
 props = self.props_from_args(args[1:])
 # convert the user-input value to a value used for find()
-for propname, value in props.iteritems():
+for propname, value in props.items():
 if ',' in value:
 values = value.split(',')
 else:
 values = [value]
 d = props[propname] = {}
 if self.separator:
 if self.print_designator:
 id = cl.find(**props)
 for i in id:
 designator.append(classname + i)
-print self.separator.join(designator)
+print(self.separator.join(designator))
 else:
-print self.separator.join(cl.find(**props))
+print(self.separator.join(cl.find(**props)))
 else:
 if self.print_designator:
 id = cl.find(**props)
 for i in id:
 designator.append(classname + i)
-print designator
+print(designator)
 else:
-print cl.find(**props)
+print(cl.find(**props))
 except KeyError:
 raise UsageError(_('%(classname)s has no property '
 '"%(propname)s"')%locals())
 except (ValueError, TypeError) as message:
 raise UsageError(message)
 # display the values
 keys = sorted(cl.properties)
 for key in keys:
 value = cl.get(nodeid, key)
-print _('%(key)s: %(value)s')%locals()
+print(_('%(key)s: %(value)s')%locals())
 def do_create(self, args):
 ''"""Usage: create classname property=value ...
 Create a new entry of a given class.
 while value != again:
 value = getpass.getpass(_('%(propname)s (Password): ')%{
 'propname': key.capitalize()})
 again = getpass.getpass(_('   %(propname)s (Again): ')%{
 'propname': key.capitalize()})
-if value != again: print _('Sorry, try again...')
+if value != again: print(_('Sorry, try again...'))
 if value:
 props[key] = value
 else:
-value = raw_input(_('%(propname)s (%(proptype)s): ')%{
+value = my_input(_('%(propname)s (%(proptype)s): ')%{
 'propname': key.capitalize(), 'proptype': name})
 if value:
 props[key] = value
 else:
 props = self.props_from_args(args[1:])
 try:
 proplist.append(cl.get(nodeid, propname))
 except KeyError:
 raise UsageError(_('%(classname)s has no property '
 '"%(propname)s"')%locals())
-print self.separator.join(proplist)
+print(self.separator.join(proplist))
 else:
 # create a list of index id's since user didn't specify
 # otherwise
-print self.separator.join(cl.list())
+print(self.separator.join(cl.list()))
 else:
 for nodeid in cl.list():
 try:
 value = cl.get(nodeid, propname)
 except KeyError:
 raise UsageError(_('%(classname)s has no property '
 '"%(propname)s"')%locals())
-print _('%(nodeid)4s: %(value)s')%locals()
+print(_('%(nodeid)4s: %(value)s')%locals())
 return 0
 def do_table(self, args):
 ''"""Usage: table classname [property[,property]*]
 List the instances of a class in tabular form.
 if curlen > maxlen:
 maxlen = curlen
 props.append((spec, maxlen))
 # now display the heading
-print ' '.join([name.capitalize().ljust(width) for name,width in props])
+print(' '.join([name.capitalize().ljust(width) for name,width in props]))
 # and the table data
 for nodeid in cl.list():
 l = []
 for name, width in props:
 value = ''
 else:
 value = str(nodeid)
 f = '%%-%ds'%width
 l.append(f%value[:width])
-print ' '.join(l)
+print(' '.join(l))
 return 0
 def do_history(self, args):
 ''"""Usage: history designator [skipquiet]
 Show the history entries of a designator.
 if args[1] != 'skipquiet':
 raise UsageError("Second argument is not skipquiet")
 skipquiet = True
 try:
-print self.db.getclass(classname).history(nodeid,
+print(self.db.getclass(classname).history(nodeid,
-skipquiet=skipquiet)
+skipquiet=skipquiet))
 except KeyError:
 raise UsageError(_('no such class "%(classname)s"')%locals())
 except IndexError:
 raise UsageError(_('no such %(classname)s node '
 '"%(nodeid)s"')%locals())
 journals = csv.writer(jf, colon_separated)
 for row in cl.export_journals():
 journals.writerow(row)
 jf.close()
 if max_len > self.db.config.CSV_FIELD_SIZE:
-print >> sys.stderr, \
+print("Warning: config csv_field_size should be at least %s"%max_len, file=sys.stderr)
-"Warning: config csv_field_size should be at least %s"%max_len
 return 0
 def do_exporttables(self, args):
 ''"""Usage: exporttables [[-]class[,class]] export_dir
 Export the database to colon-separated-value files, excluding the
 if hasattr(cl, 'import_files'):
 cl.import_files(dir, nodeid)
 maxid = max(maxid, int(nodeid))
 # (print to sys.stdout here to allow tests to squash it .. ugh)
-print >> sys.stdout
+print(file=sys.stdout)
 f.close()
 # import the journals
 f = open(os.path.join(args[0], classname + '-journals.csv'), 'r')
 reader = csv.reader(f, colon_separated)
 cl.import_journals(reader)
 f.close()
 # (print to sys.stdout here to allow tests to squash it .. ugh)
-print >> sys.stdout, 'setting', classname, maxid+1
+print('setting', classname, maxid+1, file=sys.stdout)
 # set the id counter
 self.db.setid(classname, str(maxid+1))
 self.db_uncommitted = True
 It's safe to run this even if it's not required, so just get into
 the habit.
 """
 if getattr(self.db, 'db_version_updated'):
-print _('Tracker updated')
+print(_('Tracker updated'))
 self.db_uncommitted = True
 else:
-print _('No migration action required')
+print(_('No migration action required'))
 return 0
 def run_command(self, args):
 """Run a single command
 """
 # figure what the command is
 try:
 functions = self.commands.get(command)
 except KeyError:
 # not a valid command
-print _('Unknown command "%(command)s" ("help commands" for a '
+print(_('Unknown command "%(command)s" ("help commands" for a '
-'list)')%locals()
+'list)')%locals())
 return 1
 # check for multiple matches
 if len(functions) > 1:
-print _('Multiple commands match "%(command)s": %(list)s')%{'command':
+print(_('Multiple commands match "%(command)s": %(list)s')%{'command':
-command, 'list': ', '.join([i[0] for i in functions])}
+command, 'list': ', '.join([i[0] for i in functions])})
 return 1
 command, function = functions[0]
 # make sure we have a tracker_home
 while not self.tracker_home:
 if not self.force:
-self.tracker_home = raw_input(_('Enter tracker home: ')).strip()
+self.tracker_home = my_input(_('Enter tracker home: ')).strip()
 else:
 self.tracker_home = os.curdir
 # before we open the db, we may be doing an install or init
 if command == 'initialise':
 try:
 return self.do_initialise(self.tracker_home, args)
 except UsageError as message:
-print _('Error: %(message)s')%locals()
+print(_('Error: %(message)s')%locals())
 return 1
 elif command == 'install':
 try:
 return self.do_install(self.tracker_home, args)
 except UsageError as message:
-print _('Error: %(message)s')%locals()
+print(_('Error: %(message)s')%locals())
 return 1
 # get the tracker
 try:
 tracker = roundup.instance.open(self.tracker_home)
 except ValueError as message:
 self.tracker_home = ''
-print _("Error: Couldn't open tracker: %(message)s")%locals()
+print(_("Error: Couldn't open tracker: %(message)s")%locals())
 return 1
 except NoConfigError as message:
 self.tracker_home = ''
-print _("Error: Couldn't open tracker: %(message)s")%locals()
+print(_("Error: Couldn't open tracker: %(message)s")%locals())
 return 1
 # only open the database once!
 if not self.db:
 self.db = tracker.open('admin')
 # do the command
 ret = 0
 try:
 ret = function(args[1:])
 except UsageError as message:
-print _('Error: %(message)s')%locals()
+print(_('Error: %(message)s')%locals())
-print
+print()
-print function.__doc__
+print(function.__doc__)
 ret = 1
 except:
 import traceback
 traceback.print_exc()
 ret = 1
 return ret
 def interactive(self):
 """Run in an interactive mode
 """
-print _('Roundup %s ready for input.\nType "help" for help.'
+print(_('Roundup %s ready for input.\nType "help" for help.'
-% roundup_version)
+% roundup_version))
 try:
 import readline
 except ImportError:
-print _('Note: command history and editing not available')
+print(_('Note: command history and editing not available'))
 while 1:
 try:
-command = raw_input(_('roundup> '))
+command = my_input(_('roundup> '))
 except EOFError:
-print _('exit...')
+print(_('exit...'))
 break
 if not command: continue
 try:
 args = token.token_split(command)
 except ValueError:
 if args[0] in ('quit', 'exit'): break
 self.run_command(args)
 # exit.. check for transactions
 if self.db and self.db_uncommitted:
-commit = raw_input(_('There are unsaved changes. Commit them (y/N)? '))
+commit = my_input(_('There are unsaved changes. Commit them (y/N)? '))
 if commit and commit[0].lower() == 'y':
 self.db.commit()
 return 0
 def main(self):
 for opt, arg in opts:
 if opt == '-h':
 self.usage()
 return 0
 elif opt == '-v':
-print '%s (python %s)'%(roundup_version, sys.version.split()[0])
+print('%s (python %s)'%(roundup_version, sys.version.split()[0]))
 return 0
 elif opt == '-V':
 self.verbose = 1
 elif opt == '-i':
 self.tracker_home = arg

Mercurial > p > roundup > code

comparison roundup/admin.py @ 5250:ac7fe3483206