exercism-analysis 0.1.1

data/vendor/python/logilab/common/announce.txt

@@ -0,0 +1,25 @@
+I'm pleased to announce the %(VERSION)s release of %(DISTNAME)s.
+
+What's new ?
+------------
+%(CHANGELOG)s
+
+
+What is %(DISTNAME)s ?
+------------------------
+%(LONG_DESC)s
+
+
+Home page
+---------
+%(WEB)s
+
+Download
+--------
+%(FTP)s
+
+Mailing list
+------------
+%(MAILINGLIST)s
+
+%(ADDITIONAL_DESCR)s

data/vendor/python/logilab/common/bin/pytest

@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+
+import warnings
+warnings.simplefilter('default', DeprecationWarning)
+
+from logilab.common.pytest import run
+run()

data/vendor/python/logilab/common/bin/pytest.bat

@@ -0,0 +1,17 @@
+@echo off
+rem = """-*-Python-*- script
+rem -------------------- DOS section --------------------
+rem You could set PYTHONPATH or TK environment variables here
+python -x "%~f0" %*
+goto exit
+ 
+"""
+# -------------------- Python section --------------------
+from logilab.common.pytest import run
+run()
+
+DosExitLabel = """
+:exit
+rem """
+
+

data/vendor/python/logilab/common/cache.py

@@ -0,0 +1,114 @@
+# 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/>.
+"""Cache module, with a least recently used algorithm for the management of the
+deletion of entries.
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+
+from threading import Lock
+
+from logilab.common.decorators import locked
+
+_marker = object()
+
+class Cache(dict):
+    """A dictionary like cache.
+
+    inv:
+        len(self._usage) <= self.size
+        len(self.data) <= self.size
+    """
+
+    def __init__(self, size=100):
+        """ Warning : Cache.__init__() != dict.__init__().
+        Constructor does not take any arguments beside size.
+        """
+        assert size >= 0, 'cache size must be >= 0 (0 meaning no caching)'
+        self.size = size
+        self._usage = []
+        self._lock = Lock()
+        super(Cache, self).__init__()
+
+    def _acquire(self):
+        self._lock.acquire()
+
+    def _release(self):
+        self._lock.release()
+
+    def _update_usage(self, key):
+        if not self._usage:
+            self._usage.append(key)
+        elif self._usage[-1] != key:
+            try:
+                self._usage.remove(key)
+            except ValueError:
+                # we are inserting a new key
+                # check the size of the dictionary
+                # and remove the oldest item in the cache
+                if self.size and len(self._usage) >= self.size:
+                    super(Cache, self).__delitem__(self._usage[0])
+                    del self._usage[0]
+            self._usage.append(key)
+        else:
+            pass # key is already the most recently used key
+
+    def __getitem__(self, key):
+        value = super(Cache, self).__getitem__(key)
+        self._update_usage(key)
+        return value
+    __getitem__ = locked(_acquire, _release)(__getitem__)
+
+    def __setitem__(self, key, item):
+        # Just make sure that size > 0 before inserting a new item in the cache
+        if self.size > 0:
+            super(Cache, self).__setitem__(key, item)
+            self._update_usage(key)
+    __setitem__ = locked(_acquire, _release)(__setitem__)
+
+    def __delitem__(self, key):
+        super(Cache, self).__delitem__(key)
+        self._usage.remove(key)
+    __delitem__ = locked(_acquire, _release)(__delitem__)
+
+    def clear(self):
+        super(Cache, self).clear()
+        self._usage = []
+    clear = locked(_acquire, _release)(clear)
+
+    def pop(self, key, default=_marker):
+        if key in self:
+            self._usage.remove(key)
+        #if default is _marker:
+        #    return super(Cache, self).pop(key)
+        return super(Cache, self).pop(key, default)
+    pop = locked(_acquire, _release)(pop)
+
+    def popitem(self):
+        raise NotImplementedError()
+
+    def setdefault(self, key, default=None):
+        raise NotImplementedError()
+
+    def update(self, other):
+        raise NotImplementedError()
+
+

data/vendor/python/logilab/common/changelog.py

@@ -0,0 +1,236 @@
+# 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/>.
+"""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__(cls, versionstr):
+        if isinstance(versionstr, basestring):
+            versionstr = versionstr.strip(' :') # XXX (syt) duh?
+            parsed = cls.parse(versionstr)
+        else:
+            parsed = versionstr
+        return tuple.__new__(cls, parsed)
+
+    @classmethod
+    def parse(cls, versionstr):
+        versionstr = versionstr.strip(' :')
+        try:
+            return [int(i) for i in versionstr.split('.')]
+        except ValueError, ex:
+            raise ValueError("invalid literal for version '%s' (%s)"%(versionstr, ex))
+
+    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/vendor/python/logilab/common/clcommands.py

