bee_python 0.0.1

data/tools/common/common/cli.py

@@ -0,0 +1,212 @@
+# copyright 2003-2010 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/>.
+"""Command line interface helper classes.
+
+It provides some default commands, a help system, a default readline
+configuration with completion and persistent history.
+
+Example::
+
+    class BookShell(CLIHelper):
+
+        def __init__(self):
+            # quit and help are builtins
+            # CMD_MAP keys are commands, values are topics
+            self.CMD_MAP['pionce'] = _("Sommeil")
+            self.CMD_MAP['ronfle'] = _("Sommeil")
+            CLIHelper.__init__(self)
+
+        help_do_pionce = ("pionce", "pionce duree", _("met ton corps en veille"))
+        def do_pionce(self):
+            print 'nap is good'
+
+        help_do_ronfle = ("ronfle", "ronfle volume", _("met les autres en veille"))
+        def do_ronfle(self):
+            print 'fuuuuuuuuuuuu rhhhhhrhrhrrh'
+
+    cl = BookShell()
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+
+import __builtin__
+if not hasattr(__builtin__, '_'):
+    __builtin__._ = str
+
+
+def init_readline(complete_method, histfile=None):
+    """Init the readline library if available."""
+    try:
+        import readline
+        readline.parse_and_bind("tab: complete")
+        readline.set_completer(complete_method)
+        string = readline.get_completer_delims().replace(':', '')
+        readline.set_completer_delims(string)
+        if histfile is not None:
+            try:
+                readline.read_history_file(histfile)
+            except IOError:
+                pass
+            import atexit
+            atexit.register(readline.write_history_file, histfile)
+    except:
+        print 'readline is not available :-('
+
+
+class Completer :
+    """Readline completer."""
+
+    def __init__(self, commands):
+        self.list = commands
+
+    def complete(self, text, state):
+        """Hook called by readline when <tab> is pressed."""
+        n = len(text)
+        matches = []
+        for cmd in self.list :
+            if cmd[:n] == text :
+                matches.append(cmd)
+        try:
+            return matches[state]
+        except IndexError:
+            return None
+
+
+class CLIHelper:
+    """An abstract command line interface client which recognize commands
+    and provide an help system.
+    """
+
+    CMD_MAP = {'help' : _("Others"),
+               'quit' : _("Others"),
+               }
+    CMD_PREFIX = ''
+
+    def __init__(self, histfile=None) :
+        self._topics = {}
+        self.commands = None
+        self._completer = Completer(self._register_commands())
+        init_readline(self._completer.complete, histfile)
+
+    def run(self):
+        """loop on user input, exit on EOF"""
+        while 1:
+            try:
+                line = raw_input('>>> ')
+            except EOFError:
+                print
+                break
+            s_line = line.strip()
+            if not s_line:
+                continue
+            args = s_line.split()
+            if args[0] in self.commands:
+                try:
+                    cmd = 'do_%s' % self.commands[args[0]]
+                    getattr(self, cmd)(*args[1:])
+                except EOFError:
+                    break
+                except:
+                    import traceback
+                    traceback.print_exc()
+            else:
+                try:
+                    self.handle_line(s_line)
+                except:
+                    import traceback
+                    traceback.print_exc()
+
+    def handle_line(self, stripped_line):
+        """Method to overload in the concrete class (should handle
+        lines which are not commands).
+        """
+        raise NotImplementedError()
+
+
+    # private methods #########################################################
+
+    def _register_commands(self):
+        """ register available commands method and return the list of
+        commands name
+        """
+        self.commands = {}
+        self._command_help = {}
+        commands = [attr[3:] for attr in dir(self) if attr[:3] == 'do_']
+        for command in commands:
+            topic = self.CMD_MAP[command]
+            help_method = getattr(self, 'help_do_%s' % command)
+            self._topics.setdefault(topic, []).append(help_method)
+            self.commands[self.CMD_PREFIX + command] = command
+            self._command_help[command] = help_method
+        return self.commands.keys()
+
+    def _print_help(self, cmd, syntax, explanation):
+        print _('Command %s') % cmd
+        print _('Syntax: %s') % syntax
+        print '\t', explanation
+        print
+
+
+    # predefined commands #####################################################
+
+    def do_help(self, command=None) :
+        """base input of the help system"""
+        if command in self._command_help:
+            self._print_help(*self._command_help[command])
+        elif command is None or command not in self._topics:
+            print _("Use help <topic> or help <command>.")
+            print _("Available topics are:")
+            topics = self._topics.keys()
+            topics.sort()
+            for topic in topics:
+                print '\t', topic
+            print
+            print _("Available commands are:")
+            commands = self.commands.keys()
+            commands.sort()
+            for command in commands:
+                print '\t', command[len(self.CMD_PREFIX):]
+
+        else:
+            print _('Available commands about %s:') % command
+            print
+            for command_help_method in self._topics[command]:
+                try:
+                    if callable(command_help_method):
+                        self._print_help(*command_help_method())
+                    else:
+                        self._print_help(*command_help_method)
+                except:
+                    import traceback
+                    traceback.print_exc()
+                    print 'ERROR in help method %s'% (
+                        command_help_method.func_name)
+
+    help_do_help = ("help", "help [topic|command]",
+                    _("print help message for the given topic/command or \
+available topics when no argument"))
+
+    def do_quit(self):
+        """quit the CLI"""
+        raise EOFError()
+
+    def help_do_quit(self):
+        return ("quit", "quit", _("quit the application"))

data/tools/common/common/compat.py

@@ -0,0 +1,328 @@
+# pylint: disable-msg=E0601,W0622,W0611
+# copyright 2003-2010 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/>.
+"""Wrappers around some builtins introduced in python 2.3, 2.4 and
+2.5, making them available in for earlier versions of python.
+
+
+
+
+"""
+from __future__ import generators
+__docformat__ = "restructuredtext en"
+
+import os
+from warnings import warn
+
+import __builtin__
+
+try:
+    set = set
+    frozenset = frozenset
+except NameError:
+    try:
+        from sets import Set as set, ImmutableSet as frozenset
+    except ImportError:
+        class _baseset(object):
+            def __init__(self, values=()):
+                self._data = {}
+                warn("This implementation of Set is not complete !",
+                     stacklevel=2)
+                for v in values:
+                    self._data[v] = 1
+
+            def __or__(self, other):
+                result = self.__class__(self._data.keys())
+                for val in other:
+                    result.add(val)
+                return result
+            __add__ = __or__
+
+            def __and__(self, other):
+                result = self.__class__()
+                for val in other:
+                    if val in self._data:
+                        result.add(val)
+                return result
+
+            def __sub__(self, other):
+                result = self.__class__(self._data.keys())
+                for val in other:
+                    if val in self._data:
+                        result.remove(val)
+                return result
+
+            def __cmp__(self, other):
+                keys = self._data.keys()
+                okeys = other._data.keys()
+                keys.sort()
+                okeys.sort()
+                return cmp(keys, okeys)
+
+            def __len__(self):
+                return len(self._data)
+
+            def __repr__(self):
+                elements = self._data.keys()
+                return 'lcc.%s(%r)' % (self.__class__.__name__, elements)
+            __str__ = __repr__
+
+            def __iter__(self):
+                return iter(self._data)
+
+        class frozenset(_baseset):
+            """immutable set (can be set in dictionaries)"""
+            def __init__(self, values=()):
+                super(frozenset, self).__init__(values)
+                self._hashcode = None
+
+            def _compute_hash(self):
+                """taken from python stdlib (sets.py)"""
+                # Calculate hash code for a set by xor'ing the hash codes of
+                # the elements.  This ensures that the hash code does not depend
+                # on the order in which elements are added to the set.  This is
+                # not called __hash__ because a BaseSet should not be hashable;
+                # only an ImmutableSet is hashable.
+                result = 0
+                for elt in self:
+                    result ^= hash(elt)
+                return result
+
+            def __hash__(self):
+                """taken from python stdlib (sets.py)"""
+                if self._hashcode is None:
+                    self._hashcode = self._compute_hash()
+                return self._hashcode
+
+
+        class set(_baseset):
+            """mutable set"""
+            def add(self, value):
+                self._data[value] = 1
+
+            def remove(self, element):
+                """removes <element> from set"""
+                del self._data[element]
+
+            def pop(self):
+                """pops an arbitrary element from set"""
+                return self._data.popitem()[0]
+
+            def __hash__(self):
+                """mutable set cannot be hashed."""
+                raise TypeError("set objects are not hashable")
+
+        del _baseset # don't explicitly provide this class
+
+try:
+    from itertools import izip, chain, imap
+except ImportError:
+    # from itertools documentation ###
+    def izip(*iterables):
+        iterables = map(iter, iterables)
+        while iterables:
+            result = [i.next() for i in iterables]
+            yield tuple(result)
+
+    def chain(*iterables):
+        for it in iterables:
+            for element in it:
+                yield element
+
+    def imap(function, *iterables):
+        iterables = map(iter, iterables)
+        while True:
+            args = [i.next() for i in iterables]
+            if function is None:
+                yield tuple(args)
+            else:
+                yield function(*args)
+try:
+    sum = sum
+    enumerate = enumerate
+except NameError:
+    # define the sum and enumerate functions (builtins introduced in py 2.3)
+    import operator
+    def sum(seq, start=0):
+        """Returns the sum of all elements in the sequence"""
+        return reduce(operator.add, seq, start)
+
+    def enumerate(iterable):
+        """emulates the python2.3 enumerate() function"""
+        i = 0
+        for val in iterable:
+            yield i, val
+            i += 1
+        #return zip(range(len(iterable)), iterable)
+try:
+    sorted = sorted
+    reversed = reversed
+except NameError:
+
+    def sorted(iterable, cmp=None, key=None, reverse=False):
+        original = list(iterable)
+        if key:
+            l2 = [(key(elt), index) for index, elt in enumerate(original)]
+        else:
+            l2 = original
+        l2.sort(cmp)
+        if reverse:
+            l2.reverse()
+        if key:
+            return [original[index] for elt, index in l2]
+        return l2
+
+    def reversed(l):
+        l2 = list(l)
+        l2.reverse()
+        return l2
+
+try: #
+    max = max
+    max(("ab","cde"),key=len)
+except TypeError:
+    def max( *args, **kargs):
+        if len(args) == 0:
+            raise TypeError("max expected at least 1 arguments, got 0")
+        key= kargs.pop("key", None)
+        #default implementation
+        if key is None:
+            return __builtin__.max(*args,**kargs)
+
+        for karg in kargs:
+            raise TypeError("unexpected keyword argument %s for function max") % karg
+
+        if len(args) == 1:
+            items = iter(args[0])
+        else:
+            items = iter(args)
+
+        try:
+            best_item = items.next()
+            best_value = key(best_item)
+        except StopIteration:
+            raise ValueError("max() arg is an empty sequence")
+
+        for item in items:
+            value = key(item)
+            if value > best_value:
+                best_item = item
+                best_value = value
+
+        return best_item
+
+
+# Python2.5 builtins
+try:
+    any = any
+    all = all
+except NameError:
+    def any(iterable):
+        """any(iterable) -> bool
+
+        Return True if bool(x) is True for any x in the iterable.
+        """
+        for elt in iterable:
+            if elt:
+                return True
+        return False
+
+    def all(iterable):
+        """all(iterable) -> bool
+
+        Return True if bool(x) is True for all values x in the iterable.
+        """
+        for elt in iterable:
+            if not elt:
+                return False
+        return True
+
+
+# Python2.5 subprocess added functions and exceptions
+try:
+    from subprocess import Popen
+except ImportError:
+    # gae or python < 2.3
+
+    class CalledProcessError(Exception):
+        """This exception is raised when a process run by check_call() returns
+        a non-zero exit status.  The exit status will be stored in the
+        returncode attribute."""
+        def __init__(self, returncode, cmd):
+            self.returncode = returncode
+            self.cmd = cmd
+        def __str__(self):
+            return "Command '%s' returned non-zero exit status %d" % (self.cmd,
+    self.returncode)
+
+    def call(*popenargs, **kwargs):
+        """Run command with arguments.  Wait for command to complete, then
+        return the returncode attribute.
+
+        The arguments are the same as for the Popen constructor.  Example:
+
+        retcode = call(["ls", "-l"])
+        """
+        # workaround: subprocess.Popen(cmd, stdout=sys.stdout) fails
+        # see http://bugs.python.org/issue1531862
+        if "stdout" in kwargs:
+            fileno = kwargs.get("stdout").fileno()
+            del kwargs['stdout']
+            return Popen(stdout=os.dup(fileno), *popenargs, **kwargs).wait()
+        return Popen(*popenargs, **kwargs).wait()
+
+    def check_call(*popenargs, **kwargs):
+        """Run command with arguments.  Wait for command to complete.  If
+        the exit code was zero then return, otherwise raise
+        CalledProcessError.  The CalledProcessError object will have the
+        return code in the returncode attribute.
+
+        The arguments are the same as for the Popen constructor.  Example:
+
+        check_call(["ls", "-l"])
+        """
+        retcode = call(*popenargs, **kwargs)
+        cmd = kwargs.get("args")
+        if cmd is None:
+            cmd = popenargs[0]
+        if retcode:
+            raise CalledProcessError(retcode, cmd)
+        return retcode
+
+try:
+    from os.path import relpath
+except ImportError: # python < 2.6
+    from os.path import curdir, abspath, sep, commonprefix, pardir, join
+    def relpath(path, start=curdir):
+        """Return a relative version of a path"""
+
+        if not path:
+            raise ValueError("no path specified")
+
+        start_list = abspath(start).split(sep)
+        path_list = abspath(path).split(sep)
+
+        # Work out how much of the filepath is shared by start and path.
+        i = len(commonprefix([start_list, path_list]))
+
+        rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
+        if not rel_list:
+            return curdir
+        return join(*rel_list)
+
+