bee_python 0.0.3 → 0.0.4

data/tools/logilab/logilab/astng/protocols.py

@@ -1,333 +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 python protocols for nodes
-where it makes sense.
-
-"""
-
-from __future__ import generators
-
-__doctype__ = "restructuredtext en"
-
-from logilab.astng import InferenceError, NoDefault
-from logilab.astng.node_classes import unpack_infer
-from logilab.astng.bases import copy_context, \
-     raise_if_nothing_infered, yes_if_nothing_infered, Instance, Generator, YES
-from logilab.astng.nodes import const_factory
-from logilab.astng import nodes
-
-# unary operations ############################################################
-
-def tl_infer_unary_op(self, operator):
-    if operator == 'not':
-        return const_factory(not bool(self.elts))
-    raise TypeError() # XXX log unsupported operation
-nodes.Tuple.infer_unary_op = tl_infer_unary_op
-nodes.List.infer_unary_op = tl_infer_unary_op
-
-
-def dict_infer_unary_op(self, operator):
-    if operator == 'not':
-        return const_factory(not bool(self.items))
-    raise TypeError() # XXX log unsupported operation
-nodes.Dict.infer_unary_op = dict_infer_unary_op
-
-
-def const_infer_unary_op(self, operator):
-    if operator == 'not':
-        return const_factory(not self.value)
-    # XXX log potentially raised TypeError
-    elif operator == '+':
-        return const_factory(+self.value)
-    else: # operator == '-':
-        return const_factory(-self.value)
-nodes.Const.infer_unary_op = const_infer_unary_op
-
-
-# binary operations ###########################################################
-
-BIN_OP_IMPL = {'+':  lambda a, b: a + b,
-               '-':  lambda a, b: a - b,
-               '/':  lambda a, b: a / b,
-               '//': lambda a, b: a // b,
-               '*':  lambda a, b: a * b,
-               '**': lambda a, b: a ** b,
-               '%':  lambda a, b: a % b,
-               '&':  lambda a, b: a & b,
-               '|':  lambda a, b: a | b,
-               '^':  lambda a, b: a ^ b,
-               '<<': lambda a, b: a << b,
-               '>>': lambda a, b: a >> b,
-               }
-for key, impl in BIN_OP_IMPL.items():
-    BIN_OP_IMPL[key+'='] = impl
-
-def const_infer_binary_op(self, operator, other, context):
-    for other in other.infer(context):
-        if isinstance(other, nodes.Const):
-            try:
-                impl = BIN_OP_IMPL[operator]
-
-                try:
-                    yield const_factory(impl(self.value, other.value))
-                except StandardError:
-                    # ArithmeticError is not enough: float >> float is a TypeError
-                    # TODO : let pylint know about the problem
-                    pass
-            except TypeError:
-                # XXX log TypeError
-                continue
-        elif other is YES:
-            yield other
-        else:
-            try:
-                for val in other.infer_binary_op(operator, self, context):
-                    yield val
-            except AttributeError:
-                yield YES
-nodes.Const.infer_binary_op = yes_if_nothing_infered(const_infer_binary_op)
-
-
-def tl_infer_binary_op(self, operator, other, context):
-    for other in other.infer(context):
-        if isinstance(other, self.__class__) and operator == '+':
-            node = self.__class__()
-            elts = [n for elt in self.elts for n in elt.infer(context)
-                    if not n is YES]
-            elts += [n for elt in other.elts for n in elt.infer(context)
-                     if not n is YES]
-            node.elts = elts
-            yield node
-        elif isinstance(other, nodes.Const) and operator == '*':
-            node = self.__class__()
-            elts = [n for elt in self.elts for n in elt.infer(context)
-                    if not n is YES] * other.value
-            node.elts = elts
-            yield node
-        elif isinstance(other, Instance) and not isinstance(other, nodes.Const):
-            yield YES
-    # XXX else log TypeError
-nodes.Tuple.infer_binary_op = yes_if_nothing_infered(tl_infer_binary_op)
-nodes.List.infer_binary_op = yes_if_nothing_infered(tl_infer_binary_op)
-
-
-def dict_infer_binary_op(self, operator, other, context):
-    for other in other.infer(context):
-        if isinstance(other, Instance) and isinstance(other._proxied, nodes.Class):
-            yield YES
-        # XXX else log TypeError
-nodes.Dict.infer_binary_op = yes_if_nothing_infered(dict_infer_binary_op)
-
-
-# assignment ##################################################################
-
-"""the assigned_stmts method is responsible to return the assigned statement
-(e.g. not inferred) according to the assignment type.
-
-The `asspath` argument is used to record the lhs path of the original node.
-For instance if we want assigned statements for 'c' in 'a, (b,c)', asspath
-will be [1, 1] once arrived to the Assign node.
-
-The `context` argument is the current inference context which should be given
-to any intermediary inference necessary.
-"""
-
-def _resolve_looppart(parts, asspath, context):
-    """recursive function to resolve multiple assignments on loops"""
-    asspath = asspath[:]
-    index = asspath.pop(0)
-    for part in parts:
-        if part is YES:
-            continue
-        # XXX handle __iter__ and log potentially detected errors
-        if not hasattr(part, 'itered'):
-            continue
-        try:
-            itered = part.itered()
-        except TypeError:
-            continue # XXX log error
-        for stmt in itered:
-            try:
-                assigned = stmt.getitem(index, context)
-            except (AttributeError, IndexError):
-                continue
-            except TypeError, exc: # stmt is unsubscriptable Const
-                continue
-            if not asspath:
-                # we achieved to resolved the assignment path,
-                # don't infer the last part
-                yield assigned
-            elif assigned is YES:
-                break
-            else:
-                # we are not yet on the last part of the path
-                # search on each possibly inferred value
-                try:
-                    for infered in _resolve_looppart(assigned.infer(context),
-                                                     asspath, context):
-                        yield infered
-                except InferenceError:
-                    break
-
-
-def for_assigned_stmts(self, node, context=None, asspath=None):
-    if asspath is None:
-        for lst in self.iter.infer(context):
-            if isinstance(lst, (nodes.Tuple, nodes.List)):
-                for item in lst.elts:
-                    yield item
-    else:
-        for infered in _resolve_looppart(self.iter.infer(context),
-                                             asspath, context):
-            yield infered
-
-nodes.For.assigned_stmts = raise_if_nothing_infered(for_assigned_stmts)
-nodes.Comprehension.assigned_stmts = raise_if_nothing_infered(for_assigned_stmts)
-
-
-def mulass_assigned_stmts(self, node, context=None, asspath=None):
-    if asspath is None:
-        asspath = []
-    asspath.insert(0, self.elts.index(node))
-    return self.parent.assigned_stmts(self, context, asspath)
-nodes.Tuple.assigned_stmts = mulass_assigned_stmts
-nodes.List.assigned_stmts = mulass_assigned_stmts
-
-
-def assend_assigned_stmts(self, context=None):
-    return self.parent.assigned_stmts(self, context=context)
-nodes.AssName.assigned_stmts = assend_assigned_stmts
-nodes.AssAttr.assigned_stmts = assend_assigned_stmts
-
-
-def _arguments_infer_argname(self, name, context):
-    # arguments information may be missing, in which case we can't do anything
-    # more
-    if not (self.args or self.vararg or self.kwarg):
-        yield YES
-        return
-    # first argument of instance/class method
-    if self.args and getattr(self.args[0], 'name', None) == name:
-        functype = self.parent.type
-        if functype == 'method':
-            yield Instance(self.parent.parent.frame())
-            return
-        if functype == 'classmethod':
-            yield self.parent.parent.frame()
-            return
-    if name == self.vararg:
-        yield const_factory(())
-        return
-    if name == self.kwarg:
-        yield const_factory({})
-        return
-    # if there is a default value, yield it. And then yield YES to reflect
-    # we can't guess given argument value
-    try:
-        context = copy_context(context)
-        for infered in self.default_value(name).infer(context):
-            yield infered
-        yield YES
-    except NoDefault:
-        yield YES
-
-
-def arguments_assigned_stmts(self, node, context, asspath=None):
-    if context.callcontext:
-        # reset call context/name
-        callcontext = context.callcontext
-        context = copy_context(context)
-        context.callcontext = None
-        for infered in callcontext.infer_argument(self.parent, node.name, context):
-            yield infered
-        return
-    for infered in _arguments_infer_argname(self, node.name, context):
-        yield infered
-nodes.Arguments.assigned_stmts = arguments_assigned_stmts
-
-
-def assign_assigned_stmts(self, node, context=None, asspath=None):
-    if not asspath:
-        yield self.value
-        return
-    for infered in _resolve_asspart(self.value.infer(context), asspath, context):
-        yield infered
-nodes.Assign.assigned_stmts = raise_if_nothing_infered(assign_assigned_stmts)
-nodes.AugAssign.assigned_stmts = raise_if_nothing_infered(assign_assigned_stmts)
-
-
-def _resolve_asspart(parts, asspath, context):
-    """recursive function to resolve multiple assignments"""
-    asspath = asspath[:]
-    index = asspath.pop(0)
-    for part in parts:
-        if hasattr(part, 'getitem'):
-            try:
-                assigned = part.getitem(index, context)
-            # XXX raise a specific exception to avoid potential hiding of
-            # unexpected exception ?
-            except (TypeError, IndexError):
-                return
-            if not asspath:
-                # we achieved to resolved the assignment path, don't infer the
-                # last part
-                yield assigned
-            elif assigned is YES:
-                return
-            else:
-                # we are not yet on the last part of the path search on each
-                # possibly inferred value
-                try:
-                    for infered in _resolve_asspart(assigned.infer(context),
-                                                    asspath, context):
-                        yield infered
-                except InferenceError:
-                    return
-
-
-def excepthandler_assigned_stmts(self, node, context=None, asspath=None):
-    for assigned in unpack_infer(self.type):
-        if isinstance(assigned, nodes.Class):
-            assigned = Instance(assigned)
-        yield assigned
-nodes.ExceptHandler.assigned_stmts = raise_if_nothing_infered(excepthandler_assigned_stmts)
-
-
-def with_assigned_stmts(self, node, context=None, asspath=None):
-    if asspath is None:
-        for lst in self.vars.infer(context):
-            if isinstance(lst, (nodes.Tuple, nodes.List)):
-                for item in lst.nodes:
-                    yield item
-nodes.With.assigned_stmts = raise_if_nothing_infered(with_assigned_stmts)
-
-

data/tools/logilab/logilab/astng/raw_building.py

@@ -1,212 +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 create astng trees from scratch
-(build_* functions) or from living object (object_build_* functions)
-
-"""
-
-__docformat__ = "restructuredtext en"
-
-import sys
-from inspect import getargspec
-
-from logilab.astng import nodes
-
-
-def _attach_local_node(parent, node, name):
-    node.name = name # needed by add_local_node
-    parent.add_local_node(node)
-
-_marker = object()
-
-def attach_dummy_node(node, name, object=_marker):
-    """create a dummy node and register it in the locals of the given
-    node with the specified name
-    """
-    enode = nodes.EmptyNode()
-    enode.object = object
-    _attach_local_node(node, enode, name)
-
-nodes.EmptyNode.has_underlying_object = lambda self: self.object is not _marker
-
-def attach_const_node(node, name, value):
-    """create a Const node and register it in the locals of the given
-    node with the specified name
-    """
-    if not name in node.special_attributes:
-        _attach_local_node(node, nodes.const_factory(value), name)
-
-def attach_import_node(node, modname, membername):
-    """create a From node and register it in the locals of the given
-    node with the specified name
-    """
-    from_node = nodes.From(modname, [(membername, None)])
-    _attach_local_node(node, from_node, membername)
-
-
-def build_module(name, doc=None):
-    """create and initialize a astng Module node"""
-    node = nodes.Module(name, doc, pure_python=False)
-    node.package = False
-    node.parent = None
-    return node
-
-def build_class(name, basenames=(), doc=None):
-    """create and initialize a astng Class node"""
-    node = nodes.Class(name, doc)
-    for base in basenames:
-        basenode = nodes.Name()
-        basenode.name = base
-        node.bases.append(basenode)
-        basenode.parent = node
-    return node
-
-def build_function(name, args=None, defaults=None, flag=0, doc=None):
-    """create and initialize a astng Function node"""
-    args, defaults = args or [], defaults or []
-    # first argument is now a list of decorators
-    func = nodes.Function(name, doc)
-    func.args = argsnode = nodes.Arguments()
-    argsnode.args = []
-    for arg in args:
-        argsnode.args.append(nodes.Name())
-        argsnode.args[-1].name = arg
-        argsnode.args[-1].parent = argsnode
-    argsnode.defaults = []
-    for default in defaults:
-        argsnode.defaults.append(nodes.const_factory(default))
-        argsnode.defaults[-1].parent = argsnode
-    argsnode.kwarg = None
-    argsnode.vararg = None
-    argsnode.parent = func
-    if args:
-        register_arguments(func)
-    return func
-
-
-# def build_name_assign(name, value):
-#     """create and initialize an astng Assign for a name assignment"""
-#     return nodes.Assign([nodes.AssName(name, 'OP_ASSIGN')], nodes.Const(value))
-
-# def build_attr_assign(name, value, attr='self'):
-#     """create and initialize an astng Assign for an attribute assignment"""
-#     return nodes.Assign([nodes.AssAttr(nodes.Name(attr), name, 'OP_ASSIGN')],
-#                         nodes.Const(value))
-
-
-def build_from_import(fromname, names):
-    """create and initialize an astng From import statement"""
-    return nodes.From(fromname, [(name, None) for name in names])
-
-def register_arguments(func, args=None):
-    """add given arguments to local
-
-    args is a list that may contains nested lists
-    (i.e. def func(a, (b, c, d)): ...)
-    """
-    if args is None:
-        args = func.args.args
-        if func.args.vararg:
-            func.set_local(func.args.vararg, func.args)
-        if func.args.kwarg:
-            func.set_local(func.args.kwarg, func.args)
-    for arg in args:
-        if isinstance(arg, nodes.Name):
-            func.set_local(arg.name, arg)
-        else:
-            register_arguments(func, arg.elts)
-
-def object_build_class(node, member, localname):
-    """create astng for a living class object"""
-    basenames = [base.__name__ for base in member.__bases__]
-    return _base_class_object_build(node, member, basenames,
-                                    localname=localname)
-
-def object_build_function(node, member, localname):
-    """create astng for a living function object"""
-    args, varargs, varkw, defaults = getargspec(member)
-    if varargs is not None:
-        args.append(varargs)
-    if varkw is not None:
-        args.append(varkw)
-    func = build_function(getattr(member, '__name__', None) or localname, args,
-                          defaults, member.func_code.co_flags, member.__doc__)
-    node.add_local_node(func, localname)
-
-def object_build_datadescriptor(node, member, name):
-    """create astng for a living data descriptor object"""
-    return _base_class_object_build(node, member, [], name)
-
-def object_build_methoddescriptor(node, member, localname):
-    """create astng for a living method descriptor object"""
-    # FIXME get arguments ?
-    func = build_function(getattr(member, '__name__', None) or localname,
-                          doc=member.__doc__)
-    # set node's arguments to None to notice that we have no information, not
-    # and empty argument list
-    func.args.args = None
-    node.add_local_node(func, localname)
-
-def _base_class_object_build(node, member, basenames, name=None, localname=None):
-    """create astng for a living class object, with a given set of base names
-    (e.g. ancestors)
-    """
-    klass = build_class(name or getattr(member, '__name__', None) or localname,
-                        basenames, member.__doc__)
-    klass._newstyle = isinstance(member, type)
-    node.add_local_node(klass, localname)
-    try:
-        # limit the instantiation trick since it's too dangerous
-        # (such as infinite test execution...)
-        # this at least resolves common case such as Exception.args,
-        # OSError.errno
-        if issubclass(member, Exception):
-            instdict = member().__dict__
-        else:
-            raise TypeError
-    except:
-        pass
-    else:
-        for name, obj in instdict.items():
-            valnode = nodes.EmptyNode()
-            valnode.object = obj
-            valnode.parent = klass
-            valnode.lineno = 1
-            klass.instance_attrs[name] = [valnode]
-    return klass
-
-
-__all__ = ('register_arguments',  'build_module',
-           'object_build_class', 'object_build_function',
-           'object_build_datadescriptor', 'object_build_methoddescriptor',
-           'attach_dummy_node',
-           'attach_const_node', 'attach_import_node')