@@ -0,0 +1,332 @@
+# 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
+"""
+
+__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
+
+
+class BadCommandUsage(Exception):
+    """Raised when an unknown command is used or when a command is not
+    correctly used (bad options, too much / missing arguments...).
+
+    Trigger display of command usage.
+    """
+
+class CommandError(Exception):
+    """Raised when a command can't be processed and we want to display it and
+    exit, without traceback nor usage displayed.
+    """
+
+
+# command line access point ####################################################
+
+class CommandLine(dict):
+    """Usage:
+
+    >>> LDI = cli.CommandLine('ldi', doc='Logilab debian installer',
+                              version=version, rcfile=RCFILE)
+    >>> LDI.register(MyCommandClass)
+    >>> LDI.register(MyOtherCommandClass)
+    >>> LDI.run(sys.argv[1:])
+
+    Arguments:
+
+    * `pgm`, the program name, default to `basename(sys.argv[0])`
+
+    * `doc`, a short description of the command line tool
+
+    * `copyright`, additional doc string that will be appended to the generated
+      doc
+
+    * `version`, version number of string of the tool. If specified, global
+      --version option will be available.
+
+    * `rcfile`, path to a configuration file. If specified, global --C/--rc-file
+      option will be available?  self.rcfile = rcfile
+
+    * `logger`, logger to propagate to commands, default to
+      `logging.getLogger(self.pgm))`
+    """
+    def __init__(self, pgm=None, doc=None, copyright=None, version=None,
+                 rcfile=None, logthreshold=logging.ERROR,
+                 check_duplicated_command=True):
+        if pgm is None:
+            pgm = basename(sys.argv[0])
+        self.pgm = pgm
+        self.doc = doc
+        self.copyright = copyright
+        self.version = version
+        self.rcfile = rcfile
+        self.logger = None
+        self.logthreshold = logthreshold
+        self.check_duplicated_command = check_duplicated_command
+
+    def register(self, cls, force=False):
+        """register the given :class:`Command` subclass"""
+        assert not self.check_duplicated_command or force or not cls.name in self, \
+               'a command %s is already defined' % cls.name
+        self[cls.name] = cls
+        return cls
+
+    def run(self, args):
+        """main command line access point:
+        * init logging
+        * handle global options (-h/--help, --version, -C/--rc-file)
+        * check command
+        * run command
+
+        Terminate by :exc:`SystemExit`
+        """
+        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
+            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
+            self.usage_and_exit(1)
+        try:
+            sys.exit(command.main_run(args, rcfile))
+        except KeyboardInterrupt, exc:
+            print 'Interrupted',
+            if str(exc):
+                print ': %s' % exc,
+            print
+            sys.exit(4)
+        except BadCommandUsage, 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,
+        if self.rcfile:
+            print '[--rc-file=<configuration file>]',
+        print '<command> [options] <command argument>...'
+        if self.doc:
+            print '\n%s' % self.doc
+        print  '''
+Type "%(pgm)s <command> --help" for more information about a specific
+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()
+        if self.rcfile:
+            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__
+        if self.version:
+            print  '''%(pgm)s -v/--version
+      display version configuration and exit''' % self.__dict__
+        if 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.
+
+    Class attributes:
+
+    * `name`, the name of the command
+
+    * `min_args`, minimum number of arguments, None if unspecified
+
+    * `max_args`, maximum number of arguments, None if unspecified
+
+    * `arguments`, string describing arguments, used in command usage
+
+    * `hidden`, boolean flag telling if the command should be hidden, e.g. does
+      not appear in help's commands list
+
+    * `options`, options list, as allowed by :mod:configuration
+    """
+
+    arguments = ''
+    name = ''
+    # hidden from help ?
+    hidden = False
+    # max/min args, None meaning unspecified
+    min_args = None
+    max_args = None
+
+    @classmethod
+    def description(cls):
+        return cls.__doc__.replace('    ', '')
+
+    @classmethod
+    def short_description(cls):
+        return cls.description().split('.')[0]
+
+    def __init__(self, logger):
+        usage = '%%prog %s %s\n\n%s' % (self.name, self.arguments,
+                                        self.description())
+        Configuration.__init__(self, usage=usage)
+        self.logger = logger
+
+    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 main_run(self, args, rcfile=None):
+        """Run the command and return status 0 if everything went fine.
+
+        If :exc:`CommandError` is raised by the underlying command, simply log
+        the error and return status 2.
+
+        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:
+            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
+        else:
+            commands = sorted(_COMMANDS.keys())
+            for command in commands:
+                cmd = _COMMANDS[command]
+                if not cmd.hidden:
+                    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'''
+
+@deprecated('use cls.register(cli)')
+def register_commands(commands):
+    """register existing commands"""
+    for command_klass in commands:
+        _COMMANDS.register(command_klass)
+
+@deprecated('use args.pop(0)')
+def main_run(args, doc=None, copyright=None, version=None):
+    """command line tool: run command specified by argument list (without the
+    program name). Raise SystemExit with status 0 if everything went fine.
+
+    >>> main_run(sys.argv[1:])
+    """
+    _COMMANDS.doc = doc
+    _COMMANDS.copyright = copyright
+    _COMMANDS.version = version
+    _COMMANDS.run(args)
+
+@deprecated('use args.pop(0)')
+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
+