bee_python 0.0.3 → 0.0.4

data/tools/logilab/logilab/astng/builder.py

@@ -1,239 +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/>.
-"""The ASTNGBuilder makes astng from living object and / or from compiler.ast
-
-With python >= 2.5, the internal _ast module is used instead
-
-The builder is not thread safe and can't be used to parse different sources
-at the same time.
-
-
-"""
-
-__docformat__ = "restructuredtext en"
-
-import sys
-from os.path import splitext, basename, dirname, exists, abspath
-from inspect import isfunction, ismethod, ismethoddescriptor, isclass, \
-     isbuiltin
-from inspect import isdatadescriptor
-
-from logilab.common.fileutils import norm_read
-from logilab.common.modutils import modpath_from_file
-
-from logilab.astng._exceptions import ASTNGBuildingException
-from logilab.astng.raw_building import *
-
-try:
-    from _ast import PyCF_ONLY_AST
-    def parse(string):
-        return compile(string, "<string>", 'exec', PyCF_ONLY_AST)
-    from logilab.astng._nodes_ast import TreeRebuilder
-except ImportError, exc:
-    from compiler import parse
-    from logilab.astng import patchcomptransformer
-    from logilab.astng._nodes_compiler import TreeRebuilder
-
-# ast NG builder ##############################################################
-
-class ASTNGBuilder:
-    """provide astng building methods
-    """
-
-    def __init__(self, manager=None):
-        if manager is None:
-            from logilab.astng import MANAGER as manager
-        self._manager = manager
-        self._module = None
-        self._file = None
-        self._done = None
-        self.rebuilder = TreeRebuilder(manager)
-        self._dyn_modname_map = {'gtk': 'gtk._gtk'}
-
-    def module_build(self, module, modname=None):
-        """build an astng from a living module instance
-        """
-        node = None
-        self._module = module
-        path = getattr(module, '__file__', None)
-        if path is not None:
-            path_, ext = splitext(module.__file__)
-            if ext in ('.py', '.pyc', '.pyo') and exists(path_ + '.py'):
-                node = self.file_build(path_ + '.py', modname)
-        if node is None:
-            # this is a built-in module
-            # get a partial representation by introspection
-            node = self.inspect_build(module, modname=modname, path=path)
-        return node
-
-    def inspect_build(self, module, modname=None, path=None):
-        """build astng from a living module (i.e. using inspect)
-        this is used when there is no python source code available (either
-        because it's a built-in module or because the .py is not available)
-        """
-        self._module = module
-        if modname is None:
-            modname = module.__name__
-        node = build_module(modname, module.__doc__)
-        node.file = node.path = path and abspath(path) or path
-        if self._manager is not None:
-            self._manager._cache[modname] = node
-        node.package = hasattr(module, '__path__')
-        self._done = {}
-        self.object_build(node, module)
-        return node
-
-    def file_build(self, path, modname=None):
-        """build astng from a source code file (i.e. from an ast)
-
-        path is expected to be a python source file
-        """
-        try:
-            data = norm_read(path)
-        except IOError, ex:
-            msg = 'Unable to load file %r (%s)' % (path, ex)
-            raise ASTNGBuildingException(msg)
-        self._file = path
-        # get module name if necessary, *before modifying sys.path*
-        if modname is None:
-            try:
-                modname = '.'.join(modpath_from_file(path))
-            except ImportError:
-                modname = splitext(basename(path))[0]
-        # build astng representation
-        try:
-            sys.path.insert(0, dirname(path))
-            node = self.string_build(data, modname, path)
-            node.file = abspath(path)
-        finally:
-            self._file = None
-            sys.path.pop(0)
-
-        return node
-
-    def string_build(self, data, modname='', path=None):
-        """build astng from a source code stream (i.e. from an ast)"""
-        return self.ast_build(parse(data + '\n'), modname, path)
-
-    def ast_build(self, node, modname='', path=None):
-        """build the astng from AST, return the new tree"""
-        if path is not None:
-            node_file = abspath(path)
-        else:
-            node_file = '<?>'
-        if modname.endswith('.__init__'):
-            modname = modname[:-9]
-            package = True
-        else:
-            package = path and path.find('__init__.py') > -1 or False
-        newnode = self.rebuilder.build(node, modname, node_file)
-        newnode.package = package
-        return newnode
-
-    # astng from living objects ###############################################
-    #
-    # this is actually a really minimal representation, including only Module,
-    # Function and Class nodes and some others as guessed
-
-    def object_build(self, node, obj):
-        """recursive method which create a partial ast from real objects
-         (only function, class, and method are handled)
-        """
-        if self._done.has_key(obj):
-            return self._done[obj]
-        self._done[obj] = node
-        for name in dir(obj):
-            try:
-                member = getattr(obj, name)
-            except AttributeError:
-                # damned ExtensionClass.Base, I know you're there !
-                attach_dummy_node(node, name)
-                continue
-            if ismethod(member):
-                member = member.im_func
-            if isfunction(member):
-                # verify this is not an imported function
-                if member.func_code.co_filename != getattr(self._module, '__file__', None):
-                    attach_dummy_node(node, name, member)
-                    continue
-                object_build_function(node, member, name)
-            elif isbuiltin(member):
-                # verify this is not an imported member
-                if self._member_module(member) != self._module.__name__:
-                    imported_member(node, member, name)
-                    continue
-                object_build_methoddescriptor(node, member, name)
-            elif isclass(member):
-                # verify this is not an imported class
-                if self._member_module(member) != self._module.__name__:
-                    imported_member(node, member, name)
-                    continue
-                if member in self._done:
-                    class_node = self._done[member]
-                    if not class_node in node.locals.get(name, ()):
-                        node.add_local_node(class_node, name)
-                else:
-                    class_node = object_build_class(node, member, name)
-                    # recursion
-                    self.object_build(class_node, member)
-            elif ismethoddescriptor(member):
-                assert isinstance(member, object)
-                object_build_methoddescriptor(node, member, name)
-            elif isdatadescriptor(member):
-                assert isinstance(member, object)
-                object_build_datadescriptor(node, member, name)
-            elif isinstance(member, (int, long, float, str, unicode)) or member is None:
-                attach_const_node(node, name, member)
-            else:
-                # create an empty node so that the name is actually defined
-                attach_dummy_node(node, name, member)
-
-    def _member_module(self, member):
-        modname = getattr(member, '__module__', None)
-        return self._dyn_modname_map.get(modname, modname)
-
-
-def imported_member(node, member, name):
-    """consider a class/builtin member where __module__ != current module name
-
-    check if it's sound valid and then add an import node, else use a dummy node
-    """
-    # /!\ some classes like ExtensionClass doesn't have a
-    # __module__ attribute !
-    member_module = getattr(member, '__module__', '__builtin__')
-    try:
-        getattr(sys.modules[member_module], name)
-    except (KeyError, AttributeError):
-        attach_dummy_node(node, name, member)
-    else:
-        attach_import_node(node, member_module, name)
-

