pylint: upgrade to 1.3.1

third_party/logilab/common/clcommands.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.
 #
 # logilab-common is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 # details.
 #
 # You should have received a copy of the GNU Lesser General Public License along
 # with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
 """Helper functions to support command line tools providing more than
 one command.
 
 e.g called as "tool command [options] args..." where <options> and <args> are
 command'specific
 """
 
+from __future__ import print_function
+
 __docformat__ = "restructuredtext en"
 
 import sys
 import logging
 from os.path import basename
 
 from logilab.common.configuration import Configuration
 from logilab.common.logging_ext import init_log, get_threshold
 from logilab.common.deprecation import deprecated
 
@@ skipping 73 matching lines @@
         init_log(debug=True, # so that we use StreamHandler
                  logthreshold=self.logthreshold,
                  logformat='%(levelname)s: %(message)s')
         try:
             arg = args.pop(0)
         except IndexError:
             self.usage_and_exit(1)
         if arg in ('-h', '--help'):
             self.usage_and_exit(0)
         if self.version is not None and arg in ('--version'):
-            print self.version
+            print(self.version)
             sys.exit(0)
         rcfile = self.rcfile
         if rcfile is not None and arg in ('-C', '--rc-file'):
             try:
                 rcfile = args.pop(0)
                 arg = args.pop(0)
             except IndexError:
                 self.usage_and_exit(1)
         try:
             command = self.get_command(arg)
         except KeyError:
-            print 'ERROR: no %s command' % arg
-            print
+            print('ERROR: no %s command' % arg)
+            print()
             self.usage_and_exit(1)
         try:
             sys.exit(command.main_run(args, rcfile))
-        except KeyboardInterrupt, exc:
-            print 'Interrupted',
+        except KeyboardInterrupt as exc:
+            print('Interrupted', end=' ')
             if str(exc):
-                print ': %s' % exc,
-            print
+                print(': %s' % exc, end=' ')
+            print()
             sys.exit(4)
-        except BadCommandUsage, err:
-            print 'ERROR:', err
-            print
-            print command.help()
+        except BadCommandUsage as err:
+            print('ERROR:', err)
+            print()
+            print(command.help())
             sys.exit(1)
 
     def create_logger(self, handler, logthreshold=None):
         logger = logging.Logger(self.pgm)
         logger.handlers = [handler]
         if logthreshold is None:
             logthreshold = get_threshold(self.logthreshold)
         logger.setLevel(logthreshold)
         return logger
 
     def get_command(self, cmd, logger=None):
         if logger is None:
             logger = self.logger
         if logger is None:
             logger = self.logger = logging.getLogger(self.pgm)
             logger.setLevel(get_threshold(self.logthreshold))
         return self[cmd](logger)
 
     def usage(self):
         """display usage for the main program (i.e. when no command supplied)
         and exit
         """
-        print 'usage:', self.pgm,
+        print('usage:', self.pgm, end=' ')
         if self.rcfile:
-            print '[--rc-file=<configuration file>]',
-        print '<command> [options] <command argument>...'
+            print('[--rc-file=<configuration file>]', end=' ')
+        print('<command> [options] <command argument>...')
         if self.doc:
-            print '\n%s' % self.doc
-        print  '''
+            print('\n%s' % self.doc)
+        print('''
 Type "%(pgm)s <command> --help" for more information about a specific
-command. Available commands are :\n''' % self.__dict__
+command. Available commands are :\n''' % self.__dict__)
         max_len = max([len(cmd) for cmd in self])
         padding = ' ' * max_len
         for cmdname, cmd in sorted(self.items()):
             if not cmd.hidden:
-                print ' ', (cmdname + padding)[:max_len], cmd.short_description()
+                print(' ', (cmdname + padding)[:max_len], cmd.short_description())
         if self.rcfile:
-            print '''
+            print('''
 Use --rc-file=<configuration file> / -C <configuration file> before the command
 to specify a configuration file. Default to %s.
-''' % self.rcfile
-        print  '''%(pgm)s -h/--help
-      display this usage information and exit''' % self.__dict__
+''' % self.rcfile)
+        print('''%(pgm)s -h/--help
+      display this usage information and exit''' % self.__dict__)
         if self.version:
-            print  '''%(pgm)s -v/--version
-      display version configuration and exit''' % self.__dict__
+            print('''%(pgm)s -v/--version
+      display version configuration and exit''' % self.__dict__)
         if self.copyright:
-            print '\n', self.copyright
+            print('\n', self.copyright)
 
     def usage_and_exit(self, status):
         self.usage()
         sys.exit(status)
 
 
 # base command classes #########################################################
 
 class Command(Configuration):
     """Base class for command line commands.
@@ skipping 51 matching lines @@
 
         Any other exceptions, including :exc:`BadCommandUsage` will be
         propagated.
         """
         if rcfile:
             self.load_file_configuration(rcfile)
         args = self.load_command_line_configuration(args)
         try:
             self.check_args(args)
             self.run(args)
-        except CommandError, err:
+        except CommandError as err:
             self.logger.error(err)
             return 2
         return 0
 
     def run(self, args):
         """run the command with its specific arguments"""
         raise NotImplementedError()
 
 
 class ListCommandsCommand(Command):
     """list available commands, useful for bash completion."""
     name = 'listcommands'
     arguments = '[command]'
     hidden = True
 
     def run(self, args):
         """run the command with its specific arguments"""
         if args:
             command = args.pop()
             cmd = _COMMANDS[command]
             for optname, optdict in cmd.options:
-                print '--help'
-                print '--' + optname
+                print('--help')
+                print('--' + optname)
         else:
             commands = sorted(_COMMANDS.keys())
             for command in commands:
                 cmd = _COMMANDS[command]
                 if not cmd.hidden:
-                    print command
+                    print(command)
 
 
 # deprecated stuff #############################################################
 
 _COMMANDS = CommandLine()
 
 DEFAULT_COPYRIGHT = '''\
 Copyright (c) 2004-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 http://www.logilab.fr/ -- mailto:contact@logilab.fr'''
 
@@ skipping 19 matching lines @@
 def pop_arg(args_list, expected_size_after=None, msg="Missing argument"):
     """helper function to get and check command line arguments"""
     try:
         value = args_list.pop(0)
     except IndexError:
         raise BadCommandUsage(msg)
     if expected_size_after is not None and len(args_list) > expected_size_after:
         raise BadCommandUsage('too many arguments')
     return value