Cleanup pylint's warnings over astroid codebase

Some of the messages were disabled in pylintrc, since they're not
very useful for our case. Other parameters, such as the number of
arguments / statements / attributes etc were configured so that they
won't be too restrictive for our codebase, since making the code
to respect them right now requires too much development changes,
which is not justified by the end result.
Closes issue #284.

28 files changed, 269 insertions, 218 deletions

diff --git a/astroid/__init__.py b/astroid/__init__.py
index 54d861aa..98c43973 100644
--- a/astroid/__init__.py
+++ b/astroid/__init__.py
@@ -39,7 +39,7 @@ Main modules are:
 
 * builder contains the class responsible to build astroid trees
 """
-
+import os
 import sys
 import re
 from operator import attrgetter
@@ -48,6 +48,7 @@ import enum
 
 
 _Context = enum.Enum('Context', 'Load Store Del')
+# pylint: disable=no-member; github.com/pycqa/pylint/issues/690
 Load = _Context.Load
 Store = _Context.Store
 Del = _Context.Del
@@ -57,6 +58,8 @@ del _Context
 # WARNING: internal imports order matters !
 
 # pylint: disable=redefined-builtin, wildcard-import
+# pylint: disable=wrong-import-position; the current order of imports is critical
+# here, that's why we don't respect it.
 
 # make all exception classes accessible from astroid package
 from astroid.exceptions import *
@@ -101,6 +104,7 @@ class AsStringRegexpPredicate(object):
 
     def __call__(self, node):
         if self.expression is not None:
+            # pylint: disable=no-member; github.com/pycqa/astroid/126
             node = attrgetter(self.expression)(node)
         return self.regexp.search(node.as_string())
 
@@ -131,13 +135,11 @@ def register_module_extender(manager, module_name, get_extension_mod):
 
 
 # load brain plugins
-from os import listdir
-from os.path import join, dirname
-BRAIN_MODULES_DIR = join(dirname(__file__), 'brain')
+BRAIN_MODULES_DIR = os.path.join(os.path.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):
+for module in os.listdir(BRAIN_MODULES_DIR):
     if module.endswith('.py'):
         __import__(module[:-3])
diff --git a/astroid/__pkginfo__.py b/astroid/__pkginfo__.py
index 3686d03c..64540bf2 100644
--- a/astroid/__pkginfo__.py
+++ b/astroid/__pkginfo__.py
@@ -30,6 +30,7 @@ install_requires = ['lazy_object_proxy', 'six', 'wrapt']
 if sys.version_info < (3, 4):
     install_requires += ['enum34', 'singledispatch']
 
+# pylint: disable=redefined-builtin; why license is a builtin anyway?
 license = 'LGPL'
 
 author = 'Logilab'
diff --git a/astroid/arguments.py b/astroid/arguments.py
index 949783af..8f4ea2f7 100644
--- a/astroid/arguments.py
+++ b/astroid/arguments.py
@@ -16,13 +16,14 @@
 # You should have received a copy of the GNU Lesser General Public License along
 # with astroid. If not, see <http://www.gnu.org/licenses/>.
 
+import six
+
 from astroid import bases
 from astroid import context as contextmod
 from astroid import exceptions
 from astroid import nodes
 from astroid import util
 
-import six
 
 
 class CallSite(object):
diff --git a/astroid/as_string.py b/astroid/as_string.py
index 5bd62335..c081ea56 100644
--- a/astroid/as_string.py
+++ b/astroid/as_string.py
@@ -26,6 +26,10 @@ import sys
 
 import six
 
+# pylint: disable=no-self-use; some visit methods don't need the self argument.
+# pylint: disable=unused-argument
+
+
 class AsStringVisitor(object):
     """Visitor to render an Astroid node as a valid python code string"""
 
diff --git a/astroid/bases.py b/astroid/bases.py
index 0762f528..109dabce 100644
--- a/astroid/bases.py
+++ b/astroid/bases.py
@@ -263,7 +263,6 @@ class Instance(Proxy):
 
     # TODO(cpopa): this is set in inference.py
     # The circular dependency hell goes deeper and deeper.
-    # pylint: disable=unused-argument
     def getitem(self, index, context=None):
         pass
 
diff --git a/astroid/builder.py b/astroid/builder.py
index 21b227d1..47aee988 100644
--- a/astroid/builder.py
+++ b/astroid/builder.py
@@ -22,6 +22,7 @@ at the same time.
 """
 
 import _ast
+import re
 import os
 import sys
 import textwrap
@@ -41,6 +42,8 @@ def _parse(string):
 
 if sys.version_info >= (3, 0):
     # pylint: disable=no-name-in-module; We don't understand flows yet.
+    # pylint: disable=wrong-import-order, wrong-import-position; have to do it here,
+    # rather than moving the entire block between standard and local imports.
     from tokenize import detect_encoding
 
     def open_source_file(filename):
@@ -51,8 +54,6 @@ if sys.version_info >= (3, 0):
         return stream, encoding, data
 
 else:
-    import re
-
     _ENCODING_RGX = re.compile(r"\s*#+.*coding[:=]\s*([-\w.]+)")
 
     def _guess_encoding(string):
@@ -86,7 +87,7 @@ class AstroidBuilder(raw_building.InspectBuilder):
     applied after the tree was built from source or from a live object,
     by default being True.
     """
-
+    # pylint: disable=redefined-outer-name
     def __init__(self, manager=None, apply_transforms=True):
         super(AstroidBuilder, self).__init__()
         self._manager = manager or MANAGER
@@ -129,7 +130,7 @@ class AstroidBuilder(raw_building.InspectBuilder):
             # detect_encoding returns utf-8 if no encoding specified
             util.reraise(exceptions.AstroidBuildingError(
                 'Wrong ({encoding}) or no encoding specified for {filename}.',
-                encoding=encoding, filename=filename))
+                encoding=encoding, filename=path))
         with stream:
             # get module name if necessary
             if modname is None:
@@ -241,7 +242,7 @@ class AstroidBuilder(raw_building.InspectBuilder):
                     continue
                 # get assign in __init__ first XXX useful ?
                 if (frame.name == '__init__' and values and
-                        not values[0].frame().name == '__init__'):
+                        values[0].frame().name != '__init__'):
                     values.insert(0, node)
                 else:
                     values.append(node)
diff --git a/astroid/exceptions.py b/astroid/exceptions.py
index 3cfadbd2..98a0f881 100644
--- a/astroid/exceptions.py
+++ b/astroid/exceptions.py
@@ -34,6 +34,7 @@ class AstroidError(Exception):
     arguments.
     """
     def __init__(self, message='', **kws):
+        super(AstroidError, self).__init__(message)
         self.message = message
         for key, value in kws.items():
             setattr(self, key, value)
@@ -202,4 +203,4 @@ BinaryOperationError = util.BadBinaryOperationMessage
 SuperArgumentTypeError = SuperError
 UnresolvableName = NameInferenceError
 NotFoundError = AttributeInferenceError
-AstroidBuildingException = AstroidBuildingError
\ No newline at end of file
+AstroidBuildingException = AstroidBuildingError
diff --git a/astroid/inference.py b/astroid/inference.py
index 5bbc34fd..23929b74 100644
--- a/astroid/inference.py
+++ b/astroid/inference.py
@@ -18,8 +18,6 @@
 """this module contains a set of functions to handle inference on astroid trees
 """
 
