bee_python 0.0.1

data/tools/logilab/logilab/common/changelog.py

@@ -0,0 +1,234 @@
+# 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/>.
+"""Manipulation of upstream change log files.
+
+The upstream change log files format handled is simpler than the one
+often used such as those generated by the default Emacs changelog mode.
+
+Sample ChangeLog format::
+
+  Change log for project Yoo
+  ==========================
+
+   --
+      * add a new functionality
+
+  2002-02-01 -- 0.1.1
+      * fix bug #435454
+      * fix bug #434356
+
+  2002-01-01 -- 0.1
+      * initial release
+
+
+There is 3 entries in this change log, one for each released version and one
+for the next version (i.e. the current entry).
+Each entry contains a set of messages corresponding to changes done in this
+release.
+All the non empty lines before the first entry are considered as the change
+log title.
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+
+import sys
+from stat import S_IWRITE
+
+BULLET = '*'
+SUBBULLET = '-'
+INDENT = ' ' * 4
+
+class NoEntry(Exception):
+    """raised when we are unable to find an entry"""
+
+class EntryNotFound(Exception):
+    """raised when we are unable to find a given entry"""
+
+class Version(tuple):
+    """simple class to handle soft version number has a tuple while
+    correctly printing it as X.Y.Z
+    """
+    def __new__(klass, versionstr):
+        if isinstance(versionstr, basestring):
+            versionstr = versionstr.strip(' :')
+            try:
+                parsed = [int(i) for i in versionstr.split('.')]
+            except ValueError, ex:
+                raise ValueError("invalid literal for version '%s' (%s)"%(versionstr,ex))
+        else:
+            parsed = versionstr
+        return tuple.__new__(klass, parsed)
+
+    def __str__(self):
+        return '.'.join([str(i) for i in self])
+
+# upstream change log #########################################################
+
+class ChangeLogEntry(object):
+    """a change log entry, i.e. a set of messages associated to a version and
+    its release date
+    """
+    version_class = Version
+
+    def __init__(self, date=None, version=None, **kwargs):
+        self.__dict__.update(kwargs)
+        if version:
+            self.version = self.version_class(version)
+        else:
+            self.version = None
+        self.date = date
+        self.messages = []
+
+    def add_message(self, msg):
+        """add a new message"""
+        self.messages.append(([msg],[]))
+
+    def complete_latest_message(self, msg_suite):
+        """complete the latest added message
+        """
+        if not self.messages:
+            raise ValueError('unable to complete last message as there is no previous message)')
+        if self.messages[-1][1]: # sub messages
+            self.messages[-1][1][-1].append(msg_suite)
+        else: # message
+            self.messages[-1][0].append(msg_suite)
+
+    def add_sub_message(self, sub_msg, key=None):
+        if not self.messages:
+            raise ValueError('unable to complete last message as there is no previous message)')
+        if key is None:
+            self.messages[-1][1].append([sub_msg])
+        else:
+            raise NotImplementedError("sub message to specific key are not implemented yet")
+
+    def write(self, stream=sys.stdout):
+        """write the entry to file """
+        stream.write('%s  --  %s\n' % (self.date or '', self.version or ''))
+        for msg, sub_msgs in self.messages:
+            stream.write('%s%s %s\n' % (INDENT, BULLET, msg[0]))
+            stream.write(''.join(msg[1:]))
+            if sub_msgs:
+                stream.write('\n')
+            for sub_msg in sub_msgs:
+                stream.write('%s%s %s\n' % (INDENT * 2, SUBBULLET, sub_msg[0]))
+                stream.write(''.join(sub_msg[1:]))
+            stream.write('\n')
+
+        stream.write('\n\n')
+
+class ChangeLog(object):
+    """object representation of a whole ChangeLog file"""
+
+    entry_class = ChangeLogEntry
+
+    def __init__(self, changelog_file, title=''):
+        self.file = changelog_file
+        self.title = title
+        self.additional_content = ''
+        self.entries = []
+        self.load()
+
+    def __repr__(self):
+        return '<ChangeLog %s at %s (%s entries)>' % (self.file, id(self),
+                                                      len(self.entries))
+
+    def add_entry(self, entry):
+        """add a new entry to the change log"""
+        self.entries.append(entry)
+
+    def get_entry(self, version='', create=None):
+        """ return a given changelog entry
+        if version is omitted, return the current entry
+        """
+        if not self.entries:
+            if version or not create:
+                raise NoEntry()
+            self.entries.append(self.entry_class())
+        if not version:
+            if self.entries[0].version and create is not None:
+                self.entries.insert(0, self.entry_class())
+            return self.entries[0]
+        version = self.version_class(version)
+        for entry in self.entries:
+            if entry.version == version:
+                return entry
+        raise EntryNotFound()
+
+    def add(self, msg, create=None):
+        """add a new message to the latest opened entry"""
+        entry = self.get_entry(create=create)
+        entry.add_message(msg)
+
+    def load(self):
+        """ read a logilab's ChangeLog from file """
+        try:
+            stream = open(self.file)
+        except IOError:
+            return
+        last = None
+        expect_sub = False
+        for line in stream.readlines():
+            sline = line.strip()
+            words = sline.split()
+            # if new entry
+            if len(words) == 1 and words[0] == '--':
+                expect_sub = False
+                last = self.entry_class()
+                self.add_entry(last)
+            # if old entry
+            elif len(words) == 3 and words[1] == '--':
+                expect_sub = False
+                last = self.entry_class(words[0], words[2])
+                self.add_entry(last)
+            # if title
+            elif sline and last is None:
+                self.title = '%s%s' % (self.title, line)
+            # if new entry
+            elif sline and sline[0] == BULLET:
+                expect_sub = False
+                last.add_message(sline[1:].strip())
+            # if new sub_entry
+            elif expect_sub and sline and sline[0] == SUBBULLET:
+                last.add_sub_message(sline[1:].strip())
+            # if new line for current entry
+            elif sline and last.messages:
+                last.complete_latest_message(line)
+            else:
+                expect_sub = True
+                self.additional_content += line
+        stream.close()
+
+    def format_title(self):
+        return '%s\n\n' % self.title.strip()
+
+    def save(self):
+        """write back change log"""
+        # filetutils isn't importable in appengine, so import locally
+        from logilab.common.fileutils import ensure_fs_mode
+        ensure_fs_mode(self.file, S_IWRITE)
+        self.write(open(self.file, 'w'))
+
+    def write(self, stream=sys.stdout):
+        """write changelog to stream"""
+        stream.write(self.format_title())
+        for entry in self.entries:
+            entry.write(stream)
+

