Revert "pylint: upgrade to 1.3.1"

This reverts commit e642ee86.

Conflicts:
	pylintrc

Reason:
	All repos are borked.

TBR=vapier

Review URL: https://codereview.chromium.org/741023003

git-svn-id: svn://svn.chromium.org/chrome/trunk/tools/depot_tools@293042 0039d316-1c4b-4281-b951-d872f2087c98

pylintrc

@@ -90,7 +90,7 @@ load-plugins=
 # unpacking-non-sequence
 # unused-import
 # useless-else-on-loop
-disable=C0103,C0111,C0302,I0010,I0011,R0801,R0901,R0902,R0903,R0904,R0911,R0912,R0913,R0914,R0915,R0921,R0922,W0122,W0141,W0142,W0402,W0404,W0511,W0603,W0703,W1201,bad-continuation,anomalous-backslash-in-string,bad-context-manager,bad-indentation,bad-str-strip-call,bad-whitespace,cell-var-from-loop,deprecated-lambda,eval-used,function-redefined,import-error,locally-enabled,missing-final-newline,no-init,no-name-in-module,no-self-use,not-callable,old-style-class,protected-access,superfluous-parens,super-on-old-class,too-many-function-args,trailing-whitespace,unnecessary-semicolon,unpacking-non-sequence,unused-import,useless-else-on-loop
+disable=C0103,C0111,C0302,I0010,I0011,R0801,R0901,R0902,R0903,R0904,R0911,R0912,R0913,R0914,R0915,R0921,R0922,W0122,W0141,W0142,W0402,W0404,W0511,W0603,W0703,W1201
 
 
 [REPORTS]
@@ -99,6 +99,9 @@ disable=C0103,C0111,C0302,I0010,I0011,R0801,R0901,R0902,R0903,R0904,R0911,R0912,
 # (visual studio) and html
 output-format=text
 
+# Include message's id in output
+include-ids=yes
+
 # Put messages in a separate file for each module / package specified on the
 # command line instead of printing them on stdout. Reports (if any) will be
 # written in a file name "pylint_global.[txt|html]".

third_party/logilab/astroid/README.chromium → third_party/logilab/astng/README.chromium

 URL: http://www.logilab.org/project/logilab-astng
-Version: 1.2.1
+Version: 0.23.1
 License: GPL
 License File: LICENSE.txt
 

third_party/logilab/astroid/__init__.py → third_party/logilab/astng/__init__.py

-# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2011 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 astroid.
+# This file is part of logilab-astng.
 #
-# astroid is free software: you can redistribute it and/or modify it
+# 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.
 #
-# astroid is distributed in the hope that it will be useful, but
+# 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 astroid. If not, see <http://www.gnu.org/licenses/>.
+# with logilab-astng. If not, see <http://www.gnu.org/licenses/>.
 """Python Abstract Syntax Tree New Generation
 
 The aim of this module is to provide a common base representation of
@@ -25,7 +27,7 @@ governed by pylint's needs.
 It extends class defined in the python's _ast module with some
 additional methods and attributes. Instance attributes are added by a
 builder object, which can either generate extended ast (let's call
-them astroid ;) by visiting an existent ast tree or by inspecting living
+them astng ;) by visiting an existent ast tree or by inspecting living
 object. Methods are added by monkey patching ast classes.
 
 Main modules are:
@@ -33,86 +35,39 @@ Main modules are:
 * nodes and scoped_nodes for more information about methods and
   attributes added to different node classes
 
-* the manager contains a high level object to get astroid trees from
+* the manager contains a high level object to get astng trees from
   source files and living objects. It maintains a cache of previously
   constructed tree for quick access
 
-* builder contains the class responsible to build astroid trees
+* builder contains the class responsible to build astng trees
 """
 __doctype__ = "restructuredtext en"
 
 import sys
-import re
-from operator import attrgetter
+if sys.version_info >= (3, 0):
+    BUILTINS_MODULE = 'builtins'
+else:
+    BUILTINS_MODULE = '__builtin__'
 
 # WARNING: internal imports order matters !
 
-# make all exception classes accessible from astroid package
-from astroid.exceptions import *
+# make all exception classes accessible from astng package
+from logilab.astng.exceptions import *
 
-# make all node classes accessible from astroid package
-from astroid.nodes import *
+# make all node classes accessible from astng package
+from logilab.astng.nodes import *
 
 # trigger extra monkey-patching
-from astroid import inference
+from logilab.astng import inference
 
 # more stuff available
-from astroid import raw_building
-from astroid.bases import YES, Instance, BoundMethod, UnboundMethod
-from astroid.node_classes import are_exclusive, unpack_infer
-from astroid.scoped_nodes import builtin_lookup
+from logilab.astng import raw_building
+from logilab.astng.bases import YES, Instance, BoundMethod, UnboundMethod
+from logilab.astng.node_classes import are_exclusive, unpack_infer
+from logilab.astng.scoped_nodes import builtin_lookup
 
 # make a manager instance (borg) as well as Project and Package classes