-# pylint: disable=no-value-for-parameter; Pylint FP #629, please remove afterwards.
-
 import functools
 import itertools
 import operator
@@ -138,8 +136,8 @@ def infer_import(self, context=None, asname=True):
             yield self.do_import_module(name)
     except exceptions.AstroidBuildingError as exc:
         util.reraise(exceptions.InferenceError(node=self, error=exc,
-                                               context=context))        
-        
+                                               context=context))
+
 nodes.Import._infer = infer_import
 
 
@@ -209,7 +207,8 @@ def infer_global(self, context=None):
                                   context)
     except exceptions.AttributeInferenceError as error:
         util.reraise(exceptions.InferenceError(
-            error.message, target=self, attribute=name, context=context))
+            error.message, target=self, attribute=context.lookupname,
+            context=context))
 nodes.Global._infer = infer_global
 
 
@@ -289,7 +288,7 @@ def infer_subscript(self, context=None):
     except (IndexError, TypeError, AttributeError) as exc:
         util.reraise(exceptions.InferenceError(node=self, error=exc,
                                                context=context))
-        
+
     # Prevent inferring if the inferred subscript
     # is the same as the original subscripted object.
     if self is assigned or assigned is util.Uninferable:
diff --git a/astroid/mixins.py b/astroid/mixins.py
index e67c9af3..4092fe35 100644
--- a/astroid/mixins.py
+++ b/astroid/mixins.py
@@ -22,7 +22,6 @@ import warnings
 
 from astroid import decorators
 from astroid import exceptions
-from astroid import util
 
 
 class BlockRangeMixIn(object):
diff --git a/astroid/modutils.py b/astroid/modutils.py
index e127d845..749018ca 100644
--- a/astroid/modutils.py
+++ b/astroid/modutils.py
@@ -394,7 +394,7 @@ def get_module_part(dotted_name, context_file=None):
             file_from_modpath(parts[starti:i+1], path=path,
                               context_file=context_file)
         except ImportError:
-            if not i >= max(1, len(parts) - 2):
+            if i < max(1, len(parts) - 2):
                 raise
             return '.'.join(parts[:i])
     return dotted_name
@@ -425,7 +425,7 @@ def get_module_files(src_directory, blacklist, list_all=False):
     for directory, dirnames, filenames in os.walk(src_directory):
         _handle_blacklist(blacklist, dirnames, filenames)
         # check for __init__.py
-        if not list_all and not '__init__.py' in filenames:
+        if not list_all and '__init__.py' not in filenames:
             dirnames[:] = ()
             continue
         for filename in filenames:
@@ -581,13 +581,9 @@ def _search_zip(modpath, pic):
                         filepath)
     raise ImportError('No module named %s' % '.'.join(modpath))
 
-try:
-    import pkg_resources
-except ImportError:
-    pkg_resources = None
-
 
 def _is_namespace(modname):
+    # pylint: disable=no-member; astroid issue #290, modifying globals at runtime.
     return (pkg_resources is not None
             and modname in pkg_resources._namespace_packages)
 
@@ -614,7 +610,7 @@ def _module_file(modpath, path=None):
         pic = sys.path_importer_cache
         _path = (path is None and sys.path or path)
         for __path in _path:
-            if not __path in pic:
+            if __path not in pic:
                 try:
                     pic[__path] = zipimport.zipimporter(__path)
                 except zipimport.ZipImportError:
diff --git a/astroid/node_classes.py b/astroid/node_classes.py
index 8293fe45..0e88b17b 100644
--- a/astroid/node_classes.py
+++ b/astroid/node_classes.py
@@ -68,7 +68,7 @@ def unpack_infer(stmt, context=None):
                 yield inf_inf
 
 
-def are_exclusive(stmt1, stmt2, exceptions=None):
+def are_exclusive(stmt1, stmt2, exceptions=None): # pylint: disable=redefined-outer-name
     """return true if the two given statements are mutually exclusive
 
     `exceptions` may be a list of exception names. If specified, discard If
@@ -106,12 +106,22 @@ def are_exclusive(stmt1, stmt2, exceptions=None):
                 c2attr, c2node = node.locate_child(previous)
                 c1attr, c1node = node.locate_child(children[node])
                 if c1node is not c2node:
-                    if ((c2attr == 'body'
-                         and c1attr == 'handlers'
-                         and children[node].catch(exceptions)) or
-                            (c2attr == 'handlers' and c1attr == 'body' and previous.catch(exceptions)) or
-                            (c2attr == 'handlers' and c1attr == 'orelse') or
-                            (c2attr == 'orelse' and c1attr == 'handlers')):
+                    first_in_body_catched_by_handlers = (
+                        c2attr == 'handlers'
+                        and c1attr == 'body'
+                        and previous.catch(exceptions))
+                    second_in_body_catched_by_handlers = (
+                        c2attr == 'body'
+                        and c1attr == 'handlers'
+                        and children[node].catch(exceptions))
+                    first_in_else_other_in_handlers = (
+                        c2attr == 'handlers' and c1attr == 'orelse')
+                    second_in_else_other_in_handlers = (
+                        c2attr == 'orelse' and c1attr == 'handlers')
+                    if any((first_in_body_catched_by_handlers,
+                            second_in_body_catched_by_handlers,
+                            first_in_else_other_in_handlers,
+                            second_in_else_other_in_handlers)):
                         return True
                 elif c2attr == 'handlers' and c1attr == 'handlers':
                     return previous is not children[node]
@@ -619,7 +629,6 @@ class _BaseContainer(mixins.ParentAssignTypeMixin,
 
     @classmethod
     def from_constants(cls, elts=None):
-        # pylint: disable=abstract-class-instantiated; False positive on Pylint #627.
         node = cls()
         if elts is None:
             node.elts = []
@@ -695,7 +704,7 @@ class LookupMixIn(object):
 
             if self.statement() is myframe and myframe.parent:
                 myframe = myframe.parent.frame()
-        if not myframe is frame or self is frame:
+        if myframe is not frame or self is frame:
             return stmts
         mystmt = self.statement()
         # line filtering if we are in the same frame
@@ -838,9 +847,9 @@ class Arguments(mixins.AssignTypeMixin, NodeNG):
     _other_fields = ('vararg', 'kwarg')
 
     def __init__(self, vararg=None, kwarg=None, parent=None):
+        super(Arguments, self).__init__(parent=parent)
         self.vararg = vararg
         self.kwarg = kwarg
-        self.parent = parent
         self.args = []
         self.defaults = []
         self.kwonlyargs = []
@@ -1140,8 +1149,10 @@ class Comprehension(NodeNG):
     ifs = None
 
     def __init__(self, parent=None):
+        super(Comprehension, self).__init__()
         self.parent = parent
 
+    # pylint: disable=redefined-builtin; same name as builtin ast module.
     def postinit(self, target=None, iter=None, ifs=None):
         self.target = target
         self.iter = iter
@@ -1327,6 +1338,8 @@ class Ellipsis(NodeNG): # pylint: disable=redefined-builtin
 class EmptyNode(NodeNG):
     """class representing an EmptyNode node"""
 
+    object = None
+
 
 class ExceptHandler(mixins.AssignTypeMixin, Statement):
     """class representing an ExceptHandler node"""
@@ -1335,6 +1348,7 @@ class ExceptHandler(mixins.AssignTypeMixin, Statement):
     name = None
     body = None
 
+    # pylint: disable=redefined-builtin; had to use the same name as builtin ast module.
     def postinit(self, type=None, name=None, body=None):
         self.type = type
         self.name = name
@@ -1349,7 +1363,7 @@ class ExceptHandler(mixins.AssignTypeMixin, Statement):
         else:
             return self.lineno
 
-    def catch(self, exceptions):
+    def catch(self, exceptions): # pylint: disable=redefined-outer-name
         if self.type is None or exceptions is None:
             return True
         for node in self.type.nodes_of_class(Name):
@@ -1364,6 +1378,7 @@ class Exec(Statement):
     globals = None
     locals = None
 
+    # pylint: disable=redefined-builtin; had to use the same name as builtin ast module.
     def postinit(self, expr=None, globals=None, locals=None):
         self.expr = expr
         self.globals = globals
@@ -1387,6 +1402,7 @@ class For(mixins.BlockRangeMixIn, mixins.AssignTypeMixin, Statement):
     body = None
     orelse = None
 
+    # pylint: disable=redefined-builtin; had to use the same name as builtin ast module.
     def postinit(self, target=None, iter=None, body=None, orelse=None):
         self.target = target
         self.iter = iter
@@ -1684,6 +1700,7 @@ class Subscript(NodeNG):
         super(Subscript, self).__init__(lineno=lineno,
                                         col_offset=col_offset, parent=parent)
 
+    # pylint: disable=redefined-builtin; had to use the same name as builtin ast module.
     def postinit(self, value=None, slice=None):
         self.value = value
         self.slice = slice
@@ -1865,6 +1882,7 @@ def _update_const_classes():
     """update constant classes, so the keys of CONST_CLS can be reused"""
     klasses = (bool, int, float, complex, str)
     if six.PY2:
+        # pylint: disable=undefined-variable
         klasses += (unicode, long)
     klasses += (bytes,)
     for kls in klasses:
@@ -1915,7 +1933,7 @@ def const_factory(value):
         initializer_cls = CONST_CLS[value.__class__]
         initializer = _CONST_CLS_CONSTRUCTORS[initializer_cls]
         return initializer(initializer_cls, elts)
-    except (KeyError, AttributeError) as exc:
+    except (KeyError, AttributeError):
         node = EmptyNode()
         node.object = value
         return node
diff --git a/astroid/objects.py b/astroid/objects.py
index c880a4d4..e948396f 100644
--- a/astroid/objects.py
+++ b/astroid/objects.py
@@ -49,7 +49,7 @@ class FrozenSet(node_classes._BaseContainer):
         yield self
 
     @decorators.cachedproperty
-    def _proxied(self):
+    def _proxied(self): # pylint: disable=method-hidden
         builtins = MANAGER.astroid_cache[BUILTINS]
         return builtins.getattr('frozenset')[0]
 
@@ -66,7 +66,7 @@ class Super(node_classes.NodeNG):
     *self_class* is the class where the super call is, while
     *scope* is the function where the super call is.
     """
