bee_python 0.0.3 → 0.0.4

data/tools/logilab/logilab/astng/utils.py

@@ -1,342 +0,0 @@
-# This program 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 of the License, or
-# (at your option) any later version.
-#
-# This program 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
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-# copyright 2003-2010 Sylvain Thenault, all rights reserved.
-# contact mailto:thenault@gmail.com
-#
-# This file is part of logilab-astng.
-#
-# logilab-astng 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-astng 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-astng. If not, see <http://www.gnu.org/licenses/>.
-"""this module contains some utilities to navigate in the tree or to
-extract information from it
-
-"""
-
-__docformat__ = "restructuredtext en"
-
-from logilab.astng._exceptions import IgnoreChild, ASTNGBuildingException
-
-
-class ASTVisitor(object):
-    """Abstract Base Class for Python AST Visitors.
-
-    Visitors inheriting from ASTVisitors could visit
-    compiler.ast, _ast or astng trees.
-
-    Not all methods will have to be implemented;
-    so some methods are just empty interfaces for catching
-    cases where we don't want to do anything on the
-    concerned node.
-    """
-
-    def visit_arguments(self, node):
-        """dummy method for visiting an Arguments node"""
-
-    def visit_assattr(self, node):
-        """dummy method for visiting an AssAttr node"""
-
-    def visit_assert(self, node):
-        """dummy method for visiting an Assert node"""
-
-    def visit_assign(self, node):
-        """dummy method for visiting an Assign node"""
-
-    def visit_assname(self, node):
-        """dummy method for visiting an AssName node"""
-
-    def visit_augassign(self, node):
-        """dummy method for visiting an AugAssign node"""
-
-    def visit_backquote(self, node):
-        """dummy method for visiting an Backquote node"""
-
-    def visit_binop(self, node):
-        """dummy method for visiting an BinOp node"""
-
-    def visit_boolop(self, node):
-        """dummy method for visiting an BoolOp node"""
-
-    def visit_break(self, node):
-        """dummy method for visiting an Break node"""
-
-    def visit_callfunc(self, node):
-        """dummy method for visiting an CallFunc node"""
-
-    def visit_class(self, node):
-        """dummy method for visiting an Class node"""
-
-    def visit_compare(self, node):
-        """dummy method for visiting an Compare node"""
-
-    def visit_comprehension(self, node):
-        """dummy method for visiting an Comprehension node"""
-
-    def visit_const(self, node):
-        """dummy method for visiting an Const node"""
-
-    def visit_continue(self, node):
-        """dummy method for visiting an Continue node"""
-
-    def visit_decorators(self, node):
-        """dummy method for visiting an Decorators node"""
-
-    def visit_delattr(self, node):
-        """dummy method for visiting an DelAttr node"""
-
-    def visit_delete(self, node):
-        """dummy method for visiting an Delete node"""
-
-    def visit_delname(self, node):
-        """dummy method for visiting an DelName node"""
-
-    def visit_dict(self, node):
-        """dummy method for visiting an Dict node"""
-
-    def visit_discard(self, node):
-        """dummy method for visiting an Discard node"""
-
-    def visit_emptynode(self, node):
-        """dummy method for visiting an EmptyNode node"""
-
-    def visit_excepthandler(self, node):
-        """dummy method for visiting an ExceptHandler node"""
-
-    def visit_ellipsis(self, node):
-        """dummy method for visiting an Ellipsis node"""
-
-    def visit_empty(self, node):
-        """dummy method for visiting an Empty node"""
-
-    def visit_exec(self, node):
-        """dummy method for visiting an Exec node"""
-
-    def visit_extslice(self, node):
-        """dummy method for visiting an ExtSlice node"""
-
-    def visit_for(self, node):
-        """dummy method for visiting an For node"""
-
-    def visit_from(self, node):
-        """dummy method for visiting an From node"""
-
-    def visit_function(self, node):
-        """dummy method for visiting an Function node"""
-
-    def visit_genexpr(self, node):
-        """dummy method for visiting an ListComp node"""
-
-    def visit_getattr(self, node):
-        """dummy method for visiting an Getattr node"""
-
-    def visit_global(self, node):
-        """dummy method for visiting an Global node"""
-
-    def visit_if(self, node):
-        """dummy method for visiting an If node"""
-
-    def visit_ifexp(self, node):
-        """dummy method for visiting an IfExp node"""
-
-    def visit_import(self, node):
-        """dummy method for visiting an Import node"""
-
-    def visit_index(self, node):
-        """dummy method for visiting an Index node"""
-
-    def visit_keyword(self, node):
-        """dummy method for visiting an Keyword node"""
-
-    def visit_lambda(self, node):
-        """dummy method for visiting an Lambda node"""
-
-    def visit_list(self, node):
-        """dummy method for visiting an List node"""
-
-    def visit_listcomp(self, node):
-        """dummy method for visiting an ListComp node"""
-
-    def visit_module(self, node):
-        """dummy method for visiting an Module node"""
-
-    def visit_name(self, node):
-        """dummy method for visiting an Name node"""
-
-    def visit_pass(self, node):
-        """dummy method for visiting an Pass node"""
-
-    def visit_print(self, node):
-        """dummy method for visiting an Print node"""
-
-    def visit_raise(self, node):
-        """dummy method for visiting an Raise node"""
-
-    def visit_return(self, node):
-        """dummy method for visiting an Return node"""
-
-    def visit_slice(self, node):
-        """dummy method for visiting an Slice node"""
-
-    def visit_subscript(self, node):
-        """dummy method for visiting an Subscript node"""
-
-    def visit_tryexcept(self, node):
-        """dummy method for visiting an TryExcept node"""
-
-    def visit_tryfinally(self, node):
-        """dummy method for visiting an TryFinally node"""
-
-    def visit_tuple(self, node):
-        """dummy method for visiting an Tuple node"""
-
-    def visit_unaryop(self, node):
-        """dummy method for visiting an UnaryOp node"""
-
-    def visit_while(self, node):
-        """dummy method for visiting an While node"""
-
-    def visit_with(self, node):
-        """dummy method for visiting an With node"""
-
-    def visit_yield(self, node):
-        """dummy method for visiting an Yield node"""
-
-
-class ASTWalker:
-    """a walker visiting a tree in preorder, calling on the handler:
-
-    * visit_<class name> on entering a node, where class name is the class of
-    the node in lower case
-
-    * leave_<class name> on leaving a node, where class name is the class of
-    the node in lower case
-    """
-
-    def __init__(self, handler):
-        self.handler = handler
-        self._cache = {}
-
-    def walk(self, node, _done=None):
-        """walk on the tree from <node>, getting callbacks from handler"""
-        if _done is None:
-            _done = set()
-        if node in _done:
-            raise AssertionError((id(node), node, node.parent))
-        _done.add(node)
-        try:
-            self.visit(node)
-        except IgnoreChild:
-            pass
-        else:
-            try:
-                for child_node in node.get_children():
-                    self.handler.set_context(node, child_node)
-                    assert child_node is not node
-                    self.walk(child_node, _done)
-            except AttributeError:
-                print node.__class__, id(node.__class__)
-                raise
-        self.leave(node)
-        assert node.parent is not node
-
-    def get_callbacks(self, node):
-        """get callbacks from handler for the visited node"""
-        klass = node.__class__
-        methods = self._cache.get(klass)
-        if methods is None:
-            handler = self.handler
-            kid = klass.__name__.lower()
-            e_method = getattr(handler, 'visit_%s' % kid,
-                               getattr(handler, 'visit_default', None))
-            l_method = getattr(handler, 'leave_%s' % kid,
-                               getattr(handler, 'leave_default', None))
-            self._cache[klass] = (e_method, l_method)
-        else:
-            e_method, l_method = methods
-        return e_method, l_method
-
-    def visit(self, node):
-        """walk on the tree from <node>, getting callbacks from handler"""
-        method = self.get_callbacks(node)[0]
-        if method is not None:
-            method(node)
-
-    def leave(self, node):
-        """walk on the tree from <node>, getting callbacks from handler"""
-        method = self.get_callbacks(node)[1]
-        if method is not None:
-            method(node)
-
-
-class LocalsVisitor(ASTWalker):
-    """visit a project by traversing the locals dictionary"""
-    def __init__(self):
-        ASTWalker.__init__(self, self)
-        self._visited = {}
-
-    def visit(self, node):
-        """launch the visit starting from the given node"""
-        if self._visited.has_key(node):
-            return
-        self._visited[node] = 1 # FIXME: use set ?
-        methods = self.get_callbacks(node)
-        recurse = 1
-        if methods[0] is not None:
-            try:
-                methods[0](node)
-            except IgnoreChild:
-                recurse = 0
-        if recurse:
-            if 'locals' in node.__dict__: # skip Instance and other proxy
-                for name, local_node in node.items():
-                    self.visit(local_node)
-        if methods[1] is not None:
-            return methods[1](node)
-
-
-def _check_children(node):
-    """a helper function to check children - parent relations"""
-    for child in node.get_children():
-        ok = False
-        if child is None:
-            print "Hm, child of %s is None" % node
-            continue
-        if not hasattr(child, 'parent'):
-            print " ERROR: %s has child %s %x with no parent" % (node, child, id(child))
-        elif not child.parent:
-            print " ERROR: %s has child %s %x with parent %r" % (node, child, id(child), child.parent)
-        elif child.parent is not node:
-            print " ERROR: %s %x has child %s %x with wrong parent %s" % (node,
-                                      id(node), child, id(child), child.parent)
-        else:
-            ok = True
-        if not ok:
-            print "lines;", node.lineno, child.lineno
-            print "of module", node.root(), node.root().name
-            raise ASTNGBuildingException
-        _check_children(child)
-
-
-__all__ = ('LocalsVisitor', 'ASTWalker', 'ASTVisitor',)
-