-# accessible from astroid package
-from astroid.manager import AstroidManager, Project
-MANAGER = AstroidManager()
-del AstroidManager
-
-# transform utilities (filters and decorator)
-
-class AsStringRegexpPredicate(object):
-    """Class to be used as predicate that may be given to `register_transform`
-
-    First argument is a regular expression that will be searched against the `as_string`
-    representation of the node onto which it's applied.
-
-    If specified, the second argument is an `attrgetter` expression that will be
-    applied on the node first to get the actual node on which `as_string` should
-    be called.
-    """
-    def __init__(self, regexp, expression=None):
-        self.regexp = re.compile(regexp)
-        self.expression = expression
-
-    def __call__(self, node):
-        if self.expression is not None:
-            node = attrgetter(self.expression)(node)
-        return self.regexp.search(node.as_string())
-
-def inference_tip(infer_function):
-    """Given an instance specific inference function, return a function to be
-    given to MANAGER.register_transform to set this inference function.
-
-    Typical usage
-
-    .. sourcecode:: python
-
-       MANAGER.register_transform(CallFunc, inference_tip(infer_named_tuple),
-                                  AsStringRegexpPredicate('namedtuple', 'func'))
-    """
-    def transform(node, infer_function=infer_function):
-        node._explicit_inference = infer_function
-        return node
-    return transform
-
-# load brain plugins
-from os import listdir
-from os.path import join, dirname
-BRAIN_MODULES_DIR = join(dirname(__file__), 'brain')
-if BRAIN_MODULES_DIR not in sys.path:
-    # add it to the end of the list so user path take precedence
-    sys.path.append(BRAIN_MODULES_DIR)
-# load modules in this directory
-for module in listdir(BRAIN_MODULES_DIR):
-    if module.endswith('.py'):
-        __import__(module[:-3])
+# accessible from astng package
+from logilab.astng.manager import ASTNGManager, Project
+MANAGER = ASTNGManager()
+del ASTNGManager

third_party/logilab/astroid/__pkginfo__.py → third_party/logilab/astng/__pkginfo__.py

-# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2011 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 astroid.
+# This file is part of logilab-astng.
 #
-# astroid is free software: you can redistribute it and/or modify it
+# 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.
 #
-# astroid is distributed in the hope that it will be useful, but
+# 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 astroid. If not, see <http://www.gnu.org/licenses/>.
-"""astroid packaging information"""
+# with logilab-astng. If not, see <http://www.gnu.org/licenses/>.
+"""logilab.astng packaging information"""
 
-distname = 'astroid'
+distname = 'logilab-astng'
 
-modname = 'astroid'
+modname = 'astng'
+subpackage_of = 'logilab'
 
-numversion = (1, 2, 1)
+numversion = (0, 23, 1)
 version = '.'.join([str(num) for num in numversion])
 
-install_requires = ['logilab-common >= 0.60.0']
+install_requires = ['logilab-common >= 0.53.0']
 
 license = 'LGPL'
 
 author = 'Logilab'
 author_email = 'python-projects@lists.logilab.org'
 mailinglist = "mailto://%s" % author_email
-web = 'http://bitbucket.org/logilab/astroid'
+web = "http://www.logilab.org/project/%s" % distname
+ftp = "ftp://ftp.logilab.org/pub/%s" % modname
 
 description = "rebuild a new abstract syntax tree from Python's ast"
 
 from os.path import join
-include_dirs = ['brain',
-                join('test', 'regrtest_data'),
-                join('test', 'data'), join('test', 'data2')
-               ]
-
-classifiers = ["Topic :: Software Development :: Libraries :: Python Modules",
-               "Topic :: Software Development :: Quality Assurance",
-               "Programming Language :: Python",
-               "Programming Language :: Python :: 2",
-               "Programming Language :: Python :: 3",
-              ]
+include_dirs = [join('test', 'regrtest_data'),
+                join('test', 'data'), join('test', 'data2')]

third_party/logilab/astroid/builder.py → third_party/logilab/astng/builder.py

-# copyright 2003-2014 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2011 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 astroid.
+# This file is part of logilab-astng.
 #
-# astroid is free software: you can redistribute it and/or modify it
+# 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.
 #
-# astroid is distributed in the hope that it will be useful, but
+# 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 astroid. If not, see <http://www.gnu.org/licenses/>.
-"""The AstroidBuilder makes astroid from living object and / or from _ast
+# with logilab-astng. If not, see <http://www.gnu.org/licenses/>.
+"""The ASTNGBuilder makes astng from living object and / or from _ast
 
 The builder is not thread safe and can't be used to parse different sources
 at the same time.
 """
-from __future__ import with_statement
 
 __docformat__ = "restructuredtext en"
 
-import sys
-from os.path import splitext, basename, exists, abspath
+import sys, re
+from os.path import splitext, basename, dirname, exists, abspath
 
-from astroid.exceptions import AstroidBuildingException, InferenceError
-from astroid.raw_building import InspectBuilder
-from astroid.rebuilder import TreeRebuilder
-from astroid.manager import AstroidManager
-from astroid.bases import YES, Instance
-from astroid.modutils import modpath_from_file
+from logilab.common.modutils import modpath_from_file
+
+from logilab.astng.exceptions import ASTNGBuildingException, InferenceError
+from logilab.astng.raw_building import InspectBuilder
+from logilab.astng.rebuilder import TreeRebuilder
+from logilab.astng.manager import ASTNGManager
+from logilab.astng.bases import YES, Instance
 
 from _ast import PyCF_ONLY_AST
 def parse(string):
@@ -42,21 +44,21 @@ if sys.version_info >= (3, 0):
     from tokenize import detect_encoding
 
     def open_source_file(filename):
-        with open(filename, 'rb') as byte_stream:
-            encoding = detect_encoding(byte_stream.readline)[0]
-        stream = open(filename, 'rU', encoding=encoding)
+        byte_stream = open(filename, 'bU')
+        encoding = detect_encoding(byte_stream.readline)[0]
+        stream = open(filename, 'U', encoding=encoding)
         try:
             data = stream.read()
-        except UnicodeError: # wrong encodingg
+        except UnicodeError, uex: # wrong encodingg
             # detect_encoding returns utf-8 if no encoding specified
             msg = 'Wrong (%s) or no encoding specified' % encoding
-            raise AstroidBuildingException(msg)
+            raise ASTNGBuildingException(msg)
         return stream, encoding, data
 
 else:
     import re
 
-    _ENCODING_RGX = re.compile(r"\s*#+.*coding[:=]\s*([-\w.]+)")
+    _ENCODING_RGX = re.compile("\s*#+.*coding[:=]\s*([-\w.]+)")
 
     def _guess_encoding(string):
         """get encoding from a python file as string or return None if not found