-
+    # pylint: disable=super-init-not-called
     def __init__(self, mro_pointer, mro_type, self_class, scope):
         self.type = mro_type
         self.mro_pointer = mro_pointer
diff --git a/astroid/protocols.py b/astroid/protocols.py
index 66ca9784..139b3603 100644
--- a/astroid/protocols.py
+++ b/astroid/protocols.py
@@ -20,7 +20,7 @@ where it makes sense.
 """
 
 import collections
-import operator
+import operator as operator_mod
 import sys
 
 import six
@@ -74,10 +74,10 @@ UNARY_OP_METHOD = {'+': '__pos__',
                    'not': None, # XXX not '__nonzero__'
                   }
 _UNARY_OPERATORS = {
-    '+': operator.pos,
-    '-': operator.neg,
-    '~': operator.invert,
-    'not': operator.not_,
+    '+': operator_mod.pos,
+    '-': operator_mod.neg,
+    '~': operator_mod.invert,
+    'not': operator_mod.not_,
 }
 
 
@@ -109,7 +109,7 @@ BIN_OP_IMPL = {'+':  lambda a, b: a + b,
               }
 if sys.version_info >= (3, 5):
     # MatMult is available since Python 3.5+.
-    BIN_OP_IMPL['@'] = operator.matmul
+    BIN_OP_IMPL['@'] = operator_mod.matmul
 
 for _KEY, _IMPL in list(BIN_OP_IMPL.items()):
     BIN_OP_IMPL[_KEY + '='] = _IMPL
@@ -271,9 +271,9 @@ def sequence_assigned_stmts(self, node=None, context=None, asspath=None):
     try:
         index = self.elts.index(node)
     except ValueError:
-         util.reraise(exceptions.InferenceError(
-             'Tried to retrieve a node {node!r} which does not exist',
-             node=self, assign_path=asspath, context=context))
+        util.reraise(exceptions.InferenceError(
+            'Tried to retrieve a node {node!r} which does not exist',
+            node=self, assign_path=asspath, context=context))
 
     asspath.insert(0, index)
     return self.parent.assigned_stmts(node=self, context=context, asspath=asspath)
diff --git a/astroid/raw_building.py b/astroid/raw_building.py
index ee5c31e5..2ea0f412 100644
--- a/astroid/raw_building.py
+++ b/astroid/raw_building.py
@@ -60,20 +60,20 @@ def _add_dunder_class(func, member):
     cls_name = getattr(python_cls, '__name__', None)
     if not cls_name:
         return
-    bases = [ancestor.__name__ for ancestor in python_cls.__bases__]
-    ast_klass = build_class(cls_name, bases, python_cls.__doc__)
+    cls_bases = [ancestor.__name__ for ancestor in python_cls.__bases__]
+    ast_klass = build_class(cls_name, cls_bases, python_cls.__doc__)
     func.instance_attrs['__class__'] = [ast_klass]
 
 
 _marker = object()
 
 
-def attach_dummy_node(node, name, object=_marker):
+def attach_dummy_node(node, name, runtime_object=_marker):
     """create a dummy node and register it in the locals of the given
     node with the specified name
     """
     enode = nodes.EmptyNode()
-    enode.object = object
+    enode.object = runtime_object
     _attach_local_node(node, enode, name)
 
 def _has_underlying_object(self):
@@ -115,7 +115,7 @@ def build_class(name, basenames=(), doc=None):
     return node
 
 
-def build_function(name, args=None, defaults=None, flag=0, doc=None):
+def build_function(name, args=None, defaults=None, doc=None):
     """create and initialize a astroid FunctionDef node"""
     args, defaults = args or [], defaults or []
     # first argument is now a list of decorators
@@ -170,14 +170,14 @@ def object_build_class(node, member, localname):
 
 def object_build_function(node, member, localname):
     """create astroid for a living function object"""
+    # pylint: disable=deprecated-method; completely removed in 2.0
     args, varargs, varkw, defaults = inspect.getargspec(member)
     if varargs is not None:
         args.append(varargs)
     if varkw is not None:
         args.append(varkw)
     func = build_function(getattr(member, '__name__', None) or localname, args,
-                          defaults, six.get_function_code(member).co_flags,
-                          member.__doc__)
+                          defaults, member.__doc__)
     node.add_local_node(func, localname)
 
 
diff --git a/astroid/rebuilder.py b/astroid/rebuilder.py
index a07fe295..903b3cc3 100644
--- a/astroid/rebuilder.py
+++ b/astroid/rebuilder.py
@@ -259,9 +259,9 @@ class TreeRebuilder(object):
             # problem for the correctness of the program).
             #
             # ("a" + "b" + # one thousand more + "c")
-            newnode = self._peepholer.optimize_binop(node, parent)
-            if newnode:
-                return newnode
+            optimized = self._peepholer.optimize_binop(node, parent)
+            if optimized:
+                return optimized
 
         newnode = nodes.BinOp(_BIN_OP_CLASSES[type(node.op)],
                               node.lineno, node.col_offset, parent)
diff --git a/astroid/scoped_nodes.py b/astroid/scoped_nodes.py
index 25d28aed..02a9989f 100644
--- a/astroid/scoped_nodes.py
+++ b/astroid/scoped_nodes.py
@@ -96,15 +96,15 @@ def function_to_method(n, klass):
 
 def std_special_attributes(self, name, add_locals=True):
     if add_locals:
-        locals = self.locals
+        obj_locals = self.locals
     else:
-        locals = {}
+        obj_locals = {}
     if name == '__name__':
-        return [node_classes.const_factory(self.name)] + locals.get(name, [])
+        return [node_classes.const_factory(self.name)] + obj_locals.get(name, [])
     if name == '__doc__':
-        return [node_classes.const_factory(self.doc)] + locals.get(name, [])
+        return [node_classes.const_factory(self.doc)] + obj_locals.get(name, [])
     if name == '__dict__':
-        return [node_classes.Dict()] + locals.get(name, [])
+        return [node_classes.Dict()] + obj_locals.get(name, [])
     # TODO: missing context
     raise exceptions.AttributeInferenceError(target=self, attribute=name)
 
@@ -138,10 +138,13 @@ class LocalsDictNodeNG(node_classes.LookupMixIn,
     # dictionary of locals with name as key and node defining the local as
     # value
 
+    locals = {}
+
     def qname(self):
         """return the 'qualified' name of the node, eg module.name,
         module.class.name ...
         """
+        # pylint: disable=no-member; github.com/pycqa/astroid/issues/278
         if self.parent is None:
             return self.name
         return '%s.%s' % (self.parent.frame().qname(), self.name)
@@ -188,6 +191,10 @@ class LocalsDictNodeNG(node_classes.LookupMixIn,
 
     def _append_node(self, child):
         """append a child, linking it in the tree"""
+        # pylint: disable=no-member; depending by the class
+        # which uses the current class as a mixin or base class.
+        # It's rewritten in 2.0, so it makes no sense for now
+        # to spend development time on it.
         self.body.append(child)
         child.parent = self
 
@@ -468,12 +475,12 @@ class Module(LocalsDictNodeNG):
         # to avoid catching too many Exceptions
         default = [name for name in self.keys() if not name.startswith('_')]
         try:
-            all = self['__all__']
+            all_values = self['__all__']
         except KeyError:
             return default
 
         try:
-            explicit = next(all.assigned_stmts())
+            explicit = next(all_values.assigned_stmts())
         except exceptions.InferenceError:
             return default
         except AttributeError:
@@ -664,6 +671,10 @@ class Lambda(mixins.FilterStmtsMixin, LocalsDictNodeNG):
 
     def argnames(self):
         """return a list of argument names"""
+        # pylint: disable=no-member; github.com/pycqa/astroid/issues/291
+        # args is in fact redefined later on by postinit. Can't be changed
+        # to None due to a strong interaction between Lambda and FunctionDef.
+
         if self.args.args: # maybe None with builtin functions
             names = _rec_get_names(self.args.args)
         else:
@@ -676,9 +687,17 @@ class Lambda(mixins.FilterStmtsMixin, LocalsDictNodeNG):
 
     def infer_call_result(self, caller, context=None):
         """infer what a function is returning when called"""
+        # pylint: disable=no-member; github.com/pycqa/astroid/issues/291
+        # args is in fact redefined later on by postinit. Can't be changed
+        # to None due to a strong interaction between Lambda and FunctionDef.
+
         return self.body.infer(context)
 
     def scope_lookup(self, node, name, offset=0):
+        # pylint: disable=no-member; github.com/pycqa/astroid/issues/291
+        # args is in fact redefined later on by postinit. Can't be changed
+        # to None due to a strong interaction between Lambda and FunctionDef.
+
         if node in self.args.defaults or node in self.args.kw_defaults:
             frame = self.parent.frame()
             # line offset to avoid that def func(f=func) resolve the default
@@ -1096,6 +1115,7 @@ class ClassDef(mixins.FilterStmtsMixin, LocalsDictNodeNG,
         if parent is not None:
             parent.frame().set_local(name, self)
 
+    # pylint: disable=redefined-outer-name
     def postinit(self, bases, body, decorators, newstyle=None, metaclass=None):
         self.bases = bases
         self.body = body
@@ -1728,9 +1748,9 @@ class ClassDef(mixins.FilterStmtsMixin, LocalsDictNodeNG,
             raise NotImplementedError(
                 "Could not obtain mro for old-style classes.")
 
-        bases = list(self._inferred_bases(context=context))
+        inferred_bases = list(self._inferred_bases(context=context))
         bases_mro = []
-        for base in bases:
+        for base in inferred_bases:
             try:
                 mro = base.mro(context=context)
                 bases_mro.append(mro)
@@ -1743,7 +1763,7 @@ class ClassDef(mixins.FilterStmtsMixin, LocalsDictNodeNG,
                 ancestors = list(base.ancestors(context=context))
                 bases_mro.append(ancestors)
 
-        unmerged_mro = ([[self]] + bases_mro + [bases])
+        unmerged_mro = ([[self]] + bases_mro + [inferred_bases])
         _verify_duplicates_mro(unmerged_mro, self, context)
         return _c3_merge(unmerged_mro, self, context)
 
diff --git a/astroid/test_utils.py b/astroid/test_utils.py
index 0fbbe80b..82dc9501 100644
--- a/astroid/test_utils.py
+++ b/astroid/test_utils.py
@@ -183,7 +183,7 @@ def require_version(minver=None, maxver=None):
         try:
             return tuple(int(v) for v in string.split('.'))
         except ValueError:
-            util.reraise(ValueError('%s is not a correct version : should be X.Y[.Z].' % version))
+            util.reraise(ValueError('%s is not a correct version : should be X.Y[.Z].' % string))
 
     def check_require_version(f):
         current = sys.version_info[:3]
@@ -194,9 +194,11 @@ def require_version(minver=None, maxver=None):
             @functools.wraps(f)
             def new_f(self, *args, **kwargs):
                 if minver is not None:
-                    self.skipTest('Needs Python > %s. Current version is %s.' % (minver, str_version))
+                    self.skipTest('Needs Python > %s. Current version is %s.'
+                                  % (minver, str_version))
                 elif maxver is not None:
-                    self.skipTest('Needs Python <= %s. Current version is %s.' % (maxver, str_version))
+                    self.skipTest('Needs Python <= %s. Current version is %s.'
+                                  % (maxver, str_version))
             return new_f
 
 
diff --git a/astroid/tests/unittest_brain.py b/astroid/tests/unittest_brain.py
index 31525ba0..c5a84cf6 100644
--- a/astroid/tests/unittest_brain.py
+++ b/astroid/tests/unittest_brain.py
@@ -15,31 +15,13 @@
 # You should have received a copy of the GNU Lesser General Public License along
 # with logilab-astng. If not, see <http://www.gnu.org/licenses/>.
 """Tests for basic functionality in astroid.brain."""
-import sys
-import unittest
-
-import six
-
-from astroid import MANAGER
-from astroid import bases
-from astroid import builder
-from astroid import nodes
-from astroid import test_utils
-from astroid import util
-import astroid
-
-
-try:
-    import nose # pylint: disable=unused-import
-    HAS_NOSE = True
-except ImportError:
-    HAS_NOSE = False
-
 try:
     import multiprocessing # pylint: disable=unused-import
     HAS_MULTIPROCESSING = True
 except ImportError:
     HAS_MULTIPROCESSING = False
+import sys
+import unittest
 
 try:
     import enum # pylint: disable=unused-import
@@ -52,6 +34,12 @@ except ImportError:
         HAS_ENUM = False
 
 try:
+    import nose # pylint: disable=unused-import
+    HAS_NOSE = True
+except ImportError:
+    HAS_NOSE = False
+
+try:
     import dateutil # pylint: disable=unused-import
     HAS_DATEUTIL = True
 except ImportError:
@@ -68,6 +56,15 @@ try:
     HAS_PYTEST = True
 except ImportError:
     HAS_PYTEST = False
+import six
+
+from astroid import MANAGER
+from astroid import bases
+from astroid import builder
+from astroid import nodes
+from astroid import test_utils
+from astroid import util
+import astroid
 
 
 class HashlibTest(unittest.TestCase):
@@ -112,9 +109,8 @@ class NamedTupleTest(unittest.TestCase):
         class X(namedtuple(name, fields)):
            pass
         """)