data/tools/logilab/logilab/common/clcommands.py

@@ -0,0 +1,181 @@
+# 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/>.
+"""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
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+
+# XXX : merge with optparser ?
+import sys
+from os.path import basename
+
+from logilab.common.configuration import Configuration
+
+
+DEFAULT_COPYRIGHT = '''\
+Copyright (c) 2004-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+http://www.logilab.fr/ -- mailto:contact@logilab.fr'''
+
+
+DEFAULT_DOC = '''\
+Type "%prog <command> --help" for more information about a specific
+command. Available commands are :\n'''
+
+class BadCommandUsage(Exception):
+    """Raised when an unknown command is used or when a command is not
+    correctly used.
+    """
+
+
+class Command(Configuration):
+    """Base class for command line commands."""
+    arguments = ''
+    name = ''
+    # hidden from help ?
+    hidden = False
+    # max/min args, None meaning unspecified
+    min_args = None
+    max_args = None
+    def __init__(self, __doc__=None, version=None):
+        if __doc__:
+            usage = __doc__ % (self.name, self.arguments,
+                               self.__doc__.replace('    ', ''))
+        else:
+            usage = self.__doc__.replace('    ', '')
+        Configuration.__init__(self, usage=usage, version=version)
+
+    def check_args(self, args):
+        """check command's arguments are provided"""
+        if self.min_args is not None and len(args) < self.min_args:
+            raise BadCommandUsage('missing argument')
+        if self.max_args is not None and len(args) > self.max_args:
+            raise BadCommandUsage('too many arguments')
+
+    def run(self, args):
+        """run the command with its specific arguments"""
+        raise NotImplementedError()
+
+
+def pop_arg(args_list, expected_size_after=0, 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
+
+
+_COMMANDS = {}
+
+def register_commands(commands):
+    """register existing commands"""
+    for command_klass in commands:
+        _COMMANDS[command_klass.name] = command_klass
+
+
+def main_usage(status=0, doc=DEFAULT_DOC, copyright=DEFAULT_COPYRIGHT):
+    """display usage for the main program (i.e. when no command supplied)
+    and exit
+    """
+    commands = _COMMANDS.keys()
+    commands.sort()
+    if doc != DEFAULT_DOC:
+        try:
+            doc = doc % ('<command>', '<command arguments>',
+                             '''\
+Type "%prog <command> --help" for more information about a specific
+command. Available commands are :\n''')
+        except TypeError:
+            print 'could not find the "command", "arguments" and "default" slots'
+    doc = doc.replace('%prog', basename(sys.argv[0]))
+    print 'usage:', doc
+    max_len = max([len(cmd) for cmd in commands]) # list comprehension for py 2.3 support
+    padding = ' '*max_len
+    for command in commands:
+        cmd = _COMMANDS[command]
+        if not cmd.hidden:
+            title = cmd.__doc__.split('.')[0]
+            print ' ', (command+padding)[:max_len], title
+    if copyright:
+        print '\n', copyright
+    sys.exit(status)
+
+
+def cmd_run(cmdname, *args):
+    try:
+        command = _COMMANDS[cmdname](__doc__='%%prog %s %s\n\n%s')
+    except KeyError:
+        raise BadCommandUsage('no %s command' % cmdname)
+    args = command.load_command_line_configuration(args)
+    command.check_args(args)
+    try:
+        command.run(args)
+    except KeyboardInterrupt:
+        print 'interrupted'
+    except BadCommandUsage, err:
+        print 'ERROR: ', err
+        print command.help()
+
+
+def main_run(args, doc=DEFAULT_DOC, copyright=DEFAULT_COPYRIGHT):
+    """command line tool"""
+    try:
+        arg = args.pop(0)
+    except IndexError:
+        main_usage(status=1, doc=doc, copyright=copyright)
+    if arg in ('-h', '--help'):
+        main_usage(doc=doc, copyright=copyright)
+    try:
+        cmd_run(arg, *args)
+    except BadCommandUsage, err:
+        print 'ERROR: ', err
+        main_usage(1, doc=doc, copyright=copyright)
+
+
+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 = pop_arg(args)
+            cmd = _COMMANDS[command]
+            for optname, optdict in cmd.options:
+                print '--help'
+                print '--' + optname
+        else:
+            commands = _COMMANDS.keys()
+            commands.sort()
+            for command in commands:
+                cmd = _COMMANDS[command]
+                if not cmd.hidden:
+                    print command
+
+register_commands([ListCommandsCommand])

data/tools/logilab/logilab/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"))