@@ -79,17 +81,17 @@ else:
 
 # ast NG builder ##############################################################
 
-MANAGER = AstroidManager()
+MANAGER = ASTNGManager()
 
-class AstroidBuilder(InspectBuilder):
-    """provide astroid building methods"""
+class ASTNGBuilder(InspectBuilder):
+    """provide astng building methods"""
+    rebuilder = TreeRebuilder()
 
     def __init__(self, manager=None):
-        InspectBuilder.__init__(self)
         self._manager = manager or MANAGER
 
     def module_build(self, module, modname=None):
-        """build an astroid from a living module instance
+        """build an astng from a living module instance
         """
         node = None
         path = getattr(module, '__file__', None)
@@ -101,59 +103,46 @@ class AstroidBuilder(InspectBuilder):
             # this is a built-in module
             # get a partial representation by introspection
             node = self.inspect_build(module, modname=modname, path=path)
-            # we have to handle transformation by ourselves since the rebuilder
-            # isn't called for builtin nodes
-            #
-            # XXX it's then only called for Module nodes, not for underlying
-            # nodes
-            node = self._manager.transform(node)
         return node
 
     def file_build(self, path, modname=None):
-        """build astroid from a source code file (i.e. from an ast)
+        """build astng from a source code file (i.e. from an ast)
 
         path is expected to be a python source file
         """
         try:
-            _, encoding, data = open_source_file(path)
+            stream, encoding, data = open_source_file(path)
         except IOError, exc:
             msg = 'Unable to load file %r (%s)' % (path, exc)
-            raise AstroidBuildingException(msg)
+            raise ASTNGBuildingException(msg)
         except SyntaxError, exc: # py3k encoding specification error
-            raise AstroidBuildingException(exc)
+            raise ASTNGBuildingException(exc)
         except LookupError, exc: # unknown encoding
-            raise AstroidBuildingException(exc)
+            raise ASTNGBuildingException(exc)
         # get module name if necessary
         if modname is None:
             try:
                 modname = '.'.join(modpath_from_file(path))
             except ImportError:
                 modname = splitext(basename(path))[0]
-        # build astroid representation
-        module = self._data_build(data, modname, path)
-        return self._post_build(module, encoding)
+        # build astng representation
+        node = self.string_build(data, modname, path)
+        node.file_encoding = encoding
+        return node
 
     def string_build(self, data, modname='', path=None):
-        """build astroid from source code string and return rebuilded astroid"""
+        """build astng from source code string and return rebuilded astng"""
         module = self._data_build(data, modname, path)
-        module.file_bytes = data.encode('utf-8')
-        return self._post_build(module, 'utf-8')
-
-    def _post_build(self, module, encoding):
-        """handles encoding and delayed nodes
-        after a module has been built
-        """
-        module.file_encoding = encoding
-        self._manager.cache_module(module)
+        self._manager.astng_cache[module.name] = module
         # post tree building steps after we stored the module in the cache:
         for from_node in module._from_nodes:
-            if from_node.modname == '__future__':
-                for symbol, _ in from_node.names:
-                    module.future_imports.add(symbol)
             self.add_from_names_to_locals(from_node)
         # handle delayed assattr nodes
         for delayed in module._delayed_assattr:
             self.delayed_assattr(delayed)
+        if modname:
+            for transformer in self._manager.transformers:
+                transformer(module)
         return module
 
     def _data_build(self, data, modname, path):
@@ -169,11 +158,11 @@ class AstroidBuilder(InspectBuilder):
             package = True
         else:
             package = path and path.find('__init__.py') > -1 or False
-        rebuilder = TreeRebuilder(self._manager)
-        module = rebuilder.visit_module(node, modname, package)
+        self.rebuilder.init()
+        module = self.rebuilder.visit_module(node, modname, package)
         module.file = module.path = node_file