-        for base in klass.ancestors():
-            if base.name == 'X':
-                break
+        base = next(base for base in klass.ancestors()
+                    if base.name == 'X')
         self.assertSetEqual({"a", "b", "c"}, set(base.instance_attrs))
 
     def test_namedtuple_inference_failure(self):
@@ -381,8 +377,8 @@ class EnumBrainTest(unittest.TestCase):
 
         """)
 
-        enum = next(module['MyEnum'].infer())
-        one = enum['one']
+        enumeration = next(module['MyEnum'].infer())
+        one = enumeration['one']
         self.assertEqual(one.pytype(), '.MyEnum.one')
 
         property_type = '{}.property'.format(bases.BUILTINS)
@@ -401,8 +397,8 @@ class EnumBrainTest(unittest.TestCase):
                 pass
             test = 42
         ''')
-        enum = module['Enumeration']
-        test = next(enum.igetattr('test'))
+        enumeration = module['Enumeration']
+        test = next(enumeration.igetattr('test'))
         self.assertEqual(test.value, 42)
 
     def test_enum_multiple_base_classes(self):
@@ -415,8 +411,8 @@ class EnumBrainTest(unittest.TestCase):
         class MyEnum(Mixin, enum.Enum):
             one = 1
         """)
-        enum = next(module['MyEnum'].infer())
-        one = enum['one']
+        enumeration = next(module['MyEnum'].infer())
+        one = enumeration['one']
 
         clazz = one.getattr('__class__')[0]
         self.assertTrue(clazz.is_subtype_of('.Mixin'),
@@ -430,8 +426,8 @@ class EnumBrainTest(unittest.TestCase):
             one = 1
         """)
 
-        enum = next(module['MyEnum'].infer())
-        one = enum['one']
+        enumeration = next(module['MyEnum'].infer())
+        one = enumeration['one']
 
         clazz = one.getattr('__class__')[0]
         int_type = '{}.{}'.format(bases.BUILTINS, 'int')
diff --git a/astroid/tests/unittest_builder.py b/astroid/tests/unittest_builder.py
index eb990612..bcd3c4bf 100644
--- a/astroid/tests/unittest_builder.py
+++ b/astroid/tests/unittest_builder.py
@@ -120,7 +120,8 @@ class FromToLineNoTest(unittest.TestCase):
                 print (arg)
             ''', __name__)
         function = astroid['function']
-        self.assertEqual(function.fromlineno, 3) # XXX discussable, but that's what is expected by pylint right now
+        # XXX discussable, but that's what is expected by pylint right now
+        self.assertEqual(function.fromlineno, 3)
         self.assertEqual(function.tolineno, 5)
         self.assertEqual(function.decorators.fromlineno, 2)
         self.assertEqual(function.decorators.tolineno, 2)
@@ -331,7 +332,7 @@ class BuilderTest(unittest.TestCase):
     @test_utils.require_version(maxver='3.0')
     def test_inspect_build_instance(self):
         """test astroid tree build from a living object"""
-        import exceptions
+        import exceptions # pylint: disable=redefined-outer-name
         builtin_ast = self.builder.inspect_build(exceptions)
         fclass = builtin_ast['OSError']
         # things like OSError.strerror are now (2.5) data descriptors on the
@@ -534,6 +535,7 @@ class BuilderTest(unittest.TestCase):
             '''
         builder.parse(code)
         nonetype = nodes.const_factory(None)
+        # pylint: disable=no-member; union type in const_factory, this shouldn't happen
         self.assertNotIn('custom_attr', nonetype.locals)
         self.assertNotIn('custom_attr', nonetype.instance_attrs)
         nonetype = nodes.const_factory({})
diff --git a/astroid/tests/unittest_inference.py b/astroid/tests/unittest_inference.py
index 7ac9fdd4..70eac967 100644
--- a/astroid/tests/unittest_inference.py
+++ b/astroid/tests/unittest_inference.py
@@ -17,6 +17,7 @@
 # with astroid. If not, see <http://www.gnu.org/licenses/>.
 """tests for the astroid inference capabilities
 """
+# pylint: disable=too-many-lines
 import os
 import sys
 from functools import partial
@@ -398,9 +399,12 @@ class InferenceTest(resources.SysPathSetup, unittest.TestCase):
         self.assertIsInstance(nie, nodes.ClassDef)
         nie_ancestors = [c.name for c in nie.ancestors()]
         if sys.version_info < (3, 0):
-            self.assertEqual(nie_ancestors, ['RuntimeError', 'StandardError', 'Exception', 'BaseException', 'object'])
+            expected = ['RuntimeError', 'StandardError',
+                        'Exception', 'BaseException', 'object']
+            self.assertEqual(nie_ancestors, expected)
         else:
-            self.assertEqual(nie_ancestors, ['RuntimeError', 'Exception', 'BaseException', 'object'])
+            expected = ['RuntimeError', 'Exception', 'BaseException', 'object']
+            self.assertEqual(nie_ancestors, expected)
 
     def test_except_inference(self):
         code = '''
@@ -3188,7 +3192,7 @@ class InferenceTest(resources.SysPathSetup, unittest.TestCase):
         ''')
         # This is not supported yet
         inferred = next(ast_node.infer())
-        self.assertIsInstance(inferred, ClassDef)
+        self.assertIsInstance(inferred, nodes.ClassDef)
         self.assertEqual(inferred.name, 'A')
 
 
diff --git a/astroid/tests/unittest_lookup.py b/astroid/tests/unittest_lookup.py
index c91acf70..d4b218c6 100644
--- a/astroid/tests/unittest_lookup.py
+++ b/astroid/tests/unittest_lookup.py
@@ -267,6 +267,7 @@ class LookupTest(resources.SysPathSetup, unittest.TestCase):
         self.assertEqual(len(intstmts), 1)
         self.assertIsInstance(intstmts[0], nodes.ClassDef)
         self.assertEqual(intstmts[0].name, 'int')
+        # pylint: disable=no-member; union type in const_factory, this shouldn't happen
         self.assertIs(intstmts[0], nodes.const_factory(1)._proxied)
 
     def test_decorator_arguments_lookup(self):
diff --git a/astroid/tests/unittest_modutils.py b/astroid/tests/unittest_modutils.py
index 644d33f5..6fc2d98f 100644
--- a/astroid/tests/unittest_modutils.py
+++ b/astroid/tests/unittest_modutils.py
@@ -18,10 +18,13 @@
 """
 unit tests for module modutils (module manipulation utilities)
 """
+import email
 import os
 import sys
 import unittest
+from xml import etree
 
+import astroid
 from astroid import modutils
 from astroid.tests import resources
 
@@ -116,6 +119,7 @@ class LoadModuleFromPathTest(resources.SysPathSetup, unittest.TestCase):
     def test_do_not_load_twice(self):
         modutils.load_module_from_modpath(['data', 'lmfp', 'foo'])
         modutils.load_module_from_modpath(['data', 'lmfp'])
+        # pylint: disable=no-member; just-once is added by a test file dynamically.
         self.assertEqual(len(sys.just_once), 1)
         del sys.just_once
 
@@ -131,24 +135,12 @@ class FileFromModPathTest(resources.SysPathSetup, unittest.TestCase):
         self.assertEqual(os.path.realpath(result), os.path.realpath(filename))
 
     def test_std_lib(self):
-        from os import path
-        self.assertEqual(os.path.realpath(modutils.file_from_modpath(['os', 'path']).replace('.pyc', '.py')),
-                         os.path.realpath(path.__file__.replace('.pyc', '.py')))
-
-    def test_xmlplus(self):
-        try:
-            # don't fail if pyxml isn't installed
-            from xml.dom import ext
-        except ImportError:
-            pass
-        else:
-            self.assertEqual(os.path.realpath(modutils.file_from_modpath(['xml', 'dom', 'ext']).replace('.pyc', '.py')),
-                             os.path.realpath(ext.__file__.replace('.pyc', '.py')))
+        path = modutils.file_from_modpath(['os', 'path']).replace('.pyc', '.py')
+        self.assertEqual(os.path.realpath(path),
+                         os.path.realpath(os.path.__file__.replace('.pyc', '.py')))
 
     def test_builtin(self):
-        self.assertEqual(modutils.file_from_modpath(['sys']),
-                         None)
-
+        self.assertIsNone(modutils.file_from_modpath(['sys']))
 
     def test_unexisting(self):
         self.assertRaises(ImportError, modutils.file_from_modpath, ['turlututu'])
@@ -178,65 +170,61 @@ class StandardLibModuleTest(resources.SysPathSetup, unittest.TestCase):
 
     def test_builtins(self):
         if sys.version_info < (3, 0):
-            self.assertEqual(modutils.is_standard_module('__builtin__'), True)
-            self.assertEqual(modutils.is_standard_module('builtins'), False)
+            self.assertTrue(modutils.is_standard_module('__builtin__'))
+            self.assertFalse(modutils.is_standard_module('builtins'))
         else:
-            self.assertEqual(modutils.is_standard_module('__builtin__'), False)
-            self.assertEqual(modutils.is_standard_module('builtins'), True)
+            self.assertFalse(modutils.is_standard_module('__builtin__'))
+            self.assertTrue(modutils.is_standard_module('builtins'))
 
     def test_builtin(self):
-        self.assertEqual(modutils.is_standard_module('sys'), True)
-        self.assertEqual(modutils.is_standard_module('marshal'), True)
+        self.assertTrue(modutils.is_standard_module('sys'))
+        self.assertTrue(modutils.is_standard_module('marshal'))
 
     def test_nonstandard(self):
-        self.assertEqual(modutils.is_standard_module('astroid'), False)
+        self.assertFalse(modutils.is_standard_module('astroid'))
 
     def test_unknown(self):
-        self.assertEqual(modutils.is_standard_module('unknown'), False)
+        self.assertFalse(modutils.is_standard_module('unknown'))
 
     def test_4(self):
-        self.assertEqual(modutils.is_standard_module('hashlib'), True)
-        self.assertEqual(modutils.is_standard_module('pickle'), True)
-        self.assertEqual(modutils.is_standard_module('email'), True)
-        self.assertEqual(modutils.is_standard_module('io'), sys.version_info >= (2, 6))
-        self.assertEqual(modutils.is_standard_module('StringIO'), sys.version_info < (3, 0))
-        self.assertEqual(modutils.is_standard_module('unicodedata'), True)
+        self.assertTrue(modutils.is_standard_module('hashlib'))
+        self.assertTrue(modutils.is_standard_module('pickle'))
+        self.assertTrue(modutils.is_standard_module('email'))
+        self.assertEqual(modutils.is_standard_module('io'),
+                         sys.version_info >= (2, 6))
+        self.assertEqual(modutils.is_standard_module('StringIO'),
+                         sys.version_info < (3, 0))
+        self.assertTrue(modutils.is_standard_module('unicodedata'))
 
     def test_custom_path(self):
         datadir = resources.find('')
         if datadir.startswith(modutils.EXT_LIB_DIR):
             self.skipTest('known breakage of is_standard_module on installed package')
-        self.assertEqual(modutils.is_standard_module('data.module', (datadir,)), True)
-        self.assertEqual(modutils.is_standard_module('data.module', (os.path.abspath(datadir),)), True)
+
+        self.assertTrue(modutils.is_standard_module('data.module', (datadir,)))
+        self.assertTrue(modutils.is_standard_module('data.module', (os.path.abspath(datadir),)))
 
     def test_failing_edge_cases(self):
-        from xml import etree
         # using a subpackage/submodule path as std_path argument
-        self.assertEqual(modutils.is_standard_module('xml.etree', etree.__path__), False)
+        self.assertFalse(modutils.is_standard_module('xml.etree', etree.__path__))
         # using a module + object name as modname argument
-        self.assertEqual(modutils.is_standard_module('sys.path'), True)
+        self.assertTrue(modutils.is_standard_module('sys.path'))
         # this is because only the first package/module is considered
-        self.assertEqual(modutils.is_standard_module('sys.whatever'), True)
-        self.assertEqual(modutils.is_standard_module('xml.whatever', etree.__path__), False)
+        self.assertTrue(modutils.is_standard_module('sys.whatever'))
+        self.assertFalse(modutils.is_standard_module('xml.whatever', etree.__path__))
 
 
 class IsRelativeTest(unittest.TestCase):
 
-
     def test_knownValues_is_relative_1(self):
-        import email
-        self.assertEqual(modutils.is_relative('utils', email.__path__[0]),
-                         True)
+        self.assertTrue(modutils.is_relative('utils', email.__path__[0]))
 
     def test_knownValues_is_relative_2(self):
-        from xml.etree import ElementTree
-        self.assertEqual(modutils.is_relative('ElementPath', ElementTree.__file__),
-                         True)
+        self.assertTrue(modutils.is_relative('ElementPath',
+                                             etree.ElementTree.__file__))
 
     def test_knownValues_is_relative_3(self):
-        import astroid
-        self.assertEqual(modutils.is_relative('astroid', astroid.__path__[0]),
-                         False)
+        self.assertFalse(modutils.is_relative('astroid', astroid.__path__[0]))
 
 
 class GetModuleFilesTest(unittest.TestCase):
diff --git a/astroid/tests/unittest_nodes.py b/astroid/tests/unittest_nodes.py
index 7050b883..1952bba0 100644
--- a/astroid/tests/unittest_nodes.py
+++ b/astroid/tests/unittest_nodes.py
@@ -74,7 +74,7 @@ class AsStringTest(resources.SysPathSetup, unittest.TestCase):
         self.assertEqual(binop.as_string(), '([arg]) * (1)')
 
     def test_frozenset_as_string(self):
-        nodes = test_utils.extract_node('''
+        ast_nodes = test_utils.extract_node('''
         frozenset((1, 2, 3)) #@
         frozenset({1, 2, 3}) #@
         frozenset([1, 2, 3,]) #@
@@ -82,14 +82,14 @@ class AsStringTest(resources.SysPathSetup, unittest.TestCase):
         frozenset(None) #@
         frozenset(1) #@
         ''')
-        nodes = [next(node.infer()) for node in nodes]
+        ast_nodes = [next(node.infer()) for node in ast_nodes]
 
-        self.assertEqual(nodes[0].as_string(), 'frozenset((1, 2, 3))')
-        self.assertEqual(nodes[1].as_string(), 'frozenset({1, 2, 3})')
-        self.assertEqual(nodes[2].as_string(), 'frozenset([1, 2, 3])')
+        self.assertEqual(ast_nodes[0].as_string(), 'frozenset((1, 2, 3))')
+        self.assertEqual(ast_nodes[1].as_string(), 'frozenset({1, 2, 3})')
+        self.assertEqual(ast_nodes[2].as_string(), 'frozenset([1, 2, 3])')
 
-        self.assertNotEqual(nodes[3].as_string(), 'frozenset(None)')
-        self.assertNotEqual(nodes[4].as_string(), 'frozenset(1)')
+        self.assertNotEqual(ast_nodes[3].as_string(), 'frozenset(None)')
+        self.assertNotEqual(ast_nodes[4].as_string(), 'frozenset(1)')
 
     def test_varargs_kwargs_as_string(self):
         ast = abuilder.string_build('raise_string(*args, **kwargs)').body[0]
@@ -186,9 +186,9 @@ class _NodeTest(unittest.TestCase):
         try:
             return self.__class__.__dict__['CODE_Astroid']
         except KeyError:
-            astroid = builder.parse(self.CODE)
-            self.__class__.CODE_Astroid = astroid
-            return astroid
+            module = builder.parse(self.CODE)
+            self.__class__.CODE_Astroid = module
+            return module
 
 
 class IfNodeTest(_NodeTest):
@@ -384,8 +384,8 @@ from ..cave import wine\n\n"""
             except PickleError:
                 pass
         '''
-        astroid = builder.parse(code)
-        handler_type = astroid.body[1].handlers[0].type
+        module = builder.parse(code)
+        handler_type = module.body[1].handlers[0].type
 
         excs = list(node_classes.unpack_infer(handler_type))
         # The number of returned object can differ on Python 2
@@ -397,18 +397,18 @@ from ..cave import wine\n\n"""
         self.assertIs(excs[-1], util.Uninferable)
 
     def test_absolute_import(self):
-        astroid = resources.build_file('data/absimport.py')
+        module = resources.build_file('data/absimport.py')
         ctx = contextmod.InferenceContext()
         # will fail if absolute import failed
         ctx.lookupname = 'message'
-        next(astroid['message'].infer(ctx))
+        next(module['message'].infer(ctx))
         ctx.lookupname = 'email'
-        m = next(astroid['email'].infer(ctx))
+        m = next(module['email'].infer(ctx))
         self.assertFalse(m.file.startswith(os.path.join('data', 'email.py')))
 
     def test_more_absolute_import(self):
-        astroid = resources.build_file('data/module1abs/__init__.py', 'data.module1abs')
-        self.assertIn('sys', astroid.locals)
+        module = resources.build_file('data/module1abs/__init__.py', 'data.module1abs')
+        self.assertIn('sys', module.locals)
 
 
 class CmpNodeTest(unittest.TestCase):
@@ -420,6 +420,7 @@ class CmpNodeTest(unittest.TestCase):
 class ConstNodeTest(unittest.TestCase):
 
     def _test(self, value):
+        # pylint: disable=no-member; union type in const_factory, this shouldn't happen
         node = nodes.const_factory(value)
         self.assertIsInstance(node._proxied, nodes.ClassDef)
         self.assertEqual(node._proxied.name, value.__class__.__name__)
@@ -804,9 +805,8 @@ class ContextTest(unittest.TestCase):
     def test_starred_store(self):
         node = test_utils.extract_node('a, *b = 1, 2')
         starred = node.targets[0].elts[1]
-        self.assertIs(starred.ctx, astroid.Store) 
-        
-        
+        self.assertIs(starred.ctx, astroid.Store)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/astroid/tests/unittest_protocols.py b/astroid/tests/unittest_protocols.py
index 3b7b4fd0..c0045c77 100644
--- a/astroid/tests/unittest_protocols.py
+++ b/astroid/tests/unittest_protocols.py
@@ -160,7 +160,7 @@ class ProtocolTests(unittest.TestCase):
         assigned = list(simple_mul_assnode_2.assigned_stmts())
         self.assertNameNodesEqual(['c'], assigned)
 
-    def test_sequence_assigned_stmts_not_accepting_empty_node(self):        
+    def test_sequence_assigned_stmts_not_accepting_empty_node(self):
         def transform(node):
             node.root().locals['__all__'] = [node.value]
 
diff --git a/astroid/tests/unittest_raw_building.py b/astroid/tests/unittest_raw_building.py
index 2bdaac17..5933d4bf 100644
--- a/astroid/tests/unittest_raw_building.py
+++ b/astroid/tests/unittest_raw_building.py
@@ -40,12 +40,14 @@ class RawBuildingTC(unittest.TestCase):
 
     def test_build_function_args(self):
         args = ['myArgs1', 'myArgs2']
+        # pylint: disable=no-member; not aware of postinit
         node = build_function('MyFunction', args)
         self.assertEqual('myArgs1', node.args.args[0].name)
         self.assertEqual('myArgs2', node.args.args[1].name)
         self.assertEqual(2, len(node.args.args))
 
     def test_build_function_defaults(self):
+        # pylint: disable=no-member; not aware of postinit
         defaults = ['defaults1', 'defaults2']
         node = build_function('MyFunction', None, defaults)
         self.assertEqual(2, len(node.args.defaults))
diff --git a/astroid/tests/unittest_regrtest.py b/astroid/tests/unittest_regrtest.py
index e409172d..3e6c9b6a 100644
--- a/astroid/tests/unittest_regrtest.py
+++ b/astroid/tests/unittest_regrtest.py
@@ -282,23 +282,23 @@ def test():
         ''')
         self.assertRaises(exceptions.InferenceError, next, node.infer())
 
