pylint: upgrade to 1.4.0

third_party/logilab/astroid/raw_building.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.
 #
 # 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/>.
 """this module contains a set of functions to create astroid trees from scratch
 (build_* functions) or from living object (object_build_* functions)
 """
 
 __docformat__ = "restructuredtext en"
 
 import sys
 from os.path import abspath
 from inspect import (getargspec, isdatadescriptor, isfunction, ismethod,
                      ismethoddescriptor, isclass, isbuiltin, ismodule)
+import six
 
 from astroid.node_classes import CONST_CLS
 from astroid.nodes import (Module, Class, Const, const_factory, From,
                            Function, EmptyNode, Name, Arguments)
 from astroid.bases import BUILTINS, Generator
 from astroid.manager import AstroidManager
 MANAGER = AstroidManager()
 
 _CONSTANTS = tuple(CONST_CLS) # the keys of CONST_CLS eg python builtin types
 
@@ skipping 12 matching lines @@
 _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 = EmptyNode()
     enode.object = object
     _attach_local_node(node, enode, name)
 
-EmptyNode.has_underlying_object = lambda self: self.object is not _marker
+def _has_underlying_object(self):
+    return hasattr(self, 'object') and self.object is not _marker
+
+EmptyNode.has_underlying_object = _has_underlying_object
 
 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, const_factory(value), name)
 
 def attach_import_node(node, modname, membername):
     """create a From node and register it in the locals of the given
@@ skipping 169 matching lines @@
             return self._done[obj]
         self._done[obj] = node
         for name in dir(obj):
             try:
                 member = getattr(obj, name)
             except AttributeError:
                 # damned ExtensionClass.Base, I know you're there !
                 attach_dummy_node(node, name)
                 continue
             if ismethod(member):
-                member = member.im_func
+                member = six.get_method_function(member)
             if isfunction(member):
                 # verify this is not an imported function
-                filename = getattr(member.func_code, 'co_filename', None)
+                filename = getattr(six.get_function_code(member),
+                                   'co_filename', None)
                 if filename is None:
                     assert isinstance(member, object)
                     object_build_methoddescriptor(node, member, name)
                 elif filename != getattr(self._module, '__file__', None):
                     attach_dummy_node(node, name, member)
                 else:
                     object_build_function(node, member, name)
             elif isbuiltin(member):
                 if (not _io_discrepancy(member) and
                         self.imported_member(node, member, name)):
-                    #if obj is object:
-                    #    print 'skippp', obj, name, member
                     continue
                 object_build_methoddescriptor(node, member, name)
             elif isclass(member):
                 if self.imported_member(node, member, name):
                     continue
                 if member in self._done:
                     class_node = self._done[member]
                     if not class_node in node.locals.get(name, ()):
                         node.add_local_node(class_node, name)
                 else:
@@ skipping 16 matching lines @@
 
     def imported_member(self, node, member, name):
         """verify this is not an imported class or handle it"""
         # /!\ some classes like ExtensionClass doesn't have a __module__
         # attribute ! Also, this may trigger an exception on badly built module
         # (see http://www.logilab.org/ticket/57299 for instance)
         try:
             modname = getattr(member, '__module__', None)
         except:
             # XXX use logging
-            print 'unexpected error while building astroid from living object'
+            print('unexpected error while building astroid from living object')
             import traceback
             traceback.print_exc()
             modname = None
         if modname is None:
             if name in ('__new__', '__subclasshook__'):
                 # Python 2.5.1 (r251:54863, Sep  1 2010, 22:03:14)
                 # >>> print object.__new__.__module__
                 # None
                 modname = BUILTINS
             else:
@@ skipping 39 matching lines @@
 # However __proxied introduced an
 # infinite recursion (see https://bugs.launchpad.net/pylint/+bug/456870)
 def _set_proxied(const):
     return _CONST_PROXY[const.value.__class__]
 Const._proxied = property(_set_proxied)
 
 from types import GeneratorType
 Generator._proxied = Class(GeneratorType.__name__, GeneratorType.__doc__)
 Astroid_BUILDER.object_build(Generator._proxied, GeneratorType)