-        module._from_nodes = rebuilder._from_nodes
-        module._delayed_assattr = rebuilder._delayed_assattr
+        module._from_nodes = self.rebuilder._from_nodes
+        module._delayed_assattr = self.rebuilder._delayed_assattr
         return module
 
     def add_from_names_to_locals(self, node):
@@ -187,8 +176,8 @@ class AstroidBuilder(InspectBuilder):
         for (name, asname) in node.names:
             if name == '*':
                 try:
-                    imported = node.do_import_module()
-                except InferenceError:
+                    imported = node.root().import_module(node.modname)
+                except ASTNGBuildingException:
                     continue
                 for name in imported.wildcard_import_names():
                     node.parent.set_local(name, node)

third_party/logilab/astroid/exceptions.py → third_party/logilab/astng/exceptions.py

-# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# 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 astroid.
+# This file is part of logilab-astng.
 #
-# astroid is free software: you can redistribute it and/or modify it
+# 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.
 #
-# astroid is distributed in the hope that it will be useful, but
+# 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 astroid. If not, see <http://www.gnu.org/licenses/>.
-"""this module contains exceptions used in the astroid library
+# with logilab-astng. If not, see <http://www.gnu.org/licenses/>.
+"""this module contains exceptions used in the astng library
 
 """
 
 __doctype__ = "restructuredtext en"
 
-class AstroidError(Exception):
-    """base exception class for all astroid related exceptions"""
+class ASTNGError(Exception):
+    """base exception class for all astng related exceptions"""
 
-class AstroidBuildingException(AstroidError):
-    """exception class when we are unable to build an astroid representation"""
+class ASTNGBuildingException(ASTNGError):
+    """exception class when we are unable to build an astng representation"""
 
-class ResolveError(AstroidError):
-    """base class of astroid resolution/inference error"""
+class ResolveError(ASTNGError):
+    """base class of astng resolution/inference error"""
 
 class NotFoundError(ResolveError):
     """raised when we are unable to resolve a name"""
@@ -36,15 +50,10 @@ class NotFoundError(ResolveError):
 class InferenceError(ResolveError):
     """raised when we are unable to infer a node"""
 
-class UseInferenceDefault(Exception):
-    """exception to be raised in custom inference function to indicate that it
-    should go back to the default behaviour
-    """
-
 class UnresolvableName(InferenceError):
     """raised when we are unable to resolve a name"""
 
-class NoDefault(AstroidError):
+class NoDefault(ASTNGError):
     """raised by function's `default_value` method when an argument has
     no default value
     """

third_party/logilab/astroid/inspector.py → third_party/logilab/astng/inspector.py

-# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# 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 astroid.
+# This file is part of logilab-astng.
 #
-# astroid is free software: you can redistribute it and/or modify it
+# 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.
 #
-# astroid is distributed in the hope that it will be useful, but
+# 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 astroid. If not, see <http://www.gnu.org/licenses/>.
-"""visitor doing some postprocessing on the astroid tree.
+# with logilab-astng. If not, see <http://www.gnu.org/licenses/>.
+"""visitor doing some postprocessing on the astng tree.
 Try to resolve definitions (namespace) dictionary, relationship...
 
 This module has been imported from pyreverse
@@ -25,23 +39,25 @@ __docformat__ = "restructuredtext en"
 
 from os.path import dirname
 
-import astroid
-from astroid.exceptions import InferenceError
-from astroid.utils import LocalsVisitor
-from astroid.modutils import get_module_part, is_relative, is_standard_module
+from logilab.common.modutils import get_module_part, is_relative, \
+     is_standard_module
 
-class IdGeneratorMixIn(object):
+from logilab import astng
+from logilab.astng.exceptions import InferenceError
+from logilab.astng.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
         """
@@ -52,26 +68,26 @@ class IdGeneratorMixIn(object):
 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
+      a unique identifier for the node (on astng.Project, astng.Module,
+      astng.Class and astng.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).
+      constant like a string or an integer, or an astng node (on astng.Module,
+      astng.Class and astng.Function).
 
     * instance_attrs_type
-      as locals_type but for klass member attributes (only on astroid.Class)
-
+      as locals_type but for klass member attributes (only on astng.Class)
+      
     * implements,
-      list of implemented interface _objects_ (only on astroid.Class nodes)
+      list of implemented interface _objects_ (only on astng.Class nodes)
     """
-
+    
     def __init__(self, project, inherited_interfaces=0, tag=False):
         IdGeneratorMixIn.__init__(self)
         LocalsVisitor.__init__(self)
@@ -82,30 +98,30 @@ class Linker(IdGeneratorMixIn, LocalsVisitor):
         # visited project
         self.project = project
 
-
+        
     def visit_project(self, node):
-        """visit an astroid.Project node
-
+        """visit an astng.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
-
+        """visit an astng.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
-
+        """visit an astng.Module node
+        
          * set the locals_type mapping
          * set the depends mapping
          * optionally tag the node with a unique id
@@ -116,10 +132,10 @@ class Linker(IdGeneratorMixIn, LocalsVisitor):
         node.depends = []
         if self.tag:
             node.uid = self.generate_id()
-
+    
     def visit_class(self, node):
-        """visit an astroid.Class node
-
+        """visit an astng.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
@@ -146,8 +162,8 @@ class Linker(IdGeneratorMixIn, LocalsVisitor):
             node.implements = ()
 
     def visit_function(self, node):
-        """visit an astroid.Function node
-
+        """visit an astng.Function node
+        
          * set the locals_type mapping
          * optionally tag the node with a unique id
         """