-    def test_unicode_in_docstring(self):

-        # Crashed for astroid==1.4.1

-        # Test for https://bitbucket.org/logilab/astroid/issues/273/

-

-        # In a regular file, "coding: utf-8" would have been used.

-        node = extract_node(u'''

-        from __future__ import unicode_literals

-

-        class MyClass(object):

-            def method(self):

-                "With unicode : %s "

-

-        instance = MyClass()

-        ''' % u"\u2019")

-

-        next(node.value.infer()).as_string()

-

+    def test_unicode_in_docstring(self):
+        # Crashed for astroid==1.4.1
+        # Test for https://bitbucket.org/logilab/astroid/issues/273/
+
+        # In a regular file, "coding: utf-8" would have been used.
+        node = extract_node(u'''
+        from __future__ import unicode_literals
+
+        class MyClass(object):
+            def method(self):
+                "With unicode : %s "
+
+        instance = MyClass()
+        ''' % u"\u2019")
+
+        next(node.value.infer()).as_string()
+
 
 class Whatever(object):
     a = property(lambda x: x, lambda x: x)
diff --git a/astroid/tests/unittest_scoped_nodes.py b/astroid/tests/unittest_scoped_nodes.py
index e5516a46..c4cb747b 100644
--- a/astroid/tests/unittest_scoped_nodes.py
+++ b/astroid/tests/unittest_scoped_nodes.py
@@ -170,9 +170,9 @@ class ModuleNodeTest(ModuleLoader, unittest.TestCase):
 
             expected = ("Relative import with too many levels "
                         "({level}) for module {name!r}".format(
-                        level=level - 1, name=mod.name))
+                            level=level - 1, name=mod.name))
             self.assertEqual(expected, str(cm.exception))
