Adding various forwards-compatible workarounds for pending deprecations in astroid 2.0

Author: carlio

pylint_django/augmentations/__init__.py

@@ -4,12 +4,13 @@
 from pylint.checkers.classes import ClassChecker
 from pylint.checkers.newstyle import NewStyleConflictChecker
 from pylint.checkers.variables import VariablesChecker
-from astroid import InferenceError, Getattr
-from astroid.nodes import Class, From
+from astroid import InferenceError
+from pylint_django.compat import ClassDef, ImportFrom, Attribute
 from astroid.scoped_nodes import Class as ScopedClass, Module
 from pylint.__pkginfo__ import numversion as PYLINT_VERSION
 from pylint.checkers.typecheck import TypeChecker
 from pylint_django.utils import node_is_subclass, PY3
+from pylint_django.compat import inferred
 from pylint_plugin_utils import augment_visit, suppress_message
 
 
@@ -31,7 +32,7 @@ def ignore_import_warnings_for_related_fields(orig_method, self, node):
 
     iterat = to_consume[0].items if PY3 else to_consume[0].iteritems
     for name, stmts in iterat():
-        if isinstance(stmts[0], From):
+        if isinstance(stmts[0], ImportFrom):
             if any([n[0] in ('ForeignKey', 'OneToOneField') for n in stmts[0].names]):
                 continue
         new_things[name] = stmts
@@ -109,7 +110,7 @@ class ModelB(models.Model):
         quack = True
     else:
         # we will
-        if isinstance(node.parent, Getattr):
+        if isinstance(node.parent, Attribute):
             func_name = getattr(node.parent, 'attrname', None)
             if func_name in manager_attrs:
                 quack = True
@@ -118,7 +119,7 @@ class ModelB(models.Model):
         children = list(node.get_children())
         for child in children:
             try:
-                inferred = child.infered()
+                inferred = inferred(child)()
             except InferenceError:
                 pass
             else:
@@ -143,15 +144,15 @@ def foreign_key_ids(chain, node):
 
 def is_model_admin_subclass(node):
     """Checks that node is derivative of ModelAdmin class."""
-    if node.name[-5:] != 'Admin' or isinstance(node.parent, Class):
+    if node.name[-5:] != 'Admin' or isinstance(node.parent, ClassDef):
         return False
 
     return node_is_subclass(node, 'django.contrib.admin.options.ModelAdmin')
 
 
 def is_model_media_subclass(node):
     """Checks that node is derivative of Media class."""