@@ -156,14 +172,14 @@ class Linker(IdGeneratorMixIn, LocalsVisitor):
         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
+        """visit an astng.AssName node
 
         handle locals_type
         """
@@ -176,7 +192,7 @@ class Linker(IdGeneratorMixIn, LocalsVisitor):
             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
+            # 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:
@@ -188,11 +204,11 @@ class Linker(IdGeneratorMixIn, LocalsVisitor):
                         already_infered.append(valnode)
             except KeyError:
                 frame.locals_type[node.name] = values
-        except astroid.InferenceError:
+        except astng.InferenceError:
             pass
 
     def handle_assattr_type(self, node, parent):
-        """handle an astroid.AssAttr node
+        """handle an astng.AssAttr node
 
         handle instance_attrs_type
         """
@@ -205,23 +221,23 @@ class Linker(IdGeneratorMixIn, LocalsVisitor):
                         already_infered.append(valnode)
             except KeyError:
                 parent.instance_attrs_type[node.attrname] = values
-        except astroid.InferenceError:
+        except astng.InferenceError:
             pass
-
+            
     def visit_import(self, node):
-        """visit an astroid.Import node
-
+        """visit an astng.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
-
+        """visit an astng.From node
+        
         resolve module dependencies
         """
         basename = node.modname
@@ -238,13 +254,13 @@ class Linker(IdGeneratorMixIn, LocalsVisitor):
             if fullname.find('.') > -1:
                 try:
                     # XXX: don't use get_module_part, missing package precedence
-                    fullname = get_module_part(fullname, context_file)
+                    fullname = get_module_part(fullname)
                 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)
@@ -253,7 +269,7 @@ class Linker(IdGeneratorMixIn, LocalsVisitor):
         elif is_standard_module(mod_path, (package_dir,)):
             return 1
         return 0
-
+    
     # protected methods ########################################################
 
     def _imported_module(self, node, mod_path, relative):

third_party/logilab/astroid/mixins.py → third_party/logilab/astng/mixins.py

-# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# 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 astroid.
+# This file is part of logilab-astng.
 #
-# astroid is free software: you can redistribute it and/or modify it
+# 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.
 #
-# astroid is distributed in the hope that it will be useful, but
+# 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 astroid. If not, see <http://www.gnu.org/licenses/>.
+# with logilab-astng. If not, see <http://www.gnu.org/licenses/>.
 """This module contains some mixins for the different nodes.
 """
 
-from astroid.exceptions import (AstroidBuildingException, InferenceError,
-                                NotFoundError)
+from logilab.astng.exceptions import (ASTNGBuildingException, InferenceError,
+                                      NotFoundError)
 
 
 class BlockRangeMixIn(object):
@@ -41,7 +55,6 @@ class BlockRangeMixIn(object):
             return lineno, orelse[0].fromlineno - 1
         return lineno, last or self.tolineno
 
-
 class FilterStmtsMixin(object):
     """Mixin for statement filtering and assignment type"""
 
@@ -79,13 +92,14 @@ class ParentAssignTypeMixin(AssignTypeMixin):
         return self.parent.ass_type()
 
 
+
 class FromImportMixIn(FilterStmtsMixin):
     """MixIn for From and Import Nodes"""
 
     def _infer_name(self, frame, name):
         return name
 
-    def do_import_module(self, modname=None):
+    def do_import_module(self, modname):
         """return the ast for a module whose name is <modname> imported by <self>
         """
         # handle special case where we are on a package node importing a module
@@ -94,8 +108,6 @@ class FromImportMixIn(FilterStmtsMixin):
         # XXX: no more needed ?
         mymodule = self.root()
         level = getattr(self, 'level', None) # Import as no level
-        if modname is None:
-            modname = self.modname
         # XXX we should investigate deeper if we really want to check
         # importing itself: modname and mymodule.name be relative or absolute
         if mymodule.relative_to_absolute_name(modname, level) == mymodule.name:
@@ -103,7 +115,7 @@ class FromImportMixIn(FilterStmtsMixin):
             return mymodule
         try:
             return mymodule.import_module(modname, level=level)
-        except AstroidBuildingException:
+        except ASTNGBuildingException:
             raise InferenceError(modname)
         except SyntaxError, ex:
             raise InferenceError(str(ex))
@@ -120,3 +132,5 @@ class FromImportMixIn(FilterStmtsMixin):
                 return name
         raise NotFoundError(asname)
 
+
+

third_party/logilab/astroid/nodes.py → third_party/logilab/astng/nodes.py

-# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2011 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 astroid.
+# This file is part of logilab-astng.
 #
-# astroid is free software: you can redistribute it and/or modify it
+# 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.
 #
-# astroid is distributed in the hope that it will be useful, but
+# 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 astroid. If not, see <http://www.gnu.org/licenses/>.
+# with logilab-astng. If not, see <http://www.gnu.org/licenses/>.
 """
 on all nodes :
  .is_statement, returning true if the node should be considered as a
@@ -26,7 +28,7 @@ on all nodes :
  .frame(), returning the first node defining a new local scope (i.e.
   Module, Function or Class)
  .set_local(name, node), define an identifier <name> on the first parent frame,
