Revert "pylint: upgrade to 1.3.1"

third_party/logilab/common/shellutils.py

-# copyright 2003-2014 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# 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/>.
 """shell/term utilities, useful to write some python scripts instead of shell
 scripts.
 """
-
-from __future__ import print_function
-
 __docformat__ = "restructuredtext en"
 
 import os
 import glob
 import shutil
 import stat
 import sys
 import tempfile
 import time
 import fnmatch
 import errno
 import string
 import random
-import subprocess
 from os.path import exists, isdir, islink, basename, join
 
-from six import string_types
-from six.moves import range, input as raw_input
-
 from logilab.common import STD_BLACKLIST, _handle_blacklist
+from logilab.common.compat import raw_input
 from logilab.common.compat import str_to_bytes
-from logilab.common.deprecation import deprecated
 
 try:
     from logilab.common.proc import ProcInfo, NoSuchProcess
 except ImportError:
     # windows platform
     class NoSuchProcess(Exception): pass
 
     def ProcInfo(pid):
         raise NoSuchProcess()
 
@@ skipping 57 matching lines @@
             _action(filename, join(destination, basename(filename)))
     else:
         try:
             source = sources[0]
         except IndexError:
             raise OSError('No file matching %s' % source)
         if isdir(destination) and exists(destination):
             destination = join(destination, basename(source))
         try:
             _action(source, destination)
-        except OSError as ex:
+        except OSError, ex:
             raise OSError('Unable to move %r to %r (%s)' % (
                 source, destination, ex))
 
 def rm(*files):
     """A shell-like rm, supporting wildcards.
     """
     for wfile in files:
         for filename in glob.glob(wfile):
             if islink(filename):
                 os.remove(filename)
@@ skipping 25 matching lines @@
 
     :type blacklist: list or tuple
     :param blacklist:
       optional list of files or directory to ignore, default to the value of
       `logilab.common.STD_BLACKLIST`
 
     :rtype: list
     :return:
       the list of all matching files
     """
-    if isinstance(exts, string_types):
+    if isinstance(exts, basestring):
         exts = (exts,)
     if exclude:
         def match(filename, exts):
             for ext in exts:
                 if filename.endswith(ext):
                     return False
             return True
     else:
         def match(filename, exts):
             for ext in exts:
@@ skipping 44 matching lines @@
         os.mkdir(destdir)
     zfobj = zipfile.ZipFile(archive)
     for name in zfobj.namelist():
         if name.endswith('/'):
             os.mkdir(join(destdir, name))
         else:
             outfile = open(join(destdir, name), 'wb')
             outfile.write(zfobj.read(name))
             outfile.close()
 
-
 class Execute:
     """This is a deadlock safe version of popen2 (no stdin), that returns
     an object with errorlevel, out and err.
     """
 
     def __init__(self, command):
-        cmd = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        self.out, self.err = cmd.communicate()
-        self.status = os.WEXITSTATUS(cmd.returncode)
-
-Execute = deprecated('Use subprocess.Popen instead')(Execute)
-
+        outfile = tempfile.mktemp()
+        errfile = tempfile.mktemp()
+        self.status = os.system("( %s ) >%s 2>%s" %
+                                (command, outfile, errfile)) >> 8
+        self.out = open(outfile, "r").read()
+        self.err = open(errfile, "r").read()
+        os.remove(outfile)
+        os.remove(errfile)
 
 def acquire_lock(lock_file, max_try=10, delay=10, max_delay=3600):
     """Acquire a lock represented by a file on the file system
 
     If the process written in lock file doesn't exist anymore, we remove the
     lock file immediately
     If age of the lock_file is greater than max_delay, then we raise a UserWarning
     """
     count = abs(max_try)
     while count:
         try:
             fd = os.open(lock_file, os.O_EXCL | os.O_RDWR | os.O_CREAT)
             os.write(fd, str_to_bytes(str(os.getpid())) )
             os.close(fd)
             return True
-        except OSError as e:
+        except OSError, e:
             if e.errno == errno.EEXIST:
                 try:
                     fd = open(lock_file, "r")
                     pid = int(fd.readline())
                     pi = ProcInfo(pid)
                     age = (time.time() - os.stat(lock_file)[stat.ST_MTIME])
                     if age / max_delay > 1 :
                         raise UserWarning("Command '%s' (pid %s) has locked the "
                                           "file '%s' for %s minutes"
                                           % (pi.name(), pid, lock_file, age/60))
@@ skipping 41 matching lines @@
     def _set_text(self, text=None):
         if text != self._current_text:
             self._current_text = text
             self.refresh()
 
     def _del_text(self):
         self.text = None
 
     text = property(_get_text, _set_text, _del_text)
 
-    def update(self, offset=1, exact=False):
-        """Move FORWARD to new cursor position (cursor will never go backward).
-
-        :offset: fraction of ``size``
-
-        :exact:
-
-          - False: offset relative to current cursor position if True
-          - True: offset as an asbsolute position
-
-        """
-        if exact:
-            self._current = offset
-        else:
-            self._current += offset
-
+    def update(self):
+        """Update the progression bar."""
+        self._current += 1
         progress = int((float(self._current)/float(self._total))*self._size)
         if progress > self._progress:
             self._progress = progress
             self.refresh()
 
     def refresh(self):
         """Refresh the progression bar display."""
-        self._stream.write(self._fstr % ('=' * min(self._progress, self._size)) )
+        self._stream.write(self._fstr % ('.' * min(self._progress, self._size)) )
         if self._last_text_write_size or self._current_text:
             template = ' %%-%is' % (self._last_text_write_size)
             text = self._current_text
             if text is None:
                 text = ''
             self._stream.write(template % text)
             self._last_text_write_size = len(text.rstrip())
         self._stream.flush()
 
     def finish(self):
@@ skipping 66 matching lines @@
             if len(possible) == 1:
                 return possible[0]
             elif len(possible) == 0:
                 msg = '%s is not an option.' % answer
             else:
                 msg = ('%s is an ambiguous answer, do you mean %s ?' % (
                         answer, ' or '.join(possible)))
             if self._print:
                 self._print(msg)
             else:
-                print(msg)
+                print msg
             tries -= 1
         raise Exception('unable to get a sensible answer')
 
     def confirm(self, question, default_is_yes=True):
         default = default_is_yes and 'y' or 'n'
         answer = self.ask(question, ('y', 'n'), default)
         return answer == 'y'
 
 ASK = RawInput()
 
 
 def getlogin():
     """avoid using os.getlogin() because of strange tty / stdin problems
     (man 3 getlogin)
     Another solution would be to use $LOGNAME, $USER or $USERNAME
     """
     if sys.platform != 'win32':
         import pwd # Platforms: Unix
         return pwd.getpwuid(os.getuid())[0]
     else:
         return os.environ['USERNAME']
 
 def generate_password(length=8, vocab=string.ascii_letters + string.digits):
     """dumb password generation function"""
     pwd = ''
-    for i in range(length):
+    for i in xrange(length):
         pwd += random.choice(vocab)
     return pwd