-    if node.name != 'Media' or not isinstance(node.parent, Class):
+    if node.name != 'Media' or not isinstance(node.parent, ClassDef):
         return False
 
     parents = ('django.contrib.admin.options.ModelAdmin',
@@ -167,7 +168,7 @@ def is_model_media_subclass(node):
 
 def is_model_meta_subclass(node):
     """Checks that node is derivative of Meta class."""
-    if node.name != 'Meta' or not isinstance(node.parent, Class):
+    if node.name != 'Meta' or not isinstance(node.parent, ClassDef):
         return False
 
     parents = ('.Model',  # for the transformed version used here
@@ -186,7 +187,7 @@ def is_model_meta_subclass(node):
 
 def is_model_mpttmeta_subclass(node):
     """Checks that node is derivative of MPTTMeta class."""
-    if node.name != 'MPTTMeta' or not isinstance(node.parent, Class):
+    if node.name != 'MPTTMeta' or not isinstance(node.parent, ClassDef):
         return False
 
     parents = ('django.db.models.base.Model',
@@ -200,7 +201,7 @@ def is_model_mpttmeta_subclass(node):
 
 def is_model_test_case_subclass(node):
     """Checks that node is derivative of TestCase class."""
-    if not node.name.endswith('Test') and not isinstance(node.parent, Class):
+    if not node.name.endswith('Test') and not isinstance(node.parent, ClassDef):
         return False
 
     return node_is_subclass(node, 'django.test.testcases.TestCase')
@@ -242,7 +243,7 @@ def is_model_field_display_method(node):
         # TODO: could validate the names of the fields on the model rather than
         # blindly accepting get_*_display
         try:
-            for cls in node.last_child().infered():
+            for cls in inferred(node.last_child())():
                 if node_is_subclass(cls, 'django.db.models.base.Model', '.Model'):
                     return True
         except InferenceError:

pylint_django/checkers/models.py

@@ -1,6 +1,7 @@
 """Models."""
 from astroid import Const
-from astroid.nodes import Assign, Function, AssName, Class
+from pylint_django.compat import ClassDef, FunctionDef, inferred, AssignName
+from astroid.nodes import Assign
 from pylint.interfaces import IAstroidChecker
 from pylint.checkers.utils import check_messages
 from pylint.checkers import BaseChecker
@@ -28,7 +29,7 @@
 
 
 def _is_meta_with_abstract(node):
-    if isinstance(node, Class) and node.name == 'Meta':
+    if isinstance(node, ClassDef) and node.name == 'Meta':
         for meta_child in node.get_children():
             if not isinstance(meta_child, Assign):
                 continue
@@ -77,21 +78,23 @@ def _visit_classdef(self, node):
             if isinstance(child, Assign):
                 grandchildren = list(child.get_children())
 
-                if not isinstance(grandchildren[0], AssName):
+                if not isinstance(grandchildren[0], AssignName):
                     continue
 
                 name = grandchildren[0].name
                 if name != '__unicode__':
                     continue
 
-                assigned = grandchildren[1].infered()[0]
+                grandchild = grandchildren[1]
+                assigned = inferred(grandchild)()[0]
+
                 if assigned.callable():
                     return
 
                 self.add_message('E%s01' % BASE_ID, args=node.name, node=node)
                 return
 
-            if isinstance(child, Function) and child.name == '__unicode__':
+            if isinstance(child, FunctionDef) and child.name == '__unicode__':
                 if PY3:
                     self.add_message('W%s02' % BASE_ID, args=node.name, node=node)
                 return

pylint_django/compat.py

@@ -0,0 +1,31 @@
+
+try:
+    from astroid.nodes import ClassDef, FunctionDef, ImportFrom, AssignName, Attribute
+except ImportError:
+    from astroid.nodes import Class as ClassDef, \
+        Function as FunctionDef, \
+        From as ImportFrom, \
+        AssName as AssignName, \
+        Getattr as Attribute
+
+try:
+    from astroid.bases import YES as Uninferable
+except ImportError:
+    try:
+        from astroid.util import YES as Uninferable
+    except ImportError:
+        from astroid.util import Uninferable
+
+
+def inferred(node):
+    if hasattr(node, 'inferred'):
+        return node.inferred
+    else:
+        return node.infered
+
+
+def instantiate_class(node):
+    if hasattr(node, 'instantiate_class'):
+        return node.instantiate_class
+    else:
+        return node.instanciate_class

pylint_django/transforms/__init__.py

@@ -26,7 +26,7 @@ def set_fake_locals(module):
         if module.name != package_name:
             return
         for class_name in class_names:
-            module.locals[class_name] = fake.locals[class_name]
+            module._locals[class_name] = fake._locals[class_name]
 
     MANAGER.register_transform(nodes.Module, set_fake_locals)
 

pylint_django/transforms/foreignkey.py

@@ -1,14 +1,15 @@
 from astroid import nodes, InferenceError, inference_tip, UseInferenceDefault
+from pylint_django.compat import ClassDef, instantiate_class, Attribute
 
 
 def is_foreignkey_in_class(node):
     # is this of the form  field = models.ForeignKey
     if not isinstance(node.parent, nodes.Assign):
         return False
-    if not isinstance(node.parent.parent, nodes.Class):
+    if not isinstance(node.parent.parent, ClassDef):
         return False
 
-    if isinstance(node.func, nodes.Getattr):
+    if isinstance(node.func, Attribute):
         attr = node.func.attrname
     elif isinstance(node.func, nodes.Name):
         attr = node.func.name
@@ -34,7 +35,7 @@ def infer_key_classes(node, context=None):
                     break
     else:
         raise UseInferenceDefault
-    return iter([key_cls.instanciate_class()])
+    return iter([instantiate_class(key_cls)()])
 
 
 def add_transform(manager):

pylint_django/utils.py

@@ -1,31 +1,23 @@
 """Utils."""
 from astroid.exceptions import InferenceError
 from astroid.bases import Instance
-from astroid.nodes import Class
+from pylint_django.compat import Uninferable, inferred, ClassDef
 import sys
 
-try:
-    from astroid.bases import YES as Uninferable
-except ImportError:
-    try:
-        from astroid.util import YES as Uninferable
-    except ImportError:
-        from astroid.util import Uninferable
-
 
 PY3 = sys.version_info >= (3, 0)
 
 
 def node_is_subclass(cls, *subclass_names):
     """Checks if cls node has parent with subclass_name."""
-    if not isinstance(cls, (Class, Instance)):
+    if not isinstance(cls, (ClassDef, Instance)):
         return False
 
     if cls.bases == Uninferable:
         return False
     for base_cls in cls.bases:
         try:
-            for inf in base_cls.infered():
+            for inf in inferred(base_cls)():
                 if inf.qname() in subclass_names:
                     return True
                 if inf != cls and node_is_subclass(inf, *subclass_names):