-  with the node defining it. This is used by the astroid builder and should not
+  with the node defining it. This is used by the astng builder and should not
   be used from out there.
 
 on From and Import :
@@ -37,15 +39,15 @@ on From and Import :
 
 __docformat__ = "restructuredtext en"
 
-from astroid.node_classes import Arguments, AssAttr, Assert, Assign, \
+from logilab.astng.node_classes import Arguments, AssAttr, Assert, Assign, \
     AssName, AugAssign, Backquote, BinOp, BoolOp, Break, CallFunc, Compare, \
     Comprehension, Const, Continue, Decorators, DelAttr, DelName, Delete, \
     Dict, Discard, Ellipsis, EmptyNode, ExceptHandler, Exec, ExtSlice, For, \
     From, Getattr, Global, If, IfExp, Import, Index, Keyword, \
     List, Name, Nonlocal, Pass, Print, Raise, Return, Set, Slice, Starred, Subscript, \
-    TryExcept, TryFinally, Tuple, UnaryOp, While, With, Yield, YieldFrom, \
+    TryExcept, TryFinally, Tuple, UnaryOp, While, With, Yield, \
     const_factory
-from astroid.scoped_nodes import Module, GenExpr, Lambda, DictComp, \
+from logilab.astng.scoped_nodes import Module, GenExpr, Lambda, DictComp, \
     ListComp, SetComp, Function, Class
 
 ALL_NODE_CLASSES = (
@@ -68,6 +70,6 @@ ALL_NODE_CLASSES = (
     TryExcept, TryFinally, Tuple,
     UnaryOp,
     While, With,
-    Yield, YieldFrom
+    Yield,
     )
 

third_party/logilab/astroid/protocols.py → third_party/logilab/astng/protocols.py

-# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2011 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 astroid.
+# This file is part of logilab-astng.
 #
-# astroid is free software: you can redistribute it and/or modify it
+# 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.
 #
-# astroid is distributed in the hope that it will be useful, but
+# 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 astroid. If not, see <http://www.gnu.org/licenses/>.
+# 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.
 """
 
 __doctype__ = "restructuredtext en"
 
-from astroid.exceptions import InferenceError, NoDefault, NotFoundError
-from astroid.node_classes import unpack_infer
-from astroid.bases import copy_context, \
-     raise_if_nothing_infered, yes_if_nothing_infered, Instance, YES
-from astroid.nodes import const_factory
-from astroid import nodes
-
-BIN_OP_METHOD = {'+':  '__add__',
-                 '-':  '__sub__',
-                 '/':  '__div__',
-                 '//': '__floordiv__',
-                 '*':  '__mul__',
-                 '**': '__power__',
-                 '%':  '__mod__',
-                 '&':  '__and__',
-                 '|':  '__or__',
-                 '^':  '__xor__',
-                 '<<': '__lshift__',
-                 '>>': '__rshift__',
-                }
-
-UNARY_OP_METHOD = {'+': '__pos__',
-                   '-': '__neg__',
-                   '~': '__invert__',
-                   'not': None, # XXX not '__nonzero__'
-                  }
+from logilab.astng.exceptions 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 ############################################################
 
@@ -90,7 +72,7 @@ BIN_OP_IMPL = {'+':  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
 
@@ -153,25 +135,6 @@ def dict_infer_binary_op(self, operator, other, context):
         # XXX else log TypeError
 nodes.Dict.infer_binary_op = yes_if_nothing_infered(dict_infer_binary_op)
 
-def instance_infer_binary_op(self, operator, other, context):
-    try:
-        methods = self.getattr(BIN_OP_METHOD[operator])
-    except (NotFoundError, KeyError):
-        # Unknown operator
-        yield YES
-    else:
-        for method in methods:
-            if not isinstance(method, nodes.Function):
-                continue
-            for result in method.infer_call_result(self, context):
-                if result is not YES:
-                    yield result
-            # We are interested only in the first infered method,
-            # don't go looking in the rest of the methods of the ancestors.
-            break
-
-Instance.infer_binary_op = yes_if_nothing_infered(instance_infer_binary_op)
-
 
 # assignment ##################################################################
 
@@ -205,7 +168,7 @@ def _resolve_looppart(parts, asspath, context):
                 assigned = stmt.getitem(index, context)
             except (AttributeError, IndexError):
                 continue
-            except TypeError: # stmt is unsubscriptable Const
+            except TypeError, exc: # stmt is unsubscriptable Const
                 continue
             if not asspath:
                 # we achieved to resolved the assignment path,
@@ -270,14 +233,10 @@ def _arguments_infer_argname(self, name, context):
             yield self.parent.parent.frame()
             return
     if name == self.vararg:
-        vararg = const_factory(())
-        vararg.parent = self
-        yield vararg
+        yield const_factory(())
         return
     if name == self.kwarg:
-        kwarg = const_factory({})
-        kwarg.parent = self
-        yield 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
@@ -353,13 +312,10 @@ nodes.ExceptHandler.assigned_stmts = raise_if_nothing_infered(excepthandler_assi
 
 def with_assigned_stmts(self, node, context=None, asspath=None):
     if asspath is None:
-        for _, vars in self.items:
-            if vars is None:
-                continue
-            for lst in vars.infer(context):
-                if isinstance(lst, (nodes.Tuple, nodes.List)):
-                    for item in lst.nodes:
-                        yield item
+        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)
 
 

third_party/logilab/astroid/utils.py → third_party/logilab/astng/utils.py

-# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2011 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 astroid.
+# This file is part of logilab-astng.
 #
-# astroid is free software: you can redistribute it and/or modify it
+# 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.
 #
-# astroid is distributed in the hope that it will be useful, but
+# 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 astroid. If not, see <http://www.gnu.org/licenses/>.
+# 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 astroid.exceptions import AstroidBuildingException
-from astroid.builder import parse
+from logilab.astng.exceptions import ASTNGBuildingException
 
 
-class ASTWalker(object):
+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
@@ -98,7 +99,7 @@ class LocalsVisitor(ASTWalker):
         if methods[0] is not None:
             methods[0](node)
         if 'locals' in node.__dict__: # skip Instance and other proxy
-            for local_node in node.values():
+            for name, local_node in node.items():
                 self.visit(local_node)
         if methods[1] is not None:
             return methods[1](node)
@@ -112,25 +113,27 @@ def _check_children(node):
             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))
+            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)
+            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)
+            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 AstroidBuildingException
+            raise ASTNGBuildingException
         _check_children(child)
 
 
+from _ast import PyCF_ONLY_AST
+def parse(string):
+    return compile(string, "<string>", 'exec', PyCF_ONLY_AST)
+
 class TreeTester(object):
-    '''A helper class to see _ast tree and compare with astroid tree
+    '''A helper class to see _ast tree and compare with astng tree
 
     indent: string for tree indent representation
     lineno: bool to tell if we should print the line numbers
@@ -143,11 +146,11 @@ class TreeTester(object):
     .   <Print>
     .   .   nl = True
     .   ]
-    >>> print tester.astroid_tree_repr()
+    >>> print tester.astng_tree_repr()
     Module()
         body = [
         Print()
-            dest =
+            dest = 
             values = [
             ]
         ]
@@ -182,8 +185,8 @@ class TreeTester(object):
         if _done is None:
             _done = set()
         if node in _done:
-            self._string += '\nloop in tree: %r (%s)' % (
-                node, getattr(node, 'lineno', None))
+            self._string += '\nloop in tree: %r (%s)' % (node,
+                                            getattr(node, 'lineno', None))
             return
         _done.add(node)
         self._string += '\n' + indent +  '<%s>' % node.__class__.__name__
@@ -199,7 +202,7 @@ class TreeTester(object):
                     continue
                 if a in ("lineno", "col_offset") and not self.lineno:
                     continue
-                self._string += '\n' +  indent + a + " = " + repr(attr)
+                self._string +='\n' +  indent + a + " = " + repr(attr)
         for field in node._fields or ():
             attr = node_dict[field]
             if attr is None:
@@ -221,16 +224,16 @@ class TreeTester(object):
                 self._string += '\n' + indent + field + " = " + repr(attr)
 
 
-    def build_astroid_tree(self):
-        """build astroid tree from the _ast tree
+    def build_astng_tree(self):
+        """build astng tree from the _ast tree
         """
-        from astroid.builder import AstroidBuilder
-        tree = AstroidBuilder().string_build(self.sourcecode)
+        from logilab.astng.builder import ASTNGBuilder
+        tree = ASTNGBuilder().string_build(self.sourcecode)
         return tree
 
-    def astroid_tree_repr(self, ids=False):
-        """build the astroid tree and return a nice tree representation"""
-        mod = self.build_astroid_tree()
+    def astng_tree_repr(self, ids=False):
+        """build the astng tree and return a nice tree representation"""
+        mod = self.build_astng_tree()
         return mod.repr_tree(ids)
 
 

third_party/logilab/astroid/brain/py2gi.py

-"""Astroid hooks for the Python 2 GObject introspection bindings.
-
-Helps with understanding everything imported from 'gi.repository'
-"""
-
-import inspect
-import sys
-import re
-
-from astroid import MANAGER, AstroidBuildingException
-from astroid.builder import AstroidBuilder
-
-
-_inspected_modules = {}
-
-_identifier_re = r'^[A-Za-z_]\w*$'
-
-def _gi_build_stub(parent):
-    """
-    Inspect the passed module recursively and build stubs for functions,
-    classes, etc.
-    """
-    classes = {}
-    functions = {}
-    constants = {}
-    methods = {}
-    for name in dir(parent):
-        if name.startswith("__"):
-            continue
-
-        # Check if this is a valid name in python
-        if not re.match(_identifier_re, name):
-            continue
-
-        try:
-            obj = getattr(parent, name)
-        except:
-            continue
-
-        if inspect.isclass(obj):
-            classes[name] = obj
-        elif (inspect.isfunction(obj) or
-              inspect.isbuiltin(obj)):
-            functions[name] = obj
-        elif (inspect.ismethod(obj) or
-              inspect.ismethoddescriptor(obj)):
-            methods[name] = obj
-        elif type(obj) in [int, str]:
-            constants[name] = obj
-        elif (str(obj).startswith("<flags") or
-              str(obj).startswith("<enum ") or
-              str(obj).startswith("<GType ") or
-              inspect.isdatadescriptor(obj)):
-            constants[name] = 0
-        elif callable(obj):
-            # Fall back to a function for anything callable
-            functions[name] = obj
-        else:
-            # Assume everything else is some manner of constant
-            constants[name] = 0
-
-    ret = ""
-
-    if constants:
-        ret += "# %s contants\n\n" % parent.__name__
-    for name in sorted(constants):
-        if name[0].isdigit():
-            # GDK has some busted constant names like
-            # Gdk.EventType.2BUTTON_PRESS
-            continue
-
-        val = constants[name]
-
-        strval = str(val)
-        if type(val) is str:
-            strval = '"%s"' % str(val).replace("\\", "\\\\")
-        ret += "%s = %s\n" % (name, strval)
-
-    if ret:
-        ret += "\n\n"
-    if functions:
-        ret += "# %s functions\n\n" % parent.__name__
-    for name in sorted(functions):
-        func = functions[name]
-        ret += "def %s(*args, **kwargs):\n" % name
-        ret += "    pass\n"
-
-    if ret:
-        ret += "\n\n"
-    if methods:
-        ret += "# %s methods\n\n" % parent.__name__
-    for name in sorted(methods):
-        func = methods[name]
-        ret += "def %s(self, *args, **kwargs):\n" % name
-        ret += "    pass\n"
-
-    if ret:
-        ret += "\n\n"
-    if classes:
-        ret += "# %s classes\n\n" % parent.__name__
-    for name in sorted(classes):
-        ret += "class %s(object):\n" % name
-
-        classret = _gi_build_stub(classes[name])
-        if not classret:
-            classret = "pass\n"
-
-        for line in classret.splitlines():
-            ret += "    " + line + "\n"
-        ret += "\n"
-
-    return ret
-
-# Overwrite Module.module_import to _actually_ import the introspected module if
-# it's a gi module, then build stub code by examining its info and get an astng
-# from that
-
-from astroid.scoped_nodes import Module
-_orig_import_module = Module.import_module
-
-def _new_import_module(self, modname, relative_only=False, level=None):
-    # Could be a static piece of gi.repository or whatever unrelated module,
-    # let that fall through
-    try:
-        return _orig_import_module(self, modname, relative_only, level)
-    except AstroidBuildingException:
-        # we only consider gi.repository submodules
-        if not modname.startswith('gi.repository.'):
-            if relative_only and level is None:
-                level = 0
-            modname = self.relative_to_absolute_name(modname, level)
-        if not modname.startswith('gi.repository.'):
-            raise
-    # build astroid representation unless we already tried so
-    if modname not in _inspected_modules:
-        modnames = [modname]
-        # GLib and GObject have some special case handling
-        # in pygobject that we need to cope with
-        if modname == 'gi.repository.GLib':
-            modnames.append('gi._glib')
-        elif modname == 'gi.repository.GObject':
-            modnames.append('gi._gobject')
-        try:
-            modcode = ''
-            for m in modnames:
-                __import__(m)
-                modcode += _gi_build_stub(sys.modules[m])
-        except ImportError:
-            astng = _inspected_modules[modname] = None
-        else:
-            astng = AstroidBuilder(MANAGER).string_build(modcode, modname)
-            _inspected_modules[modname] = astng
-    else:
-        astng = _inspected_modules[modname]
-    if astng is None:
-        raise AstroidBuildingException('Failed to import module %r' % modname)
-    return astng
-
-Module.import_module = _new_import_module

third_party/logilab/astroid/brain/py2mechanize.py

-from astroid import MANAGER
-from astroid.builder import AstroidBuilder
-
-def mechanize_transform(module):
-    fake = AstroidBuilder(MANAGER).string_build('''
-
-class Browser(object):
-    def open(self, url, data=None, timeout=None):
-        return None
-    def open_novisit(self, url, data=None, timeout=None):
-        return None
-    def open_local_file(self, filename):
-        return None
-
-''')
-    module.locals['Browser'] = fake.locals['Browser']
-
-import py2stdlib
-py2stdlib.MODULE_TRANSFORMS['mechanize'] = mechanize_transform
-

third_party/logilab/common/README.chromium

 URL: http://www.logilab.org/project/logilab-common
-Version: 0.63.1
+Version: 0.57.1
 License: GPL
 License File: LICENSE.txt
 

third_party/logilab/common/corbautils.py

@@ -72,7 +72,7 @@ def register_object_name(object, namepath):
         name = [CosNaming.NameComponent(id, kind)]
         try:
             context = context.bind_new_context(name)
-        except CosNaming.NamingContext.AlreadyBound as ex:
+        except CosNaming.NamingContext.AlreadyBound, ex:
             context = context.resolve(name)._narrow(CosNaming.NamingContext)
             assert context is not None, \
                    'test context exists but is not a NamingContext'
@@ -81,7 +81,7 @@ def register_object_name(object, namepath):
     name = [CosNaming.NameComponent(id, kind)]
     try:
         context.bind(name, object._this())
-    except CosNaming.NamingContext.AlreadyBound as ex:
+    except CosNaming.NamingContext.AlreadyBound, ex:
         context.rebind(name, object._this())
 
 def activate_POA():