data/tools/logilab/logilab/common/__init__.py

@@ -1,140 +0,0 @@
-# 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/>.
-"""Logilab common library (aka Logilab's extension to the standard library).
-
-:type STD_BLACKLIST: tuple
-:var STD_BLACKLIST: directories ignored by default by the functions in
-  this package which have to recurse into directories
-
-:type IGNORED_EXTENSIONS: tuple
-:var IGNORED_EXTENSIONS: file extensions that may usually be ignored
-"""
-__docformat__ = "restructuredtext en"
-from logilab.common.__pkginfo__ import version as __version__
-
-STD_BLACKLIST = ('CVS', '.svn', '.hg', 'debian', 'dist', 'build')
-
-IGNORED_EXTENSIONS = ('.pyc', '.pyo', '.elc', '~')
-
-# set this to False if you've mx DateTime installed but you don't want your db
-# adapter to use it (should be set before you got a connection)
-USE_MX_DATETIME = True
-
-
-class attrdict(dict):
-    """A dictionary for which keys are also accessible as attributes."""
-    def __getattr__(self, attr):
-        try:
-            return self[attr]
-        except KeyError:
-            raise AttributeError(attr)
-
-class dictattr(dict):
-    def __init__(self, proxy):
-        self.__proxy = proxy
-
-    def __getitem__(self, attr):
-        try:
-            return getattr(self.__proxy, attr)
-        except AttributeError:
-            raise KeyError(attr)
-
-class nullobject(object):
-    def __repr__(self):
-        return '<nullobject>'
-    def __nonzero__(self):
-        return False
-
-# flatten -----
-# XXX move in a specific module and use yield instead
-# do not mix flatten and translate
-#
-# def iterable(obj):
-#    try: iter(obj)
-#    except: return False
-#    return True
-#
-# def is_string_like(obj):
-#    try: obj +''
-#    except (TypeError, ValueError): return False
-#    return True
-#
-#def is_scalar(obj):
-#    return is_string_like(obj) or not iterable(obj)
-#
-#def flatten(seq):
-#    for item in seq:
-#        if is_scalar(item):
-#            yield item
-#        else:
-#            for subitem in flatten(item):
-#               yield subitem
-
-def flatten(iterable, tr_func=None, results=None):
-    """Flatten a list of list with any level.
-
-    If tr_func is not None, it should be a one argument function that'll be called
-    on each final element.
-
-    :rtype: list
-
-    >>> flatten([1, [2, 3]])
-    [1, 2, 3]
-    """
-    if results is None:
-        results = []
-    for val in iterable:
-        if isinstance(val, (list, tuple)):
-            flatten(val, tr_func, results)
-        elif tr_func is None:
-            results.append(val)
-        else:
-            results.append(tr_func(val))
-    return results
-
-
-# XXX is function below still used ?
-
-def make_domains(lists):
-    """
-    Given a list of lists, return a list of domain for each list to produce all
-    combinations of possibles values.
-
-    :rtype: list
-
-    Example:
-
-    >>> make_domains(['a', 'b'], ['c','d', 'e'])
-    [['a', 'b', 'a', 'b', 'a', 'b'], ['c', 'c', 'd', 'd', 'e', 'e']]
-    """
-    domains = []
-    for iterable in lists:
-        new_domain = iterable[:]
-        for i in range(len(domains)):
-            domains[i] = domains[i]*len(iterable)
-        if domains:
-            missing = (len(domains[0]) - len(iterable)) / len(iterable)
-            i = 0
-            for j in range(len(iterable)):
-                value = iterable[j]
-                for dummy in range(missing):
-                    new_domain.insert(i, value)
-                    i += 1
-                i += 1
-        domains.append(new_domain)
-    return domains

