exercism-analysis 0.1.1

data/vendor/python/astroid/inspector.py

@@ -0,0 +1,275 @@
+# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of astroid.
+#
+# astroid 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.
+#
+# astroid 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 astroid. If not, see <http://www.gnu.org/licenses/>.
+"""visitor doing some postprocessing on the astroid tree.
+Try to resolve definitions (namespace) dictionary, relationship...
+
+This module has been imported from pyreverse
+"""
+
+__docformat__ = "restructuredtext en"
+
+from os.path import dirname
+
+from logilab.common.modutils import get_module_part, is_relative, \
+     is_standard_module
+
+import astroid
+from astroid.exceptions import InferenceError
+from astroid.utils import LocalsVisitor
+
+class IdGeneratorMixIn:
+    """
+    Mixin adding the ability to generate integer uid
+    """
+    def __init__(self, start_value=0):
+        self.id_count = start_value
+    
+    def init_counter(self, start_value=0):
+        """init the id counter
+        """
+        self.id_count = start_value
+        
+    def generate_id(self):
+        """generate a new identifier
+        """
+        self.id_count += 1
+        return self.id_count
+
+
+class Linker(IdGeneratorMixIn, LocalsVisitor):
+    """
+    walk on the project tree and resolve relationships.
+    
+    According to options the following attributes may be added to visited nodes:
+    
+    * uid,
+      a unique identifier for the node (on astroid.Project, astroid.Module,
+      astroid.Class and astroid.locals_type). Only if the linker has been instantiated
+      with tag=True parameter (False by default).
+            
+    * Function
+      a mapping from locals names to their bounded value, which may be a
+      constant like a string or an integer, or an astroid node (on astroid.Module,
+      astroid.Class and astroid.Function).
+
+    * instance_attrs_type
+      as locals_type but for klass member attributes (only on astroid.Class)
+      
+    * implements,
+      list of implemented interface _objects_ (only on astroid.Class nodes)
+    """
+    
+    def __init__(self, project, inherited_interfaces=0, tag=False):
+        IdGeneratorMixIn.__init__(self)
+        LocalsVisitor.__init__(self)
+        # take inherited interface in consideration or not
+        self.inherited_interfaces = inherited_interfaces
+        # tag nodes or not
+        self.tag = tag
+        # visited project
+        self.project = project
+
+        
+    def visit_project(self, node):
+        """visit an astroid.Project node
+        
+         * optionally tag the node with a unique id
+        """
+        if self.tag:
+            node.uid = self.generate_id()
+        for module in node.modules:
+            self.visit(module)
+            
+    def visit_package(self, node):
+        """visit an astroid.Package node
+        
+         * optionally tag the node with a unique id
+        """
+        if self.tag:
+            node.uid = self.generate_id()
+        for subelmt in node.values():
+            self.visit(subelmt)
+            
+    def visit_module(self, node):
+        """visit an astroid.Module node
+        
+         * set the locals_type mapping
+         * set the depends mapping
+         * optionally tag the node with a unique id
+        """
+        if hasattr(node, 'locals_type'):
+            return
+        node.locals_type = {}
+        node.depends = []
+        if self.tag:
+            node.uid = self.generate_id()
+    
+    def visit_class(self, node):
+        """visit an astroid.Class node
+        
+         * set the locals_type and instance_attrs_type mappings
+         * set the implements list and build it
+         * optionally tag the node with a unique id
+        """
+        if hasattr(node, 'locals_type'):
+            return
+        node.locals_type = {}
+        if self.tag:
+            node.uid = self.generate_id()
+        # resolve ancestors
+        for baseobj in node.ancestors(recurs=False):
+            specializations = getattr(baseobj, 'specializations', [])
+            specializations.append(node)
+            baseobj.specializations = specializations
+        # resolve instance attributes
+        node.instance_attrs_type = {}
+        for assattrs in node.instance_attrs.values():
+            for assattr in assattrs:
+                self.handle_assattr_type(assattr, node)
+        # resolve implemented interface
+        try:
+            node.implements = list(node.interfaces(self.inherited_interfaces))
+        except InferenceError:
+            node.implements = ()
+
+    def visit_function(self, node):
+        """visit an astroid.Function node
+        
+         * set the locals_type mapping
+         * optionally tag the node with a unique id
+        """
+        if hasattr(node, 'locals_type'):
+            return
+        node.locals_type = {}
+        if self.tag:
+            node.uid = self.generate_id()
+            
+    link_project = visit_project
+    link_module = visit_module
+    link_class = visit_class
+    link_function = visit_function
+        
+    def visit_assname(self, node):
+        """visit an astroid.AssName node
+
+        handle locals_type
+        """
+        # avoid double parsing done by different Linkers.visit
+        # running over the same project:
+        if hasattr(node, '_handled'):
+            return
+        node._handled = True
+        if node.name in node.frame():
+            frame = node.frame()
+        else:
+            # the name has been defined as 'global' in the frame and belongs
+            # there. Btw the frame is not yet visited as the name is in the 
+            # root locals; the frame hence has no locals_type attribute
+            frame = node.root()
+        try:
+            values = node.infered()
+            try:
+                already_infered = frame.locals_type[node.name]
+                for valnode in values:
+                    if not valnode in already_infered:
+                        already_infered.append(valnode)
+            except KeyError:
+                frame.locals_type[node.name] = values
+        except astroid.InferenceError:
+            pass
+
+    def handle_assattr_type(self, node, parent):
+        """handle an astroid.AssAttr node
+
+        handle instance_attrs_type
+        """
+        try:
+            values = list(node.infer())
+            try:
+                already_infered = parent.instance_attrs_type[node.attrname]
+                for valnode in values:
+                    if not valnode in already_infered:
+                        already_infered.append(valnode)
+            except KeyError:
+                parent.instance_attrs_type[node.attrname] = values
+        except astroid.InferenceError:
+            pass
+            
+    def visit_import(self, node):
+        """visit an astroid.Import node
+        
+        resolve module dependencies
+        """
+        context_file = node.root().file
+        for name in node.names:
+            relative = is_relative(name[0], context_file)
+            self._imported_module(node, name[0], relative)
+        
+
+    def visit_from(self, node):
+        """visit an astroid.From node
+        
+        resolve module dependencies
+        """
+        basename = node.modname
+        context_file = node.root().file
+        if context_file is not None:
+            relative = is_relative(basename, context_file)
+        else:
+            relative = False
+        for name in node.names:
+            if name[0] == '*':
+                continue
+            # analyze dependencies
+            fullname = '%s.%s' % (basename, name[0])
+            if fullname.find('.') > -1:
+                try:
+                    # XXX: don't use get_module_part, missing package precedence
+                    fullname = get_module_part(fullname, context_file)
+                except ImportError:
+                    continue
+            if fullname != basename:
+                self._imported_module(node, fullname, relative)
+
+        
+    def compute_module(self, context_name, mod_path):
+        """return true if the module should be added to dependencies"""
+        package_dir = dirname(self.project.path)
+        if context_name == mod_path:
+            return 0
+        elif is_standard_module(mod_path, (package_dir,)):
+            return 1
+        return 0
+    
+    # protected methods ########################################################
+
+    def _imported_module(self, node, mod_path, relative):
+        """notify an imported module, used to analyze dependencies
+        """
+        module = node.root()
+        context_name = module.name
+        if relative:
+            mod_path = '%s.%s' % ('.'.join(context_name.split('.')[:-1]),
+                                  mod_path)
+        if self.compute_module(context_name, mod_path):
+            # handle dependencies
+            if not hasattr(module, 'depends'):
+                module.depends = []
+            mod_paths = module.depends
+            if not mod_path in mod_paths:
+                mod_paths.append(mod_path)

