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

comparison roundup/admin.py @ 4357:13b3155869e0

Beginnings of a big code cleanup / modernisation to make 2to3 happy

author	Richard Jones <richard@users.sourceforge.net>
date	Mon, 22 Feb 2010 05:26:57 +0000
parents	e16a1131ba67
children	a0be2bc223f5

comparison

equal deleted inserted replaced

-:05a65559d873
+:13b3155869e0
 """Administration commands for maintaining Roundup trackers.
 """
 __docformat__ = 'restructuredtext'
-import csv, getopt, getpass, os, re, shutil, sys, UserDict
+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
 Original code submitted by Engelbert Gruber.
 """
 _marker = []
 def get(self, key, default=_marker):
-if self.data.has_key(key):
+if key in self.data:
 return [(key, self.data[key])]
-keylist = self.data.keys()
+keylist = sorted(self.data)
-keylist.sort()
 l = []
 for ki in keylist:
 if ki.startswith(key):
 l.append((ki, self.data[ki]))
 if not l and default is self._marker:
-raise KeyError, key
+raise KeyError(key)
 return l
 class AdminTool:
 """ A collection of methods used in maintaining Roundup trackers.
 Additional help may be supplied by help_*() methods.
 """
 def __init__(self):
 self.commands = CommandDict()
-for k in AdminTool.__dict__.keys():
+for k in AdminTool.__dict__:
 if k[:3] == 'do_':
 self.commands[k[3:]] = getattr(self, k)
 self.help = {}
-for k in AdminTool.__dict__.keys():
+for k in AdminTool.__dict__:
 if k[:5] == 'help_':
 self.help[k[5:]] = getattr(self, k)
 self.tracker_home = ''
 self.db = None
 self.db_uncommitted = False
 """Get the class - raise an exception if it doesn't exist.
 """
 try:
 return self.db.getclass(classname)
 except KeyError:
-raise UsageError, _('no such class "%(classname)s"')%locals()
+raise UsageError(_('no such class "%(classname)s"')%locals())
 def props_from_args(self, args):
 """ Produce a dictionary of prop: value from the args list.
 The args list is specified as ``prop=value prop=value ...``.
 """
 props = {}
 for arg in args:
 if arg.find('=') == -1:
-raise UsageError, _('argument "%(arg)s" not propname=value'
+raise UsageError(_('argument "%(arg)s" not propname=value'
-)%locals()
+)%locals())
 l = arg.split('=')
 if len(l) < 2:
-raise UsageError, _('argument "%(arg)s" not propname=value'
+raise UsageError(_('argument "%(arg)s" not propname=value'
-)%locals()
+)%locals())
 key, value = l[0], '='.join(l[1:])
 if value:
 props[key] = value
 else:
 props[key] = None
 def help_commands(self):
 """List the commands available with their help summary.
 """
 print _('Commands:'),
 commands = ['']
-for command in self.commands.values():
+for command in self.commands.itervalues():
 h = _(command.__doc__).split('\n')[0]
 commands.append(' '+h[7:])
 commands.sort()
 commands.append(_(
 """Commands may be abbreviated as long as the abbreviation
 print
 def help_commands_html(self, indent_re=re.compile(r'^(\s+)\S+')):
 """ Produce an HTML command list.
 """
-commands = self.commands.values()
+commands = sorted(self.commands.itervalues(),
-def sortfun(a, b):
+operator.attrgetter('__name__'))
-return cmp(a.__name__, b.__name__)
-commands.sort(sortfun)
 for command in commands:
 h = _(command.__doc__).split('\n')
 name = command.__name__[3:]
 usage = h[0]
 print """
 else:
 topic = 'help'
 # try help_ methods
-if self.help.has_key(topic):
+if topic in self.help:
 self.help[topic]()
 return 0
 # try command docstrings
 try:
 return templates
 def help_initopts(self):
 templates = self.listTemplates()
-print _('Templates:'), ', '.join(templates.keys())
+print _('Templates:'), ', '.join(templates)
 import roundup.backends
 backends = roundup.backends.list_backends()
 print _('Back ends:'), ', '.join(backends)
 def do_install(self, tracker_home, args):
 the tracker's dbinit.py module init() function.
 See also initopts help.
 """
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 # make sure the tracker home can be created
 tracker_home = os.path.abspath(tracker_home)
 parent = os.path.split(tracker_home)[0]
 if not os.path.exists(parent):