data/tools/logilab/logilab/common/__pkginfo__.py

@@ -1,43 +0,0 @@
-# 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/>.
-"""logilab.common packaging information"""
-__docformat__ = "restructuredtext en"
-
-distname = 'logilab-common'
-modname = 'common'
-
-numversion = (0, 50, 3)
-version = '.'.join([str(num) for num in numversion])
-
-license = 'LGPL' # 2.1 or later
-
-author = "Logilab"
-author_email = "devel@logilab.fr"
-
-description = "collection of low-level Python packages and modules used by Logilab projects"
-web = "http://www.logilab.org/project/%s" % distname
-ftp = "ftp://ftp.logilab.org/pub/%s" % modname
-mailinglist = "mailto://python-projects@lists.logilab.org"
-
-subpackage_of = 'logilab'
-subpackage_master = True
-
-scripts = ('bin/pytest',)
-from os.path import join
-include_dirs = [join('test', 'data')]
-pyversions = ['2.4', '2.5', '2.6']

data/tools/logilab/logilab/common/adbh.py

@@ -1,35 +0,0 @@
-# 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/>.
-"""Helpers for DBMS specific (advanced or non standard) functionalities.
-"""
-__docformat__ = "restructuredtext en"
-
-from warnings import warn
-warn('this module is deprecated, use logilab.database instead',
-     DeprecationWarning, stacklevel=1)
-
-from logilab.database import (FunctionDescr, get_db_helper as get_adv_func_helper,
-                        _GenericAdvFuncHelper,
-                        _ADV_FUNC_HELPER_DIRECTORY as ADV_FUNC_HELPER_DIRECTORY)
-from logilab.common.decorators import monkeypatch
-
-@monkeypatch(_GenericAdvFuncHelper, 'func_sqlname')
-@classmethod
-def func_sqlname(cls, funcname):
-    funcdef = cls.function_description(funcname)
-    return funcdef.name_mapping.get(cls.backend_name, funcname)

data/tools/logilab/logilab/common/cache.py

@@ -1,114 +0,0 @@
-# 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/>.
-"""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()
-
-