data/vendor/python/astroid/manager.py

@@ -0,0 +1,336 @@
+# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of astroid.
+#
+# astroid 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.
+#
+# astroid 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 astroid. If not, see <http://www.gnu.org/licenses/>.
+"""astroid manager: avoid multiple astroid build of a same module when
+possible by providing a class responsible to get astroid representation
+from various source and using a cache of built modules)
+"""
+
+__docformat__ = "restructuredtext en"
+
+import os
+from os.path import dirname, join, isdir, exists
+
+from logilab.common.modutils import NoSourceFile, is_python_source, \
+     file_from_modpath, load_module_from_name, modpath_from_file, \
+     get_module_files, get_source_file, zipimport
+from logilab.common.configuration import OptionsProviderMixIn
+
+from astroid.exceptions import AstroidBuildingException
+
+def astroid_wrapper(func, modname):
+    """wrapper to give to AstroidManager.project_from_files"""
+    print 'parsing %s...' % modname
+    try:
+        return func(modname)
+    except AstroidBuildingException, exc:
+        print exc
+    except Exception, exc:
+        import traceback
+        traceback.print_exc()
+
+def _silent_no_wrap(func, modname):
+    """silent wrapper that doesn't do anything; can be used for tests"""
+    return func(modname)
+
+def safe_repr(obj):
+    try:
+        return repr(obj)
+    except:
+        return '???'
+
+
+
+class AstroidManager(OptionsProviderMixIn):
+    """the astroid manager, responsible to build astroid from files
+     or modules.
+
+    Use the Borg pattern.
+    """
+
+    name = 'astroid loader'
+    options = (("ignore",
+                {'type' : "csv", 'metavar' : "<file>",
+                 'dest' : "black_list", "default" : ('CVS',),
+                 'help' : "add <file> (may be a directory) to the black list\
+. It should be a base name, not a path. You may set this option multiple times\
+."}),
+               ("project",
+                {'default': "No Name", 'type' : 'string', 'short': 'p',
+                 'metavar' : '<project name>',
+                 'help' : 'set the project name.'}),
+               )
+    brain = {}
+    def __init__(self):
+        self.__dict__ = AstroidManager.brain
+        if not self.__dict__:
+            OptionsProviderMixIn.__init__(self)
+            self.load_defaults()
+            # NOTE: cache entries are added by the [re]builder
+            self.astroid_cache = {}
+            self._mod_file_cache = {}
+            self.transforms = {}
+
+    def ast_from_file(self, filepath, modname=None, fallback=True, source=False):
+        """given a module name, return the astroid object"""
+        try:
+            filepath = get_source_file(filepath, include_no_ext=True)
+            source = True
+        except NoSourceFile:
+            pass
+        if modname is None:
+            try:
+                modname = '.'.join(modpath_from_file(filepath))
+            except ImportError:
+                modname = filepath
+        if modname in self.astroid_cache and self.astroid_cache[modname].file == filepath:
+            return self.astroid_cache[modname]
+        if source:
+            from astroid.builder import AstroidBuilder
+            return AstroidBuilder(self).file_build(filepath, modname)
+        elif fallback and modname:
+            return self.ast_from_module_name(modname)
+        raise AstroidBuildingException('unable to get astroid for file %s' %
+                                     filepath)
+
+    def ast_from_module_name(self, modname, context_file=None):
+        """given a module name, return the astroid object"""
+        if modname in self.astroid_cache:
+            return self.astroid_cache[modname]
+        if modname == '__main__':
+            from astroid.builder import AstroidBuilder
+            return AstroidBuilder(self).string_build('', modname)
+        old_cwd = os.getcwd()
+        if context_file:
+            os.chdir(dirname(context_file))
+        try:
+            filepath = self.file_from_module_name(modname, context_file)
+            if filepath is not None and not is_python_source(filepath):
+                module = self.zip_import_data(filepath)
+                if module is not None:
+                    return module
+            if filepath is None or not is_python_source(filepath):
+                try:
+                    module = load_module_from_name(modname)
+                except Exception, ex:
+                    msg = 'Unable to load module %s (%s)' % (modname, ex)
+                    raise AstroidBuildingException(msg)
+                return self.ast_from_module(module, modname)
+            return self.ast_from_file(filepath, modname, fallback=False)
+        finally:
+            os.chdir(old_cwd)
+
+    def zip_import_data(self, filepath):
+        if zipimport is None:
+            return None
+        from astroid.builder import AstroidBuilder
+        builder = AstroidBuilder(self)
+        for ext in ('.zip', '.egg'):
+            try:
+                eggpath, resource = filepath.rsplit(ext + '/', 1)
+            except ValueError:
+                continue
+            try:
+                importer = zipimport.zipimporter(eggpath + ext)
+                zmodname = resource.replace('/', '.')
+                if importer.is_package(resource):
+                    zmodname =  zmodname + '.__init__'
+                module = builder.string_build(importer.get_source(resource),
+                                              zmodname, filepath)
+                return module
+            except:
+                continue
+        return None
+
+    def file_from_module_name(self, modname, contextfile):
+        try:
+            value = self._mod_file_cache[(modname, contextfile)]
+        except KeyError:
+            try:
+                value = file_from_modpath(modname.split('.'),
+                                          context_file=contextfile)
+            except ImportError, ex:
+                msg = 'Unable to load module %s (%s)' % (modname, ex)
+                value = AstroidBuildingException(msg)
+            self._mod_file_cache[(modname, contextfile)] = value
+        if isinstance(value, AstroidBuildingException):
+            raise value
+        return value
+
+    def ast_from_module(self, module, modname=None):
+        """given an imported module, return the astroid object"""
+        modname = modname or module.__name__
+        if modname in self.astroid_cache:
+            return self.astroid_cache[modname]
+        try:
+            # some builtin modules don't have __file__ attribute
+            filepath = module.__file__
+            if is_python_source(filepath):
+                return self.ast_from_file(filepath, modname)
+        except AttributeError:
+            pass
+        from astroid.builder import AstroidBuilder
+        return AstroidBuilder(self).module_build(module, modname)
+
+    def ast_from_class(self, klass, modname=None):
+        """get astroid for the given class"""
+        if modname is None:
+            try:
+                modname = klass.__module__
+            except AttributeError:
+                raise AstroidBuildingException(
+                    'Unable to get module for class %s' % safe_repr(klass))
+        modastroid = self.ast_from_module_name(modname)
+        return modastroid.getattr(klass.__name__)[0] # XXX
+
+
+    def infer_ast_from_something(self, obj, context=None):
+        """infer astroid for the given class"""
+        if hasattr(obj, '__class__') and not isinstance(obj, type):
+            klass = obj.__class__
+        else:
+            klass = obj
+        try:
+            modname = klass.__module__
+        except AttributeError:
+            raise AstroidBuildingException(
+                'Unable to get module for %s' % safe_repr(klass))
+        except Exception, ex:
+            raise AstroidBuildingException(
+                'Unexpected error while retrieving module for %s: %s'
+                % (safe_repr(klass), ex))
+        try:
+            name = klass.__name__
+        except AttributeError:
+            raise AstroidBuildingException(
+                'Unable to get name for %s' % safe_repr(klass))
+        except Exception, ex:
+            raise AstroidBuildingException(
+                'Unexpected error while retrieving name for %s: %s'
+                % (safe_repr(klass), ex))
+        # take care, on living object __module__ is regularly wrong :(
+        modastroid = self.ast_from_module_name(modname)
+        if klass is obj:
+            for  infered in modastroid.igetattr(name, context):
+                yield infered
+        else:
+            for infered in modastroid.igetattr(name, context):
+                yield infered.instanciate_class()
+
+    def project_from_files(self, files, func_wrapper=astroid_wrapper,
+                           project_name=None, black_list=None):
+        """return a Project from a list of files or modules"""
+        # build the project representation
+        project_name = project_name or self.config.project
+        black_list = black_list or self.config.black_list
+        project = Project(project_name)
+        for something in files:
+            if not exists(something):
+                fpath = file_from_modpath(something.split('.'))
+            elif isdir(something):
+                fpath = join(something, '__init__.py')
+            else:
+                fpath = something
+            astroid = func_wrapper(self.ast_from_file, fpath)
+            if astroid is None:
+                continue
+            # XXX why is first file defining the project.path ?
+            project.path = project.path or astroid.file
+            project.add_module(astroid)
+            base_name = astroid.name
+            # recurse in package except if __init__ was explicitly given
+            if astroid.package and something.find('__init__') == -1:
+                # recurse on others packages / modules if this is a package
+                for fpath in get_module_files(dirname(astroid.file),
+                                              black_list):
+                    astroid = func_wrapper(self.ast_from_file, fpath)
+                    if astroid is None or astroid.name == base_name:
+                        continue
+                    project.add_module(astroid)
+        return project
+
+    def register_transform(self, node_class, transform, predicate=None):
+        """Register `transform(node)` function to be applied on the given
+        Astroid's `node_class` if `predicate` is None or return a true value
+        when called with the node as argument.
+
+        The transform function may return a value which is then used to
+        substitute the original node in the tree.
+        """
+        self.transforms.setdefault(node_class, []).append( (transform, predicate) )
+
+    def unregister_transform(self, node_class, transform, predicate=None):
+        """Unregister the given transform."""
+        self.transforms[node_class].remove( (transform, predicate) )
+
+    def transform(self, node):
+        """Call matching transforms for the given node if any and return the
+        transformed node.
+        """
+        cls = node.__class__
+        if cls not in self.transforms:
+            # no transform registered for this class of node
+            return node
+
+        transforms = self.transforms[cls]
+        orig_node = node  # copy the reference
+        for transform_func, predicate in transforms:
+            if predicate is None or predicate(node):
+                ret = transform_func(node)
+                # if the transformation function returns something, it's
+                # expected to be a replacement for the node
+                if ret is not None:
+                    if node is not orig_node:
+                        # node has already be modified by some previous
+                        # transformation, warn about it
+                        warn('node %s substitued multiple times' % node)
+                    node = ret
+        return node
+
+    def cache_module(self, module):
+        """Cache a module if no module with the same name is known yet."""
+        self.astroid_cache.setdefault(module.name, module)
+
+
+class Project(object):
+    """a project handle a set of modules / packages"""
+    def __init__(self, name=''):
+        self.name = name
+        self.path = None
+        self.modules = []
+        self.locals = {}
+        self.__getitem__ = self.locals.__getitem__
+        self.__iter__ = self.locals.__iter__
+        self.values = self.locals.values
+        self.keys = self.locals.keys
+        self.items = self.locals.items
+
+    def add_module(self, node):
+        self.locals[node.name] = node
+        self.modules.append(node)
+
+    def get_module(self, name):
+        return self.locals[name]
+
+    def get_children(self):
+        return self.modules
+
+    def __repr__(self):
+        return '<Project %r at %s (%s modules)>' % (self.name, id(self),
+                                                    len(self.modules))
+
+