-            
+
     def test_import_1(self):
         data = '''from . import subpackage'''
         sys.path.insert(0, resources.find('data'))
@@ -253,7 +253,8 @@ class FunctionNodeTest(ModuleLoader, unittest.TestCase):
         self.assertEqual(func.getattr('__name__')[0].value, 'make_class')
         self.assertEqual(len(func.getattr('__doc__')), 1)
         self.assertIsInstance(func.getattr('__doc__')[0], nodes.Const)
-        self.assertEqual(func.getattr('__doc__')[0].value, 'check base is correctly resolved to Concrete0')
+        self.assertEqual(func.getattr('__doc__')[0].value,
+                         'check base is correctly resolved to Concrete0')
         self.assertEqual(len(self.module.getattr('__dict__')), 1)
         self.assertIsInstance(self.module.getattr('__dict__')[0], nodes.Dict)
 
@@ -1075,7 +1076,7 @@ class ClassNodeTest(ModuleLoader, unittest.TestCase):
         self.assertIn('JJJ', ancestors)
 
     def test_no_infinite_metaclass_loop_with_redefine(self):
-        nodes = test_utils.extract_node("""
+        ast_nodes = test_utils.extract_node("""
             import datetime
 
             class A(datetime.date): #@
@@ -1089,7 +1090,7 @@ class ClassNodeTest(ModuleLoader, unittest.TestCase):
             datetime.date = A
             datetime.date = B
         """)
-        for klass in nodes:
+        for klass in ast_nodes:
             self.assertEqual(None, klass.metaclass())
 
     def test_metaclass_generator_hack(self):
diff --git a/pylintrc b/pylintrc
index 812cdcb4..06f36690 100644
--- a/pylintrc
+++ b/pylintrc
@@ -70,7 +70,7 @@ confidence=
 # Enable the message, report, category or checker with the given id(s). You can


 # either give multiple identifier separated by comma (,) or put this option


 # multiple time. See also the "--disable" option for examples.

-#enable=

+enable=useless-suppression

 

 # Disable the message, report, category or checker with the given id(s). You


 # can either give multiple identifiers separated by comma (,) or put this


@@ -81,20 +81,34 @@ confidence=
 # --enable=similarities". If you want to run only the classes checker, but have


 # no Warning level messages displayed, use"--disable=all --enable=classes


 # --disable=W"

-disable=invalid-name,protected-access,no-self-use,unused-argument,

-        no-member,line-too-long,too-many-branches,too-few-public-methods,

-        too-many-public-methods,too-many-instance-attributes,

-        super-init-not-called,redefined-builtin,cyclic-import,

-        too-many-return-statements,redefined-outer-name,undefined-variable,

-        too-many-locals,method-hidden,duplicate-code,attribute-defined-outside-init,

-        fixme,missing-docstring,too-many-lines,too-many-statements,undefined-loop-variable,

-        unpacking-non-sequence,import-error,no-name-in-module,bad-builtin,too-many-arguments

+

+disable=fixme,invalid-name, missing-docstring, too-few-public-methods,

+        too-many-public-methods,

+        # We know about it and we're doing our best to remove it

+        # in 2.0

+        cyclic-import,

+        # The check is faulty in most cases and it doesn't take in

+        # account how the variable is being used. For instance,

+        # using a variable that is a list or a generator in an

+        # iteration context is fine.

+        redefined-variable-type,

+        # Requires major redesign for fixing this (and private

+        # access in the same project is fine)

+        protected-access,

+        # Most of them are conforming to an API. Putting staticmethod

+        # all over the place changes the aesthetics when these methods

+        # are following a local pattern (visit methods for instance).

+        no-self-use,

+        # API requirements in most of the occurences

+        unused-argument,

+        # Not very useful when it warns about imports..

+        duplicate-code,

 

 

 [BASIC]

 

 # List of builtins function names that should not be used, separated by a comma

-bad-functions=map,filter

+bad-functions=

 

 # Good variable names which should always be accepted, separated by a comma

 good-names=i,j,k,ex,Run,_

@@ -193,8 +207,8 @@ single-line-if-stmt=no
 # List of optional constructs for which whitespace checking is disabled

 no-space-check=trailing-comma,dict-separator

 

-# Maximum number of lines in a module

-max-module-lines=1000

+# Maximum number of lines in a module 

+max-module-lines=3000

 

 # String used as indentation unit. This is usually " " (4 spaces) or "\t" (1


 # tab).

@@ -310,29 +324,29 @@ exclude-protected=_asdict,_fields,_replace,_source,_make
 [DESIGN]

 

 # Maximum number of arguments for function / method

-max-args=5

+max-args=10

 

 # Argument names that match this expression will be ignored. Default to name


 # with leading underscore

 ignored-argument-names=_.*

 

 # Maximum number of locals for function / method body

-max-locals=15

+max-locals=25

 

 # Maximum number of return / yield for function / method body

-max-returns=6

+max-returns=10

 

 # Maximum number of branch for function / method body

-max-branches=12

+max-branches=25

 

 # Maximum number of statements in function / method body

-max-statements=50

+max-statements=60

 

 # Maximum number of parents for a class (see R0901).

 max-parents=10

 

 # Maximum number of attributes for a class (see R0902).

-max-attributes=7

+max-attributes=15

 

 # Minimum number of public methods for a class (see R0903).

 min-public-methods=2