pylint: upgrade to 1.3.1

third_party/logilab/common/optik_ext.py

 # copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of logilab-common.
 #
 # logilab-common is free software: you can redistribute it and/or modify it under
 # the terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 2.1 of the License, or (at your option) any
 # later version.
 #
@@ skipping 28 matching lines @@
   * color
     argument of this type wont be converted but checked its either a
     named color or a color specified using hexadecimal notation (preceded by a #)
   * time
     argument of this type will be converted to a float value in seconds
     according to time units (ms, s, min, h, d)
   * bytes
     argument of this type will be converted to a float value in bytes
     according to byte units (b, kb, mb, gb, tb)
 """
+from __future__ import print_function
+
 __docformat__ = "restructuredtext en"
 
 import re
 import sys
 import time
 from copy import copy
 from os.path import exists
 
 # python >= 2.3
 from optparse import OptionParser as BaseParser, Option as BaseOption, \
      OptionGroup, OptionContainer, OptionValueError, OptionError, \
      Values, HelpFormatter, NO_DEFAULT, SUPPRESS_HELP
 
 try:
     from mx import DateTime
     HAS_MX_DATETIME = True
 except ImportError:
     HAS_MX_DATETIME = False
 
+from logilab.common.textutils import splitstrip, TIME_UNITS, BYTE_UNITS, \
+    apply_units
 
-OPTPARSE_FORMAT_DEFAULT = sys.version_info >= (2, 4)
-
-from logilab.common.textutils import splitstrip
 
 def check_regexp(option, opt, value):
     """check a regexp value by trying to compile it
     return the compiled regexp
     """
     if hasattr(value, 'pattern'):
         return value
     try:
         return re.compile(value)
     except ValueError:
@@ skipping 79 matching lines @@
         return value
     # Case (2) : only accepts hexadecimal forms
     if re.match('#[a-f0-9]{6}', value, re.I):
         return value
     # Else : not a color label neither a valid hexadecimal form => error
     msg = "option %s: invalid color : %r, should be either hexadecimal \
     value or predefined color"
     raise OptionValueError(msg % (opt, value))
 
 def check_time(option, opt, value):
-    from logilab.common.textutils import TIME_UNITS, apply_units
     if isinstance(value, (int, long, float)):
         return value
     return apply_units(value, TIME_UNITS)
 
 def check_bytes(option, opt, value):
-    from logilab.common.textutils import BYTE_UNITS, apply_units
     if hasattr(value, '__int__'):
         return value
     return apply_units(value, BYTE_UNITS)
 
-import types
 
 class Option(BaseOption):
     """override optik.Option to add some new option types
     """
     TYPES = BaseOption.TYPES + ('regexp', 'csv', 'yn', 'named', 'password',
                                 'multiple_choice', 'file', 'color',
                                 'time', 'bytes')
     ATTRS = BaseOption.ATTRS + ['hide', 'level']
     TYPE_CHECKER = copy(BaseOption.TYPE_CHECKER)
     TYPE_CHECKER['regexp'] = check_regexp
@@ skipping 14 matching lines @@
         BaseOption.__init__(self, *opts, **attrs)
         if hasattr(self, "hide") and self.hide:
             self.help = SUPPRESS_HELP
 
     def _check_choice(self):
         """FIXME: need to override this due to optik misdesign"""
         if self.type in ("choice", "multiple_choice"):
             if self.choices is None:
                 raise OptionError(
                     "must supply a list of choices for type 'choice'", self)
-            elif type(self.choices) not in (types.TupleType, types.ListType):
+            elif not isinstance(self.choices, (tuple, list)):
                 raise OptionError(
                     "choices must be a list of strings ('%s' supplied)"
                     % str(type(self.choices)).split("'")[1], self)
         elif self.choices is not None:
             raise OptionError(
                 "must not supply choices for type %r" % self.type, self)
     BaseOption.CHECK_METHODS[2] = _check_choice
 
 
     def process(self, opt, value, values, parser):
         # First, convert the value(s) to the right type.  Howl if any
         # value(s) are bogus.
-        try:
-            value = self.convert_value(opt, value)
-        except AttributeError: # py < 2.4
-            value = self.check_value(opt, value)
+        value = self.convert_value(opt, value)
         if self.type == 'named':
             existant = getattr(values, self.dest)
             if existant:
                 existant.update(value)
                 value = existant
        # And then take whatever action is expected of us.
         # This is a separate method to make life easier for
         # subclasses to add new actions.
         return self.take_action(
             self.action, self.dest, opt, value, values, parser)
@@ skipping 137 matching lines @@
 %s
 ''' % pkginfo.copyright
 
         return tail
 
 def generate_manpage(optparser, pkginfo, section=1, stream=sys.stdout, level=0):
     """generate a man page from an optik parser"""
     formatter = ManHelpFormatter()
     formatter.output_level = level
     formatter.parser = optparser
-    print >> stream, formatter.format_head(optparser, pkginfo, section)
-    print >> stream, optparser.format_option_help(formatter)
-    print >> stream, formatter.format_tail(pkginfo)
+    print(formatter.format_head(optparser, pkginfo, section), file=stream)
+    print(optparser.format_option_help(formatter), file=stream)
+    print(formatter.format_tail(pkginfo), file=stream)
 
 
 __all__ = ('OptionParser', 'Option', 'OptionGroup', 'OptionValueError',
            'Values')