-raise UsageError, _('Instance home parent directory "%(parent)s"'
+raise UsageError(_('Instance home parent directory "%(parent)s"'
-' does not exist')%locals()
+' does not exist')%locals())
 config_ini_file = os.path.join(tracker_home, CoreConfig.INI_FILE)
 # check for both old- and new-style configs
-if filter(os.path.exists, [config_ini_file,
+if list(filter(os.path.exists, [config_ini_file,
-os.path.join(tracker_home, 'config.py')]):
+os.path.join(tracker_home, 'config.py')])):
 ok = raw_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':
 shutil.rmtree(tracker_home)
 # select template
 templates = self.listTemplates()
 template = len(args) > 1 and args[1] or ''
-if not templates.has_key(template):
+if template not in templates:
-print _('Templates:'), ', '.join(templates.keys())
+print _('Templates:'), ', '.join(templates)
-while not templates.has_key(template):
+while template not in templates:
 template = raw_input(_('Select template [classic]: ')).strip()
 if not template:
 template = 'classic'
 # select hyperdb backend
 # 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:")
-for section, options in need_set.items():
+for section in need_set:
-print "   [%s]: %s" % (section, ", ".join(options))
+print "   [%s]: %s" % (section, ", ".join(need_set[section]))
 # note about schema modifications
 print _("""
 If you wish to modify the database schema,
 you should also edit the schema file:
 ''"""Usage: genconfig <filename>
 Generate a new tracker config file (ini style) with default values
 in <filename>.
 """
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 config = CoreConfig()
 config.save(args[0])
 def do_initialise(self, tracker_home, args):
 ''"""Usage: initialise [adminpw]
 adminpw = getpass.getpass(_('Admin Password: '))
 confirm = getpass.getpass(_('       Confirm: '))
 # make sure the tracker home is installed
 if not os.path.exists(tracker_home):
-raise UsageError, _('Instance home does not exist')%locals()
+raise UsageError(_('Instance home does not exist')%locals())
 try:
 tracker = roundup.instance.open(tracker_home)
 except roundup.instance.TrackerError:
-raise UsageError, _('Instance has not been installed')%locals()
+raise UsageError(_('Instance has not been installed')%locals())
 # is there already a database?
 if tracker.exists():
 ok = raw_input(_(
 """WARNING: The database is already initialised!
 Retrieves the property value of the nodes specified
 by the designators.
 """
 if len(args) < 2:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 propname = args[0]
 designators = args[1].split(',')
 l = []
 for designator in designators:
 # decode the node designator
 try:
 classname, nodeid = hyperdb.splitDesignator(designator)
 except hyperdb.DesignatorError, message:
-raise UsageError, message
+raise UsageError(message)
 # get the class
 cl = self.get_class(classname)
 try:
 id=[]
 # print
 properties = cl.getprops()
 property = properties[propname]
 if not (isinstance(property, hyperdb.Multilink) or
 isinstance(property, hyperdb.Link)):
-raise UsageError, _('property %s is not of type Multilink or Link so -d flag does not apply.')%propname
+raise UsageError(_('property %s is not of type'
+' 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:
 l.append(propclassname + i)
 else:
 if self.print_designator:
 properties = cl.getprops()
 property = properties[propname]
 if not (isinstance(property, hyperdb.Multilink) or
 isinstance(property, hyperdb.Link)):
-raise UsageError, _('property %s is not of type Multilink or Link so -d flag does not apply.')%propname
+raise UsageError(_('property %s is not of type'
+' 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
 else:
 print cl.get(nodeid, propname)
 except IndexError:
-raise UsageError, _('no such %(classname)s node "%(nodeid)s"')%locals()
+raise UsageError(_('no such %(classname)s node '
+'"%(nodeid)s"')%locals())
 except KeyError:
-raise UsageError, _('no such %(classname)s property '
+raise UsageError(_('no such %(classname)s property '
-'"%(propname)s"')%locals()
+'"%(propname)s"')%locals())
 if self.separator:
 print self.separator.join(l)
 return 0
 given. If the value is missing (ie. "property=") then the property
 is un-set. If the property is a multilink, you specify the linked
 ids for the multilink as comma-separated numbers (ie "1,2,3").
 """
 if len(args) < 2:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 from roundup import hyperdb
 designators = args[0].split(',')
 if len(designators) == 1:
 designator = designators[0]
 designators = [(designator, x) for x in cl.list()]
 else:
 try:
 designators = [hyperdb.splitDesignator(x) for x in designators]
 except hyperdb.DesignatorError, message:
-raise UsageError, message
+raise UsageError(message)
 # get the props from the args
 props = self.props_from_args(args[1:])
 # now do the set for all the nodes
 for key, value in props.items():
 try:
 props[key] = hyperdb.rawToHyperdb(self.db, cl, itemid,
 key, value)
 except hyperdb.HyperdbValueError, message:
-raise UsageError, message
+raise UsageError(message)
 # try the set
 try:
-apply(cl.set, (itemid, ), props)
+cl.set(itemid, **props)
 except (TypeError, IndexError, ValueError), message:
 import traceback; traceback.print_exc()
-raise UsageError, message
+raise UsageError(message)
 self.db_uncommitted = True
 return 0
 def do_find(self, args):
 ''"""Usage: find classname propname=value ...
 Find the nodes of the given class with a given link property value.
 The value may be either the nodeid of the linked node, or its key
 value.
 """
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 classname = args[0]
 # get the class
 cl = self.get_class(classname)
 # 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.items():
+for propname, value in props.iteritems():
 if ',' in value:
 values = value.split(',')
 else:
 values = [value]
 d = props[propname] = {}
 try:
 id = []
 designator = []
 if self.separator:
 if self.print_designator:
-id=apply(cl.find, (), props)
+id = cl.find(**props)
 for i in id:
 designator.append(classname + i)
 print self.separator.join(designator)
 else:
-print self.separator.join(apply(cl.find, (), props))
+print self.separator.join(cl.find(**props))
 else:
 if self.print_designator:
-id=apply(cl.find, (), props)
+id = cl.find(**props)
 for i in id:
 designator.append(classname + i)
 print designator
 else:
-print apply(cl.find, (), props)
+print cl.find(**props)
 except KeyError:
-raise UsageError, _('%(classname)s has no property '
+raise UsageError(_('%(classname)s has no property '
-'"%(propname)s"')%locals()
+'"%(propname)s"')%locals())
 except (ValueError, TypeError), message:
-raise UsageError, message
+raise UsageError(message)
 return 0
 def do_specification(self, args):
 ''"""Usage: specification classname
 Show the properties for a classname.
 This lists the properties for a given class.
 """
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 classname = args[0]
 # get the class
 cl = self.get_class(classname)
 # get the key property
 keyprop = cl.getkey()
-for key, value in cl.properties.items():
+for key in cl.properties:
+value = cl.properties[key]
 if keyprop == key:
 print _('%(key)s: %(value)s (key property)')%locals()
 else:
 print _('%(key)s: %(value)s')%locals()
 This lists the properties and their associated values for the given
 node.
 """
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 # decode the node designator
 for designator in args[0].split(','):
 try:
 classname, nodeid = hyperdb.splitDesignator(designator)
 except hyperdb.DesignatorError, message:
-raise UsageError, message
+raise UsageError(message)
 # get the class
 cl = self.get_class(classname)
 # display the values
-keys = cl.properties.keys()
+keys = sorted(cl.properties)
-keys.sort()
 for key in keys:
 value = cl.get(nodeid, key)
 print _('%(key)s: %(value)s')%locals()
 def do_create(self, args):
 This creates a new entry of the given class using the property
 name=value arguments provided on the command line after the "create"
 command.
 """
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 from roundup import hyperdb
 classname = args[0]
 # get the class
 # now do a create
 props = {}
 properties = cl.getprops(protected = 0)
 if len(args) == 1:
 # ask for the properties
-for key, value in properties.items():
+for key in properties:
 if key == 'id': continue
+value = properties[key]
 name = value.__class__.__name__
 if isinstance(value , hyperdb.Password):
 again = None
 while value != again:
 value = getpass.getpass(_('%(propname)s (Password): ')%{
 props[key] = value
 else:
 props = self.props_from_args(args[1:])
 # convert types
-for propname, value in props.items():
+for propname in props:
 try:
 props[propname] = hyperdb.rawToHyperdb(self.db, cl, None,
-propname, value)
+propname, props[propname])
 except hyperdb.HyperdbValueError, message:
-raise UsageError, message
+raise UsageError(message)
 # check for the key property
 propname = cl.getkey()
-if propname and not props.has_key(propname):
+if propname and propname not in props:
-raise UsageError, _('you must provide the "%(propname)s" '
+raise UsageError(_('you must provide the "%(propname)s" '
-'property.')%locals()
+'property.')%locals())
 # do the actual create
 try:
-print apply(cl.create, (), props)
+print cl.create(**props)
 except (TypeError, IndexError, ValueError), message:
-raise UsageError, message
+raise UsageError(message)
 self.db_uncommitted = True
 return 0
 def do_list(self, args):
 ''"""Usage: list classname [property]
 With -c, -S or -s print a list of item id's if no property
 specified.  If property specified, print list of that property
 for every class instance.
 """
 if len(args) > 2:
-raise UsageError, _('Too many arguments supplied')
+raise UsageError(_('Too many arguments supplied'))
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 classname = args[0]
 # get the class
 cl = self.get_class(classname)
 proplist=[]
 for nodeid in cl.list():
 try:
 proplist.append(cl.get(nodeid, propname))
 except KeyError:
-raise UsageError, _('%(classname)s has no property '
+raise UsageError(_('%(classname)s has no property '
-'"%(propname)s"')%locals()
+'"%(propname)s"')%locals())
 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())
 else:
 for nodeid in cl.list():
 try:
 value = cl.get(nodeid, propname)
 except KeyError:
-raise UsageError, _('%(classname)s has no property '
+raise UsageError(_('%(classname)s has no property '
-'"%(propname)s"')%locals()
+'"%(propname)s"')%locals())
 print _('%(nodeid)4s: %(value)s')%locals()
 return 0
 def do_table(self, args):
 ''"""Usage: table classname [property[,property]*]
 4  feat
 will result in a the 4 character wide "Name" column.
 """
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 classname = args[0]
 # get the class
 cl = self.get_class(classname)
 for spec in prop_names:
 if ':' in spec:
 try:
 propname, width = spec.split(':')
 except (ValueError, TypeError):
-raise UsageError, _('"%(spec)s" not name:width')%locals()
+raise UsageError(_('"%(spec)s" not '
+'name:width')%locals())
 else:
 propname = spec
-if not all_props.has_key(propname):
+if propname not in all_props:
-raise UsageError, _('%(classname)s has no property '
+raise UsageError(_('%(classname)s has no property '
-'"%(propname)s"')%locals()
+'"%(propname)s"')%locals())
 else:
-prop_names = cl.getprops().keys()
+prop_names = cl.getprops()
 # now figure column widths
 props = []
 for spec in prop_names:
 if ':' in spec:
 eg. bug1, user10, ...
 Lists the journal entries for the node identified by the designator.
 """
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 try:
 classname, nodeid = hyperdb.splitDesignator(args[0])
 except hyperdb.DesignatorError, message:
-raise UsageError, message
+raise UsageError(message)
 try:
 print self.db.getclass(classname).history(nodeid)
 except KeyError:
-raise UsageError, _('no such class "%(classname)s"')%locals()
+raise UsageError(_('no such class "%(classname)s"')%locals())
 except IndexError:
-raise UsageError, _('no such %(classname)s node "%(nodeid)s"')%locals()
+raise UsageError(_('no such %(classname)s node '
+'"%(nodeid)s"')%locals())
 return 0
 def do_commit(self, args):
 ''"""Usage: commit
 Commit changes made to the database during an interactive session.
 This action indicates that a particular node is not to be retrieved
 by the list or find commands, and its key value may be re-used.
 """
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 designators = args[0].split(',')
 for designator in designators:
 try:
 classname, nodeid = hyperdb.splitDesignator(designator)
 except hyperdb.DesignatorError, message:
-raise UsageError, message
+raise UsageError(message)
 try:
 self.db.getclass(classname).retire(nodeid)
 except KeyError:
-raise UsageError, _('no such class "%(classname)s"')%locals()
+raise UsageError(_('no such class "%(classname)s"')%locals())
 except IndexError:
-raise UsageError, _('no such %(classname)s node "%(nodeid)s"')%locals()
+raise UsageError(_('no such %(classname)s node '
+'"%(nodeid)s"')%locals())
 self.db_uncommitted = True
 return 0
 def do_restore(self, args):
 ''"""Usage: restore designator[,designator]*
 eg. bug1, user10, ...
 The given nodes will become available for users again.
 """
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 designators = args[0].split(',')
 for designator in designators:
 try:
 classname, nodeid = hyperdb.splitDesignator(designator)
 except hyperdb.DesignatorError, message:
-raise UsageError, message
+raise UsageError(message)
 try:
 self.db.getclass(classname).restore(nodeid)
 except KeyError:
-raise UsageError, _('no such class "%(classname)s"')%locals()
+raise UsageError(_('no such class "%(classname)s"')%locals())
 except IndexError:
-raise UsageError, _('no such %(classname)s node "%(nodeid)s"')%locals()
+raise UsageError(_('no such %(classname)s node '
+'"%(nodeid)s"')%locals())
 self.db_uncommitted = True
 return 0
 def do_export(self, args, export_files=True):
 ''"""Usage: export [[-]class[,class]] export_dir
 colon-separated-value files that are placed in the nominated
 destination directory.
 """
 # grab the directory to export to
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 dir = args[-1]
 # get the list of classes to export
 if len(args) == 2:
 if args[0].startswith('-'):
-classes = [ c for c in self.db.classes.keys()
+classes = [ c for c in self.db.classes
 if not c in args[0][1:].split(',') ]
 else:
 classes = args[0].split(',')
 else:
-classes = self.db.classes.keys()
+classes = self.db.classes
 class colon_separated(csv.excel):
 delimiter = ':'
 # make sure target dir exists
 jf = open(os.path.join(dir, classname+'-journals.csv'), 'wb')
 if self.verbose:
 sys.stdout.write("\nExporting Journal for %s\n" % classname)
 sys.stdout.flush()
 journals = csv.writer(jf, colon_separated)
-map(journals.writerow, cl.export_journals())
+for row in cl.export_journals():
+journals.writerow(row)
 jf.close()
 if max_len > self.db.config.CSV_FIELD_SIZE:
 print >> sys.stderr, \
 "Warning: config csv_field_size should be at least %s"%max_len
 return 0
 The new nodes are added to the existing database - if you want to
 create a new database using the imported data, then create a new
 database (or, tediously, retire all the old data.)
 """
 if len(args) < 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 from roundup import hyperdb
 if hasattr (csv, 'field_size_limit'):
 csv.field_size_limit(self.db.config.CSV_FIELD_SIZE)
 # do the import and figure the current highest nodeid
 nodeid = cl.import_list(file_props, r)
 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
 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
 # set the id counter
-print >> sys.stdout, 'setting', classname, maxid+1
 self.db.setid(classname, str(maxid+1))
 self.db_uncommitted = True
 return 0
 Date format is "YYYY-MM-DD" eg:
 2001-01-01
 """
-if len(args) <> 1:
+if len(args) != 1:
-raise UsageError, _('Not enough arguments supplied')
+raise UsageError(_('Not enough arguments supplied'))
 # are we dealing with a period or a date
 value = args[0]
 date_re = re.compile(r"""
 (?P<date>\d\d\d\d-\d\d?-\d\d?)? # yyyy-mm-dd
 (?P<period>(\d+y\s*)?(\d+m\s*)?(\d+d\s*)?)?
 """, re.VERBOSE)
 m = date_re.match(value)
 if not m:
-raise ValueError, _('Invalid format')
+raise ValueError(_('Invalid format'))
 m = m.groupdict()
 if m['period']:
 pack_before = date.Date(". - %s"%value)
 elif m['date']:
 pack_before = date.Date(value)
 if m:
 cl = self.get_class(m.group(1))
 try:
 cl.index(m.group(2))
 except IndexError:
-raise UsageError, _('no such item "%(designator)s"')%{
+raise UsageError(_('no such item "%(designator)s"')%{
-'designator': arg}
+'designator': arg})
 else:
 cl = self.get_class(arg)
 self.db.reindex(arg)
 else:
 self.db.reindex(show_progress=True)
 roles = [(args[0], self.db.security.role[args[0]])]
 except KeyError:
 print _('No such Role "%(role)s"')%locals()
 return 1
 else:
-roles = self.db.security.role.items()
+roles = list(self.db.security.role.items())
 role = self.db.config.NEW_WEB_USER_ROLES
 if ',' in role:
 print _('New Web users get the Roles "%(role)s"')%locals()
 else:
 print _('New Web users get the Role "%(role)s"')%locals()
 # handle command-line args
 self.tracker_home = os.environ.get('TRACKER_HOME', '')
 # TODO: reinstate the user/password stuff (-u arg too)
 name = password = ''
-if os.environ.has_key('ROUNDUP_LOGIN'):
+if 'ROUNDUP_LOGIN' in os.environ:
 l = os.environ['ROUNDUP_LOGIN'].split(':')
 name = l[0]
 if len(l) > 1:
 password = l[1]
 self.separator = None

Mercurial > p > roundup > code

comparison roundup/admin.py @ 4357:13b3155869e0