pylint: upgrade to 1.4.1

third_party/logilab/astroid/manager.py

 # 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.
 #
@@ skipping 126 matching lines @@
         old_cwd = os.getcwd()
         if context_file:
             os.chdir(dirname(context_file))
         try:
             filepath, mp_type = self.file_from_module_name(modname, context_file)
             if mp_type == modutils.PY_ZIPMODULE:
                 module = self.zip_import_data(filepath)
                 if module is not None:
                     return module
             elif mp_type in (imp.C_BUILTIN, imp.C_EXTENSION):
-                if mp_type == imp.C_EXTENSION and not self._can_load_extension(modname): 
+                if mp_type == imp.C_EXTENSION and not self._can_load_extension(modname):
                     return self._build_stub_module(modname)
                 try:
                     module = modutils.load_module_from_name(modname)
                 except Exception as ex:
                     msg = 'Unable to load module %s (%s)' % (modname, ex)
                     raise AstroidBuildingException(msg)
                 return self.ast_from_module(module, modname)
             elif mp_type == imp.PY_COMPILED:
                 raise AstroidBuildingException("Unable to load compiled module %s" % (modname,))
             if filepath is None:
@@ skipping 146 matching lines @@
         The transform function may return a value which is then used to
         substitute the original node in the tree.
         """
         self.transforms[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 register_failed_import_hook(self, hook):
-        """"Registers a hook to resolve imports that cannot be found otherwise.
+        """Registers a hook to resolve imports that cannot be found otherwise.
 
         `hook` must be a function that accepts a single argument `modname` which
         contains the name of the module or package that could not be imported.
         If `hook` can resolve the import, must return a node of type `astroid.Module`,
         otherwise, it must raise `AstroidBuildingException`.
         """
         self._failed_import_hooks.append(hook)
 
     def transform(self, node):
         """Call matching transforms for the given node if any and return the
@@ skipping 16 matching lines @@
                         # node has already be modified by some previous
                         # transformation, warn about it
                         warn('node %s substituted 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)
 
-    def clear_cache(self):
+    def clear_cache(self, astroid_builtin=None):
         # XXX clear transforms
         self.astroid_cache.clear()
         # force bootstrap again, else we may ends up with cache inconsistency
         # between the manager and CONST_PROXY, making
         # unittest_lookup.LookupTC.test_builtin_lookup fail depending on the
         # test order
-        from astroid.raw_building import astroid_bootstrapping
-        astroid_bootstrapping()
+        import astroid.raw_building
+        astroid.raw_building._astroid_bootstrapping(
+            astroid_builtin=astroid_builtin)
 
 
 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__
@@ skipping 10 matching lines @@
         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))