data/tools/logilab/logilab/astng/inference.py

@@ -1,426 +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 a set of functions to handle inference on astng trees
-
-"""
-
-from __future__ import generators
-
-__doctype__ = "restructuredtext en"
-
-from logilab.common.compat import chain
-
-try:
-    GeneratorExit # introduced in py2.5
-except NameError:
-    class GeneratorExit(Exception): pass
-
-from logilab.astng import MANAGER, nodes, raw_building
-from logilab.astng import ASTNGError, InferenceError, UnresolvableName, \
-     NoDefault, NotFoundError, ASTNGBuildingException
-from logilab.astng.bases import YES, Instance, InferenceContext, \
-     _infer_stmts, copy_context, path_wrapper, raise_if_nothing_infered
-from logilab.astng.protocols import _arguments_infer_argname
-
-_CONST_PROXY = {
-    type(None): raw_building.build_class('NoneType'),
-    bool: MANAGER.astng_from_class(bool),
-    int: MANAGER.astng_from_class(int),
-    long: MANAGER.astng_from_class(long),
-    float: MANAGER.astng_from_class(float),
-    complex: MANAGER.astng_from_class(complex),
-    str: MANAGER.astng_from_class(str),
-    unicode: MANAGER.astng_from_class(unicode),
-    }
-_CONST_PROXY[type(None)].parent = _CONST_PROXY[bool].parent
-
-# TODO : find a nicer way to handle this situation; we should at least
-# be able to avoid calling MANAGER.astng_from_class(const.value.__class__)
-# each time (if we can not avoid the property). However __proxied introduced an
-# infinite recursion (see https://bugs.launchpad.net/pylint/+bug/456870)
-def _set_proxied(const):
-    return _CONST_PROXY[const.value.__class__]
-nodes.Const._proxied = property(_set_proxied)
-
-def Const_pytype(self):
-    return self._proxied.qname()
-nodes.Const.pytype = Const_pytype
-
-
-nodes.List._proxied = MANAGER.astng_from_class(list)
-nodes.Tuple._proxied = MANAGER.astng_from_class(tuple)
-nodes.Dict._proxied = MANAGER.astng_from_class(dict)
-
-
-class CallContext:
-    """when inferring a function call, this class is used to remember values
-    given as argument
-    """
-    def __init__(self, args, starargs, dstarargs):
-        self.args = []
-        self.nargs = {}
-        for arg in args:
-            if isinstance(arg, nodes.Keyword):
-                self.nargs[arg.arg] = arg.value
-            else:
-                self.args.append(arg)
-        self.starargs = starargs
-        self.dstarargs = dstarargs
-
-    def infer_argument(self, funcnode, name, context):
-        """infer a function argument value according to the call context"""
-        # 1. search in named keywords
-        try:
-            return self.nargs[name].infer(context)
-        except KeyError:
-            # Function.args.args can be None in astng (means that we don't have
-            # information on argnames)
-            argindex = funcnode.args.find_argname(name)[0]
-            if argindex is not None:
-                # 2. first argument of instance/class method
-                if argindex == 0 and funcnode.type in ('method', 'classmethod'):
-                    if context.boundnode is not None:
-                        boundnode = context.boundnode
-                    else:
-                        # XXX can do better ?
-                        boundnode = funcnode.parent.frame()
-                    if funcnode.type == 'method':
-                        if not isinstance(boundnode, Instance):
-                            boundnode = Instance(boundnode)
-                        return iter((boundnode,))
-                    if funcnode.type == 'classmethod':
-                        return iter((boundnode,))
-                # 2. search arg index
-                try:
-                    return self.args[argindex].infer(context)
-                except IndexError:
-                    pass
-                # 3. search in *args (.starargs)
-                if self.starargs is not None:
-                    its = []
-                    for infered in self.starargs.infer(context):
-                        if infered is YES:
-                            its.append((YES,))
-                            continue
-                        try:
-                            its.append(infered.getitem(argindex, context).infer(context))
-                        except (InferenceError, AttributeError):
-                            its.append((YES,))
-                        except (IndexError, TypeError):
-                            continue
-                    if its:
-                        return chain(*its)
-        # 4. XXX search in **kwargs (.dstarargs)
-        if self.dstarargs is not None:
-            its = []
-            for infered in self.dstarargs.infer(context):
-                if infered is YES:
-                    its.append((YES,))
-                    continue
-                try:
-                    its.append(infered.getitem(name, context).infer(context))
-                except (InferenceError, AttributeError):
-                    its.append((YES,))
-                except (IndexError, TypeError):
-                    continue
-            if its:
-                return chain(*its)
-        # 5. */** argument, (Tuple or Dict)
-        if name == funcnode.args.vararg:
-            return iter((nodes.const_factory(())))
-        if name == funcnode.args.kwarg:
-            return iter((nodes.const_factory({})))
-        # 6. return default value if any
-        try:
-            return funcnode.args.default_value(name).infer(context)
-        except NoDefault:
-            raise InferenceError(name)
-
-
-# .infer method ###############################################################
-
-
-def infer_end(self, context=None):
-    """inference's end for node such as Module, Class, Function, Const...
-    """
-    yield self
-nodes.Module.infer = infer_end
-nodes.Class.infer = infer_end
-nodes.Function.infer = infer_end
-nodes.Lambda.infer = infer_end
-nodes.Const.infer = infer_end
-nodes.List.infer = infer_end
-nodes.Tuple.infer = infer_end
-nodes.Dict.infer = infer_end
-
-
-def infer_name(self, context=None):
-    """infer a Name: use name lookup rules"""
-    frame, stmts = self.lookup(self.name)
-    if not stmts:
-        raise UnresolvableName(self.name)
-    context = context.clone()
-    context.lookupname = self.name
-    return _infer_stmts(stmts, context, frame)
-nodes.Name.infer = path_wrapper(infer_name)
-nodes.AssName.infer_lhs = infer_name # won't work with a path wrapper
-
-
-def infer_callfunc(self, context=None):
-    """infer a CallFunc node by trying to guess what the function returns"""
-    callcontext = context.clone()
-    callcontext.callcontext = CallContext(self.args, self.starargs, self.kwargs)
-    callcontext.boundnode = None
-    for callee in self.func.infer(context):
-        if callee is YES:
-            yield callee
-            continue
-        try:
-            if hasattr(callee, 'infer_call_result'):
-                for infered in callee.infer_call_result(self, callcontext):
-                    yield infered
-        except InferenceError:
-            ## XXX log error ?
-            continue
-nodes.CallFunc.infer = path_wrapper(raise_if_nothing_infered(infer_callfunc))
-
-
-def infer_import(self, context=None, asname=True):
-    """infer an Import node: return the imported module/object"""
-    name = context.lookupname
-    if name is None:
-        raise InferenceError()
-    if asname:
-        yield self.do_import_module(self.real_name(name))
-    else:
-        yield self.do_import_module(name)
-nodes.Import.infer = path_wrapper(infer_import)
-
-def infer_name_module(self, name):
-    context = InferenceContext()
-    context.lookupname = name
-    return self.infer(context, asname=False)
-nodes.Import.infer_name_module = infer_name_module
-
-
-def infer_from(self, context=None, asname=True):
-    """infer a From nodes: return the imported module/object"""
-    name = context.lookupname
-    if name is None:
-        raise InferenceError()
-    if asname:
-        name = self.real_name(name)
-    module = self.do_import_module(self.modname)
-    try:
-        context = copy_context(context)
-        context.lookupname = name
-        return _infer_stmts(module.getattr(name), context)
-    except NotFoundError:
-        raise InferenceError(name)
-nodes.From.infer = path_wrapper(infer_from)
-
-
-def infer_getattr(self, context=None):
-    """infer a Getattr node by using getattr on the associated object"""
-    #context = context.clone()
-    for owner in self.expr.infer(context):
-        if owner is YES:
-            yield owner
-            continue
-        try:
-            context.boundnode = owner
-            for obj in owner.igetattr(self.attrname, context):
-                yield obj
-            context.boundnode = None
-        except (NotFoundError, InferenceError):
-            context.boundnode = None
-        except AttributeError:
-            # XXX method / function
-            context.boundnode = None
-nodes.Getattr.infer = path_wrapper(raise_if_nothing_infered(infer_getattr))
-nodes.AssAttr.infer_lhs = raise_if_nothing_infered(infer_getattr) # # won't work with a path wrapper
-
-
-def infer_global(self, context=None):
-    if context.lookupname is None:
-        raise InferenceError()
-    try:
-        return _infer_stmts(self.root().getattr(context.lookupname), context)
-    except NotFoundError:
-        raise InferenceError()
-nodes.Global.infer = path_wrapper(infer_global)
-
-
-def infer_subscript(self, context=None):
-    """infer simple subscription such as [1,2,3][0] or (1,2,3)[-1]"""
-    if isinstance(self.slice, nodes.Index):
-        index = self.slice.value.infer(context).next()
-        if index is YES:
-            yield YES
-            return
-        try:
-            # suppose it's a Tuple/List node (attribute error else)
-            assigned = self.value.getitem(index.value, context)
-        except AttributeError:
-            raise InferenceError()
-        except (IndexError, TypeError):
-            yield YES
-            return
-        for infered in assigned.infer(context):
-            yield infered
-    else:
-        raise InferenceError()
-nodes.Subscript.infer = path_wrapper(infer_subscript)
-nodes.Subscript.infer_lhs = raise_if_nothing_infered(infer_subscript)
-
-
-UNARY_OP_METHOD = {'+': '__pos__',
-                   '-': '__neg__',
-                   '~': '__invert__',
-                   'not': None, # XXX not '__nonzero__'
-                  }
-
-def infer_unaryop(self, context=None):
-    for operand in self.operand.infer(context):
-        try:
-            yield operand.infer_unary_op(self.op)
-        except TypeError:
-            continue
-        except AttributeError:
-            meth = UNARY_OP_METHOD[self.op]
-            if meth is None:
-                yield YES
-            else:
-                try:
-                    # XXX just suppose if the type implement meth, returned type
-                    # will be the same
-                    operand.getattr(meth)
-                    yield operand
-                except GeneratorExit:
-                    raise
-                except:
-                    yield YES
-nodes.UnaryOp.infer = path_wrapper(infer_unaryop)
-
-
-BIN_OP_METHOD = {'+':  '__add__',
-                 '-':  '__sub__',
-                 '/':  '__div__',
-                 '//': '__floordiv__',
-                 '*':  '__mul__',
-                 '**': '__power__',
-                 '%':  '__mod__',
-                 '&':  '__and__',
-                 '|':  '__or__',
-                 '^':  '__xor__',
-                 '<<': '__lshift__',
-                 '>>': '__rshift__',
-                 }
-
-def _infer_binop(operator, operand1, operand2, context, failures=None):
-    if operand1 is YES:
-        yield operand1
-        return
-    try:
-        for valnode in operand1.infer_binary_op(operator, operand2, context):
-            yield valnode
-    except AttributeError:
-        try:
-            # XXX just suppose if the type implement meth, returned type
-            # will be the same
-            operand1.getattr(BIN_OP_METHOD[operator])
-            yield operand1
-        except:
-            if failures is None:
-                yield YES
-            else:
-                failures.append(operand1)
-
-def infer_binop(self, context=None):
-    failures = []
-    for lhs in self.left.infer(context):
-        for val in _infer_binop(self.op, lhs, self.right, context, failures):
-            yield val
-    for lhs in failures:
-        for rhs in self.right.infer(context):
-            for val in _infer_binop(self.op, rhs, lhs, context):
-                yield val
-nodes.BinOp.infer = path_wrapper(infer_binop)
-
-
-def infer_arguments(self, context=None):
-    name = context.lookupname
-    if name is None:
-        raise InferenceError()
-    return _arguments_infer_argname(self, name, context)
-nodes.Arguments.infer = infer_arguments
-
-
-def infer_ass(self, context=None):
-    """infer a AssName/AssAttr: need to inspect the RHS part of the
-    assign node
-    """
-    stmt = self.statement()
-    if isinstance(stmt, nodes.AugAssign):
-        return stmt.infer(context)
-    stmts = list(self.assigned_stmts(context=context))
-    return _infer_stmts(stmts, context)
-nodes.AssName.infer = path_wrapper(infer_ass)
-nodes.AssAttr.infer = path_wrapper(infer_ass)
-
-def infer_augassign(self, context=None):
-    failures = []
-    for lhs in self.target.infer_lhs(context):
-        for val in _infer_binop(self.op, lhs, self.value, context, failures):
-            yield val
-    for lhs in failures:
-        for rhs in self.value.infer(context):
-            for val in _infer_binop(self.op, rhs, lhs, context):
-                yield val
-nodes.AugAssign.infer = path_wrapper(infer_augassign)
-
-
-# no infer method on DelName and DelAttr (expected InferenceError)
-
-
-def infer_empty_node(self, context=None):
-    if not self.has_underlying_object():
-        yield YES
-    else:
-        try:
-            for infered in MANAGER.infer_astng_from_something(self.object,
-                                                              context=context):
-                yield infered
-        except ASTNGError:
-            yield YES
-nodes.EmptyNode.infer = path_wrapper(infer_empty_node)
-