From 5c1d9ddd0a708d6dac9b9a49214376341b97f9f9 Mon Sep 17 00:00:00 2001
From: Dimitrios Semitsoglou-Tsiapos <dsemitso@cern.ch>
Date: Tue, 17 Feb 2015 19:09:57 +0100
Subject: [PATCH 01/10] rope: correct refactoring function calls

* (Temporarily) drops passing of `task_handle`.
---
 pymode/rope.py | 68 +++++++++++++++++++++-----------------------------
 1 file changed, 28 insertions(+), 40 deletions(-)

diff --git a/pymode/rope.py b/pymode/rope.py
index 159900bf..2b12bd43 100644
--- a/pymode/rope.py
+++ b/pymode/rope.py
@@ -505,14 +505,7 @@ def get_input_str(refactor, ctx):
 
     @staticmethod
     def get_changes(refactor, input_str, in_hierarchy=False):
-        """ Get changes.
-
-        :return Changes:
-
-        """
-        progress = ProgressHandler('Calculate changes ...')
-        return refactor.get_changes(
-            input_str, task_handle=progress.handle, in_hierarchy = in_hierarchy)
+        raise NotImplementedError
 
 
 class RenameRefactoring(Refactoring):
@@ -550,8 +543,26 @@ def get_input_str(self, refactor, ctx):
 
         return newname
 
+    @staticmethod
+    def get_changes(refactor, input_str, in_hierarchy):
+        """ Get changes.
+
+        :return Changes:
+
+        """
+        return refactor.get_changes(input_str, in_hierarchy=in_hierarchy)
+
+class ExtractRefactoring(Refactoring):
+    @staticmethod
+    def get_changes(refactor, input_str, in_hierarchy):
+        """ Get changes.
+
+        :return Changes:
+
+        """
+        return refactor.get_changes(input_str) #, global_=not in_hierarchy)
 
-class ExtractMethodRefactoring(Refactoring):
+class ExtractMethodRefactoring(ExtractRefactoring):
 
     """ Extract method. """
 
@@ -574,18 +585,8 @@ def get_refactor(ctx):
         return extract.ExtractMethod(
             ctx.project, ctx.resource, offset1, offset2)
 
-    @staticmethod
-    def get_changes(refactor, input_str):
-        """ Get changes.
 
-        :return Changes:
-
-        """
-
-        return refactor.get_changes(input_str)
-
-
-class ExtractVariableRefactoring(Refactoring):
+class ExtractVariableRefactoring(ExtractRefactoring):
 
     """ Extract variable. """
 
@@ -608,16 +609,6 @@ def get_refactor(ctx):
         return extract.ExtractVariable(
             ctx.project, ctx.resource, offset1, offset2)
 
-    @staticmethod
-    def get_changes(refactor, input_str):
-        """ Get changes.
-
-        :return Changes:
-
-        """
-
-        return refactor.get_changes(input_str)
-
 
 class InlineRefactoring(Refactoring):
 
@@ -634,14 +625,13 @@ def get_refactor(ctx):
         return inline.create_inline(ctx.project, ctx.resource, offset)
 
     @staticmethod
-    def get_changes(refactor, input_str):
+    def get_changes(refactor, input_str, in_hierarchy):
         """ Get changes.
 
         :return Changes:
 
         """
-        progress = ProgressHandler('Calculate changes ...')
-        return refactor.get_changes(task_handle=progress.handle)
+        return refactor.get_changes()
 
 
 class UseFunctionRefactoring(Refactoring):
@@ -659,15 +649,13 @@ def get_refactor(ctx):
         return usefunction.UseFunction(ctx.project, ctx.resource, offset)
 
     @staticmethod
-    def get_changes(refactor, input_str):
+    def get_changes(refactor, input_str, in_hierarchy):
         """ Get changes.
 
         :return Changes:
 
         """
-        progress = ProgressHandler('Calculate changes ...')
-        return refactor.get_changes(
-            resources=[refactor.resource], task_handle=progress.handle)
+        return refactor.get_changes()
 
 
 class ModuleToPackageRefactoring(Refactoring):
@@ -684,7 +672,7 @@ def get_refactor(ctx):
         return ModuleToPackage(ctx.project, ctx.resource)
 
     @staticmethod
-    def get_changes(refactor, input_str):
+    def get_changes(refactor, input_str, in_hierarchy):
         """ Get changes.
 
         :return Changes:
@@ -746,7 +734,7 @@ def get_refactor(ctx):
         return change_signature.ChangeSignature(
             ctx.project, ctx.resource, offset)
 
-    def get_changes(self, refactor, input_string):
+    def get_changes(self, refactor, input_string, in_hierarchy):
         """ Function description.
 
         :return Rope.changes:
@@ -771,7 +759,7 @@ def get_changes(self, refactor, input_string):
         changers.append(change_signature.ArgumentReorderer(
             order, autodef='None'))
 
-        return refactor.get_changes(changers)
+        return refactor.get_changes(changers, in_hierarchy=in_hierarchy)
 
 
 class GenerateElementRefactoring(Refactoring):

From bf7336200fec9a1726e1bc0d8896ca31e18b73f4 Mon Sep 17 00:00:00 2001
From: Tyler Fenby <tylerfenby@gmail.com>
Date: Sun, 21 Dec 2014 17:37:43 -0500
Subject: [PATCH 02/10] Upgrade included rope libs to latest releases

rope: 0.10.2
rope_py3k: 0.9.4-1
---
 pymode/libs2/rope/__init__.py                 |   2 +-
 pymode/libs2/rope/base/arguments.py           |   2 +
 pymode/libs2/rope/base/builtins.py            |  67 ++++--
 pymode/libs2/rope/base/change.py              |  12 +-
 pymode/libs2/rope/base/codeanalyze.py         |  16 +-
 pymode/libs2/rope/base/default_config.py      |  12 +-
 pymode/libs2/rope/base/evaluate.py            |  16 +-
 pymode/libs2/rope/base/fscommands.py          |   3 +-
 pymode/libs2/rope/base/libutils.py            |  67 +++++-
 pymode/libs2/rope/base/oi/doa.py              |  11 +-
 pymode/libs2/rope/base/oi/runmod.py           |  19 +-
 pymode/libs2/rope/base/oi/soa.py              |   5 +-
 pymode/libs2/rope/base/oi/soi.py              |  11 +
 pymode/libs2/rope/base/oi/transform.py        |  12 +-
 pymode/libs2/rope/base/prefs.py               |   2 +-
 pymode/libs2/rope/base/project.py             | 118 +++++++++-
 pymode/libs2/rope/base/pycore.py              | 134 +++--------
 pymode/libs2/rope/base/pynames.py             |  14 +-
 pymode/libs2/rope/base/pyobjectsdef.py        |  41 ++--
 pymode/libs2/rope/base/pyscopes.py            |   7 +-
 pymode/libs2/rope/base/resourceobserver.py    |   3 +-
 pymode/libs2/rope/base/resources.py           |  56 ++++-
 pymode/libs2/rope/base/stdmods.py             |  10 +-
 pymode/libs2/rope/base/taskhandle.py          |   2 -
 pymode/libs2/rope/base/utils.py               |   5 +
 pymode/libs2/rope/base/worder.py              |  21 +-
 pymode/libs2/rope/contrib/autoimport.py       |  29 ++-
 pymode/libs2/rope/contrib/codeassist.py       | 119 +++++++---
 pymode/libs2/rope/contrib/finderrors.py       |   2 +-
 pymode/libs2/rope/contrib/findit.py           |  24 +-
 pymode/libs2/rope/contrib/fixmodnames.py      |   4 +-
 pymode/libs2/rope/contrib/fixsyntax.py        |  28 ++-
 pymode/libs2/rope/contrib/generate.py         |  43 ++--
 pymode/libs2/rope/refactor/__init__.py        |   4 +-
 .../libs2/rope/refactor/change_signature.py   |  50 ++--
 .../libs2/rope/refactor/encapsulate_field.py  |  39 ++--
 pymode/libs2/rope/refactor/extract.py         |  39 ++--
 pymode/libs2/rope/refactor/functionutils.py   |  22 +-
 .../rope/refactor/importutils/__init__.py     |  76 ++++---
 .../rope/refactor/importutils/actions.py      |  92 ++++----
 .../rope/refactor/importutils/importinfo.py   |  16 +-
 .../refactor/importutils/module_imports.py    | 109 ++++++---
 pymode/libs2/rope/refactor/inline.py          | 160 +++++++------
 .../libs2/rope/refactor/introduce_factory.py  |  30 +--
 .../rope/refactor/introduce_parameter.py      |   9 +-
 pymode/libs2/rope/refactor/localtofield.py    |  11 +-
 pymode/libs2/rope/refactor/method_object.py   |  21 +-
 pymode/libs2/rope/refactor/move.py            | 213 +++++++++++++-----
 pymode/libs2/rope/refactor/multiproject.py    |   8 +-
 pymode/libs2/rope/refactor/occurrences.py     | 104 ++++++---
 pymode/libs2/rope/refactor/patchedast.py      |  37 ++-
 pymode/libs2/rope/refactor/rename.py          |  40 ++--
 pymode/libs2/rope/refactor/restructure.py     |  24 +-
 pymode/libs2/rope/refactor/similarfinder.py   |  34 +--
 pymode/libs2/rope/refactor/sourceutils.py     |   9 +-
 pymode/libs2/rope/refactor/suites.py          |   1 +
 pymode/libs2/rope/refactor/topackage.py       |   8 +-
 pymode/libs2/rope/refactor/usefunction.py     |  15 +-
 pymode/libs2/rope/refactor/wildcards.py       |   6 +-
 pymode/libs3/rope/__init__.py                 |   2 +-
 pymode/libs3/rope/refactor/patchedast.py      |  26 +--
 pymode/libs3/rope/refactor/suites.py          |   9 -
 62 files changed, 1331 insertions(+), 800 deletions(-)

diff --git a/pymode/libs2/rope/__init__.py b/pymode/libs2/rope/__init__.py
index 19466380..c8e11f68 100644
--- a/pymode/libs2/rope/__init__.py
+++ b/pymode/libs2/rope/__init__.py
@@ -1,7 +1,7 @@
 """rope, a python refactoring library"""
 
 INFO = __doc__
-VERSION = '0.9.4'
+VERSION = '0.10.2'
 COPYRIGHT = """\
 Copyright (C) 2006-2012 Ali Gholami Rudi
 Copyright (C) 2009-2012 Anton Gritsay
diff --git a/pymode/libs2/rope/base/arguments.py b/pymode/libs2/rope/base/arguments.py
index 342e2ae5..7ba43640 100644
--- a/pymode/libs2/rope/base/arguments.py
+++ b/pymode/libs2/rope/base/arguments.py
@@ -72,6 +72,8 @@ def get_pynames(self, parameters):
 
     def get_instance_pyname(self):
         return self.pynames[0]
+
+
 class MixedArguments(object):
 
     def __init__(self, pyname, arguments, scope):
diff --git a/pymode/libs2/rope/base/builtins.py b/pymode/libs2/rope/base/builtins.py
index 78e7afb0..5bb84859 100644
--- a/pymode/libs2/rope/base/builtins.py
+++ b/pymode/libs2/rope/base/builtins.py
@@ -149,8 +149,10 @@ def _get_builtin(*args):
         return cls._generated[args]
     return _get_builtin
 
+
 def _create_builtin_getter(cls):
     type_getter = _create_builtin_type_getter(cls)
+
     def _get_builtin(*args):
         return pyobjects.PyObject(type_getter(*args))
     return _get_builtin
@@ -233,7 +235,7 @@ def __call__(self, name, returned=None, function=None,
         except AttributeError:
             if check_existence:
                 raise
-            builtin=None
+            builtin = None
         self.attributes[name] = BuiltinName(
             BuiltinFunction(returned=returned, function=function,
                             argnames=argnames, builtin=builtin))
@@ -252,7 +254,8 @@ def __init__(self, holding=None):
         collector('__new__', function=self._new_list)
 
         # Adding methods
-        collector('append', function=self._list_add, argnames=['self', 'value'])
+        collector('append', function=self._list_add,
+                  argnames=['self', 'value'])
         collector('__setitem__', function=self._list_add,
                   argnames=['self', 'index', 'value'])
         collector('insert', function=self._list_add,
@@ -306,7 +309,6 @@ class Dict(BuiltinClass):
     def __init__(self, keys=None, values=None):
         self.keys = keys
         self.values = values
-        item = get_tuple(self.keys, self.values)
         collector = _AttributeCollector(dict)
         collector('__new__', function=self._new_dict)
         collector('__setitem__', function=self._dict_add)
@@ -327,7 +329,8 @@ def do_create(holding=None):
             if holding is None:
                 return get_dict()
             type = holding.get_type()
-            if isinstance(type, Tuple) and len(type.get_holding_objects()) == 2:
+            if isinstance(type, Tuple) and \
+                    len(type.get_holding_objects()) == 2:
                 return get_dict(*type.get_holding_objects())
         return _create_builtin(args, do_create)
 
@@ -384,7 +387,7 @@ def _self_set(self, context):
         if new_dict and isinstance(new_dict.get_object().get_type(), Dict):
             args = arguments.ObjectArguments([new_dict])
             items = new_dict.get_object()['popitem'].\
-                    get_object().get_returned_object(args)
+                get_object().get_returned_object(args)
             context.save_per_name(items)
         else:
             holding = _infer_sequence_for_pyname(new_dict)
@@ -405,7 +408,8 @@ def __init__(self, *objects):
             first = objects[0]
         attributes = {
             '__getitem__': BuiltinName(BuiltinFunction(first)),
-            '__getslice__': BuiltinName(BuiltinFunction(pyobjects.PyObject(self))),
+            '__getslice__':
+            BuiltinName(BuiltinFunction(pyobjects.PyObject(self))),
             '__new__': BuiltinName(BuiltinFunction(function=self._new_tuple)),
             '__iter__': BuiltinName(BuiltinFunction(get_iterator(first)))}
         super(Tuple, self).__init__(tuple, attributes)
@@ -485,8 +489,9 @@ def __init__(self):
 
         self_methods = ['__getitem__', '__getslice__', 'capitalize', 'center',
                         'decode', 'encode', 'expandtabs', 'join', 'ljust',
-                        'lower', 'lstrip', 'replace', 'rjust', 'rstrip', 'strip',
-                        'swapcase', 'title', 'translate', 'upper', 'zfill']
+                        'lower', 'lstrip', 'replace', 'rjust', 'rstrip',
+                        'strip', 'swapcase', 'title', 'translate', 'upper',
+                        'zfill']
         for method in self_methods:
             collector(method, self_object)
 
@@ -514,6 +519,7 @@ def get_object(self):
     def get_definition_location(self):
         return (None, None)
 
+
 class Iterator(pyobjects.AbstractClass):
 
     def __init__(self, holding=None):
@@ -539,7 +545,8 @@ def __init__(self, holding=None):
         self.holding = holding
         self.attributes = {
             'next': BuiltinName(BuiltinFunction(self.holding)),
-            '__iter__': BuiltinName(BuiltinFunction(get_iterator(self.holding))),
+            '__iter__': BuiltinName(BuiltinFunction(
+                get_iterator(self.holding))),
             'close': BuiltinName(BuiltinFunction()),
             'send': BuiltinName(BuiltinFunction()),
             'throw': BuiltinName(BuiltinFunction())}
@@ -556,10 +563,10 @@ def get_returned_object(self, args):
 class File(BuiltinClass):
 
     def __init__(self):
-        self_object = pyobjects.PyObject(self)
         str_object = get_str()
         str_list = get_list(get_str())
         attributes = {}
+
         def add(name, returned=None, function=None):
             builtin = getattr(file, name, None)
             attributes[name] = BuiltinName(
@@ -587,7 +594,8 @@ def __init__(self, fget=None, fset=None, fdel=None, fdoc=None):
             'fget': BuiltinName(BuiltinFunction()),
             'fset': BuiltinName(pynames.UnboundName()),
             'fdel': BuiltinName(pynames.UnboundName()),
-            '__new__': BuiltinName(BuiltinFunction(function=_property_function))}
+            '__new__': BuiltinName(
+                BuiltinFunction(function=_property_function))}
         super(Property, self).__init__(property, attributes)
 
     def get_property_object(self, args):
@@ -631,7 +639,7 @@ def get_attributes(self):
         return {}
 
     def get_name(self):
-        return  'lambda'
+        return 'lambda'
 
     def get_param_names(self, special_args=True):
         result = [node.id for node in self.arguments.args
@@ -671,7 +679,7 @@ def _infer_sequence_for_pyname(pyname):
         iter = obj.get_returned_object(args)
         if iter is not None and 'next' in iter:
             holding = iter['next'].get_object().\
-                      get_returned_object(args)
+                get_returned_object(args)
             return holding
 
 
@@ -690,12 +698,15 @@ def _create_builtin(args, creator):
 def _range_function(args):
     return get_list()
 
+
 def _reversed_function(args):
     return _create_builtin(args, get_iterator)
 
+
 def _sorted_function(args):
     return _create_builtin(args, get_list)
 
+
 def _super_function(args):
     passed_class, passed_self = args.get_arguments(['type', 'self'])
     if passed_self is None:
@@ -709,6 +720,7 @@ def _super_function(args):
                 return pyobjects.PyObject(supers[0])
         return passed_self
 
+
 def _zip_function(args):
     args = args.get_pynames(['sequence'])
     objects = []
@@ -721,6 +733,7 @@ def _zip_function(args):
     tuple = get_tuple(*objects)
     return get_list(tuple)
 
+
 def _enumerate_function(args):
     passed = args.get_pynames(['sequence'])[0]
     if passed is None:
@@ -730,6 +743,7 @@ def _enumerate_function(args):
     tuple = get_tuple(None, holding)
     return get_iterator(tuple)
 
+
 def _iter_function(args):
     passed = args.get_pynames(['sequence'])[0]
     if passed is None:
@@ -738,6 +752,7 @@ def _iter_function(args):
         holding = _infer_sequence_for_pyname(passed)
     return get_iterator(holding)
 
+
 def _input_function(args):
     return get_str()
 
@@ -751,17 +766,25 @@ def _input_function(args):
     'file': BuiltinName(get_file_type()),
     'open': BuiltinName(get_file_type()),
     'unicode': BuiltinName(get_str_type()),
-    'range': BuiltinName(BuiltinFunction(function=_range_function, builtin=range)),
-    'reversed': BuiltinName(BuiltinFunction(function=_reversed_function, builtin=reversed)),
-    'sorted': BuiltinName(BuiltinFunction(function=_sorted_function, builtin=sorted)),
-    'super': BuiltinName(BuiltinFunction(function=_super_function, builtin=super)),
-    'property': BuiltinName(BuiltinFunction(function=_property_function, builtin=property)),
+    'range': BuiltinName(BuiltinFunction(function=_range_function,
+                         builtin=range)),
+    'reversed': BuiltinName(BuiltinFunction(function=_reversed_function,
+                            builtin=reversed)),
+    'sorted': BuiltinName(BuiltinFunction(function=_sorted_function,
+                          builtin=sorted)),
+    'super': BuiltinName(BuiltinFunction(function=_super_function,
+                         builtin=super)),
+    'property': BuiltinName(BuiltinFunction(function=_property_function,
+                            builtin=property)),
     'zip': BuiltinName(BuiltinFunction(function=_zip_function, builtin=zip)),
-    'enumerate': BuiltinName(BuiltinFunction(function=_enumerate_function, builtin=enumerate)),
+    'enumerate': BuiltinName(BuiltinFunction(function=_enumerate_function,
+                             builtin=enumerate)),
     'object': BuiltinName(BuiltinObject()),
     'type': BuiltinName(BuiltinType()),
-    'iter': BuiltinName(BuiltinFunction(function=_iter_function, builtin=iter)),
-    'raw_input': BuiltinName(BuiltinFunction(function=_input_function, builtin=raw_input)),
-    }
+    'iter': BuiltinName(BuiltinFunction(function=_iter_function,
+                        builtin=iter)),
+    'raw_input': BuiltinName(BuiltinFunction(function=_input_function,
+                             builtin=raw_input)),
+}
 
 builtins = BuiltinModule('__builtin__', initial=_initial_builtins)
diff --git a/pymode/libs2/rope/base/change.py b/pymode/libs2/rope/base/change.py
index 8d19aac1..e9764484 100644
--- a/pymode/libs2/rope/base/change.py
+++ b/pymode/libs2/rope/base/change.py
@@ -2,7 +2,6 @@
 import difflib
 import os
 import time
-import warnings
 
 import rope.base.fscommands
 from rope.base import taskhandle, exceptions, utils
@@ -17,13 +16,13 @@ class Change(object):
 
     def do(self, job_set=None):
         """Perform the change
-        
+
         .. note:: Do use this directly.  Use `Project.do()` instead.
         """
 
     def undo(self, job_set=None):
         """Perform the change
-        
+
         .. note:: Do use this directly.  Use `History.undo()` instead.
         """
 
@@ -97,7 +96,8 @@ def __str__(self):
             date = datetime.datetime.fromtimestamp(self.time)
             if date.date() == datetime.date.today():
                 string_date = 'today'
-            elif date.date() == (datetime.date.today() - datetime.timedelta(1)):
+            elif date.date() == (datetime.date.today() -
+                                 datetime.timedelta(1)):
                 string_date = 'yesterday'
             elif date.year == datetime.date.today().year:
                 string_date = date.strftime('%b %d')
@@ -257,7 +257,8 @@ class CreateFolder(CreateResource):
     """
 
     def __init__(self, parent, name):
-        resource = parent.project.get_folder(self._get_child_path(parent, name))
+        resource = parent.project.get_folder(
+            self._get_child_path(parent, name))
         super(CreateFolder, self).__init__(resource)
 
 
@@ -309,6 +310,7 @@ def count_changes(change):
         return result
     return 1
 
+
 def create_job_set(task_handle, change):
     return task_handle.create_jobset(str(change), count_changes(change))
 
diff --git a/pymode/libs2/rope/base/codeanalyze.py b/pymode/libs2/rope/base/codeanalyze.py
index 3d2a2a45..87061912 100644
--- a/pymode/libs2/rope/base/codeanalyze.py
+++ b/pymode/libs2/rope/base/codeanalyze.py
@@ -18,6 +18,7 @@ def add_change(self, start, end, new_text=None):
     def get_changed(self):
         if not self.changes:
             return None
+
         def compare_changes(change1, change2):
             return cmp(change1[:2], change2[:2])
         self.changes.sort(compare_changes)
@@ -131,6 +132,7 @@ def __call__(self):
         return result
 
     _main_chars = re.compile(r'[\'|"|#|\\|\[|\]|\{|\}|\(|\)]')
+
     def _analyze_line(self, line):
         char = None
         for match in self._main_chars.finditer(line):
@@ -142,8 +144,8 @@ def _analyze_line(self, line):
                     if char * 3 == line[i:i + 3]:
                         self.in_string = char * 3
                 elif self.in_string == line[i:i + len(self.in_string)] and \
-                     not (i > 0 and line[i - 1] == '\\' and
-                          not (i > 1 and line[i - 2] == '\\')):
+                    not (i > 0 and line[i - 1] == '\\' and
+                         not (i > 1 and line[i - 2] == '\\')):
                     self.in_string = ''
             if self.in_string:
                 continue
@@ -158,6 +160,7 @@ def _analyze_line(self, line):
         else:
             self.continuation = False
 
+
 def custom_generator(lines):
     return _CustomGenerator(lines)()
 
@@ -189,7 +192,6 @@ def generate_regions(self, start_line=1, end_line=None):
         # XXX: `block_start` should be at a better position!
         block_start = 1
         readline = LinesToReadline(self.lines, block_start)
-        shifted = start_line - block_start + 1
         try:
             for start, end in self._logical_lines(readline):
                 real_start = start + block_start - 1
@@ -199,7 +201,7 @@ def generate_regions(self, start_line=1, end_line=None):
                 real_end = end + block_start - 1
                 if real_start >= start_line:
                     yield (real_start, real_end)
-        except tokenize.TokenError, e:
+        except tokenize.TokenError:
             pass
 
     def _block_logical_line(self, block_start, line_number):
@@ -254,6 +256,7 @@ def __init__(self, lines, generate=custom_generator):
         self._generate = generate
 
     _starts = None
+
     @property
     def starts(self):
         if self._starts is None:
@@ -261,6 +264,7 @@ def starts(self):
         return self._starts
 
     _ends = None
+
     @property
     def ends(self):
         if self._ends is None:
@@ -326,6 +330,7 @@ def get_block_start(lines, lineno, maximum_indents=80):
 
 _block_start_pattern = None
 
+
 def get_block_start_patterns():
     global _block_start_pattern
     if not _block_start_pattern:
@@ -350,9 +355,10 @@ def count_line_indents(line):
 def get_string_pattern():
     start = r'(\b[uU]?[rR]?)?'
     longstr = r'%s"""(\\.|"(?!"")|\\\n|[^"\\])*"""' % start
-    shortstr = r'%s"(\\.|[^"\\\n])*"' % start
+    shortstr = r'%s"(\\.|\\\n|[^"\\])*"' % start
     return '|'.join([longstr, longstr.replace('"', "'"),
                      shortstr, shortstr.replace('"', "'")])
 
+
 def get_comment_pattern():
     return r'#[^\n]*'
diff --git a/pymode/libs2/rope/base/default_config.py b/pymode/libs2/rope/base/default_config.py
index ffebcd4f..0ee9937d 100644
--- a/pymode/libs2/rope/base/default_config.py
+++ b/pymode/libs2/rope/base/default_config.py
@@ -14,7 +14,7 @@ def set_prefs(prefs):
     # 'build/*.o': matches 'build/lib.o' but not 'build/sub/lib.o'
     # 'build//*.o': matches 'build/lib.o' and 'build/sub/lib.o'
     prefs['ignored_resources'] = ['*.pyc', '*~', '.ropeproject',
-                                  '.hg', '.svn', '_svn', '.git']
+                                  '.hg', '.svn', '_svn', '.git', '.tox']
 
     # Specifies which files should be considered python files.  It is
     # useful when you have scripts inside your project.  Only files
@@ -79,6 +79,16 @@ def set_prefs(prefs):
     # appear in the importing namespace.
     prefs['ignore_bad_imports'] = False
 
+    # If `True`, rope will transform a comma list of imports into
+    # multiple separate import statements when organizing
+    # imports.
+    prefs['split_imports'] = False
+
+    # If `True`, rope will sort imports alphabetically by module name
+    # instead of alphabetically by import statement, with from imports
+    # after normal imports.
+    prefs['sort_imports_alphabetically'] = False
+
 
 def project_opened(project):
     """This function is called after opening the project"""
diff --git a/pymode/libs2/rope/base/evaluate.py b/pymode/libs2/rope/base/evaluate.py
index 6736b2a9..faf09407 100644
--- a/pymode/libs2/rope/base/evaluate.py
+++ b/pymode/libs2/rope/base/evaluate.py
@@ -6,6 +6,7 @@
 
 BadIdentifierError = exceptions.BadIdentifierError
 
+
 def eval_location(pymodule, offset):
     """Find the pyname at the offset"""
     return eval_location2(pymodule, offset)[1]
@@ -40,7 +41,8 @@ def eval_str2(holding_scope, name):
         # parenthesizing for handling cases like 'a_var.\nattr'
         node = ast.parse('(%s)' % name)
     except SyntaxError:
-        raise BadIdentifierError('Not a resolvable python identifier selected.')
+        raise BadIdentifierError(
+            'Not a resolvable python identifier selected.')
     return eval_node2(holding_scope, node)
 
 
@@ -81,7 +83,8 @@ def get_primary_and_pyname_at(self, offset):
             keyword_name = self.worder.get_word_at(offset)
             pyobject = self.get_enclosing_function(offset)
             if isinstance(pyobject, pyobjects.PyFunction):
-                return (None, pyobject.get_parameters().get(keyword_name, None))
+                return (None,
+                        pyobject.get_parameters().get(keyword_name, None))
         # class body
         if self._is_defined_in_class_body(holding_scope, offset, lineno):
             class_scope = holding_scope
@@ -93,7 +96,8 @@ def get_primary_and_pyname_at(self, offset):
             except rope.base.exceptions.AttributeNotFoundError:
                 return (None, None)
         # function header
-        if self._is_function_name_in_function_header(holding_scope, offset, lineno):
+        if self._is_function_name_in_function_header(holding_scope,
+                                                     offset, lineno):
             name = self.worder.get_primary_at(offset).strip()
             return (None, holding_scope.parent[name])
         # from statement module
@@ -118,7 +122,7 @@ def get_enclosing_function(self, offset):
             if isinstance(pyobject, pyobjects.AbstractFunction):
                 return pyobject
             elif isinstance(pyobject, pyobjects.AbstractClass) and \
-                 '__init__' in pyobject:
+                    '__init__' in pyobject:
                 return pyobject['__init__'].get_object()
             elif '__call__' in pyobject:
                 return pyobject['__call__'].get_object()
@@ -157,6 +161,7 @@ def _Call(self, node):
         primary, pyobject = self._get_primary_and_object_for_node(node.func)
         if pyobject is None:
             return
+
         def _get_returned(pyobject):
             args = arguments.create_arguments(primary, pyobject,
                                               node, self.scope)
@@ -295,7 +300,8 @@ def _call_function(self, node, function_name, other_args=None):
             return
         if function_name in pyobject:
             called = pyobject[function_name].get_object()
-            if not called or not isinstance(called, pyobjects.AbstractFunction):
+            if not called or \
+                    not isinstance(called, pyobjects.AbstractFunction):
                 return
             args = [node]
             if other_args:
diff --git a/pymode/libs2/rope/base/fscommands.py b/pymode/libs2/rope/base/fscommands.py
index 3bc22044..daf118a0 100644
--- a/pymode/libs2/rope/base/fscommands.py
+++ b/pymode/libs2/rope/base/fscommands.py
@@ -199,12 +199,14 @@ def unicode_to_file_data(contents, encoding=None):
     except UnicodeEncodeError:
         return contents.encode('utf-8')
 
+
 def file_data_to_unicode(data, encoding=None):
     result = _decode_data(data, encoding)
     if '\r' in result:
         result = result.replace('\r\n', '\n').replace('\r', '\n')
     return result
 
+
 def _decode_data(data, encoding):
     if isinstance(data, unicode):
         return data
@@ -227,7 +229,6 @@ def read_file_coding(path):
     file = open(path, 'b')
     count = 0
     result = []
-    buffsize = 10
     while True:
         current = file.read(10)
         if not current:
diff --git a/pymode/libs2/rope/base/libutils.py b/pymode/libs2/rope/base/libutils.py
index cb9381e3..4037f183 100644
--- a/pymode/libs2/rope/base/libutils.py
+++ b/pymode/libs2/rope/base/libutils.py
@@ -3,6 +3,8 @@
 
 import rope.base.project
 import rope.base.pycore
+from rope.base import pyobjectsdef
+from rope.base import utils
 from rope.base import taskhandle
 
 
@@ -17,7 +19,7 @@ def path_to_resource(project, path, type=None):
     `Project.get_file()`, and `Project.get_folder()` methods.
 
     """
-    project_path = relative(project.address, path)
+    project_path = path_relative_to_project_root(project, path)
     if project_path is None:
         project_path = rope.base.project._realpath(path)
         project = rope.base.project.get_no_project()
@@ -29,13 +31,19 @@ def path_to_resource(project, path, type=None):
         return project.get_folder(project_path)
     return None
 
+
+def path_relative_to_project_root(project, path):
+    return relative(project.address, path)
+
+@utils.deprecated()
 def relative(root, path):
     root = rope.base.project._realpath(root).replace(os.path.sep, '/')
     path = rope.base.project._realpath(path).replace(os.path.sep, '/')
     if path == root:
-    	return ''
+        return ''
     if path.startswith(root + '/'):
-    	return path[len(root) + 1:]
+        return path[len(root) + 1:]
+
 
 def report_change(project, path, old_content):
     """Report that the contents of file at `path` was changed
@@ -52,14 +60,63 @@ def report_change(project, path, old_content):
         rope.base.pycore.perform_soa_on_changed_scopes(project, resource,
                                                        old_content)
 
+
+def analyze_module(project, resource):
+    """Perform static object analysis on a python file in the project
+
+    Note that this might be really time consuming.
+    """
+    project.pycore.analyze_module(resource)
+
+
 def analyze_modules(project, task_handle=taskhandle.NullTaskHandle()):
     """Perform static object analysis on all python files in the project
 
     Note that this might be really time consuming.
     """
-    resources = project.pycore.get_python_files()
+    resources = project.get_python_files()
     job_set = task_handle.create_jobset('Analyzing Modules', len(resources))
     for resource in resources:
         job_set.started_job(resource.path)
-        project.pycore.analyze_module(resource)
+        analyze_module(project, resource)
         job_set.finished_job()
+
+
+def get_string_module(project, code, resource=None, force_errors=False):
+    """Returns a `PyObject` object for the given code
+
+    If `force_errors` is `True`, `exceptions.ModuleSyntaxError` is
+    raised if module has syntax errors.  This overrides
+    ``ignore_syntax_errors`` project config.
+
+    """
+    return pyobjectsdef.PyModule(project.pycore, code, resource,
+                                 force_errors=force_errors)
+
+
+def get_string_scope(project, code, resource=None):
+    """Returns a `Scope` object for the given code"""
+    return get_string_module(project, code, resource).get_scope()
+
+
+def is_python_file(project, resource):
+    return project.pycore.is_python_file(resource)
+
+
+def modname(resource):
+    if resource.is_folder():
+        module_name = resource.name
+        source_folder = resource.parent
+    elif resource.name == '__init__.py':
+        module_name = resource.parent.name
+        source_folder = resource.parent.parent
+    else:
+        module_name = resource.name[:-3]
+        source_folder = resource.parent
+
+    while source_folder != source_folder.parent and \
+            source_folder.has_child('__init__.py'):
+        module_name = source_folder.name + '.' + module_name
+        source_folder = source_folder.parent
+
+    return module_name
diff --git a/pymode/libs2/rope/base/oi/doa.py b/pymode/libs2/rope/base/oi/doa.py
index 12f50553..1b2a00fc 100644
--- a/pymode/libs2/rope/base/oi/doa.py
+++ b/pymode/libs2/rope/base/oi/doa.py
@@ -25,11 +25,11 @@ def run(self):
         """Execute the process"""
         env = dict(os.environ)
         file_path = self.file.real_path
-        path_folders = self.pycore.get_source_folders() + \
-                       self.pycore.get_python_path_folders()
+        path_folders = self.pycore.project.get_source_folders() + \
+            self.pycore.project.get_python_path_folders()
         env['PYTHONPATH'] = os.pathsep.join(folder.real_path
                                             for folder in path_folders)
-        runmod_path = self.pycore.find_module('rope.base.oi.runmod').real_path
+        runmod_path = self.pycore.project.find_module('rope.base.oi.runmod').real_path
         self.receiver = None
         self._init_data_receiving()
         send_info = '-'
@@ -56,7 +56,8 @@ def _init_data_receiving(self):
             self.receiver = _SocketReceiver()
         else:
             self.receiver = _FIFOReceiver()
-        self.receiving_thread = threading.Thread(target=self._receive_information)
+        self.receiving_thread = threading.Thread(
+            target=self._receive_information)
         self.receiving_thread.setDaemon(True)
         self.receiving_thread.start()
 
@@ -114,7 +115,7 @@ def __init__(self):
             try:
                 self.server_socket.bind(('', self.data_port))
                 break
-            except socket.error, e:
+            except socket.error:
                 self.data_port += 1
         self.server_socket.listen(1)
 
diff --git a/pymode/libs2/rope/base/oi/runmod.py b/pymode/libs2/rope/base/oi/runmod.py
index 8170623c..e332d7e6 100644
--- a/pymode/libs2/rope/base/oi/runmod.py
+++ b/pymode/libs2/rope/base/oi/runmod.py
@@ -40,9 +40,9 @@ def send_data(self, data):
         def close(self):
             self.my_file.close()
 
-
     def _cached(func):
         cache = {}
+
         def newfunc(self, arg):
             if arg in cache:
                 return cache[arg]
@@ -76,7 +76,8 @@ def on_function_call(self, frame, event, arg):
             code = frame.f_code
             for argname in code.co_varnames[:code.co_argcount]:
                 try:
-                    args.append(self._object_to_persisted_form(frame.f_locals[argname]))
+                    args.append(self._object_to_persisted_form(
+                        frame.f_locals[argname]))
                 except (TypeError, AttributeError):
                     args.append(('unknown',))
             try:
@@ -94,17 +95,19 @@ def on_function_call(self, frame, event, arg):
         def _is_an_interesting_call(self, frame):
             #if frame.f_code.co_name in ['?', '<module>']:
             #    return False
-            #return not frame.f_back or not self._is_code_inside_project(frame.f_back.f_code)
+            #return not frame.f_back or
+            #    not self._is_code_inside_project(frame.f_back.f_code)
 
             if not self._is_code_inside_project(frame.f_code) and \
-               (not frame.f_back or not self._is_code_inside_project(frame.f_back.f_code)):
+               (not frame.f_back or
+                    not self._is_code_inside_project(frame.f_back.f_code)):
                 return False
             return True
 
         def _is_code_inside_project(self, code):
             source = self._path(code.co_filename)
             return source is not None and os.path.exists(source) and \
-                   _realpath(source).startswith(self.project_root)
+                _realpath(source).startswith(self.project_root)
 
         @_cached
         def _get_persisted_code(self, object_):
@@ -128,7 +131,8 @@ def _get_persisted_builtin(self, object_):
                 holding = None
                 if len(object_) > 0:
                     holding = object_[0]
-                return ('builtin', 'list', self._object_to_persisted_form(holding))
+                return ('builtin', 'list',
+                        self._object_to_persisted_form(holding))
             if isinstance(object_, dict):
                 keys = None
                 values = None
@@ -152,7 +156,8 @@ def _get_persisted_builtin(self, object_):
                     for o in object_:
                         holding = o
                         break
-                return ('builtin', 'set', self._object_to_persisted_form(holding))
+                return ('builtin', 'set',
+                        self._object_to_persisted_form(holding))
             return ('unknown',)
 
         def _object_to_persisted_form(self, object_):
diff --git a/pymode/libs2/rope/base/oi/soa.py b/pymode/libs2/rope/base/oi/soa.py
index 38cd5c9d..a34b970e 100644
--- a/pymode/libs2/rope/base/oi/soa.py
+++ b/pymode/libs2/rope/base/oi/soa.py
@@ -26,9 +26,11 @@ def _analyze_node(pycore, pydefined, should_analyze,
         new_followed_calls = max(0, followed_calls - 1)
         return_true = lambda pydefined: True
         return_false = lambda pydefined: False
+
         def _follow(pyfunction):
             _analyze_node(pycore, pyfunction, return_true,
                           return_false, new_followed_calls)
+
         if not followed_calls:
             _follow = None
         visitor = SOAVisitor(pycore, pydefined, _follow)
@@ -113,7 +115,8 @@ def _Assign(self, node):
             args_pynames.append(evaluate.eval_node(self.scope,
                                                    subscript.slice.value))
             value = rope.base.oi.soi._infer_assignment(
-                rope.base.pynames.AssignmentValue(node.value, levels), self.pymodule)
+                rope.base.pynames.AssignmentValue(node.value, levels),
+                self.pymodule)
             args_pynames.append(rope.base.pynames.UnboundName(value))
             if instance is not None and value is not None:
                 pyobject = instance.get_object()
diff --git a/pymode/libs2/rope/base/oi/soi.py b/pymode/libs2/rope/base/oi/soi.py
index bf40af90..5a11b5ef 100644
--- a/pymode/libs2/rope/base/oi/soi.py
+++ b/pymode/libs2/rope/base/oi/soi.py
@@ -30,6 +30,7 @@ def infer_returned_object(pyfunction, args):
         return result
     return object_info.get_returned(pyfunction, args)
 
+
 @_ignore_inferred
 def infer_parameter_objects(pyfunction):
     """Infer the `PyObject`\s of parameters of this `PyFunction`"""
@@ -40,6 +41,7 @@ def infer_parameter_objects(pyfunction):
     _handle_first_parameter(pyfunction, result)
     return result
 
+
 def _handle_first_parameter(pyobject, parameters):
     kind = pyobject.get_kind()
     if parameters is None or kind not in ['method', 'classmethod']:
@@ -53,6 +55,7 @@ def _handle_first_parameter(pyobject, parameters):
     if kind == 'classmethod':
         parameters[0] = pyobject.parent
 
+
 @_ignore_inferred
 def infer_assigned_object(pyname):
     if not pyname.assignments:
@@ -62,6 +65,7 @@ def infer_assigned_object(pyname):
         if result is not None:
             return result
 
+
 def get_passed_objects(pyfunction, parameter_index):
     object_info = pyfunction.pycore.object_info
     result = object_info.get_passed_objects(pyfunction,
@@ -72,6 +76,7 @@ def get_passed_objects(pyfunction, parameter_index):
             result.append(statically_inferred[parameter_index])
     return result
 
+
 def _infer_returned(pyobject, args):
     if args:
         # HACK: Setting parameter objects manually
@@ -99,12 +104,14 @@ def _infer_returned(pyobject, args):
         except rope.base.pyobjects.IsBeingInferredError:
             pass
 
+
 def _parameter_objects(pyobject):
     params = pyobject.get_param_names(special_args=False)
     return [rope.base.pyobjects.get_unknown()] * len(params)
 
 # handling `rope.base.pynames.AssignmentValue`
 
+
 @_ignore_inferred
 def _infer_assignment(assignment, pymodule):
     result = _follow_pyname(assignment, pymodule)
@@ -116,6 +123,7 @@ def _infer_assignment(assignment, pymodule):
         return None
     return _follow_levels(assignment, pyobject)
 
+
 def _follow_levels(assignment, pyobject):
     for index in assignment.levels:
         if isinstance(pyobject.get_type(), rope.base.builtins.Tuple):
@@ -132,6 +140,7 @@ def _follow_levels(assignment, pyobject):
             break
     return pyobject
 
+
 @_ignore_inferred
 def _follow_pyname(assignment, pymodule, lineno=None):
     assign_node = assignment.ast_node
@@ -149,6 +158,7 @@ def _follow_pyname(assignment, pymodule, lineno=None):
                 arguments.ObjectArguments([arg]))
         return pyname, result
 
+
 @_ignore_inferred
 def _follow_evaluations(assignment, pyname, pyobject):
     new_pyname = pyname
@@ -181,6 +191,7 @@ def _get_lineno_for_node(assign_node):
         return assign_node.lineno
     return 1
 
+
 def _get_attribute(pyobject, name):
     if pyobject is not None and name in pyobject:
         return pyobject[name]
diff --git a/pymode/libs2/rope/base/oi/transform.py b/pymode/libs2/rope/base/oi/transform.py
index 5a9d600e..aa29c373 100644
--- a/pymode/libs2/rope/base/oi/transform.py
+++ b/pymode/libs2/rope/base/oi/transform.py
@@ -120,7 +120,6 @@ def transform(self, textual):
             return None
 
     def builtin_to_pyobject(self, textual):
-        name = textual[1]
         method = getattr(self, 'builtin_%s_to_pyobject' % textual[1], None)
         if method is not None:
             return method(textual)
@@ -203,7 +202,7 @@ def instance_to_pyobject(self, textual):
     def _get_pymodule(self, path):
         resource = self.path_to_resource(path)
         if resource is not None:
-            return self.project.pycore.resource_to_pyobject(resource)
+            return self.project.get_pymodule(resource)
 
     def path_to_resource(self, path):
         try:
@@ -221,7 +220,7 @@ def path_to_resource(self, path):
 
 class DOITextualToPyObject(TextualToPyObject):
     """For transforming textual form to `PyObject`
-    
+
     The textual form DOI uses is different from rope's standard
     textual form.  The reason is that we cannot find the needed
     information by analyzing live objects.  This class can be
@@ -253,7 +252,8 @@ def _class_to_pyobject(self, textual):
            isinstance(suspected, rope.base.pyobjects.PyClass):
             return suspected
         else:
-            lineno = self._find_occurrence(name, pymodule.get_resource().read())
+            lineno = self._find_occurrence(name,
+                                           pymodule.get_resource().read())
             if lineno is not None:
                 inner_scope = module_scope.get_inner_scope_for_line(lineno)
                 return inner_scope.pyobject
@@ -278,8 +278,8 @@ def _find_occurrence(self, name, source):
 
     def path_to_resource(self, path):
         import rope.base.libutils
-        root = self.project.address
-        relpath = rope.base.libutils.relative(root, path)
+        relpath = rope.base.libutils.path_relative_to_project_root(
+            self.project, path)
         if relpath is not None:
             path = relpath
         return super(DOITextualToPyObject, self).path_to_resource(path)
diff --git a/pymode/libs2/rope/base/prefs.py b/pymode/libs2/rope/base/prefs.py
index 674a58ec..2ab45dac 100644
--- a/pymode/libs2/rope/base/prefs.py
+++ b/pymode/libs2/rope/base/prefs.py
@@ -27,7 +27,7 @@ def get(self, key, default=None):
 
     def add_callback(self, key, callback):
         """Add `key` preference with `callback` function
-        
+
         Whenever `key` is set the callback is called with the
         given `value` as parameter.
 
diff --git a/pymode/libs2/rope/base/project.py b/pymode/libs2/rope/base/project.py
index 97d2dd3e..23597f8c 100644
--- a/pymode/libs2/rope/base/project.py
+++ b/pymode/libs2/rope/base/project.py
@@ -6,8 +6,9 @@
 
 import rope.base.fscommands
 from rope.base import exceptions, taskhandle, prefs, history, pycore, utils
-from rope.base.resourceobserver import *
+import rope.base.resourceobserver as resourceobserver
 from rope.base.resources import File, Folder, _ResourceMatcher
+from rope.base.exceptions import ModuleNotFoundError
 
 
 class _Project(object):
@@ -17,6 +18,7 @@ def __init__(self, fscommands):
         self.fscommands = fscommands
         self.prefs = prefs.Prefs()
         self.data_files = _DataFiles(self)
+        self._custom_source_folders = []
 
     def get_resource(self, resource_name):
         """Get a resource in a project.
@@ -41,6 +43,40 @@ def get_resource(self, resource_name):
             raise exceptions.ResourceNotFoundError('Unknown resource '
                                                    + resource_name)
 
+    def get_module(self, name, folder=None):
+        """Returns a `PyObject` if the module was found."""
+        # check if this is a builtin module
+        pymod = self.pycore.builtin_module(name)
+        if pymod is not None:
+            return pymod
+        module = self.find_module(name, folder)
+        if module is None:
+            raise ModuleNotFoundError('Module %s not found' % name)
+        return self.pycore.resource_to_pyobject(module)
+
+    def get_python_path_folders(self):
+        result = []
+        for src in self.prefs.get('python_path', []) + sys.path:
+            try:
+                src_folder = get_no_project().get_resource(src)
+                result.append(src_folder)
+            except exceptions.ResourceNotFoundError:
+                pass
+        return result
+
+    # INFO: It was decided not to cache source folders, since:
+    #  - Does not take much time when the root folder contains
+    #    packages, that is most of the time
+    #  - We need a separate resource observer; `self.observer`
+    #    does not get notified about module and folder creations
+    def get_source_folders(self):
+        """Returns project source folders"""
+        if self.root is None:
+            return []
+        result = list(self._custom_source_folders)
+        result.extend(self.pycore._find_source_folders(self.root))
+        return result
+
     def validate(self, folder):
         """Validate files and folders contained in this folder
 
@@ -71,6 +107,9 @@ def do(self, changes, task_handle=taskhandle.NullTaskHandle()):
         """
         self.history.do(changes, task_handle=task_handle)
 
+    def get_pymodule(self, resource, force_errors=False):
+        return self.pycore.resource_to_pyobject(resource, force_errors)
+
     def get_pycore(self):
         return self.pycore
 
@@ -82,12 +121,45 @@ def get_folder(self, path):
         """Get the folder with `path` (it may not exist)"""
         return Folder(self, path)
 
-    def is_ignored(self, resource):
-        return False
-
     def get_prefs(self):
         return self.prefs
 
+    def get_relative_module(self, name, folder, level):
+        module = self.find_relative_module(name, folder, level)
+        if module is None:
+            raise ModuleNotFoundError('Module %s not found' % name)
+        return self.pycore.resource_to_pyobject(module)
+
+    def find_module(self, modname, folder=None):
+        """Returns a resource corresponding to the given module
+
+        returns None if it can not be found
+        """
+        for src in self.get_source_folders():
+            module = _find_module_in_folder(src, modname)
+            if module is not None:
+                return module
+        for src in self.get_python_path_folders():
+            module = _find_module_in_folder(src, modname)
+            if module is not None:
+                return module
+        if folder is not None:
+            module = _find_module_in_folder(folder, modname)
+            if module is not None:
+                return module
+        return None
+
+    def find_relative_module(self, modname, folder, level):
+        for i in range(level - 1):
+            folder = folder.parent
+        if modname == '':
+            return folder
+        else:
+            return _find_module_in_folder(folder, modname)
+
+    def is_ignored(self, resource):
+        return False
+
     def _get_resource_path(self, name):
         pass
 
@@ -144,10 +216,22 @@ def __init__(self, projectroot, fscommands=None,
         if ropefolder is not None:
             self.prefs['ignored_resources'] = [ropefolder]
         self._init_prefs(prefs)
+        self._init_source_folders()
+
+    @utils.deprecated('Delete once deprecated functions are gone')
+    def _init_source_folders(self):
+        for path in self.prefs.get('source_folders', []):
+            folder = self.get_resource(path)
+            self._custom_source_folders.append(folder)
 
     def get_files(self):
         return self.file_list.get_files()
 
+    def get_python_files(self):
+        """Returns all python files available in the project"""
+        return [resource for resource in self.get_files()
+                if self.pycore.is_python_file(resource)]
+
     def _get_resource_path(self, name):
         return os.path.join(self._address, *name.split('/'))
 
@@ -244,6 +328,9 @@ def get_resource(self, name):
     def get_files(self):
         return []
 
+    def get_python_files(self):
+        return []
+
     _no_project = None
 
 
@@ -258,7 +345,7 @@ class _FileListCacher(object):
     def __init__(self, project):
         self.project = project
         self.files = None
-        rawobserver = ResourceObserver(
+        rawobserver = resourceobserver.ResourceObserver(
             self._changed, self._invalid, self._invalid,
             self._invalid, self._invalid)
         self.project.add_observer(rawobserver)
@@ -334,7 +421,7 @@ def write(self):
 
     def _can_compress(self):
         try:
-            import gzip
+            import gzip  # noqa
             return True
         except ImportError:
             return False
@@ -371,5 +458,24 @@ def _realpath(path):
     if sys.platform == 'cygwin':
         if path[1:3] == ':\\':
             return path
+        elif path[1:3] == ':/':
+            path = "/cygdrive/" + path[0] + path[2:]
         return os.path.abspath(os.path.expanduser(path))
     return os.path.realpath(os.path.abspath(os.path.expanduser(path)))
+
+
+def _find_module_in_folder(folder, modname):
+    module = folder
+    packages = modname.split('.')
+    for pkg in packages[:-1]:
+        if module.is_folder() and module.has_child(pkg):
+            module = module.get_child(pkg)
+        else:
+            return None
+    if module.is_folder():
+        if module.has_child(packages[-1]) and \
+           module.get_child(packages[-1]).is_folder():
+            return module.get_child(packages[-1])
+        elif module.has_child(packages[-1] + '.py') and \
+                not module.get_child(packages[-1] + '.py').is_folder():
+            return module.get_child(packages[-1] + '.py')
diff --git a/pymode/libs2/rope/base/pycore.py b/pymode/libs2/rope/base/pycore.py
index 32056a0f..c4c1195a 100644
--- a/pymode/libs2/rope/base/pycore.py
+++ b/pymode/libs2/rope/base/pycore.py
@@ -3,15 +3,19 @@
 import sys
 import warnings
 
+import rope.base.libutils
+import rope.base.resourceobserver
+import rope.base.resources
 import rope.base.oi.doa
 import rope.base.oi.objectinfo
 import rope.base.oi.soa
-from rope.base import ast, exceptions, taskhandle, utils, stdmods
-from rope.base.exceptions import ModuleNotFoundError
-from rope.base.pyobjectsdef import PyModule, PyPackage, PyClass
-import rope.base.resources
-import rope.base.resourceobserver
 from rope.base import builtins
+from rope.base import exceptions
+from rope.base import stdmods
+from rope.base import taskhandle
+from rope.base import utils
+from rope.base.exceptions import ModuleNotFoundError
+from rope.base.pyobjectsdef import PyModule, PyPackage
 
 
 class PyCore(object):
@@ -25,7 +29,6 @@ def __init__(self, project):
         self.object_info = rope.base.oi.objectinfo.ObjectInfoManager(project)
         self._init_python_files()
         self._init_automatic_soa()
-        self._init_source_folders()
 
     def _init_python_files(self):
         self.python_matcher = None
@@ -38,15 +41,10 @@ def _init_resource_observer(self):
         callback = self._invalidate_resource_cache
         observer = rope.base.resourceobserver.ResourceObserver(
             changed=callback, moved=callback, removed=callback)
-        self.observer = rope.base.resourceobserver.FilteredResourceObserver(observer)
+        self.observer = \
+            rope.base.resourceobserver.FilteredResourceObserver(observer)
         self.project.add_observer(self.observer)
 
-    def _init_source_folders(self):
-        self._custom_source_folders = []
-        for path in self.project.prefs.get('source_folders', []):
-            folder = self.project.get_resource(path)
-            self._custom_source_folders.append(folder)
-
     def _init_automatic_soa(self):
         if not self.automatic_soa:
             return
@@ -62,7 +60,7 @@ def automatic_soa(self):
 
     def _file_changed_for_soa(self, resource, new_resource=None):
         old_contents = self.project.history.\
-                       contents_before_current_change(resource)
+            contents_before_current_change(resource)
         if old_contents is not None:
             perform_soa_on_changed_scopes(self.project, resource, old_contents)
 
@@ -73,16 +71,10 @@ def is_python_file(self, resource):
             return resource.name.endswith('.py')
         return self.python_matcher.does_match(resource)
 
+    @utils.deprecated('Use `project.get_module` instead')
     def get_module(self, name, folder=None):
         """Returns a `PyObject` if the module was found."""
-        # check if this is a builtin module
-        pymod = self._builtin_module(name)
-        if pymod is not None:
-             return pymod
-        module = self.find_module(name, folder)
-        if module is None:
-            raise ModuleNotFoundError('Module %s not found' % name)
-        return self.resource_to_pyobject(module)
+        return self.project.get_module(name, folder)
 
     def _builtin_submodules(self, modname):
         result = {}
@@ -90,18 +82,17 @@ def _builtin_submodules(self, modname):
             if extension.startswith(modname + '.'):
                 name = extension[len(modname) + 1:]
                 if '.' not in name:
-                    result[name] = self._builtin_module(extension)
+                    result[name] = self.builtin_module(extension)
         return result
 
-    def _builtin_module(self, name):
+    def builtin_module(self, name):
         return self.extension_cache.get_pymodule(name)
 
+    @utils.deprecated('Use `project.get_relative_module` instead')
     def get_relative_module(self, name, folder, level):
-        module = self.find_relative_module(name, folder, level)
-        if module is None:
-            raise ModuleNotFoundError('Module %s not found' % name)
-        return self.resource_to_pyobject(module)
+        return self.project.get_relative_module(name, folder, level)
 
+    @utils.deprecated('Use `libutils.get_string_module` instead')
     def get_string_module(self, code, resource=None, force_errors=False):
         """Returns a `PyObject` object for the given code
 
@@ -112,92 +103,48 @@ def get_string_module(self, code, resource=None, force_errors=False):
         """
         return PyModule(self, code, resource, force_errors=force_errors)
 
+    @utils.deprecated('Use `libutils.get_string_scope` instead')
     def get_string_scope(self, code, resource=None):
         """Returns a `Scope` object for the given code"""
-        return self.get_string_module(code, resource).get_scope()
+        return rope.base.libutils.get_string_scope(code, resource)
 
     def _invalidate_resource_cache(self, resource, new_resource=None):
         for observer in self.cache_observers:
             observer(resource)
 
-    def _find_module_in_folder(self, folder, modname):
-        module = folder
-        packages = modname.split('.')
-        for pkg in packages[:-1]:
-            if  module.is_folder() and module.has_child(pkg):
-                module = module.get_child(pkg)
-            else:
-                return None
-        if module.is_folder():
-            if module.has_child(packages[-1]) and \
-               module.get_child(packages[-1]).is_folder():
-                return module.get_child(packages[-1])
-            elif module.has_child(packages[-1] + '.py') and \
-                 not module.get_child(packages[-1] + '.py').is_folder():
-                return module.get_child(packages[-1] + '.py')
-
+    @utils.deprecated('Use `project.get_python_path_folders` instead')
     def get_python_path_folders(self):
-        import rope.base.project
-        result = []
-        for src in self.project.prefs.get('python_path', []) + sys.path:
-            try:
-                src_folder = rope.base.project.get_no_project().get_resource(src)
-                result.append(src_folder)
-            except rope.base.exceptions.ResourceNotFoundError:
-                pass
-        return result
+        return self.project.get_python_path_folders()
 
+    @utils.deprecated('Use `project.find_module` instead')
     def find_module(self, modname, folder=None):
         """Returns a resource corresponding to the given module
 
         returns None if it can not be found
         """
-        return self._find_module(modname, folder)
+        return self.project.find_module(modname, folder)
 
+    @utils.deprecated('Use `project.find_relative_module` instead')
     def find_relative_module(self, modname, folder, level):
-        for i in range(level - 1):
-            folder = folder.parent
-        if modname == '':
-            return folder
-        else:
-            return self._find_module_in_folder(folder, modname)
-
-    def _find_module(self, modname, folder=None):
-        """Return `modname` module resource"""
-        for src in self.get_source_folders():
-            module = self._find_module_in_folder(src, modname)
-            if module is not None:
-                return module
-        for src in self.get_python_path_folders():
-            module = self._find_module_in_folder(src, modname)
-            if module is not None:
-                return module
-        if folder is not None:
-            module = self._find_module_in_folder(folder, modname)
-            if module is not None:
-                return module
-        return None
+        return self.project.find_relative_module(modname, folder, level)
 
     # INFO: It was decided not to cache source folders, since:
     #  - Does not take much time when the root folder contains
     #    packages, that is most of the time
     #  - We need a separate resource observer; `self.observer`
     #    does not get notified about module and folder creations
+    @utils.deprecated('Use `project.get_source_folders` instead')
     def get_source_folders(self):
         """Returns project source folders"""
-        if self.project.root is None:
-            return []
-        result = list(self._custom_source_folders)
-        result.extend(self._find_source_folders(self.project.root))
-        return result
+        return self.project.get_source_folders()
 
     def resource_to_pyobject(self, resource, force_errors=False):
         return self.module_cache.get_pymodule(resource, force_errors)
 
+    @utils.deprecated('Use `project.get_python_files` instead')
     def get_python_files(self):
         """Returns all python files available in the project"""
-        return [resource for resource in self.project.get_files()
-                if self.is_python_file(resource)]
+        return self.project.get_python_files()
 
     def _is_package(self, folder):
         if folder.has_child('__init__.py') and \
@@ -270,22 +217,9 @@ def get_classes(self, task_handle=taskhandle.NullTaskHandle()):
     def __str__(self):
         return str(self.module_cache) + str(self.object_info)
 
+    @utils.deprecated('Use `libutils.modname` instead')
     def modname(self, resource):
-        if resource.is_folder():
-            module_name = resource.name
-            source_folder = resource.parent
-        elif resource.name == '__init__.py':
-            module_name = resource.parent.name
-            source_folder = resource.parent.parent
-        else:
-            module_name = resource.name[:-3]
-            source_folder = resource.parent
-
-        while source_folder != source_folder.parent and \
-              source_folder.has_child('__init__.py'):
-            module_name = source_folder.name + '.' + module_name
-            source_folder = source_folder.parent
-        return module_name
+        return rope.base.libutils.modname(resource)
 
     @property
     @utils.cacheit
@@ -355,9 +289,11 @@ def perform_soa_on_changed_scopes(project, resource, old_contents):
             new_contents = resource.read()
             # detecting changes in new_contents relative to old_contents
             detector = _TextChangeDetector(new_contents, old_contents)
+
             def search_subscopes(pydefined):
                 scope = pydefined.get_scope()
                 return detector.is_changed(scope.get_start(), scope.get_end())
+
             def should_analyze(pydefined):
                 scope = pydefined.get_scope()
                 start = scope.get_start()
diff --git a/pymode/libs2/rope/base/pynames.py b/pymode/libs2/rope/base/pynames.py
index 79bba156..5d489814 100644
--- a/pymode/libs2/rope/base/pynames.py
+++ b/pymode/libs2/rope/base/pynames.py
@@ -57,7 +57,7 @@ def __init__(self, ast_node, levels=None, evaluation='',
 
         """
         self.ast_node = ast_node
-        if levels == None:
+        if levels is None:
             self.levels = []
         else:
             self.levels = levels
@@ -112,15 +112,16 @@ def _get_pymodule(self):
         if self.pymodule.get() is None:
             pycore = self.importing_module.pycore
             if self.resource is not None:
-                self.pymodule.set(pycore.resource_to_pyobject(self.resource))
+                self.pymodule.set(pycore.project.get_pymodule(self.resource))
             elif self.module_name is not None:
                 try:
                     if self.level == 0:
-                        pymodule = pycore.get_module(self.module_name,
-                                                     self._current_folder())
+                        pymodule = pycore.project.get_module(
+                            self.module_name, self._current_folder())
                     else:
-                        pymodule = pycore.get_relative_module(
-                            self.module_name, self._current_folder(), self.level)
+                        pymodule = pycore.project.get_relative_module(
+                            self.module_name, self._current_folder(),
+                            self.level)
                     self.pymodule.set(pymodule)
                 except exceptions.ModuleNotFoundError:
                     pass
@@ -172,6 +173,7 @@ def _circular_inference():
     raise rope.base.pyobjects.IsBeingInferredError(
         'Circular Object Inference')
 
+
 class _Inferred(object):
 
     def __init__(self, get_inferred, concluded=None):
diff --git a/pymode/libs2/rope/base/pyobjectsdef.py b/pymode/libs2/rope/base/pyobjectsdef.py
index 50b24360..a738b4de 100644
--- a/pymode/libs2/rope/base/pyobjectsdef.py
+++ b/pymode/libs2/rope/base/pyobjectsdef.py
@@ -3,16 +3,17 @@
 import rope.base.builtins
 import rope.base.oi.soi
 import rope.base.pyscopes
+import rope.base.libutils
 from rope.base import (pynamesdef as pynames, exceptions, ast,
                        astutils, pyobjects, fscommands, arguments, utils)
-from rope.base.pyobjects import *
 
 
 class PyFunction(pyobjects.PyFunction):
 
     def __init__(self, pycore, ast_node, parent):
-        AbstractFunction.__init__(self)
-        PyDefinedObject.__init__(self, pycore, ast_node, parent)
+        rope.base.pyobjects.AbstractFunction.__init__(self)
+        rope.base.pyobjects.PyDefinedObject.__init__(
+            self, pycore, ast_node, parent)
         self.arguments = self.ast_node.args
         self.parameter_pyobjects = pynames._Inferred(
             self._infer_parameters, self.get_module()._get_concluded_data())
@@ -109,8 +110,9 @@ class PyClass(pyobjects.PyClass):
 
     def __init__(self, pycore, ast_node, parent):
         self.visitor_class = _ClassVisitor
-        AbstractClass.__init__(self)
-        PyDefinedObject.__init__(self, pycore, ast_node, parent)
+        rope.base.pyobjects.AbstractClass.__init__(self)
+        rope.base.pyobjects.PyDefinedObject.__init__(
+            self, pycore, ast_node, parent)
         self.parent = parent
         self._superclasses = self.get_module()._get_concluded_data()
 
@@ -134,8 +136,9 @@ def _get_bases(self):
             base = rope.base.evaluate.eval_node(self.parent.get_scope(),
                                                 base_name)
             if base is not None and \
-               base.get_object().get_type() == get_base_type('Type'):
-                result.append(base.get_object())
+                base.get_object().get_type() == \
+                    rope.base.pyobjects.get_base_type('Type'):
+                    result.append(base.get_object())
         return result
 
     def _create_scope(self):
@@ -213,7 +216,7 @@ def __init__(self, pycore, resource=None, force_errors=False):
         self.resource = resource
         init_dot_py = self._get_init_dot_py()
         if init_dot_py is not None:
-            ast_node = pycore.resource_to_pyobject(
+            ast_node = pycore.project.get_pymodule(
                 init_dot_py, force_errors=force_errors).get_ast()
         else:
             ast_node = ast.parse('\n')
@@ -221,7 +224,7 @@ def __init__(self, pycore, resource=None, force_errors=False):
 
     def _create_structural_attributes(self):
         result = {}
-        modname = self.pycore.modname(self.resource)
+        modname = rope.base.libutils.modname(self.resource)
         extension_submodules = self.pycore._builtin_submodules(modname)
         for name, module in extension_submodules.iteritems():
             result[name] = rope.base.builtins.BuiltinName(module)
@@ -235,7 +238,7 @@ def _create_concluded_attributes(self):
         result = {}
         init_dot_py = self._get_init_dot_py()
         if init_dot_py:
-            init_object = self.pycore.resource_to_pyobject(init_dot_py)
+            init_object = self.pycore.project.get_pymodule(init_dot_py)
             result.update(init_object.get_attributes())
         return result
 
@@ -245,13 +248,14 @@ def _get_child_resources(self):
             if child.is_folder():
                 result[child.name] = child
             elif child.name.endswith('.py') and \
-                 child.name != '__init__.py':
+                    child.name != '__init__.py':
                 name = child.name[:-3]
                 result[name] = child
         return result
 
     def _get_init_dot_py(self):
-        if self.resource is not None and self.resource.has_child('__init__.py'):
+        if self.resource is not None and \
+                self.resource.has_child('__init__.py'):
             return self.resource.get_child('__init__.py')
         else:
             return None
@@ -262,7 +266,7 @@ def _create_scope(self):
     def get_module(self):
         init_dot_py = self._get_init_dot_py()
         if init_dot_py:
-            return self.pycore.resource_to_pyobject(init_dot_py)
+            return self.pycore.project.get_pymodule(init_dot_py)
         return self
 
 
@@ -329,7 +333,9 @@ def _FunctionDef(self, node):
             if isinstance(decorator, ast.Name) and decorator.id == 'property':
                 if isinstance(self, _ClassVisitor):
                     type_ = rope.base.builtins.Property(pyfunction)
-                    arg = pynames.UnboundName(PyObject(self.owner_object))
+                    arg = pynames.UnboundName(
+                        rope.base.pyobjects.PyObject(self.owner_object))
+
                     def _eval(type_=type_, arg=arg):
                         return type_.get_property_object(
                             arguments.ObjectArguments([arg]))
@@ -347,7 +353,7 @@ def _AugAssign(self, node):
         pass
 
     def _For(self, node):
-        names = self._update_evaluated(node.target, node.iter,
+        names = self._update_evaluated(node.target, node.iter,  # noqa
                                        '.__iter__().next()')
         for child in node.body + node.orelse:
             ast.walk(child, self)
@@ -362,7 +368,7 @@ def _assigned(self, name, assignment):
             self.names[name] = pyname
 
     def _update_evaluated(self, targets, assigned,
-                          evaluation= '', eval_type=False):
+                          evaluation='', eval_type=False):
         result = {}
         names = astutils.get_name_levels(targets)
         for name, levels in names:
@@ -430,7 +436,8 @@ def _ImportFrom(self, node):
     def _is_ignored_import(self, imported_module):
         if not self.pycore.project.prefs.get('ignore_bad_imports', False):
             return False
-        return not isinstance(imported_module.get_object(), AbstractModule)
+        return not isinstance(imported_module.get_object(),
+                              rope.base.pyobjects.AbstractModule)
 
     def _Global(self, node):
         module = self.get_module()
diff --git a/pymode/libs2/rope/base/pyscopes.py b/pymode/libs2/rope/base/pyscopes.py
index a00381b7..0bed19a9 100644
--- a/pymode/libs2/rope/base/pyscopes.py
+++ b/pymode/libs2/rope/base/pyscopes.py
@@ -230,8 +230,8 @@ def get_holding_scope(self, module_scope, lineno, line_indents=None):
         current_scope = module_scope
         new_scope = current_scope
         while new_scope is not None and \
-              (new_scope.get_kind() == 'Module' or
-               self._get_scope_indents(new_scope) <= line_indents):
+                (new_scope.get_kind() == 'Module' or
+                 self._get_scope_indents(new_scope) <= line_indents):
             current_scope = new_scope
             if current_scope.get_start() == lineno and \
                current_scope.get_kind() != 'Module':
@@ -268,7 +268,7 @@ def find_scope_end(self, scope):
         else:
             body_indents = self._get_body_indents(scope)
         for l in self.logical_lines.generate_starts(
-            min(end + 1, self.lines.length()), self.lines.length() + 1):
+                min(end + 1, self.lines.length()), self.lines.length() + 1):
             if not self._is_empty_line(l):
                 if self.get_indents(l) < body_indents:
                     return end
@@ -288,6 +288,7 @@ def code(self):
     def logical_lines(self):
         return self.pymodule.logical_lines
 
+
 class TemporaryScope(Scope):
     """Currently used for list comprehensions and generator expressions
 
diff --git a/pymode/libs2/rope/base/resourceobserver.py b/pymode/libs2/rope/base/resourceobserver.py
index 6d1accbc..7c0937d5 100644
--- a/pymode/libs2/rope/base/resourceobserver.py
+++ b/pymode/libs2/rope/base/resourceobserver.py
@@ -231,7 +231,8 @@ def _search_resource_changes(self, resource):
     def _is_changed(self, resource):
         if self.resources[resource] is None:
             return False
-        return self.resources[resource] != self.timekeeper.get_indicator(resource)
+        return self.resources[resource] != \
+            self.timekeeper.get_indicator(resource)
 
     def _calculate_new_resource(self, main, new_main, resource):
         if new_main is None:
diff --git a/pymode/libs2/rope/base/resources.py b/pymode/libs2/rope/base/resources.py
index 46beadb0..aac755f0 100644
--- a/pymode/libs2/rope/base/resources.py
+++ b/pymode/libs2/rope/base/resources.py
@@ -1,9 +1,37 @@
+"""Files and folders in a project are represented as resource objects.
+
+Files and folders are access through `Resource` objects. `Resource` has
+two subclasses: `File` and `Folder`. What we care about is that
+refactorings and `rope.base.change.Change`s use resources.
+
+There are two options to create a `Resource` for a path in a project.
+Note that in these examples `path` is the path to a file or folder
+relative to the project's root. A project's root folder is represented
+by an empty string.
+
+  1) Use the `rope.base.Project.get_resource()` method. E.g.:
+
+       myresource = myproject.get_resource(path)
+
+
+  2) Use the `rope.base.libutils` module. `libutils` has a function
+     named `path_to_resource()`. It takes a project and a path:
+
+       from rope.base import libutils
+
+       myresource = libutils.path_to_resource(myproject, path)
+
+Once we have a `Resource`, we can retrieve information from it, like
+getting the path relative to the project's root (via `path`), reading
+from and writing to the resource, moving the resource, etc.
+"""
+
 import os
 import re
 
-import rope.base.change
-import rope.base.fscommands
+from rope.base import change
 from rope.base import exceptions
+from rope.base import fscommands
 
 
 class Resource(object):
@@ -15,12 +43,12 @@ def __init__(self, project, path):
 
     def move(self, new_location):
         """Move resource to `new_location`"""
-        self._perform_change(rope.base.change.MoveResource(self, new_location),
+        self._perform_change(change.MoveResource(self, new_location),
                              'Moving <%s> to <%s>' % (self.path, new_location))
 
     def remove(self):
         """Remove resource from the project"""
-        self._perform_change(rope.base.change.RemoveResource(self),
+        self._perform_change(change.RemoveResource(self),
                              'Removing <%s>' % self.path)
 
     def is_folder(self):
@@ -66,7 +94,7 @@ def __hash__(self):
         return hash(self.path)
 
     def _perform_change(self, change_, description):
-        changes = rope.base.change.ChangeSet(description)
+        changes = change.ChangeSet(description)
         changes.add_change(change_)
         self.project.do(changes)
 
@@ -80,7 +108,7 @@ def __init__(self, project, name):
     def read(self):
         data = self.read_bytes()
         try:
-            return rope.base.fscommands.file_data_to_unicode(data)
+            return fscommands.file_data_to_unicode(data)
         except UnicodeDecodeError, e:
             raise exceptions.ModuleDecodeError(self.path, e.reason)
 
@@ -93,7 +121,7 @@ def write(self, contents):
                 return
         except IOError:
             pass
-        self._perform_change(rope.base.change.ChangeContents(self, contents),
+        self._perform_change(change.ChangeContents(self, contents),
                              'Writing file <%s>' % self.path)
 
     def is_folder(self):
@@ -114,8 +142,12 @@ def is_folder(self):
 
     def get_children(self):
         """Return the children of this folder"""
+        try:
+            children = os.listdir(self.real_path)
+        except OSError:
+            return []
         result = []
-        for name in os.listdir(self.real_path):
+        for name in children:
             try:
                 child = self.get_child(name)
             except exceptions.ResourceNotFoundError:
@@ -126,13 +158,13 @@ def get_children(self):
 
     def create_file(self, file_name):
         self._perform_change(
-            rope.base.change.CreateFile(self, file_name),
+            change.CreateFile(self, file_name),
             'Creating file <%s>' % self._get_child_path(file_name))
         return self.get_child(file_name)
 
     def create_folder(self, folder_name):
         self._perform_change(
-            rope.base.change.CreateFolder(self, folder_name),
+            change.CreateFolder(self, folder_name),
             'Creating folder <%s>' % self._get_child_path(folder_name))
         return self.get_child(folder_name)
 
@@ -187,8 +219,8 @@ def set_patterns(self, patterns):
 
     def _add_pattern(self, pattern):
         re_pattern = pattern.replace('.', '\\.').\
-                     replace('*', '[^/]*').replace('?', '[^/]').\
-                     replace('//', '/(.*/)?')
+            replace('*', '[^/]*').replace('?', '[^/]').\
+            replace('//', '/(.*/)?')
         re_pattern = '^(.*/)?' + re_pattern + '(/.*)?$'
         self.compiled_patterns.append(re.compile(re_pattern))
 
diff --git a/pymode/libs2/rope/base/stdmods.py b/pymode/libs2/rope/base/stdmods.py
index b6c9839b..457a4fac 100644
--- a/pymode/libs2/rope/base/stdmods.py
+++ b/pymode/libs2/rope/base/stdmods.py
@@ -6,12 +6,15 @@
 
 def _stdlib_path():
     import distutils.sysconfig
-    return distutils.sysconfig.get_python_lib(standard_lib=True)
+    return distutils.sysconfig.get_python_lib(standard_lib=True,
+                                              plat_specific=True)
+
 
 @utils.cached(1)
 def standard_modules():
     return python_modules() | dynload_modules()
 
+
 @utils.cached(1)
 def python_modules():
     result = set()
@@ -27,6 +30,7 @@ def python_modules():
                     result.add(name[:-3])
     return result
 
+
 @utils.cached(1)
 def dynload_modules():
     result = set(sys.builtin_module_names)
@@ -35,6 +39,8 @@ def dynload_modules():
         for name in os.listdir(dynload_path):
             path = os.path.join(dynload_path, name)
             if os.path.isfile(path):
-                if name.endswith('.so') or name.endswith('.dll'):
+                if name.endswith('.dll'):
                     result.add(os.path.splitext(name)[0])
+                if name.endswith('.so'):
+                    result.add(os.path.splitext(name)[0].replace('module', ''))
     return result
diff --git a/pymode/libs2/rope/base/taskhandle.py b/pymode/libs2/rope/base/taskhandle.py
index 6d4ed856..c1f01b98 100644
--- a/pymode/libs2/rope/base/taskhandle.py
+++ b/pymode/libs2/rope/base/taskhandle.py
@@ -1,5 +1,3 @@
-import warnings
-
 from rope.base import exceptions
 
 
diff --git a/pymode/libs2/rope/base/utils.py b/pymode/libs2/rope/base/utils.py
index e35ecbf3..11556c13 100644
--- a/pymode/libs2/rope/base/utils.py
+++ b/pymode/libs2/rope/base/utils.py
@@ -5,6 +5,7 @@ def saveit(func):
     """A decorator that caches the return value of a function"""
 
     name = '_' + func.__name__
+
     def _wrapper(self, *args, **kwds):
         if not hasattr(self, name):
             setattr(self, name, func(self, *args, **kwds))
@@ -13,10 +14,12 @@ def _wrapper(self, *args, **kwds):
 
 cacheit = saveit
 
+
 def prevent_recursion(default):
     """A decorator that returns the return value of `default` in recursions"""
     def decorator(func):
         name = '_calling_%s_' % func.__name__
+
         def newfunc(self, *args, **kwds):
             if getattr(self, name, False):
                 return default()
@@ -46,6 +49,7 @@ def deprecated(message=None):
     def _decorator(func, message=message):
         if message is None:
             message = '%s is deprecated' % func.__name__
+
         def newfunc(*args, **kwds):
             warnings.warn(message, DeprecationWarning, stacklevel=2)
             return func(*args, **kwds)
@@ -59,6 +63,7 @@ def decorator(func):
         return _Cached(func, count)
     return decorator
 
+
 class _Cached(object):
 
     def __init__(self, func, count):
diff --git a/pymode/libs2/rope/base/worder.py b/pymode/libs2/rope/base/worder.py
index 08d75f34..c85c6b36 100644
--- a/pymode/libs2/rope/base/worder.py
+++ b/pymode/libs2/rope/base/worder.py
@@ -257,8 +257,10 @@ def get_splitted_primary_before(self, offset):
                 return (self.raw[real_start:end], '', offset)
             last_dot_position = word_start
             if self.code[word_start] != '.':
-                last_dot_position = self._find_last_non_space_char(word_start - 1)
-            last_char_position = self._find_last_non_space_char(last_dot_position - 1)
+                last_dot_position = \
+                    self._find_last_non_space_char(word_start - 1)
+            last_char_position = \
+                self._find_last_non_space_char(last_dot_position - 1)
             if self.code[word_start].isspace():
                 word_start = offset
             return (self.raw[real_start:last_char_position + 1],
@@ -304,8 +306,8 @@ def is_a_function_being_called(self, offset):
         word_end = self._find_word_end(offset) + 1
         next_char = self._find_first_non_space_char(word_end)
         return next_char < len(self.code) and \
-               self.code[next_char] == '(' and \
-               not self.is_a_class_or_function_name_in_header(offset)
+            self.code[next_char] == '(' and \
+            not self.is_a_class_or_function_name_in_header(offset)
 
     def _find_import_end(self, start):
         return self._get_line_end(start)
@@ -337,7 +339,7 @@ def is_from_statement_module(self, offset):
 
     def is_a_name_after_from_import(self, offset):
         try:
-            if len(self.code) > offset and  self.code[offset] == '\n':
+            if len(self.code) > offset and self.code[offset] == '\n':
                 line_start = self._get_line_start(offset - 1)
             else:
                 line_start = self._get_line_start(offset)
@@ -405,7 +407,6 @@ def is_on_function_call_keyword(self, offset):
 
     def find_parens_start_from_inside(self, offset):
         stop = self._get_line_start(offset)
-        opens = 1
         while offset > stop:
             if self.code[offset] == '(':
                 break
@@ -501,7 +502,7 @@ def is_assigned_in_a_tuple_assignment(self, offset):
         parens_start = self.find_parens_start_from_inside(offset)
         # XXX: only handling (x, y) = value
         return offset < equals_offset and \
-               self.code[start:parens_start].strip() == ''
+            self.code[start:parens_start].strip() == ''
 
     def get_function_and_args_in_header(self, offset):
         offset = self.find_function_offset(offset)
@@ -518,7 +519,7 @@ def find_function_offset(self, offset, definition='def '):
         return self._find_first_non_space_char(def_)
 
     def get_lambda_and_args(self, offset):
-        offset = self.find_function_offset(offset, definition = 'lambda ')
-        lparens, rparens = self.get_word_parens_range(offset, opening=' ', closing=':')
+        offset = self.find_function_offset(offset, definition='lambda ')
+        lparens, rparens = self.get_word_parens_range(offset, opening=' ',
+                                                      closing=':')
         return self.raw[offset:rparens + 1]
-
diff --git a/pymode/libs2/rope/contrib/autoimport.py b/pymode/libs2/rope/contrib/autoimport.py
index 4b7b5b05..9670080c 100644
--- a/pymode/libs2/rope/contrib/autoimport.py
+++ b/pymode/libs2/rope/contrib/autoimport.py
@@ -1,7 +1,13 @@
 import re
 
-from rope.base import (exceptions, pynames, resourceobserver,
-                       taskhandle, pyobjects, builtins, resources)
+from rope.base import builtins
+from rope.base import exceptions
+from rope.base import libutils
+from rope.base import pynames
+from rope.base import pyobjects
+from rope.base import resources
+from rope.base import resourceobserver
+from rope.base import taskhandle
 from rope.refactor import importutils
 
 
@@ -65,11 +71,10 @@ def get_all_names(self):
     def get_name_locations(self, name):
         """Return a list of ``(resource, lineno)`` tuples"""
         result = []
-        pycore = self.project.pycore
         for module in self.names:
             if name in self.names[module]:
                 try:
-                    pymodule = pycore.get_module(module)
+                    pymodule = self.project.get_module(module)
                     if name in pymodule:
                         pyname = pymodule[name]
                         module, lineno = pyname.get_definition_location()
@@ -91,7 +96,7 @@ def generate_cache(self, resources=None, underlined=None,
 
         """
         if resources is None:
-            resources = self.project.pycore.get_python_files()
+            resources = self.project.get_python_files()
         job_set = task_handle.create_jobset(
             'Generatig autoimport cache', len(resources))
         for file in resources:
@@ -107,7 +112,7 @@ def generate_modules_cache(self, modules, underlined=None,
         for modname in modules:
             job_set.started_job('Working on <%s>' % modname)
             if modname.endswith('.*'):
-                mod = self.project.pycore.find_module(modname[:-2])
+                mod = self.project.find_module(modname[:-2])
                 if mod:
                     for sub in submodules(mod):
                         self.update_resource(sub, underlined)
@@ -130,13 +135,13 @@ def find_insertion_line(self, code):
         if match is not None:
             code = code[:match.start()]
         try:
-            pymodule = self.project.pycore.get_string_module(code)
+            pymodule = libutils.get_string_module(self.project, code)
         except exceptions.ModuleSyntaxError:
             return 1
         testmodname = '__rope_testmodule_rope'
         importinfo = importutils.NormalImport(((testmodname, None),))
-        module_imports = importutils.get_module_imports(
-            self.project.pycore, pymodule)
+        module_imports = importutils.get_module_imports(self.project,
+                                                        pymodule)
         module_imports.add_import(importinfo)
         code = module_imports.get_changed_source()
         offset = code.index(testmodname)
@@ -146,7 +151,7 @@ def find_insertion_line(self, code):
     def update_resource(self, resource, underlined=None):
         """Update the cache for global names in `resource`"""
         try:
-            pymodule = self.project.pycore.resource_to_pyobject(resource)
+            pymodule = self.project.get_pymodule(resource)
             modname = self._module_name(resource)
             self._add_names(pymodule, modname, underlined)
         except exceptions.ModuleSyntaxError:
@@ -158,13 +163,13 @@ def update_module(self, modname, underlined=None):
         `modname` is the name of a module.
         """
         try:
-            pymodule = self.project.pycore.get_module(modname)
+            pymodule = self.project.get_module(modname)
             self._add_names(pymodule, modname, underlined)
         except exceptions.ModuleNotFoundError:
             pass
 
     def _module_name(self, resource):
-        return self.project.pycore.modname(resource)
+        return libutils.modname(resource)
 
     def _add_names(self, pymodule, modname, underlined):
         if underlined is None:
diff --git a/pymode/libs2/rope/contrib/codeassist.py b/pymode/libs2/rope/contrib/codeassist.py
index 37433c2a..48b4a813 100644
--- a/pymode/libs2/rope/contrib/codeassist.py
+++ b/pymode/libs2/rope/contrib/codeassist.py
@@ -4,8 +4,15 @@
 
 import rope.base.codeanalyze
 import rope.base.evaluate
-from rope.base import pyobjects, pyobjectsdef, pynames, builtins, exceptions, worder
-from rope.base.codeanalyze import SourceLinesAdapter
+from rope.base import builtins
+from rope.base import exceptions
+from rope.base import libutils
+from rope.base import pynames
+from rope.base import pynamesdef
+from rope.base import pyobjects
+from rope.base import pyobjectsdef
+from rope.base import pyscopes
+from rope.base import worder
 from rope.contrib import fixsyntax
 from rope.refactor import functionutils
 
@@ -53,9 +60,7 @@ def starting_offset(source_code, offset):
 
 def get_doc(project, source_code, offset, resource=None, maxfixes=1):
     """Get the pydoc"""
-    fixer = fixsyntax.FixSyntax(project.pycore, source_code,
-                                resource, maxfixes)
-    pymodule = fixer.get_pymodule()
+    fixer = fixsyntax.FixSyntax(project, source_code, resource, maxfixes)
     pyname = fixer.pyname_at(offset)
     if pyname is None:
         return None
@@ -88,9 +93,7 @@ def get_calltip(project, source_code, offset, resource=None,
     If `remove_self` is `True`, the first parameter whose name is self
     will be removed for methods.
     """
-    fixer = fixsyntax.FixSyntax(project.pycore, source_code,
-                                resource, maxfixes)
-    pymodule = fixer.get_pymodule()
+    fixer = fixsyntax.FixSyntax(project, source_code, resource, maxfixes)
     pyname = fixer.pyname_at(offset)
     if pyname is None:
         return None
@@ -108,9 +111,7 @@ def get_definition_location(project, source_code, offset,
     location cannot be determined ``(None, None)`` is returned.
 
     """
-    fixer = fixsyntax.FixSyntax(project.pycore, source_code,
-                                resource, maxfixes)
-    pymodule = fixer.get_pymodule()
+    fixer = fixsyntax.FixSyntax(project, source_code, resource, maxfixes)
     pyname = fixer.pyname_at(offset)
     if pyname is not None:
         module, lineno = pyname.get_definition_location()
@@ -126,6 +127,64 @@ def find_occurrences(*args, **kwds):
     return rope.contrib.findit.find_occurrences(*args, **kwds)
 
 
+def get_canonical_path(project, resource, offset):
+    """Get the canonical path to an object.
+
+    Given the offset of the object, this returns a list of
+    (name, name_type) tuples representing the canonical path to the
+    object. For example, the 'x' in the following code:
+
+        class Foo(object):
+            def bar(self):
+                class Qux(object):
+                    def mux(self, x):
+                        pass
+
+    we will return:
+
+        [('Foo', 'CLASS'), ('bar', 'FUNCTION'), ('Qux', 'CLASS'),
+         ('mux', 'FUNCTION'), ('x', 'PARAMETER')]
+
+    `resource` is a `rope.base.resources.Resource` object.
+
+    `offset` is the offset of the pyname you want the path to.
+
+    """
+    # Retrieve the PyName.
+    pymod = project.get_pymodule(resource)
+    pyname = rope.base.evaluate.eval_location(pymod, offset)
+
+    # Now get the location of the definition and its containing scope.
+    defmod, lineno = pyname.get_definition_location()
+    if not defmod:
+        return None
+    scope = defmod.get_scope().get_inner_scope_for_line(lineno)
+
+    # Start with the name of the object we're interested in.
+    names = []
+    if isinstance(pyname, pynamesdef.ParameterName):
+        names = [(worder.get_name_at(pymod.get_resource(), offset),
+                  'PARAMETER') ]
+    elif isinstance(pyname, pynamesdef.AssignedName):
+        names = [(worder.get_name_at(pymod.get_resource(), offset),
+                  'VARIABLE')]
+
+    # Collect scope names.
+    while scope.parent:
+        if isinstance(scope, pyscopes.FunctionScope):
+            scope_type = 'FUNCTION'
+        elif isinstance(scope, pyscopes.ClassScope):
+            scope_type = 'CLASS'
+        else:
+            scope_type = None
+        names.append((scope.pyobject.get_name(), scope_type))
+        scope = scope.parent
+
+    names.append((defmod.get_resource().real_path, 'MODULE'))
+    names.reverse()
+    return names
+
+
 class CompletionProposal(object):
     """A completion proposal
 
@@ -184,15 +243,14 @@ def type(self):
             if isinstance(pyobject, builtins.BuiltinFunction):
                 return 'function'
             elif isinstance(pyobject, builtins.BuiltinClass):
-                clsobj = pyobject.builtin
                 return 'class'
             elif isinstance(pyobject, builtins.BuiltinObject) or \
-                 isinstance(pyobject, builtins.BuiltinName):
+                    isinstance(pyobject, builtins.BuiltinName):
                 return 'instance'
         elif isinstance(pyname, pynames.ImportedModule):
             return 'module'
         elif isinstance(pyname, pynames.ImportedName) or \
-           isinstance(pyname, pynames.DefinedName):
+                isinstance(pyname, pynames.DefinedName):
             pyobject = pyname.get_object()
             if isinstance(pyobject, pyobjects.AbstractFunction):
                 return 'function'
@@ -222,7 +280,7 @@ def get_doc(self):
 
     @property
     def kind(self):
-        warnings.warn("the proposal's `kind` property is deprecated, " \
+        warnings.warn("the proposal's `kind` property is deprecated, "
                       "use `scope` instead")
         return self.scope
 
@@ -294,7 +352,6 @@ class _PythonCodeAssist(object):
     def __init__(self, project, source_code, offset, resource=None,
                  maxfixes=1, later_locals=True):
         self.project = project
-        self.pycore = self.project.pycore
         self.code = source_code
         self.resource = resource
         self.maxfixes = maxfixes
@@ -309,7 +366,7 @@ def _find_starting_offset(self, source_code, offset):
         current_offset = offset - 1
         while current_offset >= 0 and (source_code[current_offset].isalnum() or
                                        source_code[current_offset] in '_'):
-            current_offset -= 1;
+            current_offset -= 1
         return current_offset + 1
 
     def _matching_keywords(self, starting):
@@ -339,11 +396,12 @@ def _dotted_completions(self, module_scope, holding_scope):
                 compl_scope = 'imported'
             for name, pyname in element.get_attributes().items():
                 if name.startswith(self.starting):
-                    result[name] = CompletionProposal(name, compl_scope, pyname)
+                    result[name] = CompletionProposal(name, compl_scope,
+                                                      pyname)
         return result
 
     def _undotted_completions(self, scope, result, lineno=None):
-        if scope.parent != None:
+        if scope.parent is not None:
             self._undotted_completions(scope.parent, result)
         if lineno is None:
             names = scope.get_propagated_names()
@@ -388,7 +446,7 @@ def _is_defined_after(self, scope, pyname, lineno):
 
     def _code_completions(self):
         lineno = self.code.count('\n', 0, self.offset) + 1
-        fixer = fixsyntax.FixSyntax(self.pycore, self.code,
+        fixer = fixsyntax.FixSyntax(self.project, self.code,
                                     self.resource, self.maxfixes)
         pymodule = fixer.get_pymodule()
         module_scope = pymodule.get_scope()
@@ -413,24 +471,21 @@ def _keyword_parameters(self, pymodule, scope):
         if offset == 0:
             return {}
         word_finder = worder.Worder(self.code, True)
-        lines = SourceLinesAdapter(self.code)
-        lineno = lines.get_line_number(offset)
         if word_finder.is_on_function_call_keyword(offset - 1):
-            name_finder = rope.base.evaluate.ScopeNameFinder(pymodule)
             function_parens = word_finder.\
                 find_parens_start_from_inside(offset - 1)
             primary = word_finder.get_primary_at(function_parens - 1)
             try:
                 function_pyname = rope.base.evaluate.\
                     eval_str(scope, primary)
-            except exceptions.BadIdentifierError, e:
+            except exceptions.BadIdentifierError:
                 return {}
             if function_pyname is not None:
                 pyobject = function_pyname.get_object()
                 if isinstance(pyobject, pyobjects.AbstractFunction):
                     pass
                 elif isinstance(pyobject, pyobjects.AbstractClass) and \
-                     '__init__' in pyobject:
+                        '__init__' in pyobject:
                     pyobject = pyobject['__init__'].get_object()
                 elif '__call__' in pyobject:
                     pyobject = pyobject['__call__'].get_object()
@@ -455,12 +510,12 @@ def __init__(self, code_assist_proposals, scopepref=None, typepref=None):
         self.proposals = code_assist_proposals
         if scopepref is None:
             scopepref = ['parameter_keyword', 'local', 'global', 'imported',
-                        'attribute', 'builtin', 'keyword']
+                         'attribute', 'builtin', 'keyword']
         self.scopepref = scopepref
         if typepref is None:
             typepref = ['class', 'function', 'instance', 'module', None]
         self.typerank = dict((type, index)
-                              for index, type in enumerate(typepref))
+                             for index, type in enumerate(typepref))
 
     def get_sorted_proposal_list(self):
         """Return a list of `CodeAssistProposal`"""
@@ -471,7 +526,7 @@ def get_sorted_proposal_list(self):
         for scope in self.scopepref:
             scope_proposals = proposals.get(scope, [])
             scope_proposals = [proposal for proposal in scope_proposals
-                              if proposal.type in self.typerank]
+                               if proposal.type in self.typerank]
             scope_proposals.sort(self._proposal_cmp)
             result.extend(scope_proposals)
         return result
@@ -526,7 +581,8 @@ def get_calltip(self, pyobject, ignore_unknown=False, remove_self=False):
     def _get_class_docstring(self, pyclass):
         contents = self._trim_docstring(pyclass.get_doc(), 2)
         supers = [super.get_name() for super in pyclass.get_superclasses()]
-        doc = 'class %s(%s):\n\n' % (pyclass.get_name(), ', '.join(supers)) + contents
+        doc = 'class %s(%s):\n\n' % (pyclass.get_name(), ', '.join(supers)) \
+            + contents
 
         if '__init__' in pyclass:
             init = pyclass['__init__'].get_object()
@@ -544,7 +600,7 @@ def _get_function_docstring(self, pyfunction):
 
     def _is_method(self, pyfunction):
         return isinstance(pyfunction, pyobjects.PyFunction) and \
-               isinstance(pyfunction.parent, pyobjects.PyClass)
+            isinstance(pyfunction.parent, pyobjects.PyClass)
 
     def _get_single_function_docstring(self, pyfunction):
         signature = self._get_function_signature(pyfunction)
@@ -579,7 +635,6 @@ def _location(self, pyobject, add_module=False):
             parent = parent.parent
         if add_module:
             if isinstance(pyobject, pyobjects.PyFunction):
-                module = pyobject.get_module()
                 location.insert(0, self._get_module(pyobject))
             if isinstance(parent, builtins.BuiltinModule):
                 location.insert(0, parent.get_name() + '.')
@@ -590,7 +645,7 @@ def _get_module(self, pyfunction):
         if module is not None:
             resource = module.get_resource()
             if resource is not None:
-                return pyfunction.pycore.modname(resource) + '.'
+                return libutils.modname(resource) + '.'
         return ''
 
     def _trim_docstring(self, docstring, indents=0):
diff --git a/pymode/libs2/rope/contrib/finderrors.py b/pymode/libs2/rope/contrib/finderrors.py
index c8cf7e15..9ee7dd15 100644
--- a/pymode/libs2/rope/contrib/finderrors.py
+++ b/pymode/libs2/rope/contrib/finderrors.py
@@ -31,7 +31,7 @@ def find_errors(project, resource):
 
     It returns a list of `Error`\s.
     """
-    pymodule = project.pycore.resource_to_pyobject(resource)
+    pymodule = project.get_pymodule(resource)
     finder = _BadAccessFinder(pymodule)
     ast.walk(pymodule.get_ast(), finder)
     return finder.errors
diff --git a/pymode/libs2/rope/contrib/findit.py b/pymode/libs2/rope/contrib/findit.py
index e8ddd7e5..93eb01a8 100644
--- a/pymode/libs2/rope/contrib/findit.py
+++ b/pymode/libs2/rope/contrib/findit.py
@@ -7,7 +7,8 @@
 
 
 def find_occurrences(project, resource, offset, unsure=False, resources=None,
-                     in_hierarchy=False, task_handle=taskhandle.NullTaskHandle()):
+                     in_hierarchy=False,
+                     task_handle=taskhandle.NullTaskHandle()):
     """Return a list of `Location`\s
 
     If `unsure` is `True`, possible matches are returned, too.  You
@@ -18,16 +19,17 @@ def find_occurrences(project, resource, offset, unsure=False, resources=None,
 
     """
     name = worder.get_name_at(resource, offset)
-    this_pymodule = project.pycore.resource_to_pyobject(resource)
+    this_pymodule = project.get_pymodule(resource)
     primary, pyname = rope.base.evaluate.eval_location2(
         this_pymodule, offset)
+
     def is_match(occurrence):
         return unsure
     finder = occurrences.create_finder(
-        project.pycore, name, pyname, unsure=is_match,
+        project, name, pyname, unsure=is_match,
         in_hierarchy=in_hierarchy, instance=primary)
     if resources is None:
-        resources = project.pycore.get_python_files()
+        resources = project.get_python_files()
     job_set = task_handle.create_jobset('Finding Occurrences',
                                         count=len(resources))
     return _find_locations(finder, resources, job_set)
@@ -41,7 +43,7 @@ def find_implementations(project, resource, offset, resources=None,
     `Location`\s.
     """
     name = worder.get_name_at(resource, offset)
-    this_pymodule = project.pycore.resource_to_pyobject(resource)
+    this_pymodule = project.get_pymodule(resource)
     pyname = rope.base.evaluate.eval_location(this_pymodule, offset)
     if pyname is not None:
         pyobject = pyname.get_object()
@@ -50,17 +52,19 @@ def find_implementations(project, resource, offset, resources=None,
             raise exceptions.BadIdentifierError('Not a method!')
     else:
         raise exceptions.BadIdentifierError('Cannot resolve the identifier!')
+
     def is_defined(occurrence):
         if not occurrence.is_defined():
             return False
+
     def not_self(occurrence):
         if occurrence.get_pyname().get_object() == pyname.get_object():
             return False
     filters = [is_defined, not_self,
                occurrences.InHierarchyFilter(pyname, True)]
-    finder = occurrences.Finder(project.pycore, name, filters=filters)
+    finder = occurrences.Finder(project, name, filters=filters)
     if resources is None:
-        resources = project.pycore.get_python_files()
+        resources = project.get_python_files()
     job_set = task_handle.create_jobset('Finding Implementations',
                                         count=len(resources))
     return _find_locations(finder, resources, job_set)
@@ -72,19 +76,19 @@ def find_definition(project, code, offset, resource=None, maxfixes=1):
     A `Location` object is returned if the definition location can be
     determined, otherwise ``None`` is returned.
     """
-    fixer = fixsyntax.FixSyntax(project.pycore, code, resource, maxfixes)
-    main_module = fixer.get_pymodule()
+    fixer = fixsyntax.FixSyntax(project, code, resource, maxfixes)
     pyname = fixer.pyname_at(offset)
     if pyname is not None:
         module, lineno = pyname.get_definition_location()
         name = rope.base.worder.Worder(code).get_word_at(offset)
         if lineno is not None:
             start = module.lines.get_line_start(lineno)
+
             def check_offset(occurrence):
                 if occurrence.offset < start:
                     return False
             pyname_filter = occurrences.PyNameFilter(pyname)
-            finder = occurrences.Finder(project.pycore, name,
+            finder = occurrences.Finder(project, name,
                                         [check_offset, pyname_filter])
             for occurrence in finder.find_occurrences(pymodule=module):
                 return Location(occurrence)
diff --git a/pymode/libs2/rope/contrib/fixmodnames.py b/pymode/libs2/rope/contrib/fixmodnames.py
index 7092f131..d8bd3da1 100644
--- a/pymode/libs2/rope/contrib/fixmodnames.py
+++ b/pymode/libs2/rope/contrib/fixmodnames.py
@@ -15,7 +15,7 @@
 argument.
 
 """
-from rope.base import change, taskhandle
+from rope.base import taskhandle
 from rope.contrib import changestack
 from rope.refactor import rename
 
@@ -57,7 +57,7 @@ def _count_fixes(self, fixer):
         return len(list(self._tobe_fixed(fixer)))
 
     def _tobe_fixed(self, fixer):
-        for resource in self.project.pycore.get_python_files():
+        for resource in self.project.get_python_files():
             modname = self._name(resource)
             if modname != fixer(modname):
                 yield resource
diff --git a/pymode/libs2/rope/contrib/fixsyntax.py b/pymode/libs2/rope/contrib/fixsyntax.py
index 870046c8..aab5c78c 100644
--- a/pymode/libs2/rope/contrib/fixsyntax.py
+++ b/pymode/libs2/rope/contrib/fixsyntax.py
@@ -1,13 +1,16 @@
 import rope.base.codeanalyze
 import rope.base.evaluate
-from rope.base import worder, exceptions, utils
+from rope.base import exceptions
+from rope.base import libutils
+from rope.base import utils
+from rope.base import worder
 from rope.base.codeanalyze import ArrayLinesAdapter, LogicalLineFinder
 
 
 class FixSyntax(object):
 
-    def __init__(self, pycore, code, resource, maxfixes=1):
-        self.pycore = pycore
+    def __init__(self, project, code, resource, maxfixes=1):
+        self.project = project
         self.code = code
         self.resource = resource
         self.maxfixes = maxfixes
@@ -22,10 +25,11 @@ def get_pymodule(self):
             try:
                 if tries == 0 and self.resource is not None and \
                    self.resource.read() == code:
-                    return self.pycore.resource_to_pyobject(self.resource,
-                                                            force_errors=True)
-                return self.pycore.get_string_module(
-                    code, resource=self.resource, force_errors=True)
+                    return self.project.get_pymodule(self.resource,
+                                                     force_errors=True)
+                return libutils.get_string_module(
+                    self.project, code, resource=self.resource,
+                    force_errors=True)
             except exceptions.ModuleSyntaxError, e:
                 if msg is None:
                     msg = '%s:%s %s' % (e.filename, e.lineno, e.message_)
@@ -34,7 +38,9 @@ def get_pymodule(self):
                     self.commenter.comment(e.lineno)
                     code = '\n'.join(self.commenter.lines)
                 else:
-                    raise exceptions.ModuleSyntaxError(e.filename, e.lineno, msg)
+                    raise exceptions.ModuleSyntaxError(
+                        e.filename, e.lineno,
+                        'Failed to fix error: {}'.format(msg))
 
     @property
     @utils.saveit
@@ -43,6 +49,7 @@ def commenter(self):
 
     def pyname_at(self, offset):
         pymodule = self.get_pymodule()
+
         def old_pyname():
             word_finder = worder.Worder(self.code, True)
             expression = word_finder.get_primary_at(offset)
@@ -51,6 +58,7 @@ def old_pyname():
             scope = pymodule.get_scope().get_inner_scope_for_line(lineno)
             return rope.base.evaluate.eval_str(scope, expression)
         new_code = pymodule.source_code
+
         def new_pyname():
             newoffset = self.commenter.transfered_offset(offset)
             return rope.base.evaluate.eval_location(pymodule, newoffset)
@@ -108,7 +116,6 @@ def _get_block_end(self, lineno):
         return end_line
 
     def _get_stmt_end(self, lineno):
-        end_line = lineno
         base_indents = _get_line_indents(self.lines[lineno])
         for i in range(lineno + 1, len(self.lines)):
             if _get_line_indents(self.lines[i]) <= base_indents:
@@ -117,7 +124,7 @@ def _get_stmt_end(self, lineno):
 
     def _fix_incomplete_try_blocks(self, lineno, indents):
         block_start = lineno
-        last_indents = current_indents = indents
+        last_indents = indents
         while block_start > 0:
             block_start = rope.base.codeanalyze.get_block_start(
                 ArrayLinesAdapter(self.lines), block_start) - 1
@@ -155,6 +162,7 @@ def _insert(self, lineno, line):
         self.origs.insert(lineno, self.origs[lineno])
         self.lines.insert(lineno, line)
 
+
 def _logical_start(lines, lineno, check_prev=False):
     logical_finder = LogicalLineFinder(ArrayLinesAdapter(lines))
     if check_prev:
diff --git a/pymode/libs2/rope/contrib/generate.py b/pymode/libs2/rope/contrib/generate.py
index 4d850da0..825f26d6 100644
--- a/pymode/libs2/rope/contrib/generate.py
+++ b/pymode/libs2/rope/contrib/generate.py
@@ -1,5 +1,7 @@
 import rope.base.evaluate
-from rope.base import change, pyobjects, exceptions, pynames, worder, codeanalyze
+from rope.base import libutils
+from rope.base import (change, pyobjects, exceptions, pynames, worder,
+                       codeanalyze)
 from rope.refactor import sourceutils, importutils, functionutils, suites
 
 
@@ -24,6 +26,7 @@ def create_module(project, name, sourcefolder=None):
         parent = parent.get_child(package)
     return parent.create_file(packages[-1] + '.py')
 
+
 def create_package(project, name, sourcefolder=None):
     """Creates a package and returns a `rope.base.resources.Folder`"""
     if sourcefolder is None:
@@ -55,14 +58,16 @@ def _check_exceptional_conditions(self):
                 'Element <%s> already exists.' % self.name)
         if not self.info.primary_is_found():
             raise exceptions.RefactoringError(
-                'Cannot determine the scope <%s> should be defined in.' % self.name)
+                'Cannot determine the scope <%s> should be defined in.' %
+                self.name)
 
     def get_changes(self):
         changes = change.ChangeSet('Generate %s <%s>' %
                                    (self._get_element_kind(), self.name))
         indents = self.info.get_scope_indents()
         blanks = self.info.get_blank_lines()
-        base_definition = sourceutils.fix_indentation(self._get_element(), indents)
+        base_definition = sourceutils.fix_indentation(self._get_element(),
+                                                      indents)
         definition = '\n' * blanks[0] + base_definition + '\n' * blanks[1]
 
         resource = self.info.get_insertion_resource()
@@ -130,18 +135,19 @@ class GenerateModule(_Generate):
     def get_changes(self):
         package = self.info.get_package()
         changes = change.ChangeSet('Generate Module <%s>' % self.name)
-        new_resource = self.project.get_file('%s/%s.py' % (package.path, self.name))
+        new_resource = self.project.get_file('%s/%s.py' %
+                                             (package.path, self.name))
         if new_resource.exists():
             raise exceptions.RefactoringError(
                 'Module <%s> already exists' % new_resource.path)
         changes.add_change(change.CreateResource(new_resource))
         changes.add_change(_add_import_to_module(
-                           self.project.pycore, self.resource, new_resource))
+                           self.project, self.resource, new_resource))
         return changes
 
     def get_location(self):
         package = self.info.get_package()
-        return (package.get_child('%s.py' % self.name) , 1)
+        return (package.get_child('%s.py' % self.name), 1)
 
 
 class GeneratePackage(_Generate):
@@ -149,13 +155,14 @@ class GeneratePackage(_Generate):
     def get_changes(self):
         package = self.info.get_package()
         changes = change.ChangeSet('Generate Package <%s>' % self.name)
-        new_resource = self.project.get_folder('%s/%s' % (package.path, self.name))
+        new_resource = self.project.get_folder('%s/%s' %
+                                               (package.path, self.name))
         if new_resource.exists():
             raise exceptions.RefactoringError(
                 'Package <%s> already exists' % new_resource.path)
         changes.add_change(change.CreateResource(new_resource))
         changes.add_change(_add_import_to_module(
-                           self.project.pycore, self.resource, new_resource))
+                           self.project, self.resource, new_resource))
         child = self.project.get_folder(package.path + '/' + self.name)
         changes.add_change(change.CreateFile(child, '__init__.py'))
         return changes
@@ -163,14 +170,14 @@ def get_changes(self):
     def get_location(self):
         package = self.info.get_package()
         child = package.get_child(self.name)
-        return (child.get_child('__init__.py') , 1)
+        return (child.get_child('__init__.py'), 1)
 
 
-def _add_import_to_module(pycore, resource, imported):
-    pymodule = pycore.resource_to_pyobject(resource)
-    import_tools = importutils.ImportTools(pycore)
+def _add_import_to_module(project, resource, imported):
+    pymodule = project.get_pymodule(resource)
+    import_tools = importutils.ImportTools(project)
     module_imports = import_tools.module_imports(pymodule)
-    module_name = pycore.modname(imported)
+    module_name = libutils.modname(imported)
     new_import = importutils.NormalImport(((module_name, None), ))
     module_imports.add_import(new_import)
     return change.ChangeContents(resource, module_imports.get_changed_source())
@@ -182,7 +189,7 @@ def __init__(self, pycore, resource, offset):
         self.pycore = pycore
         self.resource = resource
         self.offset = offset
-        self.source_pymodule = self.pycore.resource_to_pyobject(resource)
+        self.source_pymodule = self.pycore.project.get_pymodule(resource)
         finder = rope.base.evaluate.ScopeNameFinder(self.source_pymodule)
         self.primary, self.pyname = finder.get_primary_and_pyname_at(offset)
         self._init_fields()
@@ -264,7 +271,7 @@ def get_blank_lines(self):
     def get_package(self):
         primary = self.primary
         if self.primary is None:
-            return self.pycore.get_source_folders()[0]
+            return self.pycore.project.get_source_folders()[0]
         if isinstance(primary.get_object(), pyobjects.PyPackage):
             return primary.get_object().get_resource()
         raise exceptions.RefactoringError(
@@ -304,15 +311,15 @@ def element_already_exists(self):
 
     def is_static_method(self):
         return self.primary is not None and \
-               isinstance(self.primary.get_object(), pyobjects.PyClass)
+            isinstance(self.primary.get_object(), pyobjects.PyClass)
 
     def is_method(self):
         return self.primary is not None and \
-               isinstance(self.primary.get_object().get_type(), pyobjects.PyClass)
+            isinstance(self.primary.get_object().get_type(), pyobjects.PyClass)
 
     def is_constructor(self):
         return self.pyname is not None and \
-               isinstance(self.pyname.get_object(), pyobjects.PyClass)
+            isinstance(self.pyname.get_object(), pyobjects.PyClass)
 
     def is_instance(self):
         if self.pyname is None:
diff --git a/pymode/libs2/rope/refactor/__init__.py b/pymode/libs2/rope/refactor/__init__.py
index 10d734c3..4ef67513 100644
--- a/pymode/libs2/rope/refactor/__init__.py
+++ b/pymode/libs2/rope/refactor/__init__.py
@@ -45,8 +45,8 @@
 monitoring the progress of refactorings.
 
 """
-from rope.refactor.importutils import ImportOrganizer
-from rope.refactor.topackage import ModuleToPackage
+from rope.refactor.importutils import ImportOrganizer  # noqa
+from rope.refactor.topackage import ModuleToPackage  # noqa
 
 
 __all__ = ['rename', 'move', 'inline', 'extract', 'restructure', 'topackage',
diff --git a/pymode/libs2/rope/refactor/change_signature.py b/pymode/libs2/rope/refactor/change_signature.py
index a8c50d71..4279d9cf 100644
--- a/pymode/libs2/rope/refactor/change_signature.py
+++ b/pymode/libs2/rope/refactor/change_signature.py
@@ -1,7 +1,12 @@
 import copy
 
 import rope.base.exceptions
-from rope.base import pyobjects, taskhandle, evaluate, worder, codeanalyze, utils
+from rope.base import codeanalyze
+from rope.base import evaluate
+from rope.base import pyobjects
+from rope.base import taskhandle
+from rope.base import utils
+from rope.base import worder
 from rope.base.change import ChangeContents, ChangeSet
 from rope.refactor import occurrences, functionutils
 
@@ -9,7 +14,7 @@
 class ChangeSignature(object):
 
     def __init__(self, project, resource, offset):
-        self.pycore = project.pycore
+        self.project = project
         self.resource = resource
         self.offset = offset
         self._set_name_and_pyname()
@@ -20,7 +25,7 @@ def __init__(self, project, resource, offset):
 
     def _set_name_and_pyname(self):
         self.name = worder.get_name_at(self.resource, self.offset)
-        this_pymodule = self.pycore.resource_to_pyobject(self.resource)
+        this_pymodule = self.project.get_pymodule(self.resource)
         self.primary, self.pyname = evaluate.eval_location2(
             this_pymodule, self.offset)
         if self.pyname is None:
@@ -42,21 +47,21 @@ def _set_name_and_pyname(self):
     def _change_calls(self, call_changer, in_hierarchy=None, resources=None,
                       handle=taskhandle.NullTaskHandle()):
         if resources is None:
-            resources = self.pycore.get_python_files()
+            resources = self.project.get_python_files()
         changes = ChangeSet('Changing signature of <%s>' % self.name)
         job_set = handle.create_jobset('Collecting Changes', len(resources))
         finder = occurrences.create_finder(
-            self.pycore, self.name, self.pyname, instance=self.primary,
+            self.project, self.name, self.pyname, instance=self.primary,
             in_hierarchy=in_hierarchy and self.is_method())
         if self.others:
             name, pyname = self.others
             constructor_finder = occurrences.create_finder(
-                self.pycore, name, pyname, only_calls=True)
+                self.project, name, pyname, only_calls=True)
             finder = _MultipleFinders([finder, constructor_finder])
         for file in resources:
             job_set.started_job(file.path)
             change_calls = _ChangeCallsInModule(
-                self.pycore, finder, file, call_changer)
+                self.project, finder, file, call_changer)
             changed_file = change_calls.get_changed_module()
             if changed_file is not None:
                 changes.add_change(ChangeContents(file, changed_file))
@@ -160,12 +165,15 @@ def change_definition(self, call):
     def change_call(self, primary, pyname, call):
         call_info = functionutils.CallInfo.read(
             primary, pyname, self.definition_info, call)
-        mapping = functionutils.ArgumentMapping(self.definition_info, call_info)
+        mapping = functionutils.ArgumentMapping(self.definition_info,
+                                                call_info)
 
-        for definition_info, changer in zip(self.changed_definition_infos, self.changers):
+        for definition_info, changer in zip(self.changed_definition_infos,
+                                            self.changers):
             changer.change_argument_mapping(definition_info, mapping)
 
-        return mapping.to_call_info(self.changed_definition_infos[-1]).to_string()
+        return mapping.to_call_info(
+            self.changed_definition_infos[-1]).to_string()
 
 
 class _ArgumentChanger(object):
@@ -190,12 +198,14 @@ def change_definition_info(self, call_info):
         if self.index < len(call_info.args_with_defaults):
             del call_info.args_with_defaults[self.index]
         elif self.index == len(call_info.args_with_defaults) and \
-           call_info.args_arg is not None:
+                call_info.args_arg is not None:
             call_info.args_arg = None
         elif (self.index == len(call_info.args_with_defaults) and
-            call_info.args_arg is None and call_info.keywords_arg is not None) or \
-           (self.index == len(call_info.args_with_defaults) + 1 and
-            call_info.args_arg is not None and call_info.keywords_arg is not None):
+              call_info.args_arg is None and
+              call_info.keywords_arg is not None) or \
+                (self.index == len(call_info.args_with_defaults) + 1 and
+                 call_info.args_arg is not None and
+                 call_info.keywords_arg is not None):
             call_info.keywords_arg = None
 
     def change_argument_mapping(self, definition_info, mapping):
@@ -282,8 +292,8 @@ def change_definition_info(self, definition_info):
 
 class _ChangeCallsInModule(object):
 
-    def __init__(self, pycore, occurrence_finder, resource, call_changer):
-        self.pycore = pycore
+    def __init__(self, project, occurrence_finder, resource, call_changer):
+        self.project = project
         self.occurrence_finder = occurrence_finder
         self.resource = resource
         self.call_changer = call_changer
@@ -291,11 +301,13 @@ def __init__(self, pycore, occurrence_finder, resource, call_changer):
     def get_changed_module(self):
         word_finder = worder.Worder(self.source)
         change_collector = codeanalyze.ChangeCollector(self.source)
-        for occurrence in self.occurrence_finder.find_occurrences(self.resource):
+        for occurrence in self.occurrence_finder.find_occurrences(
+                self.resource):
             if not occurrence.is_called() and not occurrence.is_defined():
                 continue
             start, end = occurrence.get_primary_range()
-            begin_parens, end_parens = word_finder.get_word_parens_range(end - 1)
+            begin_parens, end_parens = word_finder.\
+                get_word_parens_range(end - 1)
             if occurrence.is_called():
                 primary, pyname = occurrence.get_primary_and_pyname()
                 changed_call = self.call_changer.change_call(
@@ -310,7 +322,7 @@ def get_changed_module(self):
     @property
     @utils.saveit
     def pymodule(self):
-        return self.pycore.resource_to_pyobject(self.resource)
+        return self.project.get_pymodule(self.resource)
 
     @property
     @utils.saveit
diff --git a/pymode/libs2/rope/refactor/encapsulate_field.py b/pymode/libs2/rope/refactor/encapsulate_field.py
index af8d3ccf..32cb7a95 100644
--- a/pymode/libs2/rope/refactor/encapsulate_field.py
+++ b/pymode/libs2/rope/refactor/encapsulate_field.py
@@ -1,4 +1,10 @@
-from rope.base import pynames, taskhandle, evaluate, exceptions, worder, utils
+from rope.base import evaluate
+from rope.base import exceptions
+from rope.base import libutils
+from rope.base import pynames
+from rope.base import taskhandle
+from rope.base import utils
+from rope.base import worder
 from rope.base.change import ChangeSet, ChangeContents
 from rope.refactor import sourceutils, occurrences
 
@@ -6,9 +12,9 @@
 class EncapsulateField(object):
 
     def __init__(self, project, resource, offset):
-        self.pycore = project.pycore
+        self.project = project
         self.name = worder.get_name_at(resource, offset)
-        this_pymodule = self.pycore.resource_to_pyobject(resource)
+        this_pymodule = self.project.get_pymodule(resource)
         self.pyname = evaluate.eval_location(this_pymodule, offset)
         if not self._is_an_attribute(self.pyname):
             raise exceptions.RefactoringError(
@@ -30,7 +36,7 @@ def get_changes(self, getter=None, setter=None, resources=None,
 
         """
         if resources is None:
-            resources = self.pycore.get_python_files()
+            resources = self.project.get_python_files()
         changes = ChangeSet('Encapsulate field <%s>' % self.name)
         job_set = task_handle.create_jobset('Collecting Changes',
                                             len(resources))
@@ -39,7 +45,7 @@ def get_changes(self, getter=None, setter=None, resources=None,
         if setter is None:
             setter = 'set_' + self.name
         renamer = GetterSetterRenameInModule(
-            self.pycore, self.name, self.pyname, getter, setter)
+            self.project, self.name, self.pyname, getter, setter)
         for file in resources:
             job_set.started_job(file.path)
             if file == self.resource:
@@ -61,7 +67,7 @@ def _is_an_attribute(self, pyname):
         if pyname is not None and isinstance(pyname, pynames.AssignedName):
             pymodule, lineno = self.pyname.get_definition_location()
             scope = pymodule.get_scope().\
-                             get_inner_scope_for_line(lineno)
+                get_inner_scope_for_line(lineno)
             if scope.get_kind() == 'Class':
                 return pyname in scope.get_names().values()
             parent = scope.parent
@@ -80,7 +86,7 @@ def _get_defining_scope(self):
         return pymodule.get_scope().get_inner_scope_for_line(line)
 
     def _change_holding_module(self, changes, renamer, getter, setter):
-        pymodule = self.pycore.resource_to_pyobject(self.resource)
+        pymodule = self.project.get_pymodule(self.resource)
         class_scope = self._get_defining_class_scope()
         defining_object = self._get_defining_scope().pyobject
         start, end = sourceutils.get_body_region(defining_object)
@@ -88,10 +94,11 @@ def _change_holding_module(self, changes, renamer, getter, setter):
         new_source = renamer.get_changed_module(pymodule=pymodule,
                                                 skip_start=start, skip_end=end)
         if new_source is not None:
-            pymodule = self.pycore.get_string_module(new_source, self.resource)
+            pymodule = libutils.get_string_module(
+                self.project, new_source, self.resource)
             class_scope = pymodule.get_scope().\
-                          get_inner_scope_for_line(class_scope.get_start())
-        indents = sourceutils.get_indent(self.pycore) * ' '
+                get_inner_scope_for_line(class_scope.get_start())
+        indents = sourceutils.get_indent(self.project) * ' '
         getter = 'def %s(self):\n%sreturn self.%s' % \
                  (getter, indents, self.name)
         setter = 'def %s(self, value):\n%sself.%s = value' % \
@@ -103,10 +110,10 @@ def _change_holding_module(self, changes, renamer, getter, setter):
 
 class GetterSetterRenameInModule(object):
 
-    def __init__(self, pycore, name, pyname, getter, setter):
-        self.pycore = pycore
+    def __init__(self, project, name, pyname, getter, setter):
+        self.project = project
         self.name = name
-        self.finder = occurrences.create_finder(pycore, name, pyname)
+        self.finder = occurrences.create_finder(project, name, pyname)
         self.getter = getter
         self.setter = setter
 
@@ -120,7 +127,7 @@ def get_changed_module(self, resource=None, pymodule=None,
 class _FindChangesForModule(object):
 
     def __init__(self, finder, resource, pymodule, skip_start, skip_end):
-        self.pycore = finder.pycore
+        self.project = finder.project
         self.finder = finder.finder
         self.getter = finder.getter
         self.setter = finder.setter
@@ -155,7 +162,7 @@ def get_changed_module(self):
                                   + ' %s ' % assignment_type[:-1])
                 current_line = self.lines.get_line_number(start)
                 start_line, end_line = self.pymodule.logical_lines.\
-                                       logical_line_in(current_line)
+                    logical_line_in(current_line)
                 self.last_set = self.lines.get_line_end(end_line)
                 end = self.source.index('=', end) + 1
                 self.set_index = len(result)
@@ -193,7 +200,7 @@ def source(self):
     @utils.saveit
     def lines(self):
         if self.pymodule is None:
-            self.pymodule = self.pycore.resource_to_pyobject(self.resource)
+            self.pymodule = self.project.get_pymodule(self.resource)
         return self.pymodule.lines
 
     @property
diff --git a/pymode/libs2/rope/refactor/extract.py b/pymode/libs2/rope/refactor/extract.py
index 3e7a619c..be541bb5 100644
--- a/pymode/libs2/rope/refactor/extract.py
+++ b/pymode/libs2/rope/refactor/extract.py
@@ -12,7 +12,7 @@
 #
 # _ExtractInfo: holds information about the refactoring; it is passed
 # to the parts that need to have information about the refactoring
-# 
+#
 # _ExtractCollector: merely saves all of the information necessary for
 # performing the refactoring.
 #
@@ -36,7 +36,6 @@ class _ExtractRefactoring(object):
     def __init__(self, project, resource, start_offset, end_offset,
                  variable=False):
         self.project = project
-        self.pycore = project.pycore
         self.resource = resource
         self.start_offset = self._fix_start(resource.read(), start_offset)
         self.end_offset = self._fix_end(resource.read(), end_offset)
@@ -95,9 +94,9 @@ class _ExtractInfo(object):
 
     def __init__(self, project, resource, start, end, new_name,
                  variable, similar, make_global):
-        self.pycore = project.pycore
+        self.project = project
         self.resource = resource
-        self.pymodule = self.pycore.resource_to_pyobject(resource)
+        self.pymodule = project.get_pymodule(resource)
         self.global_scope = self.pymodule.get_scope()
         self.source = self.pymodule.source_code
         self.lines = self.pymodule.lines
@@ -153,8 +152,8 @@ def _choose_closest_line_end(self, offset, end=False):
     @property
     def one_line(self):
         return self.region != self.lines_region and \
-               (self.logical_lines.logical_line_in(self.region_lines[0]) ==
-                self.logical_lines.logical_line_in(self.region_lines[1]))
+            (self.logical_lines.logical_line_in(self.region_lines[0]) ==
+             self.logical_lines.logical_line_in(self.region_lines[1]))
 
     @property
     def global_(self):
@@ -163,7 +162,7 @@ def global_(self):
     @property
     def method(self):
         return self.scope.parent is not None and \
-               self.scope.parent.get_kind() == 'Class'
+            self.scope.parent.get_kind() == 'Class'
 
     @property
     def indents(self):
@@ -182,6 +181,7 @@ def extracted(self):
         return self.source[self.region[0]:self.region[1]]
 
     _returned = None
+
     @property
     def returned(self):
         """Does the extracted piece contain return statement"""
@@ -273,7 +273,8 @@ def _where_to_search(self):
                 if self.info.variable:
                     return [self.info.scope_region]
                 else:
-                    return [self.info._get_scope_region(self.info.scope.parent)]
+                    return [self.info._get_scope_region(
+                        self.info.scope.parent)]
         else:
             return [self.info.region]
 
@@ -391,8 +392,9 @@ def multi_line_conditions(self, info):
                                    'contain complete statements.')
 
     def _is_region_on_a_word(self, info):
-        if info.region[0] > 0 and self._is_on_a_word(info, info.region[0] - 1) or \
-           self._is_on_a_word(info, info.region[1] - 1):
+        if info.region[0] > 0 and \
+                self._is_on_a_word(info, info.region[0] - 1) or \
+                self._is_on_a_word(info, info.region[1] - 1):
             return True
 
     def _is_on_a_word(self, info, offset):
@@ -436,7 +438,7 @@ def _get_body(self):
         return result
 
     def _find_temps(self):
-        return usefunction.find_temps(self.info.pycore.project,
+        return usefunction.find_temps(self.info.project,
                                       self._get_body())
 
     def get_checks(self):
@@ -468,7 +470,7 @@ def _get_function_definition(self):
             result.append('@staticmethod\n')
         result.append('def %s:\n' % self._get_function_signature(args))
         unindented_body = self._get_unindented_function_body(returns)
-        indents = sourceutils.get_indent(self.info.pycore)
+        indents = sourceutils.get_indent(self.info.project)
         function_body = sourceutils.indent_lines(unindented_body, indents)
         result.append(function_body)
         definition = ''.join(result)
@@ -487,11 +489,11 @@ def _get_function_signature(self, args):
                 args.remove(self_name)
             args.insert(0, self_name)
         return prefix + self.info.new_name + \
-               '(%s)' % self._get_comma_form(args)
+            '(%s)' % self._get_comma_form(args)
 
     def _extracting_method(self):
         return self.info.method and not self.info.make_global and \
-               _get_function_kind(self.info.scope) == 'method'
+            _get_function_kind(self.info.scope) == 'method'
 
     def _get_self_name(self):
         param_names = self.info.scope.pyobject.get_param_names()
@@ -503,7 +505,7 @@ def _get_function_call(self, args):
         if self.info.method and not self.info.make_global:
             if _get_function_kind(self.info.scope) == 'method':
                 self_name = self._get_self_name()
-                if  self_name in args:
+                if self_name in args:
                     args.remove(self_name)
                 prefix = self_name + '.'
             else:
@@ -557,7 +559,7 @@ def _find_function_returns(self):
         if self.info.one_line or self.info.returned:
             return []
         written = self.info_collector.written | \
-                  self.info_collector.maybe_written
+            self.info_collector.maybe_written
         return list(written & self.info_collector.postread)
 
     def _get_unindented_function_body(self, returns):
@@ -577,7 +579,7 @@ def __init__(self, info):
 
     def get_definition(self):
         result = self.info.new_name + ' = ' + \
-                 _join_lines(self.info.extracted) + '\n'
+            _join_lines(self.info.extracted) + '\n'
         return result
 
     def get_body_pattern(self):
@@ -671,7 +673,6 @@ def _For(self, node):
         self._handle_conditional_node(node)
 
 
-
 def _get_argnames(arguments):
     result = [node.id for node in arguments.args
               if isinstance(node, ast.Name)]
@@ -770,6 +771,7 @@ def has_errors(code):
         ast.walk(node, visitor)
         return visitor.error
 
+
 def _get_function_kind(scope):
     return scope.pyobject.get_kind()
 
@@ -779,6 +781,7 @@ def _parse_text(body):
     node = ast.parse(body)
     return node
 
+
 def _join_lines(code):
     lines = []
     for line in code.splitlines():
diff --git a/pymode/libs2/rope/refactor/functionutils.py b/pymode/libs2/rope/refactor/functionutils.py
index a653b9db..58baf917 100644
--- a/pymode/libs2/rope/refactor/functionutils.py
+++ b/pymode/libs2/rope/refactor/functionutils.py
@@ -32,9 +32,6 @@ def arguments_to_string(self, from_index=0):
 
     @staticmethod
     def _read(pyfunction, code):
-        scope = pyfunction.get_scope()
-        parent = scope.parent
-        parameter_names = pyfunction.get_param_names()
         kind = pyfunction.get_kind()
         is_method = kind == 'method'
         is_lambda = kind == 'lambda'
@@ -89,7 +86,8 @@ def to_string(self):
         if self.args[start:]:
             params.extend(self.args[start:])
         if self.keywords:
-            params.extend(['%s=%s' % (name, value) for name, value in self.keywords])
+            params.extend(['%s=%s' % (name, value)
+                          for name, value in self.keywords])
         if self.args_arg is not None:
             params.append('*' + self.args_arg)
         if self.keywords_arg:
@@ -120,15 +118,15 @@ def read(primary, pyname, definition_info, code):
     @staticmethod
     def _is_method_call(primary, pyname):
         return primary is not None and \
-               isinstance(primary.get_object().get_type(),
-                          rope.base.pyobjects.PyClass) and \
-                          CallInfo._is_method(pyname)
+            isinstance(primary.get_object().get_type(),
+                       rope.base.pyobjects.PyClass) and \
+            CallInfo._is_method(pyname)
 
     @staticmethod
     def _is_class(pyname):
         return pyname is not None and \
-               isinstance(pyname.get_object(),
-                          rope.base.pyobjects.PyClass)
+            isinstance(pyname.get_object(),
+                       rope.base.pyobjects.PyClass)
 
     @staticmethod
     def _is_method(pyname):
@@ -184,7 +182,8 @@ def to_call_info(self, definition_info):
         keywords.extend(self.keyword_args)
         return CallInfo(self.call_info.function_name, args, keywords,
                         self.call_info.args_arg, self.call_info.keywords_arg,
-                        self.call_info.implicit_arg, self.call_info.constructor)
+                        self.call_info.implicit_arg,
+                        self.call_info.constructor)
 
 
 class _FunctionParser(object):
@@ -197,7 +196,8 @@ def __init__(self, call, implicit_arg, is_lambda=False):
             self.last_parens = self.call.rindex(':')
         else:
             self.last_parens = self.call.rindex(')')
-        self.first_parens = self.word_finder._find_parens_start(self.last_parens)
+        self.first_parens = self.word_finder._find_parens_start(
+            self.last_parens)
 
     def get_parameters(self):
         args, keywords = self.word_finder.get_parameters(self.first_parens,
diff --git a/pymode/libs2/rope/refactor/importutils/__init__.py b/pymode/libs2/rope/refactor/importutils/__init__.py
index 2a86edb0..4871faf3 100644
--- a/pymode/libs2/rope/refactor/importutils/__init__.py
+++ b/pymode/libs2/rope/refactor/importutils/__init__.py
@@ -5,6 +5,7 @@
 
 """
 import rope.base.evaluate
+from rope.base import libutils
 from rope.base.change import ChangeSet, ChangeContents
 from rope.refactor import occurrences, rename
 from rope.refactor.importutils import module_imports, actions
@@ -21,8 +22,7 @@ class ImportOrganizer(object):
 
     def __init__(self, project):
         self.project = project
-        self.pycore = project.pycore
-        self.import_tools = ImportTools(self.pycore)
+        self.import_tools = ImportTools(self.project)
 
     def organize_imports(self, resource, offset=None):
         return self._perform_command_on_import_tools(
@@ -45,7 +45,7 @@ def handle_long_imports(self, resource, offset=None):
             self.import_tools.handle_long_imports, resource, offset)
 
     def _perform_command_on_import_tools(self, method, resource, offset):
-        pymodule = self.pycore.resource_to_pyobject(resource)
+        pymodule = self.project.get_pymodule(resource)
         before_performing = pymodule.source_code
         import_filter = None
         if offset is not None:
@@ -66,26 +66,26 @@ def import_filter(import_stmt):
 
 class ImportTools(object):
 
-    def __init__(self, pycore):
-        self.pycore = pycore
+    def __init__(self, project):
+        self.project = project
 
     def get_import(self, resource):
         """The import statement for `resource`"""
-        module_name = self.pycore.modname(resource)
+        module_name = libutils.modname(resource)
         return NormalImport(((module_name, None), ))
 
     def get_from_import(self, resource, name):
         """The from import statement for `name` in `resource`"""
-        module_name = self.pycore.modname(resource)
+        module_name = libutils.modname(resource)
         names = []
         if isinstance(name, list):
             names = [(imported, None) for imported in name]
         else:
-            names = [(name, None),]
+            names = [(name, None), ]
         return FromImport(module_name, 0, tuple(names))
 
     def module_imports(self, module, imports_filter=None):
-        return module_imports.ModuleImports(self.pycore, module,
+        return module_imports.ModuleImports(self.project, module,
                                             imports_filter)
 
     def froms_to_imports(self, pymodule, import_filter=None):
@@ -103,7 +103,8 @@ def froms_to_imports(self, pymodule, import_filter=None):
             if not import_stmt.readonly and \
                self._is_transformable_to_normal(import_stmt.import_info):
                 import_stmt.import_info = \
-                    NormalImport(((import_stmt.import_info.module_name, None),))
+                    NormalImport(((import_stmt.import_info.module_name,
+                                 None),))
         module_imports.remove_duplicates()
         return module_imports.get_changed_source()
 
@@ -121,12 +122,13 @@ def _from_to_normal(self, pymodule, import_stmt):
             if alias is not None:
                 imported = alias
             occurrence_finder = occurrences.create_finder(
-                self.pycore, imported, pymodule[imported], imports=False)
+                self.project, imported, pymodule[imported], imports=False)
             source = rename.rename_in_module(
                 occurrence_finder, module_name + '.' + name,
                 pymodule=pymodule, replace_primary=True)
             if source is not None:
-                pymodule = self.pycore.get_string_module(source, resource)
+                pymodule = libutils.get_string_module(
+                    self.project, source, resource)
         return pymodule
 
     def _clean_up_imports(self, pymodule, import_filter):
@@ -135,17 +137,20 @@ def _clean_up_imports(self, pymodule, import_filter):
         module_with_imports.expand_stars()
         source = module_with_imports.get_changed_source()
         if source is not None:
-            pymodule = self.pycore.get_string_module(source, resource)
+            pymodule = libutils.get_string_module(
+                self.project, source, resource)
         source = self.relatives_to_absolutes(pymodule)
         if source is not None:
-            pymodule = self.pycore.get_string_module(source, resource)
+            pymodule = libutils.get_string_module(
+                self.project, source, resource)
 
         module_with_imports = self.module_imports(pymodule, import_filter)
         module_with_imports.remove_duplicates()
         module_with_imports.remove_unused_imports()
         source = module_with_imports.get_changed_source()
         if source is not None:
-            pymodule = self.pycore.get_string_module(source, resource)
+            pymodule = libutils.get_string_module(
+                self.project, source, resource)
         return pymodule
 
     def relatives_to_absolutes(self, pymodule, import_filter=None):
@@ -172,12 +177,14 @@ def organize_imports(self, pymodule,
             module_imports = self.module_imports(pymodule, import_filter)
             if unused:
                 module_imports.remove_unused_imports()
+            if self.project.prefs.get("split_imports"):
+                module_imports.force_single_imports()
             if duplicates:
                 module_imports.remove_duplicates()
             source = module_imports.get_changed_source()
             if source is not None:
-                pymodule = self.pycore.get_string_module(
-                    source, pymodule.get_resource())
+                pymodule = libutils.get_string_module(
+                    self.project, source, pymodule.get_resource())
         if selfs:
             pymodule = self._remove_self_imports(pymodule, import_filter)
         if sort:
@@ -187,10 +194,12 @@ def organize_imports(self, pymodule,
 
     def _remove_self_imports(self, pymodule, import_filter=None):
         module_imports = self.module_imports(pymodule, import_filter)
-        to_be_fixed, to_be_renamed = module_imports.get_self_import_fix_and_rename_list()
+        to_be_fixed, to_be_renamed = \
+            module_imports.get_self_import_fix_and_rename_list()
         for name in to_be_fixed:
             try:
-                pymodule = self._rename_in_module(pymodule, name, '', till_dot=True)
+                pymodule = self._rename_in_module(pymodule, name, '',
+                                                  till_dot=True)
             except ValueError:
                 # There is a self import with direct access to it
                 return pymodule
@@ -200,16 +209,18 @@ def _remove_self_imports(self, pymodule, import_filter=None):
         module_imports.get_self_import_fix_and_rename_list()
         source = module_imports.get_changed_source()
         if source is not None:
-            pymodule = self.pycore.get_string_module(source, pymodule.get_resource())
+            pymodule = libutils.get_string_module(
+                self.project, source, pymodule.get_resource())
         return pymodule
 
     def _rename_in_module(self, pymodule, name, new_name, till_dot=False):
         old_name = name.split('.')[-1]
         old_pyname = rope.base.evaluate.eval_str(pymodule.get_scope(), name)
         occurrence_finder = occurrences.create_finder(
-            self.pycore, old_name, old_pyname, imports=False)
+            self.project, old_name, old_pyname, imports=False)
         changes = rope.base.codeanalyze.ChangeCollector(pymodule.source_code)
-        for occurrence in occurrence_finder.find_occurrences(pymodule=pymodule):
+        for occurrence in occurrence_finder.find_occurrences(
+                pymodule=pymodule):
             start, end = occurrence.get_primary_range()
             if till_dot:
                 new_end = pymodule.source_code.index('.', end) + 1
@@ -222,7 +233,8 @@ def _rename_in_module(self, pymodule, name, new_name, till_dot=False):
             changes.add_change(start, end, new_name)
         source = changes.get_changed()
         if source is not None:
-            pymodule = self.pycore.get_string_module(source, pymodule.get_resource())
+            pymodule = libutils.get_string_module(
+                self.project, source, pymodule.get_resource())
         return pymodule
 
     def sort_imports(self, pymodule, import_filter=None):
@@ -237,8 +249,8 @@ def handle_long_imports(self, pymodule, maxdots=2, maxlength=27,
         module_imports = self.module_imports(pymodule, import_filter)
         to_be_fixed = module_imports.handle_long_imports(maxdots, maxlength)
         # performing the renaming
-        pymodule = self.pycore.get_string_module(
-            module_imports.get_changed_source(),
+        pymodule = libutils.get_string_module(
+            self.project, module_imports.get_changed_source(),
             resource=pymodule.get_resource())
         for name in to_be_fixed:
             pymodule = self._rename_in_module(pymodule, name,
@@ -248,22 +260,22 @@ def handle_long_imports(self, pymodule, maxdots=2, maxlength=27,
                                      import_filter=import_filter)
 
 
-def get_imports(pycore, pydefined):
+def get_imports(project, pydefined):
     """A shortcut for getting the `ImportInfo`\s used in a scope"""
     pymodule = pydefined.get_module()
-    module = module_imports.ModuleImports(pycore, pymodule)
+    module = module_imports.ModuleImports(project, pymodule)
     if pymodule == pydefined:
         return [stmt.import_info for stmt in module.imports]
     return module.get_used_imports(pydefined)
 
 
-def get_module_imports(pycore, pymodule):
+def get_module_imports(project, pymodule):
     """A shortcut for creating a `module_imports.ModuleImports` object"""
-    return module_imports.ModuleImports(pycore, pymodule)
+    return module_imports.ModuleImports(project, pymodule)
 
 
-def add_import(pycore, pymodule, module_name, name=None):
-    imports = get_module_imports(pycore, pymodule)
+def add_import(project, pymodule, module_name, name=None):
+    imports = get_module_imports(project, pymodule)
     candidates = []
     names = []
     # from mod import name
@@ -288,7 +300,7 @@ def add_import(pycore, pymodule, module_name, name=None):
 
     candidates.append(normal_import)
 
-    visitor = actions.AddingVisitor(pycore, candidates)
+    visitor = actions.AddingVisitor(project, candidates)
     selected_import = normal_import
     for import_statement in imports.imports:
         if import_statement.accept(visitor):
diff --git a/pymode/libs2/rope/refactor/importutils/actions.py b/pymode/libs2/rope/refactor/importutils/actions.py
index 4851d02f..fd0f7054 100644
--- a/pymode/libs2/rope/refactor/importutils/actions.py
+++ b/pymode/libs2/rope/refactor/importutils/actions.py
@@ -1,6 +1,4 @@
-import os
-import sys
-
+from rope.base import libutils
 from rope.base import pyobjects, exceptions, stdmods
 from rope.refactor import occurrences
 from rope.refactor.importutils import importinfo
@@ -28,24 +26,25 @@ def visitFromImport(self, import_stmt, import_info):
 
 class RelativeToAbsoluteVisitor(ImportInfoVisitor):
 
-    def __init__(self, pycore, current_folder):
+    def __init__(self, project, current_folder):
         self.to_be_absolute = []
-        self.pycore = pycore
+        self.project = project
         self.folder = current_folder
-        self.context = importinfo.ImportContext(pycore, current_folder)
+        self.context = importinfo.ImportContext(project, current_folder)
 
     def visitNormalImport(self, import_stmt, import_info):
-        self.to_be_absolute.extend(self._get_relative_to_absolute_list(import_info))
+        self.to_be_absolute.extend(
+            self._get_relative_to_absolute_list(import_info))
         new_pairs = []
         for name, alias in import_info.names_and_aliases:
-            resource = self.pycore.find_module(name, folder=self.folder)
+            resource = self.project.find_module(name, folder=self.folder)
             if resource is None:
                 new_pairs.append((name, alias))
                 continue
-            absolute_name = self.pycore.modname(resource)
+            absolute_name = libutils.modname(resource)
             new_pairs.append((absolute_name, alias))
         if not import_info._are_name_and_alias_lists_equal(
-            new_pairs, import_info.names_and_aliases):
+                new_pairs, import_info.names_and_aliases):
             import_stmt.import_info = importinfo.NormalImport(new_pairs)
 
     def _get_relative_to_absolute_list(self, import_info):
@@ -53,10 +52,10 @@ def _get_relative_to_absolute_list(self, import_info):
         for name, alias in import_info.names_and_aliases:
             if alias is not None:
                 continue
-            resource = self.pycore.find_module(name, folder=self.folder)
+            resource = self.project.find_module(name, folder=self.folder)
             if resource is None:
                 continue
-            absolute_name = self.pycore.modname(resource)
+            absolute_name = libutils.modname(resource)
             if absolute_name != name:
                 result.append((name, absolute_name))
         return result
@@ -65,7 +64,7 @@ def visitFromImport(self, import_stmt, import_info):
         resource = import_info.get_imported_resource(self.context)
         if resource is None:
             return None
-        absolute_name = self.pycore.modname(resource)
+        absolute_name = libutils.modname(resource)
         if import_info.module_name != absolute_name:
             import_stmt.import_info = importinfo.FromImport(
                 absolute_name, 0, import_info.names_and_aliases)
@@ -73,11 +72,11 @@ def visitFromImport(self, import_stmt, import_info):
 
 class FilteringVisitor(ImportInfoVisitor):
 
-    def __init__(self, pycore, folder, can_select):
+    def __init__(self, project, folder, can_select):
         self.to_be_absolute = []
-        self.pycore = pycore
+        self.project = project
         self.can_select = self._transform_can_select(can_select)
-        self.context = importinfo.ImportContext(pycore, folder)
+        self.context = importinfo.ImportContext(project, folder)
 
     def _transform_can_select(self, can_select):
         def can_select_name_and_alias(name, alias):
@@ -113,10 +112,10 @@ def visitFromImport(self, import_stmt, import_info):
 
 class RemovingVisitor(ImportInfoVisitor):
 
-    def __init__(self, pycore, folder, can_select):
+    def __init__(self, project, folder, can_select):
         self.to_be_absolute = []
-        self.pycore = pycore
-        self.filtering = FilteringVisitor(pycore, folder, can_select)
+        self.project = project
+        self.filtering = FilteringVisitor(project, folder, can_select)
 
     def dispatch(self, import_):
         result = self.filtering.dispatch(import_)
@@ -133,8 +132,8 @@ class AddingVisitor(ImportInfoVisitor):
 
     """
 
-    def __init__(self, pycore, import_list):
-        self.pycore = pycore
+    def __init__(self, project, import_list):
+        self.project = project
         self.import_list = import_list
         self.import_info = None
 
@@ -162,7 +161,8 @@ def visitNormalImport(self, import_stmt, import_info):
         # Multiple imports using a single import statement is discouraged
         # so we won't bother adding them.
         if self.import_info._are_name_and_alias_lists_equal(
-            import_info.names_and_aliases, self.import_info.names_and_aliases):
+                import_info.names_and_aliases,
+                self.import_info.names_and_aliases):
             return True
 
     def visitFromImport(self, import_stmt, import_info):
@@ -174,6 +174,9 @@ def visitFromImport(self, import_stmt, import_info):
             if self.import_info.is_star_import():
                 import_stmt.import_info = self.import_info
                 return True
+            if self.project.prefs.get("split_imports"):
+                return self.import_info.names_and_aliases == \
+                    import_info.names_and_aliases
             new_pairs = list(import_info.names_and_aliases)
             for pair in self.import_info.names_and_aliases:
                 if pair not in new_pairs:
@@ -185,10 +188,10 @@ def visitFromImport(self, import_stmt, import_info):
 
 class ExpandStarsVisitor(ImportInfoVisitor):
 
-    def __init__(self, pycore, folder, can_select):
-        self.pycore = pycore
-        self.filtering = FilteringVisitor(pycore, folder, can_select)
-        self.context = importinfo.ImportContext(pycore, folder)
+    def __init__(self, project, folder, can_select):
+        self.project = project
+        self.filtering = FilteringVisitor(project, folder, can_select)
+        self.context = importinfo.ImportContext(project, folder)
 
     def visitNormalImport(self, import_stmt, import_info):
         self.filtering.dispatch(import_stmt)
@@ -208,18 +211,18 @@ def visitFromImport(self, import_stmt, import_info):
 
 class SelfImportVisitor(ImportInfoVisitor):
 
-    def __init__(self, pycore, current_folder, resource):
-        self.pycore = pycore
+    def __init__(self, project, current_folder, resource):
+        self.project = project
         self.folder = current_folder
         self.resource = resource
         self.to_be_fixed = set()
         self.to_be_renamed = set()
-        self.context = importinfo.ImportContext(pycore, current_folder)
+        self.context = importinfo.ImportContext(project, current_folder)
 
     def visitNormalImport(self, import_stmt, import_info):
         new_pairs = []
         for name, alias in import_info.names_and_aliases:
-            resource = self.pycore.find_module(name, folder=self.folder)
+            resource = self.project.find_module(name, folder=self.folder)
             if resource is not None and resource == self.resource:
                 imported = name
                 if alias is not None:
@@ -228,7 +231,7 @@ def visitNormalImport(self, import_stmt, import_info):
             else:
                 new_pairs.append((name, alias))
         if not import_info._are_name_and_alias_lists_equal(
-            new_pairs, import_info.names_and_aliases):
+                new_pairs, import_info.names_and_aliases):
             import_stmt.import_info = importinfo.NormalImport(new_pairs)
 
     def visitFromImport(self, import_stmt, import_info):
@@ -238,7 +241,7 @@ def visitFromImport(self, import_stmt, import_info):
         if resource == self.resource:
             self._importing_names_from_self(import_info, import_stmt)
             return
-        pymodule = self.pycore.resource_to_pyobject(resource)
+        pymodule = self.project.get_pymodule(resource)
         new_pairs = []
         for name, alias in import_info.names_and_aliases:
             try:
@@ -254,7 +257,7 @@ def visitFromImport(self, import_stmt, import_info):
             except exceptions.AttributeNotFoundError:
                 new_pairs.append((name, alias))
         if not import_info._are_name_and_alias_lists_equal(
-            new_pairs, import_info.names_and_aliases):
+                new_pairs, import_info.names_and_aliases):
             import_stmt.import_info = importinfo.FromImport(
                 import_info.module_name, import_info.level, new_pairs)
 
@@ -268,19 +271,19 @@ def _importing_names_from_self(self, import_info, import_stmt):
 
 class SortingVisitor(ImportInfoVisitor):
 
-    def __init__(self, pycore, current_folder):
-        self.pycore = pycore
+    def __init__(self, project, current_folder):
+        self.project = project
         self.folder = current_folder
         self.standard = set()
         self.third_party = set()
         self.in_project = set()
         self.future = set()
-        self.context = importinfo.ImportContext(pycore, current_folder)
+        self.context = importinfo.ImportContext(project, current_folder)
 
     def visitNormalImport(self, import_stmt, import_info):
         if import_info.names_and_aliases:
             name, alias = import_info.names_and_aliases[0]
-            resource = self.pycore.find_module(
+            resource = self.project.find_module(
                 name, folder=self.folder)
             self._check_imported_resource(import_stmt, resource, name)
 
@@ -291,7 +294,7 @@ def visitFromImport(self, import_stmt, import_info):
 
     def _check_imported_resource(self, import_stmt, resource, imported_name):
         info = import_stmt.import_info
-        if resource is not None and resource.project == self.pycore.project:
+        if resource is not None and resource.project == self.project:
             self.in_project.add(import_stmt)
         elif _is_future(info):
             self.future.add(import_stmt)
@@ -303,16 +306,15 @@ def _check_imported_resource(self, import_stmt, resource, imported_name):
 
 class LongImportVisitor(ImportInfoVisitor):
 
-    def __init__(self, current_folder, pycore, maxdots, maxlength):
+    def __init__(self, current_folder, project, maxdots, maxlength):
         self.maxdots = maxdots
         self.maxlength = maxlength
         self.to_be_renamed = set()
         self.current_folder = current_folder
-        self.pycore = pycore
+        self.project = project
         self.new_imports = []
 
     def visitNormalImport(self, import_stmt, import_info):
-        new_pairs = []
         for name, alias in import_info.names_and_aliases:
             if alias is None and self._is_long(name):
                 self.to_be_renamed.add(name)
@@ -324,15 +326,15 @@ def visitNormalImport(self, import_stmt, import_info):
 
     def _is_long(self, name):
         return name.count('.') > self.maxdots or \
-               ('.' in name and len(name) > self.maxlength)
+            ('.' in name and len(name) > self.maxlength)
 
 
 class RemovePyNameVisitor(ImportInfoVisitor):
 
-    def __init__(self, pycore, pymodule, pyname, folder):
+    def __init__(self, project, pymodule, pyname, folder):
         self.pymodule = pymodule
         self.pyname = pyname
-        self.context = importinfo.ImportContext(pycore, folder)
+        self.context = importinfo.ImportContext(project, folder)
 
     def visitFromImport(self, import_stmt, import_info):
         new_pairs = []
@@ -356,4 +358,4 @@ def dispatch(self, import_):
 
 def _is_future(info):
     return isinstance(info, importinfo.FromImport) and \
-           info.module_name == '__future__'
+        info.module_name == '__future__'
diff --git a/pymode/libs2/rope/refactor/importutils/importinfo.py b/pymode/libs2/rope/refactor/importutils/importinfo.py
index 25c8e813..114080aa 100644
--- a/pymode/libs2/rope/refactor/importutils/importinfo.py
+++ b/pymode/libs2/rope/refactor/importutils/importinfo.py
@@ -84,7 +84,7 @@ def _are_name_and_alias_lists_equal(self, list1, list2):
 
     def __eq__(self, obj):
         return isinstance(obj, self.__class__) and \
-               self.get_import_statement() == obj.get_import_statement()
+            self.get_import_statement() == obj.get_import_statement()
 
     def __ne__(self, obj):
         return not self.__eq__(obj)
@@ -147,10 +147,10 @@ def get_imported_resource(self, context):
         Returns `None` if module was not found.
         """
         if self.level == 0:
-            return context.pycore.find_module(
+            return context.project.find_module(
                 self.module_name, folder=context.folder)
         else:
-            return context.pycore.find_relative_module(
+            return context.project.find_relative_module(
                 self.module_name, context.folder, self.level)
 
     def get_imported_module(self, context):
@@ -160,10 +160,10 @@ def get_imported_module(self, context):
         could not be found.
         """
         if self.level == 0:
-            return context.pycore.get_module(
+            return context.project.get_module(
                 self.module_name, context.folder)
         else:
-            return context.pycore.get_relative_module(
+            return context.project.get_relative_module(
                 self.module_name, context.folder, self.level)
 
     def get_import_statement(self):
@@ -180,7 +180,7 @@ def is_empty(self):
 
     def is_star_import(self):
         return len(self.names_and_aliases) > 0 and \
-               self.names_and_aliases[0][0] == '*'
+            self.names_and_aliases[0][0] == '*'
 
 
 class EmptyImport(ImportInfo):
@@ -196,6 +196,6 @@ def get_imported_primaries(self, context):
 
 class ImportContext(object):
 
-    def __init__(self, pycore, folder):
-        self.pycore = pycore
+    def __init__(self, project, folder):
+        self.project = project
         self.folder = folder
diff --git a/pymode/libs2/rope/refactor/importutils/module_imports.py b/pymode/libs2/rope/refactor/importutils/module_imports.py
index 874213f2..b96eebc4 100644
--- a/pymode/libs2/rope/refactor/importutils/module_imports.py
+++ b/pymode/libs2/rope/refactor/importutils/module_imports.py
@@ -1,13 +1,14 @@
-import rope.base.pynames
-from rope.base import ast, utils
-from rope.refactor.importutils import importinfo
+from rope.base import ast
+from rope.base import pynames
+from rope.base import utils
 from rope.refactor.importutils import actions
+from rope.refactor.importutils import importinfo
 
 
 class ModuleImports(object):
 
-    def __init__(self, pycore, pymodule, import_filter=None):
-        self.pycore = pycore
+    def __init__(self, project, pymodule, import_filter=None):
+        self.project = project
         self.pymodule = pymodule
         self.separating_lines = 0
         self.filter = import_filter
@@ -15,7 +16,7 @@ def __init__(self, pycore, pymodule, import_filter=None):
     @property
     @utils.saveit
     def imports(self):
-        finder = _GlobalImportFinder(self.pymodule, self.pycore)
+        finder = _GlobalImportFinder(self.pymodule)
         result = finder.find_import_statements()
         self.separating_lines = finder.get_separating_line_count()
         if self.filter is not None:
@@ -32,15 +33,16 @@ def _get_unbound_names(self, defined_pyobject):
     def remove_unused_imports(self):
         can_select = _OneTimeSelector(self._get_unbound_names(self.pymodule))
         visitor = actions.RemovingVisitor(
-            self.pycore, self._current_folder(), can_select)
+            self.project, self._current_folder(), can_select)
         for import_statement in self.imports:
             import_statement.accept(visitor)
 
     def get_used_imports(self, defined_pyobject):
         result = []
-        can_select = _OneTimeSelector(self._get_unbound_names(defined_pyobject))
+        can_select = _OneTimeSelector(
+            self._get_unbound_names(defined_pyobject))
         visitor = actions.FilteringVisitor(
-            self.pycore, self._current_folder(), can_select)
+            self.project, self._current_folder(), can_select)
         for import_statement in self.imports:
             new_import = import_statement.accept(visitor)
             if new_import is not None and not new_import.is_empty():
@@ -48,11 +50,18 @@ def get_used_imports(self, defined_pyobject):
         return result
 
     def get_changed_source(self):
-        imports = self.imports
-        after_removing = self._remove_imports(imports)
-        imports = [stmt for stmt in imports
+        # Make sure we forward a removed import's preceding blank
+        # lines count to the following import statement.
+        prev_stmt = None
+        for stmt in self.imports:
+            if prev_stmt is not None and prev_stmt.import_info.is_empty():
+                stmt.blank_lines = max(prev_stmt.blank_lines, stmt.blank_lines)
+            prev_stmt = stmt
+        # The new list of imports.
+        imports = [stmt for stmt in self.imports
                    if not stmt.import_info.is_empty()]
 
+        after_removing = self._remove_imports(self.imports)
         first_non_blank = self._first_non_blank_line(after_removing, 0)
         first_import = self._first_import_line() - 1
         result = []
@@ -61,7 +70,6 @@ def get_changed_source(self):
         # Writing imports
         sorted_imports = sorted(imports, self._compare_import_locations)
         for stmt in sorted_imports:
-            start = self._get_import_location(stmt)
             if stmt != sorted_imports[0]:
                 result.append('\n' * stmt.blank_lines)
             result.append(stmt.get_import_statement() + '\n')
@@ -111,7 +119,7 @@ def _first_non_blank_line(self, lines, lineno):
         return result
 
     def add_import(self, import_info):
-        visitor = actions.AddingVisitor(self.pycore, [import_info])
+        visitor = actions.AddingVisitor(self.project, [import_info])
         for import_statement in self.imports:
             if import_statement.accept(visitor):
                 break
@@ -132,21 +140,21 @@ def _get_new_import_lineno(self):
 
     def filter_names(self, can_select):
         visitor = actions.RemovingVisitor(
-            self.pycore, self._current_folder(), can_select)
+            self.project, self._current_folder(), can_select)
         for import_statement in self.imports:
             import_statement.accept(visitor)
 
     def expand_stars(self):
         can_select = _OneTimeSelector(self._get_unbound_names(self.pymodule))
         visitor = actions.ExpandStarsVisitor(
-            self.pycore, self._current_folder(), can_select)
+            self.project, self._current_folder(), can_select)
         for import_statement in self.imports:
             import_statement.accept(visitor)
 
     def remove_duplicates(self):
         added_imports = []
         for import_stmt in self.imports:
-            visitor = actions.AddingVisitor(self.pycore,
+            visitor = actions.AddingVisitor(self.project,
                                             [import_stmt.import_info])
             for added_import in added_imports:
                 if added_import.accept(visitor):
@@ -154,17 +162,34 @@ def remove_duplicates(self):
             else:
                 added_imports.append(import_stmt)
 
+    def force_single_imports(self):
+        """force a single import per statement"""
+        for import_stmt in self.imports[:]:
+            import_info = import_stmt.import_info
+            if import_info.is_empty():
+                continue
+            if len(import_info.names_and_aliases) > 1:
+                for name_and_alias in import_info.names_and_aliases:
+                    if hasattr(import_info, "module_name"):
+                        new_import = importinfo.FromImport(
+                            import_info.module_name, import_info.level,
+                            [name_and_alias])
+                    else:
+                        new_import = importinfo.NormalImport([name_and_alias])
+                    self.add_import(new_import)
+                import_stmt.empty_import()
+
     def get_relative_to_absolute_list(self):
-        visitor = rope.refactor.importutils.actions.RelativeToAbsoluteVisitor(
-            self.pycore, self._current_folder())
+        visitor = actions.RelativeToAbsoluteVisitor(
+            self.project, self._current_folder())
         for import_stmt in self.imports:
             if not import_stmt.readonly:
                 import_stmt.accept(visitor)
         return visitor.to_be_absolute
 
     def get_self_import_fix_and_rename_list(self):
-        visitor = rope.refactor.importutils.actions.SelfImportVisitor(
-            self.pycore, self._current_folder(), self.pymodule.get_resource())
+        visitor = actions.SelfImportVisitor(
+            self.project, self._current_folder(), self.pymodule.get_resource())
         for import_stmt in self.imports:
             if not import_stmt.readonly:
                 import_stmt.accept(visitor)
@@ -174,15 +199,19 @@ def _current_folder(self):
         return self.pymodule.get_resource().parent
 
     def sort_imports(self):
+        if self.project.prefs.get("sort_imports_alphabetically"):
+            sort_kwargs = dict(key=self._get_import_name)
+        else:
+            sort_kwargs = dict(cmp=self._compare_imports)
+
         # IDEA: Sort from import list
-        visitor = actions.SortingVisitor(self.pycore, self._current_folder())
+        visitor = actions.SortingVisitor(self.project, self._current_folder())
         for import_statement in self.imports:
             import_statement.accept(visitor)
-        in_projects = sorted(visitor.in_project, self._compare_imports)
-        third_party = sorted(visitor.third_party, self._compare_imports)
-        standards = sorted(visitor.standard, self._compare_imports)
-        future = sorted(visitor.future, self._compare_imports)
-        blank_lines = 0
+        in_projects = sorted(visitor.in_project, **sort_kwargs)
+        third_party = sorted(visitor.third_party, **sort_kwargs)
+        standards = sorted(visitor.standard, **sort_kwargs)
+        future = sorted(visitor.future, **sort_kwargs)
         last_index = self._first_import_line()
         last_index = self._move_imports(future, last_index, 0)
         last_index = self._move_imports(standards, last_index, 1)
@@ -208,6 +237,14 @@ def _first_import_line(self):
                 break
         return lineno
 
+    def _get_import_name(self, import_stmt):
+        import_info = import_stmt.import_info
+        if hasattr(import_info, "module_name"):
+            return "%s.%s" % (import_info.module_name,
+                              import_info.names_and_aliases[0][0])
+        else:
+            return import_info.names_and_aliases[0][0]
+
     def _compare_imports(self, stmt1, stmt2):
         str1 = stmt1.get_import_statement()
         str2 = stmt2.get_import_statement()
@@ -229,7 +266,7 @@ def _move_imports(self, imports, index, blank_lines):
 
     def handle_long_imports(self, maxdots, maxlength):
         visitor = actions.LongImportVisitor(
-            self._current_folder(), self.pycore, maxdots, maxlength)
+            self._current_folder(), self.project, maxdots, maxlength)
         for import_statement in self.imports:
             if not import_statement.readonly:
                 import_statement.accept(visitor)
@@ -239,7 +276,7 @@ def handle_long_imports(self, maxdots, maxlength):
 
     def remove_pyname(self, pyname):
         """Removes pyname when imported in ``from mod import x``"""
-        visitor = actions.RemovePyNameVisitor(self.pycore, self.pymodule,
+        visitor = actions.RemovePyNameVisitor(self.project, self.pymodule,
                                               pyname, self._current_folder())
         for import_stmt in self.imports:
             import_stmt.accept(visitor)
@@ -277,7 +314,7 @@ def __init__(self, pyobject):
 
     def _visit_child_scope(self, node):
         pyobject = self.pyobject.get_module().get_scope().\
-                   get_inner_scope_for_line(node.lineno).pyobject
+            get_inner_scope_for_line(node.lineno).pyobject
         visitor = _LocalUnboundNameFinder(pyobject, self)
         for child in ast.get_child_nodes(node):
             ast.walk(child, visitor)
@@ -324,8 +361,8 @@ def __init__(self, pymodule, wanted_pyobject):
         self.unbound = set()
         self.names = set()
         for name, pyname in pymodule._get_structural_attributes().items():
-            if not isinstance(pyname, (rope.base.pynames.ImportedName,
-                                       rope.base.pynames.ImportedModule)):
+            if not isinstance(pyname, (pynames.ImportedName,
+                                       pynames.ImportedModule)):
                 self.names.add(name)
         wanted_scope = wanted_pyobject.get_scope()
         self.start = wanted_scope.get_start()
@@ -374,12 +411,11 @@ def add_unbound(self, name):
 
 class _GlobalImportFinder(object):
 
-    def __init__(self, pymodule, pycore):
+    def __init__(self, pymodule):
         self.current_folder = None
         if pymodule.get_resource():
             self.current_folder = pymodule.get_resource().parent
             self.pymodule = pymodule
-        self.pycore = pycore
         self.imports = []
         self.pymodule = pymodule
         self.lines = self.pymodule.lines
@@ -428,13 +464,14 @@ def visit_from(self, node, end_line):
         if node.level:
             level = node.level
         import_info = importinfo.FromImport(
-            node.module or '', # see comment at rope.base.ast.walk
+            node.module or '',  # see comment at rope.base.ast.walk
             level, self._get_names(node.names))
         start_line = node.lineno
         self.imports.append(importinfo.ImportStatement(
                             import_info, node.lineno, end_line,
                             self._get_text(start_line, end_line),
-                            blank_lines=self._count_empty_lines_before(start_line)))
+                            blank_lines=
+                            self._count_empty_lines_before(start_line)))
 
     def _get_names(self, alias_names):
         result = []
diff --git a/pymode/libs2/rope/refactor/inline.py b/pymode/libs2/rope/refactor/inline.py
index cfd64a7e..0ae1f8f4 100644
--- a/pymode/libs2/rope/refactor/inline.py
+++ b/pymode/libs2/rope/refactor/inline.py
@@ -21,17 +21,19 @@
 import rope.base.exceptions
 import rope.refactor.functionutils
 from rope.base import (pynames, pyobjects, codeanalyze,
-                       taskhandle, evaluate, worder, utils)
+                       taskhandle, evaluate, worder, utils, libutils)
 from rope.base.change import ChangeSet, ChangeContents
 from rope.refactor import (occurrences, rename, sourceutils,
                            importutils, move, change_signature)
 
+
 def unique_prefix():
     n = 0
     while True:
         yield "__" + str(n) + "__"
         n += 1
 
+
 def create_inline(project, resource, offset):
     """Create a refactoring object for inlining
 
@@ -39,8 +41,7 @@ def create_inline(project, resource, offset):
     `InlineMethod`, `InlineVariable` or `InlineParameter`.
 
     """
-    pycore = project.pycore
-    pyname = _get_pyname(pycore, resource, offset)
+    pyname = _get_pyname(project, resource, offset)
     message = 'Inline refactoring should be performed on ' \
               'a method, local variable or parameter.'
     if pyname is None:
@@ -61,9 +62,8 @@ class _Inliner(object):
 
     def __init__(self, project, resource, offset):
         self.project = project
-        self.pycore = project.pycore
-        self.pyname = _get_pyname(self.pycore, resource, offset)
-        range_finder = worder.Worder(resource.read())
+        self.pyname = _get_pyname(project, resource, offset)
+        range_finder = worder.Worder(resource.read(), True)
         self.region = range_finder.get_primary_range(offset)
         self.name = range_finder.get_word_at(offset)
         self.offset = offset
@@ -84,7 +84,7 @@ def __init__(self, *args, **kwds):
         self.pymodule = self.pyfunction.get_module()
         self.resource = self.pyfunction.get_module().get_resource()
         self.occurrence_finder = occurrences.create_finder(
-            self.pycore, self.name, self.pyname)
+            self.project, self.name, self.pyname)
         self.normal_generator = _DefinitionGenerator(self.project,
                                                      self.pyfunction)
         self._init_imports()
@@ -92,7 +92,7 @@ def __init__(self, *args, **kwds):
     def _init_imports(self):
         body = sourceutils.get_body(self.pyfunction)
         body, imports = move.moving_code_with_imports(
-            self.pycore, self.resource, body)
+            self.project, self.resource, body)
         self.imports = imports
         self.others_generator = _DefinitionGenerator(
             self.project, self.pyfunction, body=body)
@@ -100,7 +100,6 @@ def _init_imports(self):
     def _get_scope_range(self):
         scope = self.pyfunction.get_scope()
         lines = self.pymodule.lines
-        logicals = self.pymodule.logical_lines
         start_line = scope.get_start()
         if self.pyfunction.decorators:
             decorators = self.pyfunction.decorators
@@ -121,7 +120,7 @@ def get_changes(self, remove=True, only_current=False, resources=None,
         """
         changes = ChangeSet('Inline method <%s>' % self.name)
         if resources is None:
-            resources = self.pycore.get_python_files()
+            resources = self.project.get_python_files()
         if only_current:
             resources = [self.original]
             if remove:
@@ -132,20 +131,20 @@ def get_changes(self, remove=True, only_current=False, resources=None,
             job_set.started_job(file.path)
             if file == self.resource:
                 changes.add_change(self._defining_file_changes(
-                        changes, remove=remove, only_current=only_current))
+                    changes, remove=remove, only_current=only_current))
             else:
                 aim = None
                 if only_current and self.original == file:
                     aim = self.offset
                 handle = _InlineFunctionCallsForModuleHandle(
-                    self.pycore, file, self.others_generator, aim)
+                    self.project, file, self.others_generator, aim)
                 result = move.ModuleSkipRenamer(
                     self.occurrence_finder, file, handle).get_changed_module()
                 if result is not None:
-                    result = _add_imports(self.pycore, result,
+                    result = _add_imports(self.project, result,
                                           file, self.imports)
                     if remove:
-                        result = _remove_from(self.pycore, self.pyname,
+                        result = _remove_from(self.project, self.pyname,
                                               result, file)
                     changes.add_change(ChangeContents(file, result))
             job_set.finished_job()
@@ -154,8 +153,6 @@ def get_changes(self, remove=True, only_current=False, resources=None,
     def _get_removed_range(self):
         scope = self.pyfunction.get_scope()
         lines = self.pymodule.lines
-        logical = self.pymodule.logical_lines
-        start_line = scope.get_start()
         start, end = self._get_scope_range()
         end_line = scope.get_end()
         for i in range(end_line + 1, lines.length()):
@@ -177,7 +174,7 @@ def _defining_file_changes(self, changes, remove, only_current):
                 # we don't want to change any of them
                 aim = len(self.resource.read()) + 100
         handle = _InlineFunctionCallsForModuleHandle(
-            self.pycore, self.resource,
+            self.project, self.resource,
             self.normal_generator, aim_offset=aim)
         replacement = None
         if remove:
@@ -200,7 +197,6 @@ def _is_the_last_method_of_a_class(self):
             return False
         class_start, class_end = sourceutils.get_body_region(pyclass)
         source = self.pymodule.source_code
-        lines = self.pymodule.lines
         func_start, func_end = self._get_scope_range()
         if source[class_start:func_start].strip() == '' and \
            source[func_end:class_end].strip() == '':
@@ -226,12 +222,12 @@ def _check_exceptional_conditions(self):
                 'Local variable should be assigned once for inlining.')
 
     def get_changes(self, remove=True, only_current=False, resources=None,
-                    task_handle=taskhandle.NullTaskHandle()):
+                    docs=False, task_handle=taskhandle.NullTaskHandle()):
         if resources is None:
             if rename._is_local(self.pyname):
                 resources = [self.resource]
             else:
-                resources = self.pycore.get_python_files()
+                resources = self.project.get_python_files()
         if only_current:
             resources = [self.original]
             if remove and self.original != self.resource:
@@ -243,28 +239,29 @@ def get_changes(self, remove=True, only_current=False, resources=None,
         for resource in resources:
             jobset.started_job(resource.path)
             if resource == self.resource:
-                source = self._change_main_module(remove, only_current)
+                source = self._change_main_module(remove, only_current, docs)
                 changes.add_change(ChangeContents(self.resource, source))
             else:
                 result = self._change_module(resource, remove, only_current)
                 if result is not None:
-                    result = _add_imports(self.pycore, result,
+                    result = _add_imports(self.project, result,
                                           resource, self.imports)
                     changes.add_change(ChangeContents(resource, result))
             jobset.finished_job()
         return changes
 
-    def _change_main_module(self, remove, only_current):
+    def _change_main_module(self, remove, only_current, docs):
         region = None
         if only_current and self.original == self.resource:
             region = self.region
-        return _inline_variable(self.pycore, self.pymodule, self.pyname,
-                                self.name, remove=remove, region=region)
+        return _inline_variable(self.project, self.pymodule, self.pyname,
+                                self.name, remove=remove, region=region,
+                                docs=docs)
 
     def _init_imports(self):
         vardef = _getvardef(self.pymodule, self.pyname)
         self.imported, self.imports = move.moving_code_with_imports(
-            self.pycore, self.resource, vardef)
+            self.project, self.resource, vardef)
 
     def _change_module(self, resource, remove, only_current):
         filters = [occurrences.NoImportsFilter(),
@@ -275,11 +272,12 @@ def check_aim(occurrence):
                 if self.offset < start or end < self.offset:
                     return False
             filters.insert(0, check_aim)
-        finder = occurrences.Finder(self.pycore, self.name, filters=filters)
+        finder = occurrences.Finder(self.project, self.name, filters=filters)
         changed = rename.rename_in_module(
             finder, self.imported, resource=resource, replace_primary=True)
         if changed and remove:
-            changed = _remove_from(self.pycore, self.pyname, changed, resource)
+            changed = _remove_from(self.project, self.pyname,
+                                   changed, resource)
         return changed
 
     def get_kind(self):
@@ -329,8 +327,9 @@ def _join_lines(lines):
 
 class _DefinitionGenerator(object):
     unique_prefix = unique_prefix()
+
     def __init__(self, project, pyfunction, body=None):
-        self.pycore = project.pycore
+        self.project = project
         self.pyfunction = pyfunction
         self.pymodule = pyfunction.get_module()
         self.resource = self.pymodule.get_resource()
@@ -360,10 +359,11 @@ def _get_definition_params(self):
     def get_function_name(self):
         return self.pyfunction.get_name()
 
-    def get_definition(self, primary, pyname, call, host_vars=[],returns=False):
+    def get_definition(self, primary, pyname, call, host_vars=[],
+                       returns=False):
         # caching already calculated definitions
         return self._calculate_definition(primary, pyname, call,
-                           host_vars, returns)
+                                          host_vars, returns)
 
     def _calculate_header(self, primary, pyname, call):
         # A header is created which initializes parameters
@@ -377,10 +377,6 @@ def _calculate_header(self, primary, pyname, call):
             paramdict[param_name] = value
         header = ''
         to_be_inlined = []
-        mod = self.pycore.get_string_module(self.body)
-        all_names = mod.get_scope().get_names()
-        assigned_names = [name for name in all_names if
-            isinstance(all_names[name], rope.base.pynamesdef.AssignedName)]
         for name, value in paramdict.items():
             if name != value and value is not None:
                 header += name + ' = ' + value.replace('\n', ' ') + '\n'
@@ -392,32 +388,36 @@ def _calculate_definition(self, primary, pyname, call, host_vars, returns):
         header, to_be_inlined = self._calculate_header(primary, pyname, call)
 
         source = header + self.body
-        mod = self.pycore.get_string_module(source)
+        mod = libutils.get_string_module(self.project, source)
         name_dict = mod.get_scope().get_names()
-        all_names =   [x for x in  name_dict if
-            not isinstance(name_dict[x], rope.base.builtins.BuiltinName)]
+        all_names = [x for x in name_dict if
+                     not isinstance(name_dict[x],
+                                    rope.base.builtins.BuiltinName)]
 
         # If there is a name conflict, all variable names
         # inside the inlined function are renamed
         if len(set(all_names).intersection(set(host_vars))) > 0:
 
             prefix = _DefinitionGenerator.unique_prefix.next()
-            guest = self.pycore.get_string_module(source, self.resource)
+            guest = libutils.get_string_module(self.project, source,
+                                               self.resource)
 
-            to_be_inlined = [prefix+item for item in to_be_inlined]
+            to_be_inlined = [prefix + item for item in to_be_inlined]
             for item in all_names:
                 pyname = guest[item]
-                occurrence_finder = occurrences.create_finder(
-                                        self.pycore, item, pyname)
+                occurrence_finder = occurrences.create_finder(self.project,
+                                                              item, pyname)
                 source = rename.rename_in_module(occurrence_finder,
-                                         prefix+item, pymodule=guest)
-                guest = self.pycore.get_string_module(source, self.resource)
+                                                 prefix + item, pymodule=guest)
+                guest = libutils.get_string_module(
+                    self.project, source, self.resource)
 
         #parameters not reassigned inside the functions are now inlined.
         for name in to_be_inlined:
-            pymodule = self.pycore.get_string_module(source, self.resource)
+            pymodule = libutils.get_string_module(
+                self.project, source, self.resource)
             pyname = pymodule[name]
-            source = _inline_variable(self.pycore, pymodule, pyname, name)
+            source = _inline_variable(self.project, pymodule, pyname, name)
 
         return self._replace_returns_with(source, returns)
 
@@ -425,19 +425,22 @@ def _replace_returns_with(self, source, returns):
         result = []
         returned = None
         last_changed = 0
-        for match in _DefinitionGenerator._get_return_pattern().finditer(source):
+        for match in _DefinitionGenerator._get_return_pattern().finditer(
+                source):
             for key, value in match.groupdict().items():
                 if value and key == 'return':
                     result.append(source[last_changed:match.start('return')])
                     if returns:
                         self._check_nothing_after_return(source,
                                                          match.end('return'))
+                        beg_idx = match.end('return')
                         returned = _join_lines(
-                            source[match.end('return'): len(source)].splitlines())
+                            source[beg_idx:len(source)].splitlines())
                         last_changed = len(source)
                     else:
                         current = match.end('return')
-                        while current < len(source) and source[current] in ' \t':
+                        while current < len(source) and \
+                                source[current] in ' \t':
                             current += 1
                         last_changed = current
                         if current == len(source) or source[current] == '\n':
@@ -452,7 +455,8 @@ def _check_nothing_after_return(self, source, offset):
         lineno = logical_lines.logical_line_in(lineno)[1]
         if source[lines.get_line_end(lineno):len(source)].strip() != '':
             raise rope.base.exceptions.RefactoringError(
-                'Cannot inline functions with statements after return statement.')
+                'Cannot inline functions with statements ' +
+                'after return statement.')
 
     @classmethod
     def _get_return_pattern(cls):
@@ -471,7 +475,7 @@ def named_pattern(name, list_):
 
 class _InlineFunctionCallsForModuleHandle(object):
 
-    def __init__(self, pycore, resource,
+    def __init__(self, project, resource,
                  definition_generator, aim_offset=None):
         """Inlines occurrences
 
@@ -479,7 +483,7 @@ def __init__(self, pycore, resource,
         `aim` offset will be inlined.
 
         """
-        self.pycore = pycore
+        self.project = project
         self.generator = definition_generator
         self.resource = resource
         self.aim = aim_offset
@@ -504,24 +508,24 @@ def occurred_outside_skip(self, change_collector, occurrence):
         end_parens = self._find_end_parens(self.source, end - 1)
         lineno = self.lines.get_line_number(start)
         start_line, end_line = self.pymodule.logical_lines.\
-                               logical_line_in(lineno)
+            logical_line_in(lineno)
         line_start = self.lines.get_line_start(start_line)
         line_end = self.lines.get_line_end(end_line)
 
-
         returns = self.source[line_start:start].strip() != '' or \
-                  self.source[end_parens:line_end].strip() != ''
+            self.source[end_parens:line_end].strip() != ''
         indents = sourceutils.get_indents(self.lines, start_line)
         primary, pyname = occurrence.get_primary_and_pyname()
 
-        host = self.pycore.resource_to_pyobject(self.resource)
+        host = self.pymodule
         scope = host.scope.get_inner_scope_for_line(lineno)
         definition, returned = self.generator.get_definition(
-            primary, pyname, self.source[start:end_parens], scope.get_names(), returns=returns)
+            primary, pyname, self.source[start:end_parens], scope.get_names(),
+            returns=returns)
 
         end = min(line_end + 1, len(self.source))
-        change_collector.add_change(line_start, end,
-               sourceutils.fix_indentation(definition, indents))
+        change_collector.add_change(
+            line_start, end, sourceutils.fix_indentation(definition, indents))
         if returns:
             name = returned
             if name is None:
@@ -537,7 +541,7 @@ def _find_end_parens(self, source, offset):
     @property
     @utils.saveit
     def pymodule(self):
-        return self.pycore.resource_to_pyobject(self.resource)
+        return self.project.get_pymodule(self.resource)
 
     @property
     @utils.saveit
@@ -553,12 +557,13 @@ def lines(self):
         return self.pymodule.lines
 
 
-def _inline_variable(pycore, pymodule, pyname, name,
-                     remove=True, region=None):
+def _inline_variable(project, pymodule, pyname, name,
+                     remove=True, region=None, docs=False):
     definition = _getvardef(pymodule, pyname)
     start, end = _assigned_lineno(pymodule, pyname)
 
-    occurrence_finder = occurrences.create_finder(pycore, name, pyname)
+    occurrence_finder = occurrences.create_finder(project, name, pyname,
+                                                  docs=docs)
     changed_source = rename.rename_in_module(
         occurrence_finder, definition, pymodule=pymodule,
         replace_primary=True, writes=False, region=region)
@@ -567,11 +572,12 @@ def _inline_variable(pycore, pymodule, pyname, name,
     if remove:
         lines = codeanalyze.SourceLinesAdapter(changed_source)
         source = changed_source[:lines.get_line_start(start)] + \
-                 changed_source[lines.get_line_end(end) + 1:]
+            changed_source[lines.get_line_end(end) + 1:]
     else:
         source = changed_source
     return source
 
+
 def _getvardef(pymodule, pyname):
     assignment = pyname.assignments[0]
     lines = pymodule.lines
@@ -581,35 +587,39 @@ def _getvardef(pymodule, pyname):
     if assignment.levels:
         raise rope.base.exceptions.RefactoringError(
             'Cannot inline tuple assignments.')
-    definition = definition_with_assignment[definition_with_assignment.\
+    definition = definition_with_assignment[definition_with_assignment.
                                             index('=') + 1:].strip()
     return definition
 
+
 def _assigned_lineno(pymodule, pyname):
     definition_line = pyname.assignments[0].ast_node.lineno
     return pymodule.logical_lines.logical_line_in(definition_line)
 
-def _add_imports(pycore, source, resource, imports):
+
+def _add_imports(project, source, resource, imports):
     if not imports:
         return source
-    pymodule = pycore.get_string_module(source, resource)
-    module_import = importutils.get_module_imports(pycore, pymodule)
+    pymodule = libutils.get_string_module(project, source, resource)
+    module_import = importutils.get_module_imports(project, pymodule)
     for import_info in imports:
         module_import.add_import(import_info)
     source = module_import.get_changed_source()
-    pymodule = pycore.get_string_module(source, resource)
-    import_tools = importutils.ImportTools(pycore)
+    pymodule = libutils.get_string_module(project, source, resource)
+    import_tools = importutils.ImportTools(project)
     return import_tools.organize_imports(pymodule, unused=False, sort=False)
 
-def _get_pyname(pycore, resource, offset):
-    pymodule = pycore.resource_to_pyobject(resource)
+
+def _get_pyname(project, resource, offset):
+    pymodule = project.get_pymodule(resource)
     pyname = evaluate.eval_location(pymodule, offset)
     if isinstance(pyname, pynames.ImportedName):
         pyname = pyname._get_imported_pyname()
     return pyname
 
-def _remove_from(pycore, pyname, source, resource):
-    pymodule = pycore.get_string_module(source, resource)
-    module_import = importutils.get_module_imports(pycore, pymodule)
+
+def _remove_from(project, pyname, source, resource):
+    pymodule = libutils.get_string_module(project, source, resource)
+    module_import = importutils.get_module_imports(project, pymodule)
     module_import.remove_pyname(pyname)
     return module_import.get_changed_source()
diff --git a/pymode/libs2/rope/refactor/introduce_factory.py b/pymode/libs2/rope/refactor/introduce_factory.py
index 5a885587..7532e361 100644
--- a/pymode/libs2/rope/refactor/introduce_factory.py
+++ b/pymode/libs2/rope/refactor/introduce_factory.py
@@ -1,5 +1,6 @@
 import rope.base.exceptions
 import rope.base.pyobjects
+from rope.base import libutils
 from rope.base import taskhandle, evaluate
 from rope.base.change import (ChangeSet, ChangeContents)
 from rope.refactor import rename, occurrences, sourceutils, importutils
@@ -8,13 +9,14 @@
 class IntroduceFactory(object):
 
     def __init__(self, project, resource, offset):
-        self.pycore = project.pycore
+        self.project = project
         self.offset = offset
 
-        this_pymodule = self.pycore.resource_to_pyobject(resource)
+        this_pymodule = self.project.get_pymodule(resource)
         self.old_pyname = evaluate.eval_location(this_pymodule, offset)
-        if self.old_pyname is None or not isinstance(self.old_pyname.get_object(),
-                                                     rope.base.pyobjects.PyClass):
+        if self.old_pyname is None or \
+                not isinstance(self.old_pyname.get_object(),
+                               rope.base.pyobjects.PyClass):
             raise rope.base.exceptions.RefactoringError(
                 'Introduce factory should be performed on a class.')
         self.old_name = self.old_pyname.get_object().get_name()
@@ -35,7 +37,7 @@ def get_changes(self, factory_name, global_factory=False, resources=None,
 
         """
         if resources is None:
-            resources = self.pycore.get_python_files()
+            resources = self.project.get_python_files()
         changes = ChangeSet('Introduce factory method <%s>' % factory_name)
         job_set = task_handle.create_jobset('Collecting Changes',
                                             len(resources))
@@ -64,11 +66,11 @@ def _change_module(self, resources, changes,
                                                     global_)
             if changed_code is not None:
                 if global_:
-                    new_pymodule = self.pycore.get_string_module(changed_code,
-                                                                 self.resource)
-                    modname = self.pycore.modname(self.resource)
+                    new_pymodule = libutils.get_string_module(
+                        self.project, changed_code, self.resource)
+                    modname = libutils.modname(self.resource)
                     changed_code, imported = importutils.add_import(
-                        self.pycore, new_pymodule, modname, factory_name)
+                        self.project, new_pymodule, modname, factory_name)
                     changed_code = changed_code.replace(replacement, imported)
                 changes.add_change(ChangeContents(file_, changed_code))
             job_set.finished_job()
@@ -81,8 +83,8 @@ def _change_resource(self, changes, factory_name, global_):
         if source_code is None:
             source_code = self.pymodule.source_code
         else:
-            self.pymodule = self.pycore.get_string_module(
-                source_code, resource=self.resource)
+            self.pymodule = libutils.get_string_module(
+                self.project, source_code, resource=self.resource)
         lines = self.pymodule.lines
         start = self._get_insertion_offset(class_scope, lines)
         result = source_code[:start]
@@ -100,7 +102,7 @@ def _get_insertion_offset(self, class_scope, lines):
 
     def _get_factory_method(self, lines, class_scope,
                             factory_name, global_):
-        unit_indents = ' ' * sourceutils.get_indent(self.pycore)
+        unit_indents = ' ' * sourceutils.get_indent(self.project)
         if global_:
             if self._get_scope_indents(lines, class_scope) > 0:
                 raise rope.base.exceptions.RefactoringError(
@@ -111,7 +113,7 @@ def _get_factory_method(self, lines, class_scope,
             ('@staticmethod\ndef %s(*args, **kwds):\n' % factory_name +
              '%sreturn %s(*args, **kwds)\n' % (unit_indents, self.old_name))
         indents = self._get_scope_indents(lines, class_scope) + \
-                  sourceutils.get_indent(self.pycore)
+            sourceutils.get_indent(self.project)
         return '\n' + sourceutils.indent_lines(unindented_factory, indents)
 
     def _get_scope_indents(self, lines, scope):
@@ -124,7 +126,7 @@ def _new_function_name(self, factory_name, global_):
             return self.old_name + '.' + factory_name
 
     def _rename_occurrences(self, file_, changed_name, global_factory):
-        finder = occurrences.create_finder(self.pycore, self.old_name,
+        finder = occurrences.create_finder(self.project, self.old_name,
                                            self.old_pyname, only_calls=True)
         result = rename.rename_in_module(finder, changed_name, resource=file_,
                                          replace_primary=global_factory)
diff --git a/pymode/libs2/rope/refactor/introduce_parameter.py b/pymode/libs2/rope/refactor/introduce_parameter.py
index 312c61aa..43d6f755 100644
--- a/pymode/libs2/rope/refactor/introduce_parameter.py
+++ b/pymode/libs2/rope/refactor/introduce_parameter.py
@@ -35,10 +35,10 @@ def f(p=a.var):
     """
 
     def __init__(self, project, resource, offset):
-        self.pycore = project.pycore
+        self.project = project
         self.resource = resource
         self.offset = offset
-        self.pymodule = self.pycore.resource_to_pyobject(self.resource)
+        self.pymodule = self.project.get_pymodule(self.resource)
         scope = self.pymodule.get_scope().get_inner_scope_for_offset(offset)
         if scope.get_kind() != 'Function':
             raise exceptions.RefactoringError(
@@ -79,7 +79,7 @@ def _get_header_offsets(self):
         lines = self.pymodule.lines
         start_line = self.pyfunction.get_scope().get_start()
         end_line = self.pymodule.logical_lines.\
-                   logical_line_in(start_line)[1]
+            logical_line_in(start_line)[1]
         start = lines.get_line_start(start_line)
         end = lines.get_line_end(end_line)
         start = self.pymodule.source_code.find('def', start) + 4
@@ -88,7 +88,8 @@ def _get_header_offsets(self):
 
     def _change_function_occurances(self, collector, function_start,
                                     function_end, new_name):
-        finder = occurrences.create_finder(self.pycore, self.name, self.pyname)
+        finder = occurrences.create_finder(self.project, self.name,
+                                           self.pyname)
         for occurrence in finder.find_occurrences(resource=self.resource):
             start, end = occurrence.get_primary_range()
             if function_start <= start < function_end:
diff --git a/pymode/libs2/rope/refactor/localtofield.py b/pymode/libs2/rope/refactor/localtofield.py
index 532d4c9e..f276070f 100644
--- a/pymode/libs2/rope/refactor/localtofield.py
+++ b/pymode/libs2/rope/refactor/localtofield.py
@@ -6,13 +6,12 @@ class LocalToField(object):
 
     def __init__(self, project, resource, offset):
         self.project = project
-        self.pycore = project.pycore
         self.resource = resource
         self.offset = offset
 
     def get_changes(self):
         name = worder.get_name_at(self.resource, self.offset)
-        this_pymodule = self.pycore.resource_to_pyobject(self.resource)
+        this_pymodule = self.project.get_pymodule(self.resource)
         pyname = evaluate.eval_location(this_pymodule, self.offset)
         if not self._is_a_method_local(pyname):
             raise exceptions.RefactoringError(
@@ -26,7 +25,7 @@ def get_changes(self):
 
         new_name = self._get_field_name(function_scope.pyobject, name)
         changes = Rename(self.project, self.resource, self.offset).\
-                  get_changes(new_name, resources=[self.resource])
+            get_changes(new_name, resources=[self.resource])
         return changes
 
     def _check_redefinition(self, name, function_scope):
@@ -45,6 +44,6 @@ def _is_a_method_local(self, pyname):
         holding_scope = pymodule.get_scope().get_inner_scope_for_line(lineno)
         parent = holding_scope.parent
         return isinstance(pyname, pynames.AssignedName) and \
-               pyname in holding_scope.get_names().values() and \
-               holding_scope.get_kind() == 'Function' and \
-               parent is not None and parent.get_kind() == 'Class'
+            pyname in holding_scope.get_names().values() and \
+            holding_scope.get_kind() == 'Function' and \
+            parent is not None and parent.get_kind() == 'Class'
diff --git a/pymode/libs2/rope/refactor/method_object.py b/pymode/libs2/rope/refactor/method_object.py
index b3dd6bdd..29ce429d 100644
--- a/pymode/libs2/rope/refactor/method_object.py
+++ b/pymode/libs2/rope/refactor/method_object.py
@@ -1,5 +1,6 @@
 import warnings
 
+from rope.base import libutils
 from rope.base import pyobjects, exceptions, change, evaluate, codeanalyze
 from rope.refactor import sourceutils, occurrences, rename
 
@@ -7,8 +8,8 @@
 class MethodObject(object):
 
     def __init__(self, project, resource, offset):
-        self.pycore = project.pycore
-        this_pymodule = self.pycore.resource_to_pyobject(resource)
+        self.project = project
+        this_pymodule = self.project.get_pymodule(resource)
         pyname = evaluate.eval_location(this_pymodule, offset)
         if pyname is None or not isinstance(pyname.get_object(),
                                             pyobjects.PyFunction):
@@ -21,10 +22,10 @@ def __init__(self, project, resource, offset):
 
     def get_new_class(self, name):
         body = sourceutils.fix_indentation(
-            self._get_body(), sourceutils.get_indent(self.pycore) * 2)
+            self._get_body(), sourceutils.get_indent(self.project) * 2)
         return 'class %s(object):\n\n%s%sdef __call__(self):\n%s' % \
                (name, self._get_init(),
-                ' ' * sourceutils.get_indent(self.pycore), body)
+                ' ' * sourceutils.get_indent(self.project), body)
 
     def get_changes(self, classname=None, new_class_name=None):
         if new_class_name is not None:
@@ -36,14 +37,15 @@ def get_changes(self, classname=None, new_class_name=None):
         start, end = sourceutils.get_body_region(self.pyfunction)
         indents = sourceutils.get_indents(
             self.pymodule.lines, self.pyfunction.get_scope().get_start()) + \
-            sourceutils.get_indent(self.pycore)
+            sourceutils.get_indent(self.project)
         new_contents = ' ' * indents + 'return %s(%s)()\n' % \
                        (classname, ', '.join(self._get_parameter_names()))
         collector.add_change(start, end, new_contents)
         insertion = self._get_class_insertion_point()
         collector.add_change(insertion, insertion,
                              '\n\n' + self.get_new_class(classname))
-        changes = change.ChangeSet('Replace method with method object refactoring')
+        changes = change.ChangeSet(
+            'Replace method with method object refactoring')
         changes.add_change(change.ChangeContents(self.resource,
                                                  collector.get_changed()))
         return changes
@@ -59,9 +61,10 @@ def _get_body(self):
         body = sourceutils.get_body(self.pyfunction)
         for param in self._get_parameter_names():
             body = param + ' = None\n' + body
-            pymod = self.pycore.get_string_module(body, self.resource)
+            pymod = libutils.get_string_module(
+                self.project, body, self.resource)
             pyname = pymod[param]
-            finder = occurrences.create_finder(self.pycore, param, pyname)
+            finder = occurrences.create_finder(self.project, param, pyname)
             result = rename.rename_in_module(finder, 'self.' + param,
                                              pymodule=pymod)
             body = result[result.index('\n') + 1:]
@@ -69,7 +72,7 @@ def _get_body(self):
 
     def _get_init(self):
         params = self._get_parameter_names()
-        indents = ' ' * sourceutils.get_indent(self.pycore)
+        indents = ' ' * sourceutils.get_indent(self.project)
         if not params:
             return ''
         header = indents + 'def __init__(self'
diff --git a/pymode/libs2/rope/refactor/move.py b/pymode/libs2/rope/refactor/move.py
index c8761011..60df493e 100644
--- a/pymode/libs2/rope/refactor/move.py
+++ b/pymode/libs2/rope/refactor/move.py
@@ -4,9 +4,11 @@
 based on inputs.
 
 """
-from rope.base import pyobjects, codeanalyze, exceptions, pynames, taskhandle, evaluate, worder
+from rope.base import (pyobjects, codeanalyze, exceptions, pynames,
+                       taskhandle, evaluate, worder, libutils)
 from rope.base.change import ChangeSet, ChangeContents, MoveResource
-from rope.refactor import importutils, rename, occurrences, sourceutils, functionutils
+from rope.refactor import importutils, rename, occurrences, sourceutils, \
+    functionutils
 
 
 def create_move(project, resource, offset=None):
@@ -18,7 +20,7 @@ def create_move(project, resource, offset=None):
     """
     if offset is None:
         return MoveModule(project, resource)
-    this_pymodule = project.pycore.resource_to_pyobject(resource)
+    this_pymodule = project.get_pymodule(resource)
     pyname = evaluate.eval_location(this_pymodule, offset)
     if pyname is None:
         raise exceptions.RefactoringError(
@@ -48,8 +50,7 @@ class MoveMethod(object):
 
     def __init__(self, project, resource, offset):
         self.project = project
-        self.pycore = project.pycore
-        this_pymodule = self.pycore.resource_to_pyobject(resource)
+        this_pymodule = self.project.get_pymodule(resource)
         pyname = evaluate.eval_location(this_pymodule, offset)
         self.method_name = worder.get_name_at(resource, offset)
         self.pyfunction = pyname.get_object()
@@ -73,7 +74,7 @@ def get_changes(self, dest_attr, new_name=None, resources=None,
         """
         changes = ChangeSet('Moving method <%s>' % self.method_name)
         if resources is None:
-            resources = self.pycore.get_python_files()
+            resources = self.project.get_python_files()
         if new_name is None:
             new_name = self.get_method_name()
         resource1, start1, end1, new_content1 = \
@@ -89,11 +90,11 @@ def get_changes(self, dest_attr, new_name=None, resources=None,
             collector2 = codeanalyze.ChangeCollector(resource2.read())
             collector2.add_change(start2, end2, new_content2)
             result = collector2.get_changed()
-            import_tools = importutils.ImportTools(self.pycore)
+            import_tools = importutils.ImportTools(self.project)
             new_imports = self._get_used_imports(import_tools)
             if new_imports:
-                goal_pymodule = self.pycore.get_string_module(result,
-                                                              resource2)
+                goal_pymodule = libutils.get_string_module(
+                    self.project, result, resource2)
                 result = _add_imports_to_module(
                     import_tools, goal_pymodule, new_imports)
             if resource2 in resources:
@@ -108,13 +109,13 @@ def get_method_name(self):
         return self.method_name
 
     def _get_used_imports(self, import_tools):
-        return importutils.get_imports(self.pycore, self.pyfunction)
+        return importutils.get_imports(self.project, self.pyfunction)
 
     def _get_changes_made_by_old_class(self, dest_attr, new_name):
         pymodule = self.pyfunction.get_module()
         indents = self._get_scope_indents(self.pyfunction)
-        body = 'return self.%s.%s(%s)\n' % (dest_attr, new_name,
-                                            self._get_passed_arguments_string())
+        body = 'return self.%s.%s(%s)\n' % (
+            dest_attr, new_name, self._get_passed_arguments_string())
         region = sourceutils.get_body_region(self.pyfunction)
         return (pymodule.get_resource(), region[0], region[1],
                 sourceutils.fix_indentation(body, indents))
@@ -123,7 +124,7 @@ def _get_scope_indents(self, pyobject):
         pymodule = pyobject.get_module()
         return sourceutils.get_indents(
             pymodule.lines, pyobject.get_scope().get_start()) + \
-            sourceutils.get_indent(self.pycore)
+            sourceutils.get_indent(self.project)
 
     def _get_changes_made_by_new_class(self, dest_attr, new_name):
         old_pyclass = self.pyfunction.parent
@@ -150,7 +151,7 @@ def get_new_method(self, name):
         return '%s\n%s' % (
             self._get_new_header(name),
             sourceutils.fix_indentation(self._get_body(),
-                                        sourceutils.get_indent(self.pycore)))
+                                        sourceutils.get_indent(self.project)))
 
     def _get_unchanged_body(self):
         return sourceutils.get_body(self.pyfunction)
@@ -158,9 +159,9 @@ def _get_unchanged_body(self):
     def _get_body(self, host='host'):
         self_name = self._get_self_name()
         body = self_name + ' = None\n' + self._get_unchanged_body()
-        pymodule = self.pycore.get_string_module(body)
+        pymodule = libutils.get_string_module(self.project, body)
         finder = occurrences.create_finder(
-            self.pycore, self_name, pymodule[self_name])
+            self.project, self_name, pymodule[self_name])
         result = rename.rename_in_module(finder, host, pymodule=pymodule)
         if result is None:
             result = body
@@ -199,26 +200,28 @@ class MoveGlobal(object):
     """For moving global function and classes"""
 
     def __init__(self, project, resource, offset):
-        self.pycore = project.pycore
-        this_pymodule = self.pycore.resource_to_pyobject(resource)
+        self.project = project
+        this_pymodule = self.project.get_pymodule(resource)
         self.old_pyname = evaluate.eval_location(this_pymodule, offset)
         self.old_name = self.old_pyname.get_object().get_name()
         pymodule = self.old_pyname.get_object().get_module()
         self.source = pymodule.get_resource()
-        self.tools = _MoveTools(self.pycore, self.source,
+        self.tools = _MoveTools(self.project, self.source,
                                 self.old_pyname, self.old_name)
         self.import_tools = self.tools.import_tools
         self._check_exceptional_conditions()
 
     def _check_exceptional_conditions(self):
         if self.old_pyname is None or \
-           not isinstance(self.old_pyname.get_object(), pyobjects.PyDefinedObject):
+           not isinstance(self.old_pyname.get_object(),
+                          pyobjects.PyDefinedObject):
             raise exceptions.RefactoringError(
                 'Move refactoring should be performed on a class/function.')
         moving_pyobject = self.old_pyname.get_object()
         if not self._is_global(moving_pyobject):
             raise exceptions.RefactoringError(
-                'Move refactoring should be performed on a global class/function.')
+                'Move refactoring should be performed ' +
+                'on a global class/function.')
 
     def _is_global(self, pyobject):
         return pyobject.get_scope().parent == pyobject.get_module().get_scope()
@@ -226,7 +229,7 @@ def _is_global(self, pyobject):
     def get_changes(self, dest, resources=None,
                     task_handle=taskhandle.NullTaskHandle()):
         if resources is None:
-            resources = self.pycore.get_python_files()
+            resources = self.project.get_python_files()
         if dest is None or not dest.exists():
             raise exceptions.RefactoringError(
                 'Move destination does not exist.')
@@ -251,7 +254,7 @@ def _calculate_changes(self, dest, resources, task_handle):
             elif file_ == dest:
                 changes.add_change(self._dest_module_changes(dest))
             elif self.tools.occurs_in_module(resource=file_):
-                pymodule = self.pycore.resource_to_pyobject(file_)
+                pymodule = self.project.get_pymodule(file_)
                 # Changing occurrences
                 placeholder = '__rope_renaming_%s_' % self.old_name
                 source = self.tools.rename_in_module(placeholder,
@@ -264,7 +267,8 @@ def _calculate_changes(self, dest, resources, task_handle):
                 if should_import:
                     pymodule = self.tools.new_pymodule(pymodule, source)
                     source, imported = importutils.add_import(
-                        self.pycore, pymodule, self._new_modname(dest), self.old_name)
+                        self.project, pymodule, self._new_modname(dest),
+                        self.old_name)
                     source = source.replace(placeholder, imported)
                 source = self.tools.new_source(pymodule, source)
                 if source != file_.read():
@@ -276,25 +280,26 @@ def _source_module_changes(self, dest):
         placeholder = '__rope_moving_%s_' % self.old_name
         handle = _ChangeMoveOccurrencesHandle(placeholder)
         occurrence_finder = occurrences.create_finder(
-            self.pycore, self.old_name, self.old_pyname)
+            self.project, self.old_name, self.old_pyname)
         start, end = self._get_moving_region()
         renamer = ModuleSkipRenamer(occurrence_finder, self.source,
                                     handle, start, end)
         source = renamer.get_changed_module()
         if handle.occurred:
-            pymodule = self.pycore.get_string_module(source, self.source)
+            pymodule = libutils.get_string_module(
+                self.project, source, self.source)
             # Adding new import
             source, imported = importutils.add_import(
-                self.pycore, pymodule, self._new_modname(dest), self.old_name)
+                self.project, pymodule, self._new_modname(dest), self.old_name)
             source = source.replace(placeholder, imported)
         return ChangeContents(self.source, source)
 
     def _new_modname(self, dest):
-        return self.pycore.modname(dest)
+        return libutils.modname(dest)
 
     def _dest_module_changes(self, dest):
         # Changing occurrences
-        pymodule = self.pycore.resource_to_pyobject(dest)
+        pymodule = self.project.get_pymodule(dest)
         source = self.tools.rename_in_module(self.old_name, pymodule)
         pymodule = self.tools.new_pymodule(pymodule, source)
 
@@ -310,7 +315,8 @@ def _dest_module_changes(self, dest):
             lineno = module_with_imports.imports[-1].end_line - 1
         else:
             while lineno < pymodule.lines.length() and \
-                  pymodule.lines.get_line(lineno + 1).lstrip().startswith('#'):
+                    pymodule.lines.get_line(lineno + 1).\
+                    lstrip().startswith('#'):
                 lineno += 1
         if lineno > 0:
             cut = pymodule.lines.get_line_end(lineno) + 1
@@ -320,17 +326,18 @@ def _dest_module_changes(self, dest):
 
         # Organizing imports
         source = result
-        pymodule = self.pycore.get_string_module(source, dest)
+        pymodule = libutils.get_string_module(self.project, source, dest)
         source = self.import_tools.organize_imports(pymodule, sort=False,
                                                     unused=False)
         return ChangeContents(dest, source)
 
     def _get_moving_element_with_imports(self):
         return moving_code_with_imports(
-            self.pycore, self.source, self._get_moving_element())
+            self.project, self.source, self._get_moving_element())
 
     def _get_module_with_imports(self, source_code, resource):
-        pymodule = self.pycore.get_string_module(source_code, resource)
+        pymodule = libutils.get_string_module(
+            self.project, source_code, resource)
         return self.import_tools.module_imports(pymodule)
 
     def _get_moving_element(self):
@@ -339,13 +346,13 @@ def _get_moving_element(self):
         return moving.rstrip() + '\n'
 
     def _get_moving_region(self):
-        pymodule = self.pycore.resource_to_pyobject(self.source)
+        pymodule = self.project.get_pymodule(self.source)
         lines = pymodule.lines
         scope = self.old_pyname.get_object().get_scope()
         start = lines.get_line_start(scope.get_start())
         end_line = scope.get_end()
         while end_line < lines.length() and \
-              lines.get_line(end_line + 1).strip() == '':
+                lines.get_line(end_line + 1).strip() == '':
             end_line += 1
         end = min(lines.get_line_end(end_line) + 1, len(pymodule.source_code))
         return start, end
@@ -356,7 +363,8 @@ def _add_imports2(self, pymodule, new_imports):
             return pymodule, False
         else:
             resource = pymodule.get_resource()
-            pymodule = self.pycore.get_string_module(source, resource)
+            pymodule = libutils.get_string_module(
+                self.project, source, resource)
             return pymodule, True
 
 
@@ -365,13 +373,12 @@ class MoveModule(object):
 
     def __init__(self, project, resource):
         self.project = project
-        self.pycore = project.pycore
         if not resource.is_folder() and resource.name == '__init__.py':
             resource = resource.parent
         if resource.is_folder() and not resource.has_child('__init__.py'):
             raise exceptions.RefactoringError(
                 'Cannot move non-package folder.')
-        dummy_pymodule = self.pycore.get_string_module('')
+        dummy_pymodule = libutils.get_string_module(self.project, '')
         self.old_pyname = pynames.ImportedModule(dummy_pymodule,
                                                  resource=resource)
         self.source = self.old_pyname.get_object().get_resource()
@@ -379,15 +386,14 @@ def __init__(self, project, resource):
             self.old_name = self.source.name
         else:
             self.old_name = self.source.name[:-3]
-        self.tools = _MoveTools(self.pycore, self.source,
+        self.tools = _MoveTools(self.project, self.source,
                                 self.old_pyname, self.old_name)
         self.import_tools = self.tools.import_tools
 
     def get_changes(self, dest, resources=None,
                     task_handle=taskhandle.NullTaskHandle()):
-        moving_pyobject = self.old_pyname.get_object()
         if resources is None:
-            resources = self.pycore.get_python_files()
+            resources = self.project.get_python_files()
         if dest is None or not dest.is_folder():
             raise exceptions.RefactoringError(
                 'Move destination for modules should be packages.')
@@ -412,7 +418,7 @@ def _calculate_changes(self, dest, resources, task_handle):
         return changes
 
     def _new_modname(self, dest):
-        destname = self.pycore.modname(dest)
+        destname = libutils.modname(dest)
         if destname:
             return destname + '.' + self.old_name
         return self.old_name
@@ -422,7 +428,7 @@ def _new_import(self, dest):
 
     def _change_moving_module(self, changes, dest):
         if not self.source.is_folder():
-            pymodule = self.pycore.resource_to_pyobject(self.source)
+            pymodule = self.project.get_pymodule(self.source)
             source = self.import_tools.relatives_to_absolutes(pymodule)
             pymodule = self.tools.new_pymodule(pymodule, source)
             source = self._change_occurrences_in_module(dest, pymodule)
@@ -436,11 +442,24 @@ def _change_occurrences_in_module(self, dest, pymodule=None,
                                            resource=resource):
             return
         if pymodule is None:
-            pymodule = self.pycore.resource_to_pyobject(resource)
+            pymodule = self.project.get_pymodule(resource)
         new_name = self._new_modname(dest)
+        module_imports = importutils.get_module_imports(self.project, pymodule)
+        changed = False
+
+        source = None
+        if libutils.modname(dest):
+            changed = self._change_import_statements(dest, new_name,
+                                                     module_imports)
+            if changed:
+                source = module_imports.get_changed_source()
+                source = self.tools.new_source(pymodule, source)
+                pymodule = self.tools.new_pymodule(pymodule, source)
+
         new_import = self._new_import(dest)
         source = self.tools.rename_in_module(
-            new_name, imports=True, pymodule=pymodule, resource=resource)
+            new_name, imports=True, pymodule=pymodule,
+            resource=resource if not changed else None)
         should_import = self.tools.occurs_in_module(
             pymodule=pymodule, resource=resource, imports=False)
         pymodule = self.tools.new_pymodule(pymodule, source)
@@ -449,8 +468,75 @@ def _change_occurrences_in_module(self, dest, pymodule=None,
             pymodule = self.tools.new_pymodule(pymodule, source)
             source = self.tools.add_imports(pymodule, [new_import])
         source = self.tools.new_source(pymodule, source)
-        if source != pymodule.resource.read():
+        if source is not None and source != pymodule.resource.read():
             return source
+        return None
+
+
+    def _change_import_statements(self, dest, new_name, module_imports):
+        moving_module = self.source
+        parent_module = moving_module.parent
+
+        changed = False
+        for import_stmt in module_imports.imports:
+            if not any(name_and_alias[0] == self.old_name
+                       for name_and_alias in
+                       import_stmt.import_info.names_and_aliases) and \
+               not any(name_and_alias[0] == libutils.modname(self.source)
+                       for name_and_alias in
+                       import_stmt.import_info.names_and_aliases):
+                continue
+
+            # Case 1: Look for normal imports of the moving module.
+            if isinstance(import_stmt.import_info, importutils.NormalImport):
+                continue
+
+            # Case 2: The moving module is from-imported.
+            changed = self._handle_moving_in_from_import_stmt(
+                dest, import_stmt, module_imports, parent_module) or changed
+
+            # Case 3: Names are imported from the moving module.
+            context = importutils.importinfo.ImportContext(self.project, None)
+            if not import_stmt.import_info.is_empty() and \
+               import_stmt.import_info.get_imported_resource(context) == \
+                    moving_module:
+                import_stmt.import_info = importutils.FromImport(
+                    new_name, import_stmt.import_info.level,
+                    import_stmt.import_info.names_and_aliases)
+                changed = True
+
+        return changed
+
+    def _handle_moving_in_from_import_stmt(self, dest, import_stmt,
+                                           module_imports, parent_module):
+        changed = False
+        context = importutils.importinfo.ImportContext(self.project, None)
+        if import_stmt.import_info.get_imported_resource(context) == \
+                parent_module:
+            imports = import_stmt.import_info.names_and_aliases
+            new_imports = []
+            for name, alias in imports:
+                # The moving module was imported.
+                if name == self.old_name:
+                    changed = True
+                    new_import = importutils.FromImport(
+                        libutils.modname(dest), 0,
+                        [(self.old_name, alias)])
+                    module_imports.add_import(new_import)
+                else:
+                    new_imports.append((name, alias))
+
+            # Update the imports if the imported names were changed.
+            if new_imports != imports:
+                changed = True
+                if new_imports:
+                    import_stmt.import_info = importutils.FromImport(
+                        import_stmt.import_info.module_name,
+                        import_stmt.import_info.level,
+                        new_imports)
+                else:
+                    import_stmt.empty_import()
+        return changed
 
 
 class _ChangeMoveOccurrencesHandle(object):
@@ -470,20 +556,22 @@ def occurred_outside_skip(self, change_collector, occurrence):
 
 class _MoveTools(object):
 
-    def __init__(self, pycore, source, pyname, old_name):
-        self.pycore = pycore
+    def __init__(self, project, source, pyname, old_name):
+        self.project = project
         self.source = source
         self.old_pyname = pyname
         self.old_name = old_name
-        self.import_tools = importutils.ImportTools(self.pycore)
+        self.import_tools = importutils.ImportTools(self.project)
 
     def remove_old_imports(self, pymodule):
         old_source = pymodule.source_code
         module_with_imports = self.import_tools.module_imports(pymodule)
+
         class CanSelect(object):
             changed = False
             old_name = self.old_name
             old_pyname = self.old_pyname
+
             def __call__(self, name):
                 try:
                     if name == self.old_name and \
@@ -501,7 +589,7 @@ def __call__(self, name):
             return new_source
 
     def rename_in_module(self, new_name, pymodule=None,
-                          imports=False, resource=None):
+                         imports=False, resource=None):
         occurrence_finder = self._create_finder(imports)
         source = rename.rename_in_module(
             occurrence_finder, new_name, replace_primary=True,
@@ -516,13 +604,13 @@ def occurs_in_module(self, pymodule=None, resource=None, imports=True):
         return False
 
     def _create_finder(self, imports):
-        return occurrences.create_finder(self.pycore, self.old_name,
+        return occurrences.create_finder(self.project, self.old_name,
                                          self.old_pyname, imports=imports)
 
     def new_pymodule(self, pymodule, source):
         if source is not None:
-            return self.pycore.get_string_module(
-                source, pymodule.get_resource())
+            return libutils.get_string_module(
+                self.project, source, pymodule.get_resource())
         return pymodule
 
     def new_source(self, pymodule, source):
@@ -541,10 +629,10 @@ def _add_imports_to_module(import_tools, pymodule, new_imports):
     return module_with_imports.get_changed_source()
 
 
-def moving_code_with_imports(pycore, resource, source):
-    import_tools = importutils.ImportTools(pycore)
-    pymodule = pycore.get_string_module(source, resource)
-    origin = pycore.resource_to_pyobject(resource)
+def moving_code_with_imports(project, resource, source):
+    import_tools = importutils.ImportTools(project)
+    pymodule = libutils.get_string_module(project, source, resource)
+    origin = project.get_pymodule(resource)
 
     imports = []
     for stmt in import_tools.module_imports(origin).imports:
@@ -557,12 +645,12 @@ def moving_code_with_imports(pycore, resource, source):
     imports.append(import_tools.get_from_import(resource, back_names))
 
     source = _add_imports_to_module(import_tools, pymodule, imports)
-    pymodule = pycore.get_string_module(source, resource)
+    pymodule = libutils.get_string_module(project, source, resource)
 
     source = import_tools.relatives_to_absolutes(pymodule)
-    pymodule = pycore.get_string_module(source, resource)
+    pymodule = libutils.get_string_module(project, source, resource)
     source = import_tools.organize_imports(pymodule, selfs=False)
-    pymodule = pycore.get_string_module(source, resource)
+    pymodule = libutils.get_string_module(project, source, resource)
 
     # extracting imports after changes
     module_imports = import_tools.module_imports(pymodule)
@@ -610,7 +698,7 @@ def __init__(self, occurrence_finder, resource, handle=None,
         self.replacement = replacement
         self.handle = handle
         if self.handle is None:
-            self.handle = ModuleSkipHandle()
+            self.handle = ModuleSkipRenamerHandle()
 
     def get_changed_module(self):
         source = self.resource.read()
@@ -618,7 +706,8 @@ def get_changed_module(self):
         if self.replacement is not None:
             change_collector.add_change(self.skip_start, self.skip_end,
                                         self.replacement)
-        for occurrence in self.occurrence_finder.find_occurrences(self.resource):
+        for occurrence in self.occurrence_finder.find_occurrences(
+                self.resource):
             start, end = occurrence.get_primary_range()
             if self.skip_start <= start < self.skip_end:
                 self.handle.occurred_inside_skip(change_collector, occurrence)
diff --git a/pymode/libs2/rope/refactor/multiproject.py b/pymode/libs2/rope/refactor/multiproject.py
index 6a85d2a2..ac243bda 100644
--- a/pymode/libs2/rope/refactor/multiproject.py
+++ b/pymode/libs2/rope/refactor/multiproject.py
@@ -1,11 +1,11 @@
 """This module can be used for performing cross-project refactorings
 
-See the "cross-project refactorings" section of ``docs/library.txt``
+See the "cross-project refactorings" section of ``docs/library.rst``
 file.
 
 """
 
-from rope.base import resources, project, libutils
+from rope.base import resources, libutils
 
 
 class MultiProjectRefactoring(object):
@@ -33,7 +33,7 @@ def __init__(self, refactoring, other_projects, addpath,
         self.refactoring = refactoring
         self.projects = [project] + other_projects
         for other_project in other_projects:
-            for folder in self.project.pycore.get_source_folders():
+            for folder in self.project.get_source_folders():
                 other_project.get_prefs().add('python_path', folder.real_path)
         self.refactorings = []
         for other in self.projects:
@@ -57,7 +57,7 @@ def _resources_for_args(self, project, args, kwds):
         newkwds = dict((name, self._change_project_resource(project, value))
                        for name, value in kwds.items())
         return newargs, newkwds
-        
+
     def _change_project_resource(self, project, obj):
         if isinstance(obj, resources.Resource) and \
            obj.project != project:
diff --git a/pymode/libs2/rope/refactor/occurrences.py b/pymode/libs2/rope/refactor/occurrences.py
index 2808ed2c..14a2d7de 100644
--- a/pymode/libs2/rope/refactor/occurrences.py
+++ b/pymode/libs2/rope/refactor/occurrences.py
@@ -1,7 +1,46 @@
+"""Find occurrences of a name in a project.
+
+This module consists of a `Finder` that finds all occurrences of a name
+in a project. The `Finder.find_occurrences()` method is a generator that
+yields `Occurrence` instances for each occurrence of the name. To create
+a `Finder` object, use the `create_finder()` function:
+
+    finder = occurrences.create_finder(project, 'foo', pyname)
+    for occurrence in finder.find_occurrences():
+        pass
+
+It's possible to filter the occurrences. They can be specified when
+calling the `create_finder()` function.
+
+  * `only_calls`: If True, return only those instances where the name is
+    a function that's being called.
+
+  * `imports`: If False, don't return instances that are in import
+    statements.
+
+  * `unsure`: If a prediate function, return instances where we don't
+    know what the name references. It also filters based on the
+    predicate function.
+
+  * `docs`: If True, it will search for occurrences in regions normally
+    ignored. E.g., strings and comments.
+
+  * `in_hierarchy`: If True, it will find occurrences if the name is in
+    the class's hierarchy.
+
+  * `instance`: Used only when you want implicit interfaces to be
+    considered.
+"""
+
 import re
 
-import rope.base.pynames
-from rope.base import pynames, pyobjects, codeanalyze, evaluate, exceptions, utils, worder
+from rope.base import codeanalyze
+from rope.base import evaluate
+from rope.base import exceptions
+from rope.base import pynames
+from rope.base import pyobjects
+from rope.base import utils
+from rope.base import worder
 
 
 class Finder(object):
@@ -19,8 +58,8 @@ class Finder(object):
 
     """
 
-    def __init__(self, pycore, name, filters=[lambda o: True], docs=False):
-        self.pycore = pycore
+    def __init__(self, project, name, filters=[lambda o: True], docs=False):
+        self.project = project
         self.name = name
         self.docs = docs
         self.filters = filters
@@ -28,7 +67,7 @@ def __init__(self, pycore, name, filters=[lambda o: True], docs=False):
 
     def find_occurrences(self, resource=None, pymodule=None):
         """Generate `Occurrence` instances"""
-        tools = _OccurrenceToolsCreator(self.pycore, resource=resource,
+        tools = _OccurrenceToolsCreator(self.project, resource=resource,
                                         pymodule=pymodule, docs=self.docs)
         for offset in self._textual_finder.find_offsets(tools.source_code):
             occurrence = Occurrence(tools, offset)
@@ -41,7 +80,7 @@ def find_occurrences(self, resource=None, pymodule=None):
                 break
 
 
-def create_finder(pycore, name, pyname, only_calls=False, imports=True,
+def create_finder(project, name, pyname, only_calls=False, imports=True,
                   unsure=None, docs=False, instance=None, in_hierarchy=False):
     """A factory for `Finder`
 
@@ -50,25 +89,25 @@ def create_finder(pycore, name, pyname, only_calls=False, imports=True,
     considered.
 
     """
-    pynames = set([pyname])
+    pynames_ = set([pyname])
     filters = []
     if only_calls:
         filters.append(CallsFilter())
     if not imports:
         filters.append(NoImportsFilter())
-    if isinstance(instance, rope.base.pynames.ParameterName):
+    if isinstance(instance, pynames.ParameterName):
         for pyobject in instance.get_objects():
             try:
-                pynames.add(pyobject[name])
+                pynames_.add(pyobject[name])
             except exceptions.AttributeNotFoundError:
                 pass
-    for pyname in pynames:
+    for pyname in pynames_:
         filters.append(PyNameFilter(pyname))
         if in_hierarchy:
             filters.append(InHierarchyFilter(pyname))
     if unsure:
         filters.append(UnsureFilter(unsure))
-    return Finder(pycore, name, filters=filters, docs=docs)
+    return Finder(project, name, filters=filters, docs=docs)
 
 
 class Occurrence(object):
@@ -96,7 +135,8 @@ def get_pyname(self):
     @utils.saveit
     def get_primary_and_pyname(self):
         try:
-            return self.tools.name_finder.get_primary_and_pyname_at(self.offset)
+            return self.tools.name_finder.get_primary_and_pyname_at(
+                self.offset)
         except exceptions.BadIdentifierError:
             pass
 
@@ -109,11 +149,13 @@ def is_called(self):
         return self.tools.word_finder.is_a_function_being_called(self.offset)
 
     def is_defined(self):
-        return self.tools.word_finder.is_a_class_or_function_name_in_header(self.offset)
+        return self.tools.word_finder.is_a_class_or_function_name_in_header(
+            self.offset)
 
     def is_a_fixed_primary(self):
-        return self.tools.word_finder.is_a_class_or_function_name_in_header(self.offset) or \
-               self.tools.word_finder.is_a_name_after_from_import(self.offset)
+        return self.tools.word_finder.is_a_class_or_function_name_in_header(
+            self.offset) or \
+            self.tools.word_finder.is_a_name_after_from_import(self.offset)
 
     def is_written(self):
         return self.tools.word_finder.is_assigned_here(self.offset)
@@ -134,11 +176,14 @@ def same_pyname(expected, pyname):
         return False
     if expected == pyname:
         return True
-    if type(expected) not in (pynames.ImportedModule, pynames.ImportedName) and \
-       type(pyname) not in (pynames.ImportedModule, pynames.ImportedName):
+    if type(expected) not in (pynames.ImportedModule, pynames.ImportedName) \
+        and type(pyname) not in \
+            (pynames.ImportedModule, pynames.ImportedName):
         return False
-    return expected.get_definition_location() == pyname.get_definition_location() and \
-           expected.get_object() == pyname.get_object()
+    return expected.get_definition_location() == \
+        pyname.get_definition_location() and \
+        expected.get_object() == pyname.get_object()
+
 
 def unsure_pyname(pyname, unbound=True):
     """Return `True` if we don't know what this name references"""
@@ -151,7 +196,7 @@ def unsure_pyname(pyname, unbound=True):
 
 
 class PyNameFilter(object):
-    """For finding occurrences of a name"""
+    """For finding occurrences of a name."""
 
     def __init__(self, pyname):
         self.pyname = pyname
@@ -162,7 +207,7 @@ def __call__(self, occurrence):
 
 
 class InHierarchyFilter(object):
-    """For finding occurrences of a name"""
+    """Finds the occurrence if the name is in the class's hierarchy."""
 
     def __init__(self, pyname, implementations_only=False):
         self.pyname = pyname
@@ -203,6 +248,7 @@ def _get_root_classes(self, pyclass, name):
 
 
 class UnsureFilter(object):
+    """Occurrences where we don't knoow what the name references."""
 
     def __init__(self, unsure):
         self.unsure = unsure
@@ -213,6 +259,7 @@ def __call__(self, occurrence):
 
 
 class NoImportsFilter(object):
+    """Don't include import statements as occurrences."""
 
     def __call__(self, occurrence):
         if occurrence.is_in_import_statement():
@@ -220,6 +267,7 @@ def __call__(self, occurrence):
 
 
 class CallsFilter(object):
+    """Filter out non-call occurrences."""
 
     def __call__(self, occurrence):
         if not occurrence.is_called():
@@ -258,8 +306,10 @@ def _normal_search(self, source):
             try:
                 found = source.index(self.name, current)
                 current = found + len(self.name)
-                if (found == 0 or not self._is_id_char(source[found - 1])) and \
-                   (current == len(source) or not self._is_id_char(source[current])):
+                if (found == 0 or
+                        not self._is_id_char(source[found - 1])) and \
+                    (current == len(source) or
+                        not self._is_id_char(source[current])):
                     yield found
             except ValueError:
                 break
@@ -282,7 +332,7 @@ def _get_source(self, resource, pymodule):
 
     def _get_occurrence_pattern(self, name):
         occurrence_pattern = _TextualFinder.any('occurrence',
-                                                 ['\\b' + name + '\\b'])
+                                                ['\\b' + name + '\\b'])
         pattern = re.compile(occurrence_pattern + '|' + self.comment_pattern +
                              '|' + self.string_pattern)
         return pattern
@@ -294,8 +344,8 @@ def any(name, list_):
 
 class _OccurrenceToolsCreator(object):
 
-    def __init__(self, pycore, resource=None, pymodule=None, docs=False):
-        self.pycore = pycore
+    def __init__(self, project, resource=None, pymodule=None, docs=False):
+        self.project = project
         self.__resource = resource
         self.__pymodule = pymodule
         self.docs = docs
@@ -331,4 +381,4 @@ def resource(self):
     def pymodule(self):
         if self.__pymodule is not None:
             return self.__pymodule
-        return self.pycore.resource_to_pyobject(self.resource)
+        return self.project.get_pymodule(self.resource)
diff --git a/pymode/libs2/rope/refactor/patchedast.py b/pymode/libs2/rope/refactor/patchedast.py
index 88fa4d85..28d36d5a 100644
--- a/pymode/libs2/rope/refactor/patchedast.py
+++ b/pymode/libs2/rope/refactor/patchedast.py
@@ -68,6 +68,7 @@ def __init__(self, source, children=False):
 
     Number = object()
     String = object()
+    semicolon_or_as_in_except = object()
 
     def __call__(self, node):
         method = getattr(self, '_' + node.__class__.__name__, None)
@@ -111,6 +112,10 @@ def _handle(self, node, base_children, eat_parens=False, eat_spaces=False):
                 elif child == '!=':
                     # INFO: This has been added to handle deprecated ``<>``
                     region = self.source.consume_not_equal()
+                elif child == self.semicolon_or_as_in_except:
+                    # INFO: This has been added to handle deprecated
+                    # semicolon in except
+                    region = self.source.consume_except_as_or_semicolon()
                 else:
                     region = self.source.consume(child)
                 child = self.source[region[0]:region[1]]
@@ -205,16 +210,17 @@ def _find_next_statement_start(self):
             for child in children:
                 if isinstance(child, ast.stmt):
                     return child.col_offset \
-                           + self.lines.get_line_start(child.lineno)
+                        + self.lines.get_line_start(child.lineno)
         return len(self.source.source)
 
-    _operators = {'And': 'and', 'Or': 'or', 'Add': '+', 'Sub': '-', 'Mult': '*',
-                  'Div': '/', 'Mod': '%', 'Pow': '**', 'LShift': '<<',
-                  'RShift': '>>', 'BitOr': '|', 'BitAnd': '&', 'BitXor': '^',
-                  'FloorDiv': '//', 'Invert': '~', 'Not': 'not', 'UAdd': '+',
-                  'USub': '-', 'Eq': '==', 'NotEq': '!=', 'Lt': '<',
-                  'LtE': '<=', 'Gt': '>', 'GtE': '>=', 'Is': 'is',
-                  'IsNot': 'is not', 'In': 'in', 'NotIn': 'not in'}
+    _operators = {'And': 'and', 'Or': 'or', 'Add': '+', 'Sub': '-',
+                  'Mult': '*', 'Div': '/', 'Mod': '%', 'Pow': '**',
+                  'LShift': '<<', 'RShift': '>>', 'BitOr': '|', 'BitAnd': '&',
+                  'BitXor': '^', 'FloorDiv': '//', 'Invert': '~',
+                  'Not': 'not', 'UAdd': '+', 'USub': '-', 'Eq': '==',
+                  'NotEq': '!=', 'Lt': '<', 'LtE': '<=', 'Gt': '>',
+                  'GtE': '>=', 'Is': 'is', 'IsNot': 'is not', 'In': 'in',
+                  'NotIn': 'not in'}
 
     def _get_op(self, node):
         return self._operators[node.__class__.__name__].split(' ')
@@ -351,7 +357,8 @@ def _ImportFrom(self, node):
         children = ['from']
         if node.level:
             children.append('.' * node.level)
-        children.extend([node.module or '', # see comment at rope.base.ast.walk
+        # see comment at rope.base.ast.walk
+        children.extend([node.module or '',
                          'import'])
         children.extend(self._child_nodes(node.names, ','))
         self._handle(node, children)
@@ -380,7 +387,8 @@ def _FunctionDef(self, node):
     def _arguments(self, node):
         children = []
         args = list(node.args)
-        defaults = [None] * (len(args) - len(node.defaults)) + list(node.defaults)
+        defaults = [None] * (len(args) - len(node.defaults)) + \
+            list(node.defaults)
         for index, (arg, default) in enumerate(zip(args, defaults)):
             if index > 0:
                 children.append(',')
@@ -568,13 +576,16 @@ def _ExceptHandler(self, node):
         self._excepthandler(node)
 
     def _excepthandler(self, node):
+        # self._handle(node, [self.semicolon_or_as_in_except])
         children = ['except']
         if node.type:
             children.append(node.type)
         if node.name:
-            children.extend([',', node.name])
+            children.append(self.semicolon_or_as_in_except)
+            children.append(node.name)
         children.append(':')
         children.extend(node.body)
+
         self._handle(node, children)
 
     def _Tuple(self, node):
@@ -663,6 +674,10 @@ def consume_not_equal(self):
         repattern = _Source._not_equals_pattern
         return self._consume_pattern(repattern)
 
+    def consume_except_as_or_semicolon(self):
+        repattern = re.compile(r'as|,')
+        return self._consume_pattern(repattern)
+
     def _good_token(self, token, offset, start=None):
         """Checks whether consumed token is in comments"""
         if start is None:
diff --git a/pymode/libs2/rope/refactor/rename.py b/pymode/libs2/rope/refactor/rename.py
index 65e6e1d5..3f1f5b7e 100644
--- a/pymode/libs2/rope/refactor/rename.py
+++ b/pymode/libs2/rope/refactor/rename.py
@@ -1,8 +1,9 @@
 import warnings
 
-from rope.base import exceptions, pyobjects, pynames, taskhandle, evaluate, worder, codeanalyze
+from rope.base import (exceptions, pyobjects, pynames, taskhandle,
+                       evaluate, worder, codeanalyze, libutils)
 from rope.base.change import ChangeSet, ChangeContents, MoveResource
-from rope.refactor import occurrences, sourceutils
+from rope.refactor import occurrences
 
 
 class Rename(object):
@@ -16,11 +17,10 @@ class Rename(object):
     def __init__(self, project, resource, offset=None):
         """If `offset` is None, the `resource` itself will be renamed"""
         self.project = project
-        self.pycore = project.pycore
         self.resource = resource
         if offset is not None:
             self.old_name = worder.get_name_at(self.resource, offset)
-            this_pymodule = self.pycore.resource_to_pyobject(self.resource)
+            this_pymodule = self.project.get_pymodule(self.resource)
             self.old_instance, self.old_pyname = \
                 evaluate.eval_location2(this_pymodule, offset)
             if self.old_pyname is None:
@@ -30,7 +30,7 @@ def __init__(self, project, resource, offset=None):
         else:
             if not resource.is_folder() and resource.name == '__init__.py':
                 resource = resource.parent
-            dummy_pymodule = self.pycore.get_string_module('')
+            dummy_pymodule = libutils.get_string_module(self.project, '')
             self.old_instance = None
             self.old_pyname = pynames.ImportedModule(dummy_pymodule,
                                                      resource=resource)
@@ -70,6 +70,7 @@ def get_changes(self, new_name, in_file=None, in_hierarchy=False,
             warnings.warn(
                 'unsure parameter should be a function that returns '
                 'True or False', DeprecationWarning, stacklevel=2)
+
             def unsure_func(value=unsure):
                 return value
             unsure = unsure_func
@@ -82,14 +83,15 @@ def unsure_func(value=unsure):
         if _is_local(self.old_pyname):
             resources = [self.resource]
         if resources is None:
-            resources = self.pycore.get_python_files()
+            resources = self.project.get_python_files()
         changes = ChangeSet('Renaming <%s> to <%s>' %
                             (self.old_name, new_name))
         finder = occurrences.create_finder(
-            self.pycore, self.old_name, self.old_pyname, unsure=unsure,
+            self.project, self.old_name, self.old_pyname, unsure=unsure,
             docs=docs, instance=self.old_instance,
             in_hierarchy=in_hierarchy and self.is_method())
-        job_set = task_handle.create_jobset('Collecting Changes', len(resources))
+        job_set = task_handle.create_jobset('Collecting Changes',
+                                            len(resources))
         for file_ in resources:
             job_set.started_job(file_.path)
             new_content = rename_in_module(finder, new_name, resource=file_)
@@ -119,8 +121,8 @@ def _is_renaming_a_module(self):
     def is_method(self):
         pyname = self.old_pyname
         return isinstance(pyname, pynames.DefinedName) and \
-               isinstance(pyname.get_object(), pyobjects.PyFunction) and \
-               isinstance(pyname.get_object().parent, pyobjects.PyClass)
+            isinstance(pyname.get_object(), pyobjects.PyFunction) and \
+            isinstance(pyname.get_object().parent, pyobjects.PyClass)
 
     def _rename_module(self, resource, new_name, changes):
         if not resource.is_folder():
@@ -147,11 +149,11 @@ class ChangeOccurrences(object):
     """
 
     def __init__(self, project, resource, offset):
-        self.pycore = project.pycore
+        self.project = project
         self.resource = resource
         self.offset = offset
         self.old_name = worder.get_name_at(resource, offset)
-        self.pymodule = self.pycore.resource_to_pyobject(self.resource)
+        self.pymodule = project.get_pymodule(self.resource)
         self.old_pyname = evaluate.eval_location(self.pymodule, offset)
 
     def get_old_name(self):
@@ -161,7 +163,7 @@ def get_old_name(self):
     def _get_scope_offset(self):
         lines = self.pymodule.lines
         scope = self.pymodule.get_scope().\
-                get_inner_scope_for_line(lines.get_line_number(self.offset))
+            get_inner_scope_for_line(lines.get_line_number(self.offset))
         start = lines.get_line_start(scope.get_start())
         end = lines.get_line_end(scope.get_end())
         return start, end
@@ -171,7 +173,7 @@ def get_changes(self, new_name, only_calls=False, reads=True, writes=True):
                             (self.old_name, new_name))
         scope_start, scope_end = self._get_scope_offset()
         finder = occurrences.create_finder(
-            self.pycore, self.old_name, self.old_pyname,
+            self.project, self.old_name, self.old_pyname,
             imports=False, only_calls=only_calls)
         new_contents = rename_in_module(
             finder, new_name, pymodule=self.pymodule, replace_primary=True,
@@ -181,8 +183,9 @@ def get_changes(self, new_name, only_calls=False, reads=True, writes=True):
         return changes
 
 
-def rename_in_module(occurrences_finder, new_name, resource=None, pymodule=None,
-                     replace_primary=False, region=None, reads=True, writes=True):
+def rename_in_module(occurrences_finder, new_name, resource=None,
+                     pymodule=None, replace_primary=False, region=None,
+                     reads=True, writes=True):
     """Returns the changed source or `None` if there is no changes"""
     if resource is not None:
         source_code = resource.read()
@@ -203,6 +206,7 @@ def rename_in_module(occurrences_finder, new_name, resource=None, pymodule=None,
             change_collector.add_change(start, end, new_name)
     return change_collector.get_changed()
 
+
 def _is_local(pyname):
     module, lineno = pyname.get_definition_location()
     if lineno is None:
@@ -212,5 +216,5 @@ def _is_local(pyname):
        scope.get_kind() in ('Function', 'Class'):
         scope = scope.parent
     return scope.get_kind() == 'Function' and \
-           pyname in scope.get_names().values() and \
-           isinstance(pyname, pynames.AssignedName)
+        pyname in scope.get_names().values() and \
+        isinstance(pyname, pynames.AssignedName)
diff --git a/pymode/libs2/rope/refactor/restructure.py b/pymode/libs2/rope/refactor/restructure.py
index 1573c2fe..98a11e3d 100644
--- a/pymode/libs2/rope/refactor/restructure.py
+++ b/pymode/libs2/rope/refactor/restructure.py
@@ -1,6 +1,7 @@
 import warnings
 
 from rope.base import change, taskhandle, builtins, ast, codeanalyze
+from rope.base import libutils
 from rope.refactor import patchedast, similarfinder, sourceutils
 from rope.refactor.importutils import module_imports
 
@@ -52,7 +53,6 @@ class Restructure(object):
        from rope.contrib import generate
 
       args
-       pycore: type=rope.base.pycore.PyCore
        project: type=rope.base.project.Project
 
     Example #4::
@@ -79,7 +79,7 @@ def __init__(self, project, pattern, goal, args=None,
         See class pydoc for more info about the arguments.
 
         """
-        self.pycore = project.pycore
+        self.project = project
         self.pattern = pattern
         self.goal = goal
         self.args = args
@@ -132,13 +132,13 @@ def get_changes(self, checks=None, imports=None, resources=None,
                                    (self.pattern, self.goal))
         if resources is not None:
             files = [resource for resource in resources
-                     if self.pycore.is_python_file(resource)]
+                     if libutils.is_python_file(self.project, resource)]
         else:
-            files = self.pycore.get_python_files()
+            files = self.project.get_python_files()
         job_set = task_handle.create_jobset('Collecting Changes', len(files))
         for resource in files:
             job_set.started_job(resource.path)
-            pymodule = self.pycore.resource_to_pyobject(resource)
+            pymodule = self.project.get_pymodule(resource)
             finder = similarfinder.SimilarFinder(pymodule,
                                                  wildcards=self.wildcards)
             matches = list(finder.get_matches(self.pattern, self.args))
@@ -161,16 +161,16 @@ def _add_imports(self, resource, source, imports):
         if not imports:
             return source
         import_infos = self._get_import_infos(resource, imports)
-        pymodule = self.pycore.get_string_module(source, resource)
-        imports = module_imports.ModuleImports(self.pycore, pymodule)
+        pymodule = libutils.get_string_module(self.project, source, resource)
+        imports = module_imports.ModuleImports(self.project, pymodule)
         for import_info in import_infos:
             imports.add_import(import_info)
         return imports.get_changed_source()
 
     def _get_import_infos(self, resource, imports):
-        pymodule = self.pycore.get_string_module('\n'.join(imports),
-                                                 resource)
-        imports = module_imports.ModuleImports(self.pycore, pymodule)
+        pymodule = libutils.get_string_module(
+            self.project, '\n'.join(imports), resource)
+        imports = module_imports.ModuleImports(self.project, pymodule)
         return [imports.import_info
                 for imports in imports.imports]
 
@@ -183,7 +183,7 @@ def make_checks(self, string_checks):
         checks = {}
         for key, value in string_checks.items():
             is_pyname = not key.endswith('.object') and \
-                        not key.endswith('.type')
+                not key.endswith('.type')
             evaluated = self._evaluate(value, is_pyname=is_pyname)
             if evaluated is not None:
                 checks[key] = evaluated
@@ -198,7 +198,7 @@ def get_attribute(self, name):
                     return builtins.builtins[name]
             pyobject = _BuiltinsStub()
         else:
-            pyobject = self.pycore.get_module(attributes[0])
+            pyobject = self.project.get_module(attributes[0])
         for attribute in attributes[1:]:
             pyname = pyobject[attribute]
             if pyname is None:
diff --git a/pymode/libs2/rope/refactor/similarfinder.py b/pymode/libs2/rope/refactor/similarfinder.py
index fc71abfa..f1a7d42d 100644
--- a/pymode/libs2/rope/refactor/similarfinder.py
+++ b/pymode/libs2/rope/refactor/similarfinder.py
@@ -2,9 +2,11 @@
 import re
 
 import rope.refactor.wildcards
-from rope.base import codeanalyze, evaluate, exceptions, ast, builtins
-from rope.refactor import (patchedast, sourceutils, occurrences,
-                           wildcards, importutils)
+from rope.base import libutils
+from rope.base import codeanalyze, exceptions, ast, builtins
+from rope.refactor import (patchedast, wildcards)
+
+from rope.refactor.patchedast import MismatchedTokenError
 
 
 class BadNameInCheckError(exceptions.RefactoringError):
@@ -22,8 +24,12 @@ class SimilarFinder(object):
     def __init__(self, pymodule, wildcards=None):
         """Construct a SimilarFinder"""
         self.source = pymodule.source_code
-        self.raw_finder = RawSimilarFinder(
-            pymodule.source_code, pymodule.get_ast(), self._does_match)
+        try:
+            self.raw_finder = RawSimilarFinder(
+                pymodule.source_code, pymodule.get_ast(), self._does_match)
+        except MismatchedTokenError:
+            print "in file %s" % pymodule.resource.path
+            raise
         self.pymodule = pymodule
         if wildcards is None:
             self.wildcards = {}
@@ -41,7 +47,7 @@ def get_matches(self, code, args={}, start=0, end=None):
         if 'skip' in args.get('', {}):
             resource, region = args['']['skip']
             if resource == self.pymodule.get_resource():
-                skip_region = region            
+                skip_region = region
         return self.raw_finder.get_matches(code, start=start, end=end,
                                            skip=skip_region)
 
@@ -97,7 +103,7 @@ def get_matches(self, code, start=0, end=None, skip=None):
             if start <= match_start and match_end <= end:
                 if skip is not None and (skip[0] < match_end and
                                          skip[1] > match_start):
-                    continue                    
+                    continue
                 yield match
 
     def _get_matched_asts(self, code):
@@ -175,8 +181,8 @@ def __check_stmt_list(self, nodes):
 
     def _match_nodes(self, expected, node, mapping):
         if isinstance(expected, ast.Name):
-           if self.ropevar.is_var(expected.id):
-               return self._match_wildcard(expected, node, mapping)
+            if self.ropevar.is_var(expected.id):
+                return self._match_wildcard(expected, node, mapping)
         if not isinstance(expected, ast.AST):
             return expected == node
         if expected.__class__ != node.__class__:
@@ -296,8 +302,8 @@ def substitute(self, mapping):
     def _get_pattern(cls):
         if cls._match_pattern is None:
             pattern = codeanalyze.get_comment_pattern() + '|' + \
-                      codeanalyze.get_string_pattern() + '|' + \
-                      r'(?P<name>\$\{[^\s\$\}]*\})'
+                codeanalyze.get_string_pattern() + '|' + \
+                r'(?P<name>\$\{[^\s\$\}]*\})'
             cls._match_pattern = re.compile(pattern)
         return cls._match_pattern
 
@@ -339,6 +345,7 @@ def _is_var(self, name):
 def make_pattern(code, variables):
     variables = set(variables)
     collector = codeanalyze.ChangeCollector(code)
+
     def does_match(node, name):
         return isinstance(node, ast.Name) and node.id == name
     finder = RawSimilarFinder(code, does_match=does_match)
@@ -352,11 +359,12 @@ def does_match(node, name):
 
 def _pydefined_to_str(pydefined):
     address = []
-    if isinstance(pydefined, (builtins.BuiltinClass, builtins.BuiltinFunction)):
+    if isinstance(pydefined,
+                  (builtins.BuiltinClass, builtins.BuiltinFunction)):
         return '__builtins__.' + pydefined.get_name()
     else:
         while pydefined.parent is not None:
             address.insert(0, pydefined.get_name())
             pydefined = pydefined.parent
-        module_name = pydefined.pycore.modname(pydefined.resource)
+        module_name = libutils.modname(pydefined.resource)
     return '.'.join(module_name.split('.') + address)
diff --git a/pymode/libs2/rope/refactor/sourceutils.py b/pymode/libs2/rope/refactor/sourceutils.py
index f64213db..9b842906 100644
--- a/pymode/libs2/rope/refactor/sourceutils.py
+++ b/pymode/libs2/rope/refactor/sourceutils.py
@@ -1,4 +1,4 @@
-from rope.base import ast, codeanalyze
+from rope.base import codeanalyze
 
 
 def get_indents(lines, lineno):
@@ -48,7 +48,7 @@ def add_methods(pymodule, class_scope, methods_sources):
     methods = '\n\n' + '\n\n'.join(methods_sources)
     indented_methods = fix_indentation(
         methods, get_indents(lines, class_scope.get_start()) +
-        get_indent(pymodule.pycore))
+        get_indent(pymodule.pycore.project))
     result = []
     result.append(source_code[:insertion_offset])
     result.append(indented_methods)
@@ -58,7 +58,7 @@ def add_methods(pymodule, class_scope, methods_sources):
 
 def get_body(pyfunction):
     """Return unindented function body"""
-    scope = pyfunction.get_scope()
+    # FIXME scope = pyfunction.get_scope()
     pymodule = pyfunction.get_module()
     start, end = get_body_region(pyfunction)
     return fix_indentation(pymodule.source_code[start:end], 0)
@@ -87,6 +87,5 @@ def get_body_region(defined):
     return start, end
 
 
-def get_indent(pycore):
-    project = pycore.project
+def get_indent(project):
     return project.prefs.get('indent_size', 4)
diff --git a/pymode/libs2/rope/refactor/suites.py b/pymode/libs2/rope/refactor/suites.py
index d955c819..4f9a8c71 100644
--- a/pymode/libs2/rope/refactor/suites.py
+++ b/pymode/libs2/rope/refactor/suites.py
@@ -14,6 +14,7 @@ def find_visible_for_suite(root, lines):
     line2 = find_visible_for_suite(root, lines[1:])
     suite1 = root.find_suite(line1)
     suite2 = root.find_suite(line2)
+
     def valid(suite):
         return suite is not None and not suite.ignored
     if valid(suite1) and not valid(suite2):
diff --git a/pymode/libs2/rope/refactor/topackage.py b/pymode/libs2/rope/refactor/topackage.py
index b7113979..f36a6d52 100644
--- a/pymode/libs2/rope/refactor/topackage.py
+++ b/pymode/libs2/rope/refactor/topackage.py
@@ -1,12 +1,12 @@
 import rope.refactor.importutils
-from rope.base.change import ChangeSet, ChangeContents, MoveResource, CreateFolder
+from rope.base.change import ChangeSet, ChangeContents, MoveResource, \
+    CreateFolder
 
 
 class ModuleToPackage(object):
 
     def __init__(self, project, resource):
         self.project = project
-        self.pycore = project.pycore
         self.resource = resource
 
     def get_changes(self):
@@ -27,6 +27,6 @@ def get_changes(self):
         return changes
 
     def _transform_relatives_to_absolute(self, resource):
-        pymodule = self.pycore.resource_to_pyobject(resource)
-        import_tools = rope.refactor.importutils.ImportTools(self.pycore)
+        pymodule = self.project.get_pymodule(resource)
+        import_tools = rope.refactor.importutils.ImportTools(self.project)
         return import_tools.relatives_to_absolutes(pymodule)
diff --git a/pymode/libs2/rope/refactor/usefunction.py b/pymode/libs2/rope/refactor/usefunction.py
index b0621525..85896a98 100644
--- a/pymode/libs2/rope/refactor/usefunction.py
+++ b/pymode/libs2/rope/refactor/usefunction.py
@@ -1,6 +1,7 @@
 from rope.base import (change, taskhandle, evaluate,
                        exceptions, pyobjects, pynames, ast)
-from rope.refactor import restructure, sourceutils, similarfinder, importutils
+from rope.base import libutils
+from rope.refactor import restructure, sourceutils, similarfinder
 
 
 class UseFunction(object):
@@ -9,7 +10,7 @@ class UseFunction(object):
     def __init__(self, project, resource, offset):
         self.project = project
         self.offset = offset
-        this_pymodule = project.pycore.resource_to_pyobject(resource)
+        this_pymodule = project.get_pymodule(resource)
         pyname = evaluate.eval_location(this_pymodule, offset)
         if pyname is None:
             raise exceptions.RefactoringError('Unresolvable name selected')
@@ -37,7 +38,7 @@ def _check_returns(self):
     def get_changes(self, resources=None,
                     task_handle=taskhandle.NullTaskHandle()):
         if resources is None:
-            resources = self.project.pycore.get_python_files()
+            resources = self.project.get_python_files()
         changes = change.ChangeSet('Using function <%s>' %
                                    self.pyfunction.get_name())
         if self.resource in resources:
@@ -55,7 +56,6 @@ def get_function_name(self):
         return self.pyfunction.get_name()
 
     def _restructure(self, resources, task_handle, others=True):
-        body = self._get_body()
         pattern = self._make_pattern()
         goal = self._make_goal(import_=others)
         imports = None
@@ -75,7 +75,7 @@ def _find_temps(self):
         return find_temps(self.project, self._get_body())
 
     def _module_name(self):
-        return self.project.pycore.modname(self.resource)
+        return libutils.modname(self.resource)
 
     def _make_pattern(self):
         params = self.pyfunction.get_param_names()
@@ -123,7 +123,7 @@ def _is_expression(self):
 
 def find_temps(project, code):
     code = 'def f():\n' + sourceutils.indent_lines(code, 4)
-    pymodule = project.pycore.get_string_module(code)
+    pymodule = libutils.get_string_module(project, code)
     result = []
     function_scope = pymodule.get_scope().get_scopes()[0]
     for name, pyname in function_scope.get_names().items():
@@ -135,16 +135,19 @@ def find_temps(project, code):
 def _returns_last(node):
     return node.body and isinstance(node.body[-1], ast.Return)
 
+
 def _yield_count(node):
     visitor = _ReturnOrYieldFinder()
     visitor.start_walking(node)
     return visitor.yields
 
+
 def _return_count(node):
     visitor = _ReturnOrYieldFinder()
     visitor.start_walking(node)
     return visitor.returns
 
+
 class _ReturnOrYieldFinder(object):
 
     def __init__(self):
diff --git a/pymode/libs2/rope/refactor/wildcards.py b/pymode/libs2/rope/refactor/wildcards.py
index 6c487a2a..90040c79 100644
--- a/pymode/libs2/rope/refactor/wildcards.py
+++ b/pymode/libs2/rope/refactor/wildcards.py
@@ -100,7 +100,7 @@ def __call__(self, pymodule, node):
         pyname = self._evaluate_node(pymodule, node)
         if pyname is None or self.expected is None:
             return self.unsure
-        if self._unsure_pyname(pyname, unbound=self.kind=='name'):
+        if self._unsure_pyname(pyname, unbound=self.kind == 'name'):
             return True
         if self.kind == 'name':
             return self._same_pyname(self.expected, pyname)
@@ -161,13 +161,15 @@ def _evaluate(self, code):
             class _BuiltinsStub(object):
                 def get_attribute(self, name):
                     return builtins.builtins[name]
+
                 def __getitem__(self, name):
                     return builtins.builtins[name]
+
                 def __contains__(self, name):
                     return name in builtins.builtins
             pyobject = _BuiltinsStub()
         else:
-            pyobject = self.project.pycore.get_module(attributes[0])
+            pyobject = self.project.get_module(attributes[0])
         for attribute in attributes[1:]:
             pyname = pyobject[attribute]
             if pyname is None:
diff --git a/pymode/libs3/rope/__init__.py b/pymode/libs3/rope/__init__.py
index 451ebe3a..a936fe29 100644
--- a/pymode/libs3/rope/__init__.py
+++ b/pymode/libs3/rope/__init__.py
@@ -1,7 +1,7 @@
 """rope, a python refactoring library"""
 
 INFO = __doc__
-VERSION = '0.9.4'
+VERSION = '0.9.4-1'
 COPYRIGHT = """\
 Copyright (C) 2006-2010 Ali Gholami Rudi
 Copyright (C) 2009-2010 Anton Gritsay
diff --git a/pymode/libs3/rope/refactor/patchedast.py b/pymode/libs3/rope/refactor/patchedast.py
index 034dac35..042b33dd 100644
--- a/pymode/libs3/rope/refactor/patchedast.py
+++ b/pymode/libs3/rope/refactor/patchedast.py
@@ -1,7 +1,6 @@
 import collections
 import re
 import warnings
-import sys
 
 from rope.base import ast, codeanalyze, exceptions
 
@@ -564,19 +563,6 @@ def _TryExcept(self, node):
             children.extend(['else', ':'])
             children.extend(node.orelse)
         self._handle(node, children)
-        
-    def _Try(self, node):
-        children = ['try', ':']
-        children.extend(node.body)
-        children.extend(node.handlers)
-        if node.orelse:
-            children.extend(['else', ':'])
-            children.extend(node.orelse)
-        if node.finalbody:
-            children.extend(['finally', ':'])
-            children.extend(node.finalbody)
-            
-        self._handle(node, children)
 
     def _ExceptHandler(self, node):
         self._excepthandler(node)
@@ -618,15 +604,9 @@ def _While(self, node):
         self._handle(node, children)
 
     def _With(self, node):
-        children = []
-        if (sys.version_info[1] < 3):
-            children = ['with', node.context_expr]
-            if node.optional_vars:
-                children.extend(['as', node.optional_vars])
-        else:
-            children = ['with', node.items[0].context_expr]
-            if node.items[0].optional_vars:
-                children.extend(['as', node.items[0].optional_vars])
+        children = ['with', node.context_expr]
+        if node.optional_vars:
+            children.extend(['as', node.optional_vars])
         children.append(':')
         children.extend(node.body)
         self._handle(node, children)
diff --git a/pymode/libs3/rope/refactor/suites.py b/pymode/libs3/rope/refactor/suites.py
index 041c06a2..d955c819 100644
--- a/pymode/libs3/rope/refactor/suites.py
+++ b/pymode/libs3/rope/refactor/suites.py
@@ -128,15 +128,6 @@ def _TryExcept(self, node):
         if node.orelse:
             self.suites.append(Suite(node.orelse, node.lineno, self.suite))
 
-    def _Try(self, node):
-        self.suites.append(Suite(node.body, node.lineno, self.suite))
-        for handler in node.handlers:
-            self.suites.append(Suite(handler.body, node.lineno, self.suite))
-        if node.orelse:
-            self.suites.append(Suite(node.orelse, node.lineno, self.suite))
-        if node.finalbody:
-            self.suites.append(Suite(node.finalbody, node.lineno, self.suite))
-
     def _add_if_like_node(self, node):
         self.suites.append(Suite(node.body, node.lineno, self.suite))
         if node.orelse:

From ed82ecc64e5e07f25aa833492ff49f4afd5f6af1 Mon Sep 17 00:00:00 2001
From: Tyler Fenby <tylerfenby@gmail.com>
Date: Sun, 21 Dec 2014 17:40:35 -0500
Subject: [PATCH 03/10] Update AUTHORS

---
 AUTHORS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/AUTHORS b/AUTHORS
index c09fe72d..ef6d0bbc 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -47,3 +47,4 @@ Contributors:
 * lee (loyalpartner);
 * nixon;
 * tramchamploo;
+* Tyler Fenby (https://github.com/TFenby)

From 5b79d48f9d0476ba326987f84fc676e61a5a6465 Mon Sep 17 00:00:00 2001
From: Samir Benmendil <samir.benmendil@gmail.com>
Date: Sun, 22 Feb 2015 14:58:29 +0000
Subject: [PATCH 04/10] Don't skip a line when the first docstring contains
 text

---
 autoload/pymode/folding.vim | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/autoload/pymode/folding.vim b/autoload/pymode/folding.vim
index 0ae61dd4..e54ef1bf 100644
--- a/autoload/pymode/folding.vim
+++ b/autoload/pymode/folding.vim
@@ -18,7 +18,7 @@ fun! pymode#folding#text() " {{{
     while getline(fs) !~ s:def_regex && getline(fs) !~ s:doc_begin_regex
         let fs = nextnonblank(fs + 1)
     endwhile
-    if getline(fs) =~ s:doc_begin_regex
+    if getline(fs) =~ s:doc_end_regex && getline(fs) =~ s:doc_begin_regex
         let fs = nextnonblank(fs + 1)
     endif
     let line = getline(fs)

From 3d0c1d6f2a9228c973f65cdca47cacf2d5d49906 Mon Sep 17 00:00:00 2001
From: Dylan Semler <dsem@users.noreply.github.com>
Date: Sun, 8 Mar 2015 08:26:23 -0400
Subject: [PATCH 05/10] fix placement of pymode_options help description

---
 doc/pymode.txt | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/pymode.txt b/doc/pymode.txt
index 33968b3e..36ce040e 100644
--- a/doc/pymode.txt
+++ b/doc/pymode.txt
@@ -98,10 +98,6 @@ Setup default python options                                *'g:pymode_options'*
 >
     let g:pymode_options = 1
 
-Setup max line length                       *'g:pymode_options_max_line_length'*
->
-    let g:pymode_options_max_line_length = 79
-
 If this option is set to 1, pymode will enable the following options for
 python buffers: >
 
@@ -115,6 +111,10 @@ python buffers: >
     setlocal commentstring=#%s
     setlocal define=^\s*\\(def\\\\|class\\)
 
+Setup max line length                       *'g:pymode_options_max_line_length'*
+>
+    let g:pymode_options_max_line_length = 79
+
 Enable colorcolumn display at max_line_length   *'g:pymode_options_colorcolumn'*
 >
     let g:pymode_options_colorcolumn = 1

From 5443b41dde7c98f854cc03ec83523d9a4a1df035 Mon Sep 17 00:00:00 2001
From: Jacob Niehus <jacob.niehus@gmail.com>
Date: Fri, 3 Apr 2015 11:33:29 -0700
Subject: [PATCH 06/10] Skip doctest regions when searching for open pairs

---
 autoload/pymode/indent.vim | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/autoload/pymode/indent.vim b/autoload/pymode/indent.vim
index d8e9f148..efd41f29 100644
--- a/autoload/pymode/indent.vim
+++ b/autoload/pymode/indent.vim
@@ -110,7 +110,7 @@ function! s:SearchParensPair() " {{{
     " Skip strings and comments and don't look too far
     let skip = "line('.') < " . (line - 50) . " ? dummy :" .
                 \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? ' .
-                \ '"string\\|comment"'
+                \ '"string\\|comment\\|doctest"'
 
     " Search for parentheses
     call cursor(line, col)

From ddfeca242d3070581f093884a0a175ac69dc033a Mon Sep 17 00:00:00 2001
From: "John L. Villalovos" <john@sodarock.com>
Date: Wed, 1 Apr 2015 14:34:06 -0700
Subject: [PATCH 07/10] Use 'https:' instead of 'git:' in documentation

For people behind a proxy server it is difficult to 'git clone' using
'git:'.  While 'https:' is universally usable.
---
 README.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.rst b/README.rst
index b6f9bb69..b1da7774 100644
--- a/README.rst
+++ b/README.rst
@@ -62,7 +62,7 @@ Using pathogen (recommended)
 
     % cd ~/.vim
     % mkdir -p bundle && cd bundle
-    % git clone git://github.com/klen/python-mode.git
+    % git clone https://github.com/klen/python-mode.git
 
 - Enable `pathogen <https://github.com/tpope/vim-pathogen>`_
   in your ``~/.vimrc``: ::
@@ -81,7 +81,7 @@ Manually
 --------
 ::
 
-    % git clone git://github.com/klen/python-mode.git
+    % git clone https://github.com/klen/python-mode.git
     % cd python-mode
     % cp -R * ~/.vim
 

From 6fb4f594c6fc9eb0abc098211736764b3aa0bdd6 Mon Sep 17 00:00:00 2001
From: Dimitrios Semitsoglou-Tsiapos <dsemitso@cern.ch>
Date: Sat, 2 May 2015 10:51:25 +0200
Subject: [PATCH 08/10] Do not add rope to sys.path with pymode_rope=0

(Closes #343)
---
 ftplugin/python/pymode.vim |  2 +-
 pymode/utils.py            | 23 +++++++++++++++--------
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/ftplugin/python/pymode.vim b/ftplugin/python/pymode.vim
index 3a19d286..3feb7c1a 100644
--- a/ftplugin/python/pymode.vim
+++ b/ftplugin/python/pymode.vim
@@ -10,7 +10,7 @@ if !pymode#default('g:pymode_init', 1)
     call pymode#virtualenv#init()
     call pymode#breakpoint#init()
     PymodePython from pymode.utils import patch_paths
-    PymodePython patch_paths()
+    PymodePython patch_paths(rope=vim.eval('g:pymode_rope'))
 endif
 
 command! -buffer -nargs=1 PymodeVirtualenv call pymode#virtualenv#activate(<args>)
diff --git a/pymode/utils.py b/pymode/utils.py
index 79061857..ee4fdb29 100644
--- a/pymode/utils.py
+++ b/pymode/utils.py
@@ -31,11 +31,18 @@ def silence_stderr():
             sys.stderr = stderr
 
 
-def patch_paths():
-    """ Function description. """
-    sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'libs'))
-
-    if PY2:
-        sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'libs2'))
-    else:
-        sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'libs3'))
+def patch_paths(pylama=True, rope=True):
+    """Patch `sys.path` with the libraries that we wish to use.
+
+    :param pylama: Add pylama library to `sys.path`
+    :param rope: Add rope library to `sys.path`
+    """
+    if pylama:
+        sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'libs',))
+
+    print rope
+    if rope:
+        if PY2:
+            sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'libs2'))
+        else:
+            sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'libs3'))

From d5ad59ac26ad1c0c74edfcb85312cd3d577a4559 Mon Sep 17 00:00:00 2001
From: Dimitrios Semitsoglou-Tsiapos <dsemitso@cern.ch>
Date: Sat, 2 May 2015 11:52:32 +0200
Subject: [PATCH 09/10] loclist extending failure when column is missing

As suggested by Brandon Sandrowicz <brandon@sandrowicz.org>
---
 pymode/lint.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pymode/lint.py b/pymode/lint.py
index 5053f7fa..1ebc3746 100644
--- a/pymode/lint.py
+++ b/pymode/lint.py
@@ -67,6 +67,8 @@ def __sort(e):
 
     for e in errors:
         e._info['bufnr'] = env.curbuf.number
+        if e._info['col'] is None:
+            e._info['col'] = 1
 
     env.run('g:PymodeLocList.current().extend', [e._info for e in errors])
 

From 1e11b7411648ac16b7a0b79497c57d5769645ef4 Mon Sep 17 00:00:00 2001
From: Dimitrios Semitsoglou-Tsiapos <dsemitso@cern.ch>
Date: Sat, 2 May 2015 14:27:15 +0200
Subject: [PATCH 10/10] upgrade pylama

---
 pymode/libs/pylama/__init__.py                |    6 +-
 pymode/libs/pylama/{tasks.py => async.py}     |   50 +-
 pymode/libs/pylama/config.py                  |   42 +-
 pymode/libs/pylama/core.py                    |   63 +-
 pymode/libs/pylama/errors.py                  |   45 +-
 pymode/libs/pylama/hook.py                    |   15 +-
 .../libs/pylama/lint/pylama_pep257/pep257.py  |  500 ++++++--
 pymode/libs/pylama/lint/pylama_pep8/pep8.py   |  260 +++-
 .../pylama/lint/pylama_pyflakes/__init__.py   |   16 +-
 .../lint/pylama_pyflakes/pyflakes/checker.py  |   28 +-
 .../lint/pylama_pyflakes/pyflakes/messages.py |   15 +-
 .../pylama/lint/pylama_pylint/__init__.py     |   17 -
 .../lint/pylama_pylint/astroid/__init__.py    |  118 --
 .../lint/pylama_pylint/astroid/__pkginfo__.py |   48 -
 .../lint/pylama_pylint/astroid/as_string.py   |  496 -------
 .../lint/pylama_pylint/astroid/bases.py       |  618 ---------
 .../lint/pylama_pylint/astroid/brain/py2gi.py |  159 ---
 .../astroid/brain/py2mechanize.py             |   20 -
 .../pylama_pylint/astroid/brain/py2qt4.py     |   25 -
 .../pylama_pylint/astroid/brain/py2stdlib.py  |  252 ----
 .../lint/pylama_pylint/astroid/builder.py     |  238 ----
 .../lint/pylama_pylint/astroid/exceptions.py  |   51 -
 .../lint/pylama_pylint/astroid/inference.py   |  393 ------
 .../lint/pylama_pylint/astroid/manager.py     |  336 -----
 .../lint/pylama_pylint/astroid/mixins.py      |  122 --
 .../pylama_pylint/astroid/node_classes.py     |  928 --------------
 .../lint/pylama_pylint/astroid/nodes.py       |   73 --
 .../lint/pylama_pylint/astroid/protocols.py   |  322 -----
 .../pylama_pylint/astroid/raw_building.py     |  361 ------
 .../lint/pylama_pylint/astroid/rebuilder.py   |  954 --------------
 .../pylama_pylint/astroid/scoped_nodes.py     | 1118 ----------------
 .../lint/pylama_pylint/astroid/utils.py       |  236 ----
 .../lint/pylama_pylint/logilab/__init__.py    |    0
 .../pylama_pylint/logilab/common/__init__.py  |  171 ---
 .../logilab/common/__pkginfo__.py             |   53 -
 .../pylama_pylint/logilab/common/changelog.py |  236 ----
 .../pylama_pylint/logilab/common/compat.py    |  243 ----
 .../logilab/common/configuration.py           | 1094 ----------------
 .../logilab/common/decorators.py              |  281 ----
 .../logilab/common/deprecation.py             |  188 ---
 .../pylama_pylint/logilab/common/graph.py     |  276 ----
 .../pylama_pylint/logilab/common/interface.py |   71 -
 .../pylama_pylint/logilab/common/modutils.py  |  695 ----------
 .../pylama_pylint/logilab/common/optik_ext.py |  391 ------
 .../pylama_pylint/logilab/common/textutils.py |  534 --------
 .../lint/pylama_pylint/logilab/common/tree.py |  369 ------
 .../logilab/common/ureports/__init__.py       |  174 ---
 .../logilab/common/ureports/docbook_writer.py |  139 --
 .../logilab/common/ureports/html_writer.py    |  131 --
 .../logilab/common/ureports/nodes.py          |  201 ---
 .../logilab/common/ureports/text_writer.py    |  140 --
 .../pylama_pylint/logilab/common/visitor.py   |  107 --
 pymode/libs/pylama/lint/pylama_pylint/main.py |  113 --
 .../libs/pylama/lint/pylama_pylint/pylint.rc  |   23 -
 .../lint/pylama_pylint/pylint/__init__.py     |   44 -
 .../lint/pylama_pylint/pylint/__pkginfo__.py  |   74 --
 .../pylama_pylint/pylint/checkers/__init__.py |  145 ---
 .../pylama_pylint/pylint/checkers/base.py     | 1141 -----------------
 .../pylama_pylint/pylint/checkers/classes.py  |  792 ------------
 .../pylint/checkers/design_analysis.py        |  367 ------
 .../pylint/checkers/exceptions.py             |  306 -----
 .../pylama_pylint/pylint/checkers/format.py   |  943 --------------
 .../pylama_pylint/pylint/checkers/imports.py  |  394 ------
 .../pylama_pylint/pylint/checkers/logging.py  |  213 ---
 .../pylama_pylint/pylint/checkers/misc.py     |   90 --
 .../pylama_pylint/pylint/checkers/newstyle.py |  151 ---
 .../pylint/checkers/raw_metrics.py            |  129 --
 .../pylama_pylint/pylint/checkers/similar.py  |  365 ------
 .../pylama_pylint/pylint/checkers/stdlib.py   |   69 -
 .../pylama_pylint/pylint/checkers/strings.py  |  304 -----
 .../pylint/checkers/typecheck.py              |  451 -------
 .../pylama_pylint/pylint/checkers/utils.py    |  416 ------
 .../pylint/checkers/variables.py              |  741 -----------
 .../lint/pylama_pylint/pylint/config.py       |  156 ---
 .../lint/pylama_pylint/pylint/interfaces.py   |   72 --
 .../pylama/lint/pylama_pylint/pylint/lint.py  | 1106 ----------------
 .../pylint/reporters/__init__.py              |  138 --
 .../pylint/reporters/guireporter.py           |   28 -
 .../pylama_pylint/pylint/reporters/html.py    |   70 -
 .../pylama_pylint/pylint/reporters/text.py    |  143 ---
 .../pylama/lint/pylama_pylint/pylint/utils.py |  744 -----------
 pymode/libs/pylama/main.py                    |   93 +-
 pymode/libs/pylama/pytest.py                  |    4 +-
 83 files changed, 814 insertions(+), 22430 deletions(-)
 rename pymode/libs/pylama/{tasks.py => async.py} (56%)
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/__init__.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/__init__.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/__pkginfo__.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/as_string.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/bases.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2gi.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2mechanize.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2qt4.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2stdlib.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/builder.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/exceptions.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/inference.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/manager.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/mixins.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/node_classes.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/nodes.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/protocols.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/raw_building.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/rebuilder.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/scoped_nodes.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/astroid/utils.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/__init__.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/__init__.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/__pkginfo__.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/changelog.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/compat.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/configuration.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/decorators.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/deprecation.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/graph.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/interface.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/modutils.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/optik_ext.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/textutils.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/tree.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/__init__.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/docbook_writer.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/html_writer.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/nodes.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/text_writer.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/logilab/common/visitor.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/main.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint.rc
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/__init__.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/__pkginfo__.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/__init__.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/base.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/classes.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/design_analysis.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/exceptions.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/format.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/imports.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/logging.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/misc.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/newstyle.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/raw_metrics.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/similar.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/stdlib.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/strings.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/typecheck.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/utils.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/variables.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/config.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/interfaces.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/lint.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/__init__.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/guireporter.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/html.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/text.py
 delete mode 100644 pymode/libs/pylama/lint/pylama_pylint/pylint/utils.py

diff --git a/pymode/libs/pylama/__init__.py b/pymode/libs/pylama/__init__.py
index 1576bfd2..380b3d89 100644
--- a/pymode/libs/pylama/__init__.py
+++ b/pymode/libs/pylama/__init__.py
@@ -1,11 +1,11 @@
-""" Code audit tool for python.
+"""
+Code audit tool for python.
 
 :copyright: 2013 by Kirill Klenov.
 :license: BSD, see LICENSE for more details.
-
 """
 
-__version__ = "5.0.5"
+__version__ = "6.3.1"
 __project__ = "pylama"
 __author__ = "Kirill Klenov <horneds@gmail.com>"
 __license__ = "GNU LGPL"
diff --git a/pymode/libs/pylama/tasks.py b/pymode/libs/pylama/async.py
similarity index 56%
rename from pymode/libs/pylama/tasks.py
rename to pymode/libs/pylama/async.py
index 69881e1e..a58aaaa7 100644
--- a/pymode/libs/pylama/tasks.py
+++ b/pymode/libs/pylama/async.py
@@ -1,15 +1,16 @@
-""" Support for asyncronious code checking. """
+""" Support for asyncronious checking. """
 
 import logging
 import threading
-from os import path as op
+
+from .core import run
+
+
 try:
     import Queue
 except ImportError:
     import queue as Queue
 
-from .core import run
-
 
 try:
     import multiprocessing
@@ -36,41 +37,33 @@ def run(self):
         """ Run tasks from queue. """
         while True:
             path, params = self.path_queue.get()
-            errors = check_path(path, **params)
+            errors = run(path, **params)
             self.result_queue.put(errors)
             self.path_queue.task_done()
 
 
-def async_check_files(paths, options, rootpath=None):
-    """ Check paths.
+def check_async(paths, options, rootdir=None):
+    """ Check given paths asynchronously.
 
     :return list: list of errors
 
     """
-    errors = []
-
-    # Disable async if pylint enabled
-    async = options.async and 'pylint' not in options.linters
-
-    if not async:
-        for path in paths:
-            errors += check_path(path, options=options, rootpath=rootpath)
-        return errors
-
     LOGGER.info('Async code checking is enabled.')
     path_queue = Queue.Queue()
     result_queue = Queue.Queue()
 
-    for _ in range(CPU_COUNT):
+    for num in range(CPU_COUNT):
         worker = Worker(path_queue, result_queue)
         worker.setDaemon(True)
+        LOGGER.info('Start worker #%s', (num + 1))
         worker.start()
 
     for path in paths:
-        path_queue.put((path, dict(options=options, rootpath=rootpath)))
+        path_queue.put((path, dict(options=options, rootdir=rootdir)))
 
     path_queue.join()
 
+    errors = []
     while True:
         try:
             errors += result_queue.get(False)
@@ -80,23 +73,4 @@ def async_check_files(paths, options, rootpath=None):
     return errors
 
 
-def check_path(path, options=None, rootpath=None, code=None):
-    """ Check path.
-
-    :return list: list of errors
-
-    """
-    LOGGER.info("Parse file: %s", path)
-
-    rootpath = rootpath or '.'
-    errors = []
-    for error in run(path, code, options):
-        try:
-            error._info['rel'] = op.relpath(error.filename, rootpath)
-            errors.append(error)
-        except KeyError:
-            continue
-
-    return errors
-
 # pylama:ignore=W0212
diff --git a/pymode/libs/pylama/config.py b/pymode/libs/pylama/config.py
index 881e930a..cb3dc492 100644
--- a/pymode/libs/pylama/config.py
+++ b/pymode/libs/pylama/config.py
@@ -1,8 +1,8 @@
 """ Parse arguments from command line and configuration files. """
 import fnmatch
-import sys
 import os
-from re import compile as re
+import sys
+import re
 
 import logging
 from argparse import ArgumentParser
@@ -11,6 +11,17 @@
 from .libs.inirama import Namespace
 from .lint.extensions import LINTERS
 
+#: A default checkers
+DEFAULT_LINTERS = 'pep8', 'pyflakes', 'mccabe'
+
+CURDIR = os.getcwd()
+CONFIG_FILES = 'pylama.ini', 'setup.cfg', 'tox.ini', 'pytest.ini'
+
+#: The skip pattern
+SKIP_PATTERN = re.compile(r'# *noqa\b', re.I).search
+
+# Parse a modelines
+MODELINE_RE = re.compile(r'^\s*#\s+(?:pylama:)\s*((?:[\w_]*=[^:\n\s]+:?)+)', re.I | re.M)
 
 # Setup a logger
 LOGGER = logging.getLogger('pylama')
@@ -18,15 +29,6 @@
 STREAM = logging.StreamHandler(sys.stdout)
 LOGGER.addHandler(STREAM)
 
-#: A default checkers
-DEFAULT_LINTERS = 'pep8', 'pyflakes', 'mccabe'
-
-CURDIR = os.getcwd()
-CONFIG_FILES = [
-    os.path.join(CURDIR, basename) for basename in
-    ('pylama.ini', 'setup.cfg', 'tox.ini', 'pytest.ini')
-]
-
 
 class _Default(object):
 
@@ -86,6 +88,9 @@ def parse_linters(linters):
     "--select", "-s", default=_Default(''), type=split_csp_str,
     help="Select errors and warnings. (comma-separated list)")
 
+PARSER.add_argument(
+    "--sort", default=_Default(''), type=split_csp_str,
+    help="Sort result by error types. Ex. E,W,D")
 
 PARSER.add_argument(
     "--linters", "-l", default=_Default(','.join(DEFAULT_LINTERS)),
@@ -100,7 +105,7 @@ def parse_linters(linters):
 
 PARSER.add_argument(
     "--skip", default=_Default(''),
-    type=lambda s: [re(fnmatch.translate(p)) for p in s.split(',') if p],
+    type=lambda s: [re.compile(fnmatch.translate(p)) for p in s.split(',') if p],
     help="Skip files by masks (comma-separated, Ex. */messages.py)")
 
 PARSER.add_argument("--report", "-r", help="Send report to file [REPORT]")
@@ -124,7 +129,7 @@ def parse_linters(linters):
 ACTIONS = dict((a.dest, a) for a in PARSER._actions)
 
 
-def parse_options(args=None, config=True, **overrides): # noqa
+def parse_options(args=None, config=True, rootdir=CURDIR, **overrides): # noqa
     """ Parse options from command line and configuration files.
 
     :return argparse.Namespace:
@@ -146,7 +151,7 @@ def parse_options(args=None, config=True, **overrides): # noqa
 
     # Compile options from ini
     if config:
-        cfg = get_config(str(options.options))
+        cfg = get_config(str(options.options), rootdir=rootdir)
         for k, v in cfg.default.items():
             LOGGER.info('Find option %s (%s)', k, v)
             passed_value = getattr(options, k, _Default())
@@ -168,7 +173,7 @@ def parse_options(args=None, config=True, **overrides): # noqa
                 options.linters_params[name] = dict(opts)
                 continue
 
-            mask = re(fnmatch.translate(name))
+            mask = re.compile(fnmatch.translate(name))
             options.file_params[mask] = dict(opts)
 
     # Postprocess options
@@ -177,6 +182,10 @@ def parse_options(args=None, config=True, **overrides): # noqa
         if isinstance(value, _Default):
             setattr(options, name, process_value(name, value.value))
 
+    if options.async and 'pylint' in options.linters:
+        LOGGER.warn('Cant parse code asynchronously while pylint is enabled.')
+        options.async = False
+
     return options
 
 
@@ -195,7 +204,7 @@ def process_value(name, value):
     return value
 
 
-def get_config(ini_path=None):
+def get_config(ini_path=None, rootdir=CURDIR):
     """ Load configuration from INI.
 
     :return Namespace:
@@ -206,6 +215,7 @@ def get_config(ini_path=None):
 
     if not ini_path:
         for path in CONFIG_FILES:
+            path = os.path.join(rootdir, path)
             if os.path.isfile(path) and os.access(path, os.R_OK):
                 config.read(path)
     else:
diff --git a/pymode/libs/pylama/core.py b/pymode/libs/pylama/core.py
index 1283a662..bcbed77d 100644
--- a/pymode/libs/pylama/core.py
+++ b/pymode/libs/pylama/core.py
@@ -3,33 +3,25 @@
 Prepare params, check a modeline and run the checkers.
 
 """
-import re
-
 import logging
-from collections import defaultdict
 
-from .config import process_value, LOGGER
+import os.path as op
+from .config import process_value, LOGGER, MODELINE_RE, SKIP_PATTERN, CURDIR
+from .errors import Error, remove_duplicates
 from .lint.extensions import LINTERS
-from .errors import DUPLICATES, Error
-
-
-#: The skip pattern
-SKIP_PATTERN = re.compile(r'# *noqa\b', re.I).search
-
-# Parse a modelines
-MODELINE_RE = re.compile(
-    r'^\s*#\s+(?:pylama:)\s*((?:[\w_]*=[^:\n\s]+:?)+)',
-    re.I | re.M)
 
 
-def run(path='', code=None, options=None):
-    """ Run a code checkers with given params.
+def run(path='', code=None, rootdir=CURDIR, options=None):
+    """ Run code checkers with given params.
 
+    :param path: (str) A file's path.
+    :param code: (str) A code source
     :return errors: list of dictionaries with error's information
 
     """
     errors = []
     fileconfig = dict()
+    lname = 'undefined'
     params = dict()
     linters = LINTERS
     linters_params = dict()
@@ -43,6 +35,7 @@ def run(path='', code=None, options=None):
 
     try:
         with CodeContext(code, path) as ctx:
+            path = op.relpath(path, rootdir)
             code = ctx.code
             params = prepare_params(parse_modeline(code), fileconfig, options)
             LOGGER.debug('Checking params: %s', params)
@@ -50,7 +43,7 @@ def run(path='', code=None, options=None):
             if params.get('skip'):
                 return errors
 
-            for item in linters:
+            for item in params.get('linters') or linters:
 
                 if not isinstance(item, tuple):
                     item = (item, LINTERS.get(item))
@@ -66,7 +59,8 @@ def run(path='', code=None, options=None):
                 for er in linter.run(
                         path, code=code, ignore=params.get("ignore", set()),
                         select=params.get("select", set()), params=lparams):
-                    errors.append(Error(filename=path, linter=lname, **er))
+                    errors.append(Error(
+                        filename=path, linter=lname, **er))
 
     except IOError as e:
         LOGGER.debug("IOError %s", e)
@@ -89,7 +83,11 @@ def run(path='', code=None, options=None):
     if code and errors:
         errors = filter_skiplines(code, errors)
 
-    return sorted(errors, key=lambda e: e.lnum)
+    key = lambda e: e.lnum
+    if options and options.sort:
+        sort = dict((v, n) for n, v in enumerate(options.sort, 1))
+        key = lambda e: (sort.get(e.type, 999), e.lnum)
+    return sorted(errors, key=key)
 
 
 def parse_modeline(code):
@@ -111,13 +109,13 @@ def prepare_params(modeline, fileconfig, options):
     :return dict:
 
     """
-    params = dict(skip=False, ignore=[], select=[])
+    params = dict(skip=False, ignore=[], select=[], linters=[])
     if options:
-        params['ignore'] = options.ignore
-        params['select'] = options.select
+        params['ignore'] = options.ignore[:]
+        params['select'] = options.select[:]
 
     for config in filter(None, [modeline, fileconfig]):
-        for key in ('ignore', 'select'):
+        for key in ('ignore', 'select', 'linters'):
             params[key] += process_value(key, config.get(key, []))
         params['skip'] = bool(int(config.get('skip', False)))
 
@@ -170,18 +168,6 @@ def filter_skiplines(code, errors):
     return errors
 
 
-def remove_duplicates(errors):
-    """ Remove same errors from others linters. """
-    passed = defaultdict(list)
-    for error in errors:
-        key = error.linter, error.number
-        if key in DUPLICATES:
-            if key in passed[error.lnum]:
-                continue
-            passed[error.lnum] = DUPLICATES[key]
-        yield error
-
-
 class CodeContext(object):
 
     """ Read file if code is None. """
@@ -193,16 +179,19 @@ def __init__(self, code, path):
         self._file = None
 
     def __enter__(self):
-        """ Open file and read a code. """
+        """ Open a file and read it. """
         if self.code is None:
+            LOGGER.info("File is reading: %s", self.path)
             self._file = open(self.path, 'rU')
             self.code = self._file.read()
         return self
 
     def __exit__(self, t, value, traceback):
-        """ Close opened file. """
+        """ Close the file which was opened. """
         if self._file is not None:
             self._file.close()
 
         if t and LOGGER.level == logging.DEBUG:
             LOGGER.debug(traceback)
+
+# pylama:ignore=R0912
diff --git a/pymode/libs/pylama/errors.py b/pymode/libs/pylama/errors.py
index 9e80d2a6..7f6c0a11 100644
--- a/pymode/libs/pylama/errors.py
+++ b/pymode/libs/pylama/errors.py
@@ -1,13 +1,13 @@
-""" Dont duplicate errors same type. """
+""" Don't duplicate same errors from different linters. """
+
+from collections import defaultdict
+
 
 DUPLICATES = (
 
     # multiple statements on one line
     [('pep8', 'E701'), ('pylint', 'C0321')],
 
-    # missing whitespace around operator
-    [('pep8', 'E225'), ('pylint', 'C0326')],
-
     # unused variable
     [('pylint', 'W0612'), ('pyflakes', 'W0612')],
 
@@ -17,15 +17,24 @@
     # unused import
     [('pylint', 'W0611'), ('pyflakes', 'W0611')],
 
+    # whitespace before ')'
+    [('pylint', 'C0326'), ('pep8', 'E202')],
+
+    # whitespace before '('
+    [('pylint', 'C0326'), ('pep8', 'E211')],
+
+    # multiple spaces after operator
+    [('pylint', 'C0326'), ('pep8', 'E222')],
+
+    # missing whitespace around operator
+    [('pylint', 'C0326'), ('pep8', 'E225')],
+
     # unexpected spaces
     [('pylint', 'C0326'), ('pep8', 'E251')],
 
     # long lines
     [('pylint', 'C0301'), ('pep8', 'E501')],
 
-    # whitespace before '('
-    [('pylint', 'C0326'), ('pep8', 'E211')],
-
     # statement ends with a semicolon
     [('pylint', 'W0301'), ('pep8', 'E703')],
 
@@ -35,14 +44,32 @@
     # bad indentation
     [('pylint', 'W0311'), ('pep8', 'E111')],
 
+    # wildcart import
+    [('pylint', 'W00401'), ('pyflakes', 'W0401')],
+
+    # module docstring
+    [('pep257', 'D100'), ('pylint', 'C0111')],
+
 )
 
 DUPLICATES = dict((key, values) for values in DUPLICATES for key in values)
 
 
+def remove_duplicates(errors):
+    """ Filter duplicates from given error's list. """
+    passed = defaultdict(list)
+    for error in errors:
+        key = error.linter, error.number
+        if key in DUPLICATES:
+            if key in passed[error.lnum]:
+                continue
+            passed[error.lnum] = DUPLICATES[key]
+        yield error
+
+
 class Error(object):
 
-    """ Store error information. """
+    """ Store an error's information. """
 
     def __init__(self, linter="", col=1, lnum=1, type="E",
                  text="unknown error", filename="", **kwargs):
@@ -51,7 +78,7 @@ def __init__(self, linter="", col=1, lnum=1, type="E",
         if linter:
             text = "%s [%s]" % (text, linter)
         number = text.split(' ', 1)[0]
-        self._info = dict(linter=linter, col=col, lnum=lnum, type=type,
+        self._info = dict(linter=linter, col=col, lnum=lnum, type=type[:1],
                           text=text, filename=filename, number=number)
 
     def __getattr__(self, name):
diff --git a/pymode/libs/pylama/hook.py b/pymode/libs/pylama/hook.py
index 0dc34069..0c3da297 100644
--- a/pymode/libs/pylama/hook.py
+++ b/pymode/libs/pylama/hook.py
@@ -6,7 +6,7 @@
 from os import path as op, chmod
 from subprocess import Popen, PIPE
 
-from .main import LOGGER
+from .main import LOGGER, process_paths
 from .config import parse_options, setup_logger
 
 
@@ -30,18 +30,15 @@ def run(command):
 
 def git_hook():
     """ Run pylama after git commit. """
-    from .main import check_files
-
     _, files_modified, _ = run("git diff-index --cached --name-only HEAD")
 
     options = parse_options()
     setup_logger(options)
-    check_files([f for f in map(str, files_modified)], options)
+    process_paths(options, candidates=[f for f in map(str, files_modified)])
 
 
 def hg_hook(ui, repo, node=None, **kwargs):
     """ Run pylama after mercurial commit. """
-    from .main import check_files
     seen = set()
     paths = []
     if len(repo):
@@ -55,7 +52,7 @@ def hg_hook(ui, repo, node=None, **kwargs):
 
     options = parse_options()
     setup_logger(options)
-    check_files(paths, options)
+    process_paths(options, candidates=paths)
 
 
 def install_git(path):
@@ -79,7 +76,7 @@ def install_hg(path):
         open(hook, 'w+').close()
 
     c = ConfigParser()
-    c.readfp(open(path, 'r'))
+    c.readfp(open(hook, 'r'))
     if not c.has_section('hooks'):
         c.add_section('hooks')
 
@@ -89,7 +86,7 @@ def install_hg(path):
     if not c.has_option('hooks', 'qrefresh'):
         c.set('hooks', 'qrefresh', 'python:pylama.hooks.hg_hook')
 
-    c.write(open(path, 'w+'))
+    c.write(open(hook, 'w+'))
 
 
 def install_hook(path):
@@ -101,7 +98,7 @@ def install_hook(path):
         LOGGER.warn('Git hook has been installed.')
 
     elif op.exists(hg):
-        install_hg(git)
+        install_hg(hg)
         LOGGER.warn('Mercurial hook has been installed.')
 
     else:
diff --git a/pymode/libs/pylama/lint/pylama_pep257/pep257.py b/pymode/libs/pylama/lint/pylama_pep257/pep257.py
index c5df0f72..a5992a61 100644
--- a/pymode/libs/pylama/lint/pylama_pep257/pep257.py
+++ b/pymode/libs/pylama/lint/pylama_pep257/pep257.py
@@ -15,10 +15,17 @@
 
 import os
 import sys
+import logging
 import tokenize as tk
 from itertools import takewhile, dropwhile, chain
 from optparse import OptionParser
 from re import compile as re
+try:  # Python 3.x
+    from ConfigParser import RawConfigParser
+except ImportError:  # Python 2.x
+    from configparser import RawConfigParser
+
+log = logging.getLogger(__name__)
 
 
 try:
@@ -42,26 +49,47 @@ def next(obj, default=nothing):
                 return default
 
 
-__version__ = '0.3.3-alpha'
+__version__ = '0.5.0'
 __all__ = ('check', 'collect')
 
+PROJECT_CONFIG = ('setup.cfg', 'tox.ini', '.pep257')
+
+
+def humanize(string):
+    return re(r'(.)([A-Z]+)').sub(r'\1 \2', string).lower()
+
+
+def is_magic(name):
+    return name.startswith('__') and name.endswith('__')
+
+
+def is_ascii(string):
+    return all(ord(char) < 128 for char in string)
+
 
-humanize = lambda string: re(r'(.)([A-Z]+)').sub(r'\1 \2', string).lower()
-is_magic = lambda name: name.startswith('__') and name.endswith('__')
-is_ascii = lambda string: all(ord(char) < 128 for char in string)
-is_blank = lambda string: not string.strip()
-leading_space = lambda string: re('\s*').match(string).group()
+def is_blank(string):
+    return not string.strip()
+
+
+def leading_space(string):
+    return re('\s*').match(string).group()
 
 
 class Value(object):
 
-    __init__ = lambda self, *args: vars(self).update(zip(self._fields, args))
-    __hash__ = lambda self: hash(repr(self))
-    __eq__ = lambda self, other: other and vars(self) == vars(other)
+    def __init__(self, *args):
+        vars(self).update(zip(self._fields, args))
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def __eq__(self, other):
+        return other and vars(self) == vars(other)
 
     def __repr__(self):
-        args = [vars(self)[field] for field in self._fields]
-        return '%s(%s)' % (self.__class__.__name__, ', '.join(map(repr, args)))
+        kwargs = ', '.join('{}={!r}'.format(field, getattr(self, field))
+                           for field in self._fields)
+        return '{}({})'.format(self.__class__.__name__, kwargs)
 
 
 class Definition(Value):
@@ -74,7 +102,9 @@ class Definition(Value):
     all = property(lambda self: self.module.all)
     _slice = property(lambda self: slice(self.start - 1, self.end))
     source = property(lambda self: ''.join(self._source[self._slice]))
-    __iter__ = lambda self: chain([self], *self.children)
+
+    def __iter__(self):
+        return chain([self], *self.children)
 
     @property
     def _publicity(self):
@@ -91,7 +121,9 @@ class Module(Definition):
     _nest = staticmethod(lambda s: {'def': Function, 'class': Class}[s])
     module = property(lambda self: self)
     all = property(lambda self: self._all)
-    __str__ = lambda self: 'at module level'
+
+    def __str__(self):
+        return 'at module level'
 
 
 class Function(Definition):
@@ -131,10 +163,19 @@ class NestedClass(Class):
     is_public = False
 
 
+class TokenKind(int):
+    def __repr__(self):
+        return "tk.{}".format(tk.tok_name[self])
+
+
 class Token(Value):
 
     _fields = 'kind value start end source'.split()
 
+    def __init__(self, *args):
+        super(Token, self).__init__(*args)
+        self.kind = TokenKind(self.kind)
+
 
 class TokenStream(object):
 
@@ -186,35 +227,54 @@ def __call__(self, filelike, filename):
     def consume(self, kind):
         assert self.stream.move().kind == kind
 
-    def leapfrog(self, kind):
-        for token in self.stream:
-            if token.kind == kind:
+    def leapfrog(self, kind, value=None):
+        """Skip tokens in the stream until a certain token kind is reached.
+
+        If `value` is specified, tokens whose values are different will also
+        be skipped.
+        """
+        while self.current is not None:
+            if (self.current.kind == kind and
+               (value is None or self.current.value == value)):
                 self.consume(kind)
                 return
+            self.stream.move()
 
     def parse_docstring(self):
-        for token in self.stream:
-            if token.kind in [tk.COMMENT, tk.NEWLINE, tk.NL]:
-                continue
-            elif token.kind == tk.STRING:
-                return token.value
-            else:
-                return None
+        """Parse a single docstring and return its value."""
+        log.debug("parsing docstring, token is %r (%s)",
+                  self.current.kind, self.current.value)
+        while self.current.kind in (tk.COMMENT, tk.NEWLINE, tk.NL):
+            self.stream.move()
+            log.debug("parsing docstring, token is %r (%s)",
+                      self.current.kind, self.current.value)
+        if self.current.kind == tk.STRING:
+            docstring = self.current.value
+            self.stream.move()
+            return docstring
+        return None
 
     def parse_definitions(self, class_, all=False):
-        for token in self.stream:
-            if all and token.value == '__all__':
+        """Parse multiple defintions and yield them."""
+        while self.current is not None:
+            log.debug("parsing defintion list, current token is %r (%s)",
+                      self.current.kind, self.current.value)
+            if all and self.current.value == '__all__':
                 self.parse_all()
-            if token.value in ['def', 'class']:
-                yield self.parse_definition(class_._nest(token.value))
-            if token.kind == tk.INDENT:
+            elif self.current.value in ['def', 'class']:
+                yield self.parse_definition(class_._nest(self.current.value))
+            elif self.current.kind == tk.INDENT:
                 self.consume(tk.INDENT)
                 for definition in self.parse_definitions(class_):
                     yield definition
-            if token.kind == tk.DEDENT:
+            elif self.current.kind == tk.DEDENT:
+                self.consume(tk.DEDENT)
                 return
+            else:
+                self.stream.move()
 
     def parse_all(self):
+        """Parse the __all__ definition in a module."""
         assert self.current.value == '__all__'
         self.consume(tk.NAME)
         if self.current.value != '=':
@@ -234,46 +294,84 @@ def parse_all(self):
                    "assuming __all__ is not mutated.\n" % self.filename)
             sys.stderr.write(msg)
         self.consume(tk.OP)
-        s = '('
-        while self.current.kind in (tk.NL, tk.COMMENT):
-            self.stream.move()
-        if self.current.kind != tk.STRING:
-            raise AllError('Could not evaluate contents of __all__. ')
-        while self.current.value not in ')]':
-            s += self.current.value
+
+        self.all = []
+        all_content = "("
+        while self.current.kind != tk.OP or self.current.value not in ")]":
+            if self.current.kind in (tk.NL, tk.COMMENT):
+                pass
+            elif (self.current.kind == tk.STRING or
+                  self.current.value == ','):
+                all_content += self.current.value
+            else:
+                raise AllError('Could not evaluate contents of __all__. ')
             self.stream.move()
-        s += ')'
+        self.consume(tk.OP)
+        all_content += ")"
         try:
-            self.all = eval(s, {})
-        except BaseException:
-            raise AllError('Could not evaluate contents of __all__: %s. ' % s)
+            self.all = eval(all_content, {})
+        except BaseException as e:
+            raise AllError('Could not evaluate contents of __all__.'
+                           '\bThe value was %s. The exception was:\n%s'
+                           % (all_content, e))
 
     def parse_module(self):
+        """Parse a module (and its children) and return a Module object."""
+        log.debug("parsing module.")
         start = self.line
         docstring = self.parse_docstring()
         children = list(self.parse_definitions(Module, all=True))
-        assert self.current is None
+        assert self.current is None, self.current
         end = self.line
         module = Module(self.filename, self.source, start, end,
                         docstring, children, None, self.all)
         for child in module.children:
             child.parent = module
+        log.debug("finished parsing module.")
         return module
 
     def parse_definition(self, class_):
+        """Parse a defintion and return its value in a `class_` object."""
         start = self.line
         self.consume(tk.NAME)
         name = self.current.value
-        self.leapfrog(tk.INDENT)
-        assert self.current.kind != tk.INDENT
-        docstring = self.parse_docstring()
-        children = list(self.parse_definitions(class_))
-        assert self.current.kind == tk.DEDENT
-        end = self.line - 1
+        log.debug("parsing %s '%s'", class_.__name__, name)
+        self.stream.move()
+        if self.current.kind == tk.OP and self.current.value == '(':
+            parenthesis_level = 0
+            while True:
+                if self.current.kind == tk.OP:
+                    if self.current.value == '(':
+                        parenthesis_level += 1
+                    elif self.current.value == ')':
+                        parenthesis_level -= 1
+                        if parenthesis_level == 0:
+                            break
+                self.stream.move()
+        if self.current.kind != tk.OP or self.current.value != ':':
+            self.leapfrog(tk.OP, value=":")
+        else:
+            self.consume(tk.OP)
+        if self.current.kind in (tk.NEWLINE, tk.COMMENT):
+            self.leapfrog(tk.INDENT)
+            assert self.current.kind != tk.INDENT
+            docstring = self.parse_docstring()
+            log.debug("parsing nested defintions.")
+            children = list(self.parse_definitions(class_))
+            log.debug("finished parsing nested defintions for '%s'", name)
+            end = self.line - 1
+        else:  # one-liner definition
+            docstring = self.parse_docstring()
+            children = []
+            end = self.line
+            self.leapfrog(tk.NEWLINE)
         definition = class_(name, self.source, start, end,
                             docstring, children, None)
         for child in definition.children:
             child.parent = definition
+        log.debug("finished parsing %s '%s'. Next token is %r (%s)",
+                  class_.__name__, name, self.current.kind,
+                  self.current.value)
         return definition
 
 
@@ -281,18 +379,34 @@ class Error(object):
 
     """Error in docstring style."""
 
+    # should be overridden by inheriting classes
+    code = None
+    short_desc = None
+    context = None
+
     # Options that define how errors are printed:
     explain = False
     source = False
 
-    def __init__(self, message=None, final=False):
-        self.message, self.is_final = message, final
-        self.definition, self.explanation = [None, None]
+    def __init__(self, *parameters):
+        self.parameters = parameters
+        self.definition = None
+        self.explanation = None
+
+    def set_context(self, definition, explanation):
+        self.definition = definition
+        self.explanation = explanation
 
-    code = property(lambda self: self.message.partition(':')[0])
     filename = property(lambda self: self.definition.module.name)
     line = property(lambda self: self.definition.start)
 
+    @property
+    def message(self):
+        ret = '%s: %s' % (self.code, self.short_desc)
+        if self.context is not None:
+            ret += ' (' + self.context % self.parameters + ')'
+        return ret
+
     @property
     def lines(self):
         source = ''
@@ -332,9 +446,105 @@ def __lt__(self, other):
         return (self.filename, self.line) < (other.filename, other.line)
 
 
-def parse_options():
+class ErrorRegistry(object):
+    groups = []
+
+    class ErrorGroup(object):
+
+        def __init__(self, prefix, name):
+            self.prefix = prefix
+            self.name = name
+            self.errors = []
+
+        def create_error(self, error_code, error_desc, error_context=None):
+            # TODO: check prefix
+
+            class _Error(Error):
+                code = error_code
+                short_desc = error_desc
+                context = error_context
+
+            self.errors.append(_Error)
+            return _Error
+
+    @classmethod
+    def create_group(cls, prefix, name):
+        group = cls.ErrorGroup(prefix, name)
+        cls.groups.append(group)
+        return group
+
+    @classmethod
+    def get_error_codes(cls):
+        for group in cls.groups:
+            for error in group.errors:
+                yield error
+
+    @classmethod
+    def to_rst(cls):
+        sep_line = '+' + 6 * '-' + '+' + '-' * 71 + '+\n'
+        blank_line = '|' + 78 * ' ' + '|\n'
+        table = ''
+        for group in cls.groups:
+            table += sep_line
+            table += blank_line
+            table += '|' + ('**%s**' % group.name).center(78) + '|\n'
+            table += blank_line
+            for error in group.errors:
+                table += sep_line
+                table += ('|' + error.code.center(6) + '| ' +
+                          error.short_desc.ljust(70) + '|\n')
+        table += sep_line
+        return table
+
+
+D1xx = ErrorRegistry.create_group('D1', 'Missing Docstrings')
+D100 = D1xx.create_error('D100', 'Missing docstring in public module')
+D101 = D1xx.create_error('D101', 'Missing docstring in public class')
+D102 = D1xx.create_error('D102', 'Missing docstring in public method')
+D103 = D1xx.create_error('D103', 'Missing docstring in public function')
+
+D2xx = ErrorRegistry.create_group('D2', 'Whitespace Issues')
+D200 = D2xx.create_error('D200', 'One-line docstring should fit on one line '
+                                 'with quotes', 'found %s')
+D201 = D2xx.create_error('D201', 'No blank lines allowed before function '
+                                 'docstring', 'found %s')
+D202 = D2xx.create_error('D202', 'No blank lines allowed after function '
+                                 'docstring', 'found %s')
+D203 = D2xx.create_error('D203', '1 blank line required before class '
+                                 'docstring', 'found %s')
+D204 = D2xx.create_error('D204', '1 blank line required after class '
+                                 'docstring', 'found %s')
+D205 = D2xx.create_error('D205', '1 blank line required between summary line '
+                                 'and description', 'found %s')
+D206 = D2xx.create_error('D206', 'Docstring should be indented with spaces, '
+                                 'not tabs')
+D207 = D2xx.create_error('D207', 'Docstring is under-indented')
+D208 = D2xx.create_error('D208', 'Docstring is over-indented')
+D209 = D2xx.create_error('D209', 'Multi-line docstring closing quotes should '
+                                 'be on a separate line')
+D210 = D2xx.create_error('D210', 'No whitespaces allowed surrounding '
+                                 'docstring text')
+
+D3xx = ErrorRegistry.create_group('D3', 'Quotes Issues')
+D300 = D3xx.create_error('D300', 'Use """triple double quotes"""',
+                         'found %s-quotes')
+D301 = D3xx.create_error('D301', 'Use r""" if any backslashes in a docstring')
+D302 = D3xx.create_error('D302', 'Use u""" for Unicode docstrings')
+
+D4xx = ErrorRegistry.create_group('D4', 'Docstring Content Issues')
+D400 = D4xx.create_error('D400', 'First line should end with a period',
+                         'not %r')
+D401 = D4xx.create_error('D401', 'First line should be in imperative mood',
+                         '%r, not %r')
+D402 = D4xx.create_error('D402', 'First line should not be the function\'s '
+                                 '"signature"')
+
+
+def get_option_parser():
     parser = OptionParser(version=__version__,
                           usage='Usage: pep257 [options] [<file|dir>...]')
+    parser.config_options = ('explain', 'source', 'ignore', 'match',
+                             'match-dir', 'debug', 'verbose', 'count')
     option = parser.add_option
     option('-e', '--explain', action='store_true',
            help='show explanation of each error')
@@ -352,7 +562,13 @@ def parse_options():
            help="search only dirs that exactly match <pattern> regular "
                 "expression; default is --match-dir='[^\.].*', which matches "
                 "all dirs that don't start with a dot")
-    return parser.parse_args()
+    option('-d', '--debug', action='store_true',
+           help='print debug information')
+    option('-v', '--verbose', action='store_true',
+           help='print status information')
+    option('--count', action='store_true',
+           help='print total number of errors to stdout')
+    return parser
 
 
 def collect(names, match=lambda name: True, match_dir=lambda name: True):
@@ -368,9 +584,8 @@ def collect(names, match=lambda name: True, match_dir=lambda name: True):
     for name in names:  # map(expanduser, names):
         if os.path.isdir(name):
             for root, dirs, filenames in os.walk(name):
-                for dir in dirs:
-                    if not match_dir(dir):
-                        dirs.remove(dir)  # do not visit those dirs
+                # Skip any dirs that do not match match_dir
+                dirs[:] = [dir for dir in dirs if match_dir(dir)]
                 for filename in filenames:
                     if match(filename):
                         yield os.path.join(root, filename)
@@ -390,6 +605,7 @@ def check(filenames, ignore=()):
 
     """
     for filename in filenames:
+        log.info('Checking file %s.', filename)
         try:
             with open(filename) as file:
                 source = file.read()
@@ -403,16 +619,94 @@ def check(filenames, ignore=()):
             yield SyntaxError('invalid syntax in file %s' % filename)
 
 
-def main(options, arguments):
-    Error.explain = options.explain
-    Error.source = options.source
+def get_options(args, opt_parser):
+    config = RawConfigParser()
+    parent = tail = args and os.path.abspath(os.path.commonprefix(args))
+    while tail:
+        for fn in PROJECT_CONFIG:
+            full_path = os.path.join(parent, fn)
+            if config.read(full_path):
+                log.info('local configuration: in %s.', full_path)
+                break
+        parent, tail = os.path.split(parent)
+
+    new_options = None
+    if config.has_section('pep257'):
+        option_list = dict([(o.dest, o.type or o.action)
+                            for o in opt_parser.option_list])
+
+        # First, read the default values
+        new_options, _ = opt_parser.parse_args([])
+
+        # Second, parse the configuration
+        pep257_section = 'pep257'
+        for opt in config.options(pep257_section):
+            if opt.replace('_', '-') not in opt_parser.config_options:
+                print("Unknown option '{}' ignored".format(opt))
+                continue
+            normalized_opt = opt.replace('-', '_')
+            opt_type = option_list[normalized_opt]
+            if opt_type in ('int', 'count'):
+                value = config.getint(pep257_section, opt)
+            elif opt_type == 'string':
+                value = config.get(pep257_section, opt)
+            else:
+                assert opt_type in ('store_true', 'store_false')
+                value = config.getboolean(pep257_section, opt)
+            setattr(new_options, normalized_opt, value)
+
+    # Third, overwrite with the command-line options
+    options, _ = opt_parser.parse_args(values=new_options)
+    log.debug("options: %s", options)
+    return options
+
+
+def setup_stream_handler(options):
+    if log.handlers:
+        for handler in log.handlers:
+            log.removeHandler(handler)
+    stream_handler = logging.StreamHandler(sys.stdout)
+    stream_handler.setLevel(logging.WARNING)
+    if options.debug:
+        stream_handler.setLevel(logging.DEBUG)
+    elif options.verbose:
+        stream_handler.setLevel(logging.INFO)
+    else:
+        stream_handler.setLevel(logging.WARNING)
+    log.addHandler(stream_handler)
+
+
+def run_pep257():
+    log.setLevel(logging.DEBUG)
+    opt_parser = get_option_parser()
+    # setup the logger before parsing the config file, so that command line
+    # arguments for debug / verbose will be printed.
+    options, arguments = opt_parser.parse_args()
+    setup_stream_handler(options)
+    # We parse the files before opening the config file, since it changes where
+    # we look for the file.
+    options = get_options(arguments, opt_parser)
+    # Setup the handler again with values from the config file.
+    setup_stream_handler(options)
+
     collected = collect(arguments or ['.'],
                         match=re(options.match + '$').match,
                         match_dir=re(options.match_dir + '$').match)
+
+    log.debug("starting pep257 in debug mode.")
+
+    Error.explain = options.explain
+    Error.source = options.source
+    collected = list(collected)
+    errors = check(collected, ignore=options.ignore.split(','))
     code = 0
-    for error in check(collected, ignore=options.ignore.split(',')):
+    count = 0
+    for error in errors:
         sys.stderr.write('%s\n' % error)
         code = 1
+        count += 1
+    if options.count:
+        print(count)
     return code
 
 
@@ -450,10 +744,8 @@ def check_source(self, source, filename):
                         if error is not None:
                             partition = check.__doc__.partition('.\n')
                             message, _, explanation = partition
-                            if error.message is None:
-                                error.message = message
-                            error.explanation = explanation
-                            error.definition = definition
+                            error.set_context(explanation=explanation,
+                                              definition=definition)
                             yield error
                             if check._terminal:
                                 terminate = True
@@ -483,9 +775,9 @@ def check_docstring_missing(self, definition, docstring):
         """
         if (not docstring and definition.is_public or
                 docstring and is_blank(eval(docstring))):
-            codes = {Module: 'D100', Class: 'D101', NestedClass: 'D101',
-                     Method: 'D102', Function: 'D103', NestedFunction: 'D103'}
-            return Error('%s: Docstring missing' % codes[type(definition)])
+            codes = {Module: D100, Class: D101, NestedClass: D101,
+                     Method: D102, Function: D103, NestedFunction: D103}
+            return codes[type(definition)]()
 
     @check_for(Definition)
     def check_one_liners(self, definition, docstring):
@@ -500,8 +792,7 @@ def check_one_liners(self, definition, docstring):
             if len(lines) > 1:
                 non_empty_lines = sum(1 for l in lines if not is_blank(l))
                 if non_empty_lines == 1:
-                    return Error('D200: One-line docstring should not occupy '
-                                 '%s lines' % len(lines))
+                    return D200(len(lines))
 
     @check_for(Function)
     def check_no_blank_before(self, function, docstring):  # def
@@ -519,13 +810,9 @@ def check_no_blank_before(self, function, docstring):  # def
             blanks_before_count = sum(takewhile(bool, reversed(blanks_before)))
             blanks_after_count = sum(takewhile(bool, blanks_after))
             if blanks_before_count != 0:
-                yield Error('D201: No blank lines allowed *before* %s '
-                            'docstring, found %s'
-                            % (function.kind, blanks_before_count))
+                yield D201(blanks_before_count)
             if not all(blanks_after) and blanks_after_count != 0:
-                yield Error('D202: No blank lines allowed *after* %s '
-                            'docstring, found %s'
-                            % (function.kind, blanks_after_count))
+                yield D202(blanks_after_count)
 
     @check_for(Class)
     def check_blank_before_after_class(slef, class_, docstring):
@@ -539,7 +826,7 @@ def check_blank_before_after_class(slef, class_, docstring):
         docstring.
 
         """
-        # NOTE: this gives flase-positive in this case
+        # NOTE: this gives false-positive in this case
         # class Foo:
         #
         #     """Docstring."""
@@ -554,15 +841,13 @@ def check_blank_before_after_class(slef, class_, docstring):
             blanks_before_count = sum(takewhile(bool, reversed(blanks_before)))
             blanks_after_count = sum(takewhile(bool, blanks_after))
             if blanks_before_count != 1:
-                yield Error('D203: Expected 1 blank line *before* class '
-                            'docstring, found %s' % blanks_before_count)
+                yield D203(blanks_before_count)
             if not all(blanks_after) and blanks_after_count != 1:
-                yield Error('D204: Expected 1 blank line *after* class '
-                            'docstring, found %s' % blanks_after_count)
+                yield D204(blanks_after_count)
 
     @check_for(Definition)
     def check_blank_after_summary(self, definition, docstring):
-        """D205: Blank line missing between one-line summary and description.
+        """D205: Put one blank line between summary line and description.
 
         Multi-line docstrings consist of a summary line just like a one-line
         docstring, followed by a blank line, followed by a more elaborate
@@ -573,8 +858,11 @@ def check_blank_after_summary(self, definition, docstring):
         """
         if docstring:
             lines = eval(docstring).strip().split('\n')
-            if len(lines) > 1 and not is_blank(lines[1]):
-                return Error()
+            if len(lines) > 1:
+                post_summary_blanks = list(map(is_blank, lines[1:]))
+                blanks_count = sum(takewhile(bool, post_summary_blanks))
+                if blanks_count != 1:
+                    return D205(blanks_count)
 
     @check_for(Definition)
     def check_indent(self, definition, docstring):
@@ -592,13 +880,12 @@ def check_indent(self, definition, docstring):
                 lines = lines[1:]  # First line does not need indent.
                 indents = [leading_space(l) for l in lines if not is_blank(l)]
                 if set(' \t') == set(''.join(indents) + indent):
-                    return Error('D206: Docstring indented with both tabs and '
-                                 'spaces')
-                if (len(indents) > 1 and min(indents[:-1]) > indent
-                        or indents[-1] > indent):
-                    return Error('D208: Docstring is over-indented')
+                    yield D206()
+                if (len(indents) > 1 and min(indents[:-1]) > indent or
+                        indents[-1] > indent):
+                    yield D208()
                 if min(indents) < indent:
-                    return Error('D207: Docstring is under-indented')
+                    yield D207()
 
     @check_for(Definition)
     def check_newline_after_last_paragraph(self, definition, docstring):
@@ -612,8 +899,16 @@ def check_newline_after_last_paragraph(self, definition, docstring):
             lines = [l for l in eval(docstring).split('\n') if not is_blank(l)]
             if len(lines) > 1:
                 if docstring.split("\n")[-1].strip() not in ['"""', "'''"]:
-                    return Error('D209: Put multi-line docstring closing '
-                                 'quotes on separate line')
+                    return D209()
+
+    @check_for(Definition)
+    def check_surrounding_whitespaces(self, definition, docstring):
+        """D210: No whitespaces allowed surrounding docstring text."""
+        if docstring:
+            lines = eval(docstring).split('\n')
+            if lines[0].startswith(' ') or \
+                    len(lines) == 1 and lines[0].endswith(' '):
+                return D210()
 
     @check_for(Definition)
     def check_triple_double_quotes(self, definition, docstring):
@@ -635,7 +930,7 @@ def check_triple_double_quotes(self, definition, docstring):
             return
         if docstring and not docstring.startswith(('"""', 'r"""', 'u"""')):
             quotes = "'''" if "'''" in docstring[:4] else "'"
-            return Error('D300: Expected """-quotes, got %s-quotes' % quotes)
+            return D300(quotes)
 
     @check_for(Definition)
     def check_backslashes(self, definition, docstring):
@@ -648,7 +943,7 @@ def check_backslashes(self, definition, docstring):
         # Just check that docstring is raw, check_triple_double_quotes
         # ensures the correct quotes.
         if docstring and '\\' in docstring and not docstring.startswith('r'):
-            return Error()
+            return D301()
 
     @check_for(Definition)
     def check_unicode_docstring(self, definition, docstring):
@@ -661,7 +956,7 @@ def check_unicode_docstring(self, definition, docstring):
         # ensures the correct quotes.
         if docstring and sys.version_info[0] <= 2:
             if not is_ascii(docstring) and not docstring.startswith('u'):
-                return Error()
+                return D302()
 
     @check_for(Definition)
     def check_ends_with_period(self, definition, docstring):
@@ -673,8 +968,7 @@ def check_ends_with_period(self, definition, docstring):
         if docstring:
             summary_line = eval(docstring).strip().split('\n')[0]
             if not summary_line.endswith('.'):
-                return Error("D400: First line should end with '.', not %r"
-                             % summary_line[-1])
+                return D400(summary_line[-1])
 
     @check_for(Function)
     def check_imperative_mood(self, function, docstring):  # def context
@@ -690,8 +984,7 @@ def check_imperative_mood(self, function, docstring):  # def context
             if stripped:
                 first_word = stripped.split()[0]
                 if first_word.endswith('s') and not first_word.endswith('ss'):
-                    return Error('D401: First line should be imperative: '
-                                 '%r, not %r' % (first_word[:-1], first_word))
+                    return D401(first_word[:-1], first_word)
 
     @check_for(Function)
     def check_no_signature(self, function, docstring):  # def context
@@ -704,8 +997,7 @@ def check_no_signature(self, function, docstring):  # def context
         if docstring:
             first_line = eval(docstring).strip().split('\n')[0]
             if function.name + '(' in first_line.replace(' ', ''):
-                return Error("D402: First line should not be %s's signature"
-                             % function.kind)
+                return D402()
 
     # Somewhat hard to determine if return value is mentioned.
     # @check(Function)
@@ -721,8 +1013,12 @@ def SKIP_check_return_type(self, function, docstring):
                 return Error()
 
 
-if __name__ == '__main__':
+def main():
     try:
-        sys.exit(main(*parse_options()))
+        sys.exit(run_pep257())
     except KeyboardInterrupt:
         pass
+
+
+if __name__ == '__main__':
+    main()
diff --git a/pymode/libs/pylama/lint/pylama_pep8/pep8.py b/pymode/libs/pylama/lint/pylama_pep8/pep8.py
index 10a3a155..4d993dab 100644
--- a/pymode/libs/pylama/lint/pylama_pep8/pep8.py
+++ b/pymode/libs/pylama/lint/pylama_pep8/pep8.py
@@ -2,6 +2,7 @@
 # pep8.py - Check Python source code formatting, according to PEP 8
 # Copyright (C) 2006-2009 Johann C. Rocholl <johann@rocholl.net>
 # Copyright (C) 2009-2014 Florent Xicluna <florent.xicluna@gmail.com>
+# Copyright (C) 2014-2015 Ian Lee <ianlee1521@gmail.com>
 #
 # Permission is hereby granted, free of charge, to any person
 # obtaining a copy of this software and associated documentation files
@@ -46,8 +47,6 @@
 """
 from __future__ import with_statement
 
-__version__ = '1.6.0a0'
-
 import os
 import sys
 import re
@@ -63,13 +62,21 @@
 except ImportError:
     from ConfigParser import RawConfigParser
 
-DEFAULT_EXCLUDE = '.svn,CVS,.bzr,.hg,.git,__pycache__'
-DEFAULT_IGNORE = 'E123,E226,E24,E704'
-if sys.platform == 'win32':
-    DEFAULT_CONFIG = os.path.expanduser(r'~\.pep8')
-else:
-    DEFAULT_CONFIG = os.path.join(os.getenv('XDG_CONFIG_HOME') or
-                                  os.path.expanduser('~/.config'), 'pep8')
+__version__ = '1.6.3a0'
+
+DEFAULT_EXCLUDE = '.svn,CVS,.bzr,.hg,.git,__pycache__,.tox'
+DEFAULT_IGNORE = 'E121,E123,E126,E226,E24,E704'
+try:
+    if sys.platform == 'win32':
+        USER_CONFIG = os.path.expanduser(r'~\.pep8')
+    else:
+        USER_CONFIG = os.path.join(
+            os.getenv('XDG_CONFIG_HOME') or os.path.expanduser('~/.config'),
+            'pep8'
+        )
+except ImportError:
+    USER_CONFIG = None
+
 PROJECT_CONFIG = ('setup.cfg', 'tox.ini', '.pep8')
 TESTSUITE_PATH = os.path.join(os.path.dirname(__file__), 'testsuite')
 MAX_LINE_LENGTH = 79
@@ -101,8 +108,9 @@
 DOCSTRING_REGEX = re.compile(r'u?r?["\']')
 EXTRANEOUS_WHITESPACE_REGEX = re.compile(r'[[({] | []}),;:]')
 WHITESPACE_AFTER_COMMA_REGEX = re.compile(r'[,;:]\s*(?:  |\t)')
-COMPARE_SINGLETON_REGEX = re.compile(r'([=!]=)\s*(None|False|True)')
-COMPARE_NEGATIVE_REGEX = re.compile(r'\b(not)\s+[^[({ ]+\s+(in|is)\s')
+COMPARE_SINGLETON_REGEX = re.compile(r'\b(None|False|True)?\s*([=!]=)'
+                                     r'\s*(?(1)|(None|False|True))\b')
+COMPARE_NEGATIVE_REGEX = re.compile(r'\b(not)\s+[^][)(}{ ]+\s+(in|is)\s')
 COMPARE_TYPE_REGEX = re.compile(r'(?:[=!]=|is(?:\s+not)?)\s*type(?:s.\w+Type'
                                 r'|\s*\(\s*([^)]*[^ )])\s*\))')
 KEYWORD_REGEX = re.compile(r'(\s*)\b(?:%s)\b(\s*)' % r'|'.join(KEYWORDS))
@@ -199,7 +207,6 @@ def maximum_line_length(physical_line, max_line_length, multiline):
 
     Reports error E501.
     """
-    max_line_length = int(max_line_length)
     line = physical_line.rstrip()
     length = len(line)
     if length > max_line_length and not noqa(line):
@@ -428,6 +435,7 @@ def continued_indentation(logical_line, tokens, indent_level, hang_closing,
     indent_chances = {}
     last_indent = tokens[0][2]
     visual_indent = None
+    last_token_multiline = False
     # for each depth, memorize the visual indent column
     indent = [last_indent[1]]
     if verbose >= 3:
@@ -507,8 +515,9 @@ def continued_indentation(logical_line, tokens, indent_level, hang_closing,
                 yield start, "%s continuation line %s" % error
 
         # look for visual indenting
-        if (parens[row] and token_type not in (tokenize.NL, tokenize.COMMENT)
-                and not indent[depth]):
+        if (parens[row] and
+                token_type not in (tokenize.NL, tokenize.COMMENT) and
+                not indent[depth]):
             indent[depth] = start[1]
             indent_chances[start[1]] = True
             if verbose >= 4:
@@ -681,7 +690,7 @@ def missing_whitespace_around_operator(logical_line, tokens):
                 if need_space is True or need_space[1]:
                     # A needed trailing space was not found
                     yield prev_end, "E225 missing whitespace around operator"
-                else:
+                elif prev_text != '**':
                     code, optype = 'E226', 'arithmetic'
                     if prev_text == '%':
                         code, optype = 'E228', 'modulo'
@@ -749,6 +758,7 @@ def whitespace_around_named_parameter_equals(logical_line, tokens):
     Okay: boolean(a != b)
     Okay: boolean(a <= b)
     Okay: boolean(a >= b)
+    Okay: def foo(arg: int = 42):
 
     E251: def complex(real, imag = 0.0):
     E251: return magic(r = real, i = imag)
@@ -756,6 +766,8 @@ def whitespace_around_named_parameter_equals(logical_line, tokens):
     parens = 0
     no_space = False
     prev_end = None
+    annotated_func_arg = False
+    in_def = logical_line.startswith('def')
     message = "E251 unexpected spaces around keyword / parameter equals"
     for token_type, text, start, end, line in tokens:
         if token_type == tokenize.NL:
@@ -764,15 +776,22 @@ def whitespace_around_named_parameter_equals(logical_line, tokens):
             no_space = False
             if start != prev_end:
                 yield (prev_end, message)
-        elif token_type == tokenize.OP:
+        if token_type == tokenize.OP:
             if text == '(':
                 parens += 1
             elif text == ')':
                 parens -= 1
-            elif parens and text == '=':
+            elif in_def and text == ':' and parens == 1:
+                annotated_func_arg = True
+            elif parens and text == ',' and parens == 1:
+                annotated_func_arg = False
+            elif parens and text == '=' and not annotated_func_arg:
                 no_space = True
                 if start != prev_end:
                     yield (prev_end, message)
+            if not parens:
+                annotated_func_arg = False
+
         prev_end = end
 
 
@@ -836,6 +855,56 @@ def imports_on_separate_lines(logical_line):
             yield found, "E401 multiple imports on one line"
 
 
+def module_imports_on_top_of_file(
+        logical_line, indent_level, checker_state, noqa):
+    r"""Imports are always put at the top of the file, just after any module
+    comments and docstrings, and before module globals and constants.
+
+    Okay: import os
+    Okay: # this is a comment\nimport os
+    Okay: '''this is a module docstring'''\nimport os
+    Okay: r'''this is a module docstring'''\nimport os
+    Okay: try:\n    import x\nexcept:\n    pass\nelse:\n    pass\nimport y
+    Okay: try:\n    import x\nexcept:\n    pass\nfinally:\n    pass\nimport y
+    E402: a=1\nimport os
+    E402: 'One string'\n"Two string"\nimport os
+    E402: a=1\nfrom sys import x
+
+    Okay: if x:\n    import os
+    """
+    def is_string_literal(line):
+        if line[0] in 'uUbB':
+            line = line[1:]
+        if line and line[0] in 'rR':
+            line = line[1:]
+        return line and (line[0] == '"' or line[0] == "'")
+
+    allowed_try_keywords = ('try', 'except', 'else', 'finally')
+
+    if indent_level:  # Allow imports in conditional statements or functions
+        return
+    if not logical_line:  # Allow empty lines or comments
+        return
+    if noqa:
+        return
+    line = logical_line
+    if line.startswith('import ') or line.startswith('from '):
+        if checker_state.get('seen_non_imports', False):
+            yield 0, "E402 module level import not at top of file"
+    elif any(line.startswith(kw) for kw in allowed_try_keywords):
+        # Allow try, except, else, finally keywords intermixed with imports in
+        # order to support conditional importing
+        return
+    elif is_string_literal(line):
+        # The first literal is a docstring, allow it. Otherwise, report error.
+        if checker_state.get('seen_docstring', False):
+            checker_state['seen_non_imports'] = True
+        else:
+            checker_state['seen_docstring'] = True
+    else:
+        checker_state['seen_non_imports'] = True
+
+
 def compound_statements(logical_line):
     r"""Compound statements (on the same line) are generally discouraged.
 
@@ -872,8 +941,12 @@ def compound_statements(logical_line):
         if ((before.count('{') <= before.count('}') and   # {'a': 1} (dict)
              before.count('[') <= before.count(']') and   # [1:2] (slice)
              before.count('(') <= before.count(')'))):    # (annotation)
-            if LAMBDA_REGEX.search(before):
-                yield 0, "E731 do not assign a lambda expression, use a def"
+            lambda_kw = LAMBDA_REGEX.search(before)
+            if lambda_kw:
+                before = line[:lambda_kw.start()].rstrip()
+                if before[-1:] == '=' and isidentifier(before[:-1].strip()):
+                    yield 0, ("E731 do not assign a lambda expression, use a "
+                              "def")
                 break
             if before.startswith('def '):
                 yield 0, "E704 multiple statements on one line (def)"
@@ -903,10 +976,15 @@ def explicit_line_join(logical_line, tokens):
     Okay: aaa = [123,\n       123]
     Okay: aaa = ("bbb "\n       "ccc")
     Okay: aaa = "bbb " \\n    "ccc"
+    Okay: aaa = 123  # \\
     """
     prev_start = prev_end = parens = 0
+    comment = False
+    backslash = None
     for token_type, text, start, end, line in tokens:
-        if start[0] != prev_start and parens and backslash:
+        if token_type == tokenize.COMMENT:
+            comment = True
+        if start[0] != prev_start and parens and backslash and not comment:
             yield backslash, "E502 the backslash is redundant between brackets"
         if end[0] != prev_end:
             if line.rstrip('\r\n').endswith('\\'):
@@ -923,6 +1001,45 @@ def explicit_line_join(logical_line, tokens):
                 parens -= 1
 
 
+def break_around_binary_operator(logical_line, tokens):
+    r"""
+    Avoid breaks before binary operators.
+
+    The preferred place to break around a binary operator is after the
+    operator, not before it.
+
+    W503: (width == 0\n + height == 0)
+    W503: (width == 0\n and height == 0)
+
+    Okay: (width == 0 +\n height == 0)
+    Okay: foo(\n    -x)
+    Okay: foo(x\n    [])
+    Okay: x = '''\n''' + ''
+    Okay: foo(x,\n    -y)
+    Okay: foo(x,  # comment\n    -y)
+    """
+    def is_binary_operator(token_type, text):
+        # The % character is strictly speaking a binary operator, but the
+        # common usage seems to be to put it next to the format parameters,
+        # after a line break.
+        return ((token_type == tokenize.OP or text in ['and', 'or']) and
+                text not in "()[]{},:.;@=%")
+
+    line_break = False
+    unary_context = True
+    for token_type, text, start, end, line in tokens:
+        if token_type == tokenize.COMMENT:
+            continue
+        if ('\n' in text or '\r' in text) and token_type != tokenize.STRING:
+            line_break = True
+        else:
+            if (is_binary_operator(token_type, text) and line_break and
+                    not unary_context):
+                yield start, "W503 line break before binary operator"
+            unary_context = text in '([{,;'
+            line_break = False
+
+
 def comparison_to_singleton(logical_line, noqa):
     r"""Comparison to singletons should use "is" or "is not".
 
@@ -931,7 +1048,9 @@ def comparison_to_singleton(logical_line, noqa):
 
     Okay: if arg is not None:
     E711: if arg != None:
+    E711: if None == arg:
     E712: if arg == True:
+    E712: if False == arg:
 
     Also, beware of writing if x when you really mean if x is not None --
     e.g. when testing whether a variable or argument that defaults to None was
@@ -940,8 +1059,9 @@ def comparison_to_singleton(logical_line, noqa):
     """
     match = not noqa and COMPARE_SINGLETON_REGEX.search(logical_line)
     if match:
-        same = (match.group(1) == '==')
-        singleton = match.group(2)
+        singleton = match.group(1) or match.group(3)
+        same = (match.group(2) == '==')
+
         msg = "'if cond is %s:'" % (('' if same else 'not ') + singleton)
         if singleton in ('None',):
             code = 'E711'
@@ -950,7 +1070,7 @@ def comparison_to_singleton(logical_line, noqa):
             nonzero = ((singleton == 'True' and same) or
                        (singleton == 'False' and not same))
             msg += " or 'if %scond:'" % ('' if nonzero else 'not ')
-        yield match.start(1), ("%s comparison to %s should be %s" %
+        yield match.start(2), ("%s comparison to %s should be %s" %
                                (code, singleton, msg))
 
 
@@ -975,7 +1095,7 @@ def comparison_negative(logical_line):
             yield pos, "E714 test for object identity should be 'is not'"
 
 
-def comparison_type(logical_line):
+def comparison_type(logical_line, noqa):
     r"""Object type comparisons should always use isinstance().
 
     Do not compare types directly.
@@ -991,7 +1111,7 @@ def comparison_type(logical_line):
     Okay: if type(a1) is type(b1):
     """
     match = COMPARE_TYPE_REGEX.search(logical_line)
-    if match:
+    if match and not noqa:
         inst = match.group(1)
         if inst and isidentifier(inst) and inst not in SINGLETONS:
             return  # Allow comparison for types which are not obvious
@@ -1057,7 +1177,7 @@ def readlines(filename):
         """Read the source code."""
         with open(filename, 'rU') as f:
             return f.readlines()
-    isidentifier = re.compile(r'[a-zA-Z_]\w*').match
+    isidentifier = re.compile(r'[a-zA-Z_]\w*$').match
     stdin_get_value = sys.stdin.read
 else:
     # Python 3
@@ -1156,10 +1276,13 @@ def normalize_paths(value, parent=os.curdir):
 
     Return a list of absolute paths.
     """
-    if not value or isinstance(value, list):
+    if not value:
+        return []
+    if isinstance(value, list):
         return value
     paths = []
     for path in value.split(','):
+        path = path.strip()
         if '/' in path:
             path = os.path.abspath(os.path.join(parent, path))
         paths.append(path.rstrip('/'))
@@ -1176,14 +1299,12 @@ def filename_match(filename, patterns, default=True):
     return any(fnmatch(filename, pattern) for pattern in patterns)
 
 
+def _is_eol_token(token):
+    return token[0] in NEWLINE or token[4][token[3][1]:].lstrip() == '\\\n'
 if COMMENT_WITH_NL:
-    def _is_eol_token(token):
-        return (token[0] in NEWLINE or
-                (token[0] == tokenize.COMMENT and token[1] == token[4]))
-else:
-    def _is_eol_token(token):
-        return token[0] in NEWLINE
-
+    def _is_eol_token(token, _eol_token=_is_eol_token):
+        return _eol_token(token) or (token[0] == tokenize.COMMENT and
+                                     token[1] == token[4])
 
 ##############################################################################
 # Framework to run all checks
@@ -1240,6 +1361,8 @@ def __init__(self, filename=None, lines=None,
         self.hang_closing = options.hang_closing
         self.verbose = options.verbose
         self.filename = filename
+        # Dictionary where a checker can store its custom state.
+        self._checker_states = {}
         if filename is None:
             self.filename = 'stdin'
             self.lines = lines or []
@@ -1295,10 +1418,16 @@ def run_check(self, check, argument_names):
             arguments.append(getattr(self, name))
         return check(*arguments)
 
+    def init_checker_state(self, name, argument_names):
+        """ Prepares a custom state for the specific checker plugin."""
+        if 'checker_state' in argument_names:
+            self.checker_state = self._checker_states.setdefault(name, {})
+
     def check_physical(self, line):
         """Run all physical checks on a raw input line."""
         self.physical_line = line
         for name, check, argument_names in self._physical_checks:
+            self.init_checker_state(name, argument_names)
             result = self.run_check(check, argument_names)
             if result is not None:
                 (offset, text) = result
@@ -1326,8 +1455,8 @@ def build_tokens_line(self):
                 (start_row, start_col) = start
                 if prev_row != start_row:    # different row
                     prev_text = self.lines[prev_row - 1][prev_col - 1]
-                    if prev_text == ',' or (prev_text not in '{[('
-                                            and text not in '}])'):
+                    if prev_text == ',' or (prev_text not in '{[(' and
+                                            text not in '}])'):
                         text = ' ' + text
                 elif prev_col != start_col:  # different column
                     text = line[prev_col:start_col] + text
@@ -1343,6 +1472,10 @@ def check_logical(self):
         """Build a line from tokens and run all logical checks on it."""
         self.report.increment_logical_line()
         mapping = self.build_tokens_line()
+
+        if not mapping:
+            return
+
         (start_row, start_col) = mapping[0][1]
         start_line = self.lines[start_row - 1]
         self.indent_level = expand_indent(start_line[:start_col])
@@ -1353,6 +1486,7 @@ def check_logical(self):
         for name, check, argument_names in self._logical_checks:
             if self.verbose >= 4:
                 print('   ' + name)
+            self.init_checker_state(name, argument_names)
             for offset, text in self.run_check(check, argument_names) or ():
                 if not isinstance(offset, tuple):
                     for token_offset, pos in mapping:
@@ -1614,6 +1748,14 @@ def get_file_results(self):
                 print(re.sub(r'\S', ' ', line[:offset]) + '^')
             if self._show_pep8 and doc:
                 print('    ' + doc.strip())
+
+            # stdout is block buffered when not stdout.isatty().
+            # line can be broken where buffer boundary since other processes
+            # write to same file.
+            # flush() after print() to avoid buffer boundary.
+            # Typical buffer size is 8192. line written safely when
+            # len(line) < 8192.
+            sys.stdout.flush()
         return self.file_errors
 
 
@@ -1637,7 +1779,7 @@ def __init__(self, *args, **kwargs):
         # build options from the command line
         self.checker_class = kwargs.pop('checker_class', Checker)
         parse_argv = kwargs.pop('parse_argv', False)
-        config_file = kwargs.pop('config_file', None)
+        config_file = kwargs.pop('config_file', False)
         parser = kwargs.pop('parser', None)
         # build options from dict
         options_dict = dict(*args, **kwargs)
@@ -1790,7 +1932,8 @@ def get_parser(prog='pep8', version=__version__):
     parser.add_option('--select', metavar='errors', default='',
                       help="select errors and warnings (e.g. E,W6)")
     parser.add_option('--ignore', metavar='errors', default='',
-                      help="skip errors and warnings (e.g. E4,W)")
+                      help="skip errors and warnings (e.g. E4,W) "
+                           "(default: %s)" % DEFAULT_IGNORE)
     parser.add_option('--show-source', action='store_true',
                       help="show source code for each error")
     parser.add_option('--show-pep8', action='store_true',
@@ -1826,25 +1969,40 @@ def get_parser(prog='pep8', version=__version__):
 
 
 def read_config(options, args, arglist, parser):
-    """Read both user configuration and local configuration."""
+    """Read and parse configurations
+
+    If a config file is specified on the command line with the "--config"
+    option, then only it is used for configuration.
+
+    Otherwise, the user configuration (~/.config/pep8) and any local
+    configurations in the current directory or above will be merged together
+    (in that order) using the read method of ConfigParser.
+    """
     config = RawConfigParser()
 
-    user_conf = options.config
-    if user_conf and os.path.isfile(user_conf):
-        if options.verbose:
-            print('user configuration: %s' % user_conf)
-        config.read(user_conf)
+    cli_conf = options.config
 
     local_dir = os.curdir
+
+    if USER_CONFIG and os.path.isfile(USER_CONFIG):
+        if options.verbose:
+            print('user configuration: %s' % USER_CONFIG)
+        config.read(USER_CONFIG)
+
     parent = tail = args and os.path.abspath(os.path.commonprefix(args))
     while tail:
-        if config.read([os.path.join(parent, fn) for fn in PROJECT_CONFIG]):
+        if config.read(os.path.join(parent, fn) for fn in PROJECT_CONFIG):
             local_dir = parent
             if options.verbose:
                 print('local configuration: in %s' % parent)
             break
         (parent, tail) = os.path.split(parent)
 
+    if cli_conf and os.path.isfile(cli_conf):
+        if options.verbose:
+            print('cli configuration: %s' % cli_conf)
+        config.read(cli_conf)
+
     pep8_section = parser.prog
     if config.has_section(pep8_section):
         option_list = dict([(o.dest, o.type or o.action)
@@ -1881,19 +2039,21 @@ def read_config(options, args, arglist, parser):
 
 def process_options(arglist=None, parse_argv=False, config_file=None,
                     parser=None):
-    """Process options passed either via arglist or via command line args."""
+    """Process options passed either via arglist or via command line args.
+
+    Passing in the ``config_file`` parameter allows other tools, such as flake8
+    to specify their own options to be processed in pep8.
+    """
     if not parser:
         parser = get_parser()
     if not parser.has_option('--config'):
-        if config_file is True:
-            config_file = DEFAULT_CONFIG
         group = parser.add_option_group("Configuration", description=(
             "The project options are read from the [%s] section of the "
             "tox.ini file or the setup.cfg file located in any parent folder "
             "of the path(s) being processed.  Allowed options are: %s." %
             (parser.prog, ', '.join(parser.config_options))))
         group.add_option('--config', metavar='path', default=config_file,
-                         help="user config file location (default: %default)")
+                         help="user config file location")
     # Don't read the command line if the module is used as a library.
     if not arglist and not parse_argv:
         arglist = []
@@ -1938,7 +2098,7 @@ def _main():
     except AttributeError:
         pass    # not supported on Windows
 
-    pep8style = StyleGuide(parse_argv=True, config_file=True)
+    pep8style = StyleGuide(parse_argv=True)
     options = pep8style.options
     if options.doctest or options.testsuite:
         from testsuite.support import run_tests
diff --git a/pymode/libs/pylama/lint/pylama_pyflakes/__init__.py b/pymode/libs/pylama/lint/pylama_pyflakes/__init__.py
index 72fc26fe..9c41d3f6 100644
--- a/pymode/libs/pylama/lint/pylama_pyflakes/__init__.py
+++ b/pymode/libs/pylama/lint/pylama_pyflakes/__init__.py
@@ -49,17 +49,17 @@ def run(path, code=None, params=None, **meta):
 def monkey_patch_messages(messages):
     """ Patch pyflakes messages. """
 
-    messages.LateFutureImport.message = "W0410 future import(s) %r after other statements"
-    messages.ImportStarUsed.message = "W0401 'from %s import *' used; unable to detect undefined names"
-    messages.RedefinedWhileUnused.message = "W0404 redefinition of unused %r from line %r"
-    messages.DoctestSyntaxError.message = "W0511 syntax error in doctest"
     messages.UnusedImport.message = "W0611 %r imported but unused"
-    messages.UnusedVariable.message = "W0612 local variable %r is assigned to but never used"
+    messages.RedefinedWhileUnused.message = "W0404 redefinition of unused %r from line %r"
     messages.RedefinedInListComp.message = "W0621 list comprehension redefines %r from line %r"
-    messages.Redefined.message = "W0621 redefinition of %r from line %r"
     messages.ImportShadowedByLoopVar.message = "W0621 import %r from line %r shadowed by loop variable"
-    messages.ReturnWithArgsInsideGenerator.message = "E0106 'return' with argument inside generator"
+    messages.ImportStarUsed.message = "W0401 'from %s import *' used; unable to detect undefined names"
     messages.UndefinedName.message = "E0602 undefined name %r"
-    messages.UndefinedLocal.message = "E0602 local variable %r (defined in enclosing scope on line %r) referenced before assignment"
+    messages.DoctestSyntaxError.message = "W0511 syntax error in doctest"
     messages.UndefinedExport.message = "E0603 undefined name %r in __all__"
+    messages.UndefinedLocal.message = "E0602 local variable %r (defined in enclosing scope on line %r) referenced before assignment"
     messages.DuplicateArgument.message = "E1122 duplicate argument %r in function definition"
+    messages.LateFutureImport.message = "W0410 future import(s) %r after other statements"
+    messages.UnusedVariable.message = "W0612 local variable %r is assigned to but never used"
+    messages.ReturnWithArgsInsideGenerator.message = "E0106 'return' with argument inside generator"
+    messages.ReturnOutsideFunction.message = "E0104 'return' outside function"
diff --git a/pymode/libs/pylama/lint/pylama_pyflakes/pyflakes/checker.py b/pymode/libs/pylama/lint/pylama_pyflakes/pyflakes/checker.py
index 70558324..df2f9074 100644
--- a/pymode/libs/pylama/lint/pylama_pyflakes/pyflakes/checker.py
+++ b/pymode/libs/pylama/lint/pylama_pyflakes/pyflakes/checker.py
@@ -471,7 +471,7 @@ def handleNodeLoad(self, node):
             return
 
         scopes = [scope for scope in self.scopeStack[:-1]
-                  if isinstance(scope, (FunctionScope, ModuleScope))]
+                  if isinstance(scope, (FunctionScope, ModuleScope, GeneratorScope))]
         if isinstance(self.scope, GeneratorScope) and scopes[-1] != self.scopeStack[-2]:
             scopes.append(self.scopeStack[-2])
 
@@ -531,9 +531,27 @@ def handleNodeStore(self, node):
         self.addBinding(node, binding)
 
     def handleNodeDelete(self, node):
+
+        def on_conditional_branch():
+            """
+            Return `True` if node is part of a conditional body.
+            """
+            current = getattr(node, 'parent', None)
+            while current:
+                if isinstance(current, (ast.If, ast.While, ast.IfExp)):
+                    return True
+                current = getattr(current, 'parent', None)
+            return False
+
         name = getNodeName(node)
         if not name:
             return
+
+        if on_conditional_branch():
+            # We can not predict if this conditional branch is going to
+            # be executed.
+            return
+
         if isinstance(self.scope, FunctionScope) and name in self.scope.globals:
             self.scope.globals.remove(name)
         else:
@@ -654,7 +672,7 @@ def ignore(self, node):
         EQ = NOTEQ = LT = LTE = GT = GTE = IS = ISNOT = IN = NOTIN = ignore
 
     # additional node types
-    LISTCOMP = COMPREHENSION = KEYWORD = handleChildren
+    COMPREHENSION = KEYWORD = handleChildren
 
     def GLOBAL(self, node):
         """
@@ -670,6 +688,8 @@ def GENERATOREXP(self, node):
         self.handleChildren(node)
         self.popScope()
 
+    LISTCOMP = handleChildren if PY2 else GENERATOREXP
+
     DICTCOMP = SETCOMP = GENERATOREXP
 
     def NAME(self, node):
@@ -693,6 +713,10 @@ def NAME(self, node):
             raise RuntimeError("Got impossible expression context: %r" % (node.ctx,))
 
     def RETURN(self, node):
+        if isinstance(self.scope, ClassScope):
+            self.report(messages.ReturnOutsideFunction, node)
+            return
+
         if (
             node.value and
             hasattr(self.scope, 'returnValue') and
diff --git a/pymode/libs/pylama/lint/pylama_pyflakes/pyflakes/messages.py b/pymode/libs/pylama/lint/pylama_pyflakes/pyflakes/messages.py
index 1f799ec5..8899b7b0 100644
--- a/pymode/libs/pylama/lint/pylama_pyflakes/pyflakes/messages.py
+++ b/pymode/libs/pylama/lint/pylama_pyflakes/pyflakes/messages.py
@@ -100,14 +100,6 @@ def __init__(self, filename, loc, name):
         self.message_args = (name,)
 
 
-class Redefined(Message):
-    message = 'redefinition of %r from line %r'
-
-    def __init__(self, filename, loc, name, orig_loc):
-        Message.__init__(self, filename, loc)
-        self.message_args = (name, orig_loc.lineno)
-
-
 class LateFutureImport(Message):
     message = 'future import(s) %r after other statements'
 
@@ -133,3 +125,10 @@ class ReturnWithArgsInsideGenerator(Message):
     Indicates a return statement with arguments inside a generator.
     """
     message = '\'return\' with argument inside generator'
+
+
+class ReturnOutsideFunction(Message):
+    """
+    Indicates a return statement outside of a function/method.
+    """
+    message = '\'return\' outside function'
diff --git a/pymode/libs/pylama/lint/pylama_pylint/__init__.py b/pymode/libs/pylama/lint/pylama_pylint/__init__.py
deleted file mode 100644
index 6ec4f3ba..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-""" Description. """
-
-# Module information
-# ==================
-
-
-__version__ = "0.3.1"
-__project__ = "pylama_pylint"
-__author__ = "horneds <horneds@gmail.com>"
-__license__ = "BSD"
-
-import sys
-if sys.version_info >= (3, 0, 0):
-    raise ImportError("pylama_pylint doesnt support python3")
-
-from .main import Linter
-assert Linter
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/__init__.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/__init__.py
deleted file mode 100644
index 19c80902..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/__init__.py
+++ /dev/null
@@ -1,118 +0,0 @@
-# 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/>.
-"""Python Abstract Syntax Tree New Generation
-
-The aim of this module is to provide a common base representation of
-python source code for projects such as pychecker, pyreverse,
-pylint... Well, actually the development of this library is essentially
-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
-object. Methods are added by monkey patching ast classes.
-
-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
-  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
-"""
-__doctype__ = "restructuredtext en"
-
-import sys
-import re
-from operator import attrgetter
-
-# WARNING: internal imports order matters !
-
-# make all exception classes accessible from astroid package
-from astroid.exceptions import *
-
-# make all node classes accessible from astroid package
-from astroid.nodes import *
-
-# trigger extra monkey-patching
-from astroid 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
-
-# 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])
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/__pkginfo__.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/__pkginfo__.py
deleted file mode 100644
index 85398ff1..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/__pkginfo__.py
+++ /dev/null
@@ -1,48 +0,0 @@
-# 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/>.
-"""astroid packaging information"""
-
-distname = 'astroid'
-
-modname = 'astroid'
-
-numversion = (1, 1, 1)
-version = '.'.join([str(num) for num in numversion])
-
-install_requires = ['logilab-common >= 0.60.0']
-
-license = 'LGPL'
-
-author = 'Logilab'
-author_email = 'python-projects@lists.logilab.org'
-mailinglist = "mailto://%s" % author_email
-web = 'http://bitbucket.org/logilab/astroid'
-
-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",
-               ]
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/as_string.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/as_string.py
deleted file mode 100644
index ace1c4e3..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/as_string.py
+++ /dev/null
@@ -1,496 +0,0 @@
-# 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 renders Astroid nodes as string:
-
-* :func:`to_code` function return equivalent (hopefuly valid) python string
-
-* :func:`dump` function return an internal representation of nodes found
-  in the tree, useful for debugging or understanding the tree structure
-"""
-
-import sys
-
-INDENT = '    ' # 4 spaces ; keep indentation variable
-
-
-def dump(node, ids=False):
-    """print a nice astroid tree representation.
-
-    :param ids: if true, we also print the ids (usefull for debugging)
-    """
-    result = []
-    _repr_tree(node, result, ids=ids)
-    return "\n".join(result)
-
-def _repr_tree(node, result, indent='', _done=None, ids=False):
-    """built a tree representation of a node as a list of lines"""
-    if _done is None:
-        _done = set()
-    if not hasattr(node, '_astroid_fields'): # not a astroid node
-        return
-    if node in _done:
-        result.append( indent + 'loop in tree: %s' % node )
-        return
-    _done.add(node)
-    node_str = str(node)
-    if ids:
-        node_str += '  . \t%x' % id(node)
-    result.append( indent + node_str )
-    indent += INDENT
-    for field in node._astroid_fields:
-        value = getattr(node, field)
-        if isinstance(value, (list, tuple) ):
-            result.append(  indent + field + " = [" )
-            for child in value:
-                if isinstance(child, (list, tuple) ):
-                    # special case for Dict # FIXME
-                    _repr_tree(child[0], result, indent, _done, ids)
-                    _repr_tree(child[1], result, indent, _done, ids)
-                    result.append(indent + ',')
-                else:
-                    _repr_tree(child, result, indent, _done, ids)
-            result.append(  indent + "]" )
-        else:
-            result.append(  indent + field + " = " )
-            _repr_tree(value, result, indent, _done, ids)
-
-
-class AsStringVisitor(object):
-    """Visitor to render an Astroid node as a valid python code string"""
-
-    def __call__(self, node):
-        """Makes this visitor behave as a simple function"""
-        return node.accept(self)
-
-    def _stmt_list(self, stmts):
-        """return a list of nodes to string"""
-        stmts = '\n'.join([nstr for nstr in [n.accept(self) for n in stmts] if nstr])
-        return INDENT + stmts.replace('\n', '\n'+INDENT)
-
-
-    ## visit_<node> methods ###########################################
-
-    def visit_arguments(self, node):
-        """return an astroid.Function node as string"""
-        return node.format_args()
-
-    def visit_assattr(self, node):
-        """return an astroid.AssAttr node as string"""
-        return self.visit_getattr(node)
-
-    def visit_assert(self, node):
-        """return an astroid.Assert node as string"""
-        if node.fail:
-            return 'assert %s, %s' % (node.test.accept(self),
-                                        node.fail.accept(self))
-        return 'assert %s' % node.test.accept(self)
-
-    def visit_assname(self, node):
-        """return an astroid.AssName node as string"""
-        return node.name
-
-    def visit_assign(self, node):
-        """return an astroid.Assign node as string"""
-        lhs = ' = '.join([n.accept(self) for n in node.targets])
-        return '%s = %s' % (lhs, node.value.accept(self))
-
-    def visit_augassign(self, node):
-        """return an astroid.AugAssign node as string"""
-        return '%s %s %s' % (node.target.accept(self), node.op, node.value.accept(self))
-
-    def visit_backquote(self, node):
-        """return an astroid.Backquote node as string"""
-        return '`%s`' % node.value.accept(self)
-
-    def visit_binop(self, node):
-        """return an astroid.BinOp node as string"""
-        return '(%s) %s (%s)' % (node.left.accept(self), node.op, node.right.accept(self))
-
-    def visit_boolop(self, node):
-        """return an astroid.BoolOp node as string"""
-        return (' %s ' % node.op).join(['(%s)' % n.accept(self)
-                                            for n in node.values])
-
-    def visit_break(self, node):
-        """return an astroid.Break node as string"""
-        return 'break'
-
-    def visit_callfunc(self, node):
-        """return an astroid.CallFunc node as string"""
-        expr_str = node.func.accept(self)
-        args = [arg.accept(self) for arg in node.args]
-        if node.starargs:
-            args.append( '*' + node.starargs.accept(self))
-        if node.kwargs:
-            args.append( '**' + node.kwargs.accept(self))
-        return '%s(%s)' % (expr_str, ', '.join(args))
-
-    def visit_class(self, node):
-        """return an astroid.Class node as string"""
-        decorate = node.decorators and node.decorators.accept(self)  or ''
-        bases =  ', '.join([n.accept(self) for n in node.bases])
-        if sys.version_info[0] == 2:
-            bases = bases and '(%s)' % bases or ''
-        else:
-            metaclass = node.metaclass()
-            if metaclass:
-                if bases:
-                    bases = '(%s, metaclass=%s)' % (bases, metaclass.name)
-                else:
-                    bases = '(metaclass=%s)' % metaclass.name
-            else:
-                bases = bases and '(%s)' % bases or ''
-        docs = node.doc and '\n%s"""%s"""' % (INDENT, node.doc) or ''
-        return '\n\n%sclass %s%s:%s\n%s\n' % (decorate, node.name, bases, docs,
-                                            self._stmt_list( node.body))
-
-    def visit_compare(self, node):
-        """return an astroid.Compare node as string"""
-        rhs_str = ' '.join(['%s %s' % (op, expr.accept(self))
-                            for op, expr in node.ops])
-        return '%s %s' % (node.left.accept(self), rhs_str)
-
-    def visit_comprehension(self, node):
-        """return an astroid.Comprehension node as string"""
-        ifs = ''.join([ ' if %s' % n.accept(self) for n in node.ifs])
-        return 'for %s in %s%s' % (node.target.accept(self),
-                                    node.iter.accept(self), ifs )
-
-    def visit_const(self, node):
-        """return an astroid.Const node as string"""
-        return repr(node.value)
-
-    def visit_continue(self, node):
-        """return an astroid.Continue node as string"""
-        return 'continue'
-
-    def visit_delete(self, node): # XXX check if correct
-        """return an astroid.Delete node as string"""
-        return 'del %s' % ', '.join([child.accept(self)
-                                for child in node.targets])
-
-    def visit_delattr(self, node):
-        """return an astroid.DelAttr node as string"""
-        return self.visit_getattr(node)
-
-    def visit_delname(self, node):
-        """return an astroid.DelName node as string"""
-        return node.name
-
-    def visit_decorators(self, node):
-        """return an astroid.Decorators node as string"""
-        return '@%s\n' % '\n@'.join([item.accept(self) for item in node.nodes])
-
-    def visit_dict(self, node):
-        """return an astroid.Dict node as string"""
-        return '{%s}' % ', '.join(['%s: %s' % (key.accept(self),
-                            value.accept(self)) for key, value in node.items])
-
-    def visit_dictcomp(self, node):
-        """return an astroid.DictComp node as string"""
-        return '{%s: %s %s}' % (node.key.accept(self), node.value.accept(self),
-                ' '.join([n.accept(self) for n in node.generators]))
-
-    def visit_discard(self, node):
-        """return an astroid.Discard node as string"""
-        return node.value.accept(self)
-
-    def visit_emptynode(self, node):
-        """dummy method for visiting an Empty node"""
-        return ''
-
-    def visit_excepthandler(self, node):
-        if node.type:
-            if node.name:
-                excs = 'except %s, %s' % (node.type.accept(self),
-                                        node.name.accept(self))
-            else:
-                excs = 'except %s' % node.type.accept(self)
-        else:
-            excs = 'except'
-        return '%s:\n%s' % (excs, self._stmt_list(node.body))
-
-    def visit_ellipsis(self, node):
-        """return an astroid.Ellipsis node as string"""
-        return '...'
-
-    def visit_empty(self, node):
-        """return an Empty node as string"""
-        return ''
-
-    def visit_exec(self, node):
-        """return an astroid.Exec node as string"""
-        if node.locals:
-            return 'exec %s in %s, %s' % (node.expr.accept(self),
-                                          node.locals.accept(self),
-                                          node.globals.accept(self))
-        if node.globals:
-            return 'exec %s in %s' % (node.expr.accept(self),
-                                      node.globals.accept(self))
-        return 'exec %s' % node.expr.accept(self)
-
-    def visit_extslice(self, node):
-        """return an astroid.ExtSlice node as string"""
-        return ','.join( [dim.accept(self) for dim in node.dims] )
-
-    def visit_for(self, node):
-        """return an astroid.For node as string"""
-        fors = 'for %s in %s:\n%s' % (node.target.accept(self),
-                                    node.iter.accept(self),
-                                    self._stmt_list( node.body))
-        if node.orelse:
-            fors = '%s\nelse:\n%s' % (fors, self._stmt_list(node.orelse))
-        return fors
-
-    def visit_from(self, node):
-        """return an astroid.From node as string"""
-        return 'from %s import %s' % ('.' * (node.level or 0) + node.modname,
-                                      _import_string(node.names))
-
-    def visit_function(self, node):
-        """return an astroid.Function node as string"""
-        decorate = node.decorators and node.decorators.accept(self)  or ''
-        docs = node.doc and '\n%s"""%s"""' % (INDENT, node.doc) or ''
-        return '\n%sdef %s(%s):%s\n%s' % (decorate, node.name, node.args.accept(self),
-                                        docs, self._stmt_list(node.body))
-
-    def visit_genexpr(self, node):
-        """return an astroid.GenExpr node as string"""
-        return '(%s %s)' % (node.elt.accept(self), ' '.join([n.accept(self)
-                                                    for n in node.generators]))
-
-    def visit_getattr(self, node):
-        """return an astroid.Getattr node as string"""
-        return '%s.%s' % (node.expr.accept(self), node.attrname)
-
-    def visit_global(self, node):
-        """return an astroid.Global node as string"""
-        return 'global %s' % ', '.join(node.names)
-
-    def visit_if(self, node):
-        """return an astroid.If node as string"""
-        ifs = ['if %s:\n%s' % (node.test.accept(self), self._stmt_list(node.body))]
-        if node.orelse:# XXX use elif ???
-            ifs.append('else:\n%s' % self._stmt_list(node.orelse))
-        return '\n'.join(ifs)
-
-    def visit_ifexp(self, node):
-        """return an astroid.IfExp node as string"""
-        return '%s if %s else %s' % (node.body.accept(self),
-                node.test.accept(self), node.orelse.accept(self))
-
-    def visit_import(self, node):
-        """return an astroid.Import node as string"""
-        return 'import %s' % _import_string(node.names)
-
-    def visit_keyword(self, node):
-        """return an astroid.Keyword node as string"""
-        return '%s=%s' % (node.arg, node.value.accept(self))
-
-    def visit_lambda(self, node):
-        """return an astroid.Lambda node as string"""
-        return 'lambda %s: %s' % (node.args.accept(self), node.body.accept(self))
-
-    def visit_list(self, node):
-        """return an astroid.List node as string"""
-        return '[%s]' % ', '.join([child.accept(self) for child in node.elts])
-
-    def visit_listcomp(self, node):
-        """return an astroid.ListComp node as string"""
-        return '[%s %s]' % (node.elt.accept(self), ' '.join([n.accept(self)
-                                                for n in node.generators]))
-
-    def visit_module(self, node):
-        """return an astroid.Module node as string"""
-        docs = node.doc and '"""%s"""\n\n' % node.doc or ''
-        return docs + '\n'.join([n.accept(self) for n in node.body]) + '\n\n'
-
-    def visit_name(self, node):
-        """return an astroid.Name node as string"""
-        return node.name
-
-    def visit_pass(self, node):
-        """return an astroid.Pass node as string"""
-        return 'pass'
-
-    def visit_print(self, node):
-        """return an astroid.Print node as string"""
-        nodes = ', '.join([n.accept(self) for n in node.values])
-        if not node.nl:
-            nodes = '%s,' % nodes
-        if node.dest:
-            return 'print >> %s, %s' % (node.dest.accept(self), nodes)
-        return 'print %s' % nodes
-
-    def visit_raise(self, node):
-        """return an astroid.Raise node as string"""
-        if node.exc:
-            if node.inst:
-                if node.tback:
-                    return 'raise %s, %s, %s' % (node.exc.accept(self),
-                                                node.inst.accept(self),
-                                                node.tback.accept(self))
-                return 'raise %s, %s' % (node.exc.accept(self),
-                                        node.inst.accept(self))
-            return 'raise %s' % node.exc.accept(self)
-        return 'raise'
-
-    def visit_return(self, node):
-        """return an astroid.Return node as string"""
-        if node.value:
-            return 'return %s' % node.value.accept(self)
-        else:
-            return 'return'
-
-    def visit_index(self, node):
-        """return a astroid.Index node as string"""
-        return node.value.accept(self)
-
-    def visit_set(self, node):
-        """return an astroid.Set node as string"""
-        return '{%s}' % ', '.join([child.accept(self) for child in node.elts])
-
-    def visit_setcomp(self, node):
-        """return an astroid.SetComp node as string"""
-        return '{%s %s}' % (node.elt.accept(self), ' '.join([n.accept(self)
-                                                for n in node.generators]))
-
-    def visit_slice(self, node):
-        """return a astroid.Slice node as string"""
-        lower = node.lower and node.lower.accept(self) or ''
-        upper = node.upper and node.upper.accept(self) or ''
-        step = node.step and node.step.accept(self) or ''
-        if step:
-            return '%s:%s:%s' % (lower, upper, step)
-        return  '%s:%s' % (lower, upper)
-
-    def visit_subscript(self, node):
-        """return an astroid.Subscript node as string"""
-        return '%s[%s]' % (node.value.accept(self), node.slice.accept(self))
-
-    def visit_tryexcept(self, node):
-        """return an astroid.TryExcept node as string"""
-        trys = ['try:\n%s' % self._stmt_list( node.body)]
-        for handler in node.handlers:
-            trys.append(handler.accept(self))
-        if node.orelse:
-            trys.append('else:\n%s' % self._stmt_list(node.orelse))
-        return '\n'.join(trys)
-
-    def visit_tryfinally(self, node):
-        """return an astroid.TryFinally node as string"""
-        return 'try:\n%s\nfinally:\n%s' % (self._stmt_list( node.body),
-                                        self._stmt_list(node.finalbody))
-
-    def visit_tuple(self, node):
-        """return an astroid.Tuple node as string"""
-        if len(node.elts) == 1:
-            return '(%s, )' % node.elts[0].accept(self) 
-        return '(%s)' % ', '.join([child.accept(self) for child in node.elts])
-
-    def visit_unaryop(self, node):
-        """return an astroid.UnaryOp node as string"""
-        if node.op == 'not':
-            operator = 'not '
-        else:
-            operator = node.op
-        return '%s%s' % (operator, node.operand.accept(self))
-
-    def visit_while(self, node):
-        """return an astroid.While node as string"""
-        whiles = 'while %s:\n%s' % (node.test.accept(self),
-                                    self._stmt_list(node.body))
-        if node.orelse:
-            whiles = '%s\nelse:\n%s' % (whiles, self._stmt_list(node.orelse))
-        return whiles
-
-    def visit_with(self, node): # 'with' without 'as' is possible
-        """return an astroid.With node as string"""
-        items = ', '.join(('(%s)' % expr.accept(self)) +
-                          (vars and ' as (%s)' % (vars.accept(self)) or '')
-                          for expr, vars in node.items)
-        return 'with %s:\n%s' % (items, self._stmt_list( node.body))
-
-    def visit_yield(self, node):
-        """yield an ast.Yield node as string"""
-        yi_val = node.value and (" " + node.value.accept(self)) or ""
-        expr = 'yield' + yi_val
-        if node.parent.is_statement:
-            return expr
-        else:
-            return "(%s)" % (expr,)
-
-
-class AsStringVisitor3k(AsStringVisitor):
-    """AsStringVisitor3k overwrites some AsStringVisitor methods"""
-
-    def visit_excepthandler(self, node):
-        if node.type:
-            if node.name:
-                excs = 'except %s as %s' % (node.type.accept(self),
-                                        node.name.accept(self))
-            else:
-                excs = 'except %s' % node.type.accept(self)
-        else:
-            excs = 'except'
-        return '%s:\n%s' % (excs, self._stmt_list(node.body))
-
-    def visit_nonlocal(self, node):
-        """return an astroid.Nonlocal node as string"""
-        return 'nonlocal %s' % ', '.join(node.names)
-
-    def visit_raise(self, node):
-        """return an astroid.Raise node as string"""
-        if node.exc:
-            if node.cause:
-                return 'raise %s from %s' % (node.exc.accept(self),
-                                             node.cause.accept(self))
-            return 'raise %s' % node.exc.accept(self)
-        return 'raise'
-
-    def visit_starred(self, node):
-        """return Starred node as string"""
-        return "*" + node.value.accept(self)
-
-    def visit_yieldfrom(self, node):
-        """ Return an astroid.YieldFrom node as string. """
-        yi_val = node.value and (" " + node.value.accept(self)) or ""
-        expr = 'yield from' + yi_val
-        if node.parent.is_statement:
-            return expr
-        else:
-            return "(%s)" % (expr,)
-
-
-def _import_string(names):
-    """return a list of (name, asname) formatted as a string"""
-    _names = []
-    for name, asname in names:
-        if asname is not None:
-            _names.append('%s as %s' % (name, asname))
-        else:
-            _names.append(name)
-    return  ', '.join(_names)
-
-
-if sys.version_info >= (3, 0):
-    AsStringVisitor = AsStringVisitor3k
-
-# this visitor is stateless, thus it can be reused
-to_code = AsStringVisitor()
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/bases.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/bases.py
deleted file mode 100644
index 5ee11b3b..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/bases.py
+++ /dev/null
@@ -1,618 +0,0 @@
-# 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 base classes and functions for the nodes and some
-inference utils.
-"""
-
-__docformat__ = "restructuredtext en"
-
-import sys
-from contextlib import contextmanager
-
-from astroid.exceptions import (InferenceError, AstroidError, NotFoundError,
-                                UnresolvableName, UseInferenceDefault)
-
-
-if sys.version_info >= (3, 0):
-    BUILTINS = 'builtins'
-else:
-    BUILTINS = '__builtin__'
-
-
-class Proxy(object):
-    """a simple proxy object"""
-
-    _proxied = None # proxied object may be set by class or by instance
-
-    def __init__(self, proxied=None):
-        if proxied is not None:
-            self._proxied = proxied
-
-    def __getattr__(self, name):
-        if name == '_proxied':
-            return getattr(self.__class__, '_proxied')
-        if name in self.__dict__:
-            return self.__dict__[name]
-        return getattr(self._proxied, name)
-
-    def infer(self, context=None):
-        yield self
-
-
-# Inference ##################################################################
-
-class InferenceContext(object):
-    __slots__ = ('path', 'lookupname', 'callcontext', 'boundnode')
-
-    def __init__(self, path=None):
-        if path is None:
-            self.path = set()
-        else:
-            self.path = path
-        self.lookupname = None
-        self.callcontext = None
-        self.boundnode = None
-
-    def push(self, node):
-        name = self.lookupname
-        if (node, name) in self.path:
-            raise StopIteration()
-        self.path.add( (node, name) )
-
-    def clone(self):
-        # XXX copy lookupname/callcontext ?
-        clone = InferenceContext(self.path)
-        clone.callcontext = self.callcontext
-        clone.boundnode = self.boundnode
-        return clone
-
-    @contextmanager
-    def restore_path(self):
-        path = set(self.path)
-        yield
-        self.path = path
-
-def copy_context(context):
-    if context is not None:
-        return context.clone()
-    else:
-        return InferenceContext()
-
-
-def _infer_stmts(stmts, context, frame=None):
-    """return an iterator on statements inferred by each statement in <stmts>
-    """
-    stmt = None
-    infered = False
-    if context is not None:
-        name = context.lookupname
-        context = context.clone()
-    else:
-        name = None
-        context = InferenceContext()
-    for stmt in stmts:
-        if stmt is YES:
-            yield stmt
-            infered = True
-            continue
-        context.lookupname = stmt._infer_name(frame, name)
-        try:
-            for infered in stmt.infer(context):
-                yield infered
-                infered = True
-        except UnresolvableName:
-            continue
-        except InferenceError:
-            yield YES
-            infered = True
-    if not infered:
-        raise InferenceError(str(stmt))
-
-
-# special inference objects (e.g. may be returned as nodes by .infer()) #######
-
-class _Yes(object):
-    """a yes object"""
-    def __repr__(self):
-        return 'YES'
-    def __getattribute__(self, name):
-        if name == 'next':
-            raise AttributeError('next method should not be called')
-        if name.startswith('__') and name.endswith('__'):
-            # to avoid inspection pb
-            return super(_Yes, self).__getattribute__(name)
-        return self
-    def __call__(self, *args, **kwargs):
-        return self
-
-
-YES = _Yes()
-
-
-class Instance(Proxy):
-    """a special node representing a class instance"""
-    def getattr(self, name, context=None, lookupclass=True):
-        try:
-            values = self._proxied.instance_attr(name, context)
-        except NotFoundError:
-            if name == '__class__':
-                return [self._proxied]
-            if lookupclass:
-                # class attributes not available through the instance
-                # unless they are explicitly defined
-                if name in ('__name__', '__bases__', '__mro__', '__subclasses__'):
-                    return self._proxied.local_attr(name)
-                return self._proxied.getattr(name, context)
-            raise NotFoundError(name)
-        # since we've no context information, return matching class members as
-        # well
-        if lookupclass:
-            try:
-                return values + self._proxied.getattr(name, context)
-            except NotFoundError:
-                pass
-        return values
-
-    def igetattr(self, name, context=None):
-        """inferred getattr"""
-        try:
-            # avoid recursively inferring the same attr on the same class
-            if context:
-                context.push((self._proxied, name))
-            # XXX frame should be self._proxied, or not ?
-            get_attr = self.getattr(name, context, lookupclass=False)
-            return _infer_stmts(self._wrap_attr(get_attr, context), context,
-                                frame=self)
-        except NotFoundError:
-            try:
-                # fallback to class'igetattr since it has some logic to handle
-                # descriptors
-                return self._wrap_attr(self._proxied.igetattr(name, context),
-                                       context)
-            except NotFoundError:
-                raise InferenceError(name)
-
-    def _wrap_attr(self, attrs, context=None):
-        """wrap bound methods of attrs in a InstanceMethod proxies"""
-        for attr in attrs:
-            if isinstance(attr, UnboundMethod):
-                if BUILTINS + '.property' in attr.decoratornames():
-                    for infered in attr.infer_call_result(self, context):
-                        yield infered
-                else:
-                    yield BoundMethod(attr, self)
-            else:
-                yield attr
-
-    def infer_call_result(self, caller, context=None):
-        """infer what a class instance is returning when called"""
-        infered = False
-        for node in self._proxied.igetattr('__call__', context):
-            if node is YES:
-                continue
-            for res in node.infer_call_result(caller, context):
-                infered = True
-                yield res
-        if not infered:
-            raise InferenceError()
-
-    def __repr__(self):
-        return '<Instance of %s.%s at 0x%s>' % (self._proxied.root().name,
-                                                self._proxied.name,
-                                                id(self))
-    def __str__(self):
-        return 'Instance of %s.%s' % (self._proxied.root().name,
-                                      self._proxied.name)
-
-    def callable(self):
-        try:
-            self._proxied.getattr('__call__')
-            return True
-        except NotFoundError:
-            return False
-
-    def pytype(self):
-        return self._proxied.qname()
-
-    def display_type(self):
-        return 'Instance of'
-
-
-class UnboundMethod(Proxy):
-    """a special node representing a method not bound to an instance"""
-    def __repr__(self):
-        frame = self._proxied.parent.frame()
-        return '<%s %s of %s at 0x%s' % (self.__class__.__name__,
-                                         self._proxied.name,
-                                         frame.qname(), id(self))
-
-    def is_bound(self):
-        return False
-
-    def getattr(self, name, context=None):
-        if name == 'im_func':
-            return [self._proxied]
-        return super(UnboundMethod, self).getattr(name, context)
-
-    def igetattr(self, name, context=None):
-        if name == 'im_func':
-            return iter((self._proxied,))
-        return super(UnboundMethod, self).igetattr(name, context)
-
-    def infer_call_result(self, caller, context):
-        # If we're unbound method __new__ of builtin object, the result is an
-        # instance of the class given as first argument.
-        if (self._proxied.name == '__new__' and
-                self._proxied.parent.frame().qname() == '%s.object' % BUILTINS):
-            return ((x is YES and x or Instance(x))
-                    for x in caller.args[0].infer())
-        return self._proxied.infer_call_result(caller, context)
-
-
-class BoundMethod(UnboundMethod):
-    """a special node representing a method bound to an instance"""
-    def __init__(self,  proxy, bound):
-        UnboundMethod.__init__(self, proxy)
-        self.bound = bound
-
-    def is_bound(self):
-        return True
-
-    def infer_call_result(self, caller, context):
-        context = context.clone()
-        context.boundnode = self.bound
-        return self._proxied.infer_call_result(caller, context)
-
-
-class Generator(Instance):
-    """a special node representing a generator.
-
-    Proxied class is set once for all in raw_building.
-    """
-    def callable(self):
-        return False
-
-    def pytype(self):
-        return '%s.generator' % BUILTINS
-
-    def display_type(self):
-        return 'Generator'
-
-    def __repr__(self):
-        return '<Generator(%s) l.%s at 0x%s>' % (self._proxied.name, self.lineno, id(self))
-
-    def __str__(self):
-        return 'Generator(%s)' % (self._proxied.name)
-
-
-# decorators ##################################################################
-
-def path_wrapper(func):
-    """return the given infer function wrapped to handle the path"""
-    def wrapped(node, context=None, _func=func, **kwargs):
-        """wrapper function handling context"""
-        if context is None:
-            context = InferenceContext()
-        context.push(node)
-        yielded = set()
-        for res in _func(node, context, **kwargs):
-            # unproxy only true instance, not const, tuple, dict...
-            if res.__class__ is Instance:
-                ares = res._proxied
-            else:
-                ares = res
-            if not ares in yielded:
-                yield res
-                yielded.add(ares)
-    return wrapped
-
-def yes_if_nothing_infered(func):
-    def wrapper(*args, **kwargs):
-        infered = False
-        for node in func(*args, **kwargs):
-            infered = True
-            yield node
-        if not infered:
-            yield YES
-    return wrapper
-
-def raise_if_nothing_infered(func):
-    def wrapper(*args, **kwargs):
-        infered = False
-        for node in func(*args, **kwargs):
-            infered = True
-            yield node
-        if not infered:
-            raise InferenceError()
-    return wrapper
-
-
-# Node  ######################################################################
-
-class NodeNG(object):
-    """Base Class for all Astroid node classes.
-
-    It represents a node of the new abstract syntax tree.
-    """
-    is_statement = False
-    optional_assign = False # True  for For (and for Comprehension if py <3.0)
-    is_function = False # True for Function nodes
-    # attributes below are set by the builder module or by raw factories
-    lineno = None
-    fromlineno = None
-    tolineno = None
-    col_offset = None
-    # parent node in the tree
-    parent = None
-    # attributes containing child node(s) redefined in most concrete classes:
-    _astroid_fields = ()
-    # instance specific inference function infer(node, context)
-    _explicit_inference = None
-
-    def infer(self, context=None, **kwargs):
-        """main interface to the interface system, return a generator on infered
-        values.
-
-        If the instance has some explicit inference function set, it will be
-        called instead of the default interface.
-        """
-        if self._explicit_inference is not None:
-            # explicit_inference is not bound, give it self explicitly
-            try:
-                return self._explicit_inference(self, context, **kwargs)
-            except UseInferenceDefault:
-                pass
-        return self._infer(context, **kwargs)
-
-    def _repr_name(self):
-        """return self.name or self.attrname or '' for nice representation"""
-        return getattr(self, 'name', getattr(self, 'attrname', ''))
-
-    def __str__(self):
-        return '%s(%s)' % (self.__class__.__name__, self._repr_name())
-
-    def __repr__(self):
-        return '<%s(%s) l.%s [%s] at Ox%x>' % (self.__class__.__name__,
-                                           self._repr_name(),
-                                           self.fromlineno,
-                                           self.root().name,
-                                           id(self))
-
-
-    def accept(self, visitor):
-        klass = self.__class__.__name__
-        func = getattr(visitor, "visit_" + self.__class__.__name__.lower())
-        return func(self)
-
-    def get_children(self):
-        for field in self._astroid_fields:
-            attr = getattr(self, field)
-            if attr is None:
-                continue
-            if isinstance(attr, (list, tuple)):
-                for elt in attr:
-                    yield elt
-            else:
-                yield attr
-
-    def last_child(self):
-        """an optimized version of list(get_children())[-1]"""
-        for field in self._astroid_fields[::-1]:
-            attr = getattr(self, field)
-            if not attr: # None or empty listy / tuple
-                continue
-            if isinstance(attr, (list, tuple)):
-                return attr[-1]
-            else:
-                return attr
-        return None
-
-    def parent_of(self, node):
-        """return true if i'm a parent of the given node"""
-        parent = node.parent
-        while parent is not None:
-            if self is parent:
-                return True
-            parent = parent.parent
-        return False
-
-    def statement(self):
-        """return the first parent node marked as statement node"""
-        if self.is_statement:
-            return self
-        return self.parent.statement()
-
-    def frame(self):
-        """return the first parent frame node (i.e. Module, Function or Class)
-        """
-        return self.parent.frame()
-
-    def scope(self):
-        """return the first node defining a new scope (i.e. Module, Function,
-        Class, Lambda but also GenExpr)
-        """
-        return self.parent.scope()
-
-    def root(self):
-        """return the root node of the tree, (i.e. a Module)"""
-        if self.parent:
-            return self.parent.root()
-        return self
-
-    def child_sequence(self, child):
-        """search for the right sequence where the child lies in"""
-        for field in self._astroid_fields:
-            node_or_sequence = getattr(self, field)
-            if node_or_sequence is child:
-                return [node_or_sequence]
-            # /!\ compiler.ast Nodes have an __iter__ walking over child nodes
-            if isinstance(node_or_sequence, (tuple, list)) and child in node_or_sequence:
-                return node_or_sequence
-        else:
-            msg = 'Could not find %s in %s\'s children'
-            raise AstroidError(msg % (repr(child), repr(self)))
-
-    def locate_child(self, child):
-        """return a 2-uple (child attribute name, sequence or node)"""
-        for field in self._astroid_fields:
-            node_or_sequence = getattr(self, field)
-            # /!\ compiler.ast Nodes have an __iter__ walking over child nodes
-            if child is node_or_sequence:
-                return field, child
-            if isinstance(node_or_sequence, (tuple, list)) and child in node_or_sequence:
-                return field, node_or_sequence
-        msg = 'Could not find %s in %s\'s children'
-        raise AstroidError(msg % (repr(child), repr(self)))
-    # FIXME : should we merge child_sequence and locate_child ? locate_child
-    # is only used in are_exclusive, child_sequence one time in pylint.
-
-    def next_sibling(self):
-        """return the next sibling statement"""
-        return self.parent.next_sibling()
-
-    def previous_sibling(self):
-        """return the previous sibling statement"""
-        return self.parent.previous_sibling()
-
-    def nearest(self, nodes):
-        """return the node which is the nearest before this one in the
-        given list of nodes
-        """
-        myroot = self.root()
-        mylineno = self.fromlineno
-        nearest = None, 0
-        for node in nodes:
-            assert node.root() is myroot, \
-                   'nodes %s and %s are not from the same module' % (self, node)
-            lineno = node.fromlineno
-            if node.fromlineno > mylineno:
-                break
-            if lineno > nearest[1]:
-                nearest = node, lineno
-        # FIXME: raise an exception if nearest is None ?
-        return nearest[0]
-
-    def set_line_info(self, lastchild):
-        if self.lineno is None:
-            self.fromlineno = self._fixed_source_line()
-        else:
-            self.fromlineno = self.lineno
-        if lastchild is None:
-            self.tolineno = self.fromlineno
-        else:
-            self.tolineno = lastchild.tolineno
-        return
-        # TODO / FIXME:
-        assert self.fromlineno is not None, self
-        assert self.tolineno is not None, self
-
-    def _fixed_source_line(self):
-        """return the line number where the given node appears
-
-        we need this method since not all nodes have the lineno attribute
-        correctly set...
-        """
-        line = self.lineno
-        _node = self
-        try:
-            while line is None:
-                _node = _node.get_children().next()
-                line = _node.lineno
-        except StopIteration:
-            _node = self.parent
-            while _node and line is None:
-                line = _node.lineno
-                _node = _node.parent
-        return line
-
-    def block_range(self, lineno):
-        """handle block line numbers range for non block opening statements
-        """
-        return lineno, self.tolineno
-
-    def set_local(self, name, stmt):
-        """delegate to a scoped parent handling a locals dictionary"""
-        self.parent.set_local(name, stmt)
-
-    def nodes_of_class(self, klass, skip_klass=None):
-        """return an iterator on nodes which are instance of the given class(es)
-
-        klass may be a class object or a tuple of class objects
-        """
-        if isinstance(self, klass):
-            yield self
-        for child_node in self.get_children():
-            if skip_klass is not None and isinstance(child_node, skip_klass):
-                continue
-            for matching in child_node.nodes_of_class(klass, skip_klass):
-                yield matching
-
-    def _infer_name(self, frame, name):
-        # overridden for From, Import, Global, TryExcept and Arguments
-        return None
-
-    def _infer(self, context=None):
-        """we don't know how to resolve a statement by default"""
-        # this method is overridden by most concrete classes
-        raise InferenceError(self.__class__.__name__)
-
-    def infered(self):
-        '''return list of infered values for a more simple inference usage'''
-        return list(self.infer())
-
-    def instanciate_class(self):
-        """instanciate a node if it is a Class node, else return self"""
-        return self
-
-    def has_base(self, node):
-        return False
-
-    def callable(self):
-        return False
-
-    def eq(self, value):
-        return False
-
-    def as_string(self):
-        from astroid.as_string import to_code
-        return to_code(self)
-
-    def repr_tree(self, ids=False):
-        from astroid.as_string import dump
-        return dump(self)
-
-
-class Statement(NodeNG):
-    """Statement node adding a few attributes"""
-    is_statement = True
-
-    def next_sibling(self):
-        """return the next sibling statement"""
-        stmts = self.parent.child_sequence(self)
-        index = stmts.index(self)
-        try:
-            return stmts[index +1]
-        except IndexError:
-            pass
-
-    def previous_sibling(self):
-        """return the previous sibling statement"""
-        stmts = self.parent.child_sequence(self)
-        index = stmts.index(self)
-        if index >= 1:
-            return stmts[index -1]
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2gi.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2gi.py
deleted file mode 100644
index dd9868db..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2gi.py
+++ /dev/null
@@ -1,159 +0,0 @@
-"""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
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2mechanize.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2mechanize.py
deleted file mode 100644
index 1e0b102d..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2mechanize.py
+++ /dev/null
@@ -1,20 +0,0 @@
-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
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2qt4.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2qt4.py
deleted file mode 100644
index 0ee0410e..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2qt4.py
+++ /dev/null
@@ -1,25 +0,0 @@
-"""Astroid hooks for the Python 2 qt4 module.
-
-Currently help understanding of :
-
-* PyQT4.QtCore
-"""
-
-from astroid import MANAGER
-from astroid.builder import AstroidBuilder
-
-
-def pyqt4_qtcore_transform(module):
-    fake = AstroidBuilder(MANAGER).string_build('''
-
-def SIGNAL(signal_name): pass
-
-class QObject(object):
-    def emit(self, signal): pass
-''')
-    for klass in ('QObject',):
-        module.locals[klass] = fake.locals[klass]
-
-
-import py2stdlib
-py2stdlib.MODULE_TRANSFORMS['PyQt4.QtCore'] = pyqt4_qtcore_transform
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2stdlib.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2stdlib.py
deleted file mode 100644
index 6b0ef501..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/brain/py2stdlib.py
+++ /dev/null
@@ -1,252 +0,0 @@
-"""Astroid hooks for the Python 2 standard library.
-
-Currently help understanding of :
-
-* hashlib.md5 and hashlib.sha1
-"""
-
-import sys
-
-from astroid import MANAGER, AsStringRegexpPredicate, UseInferenceDefault, inference_tip, YES
-from astroid import exceptions
-from astroid import nodes
-from astroid.builder import AstroidBuilder
-
-MODULE_TRANSFORMS = {}
-PY3K = sys.version_info > (3, 0)
-
-
-# module specific transformation functions #####################################
-
-def transform(module):
-    try:
-        tr = MODULE_TRANSFORMS[module.name]
-    except KeyError:
-        pass
-    else:
-        tr(module)
-MANAGER.register_transform(nodes.Module, transform)
-
-# module specific transformation functions #####################################
-
-def hashlib_transform(module):
-    template = '''
-
-class %s(object):
-  def __init__(self, value=''): pass
-  def digest(self):
-    return u''
-  def update(self, value): pass
-  def hexdigest(self):
-    return u''
-'''
-
-    algorithms = ('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512')
-    classes = "".join(template % hashfunc for hashfunc in algorithms)
-
-    fake = AstroidBuilder(MANAGER).string_build(classes)
-
-    for hashfunc in algorithms:
-        module.locals[hashfunc] = fake.locals[hashfunc]
-
-def collections_transform(module):
-    fake = AstroidBuilder(MANAGER).string_build('''
-
-class defaultdict(dict):
-    default_factory = None
-    def __missing__(self, key): pass
-
-class deque(object):
-    maxlen = 0
-    def __init__(iterable=None, maxlen=None): pass
-    def append(self, x): pass
-    def appendleft(self, x): pass
-    def clear(self): pass
-    def count(self, x): return 0
-    def extend(self, iterable): pass
-    def extendleft(self, iterable): pass
-    def pop(self): pass
-    def popleft(self): pass
-    def remove(self, value): pass
-    def reverse(self): pass
-    def rotate(self, n): pass
-    def __iter__(self): return self
-
-''')
-
-    for klass in ('deque', 'defaultdict'):
-        module.locals[klass] = fake.locals[klass]
-
-def pkg_resources_transform(module):
-    fake = AstroidBuilder(MANAGER).string_build('''
-
-def resource_exists(package_or_requirement, resource_name):
-    pass
-
-def resource_isdir(package_or_requirement, resource_name):
-    pass
-
-def resource_filename(package_or_requirement, resource_name):
-    pass
-
-def resource_stream(package_or_requirement, resource_name):
-    pass
-
-def resource_string(package_or_requirement, resource_name):
-    pass
-
-def resource_listdir(package_or_requirement, resource_name):
-    pass
-
-def extraction_error():
-    pass
-
-def get_cache_path(archive_name, names=()):
-    pass
-
-def postprocess(tempname, filename):
-    pass
-
-def set_extraction_path(path):
-    pass
-
-def cleanup_resources(force=False):
-    pass
-
-''')
-
-    for func_name, func in fake.locals.items():
-        module.locals[func_name] = func
-
-
-def urlparse_transform(module):
-    fake = AstroidBuilder(MANAGER).string_build('''
-
-def urlparse(url, scheme='', allow_fragments=True):
-    return ParseResult()
-
-class ParseResult(object):
-    def __init__(self):
-        self.scheme = ''
-        self.netloc = ''
-        self.path = ''
-        self.params = ''
-        self.query = ''
-        self.fragment = ''
-        self.username = None
-        self.password = None
-        self.hostname = None
-        self.port = None
-
-    def geturl(self):
-        return ''
-''')
-
-    for func_name, func in fake.locals.items():
-        module.locals[func_name] = func
-
-def subprocess_transform(module):
-    if PY3K:
-        communicate = (bytes('string', 'ascii'), bytes('string', 'ascii'))
-    else:
-        communicate = ('string', 'string')
-    fake = AstroidBuilder(MANAGER).string_build('''
-
-class Popen(object):
-    returncode = pid = 0
-    stdin = stdout = stderr = file()
-
-    def __init__(self, args, bufsize=0, executable=None,
-                 stdin=None, stdout=None, stderr=None,
-                 preexec_fn=None, close_fds=False, shell=False,
-                 cwd=None, env=None, universal_newlines=False,
-                 startupinfo=None, creationflags=0):
-        pass
-
-    def communicate(self, input=None):
-        return %r
-    def wait(self):
-        return self.returncode
-    def poll(self):
-        return self.returncode
-    def send_signal(self, signal):
-        pass
-    def terminate(self):
-        pass
-    def kill(self):
-        pass
-   ''' % (communicate, ))
-
-    for func_name, func in fake.locals.items():
-        module.locals[func_name] = func
-
-
-
-MODULE_TRANSFORMS['hashlib'] = hashlib_transform
-MODULE_TRANSFORMS['collections'] = collections_transform
-MODULE_TRANSFORMS['pkg_resources'] = pkg_resources_transform
-MODULE_TRANSFORMS['urlparse'] = urlparse_transform
-MODULE_TRANSFORMS['subprocess'] = subprocess_transform
-
-# namedtuple support ###########################################################
-
-def infer_named_tuple(node, context=None):
-    """Specific inference function for namedtuple CallFunc node"""
-    def infer_first(node):
-        try:
-            value = node.infer().next()
-            if value is YES:
-                raise UseInferenceDefault()
-            else:
-                return value
-        except StopIteration:
-            raise InferenceError()
-
-    # node is a CallFunc node, class name as first argument and generated class
-    # attributes as second argument
-    if len(node.args) != 2:
-        # something weird here, go back to class implementation
-        raise UseInferenceDefault()
-    # namedtuple list of attributes can be a list of strings or a
-    # whitespace-separate string
-    try:
-        name = infer_first(node.args[0]).value
-        names = infer_first(node.args[1])
-        try:
-            attributes = names.value.split()
-        except AttributeError:
-            attributes = [infer_first(const).value for const in names.elts]
-    except (AttributeError, exceptions.InferenceError):
-        raise UseInferenceDefault()
-    # we want to return a Class node instance with proper attributes set
-    class_node = nodes.Class(name, 'docstring')
-    class_node.parent = node.parent
-    # set base class=tuple
-    class_node.bases.append(nodes.Tuple._proxied)
-    # XXX add __init__(*attributes) method
-    for attr in attributes:
-        fake_node = nodes.EmptyNode()
-        fake_node.parent = class_node
-        class_node.instance_attrs[attr] = [fake_node]
-
-    fake = AstroidBuilder(MANAGER).string_build('''
-class %(name)s(tuple):
-    def _asdict(self):
-        return self.__dict__
-    @classmethod
-    def _make(cls, iterable, new=tuple.__new__, len=len):
-        return new(cls, iterable)
-    def _replace(_self, **kwds):
-        result = _self._make(map(kwds.pop, %(fields)r, _self))
-        if kwds:
-            raise ValueError('Got unexpected field names: %%r' %% list(kwds))
-        return result
-    ''' % {'name': name, 'fields': attributes})
-    class_node.locals['_asdict'] = fake.body[0].locals['_asdict']
-    class_node.locals['_make'] = fake.body[0].locals['_make']
-    class_node.locals['_replace'] = fake.body[0].locals['_replace']
-    # we use UseInferenceDefault, we can't be a generator so return an iterator
-    return iter([class_node])
-
-MANAGER.register_transform(nodes.CallFunc, inference_tip(infer_named_tuple),
-                           AsStringRegexpPredicate('namedtuple', 'func'))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/builder.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/builder.py
deleted file mode 100644
index b6ceff82..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/builder.py
+++ /dev/null
@@ -1,238 +0,0 @@
-# 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/>.
-"""The AstroidBuilder makes astroid 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.
-"""
-
-__docformat__ = "restructuredtext en"
-
-import sys
-from os.path import splitext, basename, exists, abspath
-
-from logilab.common.modutils import modpath_from_file
-
-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 _ast import PyCF_ONLY_AST
-def parse(string):
-    return compile(string, "<string>", 'exec', PyCF_ONLY_AST)
-
-if sys.version_info >= (3, 0):
-    from tokenize import detect_encoding
-
-    def open_source_file(filename):
-        byte_stream = open(filename, 'bU')
-        encoding = detect_encoding(byte_stream.readline)[0]
-        byte_stream.close()
-        stream = open(filename, 'U', encoding=encoding)
-        try:
-            data = stream.read()
-        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)
-        return stream, encoding, data
-
-else:
-    import re
-
-    _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
-        """
-        # check for UTF-8 byte-order mark
-        if string.startswith('\xef\xbb\xbf'):
-            return 'UTF-8'
-        for line in string.split('\n', 2)[:2]:
-            # check for encoding declaration
-            match = _ENCODING_RGX.match(line)
-            if match is not None:
-                return match.group(1)
-
-    def open_source_file(filename):
-        """get data for parsing a file"""
-        stream = open(filename, 'U')
-        data = stream.read()
-        encoding = _guess_encoding(data)
-        return stream, encoding, data
-
-# ast NG builder ##############################################################
-
-MANAGER = AstroidManager()
-
-class AstroidBuilder(InspectBuilder):
-    """provide astroid building methods"""
-
-    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
-        """
-        node = None
-        path = getattr(module, '__file__', None)
-        if path is not None:
-            path_, ext = splitext(module.__file__)
-            if ext in ('.py', '.pyc', '.pyo') and exists(path_ + '.py'):
-                node = self.file_build(path_ + '.py', modname)
-        if node is None:
-            # 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)
-
-        path is expected to be a python source file
-        """
-        try:
-            stream, encoding, data = open_source_file(path)
-        except IOError, exc:
-            msg = 'Unable to load file %r (%s)' % (path, exc)
-            raise AstroidBuildingException(msg)
-        except SyntaxError, exc: # py3k encoding specification error
-            raise AstroidBuildingException(exc)
-        except LookupError, exc: # unknown encoding
-            raise AstroidBuildingException(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)
-
-    def string_build(self, data, modname='', path=None):
-        """build astroid from source code string and return rebuilded astroid"""
-        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)
-        # 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)
-        return module
-
-    def _data_build(self, data, modname, path):
-        """build tree node from data and add some informations"""
-        # this method could be wrapped with a pickle/cache function
-        node = parse(data + '\n')
-        if path is not None:
-            node_file = abspath(path)
-        else:
-            node_file = '<?>'
-        if modname.endswith('.__init__'):
-            modname = modname[:-9]
-            package = True
-        else:
-            package = path and path.find('__init__.py') > -1 or False
-        rebuilder = TreeRebuilder(self._manager)
-        module = rebuilder.visit_module(node, modname, package)
-        module.file = module.path = node_file
-        module._from_nodes = rebuilder._from_nodes
-        module._delayed_assattr = rebuilder._delayed_assattr
-        return module
-
-    def add_from_names_to_locals(self, node):
-        """store imported names to the locals;
-        resort the locals if coming from a delayed node
-        """
-
-        _key_func = lambda node: node.fromlineno
-        def sort_locals(my_list):
-            my_list.sort(key=_key_func)
-        for (name, asname) in node.names:
-            if name == '*':
-                try:
-                    imported = node.root().import_module(node.modname)
-                except AstroidBuildingException:
-                    continue
-                for name in imported.wildcard_import_names():
-                    node.parent.set_local(name, node)
-                    sort_locals(node.parent.scope().locals[name])
-            else:
-                node.parent.set_local(asname or name, node)
-                sort_locals(node.parent.scope().locals[asname or name])
-
-    def delayed_assattr(self, node):
-        """visit a AssAttr node -> add name to locals, handle members
-        definition
-        """
-        try:
-            frame = node.frame()
-            for infered in node.expr.infer():
-                if infered is YES:
-                    continue
-                try:
-                    if infered.__class__ is Instance:
-                        infered = infered._proxied
-                        iattrs = infered.instance_attrs
-                    elif isinstance(infered, Instance):
-                        # Const, Tuple, ... we may be wrong, may be not, but
-                        # anyway we don't want to pollute builtin's namespace
-                        continue
-                    elif infered.is_function:
-                        iattrs = infered.instance_attrs
-                    else:
-                        iattrs = infered.locals
-                except AttributeError:
-                    # XXX log error
-                    #import traceback
-                    #traceback.print_exc()
-                    continue
-                values = iattrs.setdefault(node.attrname, [])
-                if node in values:
-                    continue
-                # get assign in __init__ first XXX useful ?
-                if frame.name == '__init__' and values and not \
-                       values[0].frame().name == '__init__':
-                    values.insert(0, node)
-                else:
-                    values.append(node)
-        except InferenceError:
-            pass
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/exceptions.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/exceptions.py
deleted file mode 100644
index 3889e2e7..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/exceptions.py
+++ /dev/null
@@ -1,51 +0,0 @@
-# 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 exceptions used in the astroid library
-
-"""
-
-__doctype__ = "restructuredtext en"
-
-class AstroidError(Exception):
-    """base exception class for all astroid related exceptions"""
-
-class AstroidBuildingException(AstroidError):
-    """exception class when we are unable to build an astroid representation"""
-
-class ResolveError(AstroidError):
-    """base class of astroid resolution/inference error"""
-
-class NotFoundError(ResolveError):
-    """raised when we are unable to resolve a name"""
-
-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):
-    """raised by function's `default_value` method when an argument has
-    no default value
-    """
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/inference.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/inference.py
deleted file mode 100644
index 35cce332..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/inference.py
+++ /dev/null
@@ -1,393 +0,0 @@
-# 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 handle inference on astroid trees
-"""
-
-__doctype__ = "restructuredtext en"
-
-from itertools import chain
-
-from astroid import nodes
-
-from astroid.manager import AstroidManager
-from astroid.exceptions import (AstroidError,
-    InferenceError, NoDefault, NotFoundError, UnresolvableName)
-from astroid.bases import YES, Instance, InferenceContext, \
-     _infer_stmts, copy_context, path_wrapper, raise_if_nothing_infered
-from astroid.protocols import _arguments_infer_argname
-
-MANAGER = AstroidManager()
-
-
-class CallContext:
-    """when inferring a function call, this class is used to remember values
-    given as argument
-    """
-    def __init__(self, args, starargs, dstarargs):
-        self.args = []
-        self.nargs = {}
-        for arg in args:
-            if isinstance(arg, nodes.Keyword):
-                self.nargs[arg.arg] = arg.value
-            else:
-                self.args.append(arg)
-        self.starargs = starargs
-        self.dstarargs = dstarargs
-
-    def infer_argument(self, funcnode, name, context):
-        """infer a function argument value according to the call context"""
-        # 1. search in named keywords
-        try:
-            return self.nargs[name].infer(context)
-        except KeyError:
-            # Function.args.args can be None in astroid (means that we don't have
-            # information on argnames)
-            argindex = funcnode.args.find_argname(name)[0]
-            if argindex is not None:
-                # 2. first argument of instance/class method
-                if argindex == 0 and funcnode.type in ('method', 'classmethod'):
-                    if context.boundnode is not None:
-                        boundnode = context.boundnode
-                    else:
-                        # XXX can do better ?
-                        boundnode = funcnode.parent.frame()
-                    if funcnode.type == 'method':
-                        if not isinstance(boundnode, Instance):
-                            boundnode = Instance(boundnode)
-                        return iter((boundnode,))
-                    if funcnode.type == 'classmethod':
-                        return iter((boundnode,))
-                # if we have a method, extract one position
-                # from the index, so we'll take in account
-                # the extra parameter represented by `self` or `cls`
-                if funcnode.type in ('method', 'classmethod'):
-                    argindex -= 1
-                # 2. search arg index
-                try:
-                    return self.args[argindex].infer(context)
-                except IndexError:
-                    pass
-                # 3. search in *args (.starargs)
-                if self.starargs is not None:
-                    its = []
-                    for infered in self.starargs.infer(context):
-                        if infered is YES:
-                            its.append((YES,))
-                            continue
-                        try:
-                            its.append(infered.getitem(argindex, context).infer(context))
-                        except (InferenceError, AttributeError):
-                            its.append((YES,))
-                        except (IndexError, TypeError):
-                            continue
-                    if its:
-                        return chain(*its)
-        # 4. XXX search in **kwargs (.dstarargs)
-        if self.dstarargs is not None:
-            its = []
-            for infered in self.dstarargs.infer(context):
-                if infered is YES:
-                    its.append((YES,))
-                    continue
-                try:
-                    its.append(infered.getitem(name, context).infer(context))
-                except (InferenceError, AttributeError):
-                    its.append((YES,))
-                except (IndexError, TypeError):
-                    continue
-            if its:
-                return chain(*its)
-        # 5. */** argument, (Tuple or Dict)
-        if name == funcnode.args.vararg:
-            return iter((nodes.const_factory(())))
-        if name == funcnode.args.kwarg:
-            return iter((nodes.const_factory({})))
-        # 6. return default value if any
-        try:
-            return funcnode.args.default_value(name).infer(context)
-        except NoDefault:
-            raise InferenceError(name)
-
-
-# .infer method ###############################################################
-
-
-def infer_end(self, context=None):
-    """inference's end for node such as Module, Class, Function, Const...
-    """
-    yield self
-nodes.Module._infer = infer_end
-nodes.Class._infer = infer_end
-nodes.Function._infer = infer_end
-nodes.Lambda._infer = infer_end
-nodes.Const._infer = infer_end
-nodes.List._infer = infer_end
-nodes.Tuple._infer = infer_end
-nodes.Dict._infer = infer_end
-nodes.Set._infer = infer_end
-
-def infer_name(self, context=None):
-    """infer a Name: use name lookup rules"""
-    frame, stmts = self.lookup(self.name)
-    if not stmts:
-        raise UnresolvableName(self.name)
-    context = context.clone()
-    context.lookupname = self.name
-    return _infer_stmts(stmts, context, frame)
-nodes.Name._infer = path_wrapper(infer_name)
-nodes.AssName.infer_lhs = infer_name # won't work with a path wrapper
-
-
-def infer_callfunc(self, context=None):
-    """infer a CallFunc node by trying to guess what the function returns"""
-    callcontext = context.clone()
-    callcontext.callcontext = CallContext(self.args, self.starargs, self.kwargs)
-    callcontext.boundnode = None
-    for callee in self.func.infer(context):
-        if callee is YES:
-            yield callee
-            continue
-        try:
-            if hasattr(callee, 'infer_call_result'):
-                for infered in callee.infer_call_result(self, callcontext):
-                    yield infered
-        except InferenceError:
-            ## XXX log error ?
-            continue
-nodes.CallFunc._infer = path_wrapper(raise_if_nothing_infered(infer_callfunc))
-
-
-def infer_import(self, context=None, asname=True):
-    """infer an Import node: return the imported module/object"""
-    name = context.lookupname
-    if name is None:
-        raise InferenceError()
-    if asname:
-        yield self.do_import_module(self.real_name(name))
-    else:
-        yield self.do_import_module(name)
-nodes.Import._infer = path_wrapper(infer_import)
-
-def infer_name_module(self, name):
-    context = InferenceContext()
-    context.lookupname = name
-    return self.infer(context, asname=False)
-nodes.Import.infer_name_module = infer_name_module
-
-
-def infer_from(self, context=None, asname=True):
-    """infer a From nodes: return the imported module/object"""
-    name = context.lookupname
-    if name is None:
-        raise InferenceError()
-    if asname:
-        name = self.real_name(name)
-    module = self.do_import_module(self.modname)
-    try:
-        context = copy_context(context)
-        context.lookupname = name
-        return _infer_stmts(module.getattr(name, ignore_locals=module is self.root()), context)
-    except NotFoundError:
-        raise InferenceError(name)
-nodes.From._infer = path_wrapper(infer_from)
-
-
-def infer_getattr(self, context=None):
-    """infer a Getattr node by using getattr on the associated object"""
-    #context = context.clone()
-    for owner in self.expr.infer(context):
-        if owner is YES:
-            yield owner
-            continue
-        try:
-            context.boundnode = owner
-            for obj in owner.igetattr(self.attrname, context):
-                yield obj
-            context.boundnode = None
-        except (NotFoundError, InferenceError):
-            context.boundnode = None
-        except AttributeError:
-            # XXX method / function
-            context.boundnode = None
-nodes.Getattr._infer = path_wrapper(raise_if_nothing_infered(infer_getattr))
-nodes.AssAttr.infer_lhs = raise_if_nothing_infered(infer_getattr) # # won't work with a path wrapper
-
-
-def infer_global(self, context=None):
-    if context.lookupname is None:
-        raise InferenceError()
-    try:
-        return _infer_stmts(self.root().getattr(context.lookupname), context)
-    except NotFoundError:
-        raise InferenceError()
-nodes.Global._infer = path_wrapper(infer_global)
-
-
-def infer_subscript(self, context=None):
-    """infer simple subscription such as [1,2,3][0] or (1,2,3)[-1]"""
-    value = self.value.infer(context).next()
-    if value is YES:
-        yield YES
-        return
-
-    index = self.slice.infer(context).next()
-    if index is YES:
-        yield YES
-        return
-
-    if isinstance(index, nodes.Const):
-        try:
-            assigned = value.getitem(index.value, context)
-        except AttributeError:
-            raise InferenceError()
-        except (IndexError, TypeError):
-            yield YES
-            return
-        for infered in assigned.infer(context):
-            yield infered
-    else:
-        raise InferenceError()
-nodes.Subscript._infer = path_wrapper(infer_subscript)
-nodes.Subscript.infer_lhs = raise_if_nothing_infered(infer_subscript)
-
-
-UNARY_OP_METHOD = {'+': '__pos__',
-                   '-': '__neg__',
-                   '~': '__invert__',
-                   'not': None, # XXX not '__nonzero__'
-                  }
-
-def infer_unaryop(self, context=None):
-    for operand in self.operand.infer(context):
-        try:
-            yield operand.infer_unary_op(self.op)
-        except TypeError:
-            continue
-        except AttributeError:
-            meth = UNARY_OP_METHOD[self.op]
-            if meth is None:
-                yield YES
-            else:
-                try:
-                    # XXX just suppose if the type implement meth, returned type
-                    # will be the same
-                    operand.getattr(meth)
-                    yield operand
-                except GeneratorExit:
-                    raise
-                except:
-                    yield YES
-nodes.UnaryOp._infer = path_wrapper(infer_unaryop)
-
-
-BIN_OP_METHOD = {'+':  '__add__',
-                 '-':  '__sub__',
-                 '/':  '__div__',
-                 '//': '__floordiv__',
-                 '*':  '__mul__',
-                 '**': '__power__',
-                 '%':  '__mod__',
-                 '&':  '__and__',
-                 '|':  '__or__',
-                 '^':  '__xor__',
-                 '<<': '__lshift__',
-                 '>>': '__rshift__',
-                 }
-
-def _infer_binop(operator, operand1, operand2, context, failures=None):
-    if operand1 is YES:
-        yield operand1
-        return
-    try:
-        for valnode in operand1.infer_binary_op(operator, operand2, context):
-            yield valnode
-    except AttributeError:
-        try:
-            # XXX just suppose if the type implement meth, returned type
-            # will be the same
-            operand1.getattr(BIN_OP_METHOD[operator])
-            yield operand1
-        except:
-            if failures is None:
-                yield YES
-            else:
-                failures.append(operand1)
-
-def infer_binop(self, context=None):
-    failures = []
-    for lhs in self.left.infer(context):
-        for val in _infer_binop(self.op, lhs, self.right, context, failures):
-            yield val
-    for lhs in failures:
-        for rhs in self.right.infer(context):
-            for val in _infer_binop(self.op, rhs, lhs, context):
-                yield val
-nodes.BinOp._infer = path_wrapper(infer_binop)
-
-
-def infer_arguments(self, context=None):
-    name = context.lookupname
-    if name is None:
-        raise InferenceError()
-    return _arguments_infer_argname(self, name, context)
-nodes.Arguments._infer = infer_arguments
-
-
-def infer_ass(self, context=None):
-    """infer a AssName/AssAttr: need to inspect the RHS part of the
-    assign node
-    """
-    stmt = self.statement()
-    if isinstance(stmt, nodes.AugAssign):
-        return stmt.infer(context)
-    stmts = list(self.assigned_stmts(context=context))
-    return _infer_stmts(stmts, context)
-nodes.AssName._infer = path_wrapper(infer_ass)
-nodes.AssAttr._infer = path_wrapper(infer_ass)
-
-def infer_augassign(self, context=None):
-    failures = []
-    for lhs in self.target.infer_lhs(context):
-        for val in _infer_binop(self.op, lhs, self.value, context, failures):
-            yield val
-    for lhs in failures:
-        for rhs in self.value.infer(context):
-            for val in _infer_binop(self.op, rhs, lhs, context):
-                yield val
-nodes.AugAssign._infer = path_wrapper(infer_augassign)
-
-
-# no infer method on DelName and DelAttr (expected InferenceError)
-
-
-def infer_empty_node(self, context=None):
-    if not self.has_underlying_object():
-        yield YES
-    else:
-        try:
-            for infered in MANAGER.infer_ast_from_something(self.object,
-                                                              context=context):
-                yield infered
-        except AstroidError:
-            yield YES
-nodes.EmptyNode._infer = path_wrapper(infer_empty_node)
-
-
-def infer_index(self, context=None):
-    return self.value.infer(context)
-nodes.Index._infer = infer_index
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/manager.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/manager.py
deleted file mode 100644
index 058e845e..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/manager.py
+++ /dev/null
@@ -1,336 +0,0 @@
-# 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/>.
-"""astroid manager: avoid multiple astroid build of a same module when
-possible by providing a class responsible to get astroid representation
-from various source and using a cache of built modules)
-"""
-
-__docformat__ = "restructuredtext en"
-
-import os
-from os.path import dirname, join, isdir, exists
-
-from logilab.common.modutils import NoSourceFile, is_python_source, \
-     file_from_modpath, load_module_from_name, modpath_from_file, \
-     get_module_files, get_source_file, zipimport
-from logilab.common.configuration import OptionsProviderMixIn
-
-from astroid.exceptions import AstroidBuildingException
-
-def astroid_wrapper(func, modname):
-    """wrapper to give to AstroidManager.project_from_files"""
-    print 'parsing %s...' % modname
-    try:
-        return func(modname)
-    except AstroidBuildingException, exc:
-        print exc
-    except Exception, exc:
-        import traceback
-        traceback.print_exc()
-
-def _silent_no_wrap(func, modname):
-    """silent wrapper that doesn't do anything; can be used for tests"""
-    return func(modname)
-
-def safe_repr(obj):
-    try:
-        return repr(obj)
-    except:
-        return '???'
-
-
-
-class AstroidManager(OptionsProviderMixIn):
-    """the astroid manager, responsible to build astroid from files
-     or modules.
-
-    Use the Borg pattern.
-    """
-
-    name = 'astroid loader'
-    options = (("ignore",
-                {'type' : "csv", 'metavar' : "<file>",
-                 'dest' : "black_list", "default" : ('CVS',),
-                 'help' : "add <file> (may be a directory) to the black list\
-. It should be a base name, not a path. You may set this option multiple times\
-."}),
-               ("project",
-                {'default': "No Name", 'type' : 'string', 'short': 'p',
-                 'metavar' : '<project name>',
-                 'help' : 'set the project name.'}),
-               )
-    brain = {}
-    def __init__(self):
-        self.__dict__ = AstroidManager.brain
-        if not self.__dict__:
-            OptionsProviderMixIn.__init__(self)
-            self.load_defaults()
-            # NOTE: cache entries are added by the [re]builder
-            self.astroid_cache = {}
-            self._mod_file_cache = {}
-            self.transforms = {}
-
-    def ast_from_file(self, filepath, modname=None, fallback=True, source=False):
-        """given a module name, return the astroid object"""
-        try:
-            filepath = get_source_file(filepath, include_no_ext=True)
-            source = True
-        except NoSourceFile:
-            pass
-        if modname is None:
-            try:
-                modname = '.'.join(modpath_from_file(filepath))
-            except ImportError:
-                modname = filepath
-        if modname in self.astroid_cache and self.astroid_cache[modname].file == filepath:
-            return self.astroid_cache[modname]
-        if source:
-            from astroid.builder import AstroidBuilder
-            return AstroidBuilder(self).file_build(filepath, modname)
-        elif fallback and modname:
-            return self.ast_from_module_name(modname)
-        raise AstroidBuildingException('unable to get astroid for file %s' %
-                                     filepath)
-
-    def ast_from_module_name(self, modname, context_file=None):
-        """given a module name, return the astroid object"""
-        if modname in self.astroid_cache:
-            return self.astroid_cache[modname]
-        if modname == '__main__':
-            from astroid.builder import AstroidBuilder
-            return AstroidBuilder(self).string_build('', modname)
-        old_cwd = os.getcwd()
-        if context_file:
-            os.chdir(dirname(context_file))
-        try:
-            filepath = self.file_from_module_name(modname, context_file)
-            if filepath is not None and not is_python_source(filepath):
-                module = self.zip_import_data(filepath)
-                if module is not None:
-                    return module
-            if filepath is None or not is_python_source(filepath):
-                try:
-                    module = load_module_from_name(modname)
-                except Exception, ex:
-                    msg = 'Unable to load module %s (%s)' % (modname, ex)
-                    raise AstroidBuildingException(msg)
-                return self.ast_from_module(module, modname)
-            return self.ast_from_file(filepath, modname, fallback=False)
-        finally:
-            os.chdir(old_cwd)
-
-    def zip_import_data(self, filepath):
-        if zipimport is None:
-            return None
-        from astroid.builder import AstroidBuilder
-        builder = AstroidBuilder(self)
-        for ext in ('.zip', '.egg'):
-            try:
-                eggpath, resource = filepath.rsplit(ext + '/', 1)
-            except ValueError:
-                continue
-            try:
-                importer = zipimport.zipimporter(eggpath + ext)
-                zmodname = resource.replace('/', '.')
-                if importer.is_package(resource):
-                    zmodname =  zmodname + '.__init__'
-                module = builder.string_build(importer.get_source(resource),
-                                              zmodname, filepath)
-                return module
-            except:
-                continue
-        return None
-
-    def file_from_module_name(self, modname, contextfile):
-        try:
-            value = self._mod_file_cache[(modname, contextfile)]
-        except KeyError:
-            try:
-                value = file_from_modpath(modname.split('.'),
-                                          context_file=contextfile)
-            except ImportError, ex:
-                msg = 'Unable to load module %s (%s)' % (modname, ex)
-                value = AstroidBuildingException(msg)
-            self._mod_file_cache[(modname, contextfile)] = value
-        if isinstance(value, AstroidBuildingException):
-            raise value
-        return value
-
-    def ast_from_module(self, module, modname=None):
-        """given an imported module, return the astroid object"""
-        modname = modname or module.__name__
-        if modname in self.astroid_cache:
-            return self.astroid_cache[modname]
-        try:
-            # some builtin modules don't have __file__ attribute
-            filepath = module.__file__
-            if is_python_source(filepath):
-                return self.ast_from_file(filepath, modname)
-        except AttributeError:
-            pass
-        from astroid.builder import AstroidBuilder
-        return AstroidBuilder(self).module_build(module, modname)
-
-    def ast_from_class(self, klass, modname=None):
-        """get astroid for the given class"""
-        if modname is None:
-            try:
-                modname = klass.__module__
-            except AttributeError:
-                raise AstroidBuildingException(
-                    'Unable to get module for class %s' % safe_repr(klass))
-        modastroid = self.ast_from_module_name(modname)
-        return modastroid.getattr(klass.__name__)[0] # XXX
-
-
-    def infer_ast_from_something(self, obj, context=None):
-        """infer astroid for the given class"""
-        if hasattr(obj, '__class__') and not isinstance(obj, type):
-            klass = obj.__class__
-        else:
-            klass = obj
-        try:
-            modname = klass.__module__
-        except AttributeError:
-            raise AstroidBuildingException(
-                'Unable to get module for %s' % safe_repr(klass))
-        except Exception, ex:
-            raise AstroidBuildingException(
-                'Unexpected error while retrieving module for %s: %s'
-                % (safe_repr(klass), ex))
-        try:
-            name = klass.__name__
-        except AttributeError:
-            raise AstroidBuildingException(
-                'Unable to get name for %s' % safe_repr(klass))
-        except Exception, ex:
-            raise AstroidBuildingException(
-                'Unexpected error while retrieving name for %s: %s'
-                % (safe_repr(klass), ex))
-        # take care, on living object __module__ is regularly wrong :(
-        modastroid = self.ast_from_module_name(modname)
-        if klass is obj:
-            for  infered in modastroid.igetattr(name, context):
-                yield infered
-        else:
-            for infered in modastroid.igetattr(name, context):
-                yield infered.instanciate_class()
-
-    def project_from_files(self, files, func_wrapper=astroid_wrapper,
-                           project_name=None, black_list=None):
-        """return a Project from a list of files or modules"""
-        # build the project representation
-        project_name = project_name or self.config.project
-        black_list = black_list or self.config.black_list
-        project = Project(project_name)
-        for something in files:
-            if not exists(something):
-                fpath = file_from_modpath(something.split('.'))
-            elif isdir(something):
-                fpath = join(something, '__init__.py')
-            else:
-                fpath = something
-            astroid = func_wrapper(self.ast_from_file, fpath)
-            if astroid is None:
-                continue
-            # XXX why is first file defining the project.path ?
-            project.path = project.path or astroid.file
-            project.add_module(astroid)
-            base_name = astroid.name
-            # recurse in package except if __init__ was explicitly given
-            if astroid.package and something.find('__init__') == -1:
-                # recurse on others packages / modules if this is a package
-                for fpath in get_module_files(dirname(astroid.file),
-                                              black_list):
-                    astroid = func_wrapper(self.ast_from_file, fpath)
-                    if astroid is None or astroid.name == base_name:
-                        continue
-                    project.add_module(astroid)
-        return project
-
-    def register_transform(self, node_class, transform, predicate=None):
-        """Register `transform(node)` function to be applied on the given
-        Astroid's `node_class` if `predicate` is None or return a true value
-        when called with the node as argument.
-
-        The transform function may return a value which is then used to
-        substitute the original node in the tree.
-        """
-        self.transforms.setdefault(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 transform(self, node):
-        """Call matching transforms for the given node if any and return the
-        transformed node.
-        """
-        cls = node.__class__
-        if cls not in self.transforms:
-            # no transform registered for this class of node
-            return node
-
-        transforms = self.transforms[cls]
-        orig_node = node  # copy the reference
-        for transform_func, predicate in transforms:
-            if predicate is None or predicate(node):
-                ret = transform_func(node)
-                # if the transformation function returns something, it's
-                # expected to be a replacement for the node
-                if ret is not None:
-                    if node is not orig_node:
-                        # node has already be modified by some previous
-                        # transformation, warn about it
-                        warn('node %s substitued 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)
-
-
-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__
-        self.__iter__ = self.locals.__iter__
-        self.values = self.locals.values
-        self.keys = self.locals.keys
-        self.items = self.locals.items
-
-    def add_module(self, node):
-        self.locals[node.name] = node
-        self.modules.append(node)
-
-    def get_module(self, name):
-        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))
-
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/mixins.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/mixins.py
deleted file mode 100644
index 5e7b7878..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/mixins.py
+++ /dev/null
@@ -1,122 +0,0 @@
-# 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 some mixins for the different nodes.
-"""
-
-from astroid.exceptions import (AstroidBuildingException, InferenceError,
-                                      NotFoundError)
-
-
-class BlockRangeMixIn(object):
-    """override block range """
-    def set_line_info(self, lastchild):
-        self.fromlineno = self.lineno
-        self.tolineno = lastchild.tolineno
-        self.blockstart_tolineno = self._blockstart_toline()
-
-    def _elsed_block_range(self, lineno, orelse, last=None):
-        """handle block line numbers range for try/finally, for, if and while
-        statements
-        """
-        if lineno == self.fromlineno:
-            return lineno, lineno
-        if orelse:
-            if lineno >= orelse[0].fromlineno:
-                return lineno, orelse[-1].tolineno
-            return lineno, orelse[0].fromlineno - 1
-        return lineno, last or self.tolineno
-
-
-class FilterStmtsMixin(object):
-    """Mixin for statement filtering and assignment type"""
-
-    def _get_filtered_stmts(self, _, node, _stmts, mystmt):
-        """method used in _filter_stmts to get statemtents and trigger break"""
-        if self.statement() is mystmt:
-            # original node's statement is the assignment, only keep
-            # current node (gen exp, list comp)
-            return [node], True
-        return _stmts, False
-
-    def ass_type(self):
-        return self
-
-
-class AssignTypeMixin(object):
-
-    def ass_type(self):
-        return self
-
-    def _get_filtered_stmts(self, lookup_node, node, _stmts, mystmt):
-        """method used in filter_stmts"""
-        if self is mystmt:
-            return _stmts, True
-        if self.statement() is mystmt:
-            # original node's statement is the assignment, only keep
-            # current node (gen exp, list comp)
-            return [node], True
-        return _stmts, False
-
-
-class ParentAssignTypeMixin(AssignTypeMixin):
-
-    def ass_type(self):
-        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):
-        """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
-        # using the same name as the package, which may end in an infinite loop
-        # on relative imports
-        # XXX: no more needed ?
-        mymodule = self.root()
-        level = getattr(self, 'level', None) # Import as no level
-        # 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:
-            # FIXME: we used to raise InferenceError here, but why ?
-            return mymodule
-        try:
-            return mymodule.import_module(modname, level=level)
-        except AstroidBuildingException:
-            raise InferenceError(modname)
-        except SyntaxError, ex:
-            raise InferenceError(str(ex))
-
-    def real_name(self, asname):
-        """get name from 'as' name"""
-        for name, _asname in self.names:
-            if name == '*':
-                return asname
-            if not _asname:
-                name = name.split('.', 1)[0]
-                _asname = name
-            if asname == _asname:
-                return name
-        raise NotFoundError(asname)
-
-
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/node_classes.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/node_classes.py
deleted file mode 100644
index 01dc8d92..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/node_classes.py
+++ /dev/null
@@ -1,928 +0,0 @@
-# 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/>.
-"""Module for some node classes. More nodes in scoped_nodes.py
-"""
-
-import sys
-
-from astroid.exceptions import NoDefault
-from astroid.bases import (NodeNG, Statement, Instance, InferenceContext,
-                                 _infer_stmts, YES, BUILTINS)
-from astroid.mixins import BlockRangeMixIn, AssignTypeMixin, \
-                                 ParentAssignTypeMixin, FromImportMixIn
-
-
-def unpack_infer(stmt, context=None):
-    """recursively generate nodes inferred by the given statement.
-    If the inferred value is a list or a tuple, recurse on the elements
-    """
-    if isinstance(stmt, (List, Tuple)):
-        for elt in stmt.elts:
-            for infered_elt in unpack_infer(elt, context):
-                yield infered_elt
-        return
-    # if infered is a final node, return it and stop
-    infered = stmt.infer(context).next()
-    if infered is stmt:
-        yield infered
-        return
-    # else, infer recursivly, except YES object that should be returned as is
-    for infered in stmt.infer(context):
-        if infered is YES:
-            yield infered
-        else:
-            for inf_inf in unpack_infer(infered, context):
-                yield inf_inf
-
-
-def are_exclusive(stmt1, stmt2, exceptions=None):
-    """return true if the two given statements are mutually exclusive
-
-    `exceptions` may be a list of exception names. If specified, discard If
-    branches and check one of the statement is in an exception handler catching
-    one of the given exceptions.
-
-    algorithm :
-     1) index stmt1's parents
-     2) climb among stmt2's parents until we find a common parent
-     3) if the common parent is a If or TryExcept statement, look if nodes are
-        in exclusive branches
-    """
-    # index stmt1's parents
-    stmt1_parents = {}
-    children = {}
-    node = stmt1.parent
-    previous = stmt1
-    while node:
-        stmt1_parents[node] = 1
-        children[node] = previous
-        previous = node
-        node = node.parent
-    # climb among stmt2's parents until we find a common parent
-    node = stmt2.parent
-    previous = stmt2
-    while node:
-        if node in stmt1_parents:
-            # if the common parent is a If or TryExcept statement, look if
-            # nodes are in exclusive branches
-            if isinstance(node, If) and exceptions is None:
-                if (node.locate_child(previous)[1]
-                    is not node.locate_child(children[node])[1]):
-                    return True
-            elif isinstance(node, TryExcept):
-                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')):
-                        return True
-                elif c2attr == 'handlers' and c1attr == 'handlers':
-                    return previous is not children[node]
-            return False
-        previous = node
-        node = node.parent
-    return False
-
-
-class LookupMixIn(object):
-    """Mixin looking up a name in the right scope
-    """
-
-    def lookup(self, name):
-        """lookup a variable name
-
-        return the scope node and the list of assignments associated to the given
-        name according to the scope where it has been found (locals, globals or
-        builtin)
-
-        The lookup is starting from self's scope. If self is not a frame itself and
-        the name is found in the inner frame locals, statements will be filtered
-        to remove ignorable statements according to self's location
-        """
-        return self.scope().scope_lookup(self, name)
-
-    def ilookup(self, name):
-        """infered lookup
-
-        return an iterator on infered values of the statements returned by
-        the lookup method
-        """
-        frame, stmts = self.lookup(name)
-        context = InferenceContext()
-        return _infer_stmts(stmts, context, frame)
-
-    def _filter_stmts(self, stmts, frame, offset):
-        """filter statements to remove ignorable statements.
-
-        If self is not a frame itself and the name is found in the inner
-        frame locals, statements will be filtered to remove ignorable
-        statements according to self's location
-        """
-        # if offset == -1, my actual frame is not the inner frame but its parent
-        #
-        # class A(B): pass
-        #
-        # we need this to resolve B correctly
-        if offset == -1:
-            myframe = self.frame().parent.frame()
-        else:
-            myframe = self.frame()
-        if not myframe is frame or self is frame:
-            return stmts
-        mystmt = self.statement()
-        # line filtering if we are in the same frame
-        #
-        # take care node may be missing lineno information (this is the case for
-        # nodes inserted for living objects)
-        if myframe is frame and mystmt.fromlineno is not None:
-            assert mystmt.fromlineno is not None, mystmt
-            mylineno = mystmt.fromlineno + offset
-        else:
-            # disabling lineno filtering
-            mylineno = 0
-        _stmts = []
-        _stmt_parents = []
-        for node in stmts:
-            stmt = node.statement()
-            # line filtering is on and we have reached our location, break
-            if mylineno > 0 and stmt.fromlineno > mylineno:
-                break
-            assert hasattr(node, 'ass_type'), (node, node.scope(),
-                                               node.scope().locals)
-            ass_type = node.ass_type()
-
-            if node.has_base(self):
-                break
-
-            _stmts, done = ass_type._get_filtered_stmts(self, node, _stmts, mystmt)
-            if done:
-                break
-
-            optional_assign = ass_type.optional_assign
-            if optional_assign and ass_type.parent_of(self):
-                # we are inside a loop, loop var assigment is hidding previous
-                # assigment
-                _stmts = [node]
-                _stmt_parents = [stmt.parent]
-                continue
-
-            # XXX comment various branches below!!!
-            try:
-                pindex = _stmt_parents.index(stmt.parent)
-            except ValueError:
-                pass
-            else:
-                # we got a parent index, this means the currently visited node
-                # is at the same block level as a previously visited node
-                if _stmts[pindex].ass_type().parent_of(ass_type):
-                    # both statements are not at the same block level
-                    continue
-                # if currently visited node is following previously considered
-                # assignement and both are not exclusive, we can drop the
-                # previous one. For instance in the following code ::
-                #
-                #   if a:
-                #     x = 1
-                #   else:
-                #     x = 2
-                #   print x
-                #
-                # we can't remove neither x = 1 nor x = 2 when looking for 'x'
-                # of 'print x'; while in the following ::
-                #
-                #   x = 1
-                #   x = 2
-                #   print x
-                #
-                # we can remove x = 1 when we see x = 2
-                #
-                # moreover, on loop assignment types, assignment won't
-                # necessarily be done if the loop has no iteration, so we don't
-                # want to clear previous assigments if any (hence the test on
-                # optional_assign)
-                if not (optional_assign or are_exclusive(_stmts[pindex], node)):
-                    del _stmt_parents[pindex]
-                    del _stmts[pindex]
-            if isinstance(node, AssName):
-                if not optional_assign and stmt.parent is mystmt.parent:
-                    _stmts = []
-                    _stmt_parents = []
-            elif isinstance(node, DelName):
-                _stmts = []
-                _stmt_parents = []
-                continue
-            if not are_exclusive(self, node):
-                _stmts.append(node)
-                _stmt_parents.append(stmt.parent)
-        return _stmts
-
-# Name classes
-
-class AssName(LookupMixIn, ParentAssignTypeMixin, NodeNG):
-    """class representing an AssName node"""
-
-
-class DelName(LookupMixIn, ParentAssignTypeMixin, NodeNG):
-    """class representing a DelName node"""
-
-
-class Name(LookupMixIn, NodeNG):
-    """class representing a Name node"""
-
-
-
-
-#####################   node classes   ########################################
-
-class Arguments(NodeNG, AssignTypeMixin):
-    """class representing an Arguments node"""
-    _astroid_fields = ('args', 'defaults', 'kwonlyargs', 'kw_defaults')
-    args = None
-    defaults = None
-    kwonlyargs = None
-    kw_defaults = None
-
-    def __init__(self, vararg=None, kwarg=None):
-        self.vararg = vararg
-        self.kwarg = kwarg
-
-    def _infer_name(self, frame, name):
-        if self.parent is frame:
-            return name
-        return None
-
-    def format_args(self):
-        """return arguments formatted as string"""
-        result = []
-        if self.args:
-            result.append(_format_args(self.args, self.defaults))
-        if self.vararg:
-            result.append('*%s' % self.vararg)
-        if self.kwarg:
-            result.append('**%s' % self.kwarg)
-        if self.kwonlyargs:
-            if not self.vararg:
-                result.append('*')
-            result.append(_format_args(self.kwonlyargs, self.kw_defaults))
-        return ', '.join(result)
-
-    def default_value(self, argname):
-        """return the default value for an argument
-
-        :raise `NoDefault`: if there is no default value defined
-        """
-        i = _find_arg(argname, self.args)[0]
-        if i is not None:
-            idx = i - (len(self.args) - len(self.defaults))
-            if idx >= 0:
-                return self.defaults[idx]
-        i = _find_arg(argname, self.kwonlyargs)[0]
-        if i is not None and self.kw_defaults[i] is not None:
-            return self.kw_defaults[i]
-        raise NoDefault()
-
-    def is_argument(self, name):
-        """return True if the name is defined in arguments"""
-        if name == self.vararg:
-            return True
-        if name == self.kwarg:
-            return True
-        return self.find_argname(name, True)[1] is not None
-
-    def find_argname(self, argname, rec=False):
-        """return index and Name node with given name"""
-        if self.args: # self.args may be None in some cases (builtin function)
-            return _find_arg(argname, self.args, rec)
-        return None, None
-
-    def get_children(self):
-        """override get_children to skip over None elements in kw_defaults"""
-        for child in super(Arguments, self).get_children():
-            if child is not None:
-                yield child
-
-
-def _find_arg(argname, args, rec=False):
-    for i, arg in enumerate(args):
-        if isinstance(arg, Tuple):
-            if rec:
-                found = _find_arg(argname, arg.elts)
-                if found[0] is not None:
-                    return found
-        elif arg.name == argname:
-            return i, arg
-    return None, None
-
-
-def _format_args(args, defaults=None):
-    values = []
-    if args is None:
-        return ''
-    if defaults is not None:
-        default_offset = len(args) - len(defaults)
-    for i, arg in enumerate(args):
-        if isinstance(arg, Tuple):
-            values.append('(%s)' % _format_args(arg.elts))
-        else:
-            values.append(arg.name)
-            if defaults is not None and i >= default_offset:
-                if defaults[i-default_offset] is not None:
-                    values[-1] += '=' + defaults[i-default_offset].as_string()
-    return ', '.join(values)
-
-
-class AssAttr(NodeNG, ParentAssignTypeMixin):
-    """class representing an AssAttr node"""
-    _astroid_fields = ('expr',)
-    expr = None
-
-class Assert(Statement):
-    """class representing an Assert node"""
-    _astroid_fields = ('test', 'fail',)
-    test = None
-    fail = None
-
-class Assign(Statement, AssignTypeMixin):
-    """class representing an Assign node"""
-    _astroid_fields = ('targets', 'value',)
-    targets = None
-    value = None
-
-class AugAssign(Statement, AssignTypeMixin):
-    """class representing an AugAssign node"""
-    _astroid_fields = ('target', 'value',)
-    target = None
-    value = None
-
-class Backquote(NodeNG):
-    """class representing a Backquote node"""
-    _astroid_fields = ('value',)
-    value = None
-
-class BinOp(NodeNG):
-    """class representing a BinOp node"""
-    _astroid_fields = ('left', 'right',)
-    left = None
-    right = None
-
-class BoolOp(NodeNG):
-    """class representing a BoolOp node"""
-    _astroid_fields = ('values',)
-    values = None
-
-class Break(Statement):
-    """class representing a Break node"""
-
-
-class CallFunc(NodeNG):
-    """class representing a CallFunc node"""
-    _astroid_fields = ('func', 'args', 'starargs', 'kwargs')
-    func = None
-    args = None
-    starargs = None
-    kwargs = None
-
-    def __init__(self):
-        self.starargs = None
-        self.kwargs = None
-
-class Compare(NodeNG):
-    """class representing a Compare node"""
-    _astroid_fields = ('left', 'ops',)
-    left = None
-    ops = None
-
-    def get_children(self):
-        """override get_children for tuple fields"""
-        yield self.left
-        for _, comparator in self.ops:
-            yield comparator # we don't want the 'op'
-
-    def last_child(self):
-        """override last_child"""
-        # XXX maybe if self.ops:
-        return self.ops[-1][1]
-        #return self.left
-
-class Comprehension(NodeNG):
-    """class representing a Comprehension node"""
-    _astroid_fields = ('target', 'iter' ,'ifs')
-    target = None
-    iter = None
-    ifs = None
-
-    optional_assign = True
-    def ass_type(self):
-        return self
-
-    def _get_filtered_stmts(self, lookup_node, node, stmts, mystmt):
-        """method used in filter_stmts"""
-        if self is mystmt:
-            if isinstance(lookup_node, (Const, Name)):
-                return [lookup_node], True
-
-        elif self.statement() is mystmt:
-            # original node's statement is the assignment, only keeps
-            # current node (gen exp, list comp)
-
-            return [node], True
-
-        return stmts, False
-
-
-class Const(NodeNG, Instance):
-    """represent a constant node like num, str, bool, None, bytes"""
-
-    def __init__(self, value=None):
-        self.value = value
-
-    def getitem(self, index, context=None):
-        if isinstance(self.value, basestring):
-            return Const(self.value[index])
-        raise TypeError('%r (value=%s)' % (self, self.value))
-
-    def has_dynamic_getattr(self):
-        return False
-
-    def itered(self):
-        if isinstance(self.value, basestring):
-            return self.value
-        raise TypeError()
-
-    def pytype(self):
-        return self._proxied.qname()
-
-
-class Continue(Statement):
-    """class representing a Continue node"""
-
-
-class Decorators(NodeNG):
-    """class representing a Decorators node"""
-    _astroid_fields = ('nodes',)
-    nodes = None
-
-    def __init__(self, nodes=None):
-        self.nodes = nodes
-
-    def scope(self):
-        # skip the function node to go directly to the upper level scope
-        return self.parent.parent.scope()
-
-class DelAttr(NodeNG, ParentAssignTypeMixin):
-    """class representing a DelAttr node"""
-    _astroid_fields = ('expr',)
-    expr = None
-
-
-class Delete(Statement, AssignTypeMixin):
-    """class representing a Delete node"""
-    _astroid_fields = ('targets',)
-    targets = None
-
-
-class Dict(NodeNG, Instance):
-    """class representing a Dict node"""
-    _astroid_fields = ('items',)
-
-    def __init__(self, items=None):
-        if items is None:
-            self.items = []
-        else:
-            self.items = [(const_factory(k), const_factory(v))
-                          for k,v in items.iteritems()]
-
-    def pytype(self):
-        return '%s.dict' % BUILTINS
-
-    def get_children(self):
-        """get children of a Dict node"""
-        # overrides get_children
-        for key, value in self.items:
-            yield key
-            yield value
-
-    def last_child(self):
-        """override last_child"""
-        if self.items:
-            return self.items[-1][1]
-        return None
-
-    def itered(self):
-        return self.items[::2]
-
-    def getitem(self, lookup_key, context=None):
-        for key, value in self.items:
-            for inferedkey in key.infer(context):
-                if inferedkey is YES:
-                    continue
-                if isinstance(inferedkey, Const) and inferedkey.value == lookup_key:
-                    return value
-        # This should raise KeyError, but all call sites only catch
-        # IndexError. Let's leave it like that for now.
-        raise IndexError(lookup_key)
-
-
-class Discard(Statement):
-    """class representing a Discard node"""
-    _astroid_fields = ('value',)
-    value = None
-
-
-class Ellipsis(NodeNG):
-    """class representing an Ellipsis node"""
-
-
-class EmptyNode(NodeNG):
-    """class representing an EmptyNode node"""
-
-
-class ExceptHandler(Statement, AssignTypeMixin):
-    """class representing an ExceptHandler node"""
-    _astroid_fields = ('type', 'name', 'body',)
-    type = None
-    name = None
-    body = None
-
-    def _blockstart_toline(self):
-        if self.name:
-            return self.name.tolineno
-        elif self.type:
-            return self.type.tolineno
-        else:
-            return self.lineno
-
-    def set_line_info(self, lastchild):
-        self.fromlineno = self.lineno
-        self.tolineno = lastchild.tolineno
-        self.blockstart_tolineno = self._blockstart_toline()
-
-    def catch(self, exceptions):
-        if self.type is None or exceptions is None:
-            return True
-        for node in self.type.nodes_of_class(Name):
-            if node.name in exceptions:
-                return True
-
-
-class Exec(Statement):
-    """class representing an Exec node"""
-    _astroid_fields = ('expr', 'globals', 'locals',)
-    expr = None
-    globals = None
-    locals = None
-
-
-class ExtSlice(NodeNG):
-    """class representing an ExtSlice node"""
-    _astroid_fields = ('dims',)
-    dims = None
-
-class For(BlockRangeMixIn, AssignTypeMixin, Statement):
-    """class representing a For node"""
-    _astroid_fields = ('target', 'iter', 'body', 'orelse',)
-    target = None
-    iter = None
-    body = None
-    orelse = None
-
-    optional_assign = True
-    def _blockstart_toline(self):
-        return self.iter.tolineno
-
-
-class From(FromImportMixIn, Statement):
-    """class representing a From node"""
-
-    def __init__(self,  fromname, names, level=0):
-        self.modname = fromname
-        self.names = names
-        self.level = level
-
-class Getattr(NodeNG):
-    """class representing a Getattr node"""
-    _astroid_fields = ('expr',)
-    expr = None
-
-
-class Global(Statement):
-    """class representing a Global node"""
-
-    def __init__(self, names):
-        self.names = names
-
-    def _infer_name(self, frame, name):
-        return name
-
-
-class If(BlockRangeMixIn, Statement):
-    """class representing an If node"""
-    _astroid_fields = ('test', 'body', 'orelse')
-    test = None
-    body = None
-    orelse = None
-
-    def _blockstart_toline(self):
-        return self.test.tolineno
-
-    def block_range(self, lineno):
-        """handle block line numbers range for if statements"""
-        if lineno == self.body[0].fromlineno:
-            return lineno, lineno
-        if lineno <= self.body[-1].tolineno:
-            return lineno, self.body[-1].tolineno
-        return self._elsed_block_range(lineno, self.orelse,
-                                       self.body[0].fromlineno - 1)
-
-
-class IfExp(NodeNG):
-    """class representing an IfExp node"""
-    _astroid_fields = ('test', 'body', 'orelse')
-    test = None
-    body = None
-    orelse = None
-
-
-class Import(FromImportMixIn, Statement):
-    """class representing an Import node"""
-
-
-class Index(NodeNG):
-    """class representing an Index node"""
-    _astroid_fields = ('value',)
-    value = None
-
-
-class Keyword(NodeNG):
-    """class representing a Keyword node"""
-    _astroid_fields = ('value',)
-    value = None
-
-
-class List(NodeNG, Instance, ParentAssignTypeMixin):
-    """class representing a List node"""
-    _astroid_fields = ('elts',)
-
-    def __init__(self, elts=None):
-        if elts is None:
-            self.elts = []
-        else:
-            self.elts = [const_factory(e) for e in elts]
-
-    def pytype(self):
-        return '%s.list' % BUILTINS
-
-    def getitem(self, index, context=None):
-        return self.elts[index]
-
-    def itered(self):
-        return self.elts
-
-
-class Nonlocal(Statement):
-    """class representing a Nonlocal node"""
-
-    def __init__(self, names):
-        self.names = names
-
-    def _infer_name(self, frame, name):
-        return name
-
-
-class Pass(Statement):
-    """class representing a Pass node"""
-
-
-class Print(Statement):
-    """class representing a Print node"""
-    _astroid_fields = ('dest', 'values',)
-    dest = None
-    values = None
-
-
-class Raise(Statement):
-    """class representing a Raise node"""
-    exc = None
-    if sys.version_info < (3, 0):
-        _astroid_fields = ('exc', 'inst', 'tback')
-        inst = None
-        tback = None
-    else:
-        _astroid_fields = ('exc', 'cause')
-        exc = None
-        cause = None
-
-    def raises_not_implemented(self):
-        if not self.exc:
-            return
-        for name in self.exc.nodes_of_class(Name):
-            if name.name == 'NotImplementedError':
-                return True
-
-
-class Return(Statement):
-    """class representing a Return node"""
-    _astroid_fields = ('value',)
-    value = None
-
-
-class Set(NodeNG, Instance, ParentAssignTypeMixin):
-    """class representing a Set node"""
-    _astroid_fields = ('elts',)
-
-    def __init__(self, elts=None):
-        if elts is None:
-            self.elts = []
-        else:
-            self.elts = [const_factory(e) for e in elts]
-
-    def pytype(self):
-        return '%s.set' % BUILTINS
-
-    def itered(self):
-        return self.elts
-
-
-class Slice(NodeNG):
-    """class representing a Slice node"""
-    _astroid_fields = ('lower', 'upper', 'step')
-    lower = None
-    upper = None
-    step = None
-
-class Starred(NodeNG, ParentAssignTypeMixin):
-    """class representing a Starred node"""
-    _astroid_fields = ('value',)
-    value = None
-
-
-class Subscript(NodeNG):
-    """class representing a Subscript node"""
-    _astroid_fields = ('value', 'slice')
-    value = None
-    slice = None
-
-
-class TryExcept(BlockRangeMixIn, Statement):
-    """class representing a TryExcept node"""
-    _astroid_fields = ('body', 'handlers', 'orelse',)
-    body = None
-    handlers = None
-    orelse = None
-
-    def _infer_name(self, frame, name):
-        return name
-
-    def _blockstart_toline(self):
-        return self.lineno
-
-    def block_range(self, lineno):
-        """handle block line numbers range for try/except statements"""
-        last = None
-        for exhandler in self.handlers:
-            if exhandler.type and lineno == exhandler.type.fromlineno:
-                return lineno, lineno
-            if exhandler.body[0].fromlineno <= lineno <= exhandler.body[-1].tolineno:
-                return lineno, exhandler.body[-1].tolineno
-            if last is None:
-                last = exhandler.body[0].fromlineno - 1
-        return self._elsed_block_range(lineno, self.orelse, last)
-
-
-class TryFinally(BlockRangeMixIn, Statement):
-    """class representing a TryFinally node"""
-    _astroid_fields = ('body', 'finalbody',)
-    body = None
-    finalbody = None
-
-    def _blockstart_toline(self):
-        return self.lineno
-
-    def block_range(self, lineno):
-        """handle block line numbers range for try/finally statements"""
-        child = self.body[0]
-        # py2.5 try: except: finally:
-        if (isinstance(child, TryExcept) and child.fromlineno == self.fromlineno
-            and lineno > self.fromlineno and lineno <= child.tolineno):
-            return child.block_range(lineno)
-        return self._elsed_block_range(lineno, self.finalbody)
-
-
-class Tuple(NodeNG, Instance, ParentAssignTypeMixin):
-    """class representing a Tuple node"""
-    _astroid_fields = ('elts',)
-
-    def __init__(self, elts=None):
-        if elts is None:
-            self.elts = []
-        else:
-            self.elts = [const_factory(e) for e in elts]
-
-    def pytype(self):
-        return '%s.tuple' % BUILTINS
-
-    def getitem(self, index, context=None):
-        return self.elts[index]
-
-    def itered(self):
-        return self.elts
-
-
-class UnaryOp(NodeNG):
-    """class representing an UnaryOp node"""
-    _astroid_fields = ('operand',)
-    operand = None
-
-
-class While(BlockRangeMixIn, Statement):
-    """class representing a While node"""
-    _astroid_fields = ('test', 'body', 'orelse',)
-    test = None
-    body = None
-    orelse = None
-
-    def _blockstart_toline(self):
-        return self.test.tolineno
-
-    def block_range(self, lineno):
-        """handle block line numbers range for for and while statements"""
-        return self. _elsed_block_range(lineno, self.orelse)
-
-
-class With(BlockRangeMixIn, AssignTypeMixin, Statement):
-    """class representing a With node"""
-    _astroid_fields = ('items', 'body')
-    items = None
-    body = None
-
-    def _blockstart_toline(self):
-        return self.items[-1][0].tolineno
-
-    def get_children(self):
-        for expr, var in self.items:
-            yield expr
-            if var:
-                yield var
-        for elt in self.body:
-            yield elt
-
-class Yield(NodeNG):
-    """class representing a Yield node"""
-    _astroid_fields = ('value',)
-    value = None
-
-class YieldFrom(Yield):
-    """ Class representing a YieldFrom node. """    
-
-# constants ##############################################################
-
-CONST_CLS = {
-    list: List,
-    tuple: Tuple,
-    dict: Dict,
-    set: Set,
-    type(None): Const,
-    }
-
-def _update_const_classes():
-    """update constant classes, so the keys of CONST_CLS can be reused"""
-    klasses = (bool, int, float, complex, str)
-    if sys.version_info < (3, 0):
-        klasses += (unicode, long)
-    if sys.version_info >= (2, 6):
-        klasses += (bytes,)
-    for kls in klasses:
-        CONST_CLS[kls] = Const
-_update_const_classes()
-
-def const_factory(value):
-    """return an astroid node for a python value"""
-    # XXX we should probably be stricter here and only consider stuff in
-    # CONST_CLS or do better treatment: in case where value is not in CONST_CLS,
-    # we should rather recall the builder on this value than returning an empty
-    # node (another option being that const_factory shouldn't be called with something
-    # not in CONST_CLS)
-    assert not isinstance(value, NodeNG)
-    try:
-        return CONST_CLS[value.__class__](value)
-    except (KeyError, AttributeError):
-        node = EmptyNode()
-        node.object = value
-        return node
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/nodes.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/nodes.py
deleted file mode 100644
index 263ab476..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/nodes.py
+++ /dev/null
@@ -1,73 +0,0 @@
-# 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/>.
-"""
-on all nodes :
- .is_statement, returning true if the node should be considered as a
-  statement node
- .root(), returning the root node of the tree (i.e. a Module)
- .previous_sibling(), returning previous sibling statement node
- .next_sibling(), returning next sibling statement node
- .statement(), returning the first parent node marked as statement node
- .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
-  be used from out there.
-
-on From and Import :
- .real_name(name),
-
-
-"""
-
-__docformat__ = "restructuredtext en"
-
-from astroid.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, \
-    const_factory
-from astroid.scoped_nodes import Module, GenExpr, Lambda, DictComp, \
-    ListComp, SetComp, Function, Class
-
-ALL_NODE_CLASSES = (
-    Arguments, AssAttr, Assert, Assign, AssName, AugAssign,
-    Backquote, BinOp, BoolOp, Break,
-    CallFunc, Class, Compare, Comprehension, Const, Continue,
-    Decorators, DelAttr, DelName, Delete,
-    Dict, DictComp, Discard,
-    Ellipsis, EmptyNode, ExceptHandler, Exec, ExtSlice,
-    For, From, Function,
-    Getattr, GenExpr, Global,
-    If, IfExp, Import, Index,
-    Keyword,
-    Lambda, List, ListComp,
-    Name, Nonlocal,
-    Module,
-    Pass, Print,
-    Raise, Return,
-    Set, SetComp, Slice, Starred, Subscript,
-    TryExcept, TryFinally, Tuple,
-    UnaryOp,
-    While, With,
-    Yield, YieldFrom
-    )
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/protocols.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/protocols.py
deleted file mode 100644
index e66b802c..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/protocols.py
+++ /dev/null
@@ -1,322 +0,0 @@
-# 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 handle python protocols for nodes
-where it makes sense.
-"""
-
-__doctype__ = "restructuredtext en"
-
-from astroid.exceptions import InferenceError, NoDefault
-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
-
-# unary operations ############################################################
-
-def tl_infer_unary_op(self, operator):
-    if operator == 'not':
-        return const_factory(not bool(self.elts))
-    raise TypeError() # XXX log unsupported operation
-nodes.Tuple.infer_unary_op = tl_infer_unary_op
-nodes.List.infer_unary_op = tl_infer_unary_op
-
-
-def dict_infer_unary_op(self, operator):
-    if operator == 'not':
-        return const_factory(not bool(self.items))
-    raise TypeError() # XXX log unsupported operation
-nodes.Dict.infer_unary_op = dict_infer_unary_op
-
-
-def const_infer_unary_op(self, operator):
-    if operator == 'not':
-        return const_factory(not self.value)
-    # XXX log potentially raised TypeError
-    elif operator == '+':
-        return const_factory(+self.value)
-    else: # operator == '-':
-        return const_factory(-self.value)
-nodes.Const.infer_unary_op = const_infer_unary_op
-
-
-# binary operations ###########################################################
-
-BIN_OP_IMPL = {'+':  lambda a, b: a + b,
-               '-':  lambda a, b: a - b,
-               '/':  lambda a, b: a / b,
-               '//': lambda a, b: a // b,
-               '*':  lambda a, b: a * b,
-               '**': lambda a, b: a ** b,
-               '%':  lambda a, b: a % b,
-               '&':  lambda a, b: a & b,
-               '|':  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
-
-def const_infer_binary_op(self, operator, other, context):
-    for other in other.infer(context):
-        if isinstance(other, nodes.Const):
-            try:
-                impl = BIN_OP_IMPL[operator]
-
-                try:
-                    yield const_factory(impl(self.value, other.value))
-                except Exception:
-                    # ArithmeticError is not enough: float >> float is a TypeError
-                    # TODO : let pylint know about the problem
-                    pass
-            except TypeError:
-                # XXX log TypeError
-                continue
-        elif other is YES:
-            yield other
-        else:
-            try:
-                for val in other.infer_binary_op(operator, self, context):
-                    yield val
-            except AttributeError:
-                yield YES
-nodes.Const.infer_binary_op = yes_if_nothing_infered(const_infer_binary_op)
-
-
-def tl_infer_binary_op(self, operator, other, context):
-    for other in other.infer(context):
-        if isinstance(other, self.__class__) and operator == '+':
-            node = self.__class__()
-            elts = [n for elt in self.elts for n in elt.infer(context)
-                    if not n is YES]
-            elts += [n for elt in other.elts for n in elt.infer(context)
-                     if not n is YES]
-            node.elts = elts
-            yield node
-        elif isinstance(other, nodes.Const) and operator == '*':
-            if not isinstance(other.value, int):
-                yield YES
-                continue
-            node = self.__class__()
-            elts = [n for elt in self.elts for n in elt.infer(context)
-                    if not n is YES] * other.value
-            node.elts = elts
-            yield node
-        elif isinstance(other, Instance) and not isinstance(other, nodes.Const):
-            yield YES
-    # XXX else log TypeError
-nodes.Tuple.infer_binary_op = yes_if_nothing_infered(tl_infer_binary_op)
-nodes.List.infer_binary_op = yes_if_nothing_infered(tl_infer_binary_op)
-
-
-def dict_infer_binary_op(self, operator, other, context):
-    for other in other.infer(context):
-        if isinstance(other, Instance) and isinstance(other._proxied, nodes.Class):
-            yield YES
-        # XXX else log TypeError
-nodes.Dict.infer_binary_op = yes_if_nothing_infered(dict_infer_binary_op)
-
-
-# assignment ##################################################################
-
-"""the assigned_stmts method is responsible to return the assigned statement
-(e.g. not inferred) according to the assignment type.
-
-The `asspath` argument is used to record the lhs path of the original node.
-For instance if we want assigned statements for 'c' in 'a, (b,c)', asspath
-will be [1, 1] once arrived to the Assign node.
-
-The `context` argument is the current inference context which should be given
-to any intermediary inference necessary.
-"""
-
-def _resolve_looppart(parts, asspath, context):
-    """recursive function to resolve multiple assignments on loops"""
-    asspath = asspath[:]
-    index = asspath.pop(0)
-    for part in parts:
-        if part is YES:
-            continue
-        # XXX handle __iter__ and log potentially detected errors
-        if not hasattr(part, 'itered'):
-            continue
-        try:
-            itered = part.itered()
-        except TypeError:
-            continue # XXX log error
-        for stmt in itered:
-            try:
-                assigned = stmt.getitem(index, context)
-            except (AttributeError, IndexError):
-                continue
-            except TypeError, exc: # stmt is unsubscriptable Const
-                continue
-            if not asspath:
-                # we achieved to resolved the assignment path,
-                # don't infer the last part
-                yield assigned
-            elif assigned is YES:
-                break
-            else:
-                # we are not yet on the last part of the path
-                # search on each possibly inferred value
-                try:
-                    for infered in _resolve_looppart(assigned.infer(context),
-                                                     asspath, context):
-                        yield infered
-                except InferenceError:
-                    break
-
-
-def for_assigned_stmts(self, node, context=None, asspath=None):
-    if asspath is None:
-        for lst in self.iter.infer(context):
-            if isinstance(lst, (nodes.Tuple, nodes.List)):
-                for item in lst.elts:
-                    yield item
-    else:
-        for infered in _resolve_looppart(self.iter.infer(context),
-                                         asspath, context):
-            yield infered
-
-nodes.For.assigned_stmts = raise_if_nothing_infered(for_assigned_stmts)
-nodes.Comprehension.assigned_stmts = raise_if_nothing_infered(for_assigned_stmts)
-
-
-def mulass_assigned_stmts(self, node, context=None, asspath=None):
-    if asspath is None:
-        asspath = []
-    asspath.insert(0, self.elts.index(node))
-    return self.parent.assigned_stmts(self, context, asspath)
-nodes.Tuple.assigned_stmts = mulass_assigned_stmts
-nodes.List.assigned_stmts = mulass_assigned_stmts
-
-
-def assend_assigned_stmts(self, context=None):
-    return self.parent.assigned_stmts(self, context=context)
-nodes.AssName.assigned_stmts = assend_assigned_stmts
-nodes.AssAttr.assigned_stmts = assend_assigned_stmts
-
-
-def _arguments_infer_argname(self, name, context):
-    # arguments information may be missing, in which case we can't do anything
-    # more
-    if not (self.args or self.vararg or self.kwarg):
-        yield YES
-        return
-    # first argument of instance/class method
-    if self.args and getattr(self.args[0], 'name', None) == name:
-        functype = self.parent.type
-        if functype == 'method':
-            yield Instance(self.parent.parent.frame())
-            return
-        if functype == 'classmethod':
-            yield self.parent.parent.frame()
-            return
-    if name == self.vararg:
-        yield const_factory(())
-        return
-    if name == self.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
-    try:
-        context = copy_context(context)
-        for infered in self.default_value(name).infer(context):
-            yield infered
-        yield YES
-    except NoDefault:
-        yield YES
-
-
-def arguments_assigned_stmts(self, node, context, asspath=None):
-    if context.callcontext:
-        # reset call context/name
-        callcontext = context.callcontext
-        context = copy_context(context)
-        context.callcontext = None
-        for infered in callcontext.infer_argument(self.parent, node.name, context):
-            yield infered
-        return
-    for infered in _arguments_infer_argname(self, node.name, context):
-        yield infered
-nodes.Arguments.assigned_stmts = arguments_assigned_stmts
-
-
-def assign_assigned_stmts(self, node, context=None, asspath=None):
-    if not asspath:
-        yield self.value
-        return
-    for infered in _resolve_asspart(self.value.infer(context), asspath, context):
-        yield infered
-nodes.Assign.assigned_stmts = raise_if_nothing_infered(assign_assigned_stmts)
-nodes.AugAssign.assigned_stmts = raise_if_nothing_infered(assign_assigned_stmts)
-
-
-def _resolve_asspart(parts, asspath, context):
-    """recursive function to resolve multiple assignments"""
-    asspath = asspath[:]
-    index = asspath.pop(0)
-    for part in parts:
-        if hasattr(part, 'getitem'):
-            try:
-                assigned = part.getitem(index, context)
-            # XXX raise a specific exception to avoid potential hiding of
-            # unexpected exception ?
-            except (TypeError, IndexError):
-                return
-            if not asspath:
-                # we achieved to resolved the assignment path, don't infer the
-                # last part
-                yield assigned
-            elif assigned is YES:
-                return
-            else:
-                # we are not yet on the last part of the path search on each
-                # possibly inferred value
-                try:
-                    for infered in _resolve_asspart(assigned.infer(context),
-                                                    asspath, context):
-                        yield infered
-                except InferenceError:
-                    return
-
-
-def excepthandler_assigned_stmts(self, node, context=None, asspath=None):
-    for assigned in unpack_infer(self.type):
-        if isinstance(assigned, nodes.Class):
-            assigned = Instance(assigned)
-        yield assigned
-nodes.ExceptHandler.assigned_stmts = raise_if_nothing_infered(excepthandler_assigned_stmts)
-
-
-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
-nodes.With.assigned_stmts = raise_if_nothing_infered(with_assigned_stmts)
-
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/raw_building.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/raw_building.py
deleted file mode 100644
index bb685a9e..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/raw_building.py
+++ /dev/null
@@ -1,361 +0,0 @@
-# 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)
-
-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
-
-def _io_discrepancy(member):
-    # _io module names itself `io`: http://bugs.python.org/issue18602
-    member_self = getattr(member, '__self__', None)
-    return (member_self and
-            ismodule(member_self) and
-            member_self.__name__ == '_io' and
-            member.__module__ == 'io')
-
-def _attach_local_node(parent, node, name):
-    node.name = name # needed by add_local_node
-    parent.add_local_node(node)
-
-_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 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
-    node with the specified name
-    """
-    from_node = From(modname, [(membername, None)])
-    _attach_local_node(node, from_node, membername)
-
-
-def build_module(name, doc=None):
-    """create and initialize a astroid Module node"""
-    node = Module(name, doc, pure_python=False)
-    node.package = False
-    node.parent = None
-    return node
-
-def build_class(name, basenames=(), doc=None):
-    """create and initialize a astroid Class node"""
-    node = Class(name, doc)
-    for base in basenames:
-        basenode = Name()
-        basenode.name = base
-        node.bases.append(basenode)
-        basenode.parent = node
-    return node
-
-def build_function(name, args=None, defaults=None, flag=0, doc=None):
-    """create and initialize a astroid Function node"""
-    args, defaults = args or [], defaults or []
-    # first argument is now a list of decorators
-    func = Function(name, doc)
-    func.args = argsnode = Arguments()
-    argsnode.args = []
-    for arg in args:
-        argsnode.args.append(Name())
-        argsnode.args[-1].name = arg
-        argsnode.args[-1].parent = argsnode
-    argsnode.defaults = []
-    for default in defaults:
-        argsnode.defaults.append(const_factory(default))
-        argsnode.defaults[-1].parent = argsnode
-    argsnode.kwarg = None
-    argsnode.vararg = None
-    argsnode.parent = func
-    if args:
-        register_arguments(func)
-    return func
-
-
-def build_from_import(fromname, names):
-    """create and initialize an astroid From import statement"""
-    return From(fromname, [(name, None) for name in names])
-
-def register_arguments(func, args=None):
-    """add given arguments to local
-
-    args is a list that may contains nested lists
-    (i.e. def func(a, (b, c, d)): ...)
-    """
-    if args is None:
-        args = func.args.args
-        if func.args.vararg:
-            func.set_local(func.args.vararg, func.args)
-        if func.args.kwarg:
-            func.set_local(func.args.kwarg, func.args)
-    for arg in args:
-        if isinstance(arg, Name):
-            func.set_local(arg.name, arg)
-        else:
-            register_arguments(func, arg.elts)
-
-def object_build_class(node, member, localname):
-    """create astroid for a living class object"""
-    basenames = [base.__name__ for base in member.__bases__]
-    return _base_class_object_build(node, member, basenames,
-                                    localname=localname)
-
-def object_build_function(node, member, localname):
-    """create astroid for a living function object"""
-    args, varargs, varkw, defaults = 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, member.func_code.co_flags, member.__doc__)
-    node.add_local_node(func, localname)
-
-def object_build_datadescriptor(node, member, name):
-    """create astroid for a living data descriptor object"""
-    return _base_class_object_build(node, member, [], name)
-
-def object_build_methoddescriptor(node, member, localname):
-    """create astroid for a living method descriptor object"""
-    # FIXME get arguments ?
-    func = build_function(getattr(member, '__name__', None) or localname,
-                          doc=member.__doc__)
-    # set node's arguments to None to notice that we have no information, not
-    # and empty argument list
-    func.args.args = None
-    node.add_local_node(func, localname)
-
-def _base_class_object_build(node, member, basenames, name=None, localname=None):
-    """create astroid for a living class object, with a given set of base names
-    (e.g. ancestors)
-    """
-    klass = build_class(name or getattr(member, '__name__', None) or localname,
-                        basenames, member.__doc__)
-    klass._newstyle = isinstance(member, type)
-    node.add_local_node(klass, localname)
-    try:
-        # limit the instantiation trick since it's too dangerous
-        # (such as infinite test execution...)
-        # this at least resolves common case such as Exception.args,
-        # OSError.errno
-        if issubclass(member, Exception):
-            instdict = member().__dict__
-        else:
-            raise TypeError
-    except:
-        pass
-    else:
-        for name, obj in instdict.items():
-            valnode = EmptyNode()
-            valnode.object = obj
-            valnode.parent = klass
-            valnode.lineno = 1
-            klass.instance_attrs[name] = [valnode]
-    return klass
-
-
-
-
-class InspectBuilder(object):
-    """class for building nodes from living object
-
-    this is actually a really minimal representation, including only Module,
-    Function and Class nodes and some others as guessed.
-    """
-
-    # astroid from living objects ###############################################
-
-    def __init__(self):
-        self._done = {}
-        self._module = None
-
-    def inspect_build(self, module, modname=None, path=None):
-        """build astroid from a living module (i.e. using inspect)
-        this is used when there is no python source code available (either
-        because it's a built-in module or because the .py is not available)
-        """
-        self._module = module
-        if modname is None:
-            modname = module.__name__
-        try:
-            node = build_module(modname, module.__doc__)
-        except AttributeError:
-            # in jython, java modules have no __doc__ (see #109562)
-            node = build_module(modname)
-        node.file = node.path = path and abspath(path) or path
-        node.name = modname
-        MANAGER.cache_module(node)
-        node.package = hasattr(module, '__path__')
-        self._done = {}
-        self.object_build(node, module)
-        return node
-
-    def object_build(self, node, obj):
-        """recursive method which create a partial ast from real objects
-         (only function, class, and method are handled)
-        """
-        if obj in self._done:
-            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
-            if isfunction(member):
-                # verify this is not an imported function
-                filename = getattr(member.func_code, '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:
-                    class_node = object_build_class(node, member, name)
-                    # recursion
-                    self.object_build(class_node, member)
-                if name == '__class__' and class_node.parent is None:
-                    class_node.parent = self._done[self._module]
-            elif ismethoddescriptor(member):
-                assert isinstance(member, object)
-                object_build_methoddescriptor(node, member, name)
-            elif isdatadescriptor(member):
-                assert isinstance(member, object)
-                object_build_datadescriptor(node, member, name)
-            elif type(member) in _CONSTANTS:
-                attach_const_node(node, name, member)
-            else:
-                # create an empty node so that the name is actually defined
-                attach_dummy_node(node, name, member)
-
-    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'
-            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:
-                attach_dummy_node(node, name, member)
-                return True
-        if {'gtk': 'gtk._gtk'}.get(modname, modname) != self._module.__name__:
-            # check if it sounds valid and then add an import node, else use a
-            # dummy node
-            try:
-                getattr(sys.modules[modname], name)
-            except (KeyError, AttributeError):
-                attach_dummy_node(node, name, member)
-            else:
-                attach_import_node(node, modname, name)
-            return True
-        return False
-
-
-### astroid boot strapping ################################################### ###
-Astroid_BUILDER = InspectBuilder()
-
-_CONST_PROXY = {}
-def astroid_boot_strapping():
-    """astroid boot strapping the builtins module"""
-    # this boot strapping is necessary since we need the Const nodes to
-    # inspect_build builtins, and then we can proxy Const
-    from logilab.common.compat import builtins
-    astroid_builtin = Astroid_BUILDER.inspect_build(builtins)
-    for cls, node_cls in CONST_CLS.items():
-        if cls is type(None):
-            proxy = build_class('NoneType')
-            proxy.parent = astroid_builtin
-        else:
-            proxy = astroid_builtin.getattr(cls.__name__)[0]
-        if cls in (dict, list, set, tuple):
-            node_cls._proxied = proxy
-        else:
-            _CONST_PROXY[cls] = proxy
-
-astroid_boot_strapping()
-
-# TODO : find a nicer way to handle this situation;
-# 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)
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/rebuilder.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/rebuilder.py
deleted file mode 100644
index 40a614f8..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/rebuilder.py
+++ /dev/null
@@ -1,954 +0,0 @@
-# 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 utilities for rebuilding a _ast tree in
-order to get a single Astroid representation
-"""
-
-import sys
-from warnings import warn
-from _ast import (Expr as Discard, Str, Name, Attribute,
-    # binary operators
-    Add, Div, FloorDiv,  Mod, Mult, Pow, Sub, BitAnd, BitOr, BitXor,
-    LShift, RShift,
-    # logical operators
-    And, Or,
-    # unary operators
-    UAdd, USub, Not, Invert,
-    # comparison operators
-    Eq, Gt, GtE, In, Is, IsNot, Lt, LtE, NotEq, NotIn,
-    )
-
-from astroid import nodes as new
-
-
-_BIN_OP_CLASSES = {Add: '+',
-                   BitAnd: '&',
-                   BitOr: '|',
-                   BitXor: '^',
-                   Div: '/',
-                   FloorDiv: '//',
-                   Mod: '%',
-                   Mult: '*',
-                   Pow: '**',
-                   Sub: '-',
-                   LShift: '<<',
-                   RShift: '>>'}
-
-_BOOL_OP_CLASSES = {And: 'and',
-                    Or: 'or'}
-
-_UNARY_OP_CLASSES = {UAdd: '+',
-                     USub: '-',
-                     Not: 'not',
-                     Invert: '~'}
-
-_CMP_OP_CLASSES = {Eq: '==',
-                   Gt: '>',
-                   GtE: '>=',
-                   In: 'in',
-                   Is: 'is',
-                   IsNot: 'is not',
-                   Lt: '<',
-                   LtE: '<=',
-                   NotEq: '!=',
-                   NotIn: 'not in'}
-
-CONST_NAME_TRANSFORMS = {'None':  None,
-                         'True':  True,
-                         'False': False}
-
-REDIRECT = {'arguments': 'Arguments',
-            'Attribute': 'Getattr',
-            'comprehension': 'Comprehension',
-            'Call': 'CallFunc',
-            'ClassDef': 'Class',
-            "ListCompFor": 'Comprehension',
-            "GenExprFor": 'Comprehension',
-            'excepthandler': 'ExceptHandler',
-            'Expr': 'Discard',
-            'FunctionDef': 'Function',
-            'GeneratorExp': 'GenExpr',
-            'ImportFrom': 'From',
-            'keyword': 'Keyword',
-            'Repr': 'Backquote',
-            }
-PY3K = sys.version_info >= (3, 0)
-PY34 = sys.version_info >= (3, 4)
-
-def _init_set_doc(node, newnode):
-    newnode.doc = None
-    try:
-        if isinstance(node.body[0], Discard) and isinstance(node.body[0].value, Str):
-            newnode.tolineno = node.body[0].lineno
-            newnode.doc = node.body[0].value.s
-            node.body = node.body[1:]
-
-    except IndexError:
-        pass # ast built from scratch
-
-def _lineno_parent(oldnode, newnode, parent):
-    newnode.parent = parent
-    if hasattr(oldnode, 'lineno'):
-        newnode.lineno = oldnode.lineno
-    if hasattr(oldnode, 'col_offset'):
-        newnode.col_offset = oldnode.col_offset
-
-def _set_infos(oldnode, newnode, parent):
-    newnode.parent = parent
-    if hasattr(oldnode, 'lineno'):
-        newnode.lineno = oldnode.lineno
-    if hasattr(oldnode, 'col_offset'):
-        newnode.col_offset = oldnode.col_offset
-    newnode.set_line_info(newnode.last_child()) # set_line_info accepts None
-
-def _infer_metaclass(node):
-    if isinstance(node, Name):
-        return node.id
-    elif isinstance(node, Attribute):
-        return node.attr
-
-def _create_yield_node(node, parent, rebuilder, factory):
-    newnode = factory()
-    _lineno_parent(node, newnode, parent)
-    if node.value is not None:
-        newnode.value = rebuilder.visit(node.value, newnode)
-    newnode.set_line_info(newnode.last_child())
-    return newnode
-
-
-class TreeRebuilder(object):
-    """Rebuilds the _ast tree to become an Astroid tree"""
-
-    def __init__(self, manager):
-        self._manager = manager
-        self.asscontext = None
-        self._metaclass = ['']
-        self._global_names = []
-        self._from_nodes = []
-        self._delayed_assattr = []
-        self._visit_meths = {}
-        self._transform = manager.transform
-
-    def visit_module(self, node, modname, package):
-        """visit a Module node by returning a fresh instance of it"""
-        newnode = new.Module(modname, None)
-        newnode.package = package
-        _lineno_parent(node, newnode, parent=None)
-        _init_set_doc(node, newnode)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.set_line_info(newnode.last_child())
-        return self._transform(newnode)
-
-    def visit(self, node, parent):
-        cls = node.__class__
-        if cls in self._visit_meths:
-            visit_method = self._visit_meths[cls]
-        else:
-            cls_name = cls.__name__
-            visit_name = 'visit_' + REDIRECT.get(cls_name, cls_name).lower()
-            visit_method = getattr(self, visit_name)
-            self._visit_meths[cls] = visit_method
-        return self._transform(visit_method(node, parent))
-
-    def _save_assignment(self, node, name=None):
-        """save assignement situation since node.parent is not available yet"""
-        if self._global_names and node.name in self._global_names[-1]:
-            node.root().set_local(node.name, node)
-        else:
-            node.parent.set_local(node.name, node)
-
-
-    def visit_arguments(self, node, parent):
-        """visit a Arguments node by returning a fresh instance of it"""
-        newnode = new.Arguments()
-        _lineno_parent(node, newnode, parent)
-        self.asscontext = "Ass"
-        newnode.args = [self.visit(child, newnode) for child in node.args]
-        self.asscontext = None
-        newnode.defaults = [self.visit(child, newnode) for child in node.defaults]
-        newnode.kwonlyargs = []
-        newnode.kw_defaults = []
-        vararg, kwarg = node.vararg, node.kwarg
-        # change added in 82732 (7c5c678e4164), vararg and kwarg
-        # are instances of `_ast.arg`, not strings
-        if vararg and PY34:
-            vararg = vararg.arg
-        if kwarg and PY34:
-            kwarg = kwarg.arg
-        newnode.vararg = vararg
-        newnode.kwarg = kwarg
-        # save argument names in locals:
-        if vararg:
-            newnode.parent.set_local(vararg, newnode)
-        if kwarg:
-            newnode.parent.set_local(kwarg, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_assattr(self, node, parent):
-        """visit a AssAttr node by returning a fresh instance of it"""
-        assc, self.asscontext = self.asscontext, None
-        newnode = new.AssAttr()
-        _lineno_parent(node, newnode, parent)
-        newnode.expr = self.visit(node.expr, newnode)
-        self.asscontext = assc
-        self._delayed_assattr.append(newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_assert(self, node, parent):
-        """visit a Assert node by returning a fresh instance of it"""
-        newnode = new.Assert()
-        _lineno_parent(node, newnode, parent)
-        newnode.test = self.visit(node.test, newnode)
-        if node.msg is not None:
-            newnode.fail = self.visit(node.msg, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_assign(self, node, parent):
-        """visit a Assign node by returning a fresh instance of it"""
-        newnode = new.Assign()
-        _lineno_parent(node, newnode, parent)
-        self.asscontext = "Ass"
-        newnode.targets = [self.visit(child, newnode) for child in node.targets]
-        self.asscontext = None
-        newnode.value = self.visit(node.value, newnode)
-        # set some function or metaclass infos  XXX explain ?
-        klass = newnode.parent.frame()
-        if (isinstance(klass, new.Class)
-            and isinstance(newnode.value, new.CallFunc)
-            and isinstance(newnode.value.func, new.Name)):
-            func_name = newnode.value.func.name
-            for ass_node in newnode.targets:
-                try:
-                    meth = klass[ass_node.name]
-                    if isinstance(meth, new.Function):
-                        if func_name in ('classmethod', 'staticmethod'):
-                            meth.type = func_name
-                        elif func_name == 'classproperty': # see lgc.decorators
-                            meth.type = 'classmethod'
-                        meth.extra_decorators.append(newnode.value)
-                except (AttributeError, KeyError):
-                    continue
-        elif getattr(newnode.targets[0], 'name', None) == '__metaclass__':
-            # XXX check more...
-            self._metaclass[-1] = _infer_metaclass(node.value)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_assname(self, node, parent, node_name=None):
-        '''visit a node and return a AssName node'''
-        newnode = new.AssName()
-        _set_infos(node, newnode, parent)
-        newnode.name = node_name
-        self._save_assignment(newnode)
-        return newnode
-
-    def visit_augassign(self, node, parent):
-        """visit a AugAssign node by returning a fresh instance of it"""
-        newnode = new.AugAssign()
-        _lineno_parent(node, newnode, parent)
-        newnode.op = _BIN_OP_CLASSES[node.op.__class__] + "="
-        self.asscontext = "Ass"
-        newnode.target = self.visit(node.target, newnode)
-        self.asscontext = None
-        newnode.value = self.visit(node.value, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_backquote(self, node, parent):
-        """visit a Backquote node by returning a fresh instance of it"""
-        newnode = new.Backquote()
-        _lineno_parent(node, newnode, parent)
-        newnode.value = self.visit(node.value, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_binop(self, node, parent):
-        """visit a BinOp node by returning a fresh instance of it"""
-        newnode = new.BinOp()
-        _lineno_parent(node, newnode, parent)
-        newnode.left = self.visit(node.left, newnode)
-        newnode.right = self.visit(node.right, newnode)
-        newnode.op = _BIN_OP_CLASSES[node.op.__class__]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_boolop(self, node, parent):
-        """visit a BoolOp node by returning a fresh instance of it"""
-        newnode = new.BoolOp()
-        _lineno_parent(node, newnode, parent)
-        newnode.values = [self.visit(child, newnode) for child in node.values]
-        newnode.op = _BOOL_OP_CLASSES[node.op.__class__]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_break(self, node, parent):
-        """visit a Break node by returning a fresh instance of it"""
-        newnode = new.Break()
-        _set_infos(node, newnode, parent)
-        return newnode
-
-    def visit_callfunc(self, node, parent):
-        """visit a CallFunc node by returning a fresh instance of it"""
-        newnode = new.CallFunc()
-        _lineno_parent(node, newnode, parent)
-        newnode.func = self.visit(node.func, newnode)
-        newnode.args = [self.visit(child, newnode) for child in node.args]
-        if node.starargs is not None:
-            newnode.starargs = self.visit(node.starargs, newnode)
-        if node.kwargs is not None:
-            newnode.kwargs = self.visit(node.kwargs, newnode)
-        newnode.args.extend(self.visit(child, newnode) for child in node.keywords)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_class(self, node, parent):
-        """visit a Class node to become astroid"""
-        self._metaclass.append(self._metaclass[-1])
-        newnode = new.Class(node.name, None)
-        _lineno_parent(node, newnode, parent)
-        _init_set_doc(node, newnode)
-        newnode.bases = [self.visit(child, newnode) for child in node.bases]
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        if 'decorator_list' in node._fields and node.decorator_list:# py >= 2.6
-            newnode.decorators = self.visit_decorators(node, newnode)
-        newnode.set_line_info(newnode.last_child())
-        metaclass = self._metaclass.pop()
-        if PY3K:
-            newnode._newstyle = True
-        else:
-            if not newnode.bases:
-                # no base classes, detect new / style old style according to
-                # current scope
-                newnode._newstyle = metaclass in ('type', 'ABCMeta')
-        newnode.parent.frame().set_local(newnode.name, newnode)
-        return newnode
-
-    def visit_const(self, node, parent):
-        """visit a Const node by returning a fresh instance of it"""
-        newnode = new.Const(node.value)
-        _set_infos(node, newnode, parent)
-        return newnode
-
-    def visit_continue(self, node, parent):
-        """visit a Continue node by returning a fresh instance of it"""
-        newnode = new.Continue()
-        _set_infos(node, newnode, parent)
-        return newnode
-
-    def visit_compare(self, node, parent):
-        """visit a Compare node by returning a fresh instance of it"""
-        newnode = new.Compare()
-        _lineno_parent(node, newnode, parent)
-        newnode.left = self.visit(node.left, newnode)
-        newnode.ops = [(_CMP_OP_CLASSES[op.__class__], self.visit(expr, newnode))
-                    for (op, expr) in zip(node.ops, node.comparators)]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_comprehension(self, node, parent):
-        """visit a Comprehension node by returning a fresh instance of it"""
-        newnode = new.Comprehension()
-        _lineno_parent(node, newnode, parent)
-        self.asscontext = "Ass"
-        newnode.target = self.visit(node.target, newnode)
-        self.asscontext = None
-        newnode.iter = self.visit(node.iter, newnode)
-        newnode.ifs = [self.visit(child, newnode) for child in node.ifs]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_decorators(self, node, parent):
-        """visit a Decorators node by returning a fresh instance of it"""
-        # /!\ node is actually a _ast.Function node while
-        # parent is a astroid.nodes.Function node
-        newnode = new.Decorators()
-        _lineno_parent(node, newnode, parent)
-        if 'decorators' in node._fields: # py < 2.6, i.e. 2.5
-            decorators = node.decorators
-        else:
-            decorators= node.decorator_list
-        newnode.nodes = [self.visit(child, newnode) for child in decorators]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_delete(self, node, parent):
-        """visit a Delete node by returning a fresh instance of it"""
-        newnode = new.Delete()
-        _lineno_parent(node, newnode, parent)
-        self.asscontext = "Del"
-        newnode.targets = [self.visit(child, newnode) for child in node.targets]
-        self.asscontext = None
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_dict(self, node, parent):
-        """visit a Dict node by returning a fresh instance of it"""
-        newnode = new.Dict()
-        _lineno_parent(node, newnode, parent)
-        newnode.items = [(self.visit(key, newnode), self.visit(value, newnode))
-                          for key, value in zip(node.keys, node.values)]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_dictcomp(self, node, parent):
-        """visit a DictComp node by returning a fresh instance of it"""
-        newnode = new.DictComp()
-        _lineno_parent(node, newnode, parent)
-        newnode.key = self.visit(node.key, newnode)
-        newnode.value = self.visit(node.value, newnode)
-        newnode.generators = [self.visit(child, newnode)
-                              for child in node.generators]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_discard(self, node, parent):
-        """visit a Discard node by returning a fresh instance of it"""
-        newnode = new.Discard()
-        _lineno_parent(node, newnode, parent)
-        newnode.value = self.visit(node.value, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_ellipsis(self, node, parent):
-        """visit an Ellipsis node by returning a fresh instance of it"""
-        newnode = new.Ellipsis()
-        _set_infos(node, newnode, parent)
-        return newnode
-
-    def visit_emptynode(self, node, parent):
-        """visit an EmptyNode node by returning a fresh instance of it"""
-        newnode = new.EmptyNode()
-        _set_infos(node, newnode, parent)
-        return newnode
-
-    def visit_excepthandler(self, node, parent):
-        """visit an ExceptHandler node by returning a fresh instance of it"""
-        newnode = new.ExceptHandler()
-        _lineno_parent(node, newnode, parent)
-        if node.type is not None:
-            newnode.type = self.visit(node.type, newnode)
-        if node.name is not None:
-            # /!\ node.name can be a tuple
-            self.asscontext = "Ass"
-            newnode.name = self.visit(node.name, newnode)
-            self.asscontext = None
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_exec(self, node, parent):
-        """visit an Exec node by returning a fresh instance of it"""
-        newnode = new.Exec()
-        _lineno_parent(node, newnode, parent)
-        newnode.expr = self.visit(node.body, newnode)
-        if node.globals is not None:
-            newnode.globals = self.visit(node.globals, newnode)
-        if node.locals is not None:
-            newnode.locals = self.visit(node.locals, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_extslice(self, node, parent):
-        """visit an ExtSlice node by returning a fresh instance of it"""
-        newnode = new.ExtSlice()
-        _lineno_parent(node, newnode, parent)
-        newnode.dims = [self.visit(dim, newnode) for dim in node.dims]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_for(self, node, parent):
-        """visit a For node by returning a fresh instance of it"""
-        newnode = new.For()
-        _lineno_parent(node, newnode, parent)
-        self.asscontext = "Ass"
-        newnode.target = self.visit(node.target, newnode)
-        self.asscontext = None
-        newnode.iter = self.visit(node.iter, newnode)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.orelse = [self.visit(child, newnode) for child in node.orelse]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_from(self, node, parent):
-        """visit a From node by returning a fresh instance of it"""
-        names = [(alias.name, alias.asname) for alias in node.names]
-        newnode = new.From(node.module or '', names, node.level or None)
-        _set_infos(node, newnode, parent)
-        # store From names to add them to locals after building
-        self._from_nodes.append(newnode)
-        return newnode
-
-    def visit_function(self, node, parent):
-        """visit an Function node to become astroid"""
-        self._global_names.append({})
-        newnode = new.Function(node.name, None)
-        _lineno_parent(node, newnode, parent)
-        _init_set_doc(node, newnode)
-        newnode.args = self.visit(node.args, newnode)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        if 'decorators' in node._fields: # py < 2.6
-            attr = 'decorators'
-        else:
-            attr = 'decorator_list'
-        decorators = getattr(node, attr)
-        if decorators:
-            newnode.decorators = self.visit_decorators(node, newnode)
-        newnode.set_line_info(newnode.last_child())
-        self._global_names.pop()
-        frame = newnode.parent.frame()
-        if isinstance(frame, new.Class):
-            if newnode.name == '__new__':
-                newnode._type = 'classmethod'
-            else:
-                newnode._type = 'method'
-        if newnode.decorators is not None:
-            for decorator_expr in newnode.decorators.nodes:
-                if isinstance(decorator_expr, new.Name):
-                    if decorator_expr.name in ('classmethod', 'staticmethod'):
-                        newnode._type = decorator_expr.name
-                    elif decorator_expr.name == 'classproperty':
-                        newnode._type = 'classmethod'
-        frame.set_local(newnode.name, newnode)
-        return newnode
-
-    def visit_genexpr(self, node, parent):
-        """visit a GenExpr node by returning a fresh instance of it"""
-        newnode = new.GenExpr()
-        _lineno_parent(node, newnode, parent)
-        newnode.elt = self.visit(node.elt, newnode)
-        newnode.generators = [self.visit(child, newnode) for child in node.generators]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_getattr(self, node, parent):
-        """visit a Getattr node by returning a fresh instance of it"""
-        if self.asscontext == "Del":
-            # FIXME : maybe we should reintroduce and visit_delattr ?
-            # for instance, deactivating asscontext
-            newnode = new.DelAttr()
-        elif self.asscontext == "Ass":
-            # FIXME : maybe we should call visit_assattr ?
-            newnode = new.AssAttr()
-            self._delayed_assattr.append(newnode)
-        else:
-            newnode = new.Getattr()
-        _lineno_parent(node, newnode, parent)
-        asscontext, self.asscontext = self.asscontext, None
-        newnode.expr = self.visit(node.value, newnode)
-        self.asscontext = asscontext
-        newnode.attrname = node.attr
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_global(self, node, parent):
-        """visit an Global node to become astroid"""
-        newnode = new.Global(node.names)
-        _set_infos(node, newnode, parent)
-        if self._global_names: # global at the module level, no effect
-            for name in node.names:
-                self._global_names[-1].setdefault(name, []).append(newnode)
-        return newnode
-
-    def visit_if(self, node, parent):
-        """visit a If node by returning a fresh instance of it"""
-        newnode = new.If()
-        _lineno_parent(node, newnode, parent)
-        newnode.test = self.visit(node.test, newnode)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.orelse = [self.visit(child, newnode) for child in node.orelse]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_ifexp(self, node, parent):
-        """visit a IfExp node by returning a fresh instance of it"""
-        newnode = new.IfExp()
-        _lineno_parent(node, newnode, parent)
-        newnode.test = self.visit(node.test, newnode)
-        newnode.body = self.visit(node.body, newnode)
-        newnode.orelse = self.visit(node.orelse, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_import(self, node, parent):
-        """visit a Import node by returning a fresh instance of it"""
-        newnode = new.Import()
-        _set_infos(node, newnode, parent)
-        newnode.names = [(alias.name, alias.asname) for alias in node.names]
-        # save import names in parent's locals:
-        for (name, asname) in newnode.names:
-            name = asname or name
-            newnode.parent.set_local(name.split('.')[0], newnode)
-        return newnode
-
-    def visit_index(self, node, parent):
-        """visit a Index node by returning a fresh instance of it"""
-        newnode = new.Index()
-        _lineno_parent(node, newnode, parent)
-        newnode.value = self.visit(node.value, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_keyword(self, node, parent):
-        """visit a Keyword node by returning a fresh instance of it"""
-        newnode = new.Keyword()
-        _lineno_parent(node, newnode, parent)
-        newnode.arg = node.arg
-        newnode.value = self.visit(node.value, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_lambda(self, node, parent):
-        """visit a Lambda node by returning a fresh instance of it"""
-        newnode = new.Lambda()
-        _lineno_parent(node, newnode, parent)
-        newnode.args = self.visit(node.args, newnode)
-        newnode.body = self.visit(node.body, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_list(self, node, parent):
-        """visit a List node by returning a fresh instance of it"""
-        newnode = new.List()
-        _lineno_parent(node, newnode, parent)
-        newnode.elts = [self.visit(child, newnode) for child in node.elts]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_listcomp(self, node, parent):
-        """visit a ListComp node by returning a fresh instance of it"""
-        newnode = new.ListComp()
-        _lineno_parent(node, newnode, parent)
-        newnode.elt = self.visit(node.elt, newnode)
-        newnode.generators = [self.visit(child, newnode)
-                              for child in node.generators]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_name(self, node, parent):
-        """visit a Name node by returning a fresh instance of it"""
-        # True and False can be assigned to something in py2x, so we have to
-        # check first the asscontext
-        if self.asscontext == "Del":
-            newnode = new.DelName()
-        elif self.asscontext is not None: # Ass
-            assert self.asscontext == "Ass"
-            newnode = new.AssName()
-        elif node.id in CONST_NAME_TRANSFORMS:
-            newnode = new.Const(CONST_NAME_TRANSFORMS[node.id])
-            _set_infos(node, newnode, parent)
-            return newnode
-        else:
-            newnode = new.Name()
-        _lineno_parent(node, newnode, parent)
-        newnode.name = node.id
-        # XXX REMOVE me :
-        if self.asscontext in ('Del', 'Ass'): # 'Aug' ??
-            self._save_assignment(newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_bytes(self, node, parent):
-        """visit a Bytes node by returning a fresh instance of Const"""
-        newnode = new.Const(node.s)
-        _set_infos(node, newnode, parent)
-        return newnode
-
-    def visit_num(self, node, parent):
-        """visit a Num node by returning a fresh instance of Const"""
-        newnode = new.Const(node.n)
-        _set_infos(node, newnode, parent)
-        return newnode
-
-    def visit_pass(self, node, parent):
-        """visit a Pass node by returning a fresh instance of it"""
-        newnode = new.Pass()
-        _set_infos(node, newnode, parent)
-        return newnode
-
-    def visit_str(self, node, parent):
-        """visit a Str node by returning a fresh instance of Const"""
-        newnode = new.Const(node.s)
-        _set_infos(node, newnode, parent)
-        return newnode
-
-    def visit_print(self, node, parent):
-        """visit a Print node by returning a fresh instance of it"""
-        newnode = new.Print()
-        _lineno_parent(node, newnode, parent)
-        newnode.nl = node.nl
-        if node.dest is not None:
-            newnode.dest = self.visit(node.dest, newnode)
-        newnode.values = [self.visit(child, newnode) for child in node.values]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_raise(self, node, parent):
-        """visit a Raise node by returning a fresh instance of it"""
-        newnode = new.Raise()
-        _lineno_parent(node, newnode, parent)
-        if node.type is not None:
-            newnode.exc = self.visit(node.type, newnode)
-        if node.inst is not None:
-            newnode.inst = self.visit(node.inst, newnode)
-        if node.tback is not None:
-            newnode.tback = self.visit(node.tback, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_return(self, node, parent):
-        """visit a Return node by returning a fresh instance of it"""
-        newnode = new.Return()
-        _lineno_parent(node, newnode, parent)
-        if node.value is not None:
-            newnode.value = self.visit(node.value, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_set(self, node, parent):
-        """visit a Set node by returning a fresh instance of it"""
-        newnode = new.Set()
-        _lineno_parent(node, newnode, parent)
-        newnode.elts = [self.visit(child, newnode) for child in node.elts]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_setcomp(self, node, parent):
-        """visit a SetComp node by returning a fresh instance of it"""
-        newnode = new.SetComp()
-        _lineno_parent(node, newnode, parent)
-        newnode.elt = self.visit(node.elt, newnode)
-        newnode.generators = [self.visit(child, newnode)
-                              for child in node.generators]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_slice(self, node, parent):
-        """visit a Slice node by returning a fresh instance of it"""
-        newnode = new.Slice()
-        _lineno_parent(node, newnode, parent)
-        if node.lower is not None:
-            newnode.lower = self.visit(node.lower, newnode)
-        if node.upper is not None:
-            newnode.upper = self.visit(node.upper, newnode)
-        if node.step is not None:
-            newnode.step = self.visit(node.step, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_subscript(self, node, parent):
-        """visit a Subscript node by returning a fresh instance of it"""
-        newnode = new.Subscript()
-        _lineno_parent(node, newnode, parent)
-        subcontext, self.asscontext = self.asscontext, None
-        newnode.value = self.visit(node.value, newnode)
-        newnode.slice = self.visit(node.slice, newnode)
-        self.asscontext = subcontext
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_tryexcept(self, node, parent):
-        """visit a TryExcept node by returning a fresh instance of it"""
-        newnode = new.TryExcept()
-        _lineno_parent(node, newnode, parent)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.handlers = [self.visit(child, newnode) for child in node.handlers]
-        newnode.orelse = [self.visit(child, newnode) for child in node.orelse]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_tryfinally(self, node, parent):
-        """visit a TryFinally node by returning a fresh instance of it"""
-        newnode = new.TryFinally()
-        _lineno_parent(node, newnode, parent)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.finalbody = [self.visit(n, newnode) for n in node.finalbody]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_tuple(self, node, parent):
-        """visit a Tuple node by returning a fresh instance of it"""
-        newnode = new.Tuple()
-        _lineno_parent(node, newnode, parent)
-        newnode.elts = [self.visit(child, newnode) for child in node.elts]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_unaryop(self, node, parent):
-        """visit a UnaryOp node by returning a fresh instance of it"""
-        newnode = new.UnaryOp()
-        _lineno_parent(node, newnode, parent)
-        newnode.operand = self.visit(node.operand, newnode)
-        newnode.op = _UNARY_OP_CLASSES[node.op.__class__]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_while(self, node, parent):
-        """visit a While node by returning a fresh instance of it"""
-        newnode = new.While()
-        _lineno_parent(node, newnode, parent)
-        newnode.test = self.visit(node.test, newnode)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.orelse = [self.visit(child, newnode) for child in node.orelse]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_with(self, node, parent):
-        newnode = new.With()
-        _lineno_parent(node, newnode, parent)
-        expr = self.visit(node.context_expr, newnode)
-        self.asscontext = "Ass"
-        if node.optional_vars is not None:
-            vars = self.visit(node.optional_vars, newnode)
-        else:
-            vars = None
-        self.asscontext = None
-        newnode.items = [(expr, vars)]
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_yield(self, node, parent):
-        """visit a Yield node by returning a fresh instance of it"""
-        return _create_yield_node(node, parent, self, new.Yield)
-
-class TreeRebuilder3k(TreeRebuilder):
-    """extend and overwrite TreeRebuilder for python3k"""
-
-    def visit_arg(self, node, parent):
-        """visit a arg node by returning a fresh AssName instance"""
-        # the <arg> node is coming from py>=3.0, but we use AssName in py2.x
-        # XXX or we should instead introduce a Arg node in astroid ?
-        return self.visit_assname(node, parent, node.arg)
-
-    def visit_nameconstant(self, node, parent):
-        # in Python 3.4 we have NameConstant for True / False / None
-        newnode = new.Const(node.value)
-        _set_infos(node, newnode, parent)
-        return newnode
-
-    def visit_arguments(self, node, parent):
-        newnode = super(TreeRebuilder3k, self).visit_arguments(node, parent)
-        self.asscontext = "Ass"
-        newnode.kwonlyargs = [self.visit(child, newnode) for child in node.kwonlyargs]
-        self.asscontext = None
-        newnode.kw_defaults = [self.visit(child, newnode) if child else None for child in node.kw_defaults]
-        return newnode
-
-    def visit_excepthandler(self, node, parent):
-        """visit an ExceptHandler node by returning a fresh instance of it"""
-        newnode = new.ExceptHandler()
-        _lineno_parent(node, newnode, parent)
-        if node.type is not None:
-            newnode.type = self.visit(node.type, newnode)
-        if node.name is not None:
-            newnode.name = self.visit_assname(node, newnode, node.name)
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_nonlocal(self, node, parent):
-        """visit a Nonlocal node and return a new instance of it"""
-        newnode = new.Nonlocal(node.names)
-        _set_infos(node, newnode, parent)
-        return newnode
-
-    def visit_raise(self, node, parent):
-        """visit a Raise node by returning a fresh instance of it"""
-        newnode = new.Raise()
-        _lineno_parent(node, newnode, parent)
-        # no traceback; anyway it is not used in Pylint
-        if node.exc is not None:
-            newnode.exc = self.visit(node.exc, newnode)
-        if node.cause is not None:
-            newnode.cause = self.visit(node.cause, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_starred(self, node, parent):
-        """visit a Starred node and return a new instance of it"""
-        newnode = new.Starred()
-        _lineno_parent(node, newnode, parent)
-        newnode.value = self.visit(node.value, newnode)
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_try(self, node, parent):
-        # python 3.3 introduce a new Try node replacing TryFinally/TryExcept nodes
-        if node.finalbody:
-            newnode = new.TryFinally()
-            _lineno_parent(node, newnode, parent)
-            newnode.finalbody = [self.visit(n, newnode) for n in node.finalbody]
-            if node.handlers:
-                excnode = new.TryExcept()
-                _lineno_parent(node, excnode, newnode)
-                excnode.body = [self.visit(child, excnode) for child in node.body]
-                excnode.handlers = [self.visit(child, excnode) for child in node.handlers]
-                excnode.orelse = [self.visit(child, excnode) for child in node.orelse]
-                excnode.set_line_info(excnode.last_child())
-                newnode.body = [excnode]
-            else:
-                newnode.body = [self.visit(child, newnode) for child in node.body]
-        elif node.handlers:
-            newnode = new.TryExcept()
-            _lineno_parent(node, newnode, parent)
-            newnode.body = [self.visit(child, newnode) for child in node.body]
-            newnode.handlers = [self.visit(child, newnode) for child in node.handlers]
-            newnode.orelse = [self.visit(child, newnode) for child in node.orelse]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_with(self, node, parent):
-        if 'items' not in node._fields:
-            # python < 3.3
-            return super(TreeRebuilder3k, self).visit_with(node, parent)
-
-        newnode = new.With()
-        _lineno_parent(node, newnode, parent)
-        def visit_child(child):
-            expr = self.visit(child.context_expr, newnode)
-            self.asscontext = 'Ass'
-            if child.optional_vars:
-                var = self.visit(child.optional_vars, newnode)
-            else:
-                var = None
-            self.asscontext = None
-            return expr, var
-        newnode.items = [visit_child(child)
-                         for child in node.items]
-        newnode.body = [self.visit(child, newnode) for child in node.body]
-        newnode.set_line_info(newnode.last_child())
-        return newnode
-
-    def visit_yieldfrom(self, node, parent):
-        return _create_yield_node(node, parent, self, new.YieldFrom)
-
-    def visit_class(self, node, parent):
-        newnode = super(TreeRebuilder3k, self).visit_class(node, parent)
-        for keyword in node.keywords:
-            if keyword.arg == 'metaclass':
-                newnode._metaclass = self.visit(keyword, newnode).value
-                break
-        return newnode
-
-if sys.version_info >= (3, 0):
-    TreeRebuilder = TreeRebuilder3k
-
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/scoped_nodes.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/scoped_nodes.py
deleted file mode 100644
index 889baa0e..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/scoped_nodes.py
+++ /dev/null
@@ -1,1118 +0,0 @@
-# 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 the classes for "scoped" node, i.e. which are opening a
-new local scope in the language definition : Module, Class, Function (and
-Lambda, GenExpr, DictComp and SetComp to some extent).
-"""
-from __future__ import with_statement
-
-__doctype__ = "restructuredtext en"
-
-import sys
-from itertools import chain
-try:
-    from io import BytesIO
-except ImportError:
-    from cStringIO import StringIO as BytesIO
-
-from logilab.common.compat import builtins
-from logilab.common.decorators import cached, cachedproperty
-
-from astroid.exceptions import NotFoundError, \
-     AstroidBuildingException, InferenceError
-from astroid.node_classes import Const, DelName, DelAttr, \
-     Dict, From, List, Pass, Raise, Return, Tuple, Yield, YieldFrom, \
-     LookupMixIn, const_factory as cf, unpack_infer, Name
-from astroid.bases import NodeNG, InferenceContext, Instance,\
-     YES, Generator, UnboundMethod, BoundMethod, _infer_stmts, copy_context, \
-     BUILTINS
-from astroid.mixins import FilterStmtsMixin
-from astroid.bases import Statement
-from astroid.manager import AstroidManager
-
-
-def remove_nodes(func, cls):
-    def wrapper(*args, **kwargs):
-        nodes = [n for n in func(*args, **kwargs) if not isinstance(n, cls)]
-        if not nodes:
-            raise NotFoundError()
-        return nodes
-    return wrapper
-
-
-def function_to_method(n, klass):
-    if isinstance(n, Function):
-        if n.type == 'classmethod':
-            return BoundMethod(n, klass)
-        if n.type != 'staticmethod':
-            return UnboundMethod(n)
-    return n
-
-def std_special_attributes(self, name, add_locals=True):
-    if add_locals:
-        locals = self.locals
-    else:
-        locals = {}
-    if name == '__name__':
-        return [cf(self.name)] + locals.get(name, [])
-    if name == '__doc__':
-        return [cf(self.doc)] + locals.get(name, [])
-    if name == '__dict__':
-        return [Dict()] + locals.get(name, [])
-    raise NotFoundError(name)
-
-MANAGER = AstroidManager()
-def builtin_lookup(name):
-    """lookup a name into the builtin module
-    return the list of matching statements and the astroid for the builtin
-    module
-    """
-    builtin_astroid = MANAGER.ast_from_module(builtins)
-    if name == '__dict__':
-        return builtin_astroid, ()
-    try:
-        stmts = builtin_astroid.locals[name]
-    except KeyError:
-        stmts = ()
-    return builtin_astroid, stmts
-
-
-# TODO move this Mixin to mixins.py; problem: 'Function' in _scope_lookup
-class LocalsDictNodeNG(LookupMixIn, NodeNG):
-    """ this class provides locals handling common to Module, Function
-    and Class nodes, including a dict like interface for direct access
-    to locals information
-    """
-
-    # attributes below are set by the builder module or by raw factories
-
-    # dictionary of locals with name as key and node defining the local as
-    # value
-
-    def qname(self):
-        """return the 'qualified' name of the node, eg module.name,
-        module.class.name ...
-        """
-        if self.parent is None:
-            return self.name
-        return '%s.%s' % (self.parent.frame().qname(), self.name)
-
-    def frame(self):
-        """return the first parent frame node (i.e. Module, Function or Class)
-        """
-        return self
-
-    def scope(self):
-        """return the first node defining a new scope (i.e. Module,
-        Function, Class, Lambda but also GenExpr, DictComp and SetComp)
-        """
-        return self
-
-
-    def _scope_lookup(self, node, name, offset=0):
-        """XXX method for interfacing the scope lookup"""
-        try:
-            stmts = node._filter_stmts(self.locals[name], self, offset)
-        except KeyError:
-            stmts = ()
-        if stmts:
-            return self, stmts
-        if self.parent: # i.e. not Module
-            # nested scope: if parent scope is a function, that's fine
-            # else jump to the module
-            pscope = self.parent.scope()
-            if not pscope.is_function:
-                pscope = pscope.root()
-            return pscope.scope_lookup(node, name)
-        return builtin_lookup(name) # Module
-
-
-
-    def set_local(self, name, stmt):
-        """define <name> in locals (<stmt> is the node defining the name)
-        if the node is a Module node (i.e. has globals), add the name to
-        globals
-
-        if the name is already defined, ignore it
-        """
-        #assert not stmt in self.locals.get(name, ()), (self, stmt)
-        self.locals.setdefault(name, []).append(stmt)
-
-    __setitem__ = set_local
-
-    def _append_node(self, child):
-        """append a child, linking it in the tree"""
-        self.body.append(child)
-        child.parent = self
-
-    def add_local_node(self, child_node, name=None):
-        """append a child which should alter locals to the given node"""
-        if name != '__class__':
-            # add __class__ node as a child will cause infinite recursion later!
-            self._append_node(child_node)
-        self.set_local(name or child_node.name, child_node)
-
-
-    def __getitem__(self, item):
-        """method from the `dict` interface returning the first node
-        associated with the given name in the locals dictionary
-
-        :type item: str
-        :param item: the name of the locally defined object
-        :raises KeyError: if the name is not defined
-        """
-        return self.locals[item][0]
-
-    def __iter__(self):
-        """method from the `dict` interface returning an iterator on
-        `self.keys()`
-        """
-        return iter(self.keys())
-
-    def keys(self):
-        """method from the `dict` interface returning a tuple containing
-        locally defined names
-        """
-        return self.locals.keys()
-
-    def values(self):
-        """method from the `dict` interface returning a tuple containing
-        locally defined nodes which are instance of `Function` or `Class`
-        """
-        return [self[key] for key in self.keys()]
-
-    def items(self):
-        """method from the `dict` interface returning a list of tuple
-        containing each locally defined name with its associated node,
-        which is an instance of `Function` or `Class`
-        """
-        return zip(self.keys(), self.values())
-
-
-    def __contains__(self, name):
-        return name in self.locals
-    has_key = __contains__
-
-# Module  #####################################################################
-
-class Module(LocalsDictNodeNG):
-    _astroid_fields = ('body',)
-
-    fromlineno = 0
-    lineno = 0
-
-    # attributes below are set by the builder module or by raw factories
-
-    # the file from which as been extracted the astroid representation. It may
-    # be None if the representation has been built from a built-in module
-    file = None
-    # Alternatively, if built from a string/bytes, this can be set
-    file_bytes = None
-    # encoding of python source file, so we can get unicode out of it (python2
-    # only)
-    file_encoding = None
-    # the module name
-    name = None
-    # boolean for astroid built from source (i.e. ast)
-    pure_python = None
-    # boolean for package module
-    package = None
-    # dictionary of globals with name as key and node defining the global
-    # as value
-    globals = None
-
-    # Future imports
-    future_imports = None
-
-    # names of python special attributes (handled by getattr impl.)
-    special_attributes = set(('__name__', '__doc__', '__file__', '__path__',
-                              '__dict__'))
-    # names of module attributes available through the global scope
-    scope_attrs = set(('__name__', '__doc__', '__file__', '__path__'))
-
-    def __init__(self, name, doc, pure_python=True):
-        self.name = name
-        self.doc = doc
-        self.pure_python = pure_python
-        self.locals = self.globals = {}
-        self.body = []
-        self.future_imports = set()
-
-    @property
-    def file_stream(self):
-        if self.file_bytes is not None:
-            return BytesIO(self.file_bytes)
-        if self.file is not None:
-            return open(self.file, 'rb')
-        return None
-
-    def block_range(self, lineno):
-        """return block line numbers.
-
-        start from the beginning whatever the given lineno
-        """
-        return self.fromlineno, self.tolineno
-
-    def scope_lookup(self, node, name, offset=0):
-        if name in self.scope_attrs and not name in self.locals:
-            try:
-                return self, self.getattr(name)
-            except NotFoundError:
-                return self, ()
-        return self._scope_lookup(node, name, offset)
-
-    def pytype(self):
-        return '%s.module' % BUILTINS
-
-    def display_type(self):
-        return 'Module'
-
-    def getattr(self, name, context=None, ignore_locals=False):
-        if name in self.special_attributes:
-            if name == '__file__':
-                return [cf(self.file)] + self.locals.get(name, [])
-            if name == '__path__' and self.package:
-                return [List()] + self.locals.get(name, [])
-            return std_special_attributes(self, name)
-        if not ignore_locals and name in self.locals:
-            return self.locals[name]
-        if self.package:
-            try:
-                return [self.import_module(name, relative_only=True)]
-            except AstroidBuildingException:
-                raise NotFoundError(name)
-            except SyntaxError:
-                raise NotFoundError(name)
-            except Exception:# XXX pylint tests never pass here; do we need it?
-                import traceback
-                traceback.print_exc()
-        raise NotFoundError(name)
-    getattr = remove_nodes(getattr, DelName)
-
-    def igetattr(self, name, context=None):
-        """inferred getattr"""
-        # set lookup name since this is necessary to infer on import nodes for
-        # instance
-        context = copy_context(context)
-        context.lookupname = name
-        try:
-            return _infer_stmts(self.getattr(name, context), context, frame=self)
-        except NotFoundError:
-            raise InferenceError(name)
-
-    def fully_defined(self):
-        """return True if this module has been built from a .py file
-        and so contains a complete representation including the code
-        """
-        return self.file is not None and self.file.endswith('.py')
-
-    def statement(self):
-        """return the first parent node marked as statement node
-        consider a module as a statement...
-        """
-        return self
-
-    def previous_sibling(self):
-        """module has no sibling"""
-        return
-
-    def next_sibling(self):
-        """module has no sibling"""
-        return
-
-    if sys.version_info < (2, 8):
-        def absolute_import_activated(self):
-            for stmt in self.locals.get('absolute_import', ()):
-                if isinstance(stmt, From) and stmt.modname == '__future__':
-                    return True
-            return False
-    else:
-        absolute_import_activated = lambda self: True
-
-    def import_module(self, modname, relative_only=False, level=None):
-        """import the given module considering self as context"""
-        if relative_only and level is None:
-            level = 0
-        absmodname = self.relative_to_absolute_name(modname, level)
-        try:
-            return MANAGER.ast_from_module_name(absmodname)
-        except AstroidBuildingException:
-            # we only want to import a sub module or package of this module,
-            # skip here
-            if relative_only:
-                raise
-        return MANAGER.ast_from_module_name(modname)
-
-    def relative_to_absolute_name(self, modname, level):
-        """return the absolute module name for a relative import.
-
-        The relative import can be implicit or explicit.
-        """
-        # XXX this returns non sens when called on an absolute import
-        # like 'pylint.checkers.astroid.utils'
-        # XXX doesn't return absolute name if self.name isn't absolute name
-        if self.absolute_import_activated() and level is None:
-            return modname
-        if level:
-            if self.package:
-                level = level - 1
-            package_name = self.name.rsplit('.', level)[0]
-        elif self.package:
-            package_name = self.name
-        else:
-            package_name = self.name.rsplit('.', 1)[0]
-        if package_name:
-            if not modname:
-                return package_name
-            return '%s.%s' % (package_name, modname)
-        return modname
-
-
-    def wildcard_import_names(self):
-        """return the list of imported names when this module is 'wildcard
-        imported'
-
-        It doesn't include the '__builtins__' name which is added by the
-        current CPython implementation of wildcard imports.
-        """
-        # take advantage of a living module if it exists
-        try:
-            living = sys.modules[self.name]
-        except KeyError:
-            pass
-        else:
-            try:
-                return living.__all__
-            except AttributeError:
-                return [name for name in living.__dict__.keys()
-                        if not name.startswith('_')]
-        # else lookup the astroid
-        #
-        # We separate the different steps of lookup in try/excepts
-        # to avoid catching too many Exceptions
-        # However, we can not analyse dynamically constructed __all__
-        try:
-            all = self['__all__']
-        except KeyError:
-            return [name for name in self.keys() if not name.startswith('_')]
-        try:
-            explicit = all.assigned_stmts().next()
-        except InferenceError:
-            return [name for name in self.keys() if not name.startswith('_')]
-        except AttributeError:
-            # not an assignment node
-            # XXX infer?
-            return [name for name in self.keys() if not name.startswith('_')]
-        try:
-            # should be a Tuple/List of constant string / 1 string not allowed
-            return [const.value for const in explicit.elts]
-        except AttributeError:
-            return [name for name in self.keys() if not name.startswith('_')]
-
-
-class ComprehensionScope(LocalsDictNodeNG):
-    def frame(self):
-        return self.parent.frame()
-
-    scope_lookup = LocalsDictNodeNG._scope_lookup
-
-
-class GenExpr(ComprehensionScope):
-    _astroid_fields = ('elt', 'generators')
-
-    def __init__(self):
-        self.locals = {}
-        self.elt = None
-        self.generators = []
-
-
-class DictComp(ComprehensionScope):
-    _astroid_fields = ('key', 'value', 'generators')
-
-    def __init__(self):
-        self.locals = {}
-        self.key = None
-        self.value = None
-        self.generators = []
-
-
-class SetComp(ComprehensionScope):
-    _astroid_fields = ('elt', 'generators')
-
-    def __init__(self):
-        self.locals = {}
-        self.elt = None
-        self.generators = []
-
-
-class _ListComp(NodeNG):
-    """class representing a ListComp node"""
-    _astroid_fields = ('elt', 'generators')
-    elt = None
-    generators = None
-
-if sys.version_info >= (3, 0):
-    class ListComp(_ListComp, ComprehensionScope):
-        """class representing a ListComp node"""
-        def __init__(self):
-            self.locals = {}
-else:
-    class ListComp(_ListComp):
-        """class representing a ListComp node"""
-
-# Function  ###################################################################
-    
-def _function_type(self):
-    """
-    Function type, possible values are:
-    method, function, staticmethod, classmethod.
-    """
-    # Can't infer that this node is decorated
-    # with a subclass of `classmethod` where `type` is first set,
-    # so do it here.
-    if self.decorators:
-        for node in self.decorators.nodes:
-            if not isinstance(node, Name):
-                continue
-            try:
-                for infered in node.infer():
-                    if not isinstance(infered, Class):
-                        continue
-                    for ancestor in infered.ancestors():
-                        if isinstance(ancestor, Class):
-                            if (ancestor.name == 'classmethod' and
-                                ancestor.root().name == BUILTINS):
-                                return 'classmethod'
-                            elif (ancestor.name == 'staticmethod' and
-                                  ancestor.root().name == BUILTINS):
-                                return 'staticmethod'
-            except InferenceError:
-                pass
-    return self._type
-
-
-class Lambda(LocalsDictNodeNG, FilterStmtsMixin):
-    _astroid_fields = ('args', 'body',)
-    name = '<lambda>'
-
-    # function's type, 'function' | 'method' | 'staticmethod' | 'classmethod'
-    type = 'function'
-
-    def __init__(self):
-        self.locals = {}
-        self.args = []
-        self.body = []
-
-    def pytype(self):
-        if 'method' in self.type:
-            return '%s.instancemethod' % BUILTINS
-        return '%s.function' % BUILTINS
-
-    def display_type(self):
-        if 'method' in self.type:
-            return 'Method'
-        return 'Function'
-
-    def callable(self):
-        return True
-
-    def argnames(self):
-        """return a list of argument names"""
-        if self.args.args: # maybe None with builtin functions
-            names = _rec_get_names(self.args.args)
-        else:
-            names = []
-        if self.args.vararg:
-            names.append(self.args.vararg)
-        if self.args.kwarg:
-            names.append(self.args.kwarg)
-        return names
-
-    def infer_call_result(self, caller, context=None):
-        """infer what a function is returning when called"""
-        return self.body.infer(context)
-
-    def scope_lookup(self, node, name, offset=0):
-        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
-            # value to the defined function
-            offset = -1
-        else:
-            # check this is not used in function decorators
-            frame = self
-        return frame._scope_lookup(node, name, offset)
-
-
-class Function(Statement, Lambda):
-    _astroid_fields = ('decorators', 'args', 'body')
-
-    special_attributes = set(('__name__', '__doc__', '__dict__'))
-    is_function = True
-    # attributes below are set by the builder module or by raw factories
-    blockstart_tolineno = None
-    decorators = None
-    _type = "function"
-    type = cachedproperty(_function_type)
-
-    def __init__(self, name, doc):
-        self.locals = {}
-        self.args = []
-        self.body = []
-        self.decorators = None
-        self.name = name
-        self.doc = doc
-        self.extra_decorators = []
-        self.instance_attrs = {}
-
-    def set_line_info(self, lastchild):
-        self.fromlineno = self.lineno
-        # lineno is the line number of the first decorator, we want the def statement lineno
-        if self.decorators is not None:
-            self.fromlineno += sum(node.tolineno - node.lineno + 1
-                                   for node in self.decorators.nodes)
-        if self.args.fromlineno < self.fromlineno:
-            self.args.fromlineno = self.fromlineno
-        self.tolineno = lastchild.tolineno
-        self.blockstart_tolineno = self.args.tolineno
-
-    def block_range(self, lineno):
-        """return block line numbers.
-
-        start from the "def" position whatever the given lineno
-        """
-        return self.fromlineno, self.tolineno
-
-    def getattr(self, name, context=None):
-        """this method doesn't look in the instance_attrs dictionary since it's
-        done by an Instance proxy at inference time.
-        """
-        if name == '__module__':
-            return [cf(self.root().qname())]
-        if name in self.instance_attrs:
-            return self.instance_attrs[name]
-        return std_special_attributes(self, name, False)
-
-    def is_method(self):
-        """return true if the function node should be considered as a method"""
-        # check we are defined in a Class, because this is usually expected
-        # (e.g. pylint...) when is_method() return True
-        return self.type != 'function' and isinstance(self.parent.frame(), Class)
-
-    def decoratornames(self):
-        """return a list of decorator qualified names"""
-        result = set()
-        decoratornodes = []
-        if self.decorators is not None:
-            decoratornodes += self.decorators.nodes
-        decoratornodes += self.extra_decorators
-        for decnode in decoratornodes:
-            for infnode in decnode.infer():
-                result.add(infnode.qname())
-        return result
-    decoratornames = cached(decoratornames)
-
-    def is_bound(self):
-        """return true if the function is bound to an Instance or a class"""
-        return self.type == 'classmethod'
-
-    def is_abstract(self, pass_is_abstract=True):
-        """Returns True if the method is abstract.
-        
-        A method is considered abstract if
-         - the only statement is 'raise NotImplementedError', or
-         - the only statement is 'pass' and pass_is_abstract is True, or
-         - the method is annotated with abc.astractproperty/abc.abstractmethod
-        """
-        if self.decorators:
-            for node in self.decorators.nodes:
-                try:
-                    infered = node.infer().next()
-                except InferenceError:
-                    continue
-                if infered and infered.qname() in ('abc.abstractproperty',
-                                                   'abc.abstractmethod'):
-                    return True
-
-        for child_node in self.body:
-            if isinstance(child_node, Raise):
-                if child_node.raises_not_implemented():
-                    return True
-            if pass_is_abstract and isinstance(child_node, Pass):
-                return True
-            return False
-        # empty function is the same as function with a single "pass" statement
-        if pass_is_abstract:
-            return True
-
-    def is_generator(self):
-        """return true if this is a generator function"""
-        # XXX should be flagged, not computed
-        try:
-            return self.nodes_of_class((Yield, YieldFrom),
-                                       skip_klass=(Function, Lambda)).next()
-        except StopIteration:
-            return False
-
-    def infer_call_result(self, caller, context=None):
-        """infer what a function is returning when called"""
-        if self.is_generator():
-            yield Generator()
-            return
-        returns = self.nodes_of_class(Return, skip_klass=Function)
-        for returnnode in returns:
-            if returnnode.value is None:
-                yield Const(None)
-            else:
-                try:
-                    for infered in returnnode.value.infer(context):
-                        yield infered
-                except InferenceError:
-                    yield YES
-
-
-def _rec_get_names(args, names=None):
-    """return a list of all argument names"""
-    if names is None:
-        names = []
-    for arg in args:
-        if isinstance(arg, Tuple):
-            _rec_get_names(arg.elts, names)
-        else:
-            names.append(arg.name)
-    return names
-
-
-# Class ######################################################################
-
-
-def _is_metaclass(klass):
-    """ Return if the given class can be
-    used as a metaclass.
-    """
-    if klass.name == 'type':
-        return True
-    for base in klass.bases:
-        try:
-            for baseobj in base.infer():
-                if isinstance(baseobj, Instance):
-                    # not abstract
-                    return False
-                if baseobj is YES:
-                    continue
-                if baseobj is klass:
-                    continue
-                if not isinstance(baseobj, Class):
-                    continue
-                if baseobj._type == 'metaclass':
-                    return True
-                if _is_metaclass(baseobj):
-                    return True
-        except InferenceError:
-            continue
-    return False
-
-
-def _class_type(klass, ancestors=None):
-    """return a Class node type to differ metaclass, interface and exception
-    from 'regular' classes
-    """
-    # XXX we have to store ancestors in case we have a ancestor loop
-    if klass._type is not None:
-        return klass._type
-    if _is_metaclass(klass):
-        klass._type = 'metaclass'
-    elif klass.name.endswith('Interface'):
-        klass._type = 'interface'
-    elif klass.name.endswith('Exception'):
-        klass._type = 'exception'
-    else:
-        if ancestors is None:
-            ancestors = set()
-        if klass in ancestors:
-            # XXX we are in loop ancestors, and have found no type
-            klass._type = 'class'
-            return 'class'
-        ancestors.add(klass)
-        # print >> sys.stderr, '_class_type', repr(klass)
-        for base in klass.ancestors(recurs=False):
-            name = _class_type(base, ancestors)
-            if name != 'class':
-                 if name == 'metaclass' and not _is_metaclass(klass):
-                     # don't propagate it if the current class
-                     # can't be a metaclass
-                     continue
-                 klass._type = base.type
-                 break
-    if klass._type is None:
-        klass._type = 'class'
-    return klass._type
-
-def _iface_hdlr(iface_node):
-    """a handler function used by interfaces to handle suspicious
-    interface nodes
-    """
-    return True
-
-
-class Class(Statement, LocalsDictNodeNG, FilterStmtsMixin):
-
-    # some of the attributes below are set by the builder module or
-    # by a raw factories
-
-    # a dictionary of class instances attributes
-    _astroid_fields = ('decorators', 'bases', 'body') # name
-
-    decorators = None
-    special_attributes = set(('__name__', '__doc__', '__dict__', '__module__',
-                              '__bases__', '__mro__', '__subclasses__'))
-    blockstart_tolineno = None
-
-    _type = None
-    type = property(_class_type,
-                    doc="class'type, possible values are 'class' | "
-                    "'metaclass' | 'interface' | 'exception'")
-
-    def __init__(self, name, doc):
-        self.instance_attrs = {}
-        self.locals = {}
-        self.bases = []
-        self.body = []
-        self.name = name
-        self.doc = doc
-
-    def _newstyle_impl(self, context=None):
-        if context is None:
-            context = InferenceContext()
-        if self._newstyle is not None:
-            return self._newstyle
-        for base in self.ancestors(recurs=False, context=context):
-            if base._newstyle_impl(context):
-                self._newstyle = True
-                break
-        if self._newstyle is None:
-            self._newstyle = False
-        return self._newstyle
-
-    _newstyle = None
-    newstyle = property(_newstyle_impl,
-                        doc="boolean indicating if it's a new style class"
-                        "or not")
-
-    def set_line_info(self, lastchild):
-        self.fromlineno = self.lineno
-        self.blockstart_tolineno = self.bases and self.bases[-1].tolineno or self.fromlineno
-        if lastchild is not None:
-            self.tolineno = lastchild.tolineno
-        # else this is a class with only a docstring, then tolineno is (should be) already ok
-
-    def block_range(self, lineno):
-        """return block line numbers.
-
-        start from the "class" position whatever the given lineno
-        """
-        return self.fromlineno, self.tolineno
-
-    def pytype(self):
-        if self.newstyle:
-            return '%s.type' % BUILTINS
-        return '%s.classobj' % BUILTINS
-
-    def display_type(self):
-        return 'Class'
-
-    def callable(self):
-        return True
-
-    def infer_call_result(self, caller, context=None):
-        """infer what a class is returning when called"""
-        yield Instance(self)
-
-    def scope_lookup(self, node, name, offset=0):
-        if node in self.bases:
-            frame = self.parent.frame()
-            # line offset to avoid that class A(A) resolve the ancestor to
-            # the defined class
-            offset = -1
-        else:
-            frame = self
-        return frame._scope_lookup(node, name, offset)
-
-    # list of parent class as a list of string (i.e. names as they appear
-    # in the class definition) XXX bw compat
-    def basenames(self):
-        return [bnode.as_string() for bnode in self.bases]
-    basenames = property(basenames)
-
-    def ancestors(self, recurs=True, context=None):
-        """return an iterator on the node base classes in a prefixed
-        depth first order
-
-        :param recurs:
-          boolean indicating if it should recurse or return direct
-          ancestors only
-        """
-        # FIXME: should be possible to choose the resolution order
-        # XXX inference make infinite loops possible here (see BaseTransformer
-        # manipulation in the builder module for instance)
-        yielded = set([self])
-        if context is None:
-            context = InferenceContext()
-        for stmt in self.bases:
-            with context.restore_path():
-                try:
-                    for baseobj in stmt.infer(context):
-                        if not isinstance(baseobj, Class):
-                            if isinstance(baseobj, Instance):
-                                baseobj = baseobj._proxied
-                            else:
-                                # duh ?
-                                continue
-                        if baseobj in yielded:
-                            continue # cf xxx above
-                        yielded.add(baseobj)
-                        yield baseobj
-                        if recurs:
-                            for grandpa in baseobj.ancestors(True, context):
-                                if grandpa in yielded:
-                                    continue # cf xxx above
-                                yielded.add(grandpa)
-                                yield grandpa
-                except InferenceError:
-                    # XXX log error ?
-                    continue
-
-    def local_attr_ancestors(self, name, context=None):
-        """return an iterator on astroid representation of parent classes
-        which have <name> defined in their locals
-        """
-        for astroid in self.ancestors(context=context):
-            if name in astroid:
-                yield astroid
-
-    def instance_attr_ancestors(self, name, context=None):
-        """return an iterator on astroid representation of parent classes
-        which have <name> defined in their instance attribute dictionary
-        """
-        for astroid in self.ancestors(context=context):
-            if name in astroid.instance_attrs:
-                yield astroid
-
-    def has_base(self, node):
-        return node in self.bases
-
-    def local_attr(self, name, context=None):
-        """return the list of assign node associated to name in this class
-        locals or in its parents
-
-        :raises `NotFoundError`:
-          if no attribute with this name has been find in this class or
-          its parent classes
-        """
-        try:
-            return self.locals[name]
-        except KeyError:
-            # get if from the first parent implementing it if any
-            for class_node in self.local_attr_ancestors(name, context):
-                return class_node.locals[name]
-        raise NotFoundError(name)
-    local_attr = remove_nodes(local_attr, DelAttr)
-
-    def instance_attr(self, name, context=None):
-        """return the astroid nodes associated to name in this class instance
-        attributes dictionary and in its parents
-
-        :raises `NotFoundError`:
-          if no attribute with this name has been find in this class or
-          its parent classes
-        """
-        values = self.instance_attrs.get(name, [])
-        # get all values from parents
-        for class_node in self.instance_attr_ancestors(name, context):
-            values += class_node.instance_attrs[name]
-        if not values:
-            raise NotFoundError(name)
-        return values
-    instance_attr = remove_nodes(instance_attr, DelAttr)
-
-    def instanciate_class(self):
-        """return Instance of Class node, else return self"""
-        return Instance(self)
-
-    def getattr(self, name, context=None):
-        """this method doesn't look in the instance_attrs dictionary since it's
-        done by an Instance proxy at inference time.
-
-        It may return a YES object if the attribute has not been actually
-        found but a __getattr__ or __getattribute__ method is defined
-        """
-        values = self.locals.get(name, [])
-        if name in self.special_attributes:
-            if name == '__module__':
-                return [cf(self.root().qname())] + values
-            # FIXME: do we really need the actual list of ancestors?
-            # returning [Tuple()] + values don't break any test
-            # this is ticket http://www.logilab.org/ticket/52785
-            # XXX need proper meta class handling + MRO implementation
-            if name == '__bases__' or (name == '__mro__' and self.newstyle):
-                node = Tuple()
-                node.items = self.ancestors(recurs=True, context=context)
-                return [node] + values
-            return std_special_attributes(self, name)
-        # don't modify the list in self.locals!
-        values = list(values)
-        for classnode in self.ancestors(recurs=True, context=context):
-            values += classnode.locals.get(name, [])
-        if not values:
-            raise NotFoundError(name)
-        return values
-
-    def igetattr(self, name, context=None):
-        """inferred getattr, need special treatment in class to handle
-        descriptors
-        """
-        # set lookup name since this is necessary to infer on import nodes for
-        # instance
-        context = copy_context(context)
-        context.lookupname = name
-        try:
-            for infered in _infer_stmts(self.getattr(name, context), context,
-                                        frame=self):
-                # yield YES object instead of descriptors when necessary
-                if not isinstance(infered, Const) and isinstance(infered, Instance):
-                    try:
-                        infered._proxied.getattr('__get__', context)
-                    except NotFoundError:
-                        yield infered
-                    else:
-                        yield YES
-                else:
-                    yield function_to_method(infered, self)
-        except NotFoundError:
-            if not name.startswith('__') and self.has_dynamic_getattr(context):
-                # class handle some dynamic attributes, return a YES object
-                yield YES
-            else:
-                raise InferenceError(name)
-
-    def has_dynamic_getattr(self, context=None):
-        """return True if the class has a custom __getattr__ or
-        __getattribute__ method
-        """
-        # need to explicitly handle optparse.Values (setattr is not detected)
-        if self.name == 'Values' and self.root().name == 'optparse':
-            return True
-        try:
-            self.getattr('__getattr__', context)
-            return True
-        except NotFoundError:
-            #if self.newstyle: XXX cause an infinite recursion error
-            try:
-                getattribute = self.getattr('__getattribute__', context)[0]
-                if getattribute.root().name != BUILTINS:
-                    # class has a custom __getattribute__ defined
-                    return True
-            except NotFoundError:
-                pass
-        return False
-
-    def methods(self):
-        """return an iterator on all methods defined in the class and
-        its ancestors
-        """
-        done = {}
-        for astroid in chain(iter((self,)), self.ancestors()):
-            for meth in astroid.mymethods():
-                if meth.name in done:
-                    continue
-                done[meth.name] = None
-                yield meth
-
-    def mymethods(self):
-        """return an iterator on all methods defined in the class"""
-        for member in self.values():
-            if isinstance(member, Function):
-                yield member
-
-    def interfaces(self, herited=True, handler_func=_iface_hdlr):
-        """return an iterator on interfaces implemented by the given
-        class node
-        """
-        # FIXME: what if __implements__ = (MyIFace, MyParent.__implements__)...
-        try:
-            implements = Instance(self).getattr('__implements__')[0]
-        except NotFoundError:
-            return
-        if not herited and not implements.frame() is self:
-            return
-        found = set()
-        missing = False
-        for iface in unpack_infer(implements):
-            if iface is YES:
-                missing = True
-                continue
-            if not iface in found and handler_func(iface):
-                found.add(iface)
-                yield iface
-        if missing:
-            raise InferenceError()
-
-    _metaclass = None
-    def _explicit_metaclass(self):
-        """ Return the explicit defined metaclass
-        for the current class.
-
-        An explicit defined metaclass is defined
-        either by passing the ``metaclass`` keyword argument
-        in the class definition line (Python 3) or by
-        having a ``__metaclass__`` class attribute.
-        """
-        if self._metaclass:
-            # Expects this from Py3k TreeRebuilder
-            try:
-                return next(node for node in self._metaclass.infer()
-                            if node is not YES)
-            except (InferenceError, StopIteration):
-                return 
-
-        try:
-            meta = self.getattr('__metaclass__')[0]
-        except NotFoundError:
-            return
-        try:
-            infered = meta.infer().next()
-        except InferenceError:
-            return
-        if infered is YES: # don't expose this
-            return None
-        return infered
-
-    def metaclass(self):
-        """ Return the metaclass of this class.
-
-        If this class does not define explicitly a metaclass,
-        then the first defined metaclass in ancestors will be used
-        instead.
-        """
-        klass = self._explicit_metaclass()
-        if klass is None:
-            for parent in self.ancestors():
-                klass = parent.metaclass()
-                if klass is not None:
-                    break
-        return klass
diff --git a/pymode/libs/pylama/lint/pylama_pylint/astroid/utils.py b/pymode/libs/pylama/lint/pylama_pylint/astroid/utils.py
deleted file mode 100644
index 1cd0e778..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/astroid/utils.py
+++ /dev/null
@@ -1,236 +0,0 @@
-# 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 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
-
-
-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
-    the node in lower case
-
-    * leave_<class name> on leaving a node, where class name is the class of
-    the node in lower case
-    """
-
-    def __init__(self, handler):
-        self.handler = handler
-        self._cache = {}
-
-    def walk(self, node, _done=None):
-        """walk on the tree from <node>, getting callbacks from handler"""
-        if _done is None:
-            _done = set()
-        if node in _done:
-            raise AssertionError((id(node), node, node.parent))
-        _done.add(node)
-        self.visit(node)
-        for child_node in node.get_children():
-            self.handler.set_context(node, child_node)
-            assert child_node is not node
-            self.walk(child_node, _done)
-        self.leave(node)
-        assert node.parent is not node
-
-    def get_callbacks(self, node):
-        """get callbacks from handler for the visited node"""
-        klass = node.__class__
-        methods = self._cache.get(klass)
-        if methods is None:
-            handler = self.handler
-            kid = klass.__name__.lower()
-            e_method = getattr(handler, 'visit_%s' % kid,
-                               getattr(handler, 'visit_default', None))
-            l_method = getattr(handler, 'leave_%s' % kid,
-                               getattr(handler, 'leave_default', None))
-            self._cache[klass] = (e_method, l_method)
-        else:
-            e_method, l_method = methods
-        return e_method, l_method
-
-    def visit(self, node):
-        """walk on the tree from <node>, getting callbacks from handler"""
-        method = self.get_callbacks(node)[0]
-        if method is not None:
-            method(node)
-
-    def leave(self, node):
-        """walk on the tree from <node>, getting callbacks from handler"""
-        method = self.get_callbacks(node)[1]
-        if method is not None:
-            method(node)
-
-
-class LocalsVisitor(ASTWalker):
-    """visit a project by traversing the locals dictionary"""
-    def __init__(self):
-        ASTWalker.__init__(self, self)
-        self._visited = {}
-
-    def visit(self, node):
-        """launch the visit starting from the given node"""
-        if node in self._visited:
-            return
-        self._visited[node] = 1 # FIXME: use set ?
-        methods = self.get_callbacks(node)
-        if methods[0] is not None:
-            methods[0](node)
-        if 'locals' in node.__dict__: # skip Instance and other proxy
-            for name, local_node in node.items():
-                self.visit(local_node)
-        if methods[1] is not None:
-            return methods[1](node)
-
-
-def _check_children(node):
-    """a helper function to check children - parent relations"""
-    for child in node.get_children():
-        ok = False
-        if child is None:
-            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))
-        elif not 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)
-        else:
-            ok = True
-        if not ok:
-            print "lines;", node.lineno, child.lineno
-            print "of module", node.root(), node.root().name
-            raise AstroidBuildingException
-        _check_children(child)
-
-
-class TreeTester(object):
-    '''A helper class to see _ast tree and compare with astroid tree
-
-    indent: string for tree indent representation
-    lineno: bool to tell if we should print the line numbers
-
-    >>> tester = TreeTester('print')
-    >>> print tester.native_tree_repr()
-
-    <Module>
-    .   body = [
-    .   <Print>
-    .   .   nl = True
-    .   ]
-    >>> print tester.astroid_tree_repr()
-    Module()
-        body = [
-        Print()
-            dest = 
-            values = [
-            ]
-        ]
-    '''
-
-    indent = '.   '
-    lineno = False
-
-    def __init__(self, sourcecode):
-        self._string = ''
-        self.sourcecode = sourcecode
-        self._ast_node = None
-        self.build_ast()
-
-    def build_ast(self):
-        """build the _ast tree from the source code"""
-        self._ast_node = parse(self.sourcecode)
-
-    def native_tree_repr(self, node=None, indent=''):
-        """get a nice representation of the _ast tree"""
-        self._string = ''
-        if node is None:
-            node = self._ast_node
-        self._native_repr_tree(node, indent)
-        return self._string
-
-
-    def _native_repr_tree(self, node, indent, _done=None):
-        """recursive method for the native tree representation"""
-        from _ast import Load as _Load, Store as _Store, Del as _Del
-        from _ast import AST as Node
-        if _done is None:
-            _done = set()
-        if node in _done:
-            self._string += '\nloop in tree: %r (%s)' % (node,
-                                            getattr(node, 'lineno', None))
-            return
-        _done.add(node)
-        self._string += '\n' + indent +  '<%s>' % node.__class__.__name__
-        indent += self.indent
-        if not hasattr(node, '__dict__'):
-            self._string += '\n' + self.indent + " ** node has no __dict__ " + str(node)
-            return
-        node_dict = node.__dict__
-        if hasattr(node, '_attributes'):
-            for a in node._attributes:
-                attr = node_dict[a]
-                if attr is None:
-                    continue
-                if a in ("lineno", "col_offset") and not self.lineno:
-                    continue
-                self._string +='\n' +  indent + a + " = " + repr(attr)
-        for field in node._fields or ():
-            attr = node_dict[field]
-            if attr is None:
-                continue
-            if isinstance(attr, list):
-                if not attr:
-                    continue
-                self._string += '\n' + indent + field + ' = ['
-                for elt in attr:
-                    self._native_repr_tree(elt, indent, _done)
-                self._string += '\n' + indent + ']'
-                continue
-            if isinstance(attr, (_Load, _Store, _Del)):
-                continue
-            if isinstance(attr, Node):
-                self._string += '\n' + indent + field + " = "
-                self._native_repr_tree(attr, indent, _done)
-            else:
-                self._string += '\n' + indent + field + " = " + repr(attr)
-
-
-    def build_astroid_tree(self):
-        """build astroid tree from the _ast tree
-        """
-        from astroid.builder import AstroidBuilder
-        tree = AstroidBuilder().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()
-        return mod.repr_tree(ids)
-
-
-__all__ = ('LocalsVisitor', 'ASTWalker',)
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/__init__.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/__init__.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/__init__.py
deleted file mode 100644
index 8d063e2c..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/__init__.py
+++ /dev/null
@@ -1,171 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Logilab common library (aka Logilab's extension to the standard library).
-
-:type STD_BLACKLIST: tuple
-:var STD_BLACKLIST: directories ignored by default by the functions in
-  this package which have to recurse into directories
-
-:type IGNORED_EXTENSIONS: tuple
-:var IGNORED_EXTENSIONS: file extensions that may usually be ignored
-"""
-__docformat__ = "restructuredtext en"
-from logilab.common.__pkginfo__ import version as __version__
-
-STD_BLACKLIST = ('CVS', '.svn', '.hg', 'debian', 'dist', 'build')
-
-IGNORED_EXTENSIONS = ('.pyc', '.pyo', '.elc', '~', '.swp', '.orig')
-
-# set this to False if you've mx DateTime installed but you don't want your db
-# adapter to use it (should be set before you got a connection)
-USE_MX_DATETIME = True
-
-
-class attrdict(dict):
-    """A dictionary for which keys are also accessible as attributes."""
-    def __getattr__(self, attr):
-        try:
-            return self[attr]
-        except KeyError:
-            raise AttributeError(attr)
-
-class dictattr(dict):
-    def __init__(self, proxy):
-        self.__proxy = proxy
-
-    def __getitem__(self, attr):
-        try:
-            return getattr(self.__proxy, attr)
-        except AttributeError:
-            raise KeyError(attr)
-
-class nullobject(object):
-    def __repr__(self):
-        return '<nullobject>'
-    def __nonzero__(self):
-        return False
-
-class tempattr(object):
-    def __init__(self, obj, attr, value):
-        self.obj = obj
-        self.attr = attr
-        self.value = value
-
-    def __enter__(self):
-        self.oldvalue = getattr(self.obj, self.attr)
-        setattr(self.obj, self.attr, self.value)
-        return self.obj
-
-    def __exit__(self, exctype, value, traceback):
-        setattr(self.obj, self.attr, self.oldvalue)
-
-
-
-# flatten -----
-# XXX move in a specific module and use yield instead
-# do not mix flatten and translate
-#
-# def iterable(obj):
-#    try: iter(obj)
-#    except: return False
-#    return True
-#
-# def is_string_like(obj):
-#    try: obj +''
-#    except (TypeError, ValueError): return False
-#    return True
-#
-#def is_scalar(obj):
-#    return is_string_like(obj) or not iterable(obj)
-#
-#def flatten(seq):
-#    for item in seq:
-#        if is_scalar(item):
-#            yield item
-#        else:
-#            for subitem in flatten(item):
-#               yield subitem
-
-def flatten(iterable, tr_func=None, results=None):
-    """Flatten a list of list with any level.
-
-    If tr_func is not None, it should be a one argument function that'll be called
-    on each final element.
-
-    :rtype: list
-
-    >>> flatten([1, [2, 3]])
-    [1, 2, 3]
-    """
-    if results is None:
-        results = []
-    for val in iterable:
-        if isinstance(val, (list, tuple)):
-            flatten(val, tr_func, results)
-        elif tr_func is None:
-            results.append(val)
-        else:
-            results.append(tr_func(val))
-    return results
-
-
-# XXX is function below still used ?
-
-def make_domains(lists):
-    """
-    Given a list of lists, return a list of domain for each list to produce all
-    combinations of possibles values.
-
-    :rtype: list
-
-    Example:
-
-    >>> make_domains(['a', 'b'], ['c','d', 'e'])
-    [['a', 'b', 'a', 'b', 'a', 'b'], ['c', 'c', 'd', 'd', 'e', 'e']]
-    """
-    domains = []
-    for iterable in lists:
-        new_domain = iterable[:]
-        for i in range(len(domains)):
-            domains[i] = domains[i]*len(iterable)
-        if domains:
-            missing = (len(domains[0]) - len(iterable)) / len(iterable)
-            i = 0
-            for j in range(len(iterable)):
-                value = iterable[j]
-                for dummy in range(missing):
-                    new_domain.insert(i, value)
-                    i += 1
-                i += 1
-        domains.append(new_domain)
-    return domains
-
-
-# private stuff ################################################################
-
-def _handle_blacklist(blacklist, dirnames, filenames):
-    """remove files/directories in the black list
-
-    dirnames/filenames are usually from os.walk
-    """
-    for norecurs in blacklist:
-        if norecurs in dirnames:
-            dirnames.remove(norecurs)
-        elif norecurs in filenames:
-            filenames.remove(norecurs)
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/__pkginfo__.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/__pkginfo__.py
deleted file mode 100644
index d3be5552..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/__pkginfo__.py
+++ /dev/null
@@ -1,53 +0,0 @@
-# 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 logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""logilab.common packaging information"""
-__docformat__ = "restructuredtext en"
-import sys
-import os
-
-distname = 'logilab-common'
-modname = 'common'
-subpackage_of = 'logilab'
-subpackage_master = True
-
-numversion = (0, 61, 0)
-version = '.'.join([str(num) for num in numversion])
-
-license = 'LGPL' # 2.1 or later
-description = "collection of low-level Python packages and modules used by Logilab projects"
-web = "http://www.logilab.org/project/%s" % distname
-mailinglist = "mailto://python-projects@lists.logilab.org"
-author = "Logilab"
-author_email = "contact@logilab.fr"
-
-
-from os.path import join
-scripts = [join('bin', 'pytest')]
-include_dirs = [join('test', 'data')]
-
-install_requires = []
-if sys.version_info < (2, 7):
-    install_requires.append('unittest2 >= 0.5.1')
-if os.name == 'nt':
-    install_requires.append('colorama')
-
-classifiers = ["Topic :: Utilities",
-               "Programming Language :: Python",
-               "Programming Language :: Python :: 2",
-               "Programming Language :: Python :: 3",
-               ]
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/changelog.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/changelog.py
deleted file mode 100644
index 74f51241..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/changelog.py
+++ /dev/null
@@ -1,236 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Manipulation of upstream change log files.
-
-The upstream change log files format handled is simpler than the one
-often used such as those generated by the default Emacs changelog mode.
-
-Sample ChangeLog format::
-
-  Change log for project Yoo
-  ==========================
-
-   --
-      * add a new functionality
-
-  2002-02-01 -- 0.1.1
-      * fix bug #435454
-      * fix bug #434356
-
-  2002-01-01 -- 0.1
-      * initial release
-
-
-There is 3 entries in this change log, one for each released version and one
-for the next version (i.e. the current entry).
-Each entry contains a set of messages corresponding to changes done in this
-release.
-All the non empty lines before the first entry are considered as the change
-log title.
-"""
-
-__docformat__ = "restructuredtext en"
-
-import sys
-from stat import S_IWRITE
-
-BULLET = '*'
-SUBBULLET = '-'
-INDENT = ' ' * 4
-
-class NoEntry(Exception):
-    """raised when we are unable to find an entry"""
-
-class EntryNotFound(Exception):
-    """raised when we are unable to find a given entry"""
-
-class Version(tuple):
-    """simple class to handle soft version number has a tuple while
-    correctly printing it as X.Y.Z
-    """
-    def __new__(cls, versionstr):
-        if isinstance(versionstr, basestring):
-            versionstr = versionstr.strip(' :') # XXX (syt) duh?
-            parsed = cls.parse(versionstr)
-        else:
-            parsed = versionstr
-        return tuple.__new__(cls, parsed)
-
-    @classmethod
-    def parse(cls, versionstr):
-        versionstr = versionstr.strip(' :')
-        try:
-            return [int(i) for i in versionstr.split('.')]
-        except ValueError, ex:
-            raise ValueError("invalid literal for version '%s' (%s)"%(versionstr, ex))
-
-    def __str__(self):
-        return '.'.join([str(i) for i in self])
-
-# upstream change log #########################################################
-
-class ChangeLogEntry(object):
-    """a change log entry, i.e. a set of messages associated to a version and
-    its release date
-    """
-    version_class = Version
-
-    def __init__(self, date=None, version=None, **kwargs):
-        self.__dict__.update(kwargs)
-        if version:
-            self.version = self.version_class(version)
-        else:
-            self.version = None
-        self.date = date
-        self.messages = []
-
-    def add_message(self, msg):
-        """add a new message"""
-        self.messages.append(([msg], []))
-
-    def complete_latest_message(self, msg_suite):
-        """complete the latest added message
-        """
-        if not self.messages:
-            raise ValueError('unable to complete last message as there is no previous message)')
-        if self.messages[-1][1]: # sub messages
-            self.messages[-1][1][-1].append(msg_suite)
-        else: # message
-            self.messages[-1][0].append(msg_suite)
-
-    def add_sub_message(self, sub_msg, key=None):
-        if not self.messages:
-            raise ValueError('unable to complete last message as there is no previous message)')
-        if key is None:
-            self.messages[-1][1].append([sub_msg])
-        else:
-            raise NotImplementedError("sub message to specific key are not implemented yet")
-
-    def write(self, stream=sys.stdout):
-        """write the entry to file """
-        stream.write('%s  --  %s\n' % (self.date or '', self.version or ''))
-        for msg, sub_msgs in self.messages:
-            stream.write('%s%s %s\n' % (INDENT, BULLET, msg[0]))
-            stream.write(''.join(msg[1:]))
-            if sub_msgs:
-                stream.write('\n')
-            for sub_msg in sub_msgs:
-                stream.write('%s%s %s\n' % (INDENT * 2, SUBBULLET, sub_msg[0]))
-                stream.write(''.join(sub_msg[1:]))
-            stream.write('\n')
-
-        stream.write('\n\n')
-
-class ChangeLog(object):
-    """object representation of a whole ChangeLog file"""
-
-    entry_class = ChangeLogEntry
-
-    def __init__(self, changelog_file, title=''):
-        self.file = changelog_file
-        self.title = title
-        self.additional_content = ''
-        self.entries = []
-        self.load()
-
-    def __repr__(self):
-        return '<ChangeLog %s at %s (%s entries)>' % (self.file, id(self),
-                                                      len(self.entries))
-
-    def add_entry(self, entry):
-        """add a new entry to the change log"""
-        self.entries.append(entry)
-
-    def get_entry(self, version='', create=None):
-        """ return a given changelog entry
-        if version is omitted, return the current entry
-        """
-        if not self.entries:
-            if version or not create:
-                raise NoEntry()
-            self.entries.append(self.entry_class())
-        if not version:
-            if self.entries[0].version and create is not None:
-                self.entries.insert(0, self.entry_class())
-            return self.entries[0]
-        version = self.version_class(version)
-        for entry in self.entries:
-            if entry.version == version:
-                return entry
-        raise EntryNotFound()
-
-    def add(self, msg, create=None):
-        """add a new message to the latest opened entry"""
-        entry = self.get_entry(create=create)
-        entry.add_message(msg)
-
-    def load(self):
-        """ read a logilab's ChangeLog from file """
-        try:
-            stream = open(self.file)
-        except IOError:
-            return
-        last = None
-        expect_sub = False
-        for line in stream.readlines():
-            sline = line.strip()
-            words = sline.split()
-            # if new entry
-            if len(words) == 1 and words[0] == '--':
-                expect_sub = False
-                last = self.entry_class()
-                self.add_entry(last)
-            # if old entry
-            elif len(words) == 3 and words[1] == '--':
-                expect_sub = False
-                last = self.entry_class(words[0], words[2])
-                self.add_entry(last)
-            # if title
-            elif sline and last is None:
-                self.title = '%s%s' % (self.title, line)
-            # if new entry
-            elif sline and sline[0] == BULLET:
-                expect_sub = False
-                last.add_message(sline[1:].strip())
-            # if new sub_entry
-            elif expect_sub and sline and sline[0] == SUBBULLET:
-                last.add_sub_message(sline[1:].strip())
-            # if new line for current entry
-            elif sline and last.messages:
-                last.complete_latest_message(line)
-            else:
-                expect_sub = True
-                self.additional_content += line
-        stream.close()
-
-    def format_title(self):
-        return '%s\n\n' % self.title.strip()
-
-    def save(self):
-        """write back change log"""
-        # filetutils isn't importable in appengine, so import locally
-        from logilab.common.fileutils import ensure_fs_mode
-        ensure_fs_mode(self.file, S_IWRITE)
-        self.write(open(self.file, 'w'))
-
-    def write(self, stream=sys.stdout):
-        """write changelog to stream"""
-        stream.write(self.format_title())
-        for entry in self.entries:
-            entry.write(stream)
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/compat.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/compat.py
deleted file mode 100644
index 8983ece9..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/compat.py
+++ /dev/null
@@ -1,243 +0,0 @@
-# pylint: disable=E0601,W0622,W0611
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Wrappers around some builtins introduced in python 2.3, 2.4 and
-2.5, making them available in for earlier versions of python.
-
-See another compatibility snippets from other projects:
-
-    :mod:`lib2to3.fixes`
-    :mod:`coverage.backward`
-    :mod:`unittest2.compatibility`
-"""
-
-from __future__ import generators
-
-__docformat__ = "restructuredtext en"
-
-import os
-import sys
-import types
-from warnings import warn
-
-import __builtin__ as builtins # 2to3 will tranform '__builtin__' to 'builtins'
-
-if sys.version_info < (3, 0):
-    str_to_bytes = str
-    def str_encode(string, encoding):
-        if isinstance(string, unicode):
-            return string.encode(encoding)
-        return str(string)
-else:
-    def str_to_bytes(string):
-        return str.encode(string)
-    # we have to ignore the encoding in py3k to be able to write a string into a
-    # TextIOWrapper or like object (which expect an unicode string)
-    def str_encode(string, encoding):
-        return str(string)
-
-# XXX callable built-in seems back in all python versions
-try:
-    callable = builtins.callable
-except AttributeError:
-    from collections import Callable
-    def callable(something):
-        return isinstance(something, Callable)
-    del Callable
-
-# See also http://bugs.python.org/issue11776
-if sys.version_info[0] == 3:
-    def method_type(callable, instance, klass):
-        # api change. klass is no more considered
-        return types.MethodType(callable, instance)
-else:
-    # alias types otherwise
-    method_type = types.MethodType
-
-if sys.version_info < (3, 0):
-    raw_input = raw_input
-else:
-    raw_input = input
-
-# Pythons 2 and 3 differ on where to get StringIO
-if sys.version_info < (3, 0):
-    from cStringIO import StringIO
-    FileIO = file
-    BytesIO = StringIO
-    reload = reload
-else:
-    from io import FileIO, BytesIO, StringIO
-    from imp import reload
-
-# Where do pickles come from?
-try:
-    import cPickle as pickle
-except ImportError:
-    import pickle
-
-from logilab.common.deprecation import deprecated
-
-from itertools import izip, chain, imap
-if sys.version_info < (3, 0):# 2to3 will remove the imports
-    izip = deprecated('izip exists in itertools since py2.3')(izip)
-    imap = deprecated('imap exists in itertools since py2.3')(imap)
-chain = deprecated('chain exists in itertools since py2.3')(chain)
-
-sum = deprecated('sum exists in builtins since py2.3')(sum)
-enumerate = deprecated('enumerate exists in builtins since py2.3')(enumerate)
-frozenset = deprecated('frozenset exists in builtins since py2.4')(frozenset)
-reversed = deprecated('reversed exists in builtins since py2.4')(reversed)
-sorted = deprecated('sorted exists in builtins since py2.4')(sorted)
-max = deprecated('max exists in builtins since py2.4')(max)
-
-
-# Python2.5 builtins
-try:
-    any = any
-    all = all
-except NameError:
-    def any(iterable):
-        """any(iterable) -> bool
-
-        Return True if bool(x) is True for any x in the iterable.
-        """
-        for elt in iterable:
-            if elt:
-                return True
-        return False
-
-    def all(iterable):
-        """all(iterable) -> bool
-
-        Return True if bool(x) is True for all values x in the iterable.
-        """
-        for elt in iterable:
-            if not elt:
-                return False
-        return True
-
-
-# Python2.5 subprocess added functions and exceptions
-try:
-    from subprocess import Popen
-except ImportError:
-    # gae or python < 2.3
-
-    class CalledProcessError(Exception):
-        """This exception is raised when a process run by check_call() returns
-        a non-zero exit status.  The exit status will be stored in the
-        returncode attribute."""
-        def __init__(self, returncode, cmd):
-            self.returncode = returncode
-            self.cmd = cmd
-        def __str__(self):
-            return "Command '%s' returned non-zero exit status %d" % (self.cmd,
-    self.returncode)
-
-    def call(*popenargs, **kwargs):
-        """Run command with arguments.  Wait for command to complete, then
-        return the returncode attribute.
-
-        The arguments are the same as for the Popen constructor.  Example:
-
-        retcode = call(["ls", "-l"])
-        """
-        # workaround: subprocess.Popen(cmd, stdout=sys.stdout) fails
-        # see http://bugs.python.org/issue1531862
-        if "stdout" in kwargs:
-            fileno = kwargs.get("stdout").fileno()
-            del kwargs['stdout']
-            return Popen(stdout=os.dup(fileno), *popenargs, **kwargs).wait()
-        return Popen(*popenargs, **kwargs).wait()
-
-    def check_call(*popenargs, **kwargs):
-        """Run command with arguments.  Wait for command to complete.  If
-        the exit code was zero then return, otherwise raise
-        CalledProcessError.  The CalledProcessError object will have the
-        return code in the returncode attribute.
-
-        The arguments are the same as for the Popen constructor.  Example:
-
-        check_call(["ls", "-l"])
-        """
-        retcode = call(*popenargs, **kwargs)
-        cmd = kwargs.get("args")
-        if cmd is None:
-            cmd = popenargs[0]
-        if retcode:
-            raise CalledProcessError(retcode, cmd)
-        return retcode
-
-try:
-    from os.path import relpath
-except ImportError: # python < 2.6
-    from os.path import curdir, abspath, sep, commonprefix, pardir, join
-    def relpath(path, start=curdir):
-        """Return a relative version of a path"""
-
-        if not path:
-            raise ValueError("no path specified")
-
-        start_list = abspath(start).split(sep)
-        path_list = abspath(path).split(sep)
-
-        # Work out how much of the filepath is shared by start and path.
-        i = len(commonprefix([start_list, path_list]))
-
-        rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
-        if not rel_list:
-            return curdir
-        return join(*rel_list)
-
-
-# XXX don't know why tests don't pass if I don't do that :
-_real_set, set = set, deprecated('set exists in builtins since py2.4')(set)
-if (2, 5) <= sys.version_info[:2]:
-    InheritableSet = _real_set
-else:
-    class InheritableSet(_real_set):
-        """hacked resolving inheritancy issue from old style class in 2.4"""
-        def __new__(cls, *args, **kwargs):
-            if args:
-                new_args = (args[0], )
-            else:
-                new_args = ()
-            obj = _real_set.__new__(cls, *new_args)
-            obj.__init__(*args, **kwargs)
-            return obj
-
-# XXX shouldn't we remove this and just let 2to3 do his job ?
-# range or xrange?
-try:
-    range = xrange
-except NameError:
-    range = range
-
-# ConfigParser was renamed to the more-standard configparser
-try:
-    import configparser
-except ImportError:
-    import ConfigParser as configparser
-
-try:
-    import json
-except ImportError:
-    try:
-        import simplejson as json
-    except ImportError:
-        json = None
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/configuration.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/configuration.py
deleted file mode 100644
index fa93a056..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/configuration.py
+++ /dev/null
@@ -1,1094 +0,0 @@
-# copyright 2003-2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Classes to handle advanced configuration in simple to complex applications.
-
-Allows to load the configuration from a file or from command line
-options, to generate a sample configuration file or to display
-program's usage. Fills the gap between optik/optparse and ConfigParser
-by adding data types (which are also available as a standalone optik
-extension in the `optik_ext` module).
-
-
-Quick start: simplest usage
----------------------------
-
-.. python ::
-
-  >>> import sys
-  >>> from logilab.common.configuration import Configuration
-  >>> options = [('dothis', {'type':'yn', 'default': True, 'metavar': '<y or n>'}),
-  ...            ('value', {'type': 'string', 'metavar': '<string>'}),
-  ...            ('multiple', {'type': 'csv', 'default': ('yop',),
-  ...                          'metavar': '<comma separated values>',
-  ...                          'help': 'you can also document the option'}),
-  ...            ('number', {'type': 'int', 'default':2, 'metavar':'<int>'}),
-  ...           ]
-  >>> config = Configuration(options=options, name='My config')
-  >>> print config['dothis']
-  True
-  >>> print config['value']
-  None
-  >>> print config['multiple']
-  ('yop',)
-  >>> print config['number']
-  2
-  >>> print config.help()
-  Usage:  [options]
-
-  Options:
-    -h, --help            show this help message and exit
-    --dothis=<y or n>
-    --value=<string>
-    --multiple=<comma separated values>
-                          you can also document the option [current: none]
-    --number=<int>
-
-  >>> f = open('myconfig.ini', 'w')
-  >>> f.write('''[MY CONFIG]
-  ... number = 3
-  ... dothis = no
-  ... multiple = 1,2,3
-  ... ''')
-  >>> f.close()
-  >>> config.load_file_configuration('myconfig.ini')
-  >>> print config['dothis']
-  False
-  >>> print config['value']
-  None
-  >>> print config['multiple']
-  ['1', '2', '3']
-  >>> print config['number']
-  3
-  >>> sys.argv = ['mon prog', '--value', 'bacon', '--multiple', '4,5,6',
-  ...             'nonoptionargument']
-  >>> print config.load_command_line_configuration()
-  ['nonoptionargument']
-  >>> print config['value']
-  bacon
-  >>> config.generate_config()
-  # class for simple configurations which don't need the
-  # manager / providers model and prefer delegation to inheritance
-  #
-  # configuration values are accessible through a dict like interface
-  #
-  [MY CONFIG]
-
-  dothis=no
-
-  value=bacon
-
-  # you can also document the option
-  multiple=4,5,6
-
-  number=3
-  >>>
-"""
-__docformat__ = "restructuredtext en"
-
-__all__ = ('OptionsManagerMixIn', 'OptionsProviderMixIn',
-           'ConfigurationMixIn', 'Configuration',
-           'OptionsManager2ConfigurationAdapter')
-
-import os
-import sys
-import re
-from os.path import exists, expanduser
-from copy import copy
-from ConfigParser import ConfigParser, NoOptionError, NoSectionError, \
-     DuplicateSectionError
-from warnings import warn
-
-from logilab.common.compat import callable, raw_input, str_encode as _encode
-from logilab.common.deprecation import deprecated
-from logilab.common.textutils import normalize_text, unquote
-from logilab.common import optik_ext
-
-OptionError = optik_ext.OptionError
-
-REQUIRED = []
-
-class UnsupportedAction(Exception):
-    """raised by set_option when it doesn't know what to do for an action"""
-
-
-def _get_encoding(encoding, stream):
-    encoding = encoding or getattr(stream, 'encoding', None)
-    if not encoding:
-        import locale
-        encoding = locale.getpreferredencoding()
-    return encoding
-
-
-# validation functions ########################################################
-
-# validators will return the validated value or raise optparse.OptionValueError
-# XXX add to documentation
-
-def choice_validator(optdict, name, value):
-    """validate and return a converted value for option of type 'choice'
-    """
-    if not value in optdict['choices']:
-        msg = "option %s: invalid value: %r, should be in %s"
-        raise optik_ext.OptionValueError(msg % (name, value, optdict['choices']))
-    return value
-
-def multiple_choice_validator(optdict, name, value):
-    """validate and return a converted value for option of type 'choice'
-    """
-    choices = optdict['choices']
-    values = optik_ext.check_csv(None, name, value)
-    for value in values:
-        if not value in choices:
-            msg = "option %s: invalid value: %r, should be in %s"
-            raise optik_ext.OptionValueError(msg % (name, value, choices))
-    return values
-
-def csv_validator(optdict, name, value):
-    """validate and return a converted value for option of type 'csv'
-    """
-    return optik_ext.check_csv(None, name, value)
-
-def yn_validator(optdict, name, value):
-    """validate and return a converted value for option of type 'yn'
-    """
-    return optik_ext.check_yn(None, name, value)
-
-def named_validator(optdict, name, value):
-    """validate and return a converted value for option of type 'named'
-    """
-    return optik_ext.check_named(None, name, value)
-
-def file_validator(optdict, name, value):
-    """validate and return a filepath for option of type 'file'"""
-    return optik_ext.check_file(None, name, value)
-
-def color_validator(optdict, name, value):
-    """validate and return a valid color for option of type 'color'"""
-    return optik_ext.check_color(None, name, value)
-
-def password_validator(optdict, name, value):
-    """validate and return a string for option of type 'password'"""
-    return optik_ext.check_password(None, name, value)
-
-def date_validator(optdict, name, value):
-    """validate and return a mx DateTime object for option of type 'date'"""
-    return optik_ext.check_date(None, name, value)
-
-def time_validator(optdict, name, value):
-    """validate and return a time object for option of type 'time'"""
-    return optik_ext.check_time(None, name, value)
-
-def bytes_validator(optdict, name, value):
-    """validate and return an integer for option of type 'bytes'"""
-    return optik_ext.check_bytes(None, name, value)
-
-
-VALIDATORS = {'string': unquote,
-              'int': int,
-              'float': float,
-              'file': file_validator,
-              'font': unquote,
-              'color': color_validator,
-              'regexp': re.compile,
-              'csv': csv_validator,
-              'yn': yn_validator,
-              'bool': yn_validator,
-              'named': named_validator,
-              'password': password_validator,
-              'date': date_validator,
-              'time': time_validator,
-              'bytes': bytes_validator,
-              'choice': choice_validator,
-              'multiple_choice': multiple_choice_validator,
-              }
-
-def _call_validator(opttype, optdict, option, value):
-    if opttype not in VALIDATORS:
-        raise Exception('Unsupported type "%s"' % opttype)
-    try:
-        return VALIDATORS[opttype](optdict, option, value)
-    except TypeError:
-        try:
-            return VALIDATORS[opttype](value)
-        except optik_ext.OptionValueError:
-            raise
-        except:
-            raise optik_ext.OptionValueError('%s value (%r) should be of type %s' %
-                                   (option, value, opttype))
-
-# user input functions ########################################################
-
-# user input functions will ask the user for input on stdin then validate
-# the result and return the validated value or raise optparse.OptionValueError
-# XXX add to documentation
-
-def input_password(optdict, question='password:'):
-    from getpass import getpass
-    while True:
-        value = getpass(question)
-        value2 = getpass('confirm: ')
-        if value == value2:
-            return value
-        print 'password mismatch, try again'
-
-def input_string(optdict, question):
-    value = raw_input(question).strip()
-    return value or None
-
-def _make_input_function(opttype):
-    def input_validator(optdict, question):
-        while True:
-            value = raw_input(question)
-            if not value.strip():
-                return None
-            try:
-                return _call_validator(opttype, optdict, None, value)
-            except optik_ext.OptionValueError, ex:
-                msg = str(ex).split(':', 1)[-1].strip()
-                print 'bad value: %s' % msg
-    return input_validator
-
-INPUT_FUNCTIONS = {
-    'string': input_string,
-    'password': input_password,
-    }
-
-for opttype in VALIDATORS.keys():
-    INPUT_FUNCTIONS.setdefault(opttype, _make_input_function(opttype))
-
-# utility functions ############################################################
-
-def expand_default(self, option):
-    """monkey patch OptionParser.expand_default since we have a particular
-    way to handle defaults to avoid overriding values in the configuration
-    file
-    """
-    if self.parser is None or not self.default_tag:
-        return option.help
-    optname = option._long_opts[0][2:]
-    try:
-        provider = self.parser.options_manager._all_options[optname]
-    except KeyError:
-        value = None
-    else:
-        optdict = provider.get_option_def(optname)
-        optname = provider.option_attrname(optname, optdict)
-        value = getattr(provider.config, optname, optdict)
-        value = format_option_value(optdict, value)
-    if value is optik_ext.NO_DEFAULT or not value:
-        value = self.NO_DEFAULT_VALUE
-    return option.help.replace(self.default_tag, str(value))
-
-
-def _validate(value, optdict, name=''):
-    """return a validated value for an option according to its type
-
-    optional argument name is only used for error message formatting
-    """
-    try:
-        _type = optdict['type']
-    except KeyError:
-        # FIXME
-        return value
-    return _call_validator(_type, optdict, name, value)
-convert = deprecated('[0.60] convert() was renamed _validate()')(_validate)
-
-# format and output functions ##################################################
-
-def comment(string):
-    """return string as a comment"""
-    lines = [line.strip() for line in string.splitlines()]
-    return '# ' + ('%s# ' % os.linesep).join(lines)
-
-def format_time(value):
-    if not value:
-        return '0'
-    if value != int(value):
-        return '%.2fs' % value
-    value = int(value)
-    nbmin, nbsec = divmod(value, 60)
-    if nbsec:
-        return '%ss' % value
-    nbhour, nbmin_ = divmod(nbmin, 60)
-    if nbmin_:
-        return '%smin' % nbmin
-    nbday, nbhour_ = divmod(nbhour, 24)
-    if nbhour_:
-        return '%sh' % nbhour
-    return '%sd' % nbday
-
-def format_bytes(value):
-    if not value:
-        return '0'
-    if value != int(value):
-        return '%.2fB' % value
-    value = int(value)
-    prevunit = 'B'
-    for unit in ('KB', 'MB', 'GB', 'TB'):
-        next, remain = divmod(value, 1024)
-        if remain:
-            return '%s%s' % (value, prevunit)
-        prevunit = unit
-        value = next
-    return '%s%s' % (value, unit)
-
-def format_option_value(optdict, value):
-    """return the user input's value from a 'compiled' value"""
-    if isinstance(value, (list, tuple)):
-        value = ','.join(value)
-    elif isinstance(value, dict):
-        value = ','.join(['%s:%s' % (k, v) for k, v in value.items()])
-    elif hasattr(value, 'match'): # optdict.get('type') == 'regexp'
-        # compiled regexp
-        value = value.pattern
-    elif optdict.get('type') == 'yn':
-        value = value and 'yes' or 'no'
-    elif isinstance(value, (str, unicode)) and value.isspace():
-        value = "'%s'" % value
-    elif optdict.get('type') == 'time' and isinstance(value, (float, int, long)):
-        value = format_time(value)
-    elif optdict.get('type') == 'bytes' and hasattr(value, '__int__'):
-        value = format_bytes(value)
-    return value
-
-def ini_format_section(stream, section, options, encoding=None, doc=None):
-    """format an options section using the INI format"""
-    encoding = _get_encoding(encoding, stream)
-    if doc:
-        print >> stream, _encode(comment(doc), encoding)
-    print >> stream, '[%s]' % section
-    ini_format(stream, options, encoding)
-
-def ini_format(stream, options, encoding):
-    """format options using the INI format"""
-    for optname, optdict, value in options:
-        value = format_option_value(optdict, value)
-        help = optdict.get('help')
-        if help:
-            help = normalize_text(help, line_len=79, indent='# ')
-            print >> stream
-            print >> stream, _encode(help, encoding)
-        else:
-            print >> stream
-        if value is None:
-            print >> stream, '#%s=' % optname
-        else:
-            value = _encode(value, encoding).strip()
-            print >> stream, '%s=%s' % (optname, value)
-
-format_section = ini_format_section
-
-def rest_format_section(stream, section, options, encoding=None, doc=None):
-    """format an options section using the INI format"""
-    encoding = _get_encoding(encoding, stream)
-    if section:
-        print >> stream, '%s\n%s' % (section, "'"*len(section))
-    if doc:
-        print >> stream, _encode(normalize_text(doc, line_len=79, indent=''),
-                                 encoding)
-        print >> stream
-    for optname, optdict, value in options:
-        help = optdict.get('help')
-        print >> stream, ':%s:' % optname
-        if help:
-            help = normalize_text(help, line_len=79, indent='  ')
-            print >> stream, _encode(help, encoding)
-        if value:
-            value = _encode(format_option_value(optdict, value), encoding)
-            print >> stream, ''
-            print >> stream, '  Default: ``%s``' % value.replace("`` ", "```` ``")
-
-# Options Manager ##############################################################
-
-class OptionsManagerMixIn(object):
-    """MixIn to handle a configuration from both a configuration file and
-    command line options
-    """
-
-    def __init__(self, usage, config_file=None, version=None, quiet=0):
-        self.config_file = config_file
-        self.reset_parsers(usage, version=version)
-        # list of registered options providers
-        self.options_providers = []
-        # dictionary associating option name to checker
-        self._all_options = {}
-        self._short_options = {}
-        self._nocallback_options = {}
-        self._mygroups = dict()
-        # verbosity
-        self.quiet = quiet
-        self._maxlevel = 0
-
-    def reset_parsers(self, usage='', version=None):
-        # configuration file parser
-        self.cfgfile_parser = ConfigParser()
-        # command line parser
-        self.cmdline_parser = optik_ext.OptionParser(usage=usage, version=version)
-        self.cmdline_parser.options_manager = self
-        self._optik_option_attrs = set(self.cmdline_parser.option_class.ATTRS)
-
-    def register_options_provider(self, provider, own_group=True):
-        """register an options provider"""
-        assert provider.priority <= 0, "provider's priority can't be >= 0"
-        for i in range(len(self.options_providers)):
-            if provider.priority > self.options_providers[i].priority:
-                self.options_providers.insert(i, provider)
-                break
-        else:
-            self.options_providers.append(provider)
-        non_group_spec_options = [option for option in provider.options
-                                  if 'group' not in option[1]]
-        groups = getattr(provider, 'option_groups', ())
-        if own_group and non_group_spec_options:
-            self.add_option_group(provider.name.upper(), provider.__doc__,
-                                  non_group_spec_options, provider)
-        else:
-            for opt, optdict in non_group_spec_options:
-                self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
-        for gname, gdoc in groups:
-            gname = gname.upper()
-            goptions = [option for option in provider.options
-                        if option[1].get('group', '').upper() == gname]
-            self.add_option_group(gname, gdoc, goptions, provider)
-
-    def add_option_group(self, group_name, doc, options, provider):
-        """add an option group including the listed options
-        """
-        assert options
-        # add option group to the command line parser
-        if group_name in self._mygroups:
-            group = self._mygroups[group_name]
-        else:
-            group = optik_ext.OptionGroup(self.cmdline_parser,
-                                         title=group_name.capitalize())
-            self.cmdline_parser.add_option_group(group)
-            group.level = provider.level
-            self._mygroups[group_name] = group
-            # add section to the config file
-            if group_name != "DEFAULT":
-                self.cfgfile_parser.add_section(group_name)
-        # add provider's specific options
-        for opt, optdict in options:
-            self.add_optik_option(provider, group, opt, optdict)
-
-    def add_optik_option(self, provider, optikcontainer, opt, optdict):
-        if 'inputlevel' in optdict:
-            warn('[0.50] "inputlevel" in option dictionary for %s is deprecated,'
-                 ' use "level"' % opt, DeprecationWarning)
-            optdict['level'] = optdict.pop('inputlevel')
-        args, optdict = self.optik_option(provider, opt, optdict)
-        option = optikcontainer.add_option(*args, **optdict)
-        self._all_options[opt] = provider
-        self._maxlevel = max(self._maxlevel, option.level or 0)
-
-    def optik_option(self, provider, opt, optdict):
-        """get our personal option definition and return a suitable form for
-        use with optik/optparse
-        """
-        optdict = copy(optdict)
-        others = {}
-        if 'action' in optdict:
-            self._nocallback_options[provider] = opt
-        else:
-            optdict['action'] = 'callback'
-            optdict['callback'] = self.cb_set_provider_option
-        # default is handled here and *must not* be given to optik if you
-        # want the whole machinery to work
-        if 'default' in optdict:
-            if ('help' in optdict
-                and optdict.get('default') is not None
-                and not optdict['action'] in ('store_true', 'store_false')):
-                optdict['help'] += ' [current: %default]'
-            del optdict['default']
-        args = ['--' + str(opt)]
-        if 'short' in optdict:
-            self._short_options[optdict['short']] = opt
-            args.append('-' + optdict['short'])
-            del optdict['short']
-        # cleanup option definition dict before giving it to optik
-        for key in optdict.keys():
-            if not key in self._optik_option_attrs:
-                optdict.pop(key)
-        return args, optdict
-
-    def cb_set_provider_option(self, option, opt, value, parser):
-        """optik callback for option setting"""
-        if opt.startswith('--'):
-            # remove -- on long option
-            opt = opt[2:]
-        else:
-            # short option, get its long equivalent
-            opt = self._short_options[opt[1:]]
-        # trick since we can't set action='store_true' on options
-        if value is None:
-            value = 1
-        self.global_set_option(opt, value)
-
-    def global_set_option(self, opt, value):
-        """set option on the correct option provider"""
-        self._all_options[opt].set_option(opt, value)
-
-    def generate_config(self, stream=None, skipsections=(), encoding=None):
-        """write a configuration file according to the current configuration
-        into the given stream or stdout
-        """
-        options_by_section = {}
-        sections = []
-        for provider in self.options_providers:
-            for section, options in provider.options_by_section():
-                if section is None:
-                    section = provider.name
-                if section in skipsections:
-                    continue
-                options = [(n, d, v) for (n, d, v) in options
-                           if d.get('type') is not None]
-                if not options:
-                    continue
-                if not section in sections:
-                    sections.append(section)
-                alloptions = options_by_section.setdefault(section, [])
-                alloptions += options
-        stream = stream or sys.stdout
-        encoding = _get_encoding(encoding, stream)
-        printed = False
-        for section in sections:
-            if printed:
-                print >> stream, '\n'
-            format_section(stream, section.upper(), options_by_section[section],
-                           encoding)
-            printed = True
-
-    def generate_manpage(self, pkginfo, section=1, stream=None):
-        """write a man page for the current configuration into the given
-        stream or stdout
-        """
-        self._monkeypatch_expand_default()
-        try:
-            optik_ext.generate_manpage(self.cmdline_parser, pkginfo,
-                                      section, stream=stream or sys.stdout,
-                                      level=self._maxlevel)
-        finally:
-            self._unmonkeypatch_expand_default()
-
-    # initialization methods ##################################################
-
-    def load_provider_defaults(self):
-        """initialize configuration using default values"""
-        for provider in self.options_providers:
-            provider.load_defaults()
-
-    def load_file_configuration(self, config_file=None):
-        """load the configuration from file"""
-        self.read_config_file(config_file)
-        self.load_config_file()
-
-    def read_config_file(self, config_file=None):
-        """read the configuration file but do not load it (i.e. dispatching
-        values to each options provider)
-        """
-        helplevel = 1
-        while helplevel <= self._maxlevel:
-            opt = '-'.join(['long'] * helplevel) + '-help'
-            if opt in self._all_options:
-                break # already processed
-            def helpfunc(option, opt, val, p, level=helplevel):
-                print self.help(level)
-                sys.exit(0)
-            helpmsg = '%s verbose help.' % ' '.join(['more'] * helplevel)
-            optdict = {'action' : 'callback', 'callback' : helpfunc,
-                       'help' : helpmsg}
-            provider = self.options_providers[0]
-            self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
-            provider.options += ( (opt, optdict), )
-            helplevel += 1
-        if config_file is None:
-            config_file = self.config_file
-        if config_file is not None:
-            config_file = expanduser(config_file)
-        if config_file and exists(config_file):
-            parser = self.cfgfile_parser
-            parser.read([config_file])
-            # normalize sections'title
-            for sect, values in parser._sections.items():
-                if not sect.isupper() and values:
-                    parser._sections[sect.upper()] = values
-        elif not self.quiet:
-            msg = 'No config file found, using default configuration'
-            print >> sys.stderr, msg
-            return
-
-    def input_config(self, onlysection=None, inputlevel=0, stream=None):
-        """interactively get configuration values by asking to the user and generate
-        a configuration file
-        """
-        if onlysection is not None:
-            onlysection = onlysection.upper()
-        for provider in self.options_providers:
-            for section, option, optdict in provider.all_options():
-                if onlysection is not None and section != onlysection:
-                    continue
-                if not 'type' in optdict:
-                    # ignore action without type (callback, store_true...)
-                    continue
-                provider.input_option(option, optdict, inputlevel)
-        # now we can generate the configuration file
-        if stream is not None:
-            self.generate_config(stream)
-
-    def load_config_file(self):
-        """dispatch values previously read from a configuration file to each
-        options provider)
-        """
-        parser = self.cfgfile_parser
-        for provider in self.options_providers:
-            for section, option, optdict in provider.all_options():
-                try:
-                    value = parser.get(section, option)
-                    provider.set_option(option, value, optdict=optdict)
-                except (NoSectionError, NoOptionError), ex:
-                    continue
-
-    def load_configuration(self, **kwargs):
-        """override configuration according to given parameters
-        """
-        for opt, opt_value in kwargs.items():
-            opt = opt.replace('_', '-')
-            provider = self._all_options[opt]
-            provider.set_option(opt, opt_value)
-
-    def load_command_line_configuration(self, args=None):
-        """override configuration according to command line parameters
-
-        return additional arguments
-        """
-        self._monkeypatch_expand_default()
-        try:
-            if args is None:
-                args = sys.argv[1:]
-            else:
-                args = list(args)
-            (options, args) = self.cmdline_parser.parse_args(args=args)
-            for provider in self._nocallback_options.keys():
-                config = provider.config
-                for attr in config.__dict__.keys():
-                    value = getattr(options, attr, None)
-                    if value is None:
-                        continue
-                    setattr(config, attr, value)
-            return args
-        finally:
-            self._unmonkeypatch_expand_default()
-
-
-    # help methods ############################################################
-
-    def add_help_section(self, title, description, level=0):
-        """add a dummy option section for help purpose """
-        group = optik_ext.OptionGroup(self.cmdline_parser,
-                                     title=title.capitalize(),
-                                     description=description)
-        group.level = level
-        self._maxlevel = max(self._maxlevel, level)
-        self.cmdline_parser.add_option_group(group)
-
-    def _monkeypatch_expand_default(self):
-        # monkey patch optik_ext to deal with our default values
-        try:
-            self.__expand_default_backup = optik_ext.HelpFormatter.expand_default
-            optik_ext.HelpFormatter.expand_default = expand_default
-        except AttributeError:
-            # python < 2.4: nothing to be done
-            pass
-    def _unmonkeypatch_expand_default(self):
-        # remove monkey patch
-        if hasattr(optik_ext.HelpFormatter, 'expand_default'):
-            # unpatch optik_ext to avoid side effects
-            optik_ext.HelpFormatter.expand_default = self.__expand_default_backup
-
-    def help(self, level=0):
-        """return the usage string for available options """
-        self.cmdline_parser.formatter.output_level = level
-        self._monkeypatch_expand_default()
-        try:
-            return self.cmdline_parser.format_help()
-        finally:
-            self._unmonkeypatch_expand_default()
-
-
-class Method(object):
-    """used to ease late binding of default method (so you can define options
-    on the class using default methods on the configuration instance)
-    """
-    def __init__(self, methname):
-        self.method = methname
-        self._inst = None
-
-    def bind(self, instance):
-        """bind the method to its instance"""
-        if self._inst is None:
-            self._inst = instance
-
-    def __call__(self, *args, **kwargs):
-        assert self._inst, 'unbound method'
-        return getattr(self._inst, self.method)(*args, **kwargs)
-
-# Options Provider #############################################################
-
-class OptionsProviderMixIn(object):
-    """Mixin to provide options to an OptionsManager"""
-
-    # those attributes should be overridden
-    priority = -1
-    name = 'default'
-    options = ()
-    level = 0
-
-    def __init__(self):
-        self.config = optik_ext.Values()
-        for option in self.options:
-            try:
-                option, optdict = option
-            except ValueError:
-                raise Exception('Bad option: %r' % option)
-            if isinstance(optdict.get('default'), Method):
-                optdict['default'].bind(self)
-            elif isinstance(optdict.get('callback'), Method):
-                optdict['callback'].bind(self)
-        self.load_defaults()
-
-    def load_defaults(self):
-        """initialize the provider using default values"""
-        for opt, optdict in self.options:
-            action = optdict.get('action')
-            if action != 'callback':
-                # callback action have no default
-                default = self.option_default(opt, optdict)
-                if default is REQUIRED:
-                    continue
-                self.set_option(opt, default, action, optdict)
-
-    def option_default(self, opt, optdict=None):
-        """return the default value for an option"""
-        if optdict is None:
-            optdict = self.get_option_def(opt)
-        default = optdict.get('default')
-        if callable(default):
-            default = default()
-        return default
-
-    def option_attrname(self, opt, optdict=None):
-        """get the config attribute corresponding to opt
-        """
-        if optdict is None:
-            optdict = self.get_option_def(opt)
-        return optdict.get('dest', opt.replace('-', '_'))
-    option_name = deprecated('[0.60] OptionsProviderMixIn.option_name() was renamed to option_attrname()')(option_attrname)
-
-    def option_value(self, opt):
-        """get the current value for the given option"""
-        return getattr(self.config, self.option_attrname(opt), None)
-
-    def set_option(self, opt, value, action=None, optdict=None):
-        """method called to set an option (registered in the options list)
-        """
-        if optdict is None:
-            optdict = self.get_option_def(opt)
-        if value is not None:
-            value = _validate(value, optdict, opt)
-        if action is None:
-            action = optdict.get('action', 'store')
-        if optdict.get('type') == 'named': # XXX need specific handling
-            optname = self.option_attrname(opt, optdict)
-            currentvalue = getattr(self.config, optname, None)
-            if currentvalue:
-                currentvalue.update(value)
-                value = currentvalue
-        if action == 'store':
-            setattr(self.config, self.option_attrname(opt, optdict), value)
-        elif action in ('store_true', 'count'):
-            setattr(self.config, self.option_attrname(opt, optdict), 0)
-        elif action == 'store_false':
-            setattr(self.config, self.option_attrname(opt, optdict), 1)
-        elif action == 'append':
-            opt = self.option_attrname(opt, optdict)
-            _list = getattr(self.config, opt, None)
-            if _list is None:
-                if isinstance(value, (list, tuple)):
-                    _list = value
-                elif value is not None:
-                    _list = []
-                    _list.append(value)
-                setattr(self.config, opt, _list)
-            elif isinstance(_list, tuple):
-                setattr(self.config, opt, _list + (value,))
-            else:
-                _list.append(value)
-        elif action == 'callback':
-            optdict['callback'](None, opt, value, None)
-        else:
-            raise UnsupportedAction(action)
-
-    def input_option(self, option, optdict, inputlevel=99):
-        default = self.option_default(option, optdict)
-        if default is REQUIRED:
-            defaultstr = '(required): '
-        elif optdict.get('level', 0) > inputlevel:
-            return
-        elif optdict['type'] == 'password' or default is None:
-            defaultstr = ': '
-        else:
-            defaultstr = '(default: %s): ' % format_option_value(optdict, default)
-        print ':%s:' % option
-        print optdict.get('help') or option
-        inputfunc = INPUT_FUNCTIONS[optdict['type']]
-        value = inputfunc(optdict, defaultstr)
-        while default is REQUIRED and not value:
-            print 'please specify a value'
-            value = inputfunc(optdict, '%s: ' % option)
-        if value is None and default is not None:
-            value = default
-        self.set_option(option, value, optdict=optdict)
-
-    def get_option_def(self, opt):
-        """return the dictionary defining an option given it's name"""
-        assert self.options
-        for option in self.options:
-            if option[0] == opt:
-                return option[1]
-        raise OptionError('no such option %s in section %r'
-                          % (opt, self.name), opt)
-
-
-    def all_options(self):
-        """return an iterator on available options for this provider
-        option are actually described by a 3-uple:
-        (section, option name, option dictionary)
-        """
-        for section, options in self.options_by_section():
-            if section is None:
-                if self.name is None:
-                    continue
-                section = self.name.upper()
-            for option, optiondict, value in options:
-                yield section, option, optiondict
-
-    def options_by_section(self):
-        """return an iterator on options grouped by section
-
-        (section, [list of (optname, optdict, optvalue)])
-        """
-        sections = {}
-        for optname, optdict in self.options:
-            sections.setdefault(optdict.get('group'), []).append(
-                (optname, optdict, self.option_value(optname)))
-        if None in sections:
-            yield None, sections.pop(None)
-        for section, options in sections.items():
-            yield section.upper(), options
-
-    def options_and_values(self, options=None):
-        if options is None:
-            options = self.options
-        for optname, optdict in options:
-            yield (optname, optdict, self.option_value(optname))
-
-# configuration ################################################################
-
-class ConfigurationMixIn(OptionsManagerMixIn, OptionsProviderMixIn):
-    """basic mixin for simple configurations which don't need the
-    manager / providers model
-    """
-    def __init__(self, *args, **kwargs):
-        if not args:
-            kwargs.setdefault('usage', '')
-        kwargs.setdefault('quiet', 1)
-        OptionsManagerMixIn.__init__(self, *args, **kwargs)
-        OptionsProviderMixIn.__init__(self)
-        if not getattr(self, 'option_groups', None):
-            self.option_groups = []
-            for option, optdict in self.options:
-                try:
-                    gdef = (optdict['group'].upper(), '')
-                except KeyError:
-                    continue
-                if not gdef in self.option_groups:
-                    self.option_groups.append(gdef)
-        self.register_options_provider(self, own_group=False)
-
-    def register_options(self, options):
-        """add some options to the configuration"""
-        options_by_group = {}
-        for optname, optdict in options:
-            options_by_group.setdefault(optdict.get('group', self.name.upper()), []).append((optname, optdict))
-        for group, options in options_by_group.items():
-            self.add_option_group(group, None, options, self)
-        self.options += tuple(options)
-
-    def load_defaults(self):
-        OptionsProviderMixIn.load_defaults(self)
-
-    def __iter__(self):
-        return iter(self.config.__dict__.iteritems())
-
-    def __getitem__(self, key):
-        try:
-            return getattr(self.config, self.option_attrname(key))
-        except (optik_ext.OptionValueError, AttributeError):
-            raise KeyError(key)
-
-    def __setitem__(self, key, value):
-        self.set_option(key, value)
-
-    def get(self, key, default=None):
-        try:
-            return getattr(self.config, self.option_attrname(key))
-        except (OptionError, AttributeError):
-            return default
-
-
-class Configuration(ConfigurationMixIn):
-    """class for simple configurations which don't need the
-    manager / providers model and prefer delegation to inheritance
-
-    configuration values are accessible through a dict like interface
-    """
-
-    def __init__(self, config_file=None, options=None, name=None,
-                 usage=None, doc=None, version=None):
-        if options is not None:
-            self.options = options
-        if name is not None:
-            self.name = name
-        if doc is not None:
-            self.__doc__ = doc
-        super(Configuration, self).__init__(config_file=config_file, usage=usage, version=version)
-
-
-class OptionsManager2ConfigurationAdapter(object):
-    """Adapt an option manager to behave like a
-    `logilab.common.configuration.Configuration` instance
-    """
-    def __init__(self, provider):
-        self.config = provider
-
-    def __getattr__(self, key):
-        return getattr(self.config, key)
-
-    def __getitem__(self, key):
-        provider = self.config._all_options[key]
-        try:
-            return getattr(provider.config, provider.option_attrname(key))
-        except AttributeError:
-            raise KeyError(key)
-
-    def __setitem__(self, key, value):
-        self.config.global_set_option(self.config.option_attrname(key), value)
-
-    def get(self, key, default=None):
-        provider = self.config._all_options[key]
-        try:
-            return getattr(provider.config, provider.option_attrname(key))
-        except AttributeError:
-            return default
-
-# other functions ##############################################################
-
-def read_old_config(newconfig, changes, configfile):
-    """initialize newconfig from a deprecated configuration file
-
-    possible changes:
-    * ('renamed', oldname, newname)
-    * ('moved', option, oldgroup, newgroup)
-    * ('typechanged', option, oldtype, newvalue)
-    """
-    # build an index of changes
-    changesindex = {}
-    for action in changes:
-        if action[0] == 'moved':
-            option, oldgroup, newgroup = action[1:]
-            changesindex.setdefault(option, []).append((action[0], oldgroup, newgroup))
-            continue
-        if action[0] == 'renamed':
-            oldname, newname = action[1:]
-            changesindex.setdefault(newname, []).append((action[0], oldname))
-            continue
-        if action[0] == 'typechanged':
-            option, oldtype, newvalue = action[1:]
-            changesindex.setdefault(option, []).append((action[0], oldtype, newvalue))
-            continue
-        if action[1] in ('added', 'removed'):
-            continue # nothing to do here
-        raise Exception('unknown change %s' % action[0])
-    # build a config object able to read the old config
-    options = []
-    for optname, optdef in newconfig.options:
-        for action in changesindex.pop(optname, ()):
-            if action[0] == 'moved':
-                oldgroup, newgroup = action[1:]
-                optdef = optdef.copy()
-                optdef['group'] = oldgroup
-            elif action[0] == 'renamed':
-                optname = action[1]
-            elif action[0] == 'typechanged':
-                oldtype = action[1]
-                optdef = optdef.copy()
-                optdef['type'] = oldtype
-        options.append((optname, optdef))
-    if changesindex:
-        raise Exception('unapplied changes: %s' % changesindex)
-    oldconfig = Configuration(options=options, name=newconfig.name)
-    # read the old config
-    oldconfig.load_file_configuration(configfile)
-    # apply values reverting changes
-    changes.reverse()
-    done = set()
-    for action in changes:
-        if action[0] == 'renamed':
-            oldname, newname = action[1:]
-            newconfig[newname] = oldconfig[oldname]
-            done.add(newname)
-        elif action[0] == 'typechanged':
-            optname, oldtype, newvalue = action[1:]
-            newconfig[optname] = newvalue
-            done.add(optname)
-    for optname, optdef in newconfig.options:
-        if optdef.get('type') and not optname in done:
-            newconfig.set_option(optname, oldconfig[optname], optdict=optdef)
-
-
-def merge_options(options, optgroup=None):
-    """preprocess a list of options and remove duplicates, returning a new list
-    (tuple actually) of options.
-
-    Options dictionaries are copied to avoid later side-effect. Also, if
-    `otpgroup` argument is specified, ensure all options are in the given group.
-    """
-    alloptions = {}
-    options = list(options)
-    for i in range(len(options)-1, -1, -1):
-        optname, optdict = options[i]
-        if optname in alloptions:
-            options.pop(i)
-            alloptions[optname].update(optdict)
-        else:
-            optdict = optdict.copy()
-            options[i] = (optname, optdict)
-            alloptions[optname] = optdict
-        if optgroup is not None:
-            alloptions[optname]['group'] = optgroup
-    return tuple(options)
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/decorators.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/decorators.py
deleted file mode 100644
index 34bbd3a9..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/decorators.py
+++ /dev/null
@@ -1,281 +0,0 @@
-# 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 logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-""" A few useful function/method decorators. """
-__docformat__ = "restructuredtext en"
-
-import sys
-import types
-from time import clock, time
-
-from logilab.common.compat import callable, method_type
-
-# XXX rewrite so we can use the decorator syntax when keyarg has to be specified
-
-def _is_generator_function(callableobj):
-    return callableobj.func_code.co_flags & 0x20
-
-class cached_decorator(object):
-    def __init__(self, cacheattr=None, keyarg=None):
-        self.cacheattr = cacheattr
-        self.keyarg = keyarg
-    def __call__(self, callableobj=None):
-        assert not _is_generator_function(callableobj), \
-               'cannot cache generator function: %s' % callableobj
-        if callableobj.func_code.co_argcount == 1 or self.keyarg == 0:
-            cache = _SingleValueCache(callableobj, self.cacheattr)
-        elif self.keyarg:
-            cache = _MultiValuesKeyArgCache(callableobj, self.keyarg, self.cacheattr)
-        else:
-            cache = _MultiValuesCache(callableobj, self.cacheattr)
-        return cache.closure()
-
-class _SingleValueCache(object):
-    def __init__(self, callableobj, cacheattr=None):
-        self.callable = callableobj
-        if cacheattr is None:
-            self.cacheattr = '_%s_cache_' % callableobj.__name__
-        else:
-            assert cacheattr != callableobj.__name__
-            self.cacheattr = cacheattr
-
-    def __call__(__me, self, *args):
-        try:
-            return self.__dict__[__me.cacheattr]
-        except KeyError:
-            value = __me.callable(self, *args)
-            setattr(self, __me.cacheattr, value)
-            return value
-
-    def closure(self):
-        def wrapped(*args, **kwargs):
-            return self.__call__(*args, **kwargs)
-        wrapped.cache_obj = self
-        try:
-            wrapped.__doc__ = self.callable.__doc__
-            wrapped.__name__ = self.callable.__name__
-            wrapped.func_name = self.callable.func_name
-        except:
-            pass
-        return wrapped
-
-    def clear(self, holder):
-        holder.__dict__.pop(self.cacheattr, None)
-
-
-class _MultiValuesCache(_SingleValueCache):
-    def _get_cache(self, holder):
-        try:
-            _cache = holder.__dict__[self.cacheattr]
-        except KeyError:
-            _cache = {}
-            setattr(holder, self.cacheattr, _cache)
-        return _cache
-
-    def __call__(__me, self, *args, **kwargs):
-        _cache = __me._get_cache(self)
-        try:
-            return _cache[args]
-        except KeyError:
-            _cache[args] = __me.callable(self, *args)
-            return _cache[args]
-
-class _MultiValuesKeyArgCache(_MultiValuesCache):
-    def __init__(self, callableobj, keyarg, cacheattr=None):
-        super(_MultiValuesKeyArgCache, self).__init__(callableobj, cacheattr)
-        self.keyarg = keyarg
-
-    def __call__(__me, self, *args, **kwargs):
-        _cache = __me._get_cache(self)
-        key = args[__me.keyarg-1]
-        try:
-            return _cache[key]
-        except KeyError:
-            _cache[key] = __me.callable(self, *args, **kwargs)
-            return _cache[key]
-
-
-def cached(callableobj=None, keyarg=None, **kwargs):
-    """Simple decorator to cache result of method call."""
-    kwargs['keyarg'] = keyarg
-    decorator = cached_decorator(**kwargs)
-    if callableobj is None:
-        return decorator
-    else:
-        return decorator(callableobj)
-
-
-class cachedproperty(object):
-    """ Provides a cached property equivalent to the stacking of
-    @cached and @property, but more efficient.
-
-    After first usage, the <property_name> becomes part of the object's
-    __dict__. Doing:
-
-      del obj.<property_name> empties the cache.
-
-    Idea taken from the pyramid_ framework and the mercurial_ project.
-
-    .. _pyramid: http://pypi.python.org/pypi/pyramid
-    .. _mercurial: http://pypi.python.org/pypi/Mercurial
-    """
-    __slots__ = ('wrapped',)
-
-    def __init__(self, wrapped):
-        try:
-            wrapped.__name__
-        except AttributeError:
-            raise TypeError('%s must have a __name__ attribute' %
-                            wrapped)
-        self.wrapped = wrapped
-
-    @property
-    def __doc__(self):
-        doc = getattr(self.wrapped, '__doc__', None)
-        return ('<wrapped by the cachedproperty decorator>%s'
-                % ('\n%s' % doc if doc else ''))
-
-    def __get__(self, inst, objtype=None):
-        if inst is None:
-            return self
-        val = self.wrapped(inst)
-        setattr(inst, self.wrapped.__name__, val)
-        return val
-
-
-def get_cache_impl(obj, funcname):
-    cls = obj.__class__
-    member = getattr(cls, funcname)
-    if isinstance(member, property):
-        member = member.fget
-    return member.cache_obj
-
-def clear_cache(obj, funcname):
-    """Clear a cache handled by the :func:`cached` decorator. If 'x' class has
-    @cached on its method `foo`, type
-
-    >>> clear_cache(x, 'foo')
-
-    to purge this method's cache on the instance.
-    """
-    get_cache_impl(obj, funcname).clear(obj)
-
-def copy_cache(obj, funcname, cacheobj):
-    """Copy cache for <funcname> from cacheobj to obj."""
-    cacheattr = get_cache_impl(obj, funcname).cacheattr
-    try:
-        setattr(obj, cacheattr, cacheobj.__dict__[cacheattr])
-    except KeyError:
-        pass
-
-
-class wproperty(object):
-    """Simple descriptor expecting to take a modifier function as first argument
-    and looking for a _<function name> to retrieve the attribute.
-    """
-    def __init__(self, setfunc):
-        self.setfunc = setfunc
-        self.attrname = '_%s' % setfunc.__name__
-
-    def __set__(self, obj, value):
-        self.setfunc(obj, value)
-
-    def __get__(self, obj, cls):
-        assert obj is not None
-        return getattr(obj, self.attrname)
-
-
-class classproperty(object):
-    """this is a simple property-like class but for class attributes.
-    """
-    def __init__(self, get):
-        self.get = get
-    def __get__(self, inst, cls):
-        return self.get(cls)
-
-
-class iclassmethod(object):
-    '''Descriptor for method which should be available as class method if called
-    on the class or instance method if called on an instance.
-    '''
-    def __init__(self, func):
-        self.func = func
-    def __get__(self, instance, objtype):
-        if instance is None:
-            return method_type(self.func, objtype, objtype.__class__)
-        return method_type(self.func, instance, objtype)
-    def __set__(self, instance, value):
-        raise AttributeError("can't set attribute")
-
-
-def timed(f):
-    def wrap(*args, **kwargs):
-        t = time()
-        c = clock()
-        res = f(*args, **kwargs)
-        print '%s clock: %.9f / time: %.9f' % (f.__name__,
-                                               clock() - c, time() - t)
-        return res
-    return wrap
-
-
-def locked(acquire, release):
-    """Decorator taking two methods to acquire/release a lock as argument,
-    returning a decorator function which will call the inner method after
-    having called acquire(self) et will call release(self) afterwards.
-    """
-    def decorator(f):
-        def wrapper(self, *args, **kwargs):
-            acquire(self)
-            try:
-                return f(self, *args, **kwargs)
-            finally:
-                release(self)
-        return wrapper
-    return decorator
-
-
-def monkeypatch(klass, methodname=None):
-    """Decorator extending class with the decorated callable. This is basically
-    a syntactic sugar vs class assignment.
-
-    >>> class A:
-    ...     pass
-    >>> @monkeypatch(A)
-    ... def meth(self):
-    ...     return 12
-    ...
-    >>> a = A()
-    >>> a.meth()
-    12
-    >>> @monkeypatch(A, 'foo')
-    ... def meth(self):
-    ...     return 12
-    ...
-    >>> a.foo()
-    12
-    """
-    def decorator(func):
-        try:
-            name = methodname or func.__name__
-        except AttributeError:
-            raise AttributeError('%s has no __name__ attribute: '
-                                 'you should provide an explicit `methodname`'
-                                 % func)
-        setattr(klass, name, func)
-        return func
-    return decorator
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/deprecation.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/deprecation.py
deleted file mode 100644
index 02e4edbb..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/deprecation.py
+++ /dev/null
@@ -1,188 +0,0 @@
-# copyright 2003-2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Deprecation utilities."""
-
-__docformat__ = "restructuredtext en"
-
-import sys
-from warnings import warn
-
-from logilab.common.changelog import Version
-
-
-class DeprecationWrapper(object):
-    """proxy to print a warning on access to any attribute of the wrapped object
-    """
-    def __init__(self, proxied, msg=None):
-        self._proxied = proxied
-        self._msg = msg
-
-    def __getattr__(self, attr):
-        warn(self._msg, DeprecationWarning, stacklevel=2)
-        return getattr(self._proxied, attr)
-
-    def __setattr__(self, attr, value):
-        if attr in ('_proxied', '_msg'):
-            self.__dict__[attr] = value
-        else:
-            warn(self._msg, DeprecationWarning, stacklevel=2)
-            setattr(self._proxied, attr, value)
-
-
-class DeprecationManager(object):
-    """Manage the deprecation message handling. Messages are dropped for
-    versions more recent than the 'compatible' version. Example::
-
-        deprecator = deprecation.DeprecationManager("module_name")
-        deprecator.compatibility('1.3')
-
-        deprecator.warn('1.2', "message.")
-
-        @deprecator.deprecated('1.2', 'Message')
-        def any_func():
-            pass
-
-        class AnyClass(object):
-            __metaclass__ = deprecator.class_deprecated('1.2')
-    """
-    def __init__(self, module_name=None):
-        """
-        """
-        self.module_name = module_name
-        self.compatible_version = None
-
-    def compatibility(self, compatible_version):
-        """Set the compatible version.
-        """
-        self.compatible_version = Version(compatible_version)
-
-    def deprecated(self, version=None, reason=None, stacklevel=2, name=None, doc=None):
-        """Display a deprecation message only if the version is older than the
-        compatible version.
-        """
-        def decorator(func):
-            message = reason or 'The function "%s" is deprecated'
-            if '%s' in message:
-                message %= func.func_name
-            def wrapped(*args, **kwargs):
-                self.warn(version, message, stacklevel+1)
-                return func(*args, **kwargs)
-            return wrapped
-        return decorator
-
-    def class_deprecated(self, version=None):
-        class metaclass(type):
-            """metaclass to print a warning on instantiation of a deprecated class"""
-
-            def __call__(cls, *args, **kwargs):
-                msg = getattr(cls, "__deprecation_warning__",
-                              "%(cls)s is deprecated") % {'cls': cls.__name__}
-                self.warn(version, msg, stacklevel=3)
-                return type.__call__(cls, *args, **kwargs)
-        return metaclass
-
-    def moved(self, version, modpath, objname):
-        """use to tell that a callable has been moved to a new module.
-
-        It returns a callable wrapper, so that when its called a warning is printed
-        telling where the object can be found, import is done (and not before) and
-        the actual object is called.
-
-        NOTE: the usage is somewhat limited on classes since it will fail if the
-        wrapper is use in a class ancestors list, use the `class_moved` function
-        instead (which has no lazy import feature though).
-        """
-        def callnew(*args, **kwargs):
-            from logilab.common.modutils import load_module_from_name
-            message = "object %s has been moved to module %s" % (objname, modpath)
-            self.warn(version, message)
-            m = load_module_from_name(modpath)
-            return getattr(m, objname)(*args, **kwargs)
-        return callnew
-
-    def class_renamed(self, version, old_name, new_class, message=None):
-        clsdict = {}
-        if message is None:
-            message = '%s is deprecated, use %s' % (old_name, new_class.__name__)
-        clsdict['__deprecation_warning__'] = message
-        try:
-            # new-style class
-            return self.class_deprecated(version)(old_name, (new_class,), clsdict)
-        except (NameError, TypeError):
-            # old-style class
-            class DeprecatedClass(new_class):
-                """FIXME: There might be a better way to handle old/new-style class
-                """
-                def __init__(self, *args, **kwargs):
-                    self.warn(version, message, stacklevel=3)
-                    new_class.__init__(self, *args, **kwargs)
-            return DeprecatedClass
-
-    def class_moved(self, version, new_class, old_name=None, message=None):
-        """nice wrapper around class_renamed when a class has been moved into
-        another module
-        """
-        if old_name is None:
-            old_name = new_class.__name__
-        if message is None:
-            message = 'class %s is now available as %s.%s' % (
-                old_name, new_class.__module__, new_class.__name__)
-        return self.class_renamed(version, old_name, new_class, message)
-
-    def warn(self, version=None, reason="", stacklevel=2):
-        """Display a deprecation message only if the version is older than the
-        compatible version.
-        """
-        if (self.compatible_version is None
-            or version is None
-            or Version(version) < self.compatible_version):
-            if self.module_name and version:
-                reason = '[%s %s] %s' % (self.module_name, version, reason)
-            elif self.module_name:
-                reason = '[%s] %s' % (self.module_name, reason)
-            elif version:
-                reason = '[%s] %s' % (version, reason)
-            warn(reason, DeprecationWarning, stacklevel=stacklevel)
-
-_defaultdeprecator = DeprecationManager()
-
-def deprecated(reason=None, stacklevel=2, name=None, doc=None):
-    return _defaultdeprecator.deprecated(None, reason, stacklevel, name, doc)
-
-class_deprecated = _defaultdeprecator.class_deprecated()
-
-def moved(modpath, objname):
-    return _defaultdeprecator.moved(None, modpath, objname)
-moved.__doc__ = _defaultdeprecator.moved.__doc__
-
-def class_renamed(old_name, new_class, message=None):
-    """automatically creates a class which fires a DeprecationWarning
-    when instantiated.
-
-    >>> Set = class_renamed('Set', set, 'Set is now replaced by set')
-    >>> s = Set()
-    sample.py:57: DeprecationWarning: Set is now replaced by set
-    s = Set()
-    >>>
-    """
-    return _defaultdeprecator.class_renamed(None, old_name, new_class, message)
-
-def class_moved(new_class, old_name=None, message=None):
-    return _defaultdeprecator.class_moved(None, new_class, old_name, message)
-class_moved.__doc__ = _defaultdeprecator.class_moved.__doc__
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/graph.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/graph.py
deleted file mode 100644
index d62e8c09..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/graph.py
+++ /dev/null
@@ -1,276 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Graph manipulation utilities.
-
-(dot generation adapted from pypy/translator/tool/make_dot.py)
-"""
-
-__docformat__ = "restructuredtext en"
-
-__metaclass__ = type
-
-import os.path as osp
-import os
-import sys
-import tempfile
-import codecs
-
-def escape(value):
-    """Make <value> usable in a dot file."""
-    lines = [line.replace('"', '\\"') for line in value.split('\n')]
-    data = '\\l'.join(lines)
-    return '\\n' + data
-
-def target_info_from_filename(filename):
-    """Transforms /some/path/foo.png into ('/some/path', 'foo.png', 'png')."""
-    basename = osp.basename(filename)
-    storedir = osp.dirname(osp.abspath(filename))
-    target = filename.split('.')[-1]
-    return storedir, basename, target
-
-
-class DotBackend:
-    """Dot File backend."""
-    def __init__(self, graphname, rankdir=None, size=None, ratio=None,
-            charset='utf-8', renderer='dot', additionnal_param={}):
-        self.graphname = graphname
-        self.renderer = renderer
-        self.lines = []
-        self._source = None
-        self.emit("digraph %s {" % normalize_node_id(graphname))
-        if rankdir:
-            self.emit('rankdir=%s' % rankdir)
-        if ratio:
-            self.emit('ratio=%s' % ratio)
-        if size:
-            self.emit('size="%s"' % size)
-        if charset:
-            assert charset.lower() in ('utf-8', 'iso-8859-1', 'latin1'), \
-                   'unsupported charset %s' % charset
-            self.emit('charset="%s"' % charset)
-        for param in additionnal_param.iteritems():
-            self.emit('='.join(param))
-
-    def get_source(self):
-        """returns self._source"""
-        if self._source is None:
-            self.emit("}\n")
-            self._source = '\n'.join(self.lines)
-            del self.lines
-        return self._source
-
-    source = property(get_source)
-
-    def generate(self, outputfile=None, dotfile=None, mapfile=None):
-        """Generates a graph file.
-
-        :param outputfile: filename and path [defaults to graphname.png]
-        :param dotfile: filename and path [defaults to graphname.dot]
-
-        :rtype: str
-        :return: a path to the generated file
-        """
-        import subprocess # introduced in py 2.4
-        name = self.graphname
-        if not dotfile:
-            # if 'outputfile' is a dot file use it as 'dotfile'
-            if outputfile and outputfile.endswith(".dot"):
-                dotfile = outputfile
-            else:
-                dotfile = '%s.dot' % name
-        if outputfile is not None:
-            storedir, basename, target = target_info_from_filename(outputfile)
-            if target != "dot":
-                pdot, dot_sourcepath = tempfile.mkstemp(".dot", name)
-                os.close(pdot)
-            else:
-                dot_sourcepath = osp.join(storedir, dotfile)
-        else:
-            target = 'png'
-            pdot, dot_sourcepath = tempfile.mkstemp(".dot", name)
-            ppng, outputfile = tempfile.mkstemp(".png", name)
-            os.close(pdot)
-            os.close(ppng)
-        pdot = codecs.open(dot_sourcepath, 'w', encoding='utf8')
-        pdot.write(self.source)
-        pdot.close()
-        if target != 'dot':
-            if sys.platform == 'win32':
-                use_shell = True
-            else:
-                use_shell = False
-            if mapfile:
-                subprocess.call([self.renderer,  '-Tcmapx', '-o', mapfile, '-T', target, dot_sourcepath, '-o', outputfile],
-                                shell=use_shell)
-            else:
-                subprocess.call([self.renderer, '-T',  target,
-                                 dot_sourcepath, '-o',  outputfile],
-                                shell=use_shell)
-            os.unlink(dot_sourcepath)
-        return outputfile
-
-    def emit(self, line):
-        """Adds <line> to final output."""
-        self.lines.append(line)
-
-    def emit_edge(self, name1, name2, **props):
-        """emit an edge from <name1> to <name2>.
-        edge properties: see http://www.graphviz.org/doc/info/attrs.html
-        """
-        attrs = ['%s="%s"' % (prop, value) for prop, value in props.items()]
-        n_from, n_to = normalize_node_id(name1), normalize_node_id(name2)
-        self.emit('%s -> %s [%s];' % (n_from, n_to, ', '.join(sorted(attrs))) )
-
-    def emit_node(self, name, **props):
-        """emit a node with given properties.
-        node properties: see http://www.graphviz.org/doc/info/attrs.html
-        """
-        attrs = ['%s="%s"' % (prop, value) for prop, value in props.items()]
-        self.emit('%s [%s];' % (normalize_node_id(name), ', '.join(sorted(attrs))))
-
-def normalize_node_id(nid):
-    """Returns a suitable DOT node id for `nid`."""
-    return '"%s"' % nid
-
-class GraphGenerator:
-    def __init__(self, backend):
-        # the backend is responsible to output the graph in a particular format
-        self.backend = backend
-
-    # XXX doesn't like space in outpufile / mapfile
-    def generate(self, visitor, propshdlr, outputfile=None, mapfile=None):
-        # the visitor
-        # the property handler is used to get node and edge properties
-        # according to the graph and to the backend
-        self.propshdlr = propshdlr
-        for nodeid, node in visitor.nodes():
-            props = propshdlr.node_properties(node)
-            self.backend.emit_node(nodeid, **props)
-        for subjnode, objnode, edge in visitor.edges():
-            props = propshdlr.edge_properties(edge, subjnode, objnode)
-            self.backend.emit_edge(subjnode, objnode, **props)
-        return self.backend.generate(outputfile=outputfile, mapfile=mapfile)
-
-
-class UnorderableGraph(Exception):
-    pass
-
-def ordered_nodes(graph):
-    """takes a dependency graph dict as arguments and return an ordered tuple of
-    nodes starting with nodes without dependencies and up to the outermost node.
-
-    If there is some cycle in the graph, :exc:`UnorderableGraph` will be raised.
-
-    Also the given graph dict will be emptied.
-    """
-    # check graph consistency
-    cycles = get_cycles(graph)
-    if cycles:
-        cycles = '\n'.join([' -> '.join(cycle) for cycle in cycles])
-        raise UnorderableGraph('cycles in graph: %s' % cycles)
-    vertices = set(graph)
-    to_vertices = set()
-    for edges in graph.values():
-        to_vertices |= set(edges)
-    missing_vertices = to_vertices - vertices
-    if missing_vertices:
-        raise UnorderableGraph('missing vertices: %s' % ', '.join(missing_vertices))
-    # order vertices
-    order = []
-    order_set = set()
-    old_len = None
-    while graph:
-        if old_len == len(graph):
-            raise UnorderableGraph('unknown problem with %s' % graph)
-        old_len = len(graph)
-        deps_ok = []
-        for node, node_deps in graph.items():
-            for dep in node_deps:
-                if dep not in order_set:
-                    break
-            else:
-                deps_ok.append(node)
-        order.append(deps_ok)
-        order_set |= set(deps_ok)
-        for node in deps_ok:
-            del graph[node]
-    result = []
-    for grp in reversed(order):
-        result.extend(sorted(grp))
-    return tuple(result)
-
-
-def get_cycles(graph_dict, vertices=None):
-    '''given a dictionary representing an ordered graph (i.e. key are vertices
-    and values is a list of destination vertices representing edges), return a
-    list of detected cycles
-    '''
-    if not graph_dict:
-        return ()
-    result = []
-    if vertices is None:
-        vertices = graph_dict.keys()
-    for vertice in vertices:
-        _get_cycles(graph_dict, [], set(), result, vertice)
-    return result
-
-def _get_cycles(graph_dict, path, visited, result, vertice):
-    """recursive function doing the real work for get_cycles"""
-    if vertice in path:
-        cycle = [vertice]
-        for node in path[::-1]:
-            if node == vertice:
-                break
-            cycle.insert(0, node)
-        # make a canonical representation
-        start_from = min(cycle)
-        index = cycle.index(start_from)
-        cycle = cycle[index:] + cycle[0:index]
-        # append it to result if not already in
-        if not cycle in result:
-            result.append(cycle)
-        return
-    path.append(vertice)
-    try:
-        for node in graph_dict[vertice]:
-            # don't check already visited nodes again
-            if node not in visited:
-                _get_cycles(graph_dict, path, visited, result, node)
-                visited.add(node)
-    except KeyError:
-        pass
-    path.pop()
-
-def has_path(graph_dict, fromnode, tonode, path=None):
-    """generic function taking a simple graph definition as a dictionary, with
-    node has key associated to a list of nodes directly reachable from it.
-
-    Return None if no path exists to go from `fromnode` to `tonode`, else the
-    first path found (as a list including the destination node at last)
-    """
-    if path is None:
-        path = []
-    elif fromnode in path:
-        return None
-    path.append(fromnode)
-    for destnode in graph_dict[fromnode]:
-        if destnode == tonode or has_path(graph_dict, destnode, tonode, path):
-            return path[1:] + [tonode]
-    path.pop()
-    return None
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/interface.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/interface.py
deleted file mode 100644
index 3ea4ab7e..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/interface.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Bases class for interfaces to provide 'light' interface handling.
-
- TODO:
-  _ implements a check method which check that an object implements the
-    interface
-  _ Attribute objects
-
-  This module requires at least python 2.2
-"""
-__docformat__ = "restructuredtext en"
-
-
-class Interface(object):
-    """Base class for interfaces."""
-    def is_implemented_by(cls, instance):
-        return implements(instance, cls)
-    is_implemented_by = classmethod(is_implemented_by)
-
-
-def implements(obj, interface):
-    """Return true if the give object (maybe an instance or class) implements
-    the interface.
-    """
-    kimplements = getattr(obj, '__implements__', ())
-    if not isinstance(kimplements, (list, tuple)):
-        kimplements = (kimplements,)
-    for implementedinterface in kimplements:
-        if issubclass(implementedinterface, interface):
-            return True
-    return False
-
-
-def extend(klass, interface, _recurs=False):
-    """Add interface to klass'__implements__ if not already implemented in.
-
-    If klass is subclassed, ensure subclasses __implements__ it as well.
-
-    NOTE: klass should be e new class.
-    """
-    if not implements(klass, interface):
-        try:
-            kimplements = klass.__implements__
-            kimplementsklass = type(kimplements)
-            kimplements = list(kimplements)
-        except AttributeError:
-            kimplementsklass = tuple
-            kimplements = []
-        kimplements.append(interface)
-        klass.__implements__ = kimplementsklass(kimplements)
-        for subklass in klass.__subclasses__():
-            extend(subklass, interface, _recurs=True)
-    elif _recurs:
-        for subklass in klass.__subclasses__():
-            extend(subklass, interface, _recurs=True)
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/modutils.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/modutils.py
deleted file mode 100644
index 27568412..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/modutils.py
+++ /dev/null
@@ -1,695 +0,0 @@
-# -*- coding: utf-8 -*-
-# 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 logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Python modules manipulation utility functions.
-
-:type PY_SOURCE_EXTS: tuple(str)
-:var PY_SOURCE_EXTS: list of possible python source file extension
-
-:type STD_LIB_DIR: str
-:var STD_LIB_DIR: directory where standard modules are located
-
-:type BUILTIN_MODULES: dict
-:var BUILTIN_MODULES: dictionary with builtin module names has key
-"""
-from __future__ import with_statement
-
-__docformat__ = "restructuredtext en"
-
-import sys
-import os
-from os.path import splitext, join, abspath, isdir, dirname, exists, basename
-from imp import find_module, load_module, C_BUILTIN, PY_COMPILED, PKG_DIRECTORY
-from distutils.sysconfig import get_config_var, get_python_lib, get_python_version
-from distutils.errors import DistutilsPlatformError
-
-try:
-    import zipimport
-except ImportError:
-    zipimport = None
-
-ZIPFILE = object()
-
-from logilab.common import STD_BLACKLIST, _handle_blacklist
-
-# Notes about STD_LIB_DIR
-# Consider arch-specific installation for STD_LIB_DIR definition
-# :mod:`distutils.sysconfig` contains to much hardcoded values to rely on
-#
-# :see: `Problems with /usr/lib64 builds <http://bugs.python.org/issue1294959>`_
-# :see: `FHS <http://www.pathname.com/fhs/pub/fhs-2.3.html#LIBLTQUALGTALTERNATEFORMATESSENTIAL>`_
-if sys.platform.startswith('win'):
-    PY_SOURCE_EXTS = ('py', 'pyw')
-    PY_COMPILED_EXTS = ('dll', 'pyd')
-else:
-    PY_SOURCE_EXTS = ('py',)
-    PY_COMPILED_EXTS = ('so',)
-
-try:
-    STD_LIB_DIR = get_python_lib(standard_lib=1)
-# get_python_lib(standard_lib=1) is not available on pypy, set STD_LIB_DIR to
-# non-valid path, see https://bugs.pypy.org/issue1164
-except DistutilsPlatformError:
-    STD_LIB_DIR = '//'
-
-EXT_LIB_DIR = get_python_lib()
-
-BUILTIN_MODULES = dict(zip(sys.builtin_module_names,
-                           [1]*len(sys.builtin_module_names)))
-
-
-class NoSourceFile(Exception):
-    """exception raised when we are not able to get a python
-    source file for a precompiled file
-    """
-
-class LazyObject(object):
-    def __init__(self, module, obj):
-        self.module = module
-        self.obj = obj
-        self._imported = None
-
-    def _getobj(self):
-        if self._imported is None:
-           self._imported = getattr(load_module_from_name(self.module),
-                                    self.obj)
-        return self._imported
-
-    def __getattribute__(self, attr):
-        try:
-            return super(LazyObject, self).__getattribute__(attr)
-        except AttributeError, ex:
-            return getattr(self._getobj(), attr)
-
-    def __call__(self, *args, **kwargs):
-        return self._getobj()(*args, **kwargs)
-
-
-def load_module_from_name(dotted_name, path=None, use_sys=1):
-    """Load a Python module from its name.
-
-    :type dotted_name: str
-    :param dotted_name: python name of a module or package
-
-    :type path: list or None
-    :param path:
-      optional list of path where the module or package should be
-      searched (use sys.path if nothing or None is given)
-
-    :type use_sys: bool
-    :param use_sys:
-      boolean indicating whether the sys.modules dictionary should be
-      used or not
-
-
-    :raise ImportError: if the module or package is not found
-
-    :rtype: module
-    :return: the loaded module
-    """
-    return load_module_from_modpath(dotted_name.split('.'), path, use_sys)
-
-
-def load_module_from_modpath(parts, path=None, use_sys=1):
-    """Load a python module from its splitted name.
-
-    :type parts: list(str) or tuple(str)
-    :param parts:
-      python name of a module or package splitted on '.'
-
-    :type path: list or None
-    :param path:
-      optional list of path where the module or package should be
-      searched (use sys.path if nothing or None is given)
-
-    :type use_sys: bool
-    :param use_sys:
-      boolean indicating whether the sys.modules dictionary should be used or not
-
-    :raise ImportError: if the module or package is not found
-
-    :rtype: module
-    :return: the loaded module
-    """
-    if use_sys:
-        try:
-            return sys.modules['.'.join(parts)]
-        except KeyError:
-            pass
-    modpath = []
-    prevmodule = None
-    for part in parts:
-        modpath.append(part)
-        curname = '.'.join(modpath)
-        module = None
-        if len(modpath) != len(parts):
-            # even with use_sys=False, should try to get outer packages from sys.modules
-            module = sys.modules.get(curname)
-        elif use_sys:
-            # because it may have been indirectly loaded through a parent
-            module = sys.modules.get(curname)
-        if module is None:
-            mp_file, mp_filename, mp_desc = find_module(part, path)
-            module = load_module(curname, mp_file, mp_filename, mp_desc)
-        if prevmodule:
-            setattr(prevmodule, part, module)
-        _file = getattr(module, '__file__', '')
-        if not _file and len(modpath) != len(parts):
-            raise ImportError('no module in %s' % '.'.join(parts[len(modpath):]) )
-        path = [dirname( _file )]
-        prevmodule = module
-    return module
-
-
-def load_module_from_file(filepath, path=None, use_sys=1, extrapath=None):
-    """Load a Python module from it's path.
-
-    :type filepath: str
-    :param filepath: path to the python module or package
-
-    :type path: list or None
-    :param path:
-      optional list of path where the module or package should be
-      searched (use sys.path if nothing or None is given)
-
-    :type use_sys: bool
-    :param use_sys:
-      boolean indicating whether the sys.modules dictionary should be
-      used or not
-
-
-    :raise ImportError: if the module or package is not found
-
-    :rtype: module
-    :return: the loaded module
-    """
-    modpath = modpath_from_file(filepath, extrapath)
-    return load_module_from_modpath(modpath, path, use_sys)
-
-
-def _check_init(path, mod_path):
-    """check there are some __init__.py all along the way"""
-    for part in mod_path:
-        path = join(path, part)
-        if not _has_init(path):
-            return False
-    return True
-
-
-def modpath_from_file(filename, extrapath=None):
-    """given a file path return the corresponding splitted module's name
-    (i.e name of a module or package splitted on '.')
-
-    :type filename: str
-    :param filename: file's path for which we want the module's name
-
-    :type extrapath: dict
-    :param extrapath:
-      optional extra search path, with path as key and package name for the path
-      as value. This is usually useful to handle package splitted in multiple
-      directories using __path__ trick.
-
-
-    :raise ImportError:
-      if the corresponding module's name has not been found
-
-    :rtype: list(str)
-    :return: the corresponding splitted module's name
-    """
-    base = splitext(abspath(filename))[0]
-    if extrapath is not None:
-        for path_ in extrapath:
-            path = abspath(path_)
-            if path and base[:len(path)] == path:
-                submodpath = [pkg for pkg in base[len(path):].split(os.sep)
-                              if pkg]
-                if _check_init(path, submodpath[:-1]):
-                    return extrapath[path_].split('.') + submodpath
-    for path in sys.path:
-        path = abspath(path)
-        if path and base.startswith(path):
-            modpath = [pkg for pkg in base[len(path):].split(os.sep) if pkg]
-            if _check_init(path, modpath[:-1]):
-                return modpath
-    raise ImportError('Unable to find module for %s in %s' % (
-        filename, ', \n'.join(sys.path)))
-
-
-
-def file_from_modpath(modpath, path=None, context_file=None):
-    """given a mod path (i.e. splitted module / package name), return the
-    corresponding file, giving priority to source file over precompiled
-    file if it exists
-
-    :type modpath: list or tuple
-    :param modpath:
-      splitted module's name (i.e name of a module or package splitted
-      on '.')
-      (this means explicit relative imports that start with dots have
-      empty strings in this list!)
-
-    :type path: list or None
-    :param path:
-      optional list of path where the module or package should be
-      searched (use sys.path if nothing or None is given)
-
-    :type context_file: str or None
-    :param context_file:
-      context file to consider, necessary if the identifier has been
-      introduced using a relative import unresolvable in the actual
-      context (i.e. modutils)
-
-    :raise ImportError: if there is no such module in the directory
-
-    :rtype: str or None
-    :return:
-      the path to the module's file or None if it's an integrated
-      builtin module such as 'sys'
-    """
-    if context_file is not None:
-        context = dirname(context_file)
-    else:
-        context = context_file
-    if modpath[0] == 'xml':
-        # handle _xmlplus
-        try:
-            return _file_from_modpath(['_xmlplus'] + modpath[1:], path, context)
-        except ImportError:
-            return _file_from_modpath(modpath, path, context)
-    elif modpath == ['os', 'path']:
-        # FIXME: currently ignoring search_path...
-        return os.path.__file__
-    return _file_from_modpath(modpath, path, context)
-
-
-
-def get_module_part(dotted_name, context_file=None):
-    """given a dotted name return the module part of the name :
-
-    >>> get_module_part('logilab.common.modutils.get_module_part')
-    'logilab.common.modutils'
-
-    :type dotted_name: str
-    :param dotted_name: full name of the identifier we are interested in
-
-    :type context_file: str or None
-    :param context_file:
-      context file to consider, necessary if the identifier has been
-      introduced using a relative import unresolvable in the actual
-      context (i.e. modutils)
-
-
-    :raise ImportError: if there is no such module in the directory
-
-    :rtype: str or None
-    :return:
-      the module part of the name or None if we have not been able at
-      all to import the given name
-
-    XXX: deprecated, since it doesn't handle package precedence over module
-    (see #10066)
-    """
-    # os.path trick
-    if dotted_name.startswith('os.path'):
-        return 'os.path'
-    parts = dotted_name.split('.')
-    if context_file is not None:
-        # first check for builtin module which won't be considered latter
-        # in that case (path != None)
-        if parts[0] in BUILTIN_MODULES:
-            if len(parts) > 2:
-                raise ImportError(dotted_name)
-            return parts[0]
-        # don't use += or insert, we want a new list to be created !
-    path = None
-    starti = 0
-    if parts[0] == '':
-        assert context_file is not None, \
-                'explicit relative import, but no context_file?'
-        path = [] # prevent resolving the import non-relatively
-        starti = 1
-    while parts[starti] == '': # for all further dots: change context
-        starti += 1
-        context_file = dirname(context_file)
-    for i in range(starti, len(parts)):
-        try:
-            file_from_modpath(parts[starti:i+1],
-                    path=path, context_file=context_file)
-        except ImportError:
-            if not i >= max(1, len(parts) - 2):
-                raise
-            return '.'.join(parts[:i])
-    return dotted_name
-
-
-def get_modules(package, src_directory, blacklist=STD_BLACKLIST):
-    """given a package directory return a list of all available python
-    modules in the package and its subpackages
-
-    :type package: str
-    :param package: the python name for the package
-
-    :type src_directory: str
-    :param src_directory:
-      path of the directory corresponding to the package
-
-    :type blacklist: list or tuple
-    :param blacklist:
-      optional list of files or directory to ignore, default to
-      the value of `logilab.common.STD_BLACKLIST`
-
-    :rtype: list
-    :return:
-      the list of all available python modules in the package and its
-      subpackages
-    """
-    modules = []
-    for directory, dirnames, filenames in os.walk(src_directory):
-        _handle_blacklist(blacklist, dirnames, filenames)
-        # check for __init__.py
-        if not '__init__.py' in filenames:
-            dirnames[:] = ()
-            continue
-        if directory != src_directory:
-            dir_package = directory[len(src_directory):].replace(os.sep, '.')
-            modules.append(package + dir_package)
-        for filename in filenames:
-            if _is_python_file(filename) and filename != '__init__.py':
-                src = join(directory, filename)
-                module = package + src[len(src_directory):-3]
-                modules.append(module.replace(os.sep, '.'))
-    return modules
-
-
-
-def get_module_files(src_directory, blacklist=STD_BLACKLIST):
-    """given a package directory return a list of all available python
-    module's files in the package and its subpackages
-
-    :type src_directory: str
-    :param src_directory:
-      path of the directory corresponding to the package
-
-    :type blacklist: list or tuple
-    :param blacklist:
-      optional list of files or directory to ignore, default to the value of
-      `logilab.common.STD_BLACKLIST`
-
-    :rtype: list
-    :return:
-      the list of all available python module's files in the package and
-      its subpackages
-    """
-    files = []
-    for directory, dirnames, filenames in os.walk(src_directory):
-        _handle_blacklist(blacklist, dirnames, filenames)
-        # check for __init__.py
-        if not '__init__.py' in filenames:
-            dirnames[:] = ()
-            continue
-        for filename in filenames:
-            if _is_python_file(filename):
-                src = join(directory, filename)
-                files.append(src)
-    return files
-
-
-def get_source_file(filename, include_no_ext=False):
-    """given a python module's file name return the matching source file
-    name (the filename will be returned identically if it's a already an
-    absolute path to a python source file...)
-
-    :type filename: str
-    :param filename: python module's file name
-
-
-    :raise NoSourceFile: if no source file exists on the file system
-
-    :rtype: str
-    :return: the absolute path of the source file if it exists
-    """
-    base, orig_ext = splitext(abspath(filename))
-    for ext in PY_SOURCE_EXTS:
-        source_path = '%s.%s' % (base, ext)
-        if exists(source_path):
-            return source_path
-    if include_no_ext and not orig_ext and exists(base):
-        return base
-    raise NoSourceFile(filename)
-
-
-def cleanup_sys_modules(directories):
-    """remove submodules of `directories` from `sys.modules`"""
-    for modname, module in sys.modules.items():
-        modfile = getattr(module, '__file__', None)
-        if modfile:
-            for directory in directories:
-                if modfile.startswith(directory):
-                    del sys.modules[modname]
-                    break
-
-
-def is_python_source(filename):
-    """
-    rtype: bool
-    return: True if the filename is a python source file
-    """
-    return splitext(filename)[1][1:] in PY_SOURCE_EXTS
-
-
-
-def is_standard_module(modname, std_path=(STD_LIB_DIR,)):
-    """try to guess if a module is a standard python module (by default,
-    see `std_path` parameter's description)
-
-    :type modname: str
-    :param modname: name of the module we are interested in
-
-    :type std_path: list(str) or tuple(str)
-    :param std_path: list of path considered has standard
-
-
-    :rtype: bool
-    :return:
-      true if the module:
-      - is located on the path listed in one of the directory in `std_path`
-      - is a built-in module
-    """
-    modname = modname.split('.')[0]
-    try:
-        filename = file_from_modpath([modname])
-    except ImportError, ex:
-        # import failed, i'm probably not so wrong by supposing it's
-        # not standard...
-        return 0
-    # modules which are not living in a file are considered standard
-    # (sys and __builtin__ for instance)
-    if filename is None:
-        return 1
-    filename = abspath(filename)
-    if filename.startswith(EXT_LIB_DIR):
-        return 0
-    for path in std_path:
-        if filename.startswith(abspath(path)):
-            return 1
-    return False
-
-
-
-def is_relative(modname, from_file):
-    """return true if the given module name is relative to the given
-    file name
-
-    :type modname: str
-    :param modname: name of the module we are interested in
-
-    :type from_file: str
-    :param from_file:
-      path of the module from which modname has been imported
-
-    :rtype: bool
-    :return:
-      true if the module has been imported relatively to `from_file`
-    """
-    if not isdir(from_file):
-        from_file = dirname(from_file)
-    if from_file in sys.path:
-        return False
-    try:
-        find_module(modname.split('.')[0], [from_file])
-        return True
-    except ImportError:
-        return False
-
-
-# internal only functions #####################################################
-
-def _file_from_modpath(modpath, path=None, context=None):
-    """given a mod path (i.e. splitted module / package name), return the
-    corresponding file
-
-    this function is used internally, see `file_from_modpath`'s
-    documentation for more information
-    """
-    assert len(modpath) > 0
-    if context is not None:
-        try:
-            mtype, mp_filename = _module_file(modpath, [context])
-        except ImportError:
-            mtype, mp_filename = _module_file(modpath, path)
-    else:
-        mtype, mp_filename = _module_file(modpath, path)
-    if mtype == PY_COMPILED:
-        try:
-            return get_source_file(mp_filename)
-        except NoSourceFile:
-            return mp_filename
-    elif mtype == C_BUILTIN:
-        # integrated builtin module
-        return None
-    elif mtype == PKG_DIRECTORY:
-        mp_filename = _has_init(mp_filename)
-    return mp_filename
-
-def _search_zip(modpath, pic):
-    for filepath, importer in pic.items():
-        if importer is not None:
-            if importer.find_module(modpath[0]):
-                if not importer.find_module('/'.join(modpath)):
-                    raise ImportError('No module named %s in %s/%s' % (
-                        '.'.join(modpath[1:]), filepath, modpath))
-                return ZIPFILE, abspath(filepath) + '/' + '/'.join(modpath), filepath
-    raise ImportError('No module named %s' % '.'.join(modpath))
-
-try:
-    import pkg_resources
-except ImportError:
-    pkg_resources = None
-
-def _module_file(modpath, path=None):
-    """get a module type / file path
-
-    :type modpath: list or tuple
-    :param modpath:
-      splitted module's name (i.e name of a module or package splitted
-      on '.'), with leading empty strings for explicit relative import
-
-    :type path: list or None
-    :param path:
-      optional list of path where the module or package should be
-      searched (use sys.path if nothing or None is given)
-
-
-    :rtype: tuple(int, str)
-    :return: the module type flag and the file path for a module
-    """
-    # egg support compat
-    try:
-        pic = sys.path_importer_cache
-        _path = (path is None and sys.path or path)
-        for __path in _path:
-            if not __path in pic:
-                try:
-                    pic[__path] = zipimport.zipimporter(__path)
-                except zipimport.ZipImportError:
-                    pic[__path] = None
-        checkeggs = True
-    except AttributeError:
-        checkeggs = False
-    # pkg_resources support (aka setuptools namespace packages)
-    if pkg_resources is not None and modpath[0] in pkg_resources._namespace_packages and len(modpath) > 1:
-        # setuptools has added into sys.modules a module object with proper
-        # __path__, get back information from there
-        module = sys.modules[modpath.pop(0)]
-        path = module.__path__
-    imported = []
-    while modpath:
-        modname = modpath[0]
-        # take care to changes in find_module implementation wrt builtin modules
-        #
-        # Python 2.6.6 (r266:84292, Sep 11 2012, 08:34:23)
-        # >>> imp.find_module('posix')
-        # (None, 'posix', ('', '', 6))
-        #
-        # Python 3.3.1 (default, Apr 26 2013, 12:08:46)
-        # >>> imp.find_module('posix')
-        # (None, None, ('', '', 6))
-        try:
-            _, mp_filename, mp_desc = find_module(modname, path)
-        except ImportError:
-            if checkeggs:
-                return _search_zip(modpath, pic)[:2]
-            raise
-        else:
-            if checkeggs and mp_filename:
-                fullabspath = [abspath(x) for x in _path]
-                try:
-                    pathindex = fullabspath.index(dirname(abspath(mp_filename)))
-                    emtype, emp_filename, zippath = _search_zip(modpath, pic)
-                    if pathindex > _path.index(zippath):
-                        # an egg takes priority
-                        return emtype, emp_filename
-                except ValueError:
-                    # XXX not in _path
-                    pass
-                except ImportError:
-                    pass
-                checkeggs = False
-        imported.append(modpath.pop(0))
-        mtype = mp_desc[2]
-        if modpath:
-            if mtype != PKG_DIRECTORY:
-                raise ImportError('No module %s in %s' % ('.'.join(modpath),
-                                                          '.'.join(imported)))
-            # XXX guess if package is using pkgutil.extend_path by looking for
-            # those keywords in the first four Kbytes
-            try:
-                with open(join(mp_filename, '__init__.py')) as stream:
-                    data = stream.read(4096)
-            except IOError:
-                path = [mp_filename]
-            else:
-                if 'pkgutil' in data and 'extend_path' in data:
-                    # extend_path is called, search sys.path for module/packages
-                    # of this name see pkgutil.extend_path documentation
-                    path = [join(p, *imported) for p in sys.path
-                            if isdir(join(p, *imported))]
-                else:
-                    path = [mp_filename]
-    return mtype, mp_filename
-
-def _is_python_file(filename):
-    """return true if the given filename should be considered as a python file
-
-    .pyc and .pyo are ignored
-    """
-    for ext in ('.py', '.so', '.pyd', '.pyw'):
-        if filename.endswith(ext):
-            return True
-    return False
-
-
-def _has_init(directory):
-    """if the given directory has a valid __init__ file, return its path,
-    else return None
-    """
-    mod_or_pack = join(directory, '__init__')
-    for ext in PY_SOURCE_EXTS + ('pyc', 'pyo'):
-        if exists(mod_or_pack + '.' + ext):
-            return mod_or_pack + '.' + ext
-    return None
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/optik_ext.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/optik_ext.py
deleted file mode 100644
index 49d685b1..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/optik_ext.py
+++ /dev/null
@@ -1,391 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Add an abstraction level to transparently import optik classes from optparse
-(python >= 2.3) or the optik package.
-
-It also defines three new types for optik/optparse command line parser :
-
-  * regexp
-    argument of this type will be converted using re.compile
-  * csv
-    argument of this type will be converted using split(',')
-  * yn
-    argument of this type will be true if 'y' or 'yes', false if 'n' or 'no'
-  * named
-    argument of this type are in the form <NAME>=<VALUE> or <NAME>:<VALUE>
-  * password
-    argument of this type wont be converted but this is used by other tools
-    such as interactive prompt for configuration to double check value and
-    use an invisible field
-  * multiple_choice
-    same as default "choice" type but multiple choices allowed
-  * file
-    argument of this type wont be converted but checked that the given file exists
-  * color
-    argument of this type wont be converted but checked its either a
-    named color or a color specified using hexadecimal notation (preceded by a #)
-  * time
-    argument of this type will be converted to a float value in seconds
-    according to time units (ms, s, min, h, d)
-  * bytes
-    argument of this type will be converted to a float value in bytes
-    according to byte units (b, kb, mb, gb, tb)
-"""
-__docformat__ = "restructuredtext en"
-
-import re
-import sys
-import time
-from copy import copy
-from os.path import exists
-
-# python >= 2.3
-from optparse import OptionParser as BaseParser, Option as BaseOption, \
-     OptionGroup, OptionContainer, OptionValueError, OptionError, \
-     Values, HelpFormatter, NO_DEFAULT, SUPPRESS_HELP
-
-try:
-    from mx import DateTime
-    HAS_MX_DATETIME = True
-except ImportError:
-    HAS_MX_DATETIME = False
-
-from logilab.common.textutils import splitstrip
-
-def check_regexp(option, opt, value):
-    """check a regexp value by trying to compile it
-    return the compiled regexp
-    """
-    if hasattr(value, 'pattern'):
-        return value
-    try:
-        return re.compile(value)
-    except ValueError:
-        raise OptionValueError(
-            "option %s: invalid regexp value: %r" % (opt, value))
-
-def check_csv(option, opt, value):
-    """check a csv value by trying to split it
-    return the list of separated values
-    """
-    if isinstance(value, (list, tuple)):
-        return value
-    try:
-        return splitstrip(value)
-    except ValueError:
-        raise OptionValueError(
-            "option %s: invalid csv value: %r" % (opt, value))
-
-def check_yn(option, opt, value):
-    """check a yn value
-    return true for yes and false for no
-    """
-    if isinstance(value, int):
-        return bool(value)
-    if value in ('y', 'yes'):
-        return True
-    if value in ('n', 'no'):
-        return False
-    msg = "option %s: invalid yn value %r, should be in (y, yes, n, no)"
-    raise OptionValueError(msg % (opt, value))
-
-def check_named(option, opt, value):
-    """check a named value
-    return a dictionary containing (name, value) associations
-    """
-    if isinstance(value, dict):
-        return value
-    values = []
-    for value in check_csv(option, opt, value):
-        if value.find('=') != -1:
-            values.append(value.split('=', 1))
-        elif value.find(':') != -1:
-            values.append(value.split(':', 1))
-    if values:
-        return dict(values)
-    msg = "option %s: invalid named value %r, should be <NAME>=<VALUE> or \
-<NAME>:<VALUE>"
-    raise OptionValueError(msg % (opt, value))
-
-def check_password(option, opt, value):
-    """check a password value (can't be empty)
-    """
-    # no actual checking, monkey patch if you want more
-    return value
-
-def check_file(option, opt, value):
-    """check a file value
-    return the filepath
-    """
-    if exists(value):
-        return value
-    msg = "option %s: file %r does not exist"
-    raise OptionValueError(msg % (opt, value))
-
-# XXX use python datetime
-def check_date(option, opt, value):
-    """check a file value
-    return the filepath
-    """
-    try:
-        return DateTime.strptime(value, "%Y/%m/%d")
-    except DateTime.Error :
-        raise OptionValueError(
-            "expected format of %s is yyyy/mm/dd" % opt)
-
-def check_color(option, opt, value):
-    """check a color value and returns it
-    /!\ does *not* check color labels (like 'red', 'green'), only
-    checks hexadecimal forms
-    """
-    # Case (1) : color label, we trust the end-user
-    if re.match('[a-z0-9 ]+$', value, re.I):
-        return value
-    # Case (2) : only accepts hexadecimal forms
-    if re.match('#[a-f0-9]{6}', value, re.I):
-        return value
-    # Else : not a color label neither a valid hexadecimal form => error
-    msg = "option %s: invalid color : %r, should be either hexadecimal \
-    value or predefined color"
-    raise OptionValueError(msg % (opt, value))
-
-def check_time(option, opt, value):
-    from logilab.common.textutils import TIME_UNITS, apply_units
-    if isinstance(value, (int, long, float)):
-        return value
-    return apply_units(value, TIME_UNITS)
-
-def check_bytes(option, opt, value):
-    from logilab.common.textutils import BYTE_UNITS, apply_units
-    if hasattr(value, '__int__'):
-        return value
-    return apply_units(value, BYTE_UNITS)
-
-import types
-
-class Option(BaseOption):
-    """override optik.Option to add some new option types
-    """
-    TYPES = BaseOption.TYPES + ('regexp', 'csv', 'yn', 'named', 'password',
-                                'multiple_choice', 'file', 'color',
-                                'time', 'bytes')
-    ATTRS = BaseOption.ATTRS + ['hide', 'level']
-    TYPE_CHECKER = copy(BaseOption.TYPE_CHECKER)
-    TYPE_CHECKER['regexp'] = check_regexp
-    TYPE_CHECKER['csv'] = check_csv
-    TYPE_CHECKER['yn'] = check_yn
-    TYPE_CHECKER['named'] = check_named
-    TYPE_CHECKER['multiple_choice'] = check_csv
-    TYPE_CHECKER['file'] = check_file
-    TYPE_CHECKER['color'] = check_color
-    TYPE_CHECKER['password'] = check_password
-    TYPE_CHECKER['time'] = check_time
-    TYPE_CHECKER['bytes'] = check_bytes
-    if HAS_MX_DATETIME:
-        TYPES += ('date',)
-        TYPE_CHECKER['date'] = check_date
-
-    def __init__(self, *opts, **attrs):
-        BaseOption.__init__(self, *opts, **attrs)
-        if hasattr(self, "hide") and self.hide:
-            self.help = SUPPRESS_HELP
-
-    def _check_choice(self):
-        """FIXME: need to override this due to optik misdesign"""
-        if self.type in ("choice", "multiple_choice"):
-            if self.choices is None:
-                raise OptionError(
-                    "must supply a list of choices for type 'choice'", self)
-            elif type(self.choices) not in (types.TupleType, types.ListType):
-                raise OptionError(
-                    "choices must be a list of strings ('%s' supplied)"
-                    % str(type(self.choices)).split("'")[1], self)
-        elif self.choices is not None:
-            raise OptionError(
-                "must not supply choices for type %r" % self.type, self)
-    BaseOption.CHECK_METHODS[2] = _check_choice
-
-
-    def process(self, opt, value, values, parser):
-        # First, convert the value(s) to the right type.  Howl if any
-        # value(s) are bogus.
-        value = self.convert_value(opt, value)
-        if self.type == 'named':
-            existant = getattr(values, self.dest)
-            if existant:
-                existant.update(value)
-                value = existant
-       # And then take whatever action is expected of us.
-        # This is a separate method to make life easier for
-        # subclasses to add new actions.
-        return self.take_action(
-            self.action, self.dest, opt, value, values, parser)
-
-
-class OptionParser(BaseParser):
-    """override optik.OptionParser to use our Option class
-    """
-    def __init__(self, option_class=Option, *args, **kwargs):
-        BaseParser.__init__(self, option_class=Option, *args, **kwargs)
-
-    def format_option_help(self, formatter=None):
-        if formatter is None:
-            formatter = self.formatter
-        outputlevel = getattr(formatter, 'output_level', 0)
-        formatter.store_option_strings(self)
-        result = []
-        result.append(formatter.format_heading("Options"))
-        formatter.indent()
-        if self.option_list:
-            result.append(OptionContainer.format_option_help(self, formatter))
-            result.append("\n")
-        for group in self.option_groups:
-            if group.level <= outputlevel and (
-                group.description or level_options(group, outputlevel)):
-                result.append(group.format_help(formatter))
-                result.append("\n")
-        formatter.dedent()
-        # Drop the last "\n", or the header if no options or option groups:
-        return "".join(result[:-1])
-
-
-OptionGroup.level = 0
-
-def level_options(group, outputlevel):
-    return [option for option in group.option_list
-            if (getattr(option, 'level', 0) or 0) <= outputlevel
-            and not option.help is SUPPRESS_HELP]
-
-def format_option_help(self, formatter):
-    result = []
-    outputlevel = getattr(formatter, 'output_level', 0) or 0
-    for option in level_options(self, outputlevel):
-        result.append(formatter.format_option(option))
-    return "".join(result)
-OptionContainer.format_option_help = format_option_help
-
-
-class ManHelpFormatter(HelpFormatter):
-    """Format help using man pages ROFF format"""
-
-    def __init__ (self,
-                  indent_increment=0,
-                  max_help_position=24,
-                  width=79,
-                  short_first=0):
-        HelpFormatter.__init__ (
-            self, indent_increment, max_help_position, width, short_first)
-
-    def format_heading(self, heading):
-        return '.SH %s\n' % heading.upper()
-
-    def format_description(self, description):
-        return description
-
-    def format_option(self, option):
-        try:
-            optstring = option.option_strings
-        except AttributeError:
-            optstring = self.format_option_strings(option)
-        if option.help:
-            help_text = self.expand_default(option)
-            help = ' '.join([l.strip() for l in help_text.splitlines()])
-        else:
-            help = ''
-        return '''.IP "%s"
-%s
-''' % (optstring, help)
-
-    def format_head(self, optparser, pkginfo, section=1):
-        long_desc = ""
-        try:
-            pgm = optparser._get_prog_name()
-        except AttributeError:
-            # py >= 2.4.X (dunno which X exactly, at least 2)
-            pgm = optparser.get_prog_name()
-        short_desc = self.format_short_description(pgm, pkginfo.description)
-        if hasattr(pkginfo, "long_desc"):
-            long_desc = self.format_long_description(pgm, pkginfo.long_desc)
-        return '%s\n%s\n%s\n%s' % (self.format_title(pgm, section),
-                                   short_desc, self.format_synopsis(pgm),
-                                   long_desc)
-
-    def format_title(self, pgm, section):
-        date = '-'.join([str(num) for num in time.localtime()[:3]])
-        return '.TH %s %s "%s" %s' % (pgm, section, date, pgm)
-
-    def format_short_description(self, pgm, short_desc):
-        return '''.SH NAME
-.B %s
-\- %s
-''' % (pgm, short_desc.strip())
-
-    def format_synopsis(self, pgm):
-        return '''.SH SYNOPSIS
-.B  %s
-[
-.I OPTIONS
-] [
-.I <arguments>
-]
-''' % pgm
-
-    def format_long_description(self, pgm, long_desc):
-        long_desc = '\n'.join([line.lstrip()
-                               for line in long_desc.splitlines()])
-        long_desc = long_desc.replace('\n.\n', '\n\n')
-        if long_desc.lower().startswith(pgm):
-            long_desc = long_desc[len(pgm):]
-        return '''.SH DESCRIPTION
-.B %s
-%s
-''' % (pgm, long_desc.strip())
-
-    def format_tail(self, pkginfo):
-        tail = '''.SH SEE ALSO
-/usr/share/doc/pythonX.Y-%s/
-
-.SH BUGS
-Please report bugs on the project\'s mailing list:
-%s
-
-.SH AUTHOR
-%s <%s>
-''' % (getattr(pkginfo, 'debian_name', pkginfo.modname),
-       pkginfo.mailinglist, pkginfo.author, pkginfo.author_email)
-
-        if hasattr(pkginfo, "copyright"):
-            tail += '''
-.SH COPYRIGHT
-%s
-''' % pkginfo.copyright
-
-        return tail
-
-def generate_manpage(optparser, pkginfo, section=1, stream=sys.stdout, level=0):
-    """generate a man page from an optik parser"""
-    formatter = ManHelpFormatter()
-    formatter.output_level = level
-    formatter.parser = optparser
-    print >> stream, formatter.format_head(optparser, pkginfo, section)
-    print >> stream, optparser.format_option_help(formatter)
-    print >> stream, formatter.format_tail(pkginfo)
-
-
-__all__ = ('OptionParser', 'Option', 'OptionGroup', 'OptionValueError',
-           'Values')
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/textutils.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/textutils.py
deleted file mode 100644
index f55c0040..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/textutils.py
+++ /dev/null
@@ -1,534 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Some text manipulation utility functions.
-
-
-:group text formatting: normalize_text, normalize_paragraph, pretty_match,\
-unquote, colorize_ansi
-:group text manipulation: searchall, splitstrip
-:sort: text formatting, text manipulation
-
-:type ANSI_STYLES: dict(str)
-:var ANSI_STYLES: dictionary mapping style identifier to ANSI terminal code
-
-:type ANSI_COLORS: dict(str)
-:var ANSI_COLORS: dictionary mapping color identifier to ANSI terminal code
-
-:type ANSI_PREFIX: str
-:var ANSI_PREFIX:
-  ANSI terminal code notifying the start of an ANSI escape sequence
-
-:type ANSI_END: str
-:var ANSI_END:
-  ANSI terminal code notifying the end of an ANSI escape sequence
-
-:type ANSI_RESET: str
-:var ANSI_RESET:
-  ANSI terminal code resetting format defined by a previous ANSI escape sequence
-"""
-__docformat__ = "restructuredtext en"
-
-import sys
-import re
-import os.path as osp
-from warnings import warn
-from unicodedata import normalize as _uninormalize
-try:
-    from os import linesep
-except ImportError:
-    linesep = '\n' # gae
-
-from logilab.common.deprecation import deprecated
-
-MANUAL_UNICODE_MAP = {
-    u'\xa1': u'!',    # INVERTED EXCLAMATION MARK
-    u'\u0142': u'l',  # LATIN SMALL LETTER L WITH STROKE
-    u'\u2044': u'/',  # FRACTION SLASH
-    u'\xc6': u'AE',   # LATIN CAPITAL LETTER AE
-    u'\xa9': u'(c)',  # COPYRIGHT SIGN
-    u'\xab': u'"',    # LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
-    u'\xe6': u'ae',   # LATIN SMALL LETTER AE
-    u'\xae': u'(r)',  # REGISTERED SIGN
-    u'\u0153': u'oe', # LATIN SMALL LIGATURE OE
-    u'\u0152': u'OE', # LATIN CAPITAL LIGATURE OE
-    u'\xd8': u'O',    # LATIN CAPITAL LETTER O WITH STROKE
-    u'\xf8': u'o',    # LATIN SMALL LETTER O WITH STROKE
-    u'\xbb': u'"',    # RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
-    u'\xdf': u'ss',   # LATIN SMALL LETTER SHARP S
-    }
-
-def unormalize(ustring, ignorenonascii=None, substitute=None):
-    """replace diacritical characters with their corresponding ascii characters
-
-    Convert the unicode string to its long normalized form (unicode character
-    will be transform into several characters) and keep the first one only.
-    The normal form KD (NFKD) will apply the compatibility decomposition, i.e.
-    replace all compatibility characters with their equivalents.
-
-    :type substitute: str
-    :param substitute: replacement character to use if decomposition fails
-
-    :see: Another project about ASCII transliterations of Unicode text
-          http://pypi.python.org/pypi/Unidecode
-    """
-    # backward compatibility, ignorenonascii was a boolean
-    if ignorenonascii is not None:
-        warn("ignorenonascii is deprecated, use substitute named parameter instead",
-             DeprecationWarning, stacklevel=2)
-        if ignorenonascii:
-            substitute = ''
-    res = []
-    for letter in ustring[:]:
-        try:
-            replacement = MANUAL_UNICODE_MAP[letter]
-        except KeyError:
-            replacement = _uninormalize('NFKD', letter)[0]
-            if ord(replacement) >= 2 ** 7:
-                if substitute is None:
-                    raise ValueError("can't deal with non-ascii based characters")
-                replacement = substitute
-        res.append(replacement)
-    return u''.join(res)
-
-def unquote(string):
-    """remove optional quotes (simple or double) from the string
-
-    :type string: str or unicode
-    :param string: an optionally quoted string
-
-    :rtype: str or unicode
-    :return: the unquoted string (or the input string if it wasn't quoted)
-    """
-    if not string:
-        return string
-    if string[0] in '"\'':
-        string = string[1:]
-    if string[-1] in '"\'':
-        string = string[:-1]
-    return string
-
-
-_BLANKLINES_RGX = re.compile('\r?\n\r?\n')
-_NORM_SPACES_RGX = re.compile('\s+')
-
-def normalize_text(text, line_len=80, indent='', rest=False):
-    """normalize a text to display it with a maximum line size and
-    optionally arbitrary indentation. Line jumps are normalized but blank
-    lines are kept. The indentation string may be used to insert a
-    comment (#) or a quoting (>) mark  for instance.
-
-    :type text: str or unicode
-    :param text: the input text to normalize
-
-    :type line_len: int
-    :param line_len: expected maximum line's length, default to 80
-
-    :type indent: str or unicode
-    :param indent: optional string to use as indentation
-
-    :rtype: str or unicode
-    :return:
-      the input text normalized to fit on lines with a maximized size
-      inferior to `line_len`, and optionally prefixed by an
-      indentation string
-    """
-    if rest:
-        normp = normalize_rest_paragraph
-    else:
-        normp = normalize_paragraph
-    result = []
-    for text in _BLANKLINES_RGX.split(text):
-        result.append(normp(text, line_len, indent))
-    return ('%s%s%s' % (linesep, indent, linesep)).join(result)
-
-
-def normalize_paragraph(text, line_len=80, indent=''):
-    """normalize a text to display it with a maximum line size and
-    optionally arbitrary indentation. Line jumps are normalized. The
-    indentation string may be used top insert a comment mark for
-    instance.
-
-    :type text: str or unicode
-    :param text: the input text to normalize
-
-    :type line_len: int
-    :param line_len: expected maximum line's length, default to 80
-
-    :type indent: str or unicode
-    :param indent: optional string to use as indentation
-
-    :rtype: str or unicode
-    :return:
-      the input text normalized to fit on lines with a maximized size
-      inferior to `line_len`, and optionally prefixed by an
-      indentation string
-    """
-    text = _NORM_SPACES_RGX.sub(' ', text)
-    line_len = line_len - len(indent)
-    lines = []
-    while text:
-        aline, text = splittext(text.strip(), line_len)
-        lines.append(indent + aline)
-    return linesep.join(lines)
-
-def normalize_rest_paragraph(text, line_len=80, indent=''):
-    """normalize a ReST text to display it with a maximum line size and
-    optionally arbitrary indentation. Line jumps are normalized. The
-    indentation string may be used top insert a comment mark for
-    instance.
-
-    :type text: str or unicode
-    :param text: the input text to normalize
-
-    :type line_len: int
-    :param line_len: expected maximum line's length, default to 80
-
-    :type indent: str or unicode
-    :param indent: optional string to use as indentation
-
-    :rtype: str or unicode
-    :return:
-      the input text normalized to fit on lines with a maximized size
-      inferior to `line_len`, and optionally prefixed by an
-      indentation string
-    """
-    toreport = ''
-    lines = []
-    line_len = line_len - len(indent)
-    for line in text.splitlines():
-        line = toreport + _NORM_SPACES_RGX.sub(' ', line.strip())
-        toreport = ''
-        while len(line) > line_len:
-            # too long line, need split
-            line, toreport = splittext(line, line_len)
-            lines.append(indent + line)
-            if toreport:
-                line = toreport + ' '
-                toreport = ''
-            else:
-                line = ''
-        if line:
-            lines.append(indent + line.strip())
-    return linesep.join(lines)
-
-
-def splittext(text, line_len):
-    """split the given text on space according to the given max line size
-
-    return a 2-uple:
-    * a line <= line_len if possible
-    * the rest of the text which has to be reported on another line
-    """
-    if len(text) <= line_len:
-        return text, ''
-    pos = min(len(text)-1, line_len)
-    while pos > 0 and text[pos] != ' ':
-        pos -= 1
-    if pos == 0:
-        pos = min(len(text), line_len)
-        while len(text) > pos and text[pos] != ' ':
-            pos += 1
-    return text[:pos], text[pos+1:].strip()
-
-
-def splitstrip(string, sep=','):
-    """return a list of stripped string by splitting the string given as
-    argument on `sep` (',' by default). Empty string are discarded.
-
-    >>> splitstrip('a, b, c   ,  4,,')
-    ['a', 'b', 'c', '4']
-    >>> splitstrip('a')
-    ['a']
-    >>>
-
-    :type string: str or unicode
-    :param string: a csv line
-
-    :type sep: str or unicode
-    :param sep: field separator, default to the comma (',')
-
-    :rtype: str or unicode
-    :return: the unquoted string (or the input string if it wasn't quoted)
-    """
-    return [word.strip() for word in string.split(sep) if word.strip()]
-
-get_csv = deprecated('get_csv is deprecated, use splitstrip')(splitstrip)
-
-
-def split_url_or_path(url_or_path):
-    """return the latest component of a string containing either an url of the
-    form <scheme>://<path> or a local file system path
-    """
-    if '://' in url_or_path:
-        return url_or_path.rstrip('/').rsplit('/', 1)
-    return osp.split(url_or_path.rstrip(osp.sep))
-
-
-def text_to_dict(text):
-    """parse multilines text containing simple 'key=value' lines and return a
-    dict of {'key': 'value'}. When the same key is encountered multiple time,
-    value is turned into a list containing all values.
-
-    >>> text_to_dict('''multiple=1
-    ... multiple= 2
-    ... single =3
-    ... ''')
-    {'single': '3', 'multiple': ['1', '2']}
-
-    """
-    res = {}
-    if not text:
-        return res
-    for line in text.splitlines():
-        line = line.strip()
-        if line and not line.startswith('#'):
-            key, value = [w.strip() for w in line.split('=', 1)]
-            if key in res:
-                try:
-                    res[key].append(value)
-                except AttributeError:
-                    res[key] = [res[key], value]
-            else:
-                res[key] = value
-    return res
-
-
-_BLANK_URE = r'(\s|,)+'
-_BLANK_RE = re.compile(_BLANK_URE)
-__VALUE_URE = r'-?(([0-9]+\.[0-9]*)|((0x?)?[0-9]+))'
-__UNITS_URE = r'[a-zA-Z]+'
-_VALUE_RE = re.compile(r'(?P<value>%s)(?P<unit>%s)?'%(__VALUE_URE, __UNITS_URE))
-_VALIDATION_RE = re.compile(r'^((%s)(%s))*(%s)?$' % (__VALUE_URE, __UNITS_URE,
-                                                    __VALUE_URE))
-
-BYTE_UNITS = {
-    "b": 1,
-    "kb": 1024,
-    "mb": 1024 ** 2,
-    "gb": 1024 ** 3,
-    "tb": 1024 ** 4,
-}
-
-TIME_UNITS = {
-    "ms": 0.0001,
-    "s": 1,
-    "min": 60,
-    "h": 60 * 60,
-    "d": 60 * 60 *24,
-}
-
-def apply_units(string, units, inter=None, final=float, blank_reg=_BLANK_RE,
-                value_reg=_VALUE_RE):
-    """Parse the string applying the units defined in units
-    (e.g.: "1.5m",{'m',60} -> 80).
-
-    :type string: str or unicode
-    :param string: the string to parse
-
-    :type units: dict (or any object with __getitem__ using basestring key)
-    :param units: a dict mapping a unit string repr to its value
-
-    :type inter: type
-    :param inter: used to parse every intermediate value (need __sum__)
-
-    :type blank_reg: regexp
-    :param blank_reg: should match every blank char to ignore.
-
-    :type value_reg: regexp with "value" and optional "unit" group
-    :param value_reg: match a value and it's unit into the
-    """
-    if inter is None:
-        inter = final
-    fstring = _BLANK_RE.sub('', string)
-    if not (fstring and _VALIDATION_RE.match(fstring)):
-        raise ValueError("Invalid unit string: %r." % string)
-    values = []
-    for match in value_reg.finditer(fstring):
-        dic = match.groupdict()
-        lit, unit = dic["value"], dic.get("unit")
-        value = inter(lit)
-        if unit is not None:
-            try:
-                value *= units[unit.lower()]
-            except KeyError:
-                raise KeyError('invalid unit %s. valid units are %s' %
-                               (unit, units.keys()))
-        values.append(value)
-    return final(sum(values))
-
-
-_LINE_RGX = re.compile('\r\n|\r+|\n')
-
-def pretty_match(match, string, underline_char='^'):
-    """return a string with the match location underlined:
-
-    >>> import re
-    >>> print(pretty_match(re.search('mange', 'il mange du bacon'), 'il mange du bacon'))
-    il mange du bacon
-       ^^^^^
-    >>>
-
-    :type match: _sre.SRE_match
-    :param match: object returned by re.match, re.search or re.finditer
-
-    :type string: str or unicode
-    :param string:
-      the string on which the regular expression has been applied to
-      obtain the `match` object
-
-    :type underline_char: str or unicode
-    :param underline_char:
-      character to use to underline the matched section, default to the
-      carret '^'
-
-    :rtype: str or unicode
-    :return:
-      the original string with an inserted line to underline the match
-      location
-    """
-    start = match.start()
-    end = match.end()
-    string = _LINE_RGX.sub(linesep, string)
-    start_line_pos = string.rfind(linesep, 0, start)
-    if start_line_pos == -1:
-        start_line_pos = 0
-        result = []
-    else:
-        result = [string[:start_line_pos]]
-        start_line_pos += len(linesep)
-    offset = start - start_line_pos
-    underline = ' ' * offset + underline_char * (end - start)
-    end_line_pos = string.find(linesep, end)
-    if end_line_pos == -1:
-        string = string[start_line_pos:]
-        result.append(string)
-        result.append(underline)
-    else:
-        end = string[end_line_pos + len(linesep):]
-        string = string[start_line_pos:end_line_pos]
-        result.append(string)
-        result.append(underline)
-        result.append(end)
-    return linesep.join(result).rstrip()
-
-
-# Ansi colorization ###########################################################
-
-ANSI_PREFIX = '\033['
-ANSI_END = 'm'
-ANSI_RESET = '\033[0m'
-ANSI_STYLES = {
-    'reset': "0",
-    'bold': "1",
-    'italic': "3",
-    'underline': "4",
-    'blink': "5",
-    'inverse': "7",
-    'strike': "9",
-}
-ANSI_COLORS = {
-    'reset': "0",
-    'black': "30",
-    'red': "31",
-    'green': "32",
-    'yellow': "33",
-    'blue': "34",
-    'magenta': "35",
-    'cyan': "36",
-    'white': "37",
-}
-
-def _get_ansi_code(color=None, style=None):
-    """return ansi escape code corresponding to color and style
-
-    :type color: str or None
-    :param color:
-      the color name (see `ANSI_COLORS` for available values)
-      or the color number when 256 colors are available
-
-    :type style: str or None
-    :param style:
-      style string (see `ANSI_COLORS` for available values). To get
-      several style effects at the same time, use a coma as separator.
-
-    :raise KeyError: if an unexistent color or style identifier is given
-
-    :rtype: str
-    :return: the built escape code
-    """
-    ansi_code = []
-    if style:
-        style_attrs = splitstrip(style)
-        for effect in style_attrs:
-            ansi_code.append(ANSI_STYLES[effect])
-    if color:
-        if color.isdigit():
-            ansi_code.extend(['38', '5'])
-            ansi_code.append(color)
-        else:
-            ansi_code.append(ANSI_COLORS[color])
-    if ansi_code:
-        return ANSI_PREFIX + ';'.join(ansi_code) + ANSI_END
-    return ''
-
-def colorize_ansi(msg, color=None, style=None):
-    """colorize message by wrapping it with ansi escape codes
-
-    :type msg: str or unicode
-    :param msg: the message string to colorize
-
-    :type color: str or None
-    :param color:
-      the color identifier (see `ANSI_COLORS` for available values)
-
-    :type style: str or None
-    :param style:
-      style string (see `ANSI_COLORS` for available values). To get
-      several style effects at the same time, use a coma as separator.
-
-    :raise KeyError: if an unexistent color or style identifier is given
-
-    :rtype: str or unicode
-    :return: the ansi escaped string
-    """
-    # If both color and style are not defined, then leave the text as is
-    if color is None and style is None:
-        return msg
-    escape_code = _get_ansi_code(color, style)
-    # If invalid (or unknown) color, don't wrap msg with ansi codes
-    if escape_code:
-        return '%s%s%s' % (escape_code, msg, ANSI_RESET)
-    return msg
-
-DIFF_STYLE = {'separator': 'cyan', 'remove': 'red', 'add': 'green'}
-
-def diff_colorize_ansi(lines, out=sys.stdout, style=DIFF_STYLE):
-    for line in lines:
-        if line[:4] in ('--- ', '+++ '):
-            out.write(colorize_ansi(line, style['separator']))
-        elif line[0] == '-':
-            out.write(colorize_ansi(line, style['remove']))
-        elif line[0] == '+':
-            out.write(colorize_ansi(line, style['add']))
-        elif line[:4] == '--- ':
-            out.write(colorize_ansi(line, style['separator']))
-        elif line[:4] == '+++ ':
-            out.write(colorize_ansi(line, style['separator']))
-        else:
-            out.write(line)
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/tree.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/tree.py
deleted file mode 100644
index 885eb0fa..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/tree.py
+++ /dev/null
@@ -1,369 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Base class to represent a tree structure.
-
-
-
-
-"""
-__docformat__ = "restructuredtext en"
-
-import sys
-
-from logilab.common import flatten
-from logilab.common.visitor import VisitedMixIn, FilteredIterator, no_filter
-
-## Exceptions #################################################################
-
-class NodeNotFound(Exception):
-    """raised when a node has not been found"""
-
-EX_SIBLING_NOT_FOUND = "No such sibling as '%s'"
-EX_CHILD_NOT_FOUND = "No such child as '%s'"
-EX_NODE_NOT_FOUND = "No such node as '%s'"
-
-
-# Base node ###################################################################
-
-class Node(object):
-    """a basic tree node, characterized by an id"""
-
-    def __init__(self, nid=None) :
-        self.id = nid
-        # navigation
-        self.parent = None
-        self.children = []
-
-    def __iter__(self):
-        return iter(self.children)
-
-    def __str__(self, indent=0):
-        s = ['%s%s %s' % (' '*indent, self.__class__.__name__, self.id)]
-        indent += 2
-        for child in self.children:
-            try:
-                s.append(child.__str__(indent))
-            except TypeError:
-                s.append(child.__str__())
-        return '\n'.join(s)
-
-    def is_leaf(self):
-        return not self.children
-
-    def append(self, child):
-        """add a node to children"""
-        self.children.append(child)
-        child.parent = self
-
-    def remove(self, child):
-        """remove a child node"""
-        self.children.remove(child)
-        child.parent = None
-
-    def insert(self, index, child):
-        """insert a child node"""
-        self.children.insert(index, child)
-        child.parent = self
-
-    def replace(self, old_child, new_child):
-        """replace a child node with another"""
-        i = self.children.index(old_child)
-        self.children.pop(i)
-        self.children.insert(i, new_child)
-        new_child.parent = self
-
-    def get_sibling(self, nid):
-        """return the sibling node that has given id"""
-        try:
-            return self.parent.get_child_by_id(nid)
-        except NodeNotFound :
-            raise NodeNotFound(EX_SIBLING_NOT_FOUND % nid)
-
-    def next_sibling(self):
-        """
-        return the next sibling for this node if any
-        """
-        parent = self.parent
-        if parent is None:
-            # root node has no sibling
-            return None
-        index = parent.children.index(self)
-        try:
-            return parent.children[index+1]
-        except IndexError:
-            return None
-
-    def previous_sibling(self):
-        """
-        return the previous sibling for this node if any
-        """
-        parent = self.parent
-        if parent is None:
-            # root node has no sibling
-            return None
-        index = parent.children.index(self)
-        if index > 0:
-            return parent.children[index-1]
-        return None
-
-    def get_node_by_id(self, nid):
-        """
-        return node in whole hierarchy that has given id
-        """
-        root = self.root()
-        try:
-            return root.get_child_by_id(nid, 1)
-        except NodeNotFound :
-            raise NodeNotFound(EX_NODE_NOT_FOUND % nid)
-
-    def get_child_by_id(self, nid, recurse=None):
-        """
-        return child of given id
-        """
-        if self.id == nid:
-            return self
-        for c in self.children :
-            if recurse:
-                try:
-                    return c.get_child_by_id(nid, 1)
-                except NodeNotFound :
-                    continue
-            if c.id == nid :
-                return c
-        raise NodeNotFound(EX_CHILD_NOT_FOUND % nid)
-
-    def get_child_by_path(self, path):
-        """
-        return child of given path (path is a list of ids)
-        """
-        if len(path) > 0 and path[0] == self.id:
-            if len(path) == 1 :
-                return self
-            else :
-                for c in self.children :
-                    try:
-                        return c.get_child_by_path(path[1:])
-                    except NodeNotFound :
-                        pass
-        raise NodeNotFound(EX_CHILD_NOT_FOUND % path)
-
-    def depth(self):
-        """
-        return depth of this node in the tree
-        """
-        if self.parent is not None:
-            return 1 + self.parent.depth()
-        else :
-            return 0
-
-    def depth_down(self):
-        """
-        return depth of the tree from this node
-        """
-        if self.children:
-            return 1 + max([c.depth_down() for c in self.children])
-        return 1
-
-    def width(self):
-        """
-        return the width of the tree from this node
-        """
-        return len(self.leaves())
-
-    def root(self):
-        """
-        return the root node of the tree
-        """
-        if self.parent is not None:
-            return self.parent.root()
-        return self
-
-    def leaves(self):
-        """
-        return a list with all the leaves nodes descendant from this node
-        """
-        leaves = []
-        if self.children:
-            for child in self.children:
-                leaves += child.leaves()
-            return leaves
-        else:
-            return [self]
-
-    def flatten(self, _list=None):
-        """
-        return a list with all the nodes descendant from this node
-        """
-        if _list is None:
-            _list = []
-        _list.append(self)
-        for c in self.children:
-            c.flatten(_list)
-        return _list
-
-    def lineage(self):
-        """
-        return list of parents up to root node
-        """
-        lst = [self]
-        if self.parent is not None:
-            lst.extend(self.parent.lineage())
-        return lst
-
-class VNode(Node, VisitedMixIn):
-    """a visitable node
-    """
-    pass
-
-
-class BinaryNode(VNode):
-    """a binary node (i.e. only two children
-    """
-    def __init__(self, lhs=None, rhs=None) :
-        VNode.__init__(self)
-        if lhs is not None or rhs is not None:
-            assert lhs and rhs
-            self.append(lhs)
-            self.append(rhs)
-
-    def remove(self, child):
-        """remove the child and replace this node with the other child
-        """
-        self.children.remove(child)
-        self.parent.replace(self, self.children[0])
-
-    def get_parts(self):
-        """
-        return the left hand side and the right hand side of this node
-        """
-        return self.children[0], self.children[1]
-
-
-
-if sys.version_info[0:2] >= (2, 2):
-    list_class = list
-else:
-    from UserList import UserList
-    list_class = UserList
-
-class ListNode(VNode, list_class):
-    """Used to manipulate Nodes as Lists
-    """
-    def __init__(self):
-        list_class.__init__(self)
-        VNode.__init__(self)
-        self.children = self
-
-    def __str__(self, indent=0):
-        return '%s%s %s' % (indent*' ', self.__class__.__name__,
-                            ', '.join([str(v) for v in self]))
-
-    def append(self, child):
-        """add a node to children"""
-        list_class.append(self, child)
-        child.parent = self
-
-    def insert(self, index, child):
-        """add a node to children"""
-        list_class.insert(self, index, child)
-        child.parent = self
-
-    def remove(self, child):
-        """add a node to children"""
-        list_class.remove(self, child)
-        child.parent = None
-
-    def pop(self, index):
-        """add a node to children"""
-        child = list_class.pop(self, index)
-        child.parent = None
-
-    def __iter__(self):
-        return list_class.__iter__(self)
-
-# construct list from tree ####################################################
-
-def post_order_list(node, filter_func=no_filter):
-    """
-    create a list with tree nodes for which the <filter> function returned true
-    in a post order fashion
-    """
-    l, stack = [], []
-    poped, index = 0, 0
-    while node:
-        if filter_func(node):
-            if node.children and not poped:
-                stack.append((node, index))
-                index = 0
-                node = node.children[0]
-            else:
-                l.append(node)
-                index += 1
-                try:
-                    node = stack[-1][0].children[index]
-                except IndexError:
-                    node = None
-        else:
-            node = None
-        poped = 0
-        if node is None and stack:
-            node, index = stack.pop()
-            poped = 1
-    return l
-
-def pre_order_list(node, filter_func=no_filter):
-    """
-    create a list with tree nodes for which the <filter> function returned true
-    in a pre order fashion
-    """
-    l, stack = [], []
-    poped, index = 0, 0
-    while node:
-        if filter_func(node):
-            if not poped:
-                l.append(node)
-            if node.children and not poped:
-                stack.append((node, index))
-                index = 0
-                node = node.children[0]
-            else:
-                index += 1
-                try:
-                    node = stack[-1][0].children[index]
-                except IndexError:
-                    node = None
-        else:
-            node = None
-        poped = 0
-        if node is None and len(stack) > 1:
-            node, index = stack.pop()
-            poped = 1
-    return l
-
-class PostfixedDepthFirstIterator(FilteredIterator):
-    """a postfixed depth first iterator, designed to be used with visitors
-    """
-    def __init__(self, node, filter_func=None):
-        FilteredIterator.__init__(self, node, post_order_list, filter_func)
-
-class PrefixedDepthFirstIterator(FilteredIterator):
-    """a prefixed depth first iterator, designed to be used with visitors
-    """
-    def __init__(self, node, filter_func=None):
-        FilteredIterator.__init__(self, node, pre_order_list, filter_func)
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/__init__.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/__init__.py
deleted file mode 100644
index dcffcfa3..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/__init__.py
+++ /dev/null
@@ -1,174 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Universal report objects and some formatting drivers.
-
-A way to create simple reports using python objects, primarily designed to be
-formatted as text and html.
-"""
-from __future__ import generators
-__docformat__ = "restructuredtext en"
-
-import sys
-from cStringIO import StringIO
-from StringIO import StringIO as UStringIO
-
-from logilab.common.textutils import linesep
-
-
-def get_nodes(node, klass):
-    """return an iterator on all children node of the given klass"""
-    for child in node.children:
-        if isinstance(child, klass):
-            yield child
-        # recurse (FIXME: recursion controled by an option)
-        for grandchild in get_nodes(child, klass):
-            yield grandchild
-
-def layout_title(layout):
-    """try to return the layout's title as string, return None if not found
-    """
-    for child in layout.children:
-        if isinstance(child, Title):
-            return ' '.join([node.data for node in get_nodes(child, Text)])
-
-def build_summary(layout, level=1):
-    """make a summary for the report, including X level"""
-    assert level > 0
-    level -= 1
-    summary = List(klass='summary')
-    for child in layout.children:
-        if not isinstance(child, Section):
-            continue
-        label = layout_title(child)
-        if not label and not child.id:
-            continue
-        if not child.id:
-            child.id = label.replace(' ', '-')
-        node = Link('#'+child.id, label=label or child.id)
-        # FIXME: Three following lines produce not very compliant
-        # docbook: there are some useless <para><para>. They might be
-        # replaced by the three commented lines but this then produces
-        # a bug in html display...
-        if level and [n for n in child.children if isinstance(n, Section)]:
-            node = Paragraph([node, build_summary(child, level)])
-        summary.append(node)
-#         summary.append(node)
-#         if level and [n for n in child.children if isinstance(n, Section)]:
-#             summary.append(build_summary(child, level))
-    return summary
-
-
-class BaseWriter(object):
-    """base class for ureport writers"""
-
-    def format(self, layout, stream=None, encoding=None):
-        """format and write the given layout into the stream object
-
-        unicode policy: unicode strings may be found in the layout;
-        try to call stream.write with it, but give it back encoded using
-        the given encoding if it fails
-        """
-        if stream is None:
-            stream = sys.stdout
-        if not encoding:
-            encoding = getattr(stream, 'encoding', 'UTF-8')
-        self.encoding = encoding or 'UTF-8'
-        self.__compute_funcs = []
-        self.out = stream
-        self.begin_format(layout)
-        layout.accept(self)
-        self.end_format(layout)
-
-    def format_children(self, layout):
-        """recurse on the layout children and call their accept method
-        (see the Visitor pattern)
-        """
-        for child in getattr(layout, 'children', ()):
-            child.accept(self)
-
-    def writeln(self, string=''):
-        """write a line in the output buffer"""
-        self.write(string + linesep)
-
-    def write(self, string):
-        """write a string in the output buffer"""
-        try:
-            self.out.write(string)
-        except UnicodeEncodeError:
-            self.out.write(string.encode(self.encoding))
-
-    def begin_format(self, layout):
-        """begin to format a layout"""
-        self.section = 0
-
-    def end_format(self, layout):
-        """finished to format a layout"""
-
-    def get_table_content(self, table):
-        """trick to get table content without actually writing it
-
-        return an aligned list of lists containing table cells values as string
-        """
-        result = [[]]
-        cols = table.cols
-        for cell in self.compute_content(table):
-            if cols == 0:
-                result.append([])
-                cols = table.cols
-            cols -= 1
-            result[-1].append(cell)
-        # fill missing cells
-        while len(result[-1]) < cols:
-            result[-1].append('')
-        return result
-
-    def compute_content(self, layout):
-        """trick to compute the formatting of children layout before actually
-        writing it
-
-        return an iterator on strings (one for each child element)
-        """
-        # use cells !
-        def write(data):
-            try:
-                stream.write(data)
-            except UnicodeEncodeError:
-                stream.write(data.encode(self.encoding))
-        def writeln(data=''):
-            try:
-                stream.write(data+linesep)
-            except UnicodeEncodeError:
-                stream.write(data.encode(self.encoding)+linesep)
-        self.write = write
-        self.writeln = writeln
-        self.__compute_funcs.append((write, writeln))
-        for child in layout.children:
-            stream = UStringIO()
-            child.accept(self)
-            yield stream.getvalue()
-        self.__compute_funcs.pop()
-        try:
-            self.write, self.writeln = self.__compute_funcs[-1]
-        except IndexError:
-            del self.write
-            del self.writeln
-
-
-from logilab.common.ureports.nodes import *
-from logilab.common.ureports.text_writer import TextWriter
-from logilab.common.ureports.html_writer import HTMLWriter
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/docbook_writer.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/docbook_writer.py
deleted file mode 100644
index e75cbe09..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/docbook_writer.py
+++ /dev/null
@@ -1,139 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""HTML formatting drivers for ureports"""
-from __future__ import generators
-__docformat__ = "restructuredtext en"
-
-from logilab.common.ureports import HTMLWriter
-
-class DocbookWriter(HTMLWriter):
-    """format layouts as HTML"""
-
-    def begin_format(self, layout):
-        """begin to format a layout"""
-        super(HTMLWriter, self).begin_format(layout)
-        if self.snippet is None:
-            self.writeln('<?xml version="1.0" encoding="ISO-8859-1"?>')
-            self.writeln("""
-<book xmlns:xi='http://www.w3.org/2001/XInclude'
-      lang='fr'>
-""")
-
-    def end_format(self, layout):
-        """finished to format a layout"""
-        if self.snippet is None:
-            self.writeln('</book>')
-
-    def visit_section(self, layout):
-        """display a section (using <chapter> (level 0) or <section>)"""
-        if self.section == 0:
-            tag = "chapter"
-        else:
-            tag = "section"
-        self.section += 1
-        self.writeln(self._indent('<%s%s>' % (tag, self.handle_attrs(layout))))
-        self.format_children(layout)
-        self.writeln(self._indent('</%s>'% tag))
-        self.section -= 1
-
-    def visit_title(self, layout):
-        """display a title using <title>"""
-        self.write(self._indent('  <title%s>' % self.handle_attrs(layout)))
-        self.format_children(layout)
-        self.writeln('</title>')
-
-    def visit_table(self, layout):
-        """display a table as html"""
-        self.writeln(self._indent('  <table%s><title>%s</title>' \
-                     % (self.handle_attrs(layout), layout.title)))
-        self.writeln(self._indent('    <tgroup cols="%s">'% layout.cols))
-        for i in range(layout.cols):
-            self.writeln(self._indent('      <colspec colname="c%s" colwidth="1*"/>' % i))
-
-        table_content = self.get_table_content(layout)
-        # write headers
-        if layout.cheaders:
-            self.writeln(self._indent('      <thead>'))
-            self._write_row(table_content[0])
-            self.writeln(self._indent('      </thead>'))
-            table_content = table_content[1:]
-        elif layout.rcheaders:
-            self.writeln(self._indent('      <thead>'))
-            self._write_row(table_content[-1])
-            self.writeln(self._indent('      </thead>'))
-            table_content = table_content[:-1]
-        # write body
-        self.writeln(self._indent('      <tbody>'))
-        for i in range(len(table_content)):
-            row = table_content[i]
-            self.writeln(self._indent('        <row>'))
-            for j in range(len(row)):
-                cell = row[j] or '&#160;'
-                self.writeln(self._indent('          <entry>%s</entry>' % cell))
-            self.writeln(self._indent('        </row>'))
-        self.writeln(self._indent('      </tbody>'))
-        self.writeln(self._indent('    </tgroup>'))
-        self.writeln(self._indent('  </table>'))
-
-    def _write_row(self, row):
-        """write content of row (using <row> <entry>)"""
-        self.writeln('        <row>')
-        for j in range(len(row)):
-            cell = row[j] or '&#160;'
-            self.writeln('          <entry>%s</entry>' % cell)
-        self.writeln(self._indent('        </row>'))
-
-    def visit_list(self, layout):
-        """display a list (using <itemizedlist>)"""
-        self.writeln(self._indent('  <itemizedlist%s>' % self.handle_attrs(layout)))
-        for row in list(self.compute_content(layout)):
-            self.writeln('    <listitem><para>%s</para></listitem>' % row)
-        self.writeln(self._indent('  </itemizedlist>'))
-
-    def visit_paragraph(self, layout):
-        """display links (using <para>)"""
-        self.write(self._indent('  <para>'))
-        self.format_children(layout)
-        self.writeln('</para>')
-
-    def visit_span(self, layout):
-        """display links (using <p>)"""
-        #TODO: translate in docbook
-        self.write('<literal %s>' % self.handle_attrs(layout))
-        self.format_children(layout)
-        self.write('</literal>')
-
-    def visit_link(self, layout):
-        """display links (using <ulink>)"""
-        self.write('<ulink url="%s"%s>%s</ulink>' % (layout.url,
-                                               self.handle_attrs(layout),
-                                               layout.label))
-
-    def visit_verbatimtext(self, layout):
-        """display verbatim text (using <programlisting>)"""
-        self.writeln(self._indent('  <programlisting>'))
-        self.write(layout.data.replace('&', '&amp;').replace('<', '&lt;'))
-        self.writeln(self._indent('  </programlisting>'))
-
-    def visit_text(self, layout):
-        """add some text"""
-        self.write(layout.data.replace('&', '&amp;').replace('<', '&lt;'))
-
-    def _indent(self, string):
-        """correctly indent string according to section"""
-        return ' ' * 2*(self.section) + string
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/html_writer.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/html_writer.py
deleted file mode 100644
index 1d095034..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/html_writer.py
+++ /dev/null
@@ -1,131 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""HTML formatting drivers for ureports"""
-__docformat__ = "restructuredtext en"
-
-from cgi import escape
-
-from logilab.common.ureports import BaseWriter
-
-
-class HTMLWriter(BaseWriter):
-    """format layouts as HTML"""
-
-    def __init__(self, snippet=None):
-        super(HTMLWriter, self).__init__()
-        self.snippet = snippet
-
-    def handle_attrs(self, layout):
-        """get an attribute string from layout member attributes"""
-        attrs = ''
-        klass = getattr(layout, 'klass', None)
-        if klass:
-            attrs += ' class="%s"' % klass
-        nid = getattr(layout, 'id', None)
-        if nid:
-            attrs += ' id="%s"' % nid
-        return attrs
-
-    def begin_format(self, layout):
-        """begin to format a layout"""
-        super(HTMLWriter, self).begin_format(layout)
-        if self.snippet is None:
-            self.writeln('<html>')
-            self.writeln('<body>')
-
-    def end_format(self, layout):
-        """finished to format a layout"""
-        if self.snippet is None:
-            self.writeln('</body>')
-            self.writeln('</html>')
-
-
-    def visit_section(self, layout):
-        """display a section as html, using div + h[section level]"""
-        self.section += 1
-        self.writeln('<div%s>' % self.handle_attrs(layout))
-        self.format_children(layout)
-        self.writeln('</div>')
-        self.section -= 1
-
-    def visit_title(self, layout):
-        """display a title using <hX>"""
-        self.write('<h%s%s>' % (self.section, self.handle_attrs(layout)))
-        self.format_children(layout)
-        self.writeln('</h%s>' % self.section)
-
-    def visit_table(self, layout):
-        """display a table as html"""
-        self.writeln('<table%s>' % self.handle_attrs(layout))
-        table_content = self.get_table_content(layout)
-        for i in range(len(table_content)):
-            row = table_content[i]
-            if i == 0 and layout.rheaders:
-                self.writeln('<tr class="header">')
-            elif i+1 == len(table_content) and layout.rrheaders:
-                self.writeln('<tr class="header">')
-            else:
-                self.writeln('<tr class="%s">' % (i%2 and 'even' or 'odd'))
-            for j in range(len(row)):
-                cell = row[j] or '&#160;'
-                if (layout.rheaders and i == 0) or \
-                   (layout.cheaders and j == 0) or \
-                   (layout.rrheaders and i+1 == len(table_content)) or \
-                   (layout.rcheaders and j+1 == len(row)):
-                    self.writeln('<th>%s</th>' % cell)
-                else:
-                    self.writeln('<td>%s</td>' % cell)
-            self.writeln('</tr>')
-        self.writeln('</table>')
-
-    def visit_list(self, layout):
-        """display a list as html"""
-        self.writeln('<ul%s>' % self.handle_attrs(layout))
-        for row in list(self.compute_content(layout)):
-            self.writeln('<li>%s</li>' % row)
-        self.writeln('</ul>')
-
-    def visit_paragraph(self, layout):
-        """display links (using <p>)"""
-        self.write('<p>')
-        self.format_children(layout)
-        self.write('</p>')
-
-    def visit_span(self, layout):
-        """display links (using <p>)"""
-        self.write('<span%s>' % self.handle_attrs(layout))
-        self.format_children(layout)
-        self.write('</span>')
-
-    def visit_link(self, layout):
-        """display links (using <a>)"""
-        self.write(' <a href="%s"%s>%s</a>' % (layout.url,
-                                               self.handle_attrs(layout),
-                                               layout.label))
-    def visit_verbatimtext(self, layout):
-        """display verbatim text (using <pre>)"""
-        self.write('<pre>')
-        self.write(layout.data.replace('&', '&amp;').replace('<', '&lt;'))
-        self.write('</pre>')
-
-    def visit_text(self, layout):
-        """add some text"""
-        data = layout.data
-        if layout.escaped:
-            data = data.replace('&', '&amp;').replace('<', '&lt;')
-        self.write(data)
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/nodes.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/nodes.py
deleted file mode 100644
index d63b5828..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/nodes.py
+++ /dev/null
@@ -1,201 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Micro reports objects.
-
-A micro report is a tree of layout and content objects.
-"""
-__docformat__ = "restructuredtext en"
-
-from logilab.common.tree import VNode
-
-class BaseComponent(VNode):
-    """base report component
-
-    attributes
-    * id : the component's optional id
-    * klass : the component's optional klass
-    """
-    def __init__(self, id=None, klass=None):
-        VNode.__init__(self, id)
-        self.klass = klass
-
-class BaseLayout(BaseComponent):
-    """base container node
-
-    attributes
-    * BaseComponent attributes
-    * children : components in this table (i.e. the table's cells)
-    """
-    def __init__(self, children=(), **kwargs):
-        super(BaseLayout, self).__init__(**kwargs)
-        for child in children:
-            if isinstance(child, BaseComponent):
-                self.append(child)
-            else:
-                self.add_text(child)
-
-    def append(self, child):
-        """overridden to detect problems easily"""
-        assert child not in self.parents()
-        VNode.append(self, child)
-
-    def parents(self):
-        """return the ancestor nodes"""
-        assert self.parent is not self
-        if self.parent is None:
-            return []
-        return [self.parent] + self.parent.parents()
-
-    def add_text(self, text):
-        """shortcut to add text data"""
-        self.children.append(Text(text))
-
-
-# non container nodes #########################################################
-
-class Text(BaseComponent):
-    """a text portion
-
-    attributes :
-    * BaseComponent attributes
-    * data : the text value as an encoded or unicode string
-    """
-    def __init__(self, data, escaped=True, **kwargs):
-        super(Text, self).__init__(**kwargs)
-        #if isinstance(data, unicode):
-        #    data = data.encode('ascii')
-        assert isinstance(data, (str, unicode)), data.__class__
-        self.escaped = escaped
-        self.data = data
-
-class VerbatimText(Text):
-    """a verbatim text, display the raw data
-
-    attributes :
-    * BaseComponent attributes
-    * data : the text value as an encoded or unicode string
-    """
-
-class Link(BaseComponent):
-    """a labelled link
-
-    attributes :
-    * BaseComponent attributes
-    * url : the link's target (REQUIRED)
-    * label : the link's label as a string (use the url by default)
-    """
-    def __init__(self, url, label=None, **kwargs):
-        super(Link, self).__init__(**kwargs)
-        assert url
-        self.url = url
-        self.label = label or url
-
-
-class Image(BaseComponent):
-    """an embedded or a single image
-
-    attributes :
-    * BaseComponent attributes
-    * filename : the image's filename (REQUIRED)
-    * stream : the stream object containing the image data (REQUIRED)
-    * title : the image's optional title
-    """
-    def __init__(self, filename, stream, title=None, **kwargs):
-        super(Image, self).__init__(**kwargs)
-        assert filename
-        assert stream
-        self.filename = filename
-        self.stream = stream
-        self.title = title
-
-
-# container nodes #############################################################
-
-class Section(BaseLayout):
-    """a section
-
-    attributes :
-    * BaseLayout attributes
-
-    a title may also be given to the constructor, it'll be added
-    as a first element
-    a description may also be given to the constructor, it'll be added
-    as a first paragraph
-    """
-    def __init__(self, title=None, description=None, **kwargs):
-        super(Section, self).__init__(**kwargs)
-        if description:
-            self.insert(0, Paragraph([Text(description)]))
-        if title:
-            self.insert(0, Title(children=(title,)))
-
-class Title(BaseLayout):
-    """a title
-
-    attributes :
-    * BaseLayout attributes
-
-    A title must not contains a section nor a paragraph!
-    """
-
-class Span(BaseLayout):
-    """a title
-
-    attributes :
-    * BaseLayout attributes
-
-    A span should only contains Text and Link nodes (in-line elements)
-    """
-
-class Paragraph(BaseLayout):
-    """a simple text paragraph
-
-    attributes :
-    * BaseLayout attributes
-
-    A paragraph must not contains a section !
-    """
-
-class Table(BaseLayout):
-    """some tabular data
-
-    attributes :
-    * BaseLayout attributes
-    * cols : the number of columns of the table (REQUIRED)
-    * rheaders : the first row's elements are table's header
-    * cheaders : the first col's elements are table's header
-    * title : the table's optional title
-    """
-    def __init__(self, cols, title=None,
-                 rheaders=0, cheaders=0, rrheaders=0, rcheaders=0,
-                 **kwargs):
-        super(Table, self).__init__(**kwargs)
-        assert isinstance(cols, int)
-        self.cols = cols
-        self.title = title
-        self.rheaders = rheaders
-        self.cheaders = cheaders
-        self.rrheaders = rrheaders
-        self.rcheaders = rcheaders
-
-class List(BaseLayout):
-    """some list data
-
-    attributes :
-    * BaseLayout attributes
-    """
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/text_writer.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/text_writer.py
deleted file mode 100644
index 04c8f263..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/ureports/text_writer.py
+++ /dev/null
@@ -1,140 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Text formatting drivers for ureports"""
-__docformat__ = "restructuredtext en"
-
-from logilab.common.textutils import linesep
-from logilab.common.ureports import BaseWriter
-
-
-TITLE_UNDERLINES = ['', '=', '-', '`', '.', '~', '^']
-BULLETS = ['*', '-']
-
-class TextWriter(BaseWriter):
-    """format layouts as text
-    (ReStructured inspiration but not totally handled yet)
-    """
-    def begin_format(self, layout):
-        super(TextWriter, self).begin_format(layout)
-        self.list_level = 0
-        self.pending_urls = []
-
-    def visit_section(self, layout):
-        """display a section as text
-        """
-        self.section += 1
-        self.writeln()
-        self.format_children(layout)
-        if self.pending_urls:
-            self.writeln()
-            for label, url in self.pending_urls:
-                self.writeln('.. _`%s`: %s' % (label, url))
-            self.pending_urls = []
-        self.section -= 1
-        self.writeln()
-
-    def visit_title(self, layout):
-        title = ''.join(list(self.compute_content(layout)))
-        self.writeln(title)
-        try:
-            self.writeln(TITLE_UNDERLINES[self.section] * len(title))
-        except IndexError:
-            print "FIXME TITLE TOO DEEP. TURNING TITLE INTO TEXT"
-
-    def visit_paragraph(self, layout):
-        """enter a paragraph"""
-        self.format_children(layout)
-        self.writeln()
-
-    def visit_span(self, layout):
-        """enter a span"""
-        self.format_children(layout)
-
-    def visit_table(self, layout):
-        """display a table as text"""
-        table_content = self.get_table_content(layout)
-        # get columns width
-        cols_width = [0]*len(table_content[0])
-        for row in table_content:
-            for index in range(len(row)):
-                col = row[index]
-                cols_width[index] = max(cols_width[index], len(col))
-        if layout.klass == 'field':
-            self.field_table(layout, table_content, cols_width)
-        else:
-            self.default_table(layout, table_content, cols_width)
-        self.writeln()
-
-    def default_table(self, layout, table_content, cols_width):
-        """format a table"""
-        cols_width = [size+1 for size in cols_width]
-        format_strings = ' '.join(['%%-%ss'] * len(cols_width))
-        format_strings = format_strings % tuple(cols_width)
-        format_strings = format_strings.split(' ')
-        table_linesep = '\n+' + '+'.join(['-'*w for w in cols_width]) + '+\n'
-        headsep = '\n+' + '+'.join(['='*w for w in cols_width]) + '+\n'
-        # FIXME: layout.cheaders
-        self.write(table_linesep)
-        for i in range(len(table_content)):
-            self.write('|')
-            line = table_content[i]
-            for j in range(len(line)):
-                self.write(format_strings[j] % line[j])
-                self.write('|')
-            if i == 0 and layout.rheaders:
-                self.write(headsep)
-            else:
-                self.write(table_linesep)
-
-    def field_table(self, layout, table_content, cols_width):
-        """special case for field table"""
-        assert layout.cols == 2
-        format_string = '%s%%-%ss: %%s' % (linesep, cols_width[0])
-        for field, value in table_content:
-            self.write(format_string % (field, value))
-
-
-    def visit_list(self, layout):
-        """display a list layout as text"""
-        bullet = BULLETS[self.list_level % len(BULLETS)]
-        indent = '  ' * self.list_level
-        self.list_level += 1
-        for child in layout.children:
-            self.write('%s%s%s ' % (linesep, indent, bullet))
-            child.accept(self)
-        self.list_level -= 1
-
-    def visit_link(self, layout):
-        """add a hyperlink"""
-        if layout.label != layout.url:
-            self.write('`%s`_' % layout.label)
-            self.pending_urls.append( (layout.label, layout.url) )
-        else:
-            self.write(layout.url)
-
-    def visit_verbatimtext(self, layout):
-        """display a verbatim layout as text (so difficult ;)
-        """
-        self.writeln('::\n')
-        for line in layout.data.splitlines():
-            self.writeln('    ' + line)
-        self.writeln()
-
-    def visit_text(self, layout):
-        """add some text"""
-        self.write(layout.data)
diff --git a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/visitor.py b/pymode/libs/pylama/lint/pylama_pylint/logilab/common/visitor.py
deleted file mode 100644
index 802d2bef..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/logilab/common/visitor.py
+++ /dev/null
@@ -1,107 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common 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.
-#
-# logilab-common 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 logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""A generic visitor abstract implementation.
-
-
-
-
-"""
-__docformat__ = "restructuredtext en"
-
-def no_filter(_):
-    return 1
-
-# Iterators ###################################################################
-class FilteredIterator(object):
-
-    def __init__(self, node, list_func, filter_func=None):
-        self._next = [(node, 0)]
-        if filter_func is None:
-            filter_func = no_filter
-        self._list = list_func(node, filter_func)
-
-    def next(self):
-        try:
-            return self._list.pop(0)
-        except :
-            return None
-
-# Base Visitor ################################################################
-class Visitor(object):
-
-    def __init__(self, iterator_class, filter_func=None):
-        self._iter_class = iterator_class
-        self.filter = filter_func
-
-    def visit(self, node, *args, **kargs):
-        """
-        launch the visit on a given node
-
-        call 'open_visit' before the beginning of the visit, with extra args
-        given
-        when all nodes have been visited, call the 'close_visit' method
-        """
-        self.open_visit(node, *args, **kargs)
-        return self.close_visit(self._visit(node))
-
-    def _visit(self, node):
-        iterator = self._get_iterator(node)
-        n = iterator.next()
-        while n:
-            result = n.accept(self)
-            n = iterator.next()
-        return result
-
-    def _get_iterator(self, node):
-        return self._iter_class(node, self.filter)
-
-    def open_visit(self, *args, **kargs):
-        """
-        method called at the beginning of the visit
-        """
-        pass
-
-    def close_visit(self, result):
-        """
-        method called at the end of the visit
-        """
-        return result
-
-# standard visited mixin ######################################################
-class VisitedMixIn(object):
-    """
-    Visited interface allow node visitors to use the node
-    """
-    def get_visit_name(self):
-        """
-        return the visit name for the mixed class. When calling 'accept', the
-        method <'visit_' + name returned by this method> will be called on the
-        visitor
-        """
-        try:
-            return self.TYPE.replace('-', '_')
-        except:
-            return self.__class__.__name__.lower()
-
-    def accept(self, visitor, *args, **kwargs):
-        func = getattr(visitor, 'visit_%s' % self.get_visit_name())
-        return func(self, *args, **kwargs)
-
-    def leave(self, visitor, *args, **kwargs):
-        func = getattr(visitor, 'leave_%s' % self.get_visit_name())
-        return func(self, *args, **kwargs)
diff --git a/pymode/libs/pylama/lint/pylama_pylint/main.py b/pymode/libs/pylama/lint/pylama_pylint/main.py
deleted file mode 100644
index 411ba31d..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/main.py
+++ /dev/null
@@ -1,113 +0,0 @@
-""" Pylint support. """
-from os import path as op, environ
-import sys
-import logging
-
-from pylama.lint import Linter as BaseLinter
-
-CURDIR = op.abspath(op.dirname(__file__))
-sys.path.insert(0, CURDIR)
-
-from astroid import MANAGER
-from pylint.lint import Run
-from pylint.reporters import BaseReporter
-
-HOME_RCFILE = op.abspath(op.join(environ.get('HOME', ''), '.pylintrc'))
-LAMA_RCFILE = op.abspath(op.join(CURDIR, 'pylint.rc'))
-
-
-logger = logging.getLogger('pylama')
-
-
-class Linter(BaseLinter):
-
-    """ Check code with pylint. """
-
-    @staticmethod
-    def run(path, code, params=None, ignore=None, select=None, **meta):
-        """ Pylint code checking.
-
-        :return list: List of errors.
-
-        """
-        logger.debug('Start pylint')
-
-        MANAGER.astroid_cache.clear()
-
-        class Reporter(BaseReporter):
-
-            def __init__(self):
-                self.errors = []
-                super(Reporter, self).__init__()
-
-            def _display(self, layout):
-                pass
-
-            def add_message(self, msg_id, location, msg):
-                _, _, line, col = location[1:]
-                self.errors.append(dict(
-                    lnum=line,
-                    col=col,
-                    text="%s %s" % (msg_id, msg),
-                    type=msg_id[0]
-                ))
-
-        params = _Params(ignore=ignore, select=select, params=params)
-        logger.debug(params)
-
-        runner = Run(
-            [path] + params.to_attrs(), reporter=Reporter(), exit=False)
-
-        return runner.linter.reporter.errors
-
-
-class _Params(object):
-
-    """ Store pylint params. """
-
-    def __init__(self, select=None, ignore=None, params=None):
-
-        params = dict(params.items())
-        rcfile = params.get('rcfile', LAMA_RCFILE)
-        enable = params.get('enable', None)
-        disable = params.get('disable', None)
-
-        if op.exists(HOME_RCFILE):
-            rcfile = HOME_RCFILE
-
-        if select:
-            enable = select | set(enable.split(",") if enable else [])
-
-        if ignore:
-            disable = ignore | set(disable.split(",") if disable else [])
-
-        params.update(dict(
-            report=params.get('report', False), rcfile=rcfile,
-            enable=enable, disable=disable))
-
-        self.params = dict(
-            (name.replace('_', '-'), self.prepare_value(value))
-            for name, value in params.items() if value is not None)
-
-    @staticmethod
-    def prepare_value(value):
-        """ Prepare value to pylint. """
-        if isinstance(value, (list, tuple, set)):
-            return ",".join(value)
-
-        if isinstance(value, bool):
-            return "y" if value else "n"
-
-        return str(value)
-
-    def to_attrs(self):
-        """ Convert to argument list. """
-        return ["--%s=%s" % item for item in self.params.items()]
-
-    def __str__(self):
-        return " ".join(self.to_attrs())
-
-    def __repr__(self):
-        return "<Pylint %s>" % self
-
-# pylama:ignore=W0403
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint.rc b/pymode/libs/pylama/lint/pylama_pylint/pylint.rc
deleted file mode 100644
index 799c62f6..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint.rc
+++ /dev/null
@@ -1,23 +0,0 @@
-[MESSAGES CONTROL]
-# Disable the message(s) with the given id(s).
-# http://pylint-messages.wikidot.com/all-codes
-#
-# C0103: Invalid name "%s" (should match %s)
-# E1101: %s %r has no %r member
-# R0901: Too many ancestors (%s/%s)
-# R0902: Too many instance attributes (%s/%s)
-# R0903: Too few public methods (%s/%s)
-# R0904: Too many public methods (%s/%s)
-# R0913: Too many arguments (%s/%s)
-# R0915: Too many statements (%s/%s)
-# W0141: Used builtin function %r
-# W0142: Used * or ** magic
-# W0221: Arguments number differs from %s method
-# W0232: Class has no __init__ method
-# W0613: Unused argument %r
-# W0631: Using possibly undefined loop variable %r
-#
-disable = C0103,E1101,R0901,R0902,R0903,R0904,R0913,R0915,W0141,W0142,W0221,W0232,W0613,W0631
-
-[TYPECHECK]
-generated-members = REQUEST,acl_users,aq_parent,objects,DoesNotExist,_meta,status_code,content,context
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/__init__.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/__init__.py
deleted file mode 100644
index eed1b62f..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/__init__.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# Copyright (c) 2003-2012 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-import sys
-
-def run_pylint():
-    """run pylint"""
-    from pylint.lint import Run
-    Run(sys.argv[1:])
-
-def run_pylint_gui():
-    """run pylint-gui"""
-    try:
-        from pylint.gui import Run
-        Run(sys.argv[1:])
-    except ImportError:
-        sys.exit('tkinter is not available')
-
-def run_epylint():
-    """run pylint"""
-    from pylint.epylint import Run
-    Run()
-
-def run_pyreverse():
-    """run pyreverse"""
-    from pylint.pyreverse.main import Run
-    Run(sys.argv[1:])
-
-def run_symilar():
-    """run symilar"""
-    from pylint.checkers.similar import Run
-    Run(sys.argv[1:])
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/__pkginfo__.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/__pkginfo__.py
deleted file mode 100644
index 86488fa5..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/__pkginfo__.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# pylint: disable=W0622,C0103
-# Copyright (c) 2003-2014 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""pylint packaging information"""
-import sys
-
-modname = distname = 'pylint'
-
-numversion = (1, 2, 1)
-version = '.'.join([str(num) for num in numversion])
-
-if sys.version_info < (2, 6):
-    install_requires = ['logilab-common >= 0.53.0', 'astroid >= 1.1',
-                        'StringFormat']
-else:
-    install_requires = ['logilab-common >= 0.53.0', 'astroid >= 1.1']
-
-license = 'GPL'
-description = "python code static checker"
-web = 'http://www.pylint.org'
-mailinglist = "mailto://code-quality@python.org"
-author = 'Logilab'
-author_email = 'python-projects@lists.logilab.org'
-
-classifiers = ['Development Status :: 4 - Beta',
-               'Environment :: Console',
-               'Intended Audience :: Developers',
-               'License :: OSI Approved :: GNU General Public License (GPL)',
-               'Operating System :: OS Independent',
-               'Programming Language :: Python',
-               'Programming Language :: Python :: 2',
-               'Programming Language :: Python :: 3',
-               'Topic :: Software Development :: Debuggers',
-               'Topic :: Software Development :: Quality Assurance',
-               'Topic :: Software Development :: Testing'
-              ]
-
-
-long_desc = """\
- Pylint is a Python source code analyzer which looks for programming
- errors, helps enforcing a coding standard and sniffs for some code
- smells (as defined in Martin Fowler's Refactoring book)
- .
- Pylint can be seen as another PyChecker since nearly all tests you
- can do with PyChecker can also be done with Pylint. However, Pylint
- offers some more features, like checking length of lines of code,
- checking if variable names are well-formed according to your coding
- standard, or checking if declared interfaces are truly implemented,
- and much more.
- .
- Additionally, it is possible to write plugins to add your own checks.
- .
- Pylint is shipped with "pylint-gui", "pyreverse" (UML diagram generator)
- and "symilar" (an independent similarities checker)."""
-
-from os.path import join
-scripts = [join('bin', filename)
-           for filename in ('pylint', 'pylint-gui', "symilar", "epylint",
-                            "pyreverse")]
-
-include_dirs = ['test']
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/__init__.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/__init__.py
deleted file mode 100644
index af7965be..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/__init__.py
+++ /dev/null
@@ -1,145 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""utilities methods and classes for checkers
-
-Base id of standard checkers (used in msg and report ids):
-01: base
-02: classes
-03: format
-04: import
-05: misc
-06: variables
-07: exceptions
-08: similar
-09: design_analysis
-10: newstyle
-11: typecheck
-12: logging
-13: string_format
-14: string_constant
-15-50: not yet used: reserved for future internal checkers.
-51-99: perhaps used: reserved for external checkers
-
-The raw_metrics checker has no number associated since it doesn't emit any
-messages nor reports. XXX not true, emit a 07 report !
-
-"""
-
-import sys
-import tokenize
-import warnings
-
-from astroid.utils import ASTWalker
-from logilab.common.configuration import OptionsProviderMixIn
-
-from pylint.reporters import diff_string
-from pylint.utils import register_plugins
-
-def table_lines_from_stats(stats, old_stats, columns):
-    """get values listed in <columns> from <stats> and <old_stats>,
-    and return a formated list of values, designed to be given to a
-    ureport.Table object
-    """
-    lines = []
-    for m_type in columns:
-        new = stats[m_type]
-        format = str
-        if isinstance(new, float):
-            format = lambda num: '%.3f' % num
-        old = old_stats.get(m_type)
-        if old is not None:
-            diff_str = diff_string(old, new)
-            old = format(old)
-        else:
-            old, diff_str = 'NC', 'NC'
-        lines += (m_type.replace('_', ' '), format(new), old, diff_str)
-    return lines
-
-
-class BaseChecker(OptionsProviderMixIn, ASTWalker):
-    """base class for checkers"""
-    # checker name (you may reuse an existing one)
-    name = None
-    # options level (0 will be displaying in --help, 1 in --long-help)
-    level = 1
-    # ordered list of options to control the ckecker behaviour
-    options = ()
-    # messages issued by this checker
-    msgs = {}
-    # reports issued by this checker
-    reports = ()
-
-    def __init__(self, linter=None):
-        """checker instances should have the linter as argument
-
-        linter is an object implementing ILinter
-        """
-        ASTWalker.__init__(self, self)
-        self.name = self.name.lower()
-        OptionsProviderMixIn.__init__(self)
-        self.linter = linter
-
-    def add_message(self, msg_id, line=None, node=None, args=None):
-        """add a message of a given type"""
-        self.linter.add_message(msg_id, line, node, args)
-
-    # dummy methods implementing the IChecker interface
-
-    def open(self):
-        """called before visiting project (i.e set of modules)"""
-
-    def close(self):
-        """called after visiting project (i.e set of modules)"""
-
-
-class BaseRawChecker(BaseChecker):
-    """base class for raw checkers"""
-
-    def process_module(self, node):
-        """process a module
-
-        the module's content is accessible via the stream object
-
-        stream must implement the readline method
-        """
-        warnings.warn("Modules that need access to the tokens should "
-                      "use the ITokenChecker interface.",
-                      DeprecationWarning)
-        stream = node.file_stream
-        stream.seek(0) # XXX may be removed with astroid > 0.23
-        if sys.version_info <= (3, 0):
-            self.process_tokens(tokenize.generate_tokens(stream.readline))
-        else:
-            self.process_tokens(tokenize.tokenize(stream.readline))
-
-    def process_tokens(self, tokens):
-        """should be overridden by subclasses"""
-        raise NotImplementedError()
-
-
-class BaseTokenChecker(BaseChecker):
-    """Base class for checkers that want to have access to the token stream."""
-
-    def process_tokens(self, tokens):
-        """Should be overridden by subclasses."""
-        raise NotImplementedError()
-
-
-def initialize(linter):
-    """initialize linter with checkers in this package """
-    register_plugins(linter, __path__[0])
-
-__all__ = ('BaseChecker', 'initialize')
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/base.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/base.py
deleted file mode 100644
index 8136d0f3..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/base.py
+++ /dev/null
@@ -1,1141 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-# Copyright (c) 2009-2010 Arista Networks, Inc.
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""basic checker for Python code"""
-
-import sys
-import astroid
-from logilab.common.ureports import Table
-from astroid import are_exclusive, InferenceError
-import astroid.bases
-
-from pylint.interfaces import IAstroidChecker
-from pylint.utils import EmptyReport
-from pylint.reporters import diff_string
-from pylint.checkers import BaseChecker
-from pylint.checkers.utils import (
-    check_messages,
-    clobber_in_except,
-    is_builtin_object,
-    is_inside_except,
-    overrides_a_method,
-    safe_infer,
-    get_argument_from_call,
-    NoSuchArgumentError,
-    )
-
-
-import re
-
-# regex for class/function/variable/constant name
-CLASS_NAME_RGX = re.compile('[A-Z_][a-zA-Z0-9]+$')
-MOD_NAME_RGX = re.compile('(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$')
-CONST_NAME_RGX = re.compile('(([A-Z_][A-Z0-9_]*)|(__.*__))$')
-COMP_VAR_RGX = re.compile('[A-Za-z_][A-Za-z0-9_]*$')
-DEFAULT_NAME_RGX = re.compile('[a-z_][a-z0-9_]{2,30}$')
-CLASS_ATTRIBUTE_RGX = re.compile(r'([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$')
-# do not require a doc string on system methods
-NO_REQUIRED_DOC_RGX = re.compile('__.*__')
-REVERSED_METHODS = (('__getitem__', '__len__'),
-                    ('__reversed__', ))
-
-PY33 = sys.version_info >= (3, 3)
-BAD_FUNCTIONS = ['map', 'filter', 'apply']
-if sys.version_info < (3, 0):
-    BAD_FUNCTIONS.append('input')
-    BAD_FUNCTIONS.append('file')
-
-# Name categories that are always consistent with all naming conventions.
-EXEMPT_NAME_CATEGORIES = set(('exempt', 'ignore'))
-
-del re
-
-def in_loop(node):
-    """return True if the node is inside a kind of for loop"""
-    parent = node.parent
-    while parent is not None:
-        if isinstance(parent, (astroid.For, astroid.ListComp, astroid.SetComp,
-                               astroid.DictComp, astroid.GenExpr)):
-            return True
-        parent = parent.parent
-    return False
-
-def in_nested_list(nested_list, obj):
-    """return true if the object is an element of <nested_list> or of a nested
-    list
-    """
-    for elmt in nested_list:
-        if isinstance(elmt, (list, tuple)):
-            if in_nested_list(elmt, obj):
-                return True
-        elif elmt == obj:
-            return True
-    return False
-
-def _loop_exits_early(loop):
-    """Returns true if a loop has a break statement in its body."""
-    loop_nodes = (astroid.For, astroid.While)
-    # Loop over body explicitly to avoid matching break statements
-    # in orelse.
-    for child in loop.body:
-        if isinstance(child, loop_nodes):
-            # break statement may be in orelse of child loop.
-            for orelse in (child.orelse or ()):
-                for _ in orelse.nodes_of_class(astroid.Break, skip_klass=loop_nodes):
-                    return True
-            continue
-        for _ in child.nodes_of_class(astroid.Break, skip_klass=loop_nodes):
-            return True
-    return False
-
-if sys.version_info < (3, 0):
-    PROPERTY_CLASSES = set(('__builtin__.property', 'abc.abstractproperty'))
-else:
-    PROPERTY_CLASSES = set(('builtins.property', 'abc.abstractproperty'))
-ABC_METHODS = set(('abc.abstractproperty', 'abc.abstractmethod',
-                   'abc.abstractclassmethod', 'abc.abstractstaticmethod'))
-
-def _determine_function_name_type(node):
-    """Determine the name type whose regex the a function's name should match.
-
-    :param node: A function node.
-    :returns: One of ('function', 'method', 'attr')
-    """
-    if not node.is_method():
-        return 'function'
-    if node.decorators:
-        decorators = node.decorators.nodes
-    else:
-        decorators = []
-    for decorator in decorators:
-        # If the function is a property (decorated with @property
-        # or @abc.abstractproperty), the name type is 'attr'.
-        if (isinstance(decorator, astroid.Name) or
-            (isinstance(decorator, astroid.Getattr) and
-             decorator.attrname == 'abstractproperty')):
-            infered = safe_infer(decorator)
-            if infered and infered.qname() in PROPERTY_CLASSES:
-                return 'attr'
-        # If the function is decorated using the prop_method.{setter,getter}
-        # form, treat it like an attribute as well.
-        elif (isinstance(decorator, astroid.Getattr) and
-              decorator.attrname in ('setter', 'deleter')):
-            return 'attr'
-    return 'method'
-
-def decorated_with_abc(func):
-    """ Determine if the `func` node is decorated
-    with `abc` decorators (abstractmethod et co.)
-    """
-    if func.decorators:
-        for node in func.decorators.nodes:
-            try:
-                infered = node.infer().next()
-            except InferenceError:
-                continue
-            if infered and infered.qname() in ABC_METHODS:
-                return True
-
-def has_abstract_methods(node):
-    """ Determine if the given `node` has
-    abstract methods, defined with `abc` module.
-    """
-    return any(decorated_with_abc(meth)
-               for meth in node.mymethods())
-
-def report_by_type_stats(sect, stats, old_stats):
-    """make a report of
-
-    * percentage of different types documented
-    * percentage of different types with a bad name
-    """
-    # percentage of different types documented and/or with a bad name
-    nice_stats = {}
-    for node_type in ('module', 'class', 'method', 'function'):
-        try:
-            total = stats[node_type]
-        except KeyError:
-            raise EmptyReport()
-        nice_stats[node_type] = {}
-        if total != 0:
-            try:
-                documented = total - stats['undocumented_'+node_type]
-                percent = (documented * 100.) / total
-                nice_stats[node_type]['percent_documented'] = '%.2f' % percent
-            except KeyError:
-                nice_stats[node_type]['percent_documented'] = 'NC'
-            try:
-                percent = (stats['badname_'+node_type] * 100.) / total
-                nice_stats[node_type]['percent_badname'] = '%.2f' % percent
-            except KeyError:
-                nice_stats[node_type]['percent_badname'] = 'NC'
-    lines = ('type', 'number', 'old number', 'difference',
-             '%documented', '%badname')
-    for node_type in ('module', 'class', 'method', 'function'):
-        new = stats[node_type]
-        old = old_stats.get(node_type, None)
-        if old is not None:
-            diff_str = diff_string(old, new)
-        else:
-            old, diff_str = 'NC', 'NC'
-        lines += (node_type, str(new), str(old), diff_str,
-                  nice_stats[node_type].get('percent_documented', '0'),
-                  nice_stats[node_type].get('percent_badname', '0'))
-    sect.append(Table(children=lines, cols=6, rheaders=1))
-
-def redefined_by_decorator(node):
-    """return True if the object is a method redefined via decorator.
-
-    For example:
-        @property
-        def x(self): return self._x
-        @x.setter
-        def x(self, value): self._x = value
-    """
-    if node.decorators:
-        for decorator in node.decorators.nodes:
-            if (isinstance(decorator, astroid.Getattr) and
-                getattr(decorator.expr, 'name', None) == node.name):
-                return True
-    return False
-
-class _BasicChecker(BaseChecker):
-    __implements__ = IAstroidChecker
-    name = 'basic'
-
-class BasicErrorChecker(_BasicChecker):
-    msgs = {
-    'E0100': ('__init__ method is a generator',
-              'init-is-generator',
-              'Used when the special class method __init__ is turned into a '
-              'generator by a yield in its body.'),
-    'E0101': ('Explicit return in __init__',
-              'return-in-init',
-              'Used when the special class method __init__ has an explicit \
-              return value.'),
-    'E0102': ('%s already defined line %s',
-              'function-redefined',
-              'Used when a function / class / method is redefined.'),
-    'E0103': ('%r not properly in loop',
-              'not-in-loop',
-              'Used when break or continue keywords are used outside a loop.'),
-
-    'E0104': ('Return outside function',
-              'return-outside-function',
-              'Used when a "return" statement is found outside a function or '
-              'method.'),
-    'E0105': ('Yield outside function',
-              'yield-outside-function',
-              'Used when a "yield" statement is found outside a function or '
-              'method.'),
-    'E0106': ('Return with argument inside generator',
-              'return-arg-in-generator',
-              'Used when a "return" statement with an argument is found '
-              'outside in a generator function or method (e.g. with some '
-              '"yield" statements).',
-              {'maxversion': (3, 3)}),
-    'E0107': ("Use of the non-existent %s operator",
-              'nonexistent-operator',
-              "Used when you attempt to use the C-style pre-increment or"
-              "pre-decrement operator -- and ++, which doesn't exist in Python."),
-    'E0108': ('Duplicate argument name %s in function definition',
-              'duplicate-argument-name',
-              'Duplicate argument names in function definitions are syntax'
-              ' errors.'),
-    'E0110': ('Abstract class with abstract methods instantiated',
-              'abstract-class-instantiated',
-              'Used when an abstract class with `abc.ABCMeta` as metaclass '
-              'has abstract methods and is instantiated.',
-              {'minversion': (3, 0)}),
-    'W0120': ('Else clause on loop without a break statement',
-              'useless-else-on-loop',
-              'Loops should only have an else clause if they can exit early '
-              'with a break statement, otherwise the statements under else '
-              'should be on the same scope as the loop itself.'),
-    }
-
-    def __init__(self, linter):
-        _BasicChecker.__init__(self, linter)
-
-    @check_messages('function-redefined')
-    def visit_class(self, node):
-        self._check_redefinition('class', node)
-
-    @check_messages('init-is-generator', 'return-in-init',
-                    'function-redefined', 'return-arg-in-generator',
-                    'duplicate-argument-name')
-    def visit_function(self, node):
-        if not redefined_by_decorator(node):
-            self._check_redefinition(node.is_method() and 'method' or 'function', node)
-        # checks for max returns, branch, return in __init__
-        returns = node.nodes_of_class(astroid.Return,
-                                      skip_klass=(astroid.Function, astroid.Class))
-        if node.is_method() and node.name == '__init__':
-            if node.is_generator():
-                self.add_message('init-is-generator', node=node)
-            else:
-                values = [r.value for r in returns]
-                # Are we returning anything but None from constructors
-                if  [v for v in values if
-                     not (v is None or
-                          (isinstance(v, astroid.Const) and v.value is None) or
-                          (isinstance(v, astroid.Name)  and v.name == 'None')
-                          )]:
-                    self.add_message('return-in-init', node=node)
-        elif node.is_generator():
-            # make sure we don't mix non-None returns and yields
-            if not PY33:
-                for retnode in returns:
-                    if isinstance(retnode.value, astroid.Const) and \
-                           retnode.value.value is not None:
-                        self.add_message('return-arg-in-generator', node=node,
-                                         line=retnode.fromlineno)
-        # Check for duplicate names
-        args = set()
-        for name in node.argnames():
-            if name in args:
-                self.add_message('duplicate-argument-name', node=node, args=(name,))
-            else:
-                args.add(name)
-
-
-    @check_messages('return-outside-function')
-    def visit_return(self, node):
-        if not isinstance(node.frame(), astroid.Function):
-            self.add_message('return-outside-function', node=node)
-
-    @check_messages('yield-outside-function')
-    def visit_yield(self, node):
-        if not isinstance(node.frame(), (astroid.Function, astroid.Lambda)):
-            self.add_message('yield-outside-function', node=node)
-
-    @check_messages('not-in-loop')
-    def visit_continue(self, node):
-        self._check_in_loop(node, 'continue')
-
-    @check_messages('not-in-loop')
-    def visit_break(self, node):
-        self._check_in_loop(node, 'break')
-
-    @check_messages('useless-else-on-loop')
-    def visit_for(self, node):
-        self._check_else_on_loop(node)
-
-    @check_messages('useless-else-on-loop')
-    def visit_while(self, node):
-        self._check_else_on_loop(node)
-
-    @check_messages('nonexistent-operator')
-    def visit_unaryop(self, node):
-        """check use of the non-existent ++ and -- operator operator"""
-        if ((node.op in '+-') and
-            isinstance(node.operand, astroid.UnaryOp) and
-            (node.operand.op == node.op)):
-            self.add_message('nonexistent-operator', node=node, args=node.op*2)
-
-    @check_messages('abstract-class-instantiated')
-    def visit_callfunc(self, node):
-        """ Check instantiating abstract class with
-        abc.ABCMeta as metaclass. 
-        """
-        try:
-            infered = node.func.infer().next()
-        except astroid.InferenceError:
-            return
-        if not isinstance(infered, astroid.Class):
-            return
-        # __init__ was called
-        metaclass = infered.metaclass()
-        if metaclass is None:
-            # Python 3.4 has `abc.ABC`, which won't be detected
-            # by ClassNode.metaclass()
-            for ancestor in infered.ancestors():
-                if (ancestor.qname() == 'abc.ABC' and
-                    has_abstract_methods(infered)):
-
-                    self.add_message('abstract-class-instantiated', node=node)
-                    break
-            return
-        if (metaclass.qname() == 'abc.ABCMeta' and
-            has_abstract_methods(infered)):
-
-            self.add_message('abstract-class-instantiated', node=node)
-   
-    def _check_else_on_loop(self, node):
-        """Check that any loop with an else clause has a break statement."""
-        if node.orelse and not _loop_exits_early(node):
-            self.add_message('useless-else-on-loop', node=node,
-                             # This is not optimal, but the line previous
-                             # to the first statement in the else clause
-                             # will usually be the one that contains the else:.
-                             line=node.orelse[0].lineno - 1)
-
-    def _check_in_loop(self, node, node_name):
-        """check that a node is inside a for or while loop"""
-        _node = node.parent
-        while _node:
-            if isinstance(_node, (astroid.For, astroid.While)):
-                break
-            _node = _node.parent
-        else:
-            self.add_message('not-in-loop', node=node, args=node_name)
-
-    def _check_redefinition(self, redeftype, node):
-        """check for redefinition of a function / method / class name"""
-        defined_self = node.parent.frame()[node.name]
-        if defined_self is not node and not are_exclusive(node, defined_self):
-            self.add_message('function-redefined', node=node,
-                             args=(redeftype, defined_self.fromlineno))
-
-
-
-class BasicChecker(_BasicChecker):
-    """checks for :
-    * doc strings
-    * number of arguments, local variables, branches, returns and statements in
-functions, methods
-    * required module attributes
-    * dangerous default values as arguments
-    * redefinition of function / method / class
-    * uses of the global statement
-    """
-
-    __implements__ = IAstroidChecker
-
-    name = 'basic'
-    msgs = {
-    'W0101': ('Unreachable code',
-              'unreachable',
-              'Used when there is some code behind a "return" or "raise" \
-              statement, which will never be accessed.'),
-    'W0102': ('Dangerous default value %s as argument',
-              'dangerous-default-value',
-              'Used when a mutable value as list or dictionary is detected in \
-              a default value for an argument.'),
-    'W0104': ('Statement seems to have no effect',
-              'pointless-statement',
-              'Used when a statement doesn\'t have (or at least seems to) \
-              any effect.'),
-    'W0105': ('String statement has no effect',
-              'pointless-string-statement',
-              'Used when a string is used as a statement (which of course \
-              has no effect). This is a particular case of W0104 with its \
-              own message so you can easily disable it if you\'re using \
-              those strings as documentation, instead of comments.'),
-    'W0106': ('Expression "%s" is assigned to nothing',
-              'expression-not-assigned',
-              'Used when an expression that is not a function call is assigned\
-              to nothing. Probably something else was intended.'),
-    'W0108': ('Lambda may not be necessary',
-              'unnecessary-lambda',
-              'Used when the body of a lambda expression is a function call \
-              on the same argument list as the lambda itself; such lambda \
-              expressions are in all but a few cases replaceable with the \
-              function being called in the body of the lambda.'),
-    'W0109': ("Duplicate key %r in dictionary",
-              'duplicate-key',
-              "Used when a dictionary expression binds the same key multiple \
-              times."),
-    'W0122': ('Use of exec',
-              'exec-used',
-              'Used when you use the "exec" statement (function for Python 3), to discourage its \
-              usage. That doesn\'t mean you can not use it !'),
-    'W0123': ('Use of eval',
-              'eval-used',
-              'Used when you use the "eval" function, to discourage its '
-              'usage. Consider using `ast.literal_eval` for safely evaluating '
-              'strings containing Python expressions '
-              'from untrusted sources. '),
-    'W0141': ('Used builtin function %r',
-              'bad-builtin',
-              'Used when a black listed builtin function is used (see the '
-              'bad-function option). Usual black listed functions are the ones '
-              'like map, or filter , where Python offers now some cleaner '
-              'alternative like list comprehension.'),
-    'W0142': ('Used * or ** magic',
-              'star-args',
-              'Used when a function or method is called using `*args` or '
-              '`**kwargs` to dispatch arguments. This doesn\'t improve '
-              'readability and should be used with care.'),
-    'W0150': ("%s statement in finally block may swallow exception",
-              'lost-exception',
-              "Used when a break or a return statement is found inside the \
-              finally clause of a try...finally block: the exceptions raised \
-              in the try clause will be silently swallowed instead of being \
-              re-raised."),
-    'W0199': ('Assert called on a 2-uple. Did you mean \'assert x,y\'?',
-              'assert-on-tuple',
-              'A call of assert on a tuple will always evaluate to true if '
-              'the tuple is not empty, and will always evaluate to false if '
-              'it is.'),
-    'W0121': ('Use raise ErrorClass(args) instead of raise ErrorClass, args.',
-              'old-raise-syntax',
-              "Used when the alternate raise syntax 'raise foo, bar' is used "
-              "instead of 'raise foo(bar)'.",
-              {'maxversion': (3, 0)}),
-
-    'C0121': ('Missing required attribute "%s"', # W0103
-              'missing-module-attribute',
-              'Used when an attribute required for modules is missing.'),
-
-    'E0109': ('Missing argument to reversed()',
-              'missing-reversed-argument',
-              'Used when reversed() builtin didn\'t receive an argument.'),
-    'E0111': ('The first reversed() argument is not a sequence',
-              'bad-reversed-sequence',
-              'Used when the first argument to reversed() builtin '
-              'isn\'t a sequence (does not implement __reversed__, '
-              'nor __getitem__ and __len__'),
-
-    }
-
-    options = (('required-attributes',
-                {'default' : (), 'type' : 'csv',
-                 'metavar' : '<attributes>',
-                 'help' : 'Required attributes for module, separated by a '
-                          'comma'}
-                ),
-               ('bad-functions',
-                {'default' : BAD_FUNCTIONS,
-                 'type' :'csv', 'metavar' : '<builtin function names>',
-                 'help' : 'List of builtins function names that should not be '
-                          'used, separated by a comma'}
-                ),
-               )
-    reports = (('RP0101', 'Statistics by type', report_by_type_stats),)
-
-    def __init__(self, linter):
-        _BasicChecker.__init__(self, linter)
-        self.stats = None
-        self._tryfinallys = None
-
-    def open(self):
-        """initialize visit variables and statistics
-        """
-        self._tryfinallys = []
-        self.stats = self.linter.add_stats(module=0, function=0,
-                                           method=0, class_=0)
-    @check_messages('missing-module-attribute')
-    def visit_module(self, node):
-        """check module name, docstring and required arguments
-        """
-        self.stats['module'] += 1
-        for attr in self.config.required_attributes:
-            if attr not in node:
-                self.add_message('missing-module-attribute', node=node, args=attr)
-
-    def visit_class(self, node):
-        """check module name, docstring and redefinition
-        increment branch counter
-        """
-        self.stats['class'] += 1
-
-    @check_messages('pointless-statement', 'pointless-string-statement',
-                    'expression-not-assigned')
-    def visit_discard(self, node):
-        """check for various kind of statements without effect"""
-        expr = node.value
-        if isinstance(expr, astroid.Const) and isinstance(expr.value,
-                                                        basestring):
-            # treat string statement in a separated message
-            self.add_message('pointless-string-statement', node=node)
-            return
-        # ignore if this is :
-        # * a direct function call
-        # * the unique child of a try/except body
-        # * a yield (which are wrapped by a discard node in _ast XXX)
-        # warn W0106 if we have any underlying function call (we can't predict
-        # side effects), else pointless-statement
-        if (isinstance(expr, (astroid.Yield, astroid.CallFunc)) or
-            (isinstance(node.parent, astroid.TryExcept) and
-             node.parent.body == [node])):
-            return
-        if any(expr.nodes_of_class(astroid.CallFunc)):
-            self.add_message('expression-not-assigned', node=node, args=expr.as_string())
-        else:
-            self.add_message('pointless-statement', node=node)
-
-    @check_messages('unnecessary-lambda')
-    def visit_lambda(self, node):
-        """check whether or not the lambda is suspicious
-        """
-        # if the body of the lambda is a call expression with the same
-        # argument list as the lambda itself, then the lambda is
-        # possibly unnecessary and at least suspicious.
-        if node.args.defaults:
-            # If the arguments of the lambda include defaults, then a
-            # judgment cannot be made because there is no way to check
-            # that the defaults defined by the lambda are the same as
-            # the defaults defined by the function called in the body
-            # of the lambda.
-            return
-        call = node.body
-        if not isinstance(call, astroid.CallFunc):
-            # The body of the lambda must be a function call expression
-            # for the lambda to be unnecessary.
-            return
-        # XXX are lambda still different with astroid >= 0.18 ?
-        # *args and **kwargs need to be treated specially, since they
-        # are structured differently between the lambda and the function
-        # call (in the lambda they appear in the args.args list and are
-        # indicated as * and ** by two bits in the lambda's flags, but
-        # in the function call they are omitted from the args list and
-        # are indicated by separate attributes on the function call node).
-        ordinary_args = list(node.args.args)
-        if node.args.kwarg:
-            if (not call.kwargs
-                or not isinstance(call.kwargs, astroid.Name)
-                or node.args.kwarg != call.kwargs.name):
-                return
-        elif call.kwargs:
-            return
-        if node.args.vararg:
-            if (not call.starargs
-                or not isinstance(call.starargs, astroid.Name)
-                or node.args.vararg != call.starargs.name):
-                return
-        elif call.starargs:
-            return
-        # The "ordinary" arguments must be in a correspondence such that:
-        # ordinary_args[i].name == call.args[i].name.
-        if len(ordinary_args) != len(call.args):
-            return
-        for i in xrange(len(ordinary_args)):
-            if not isinstance(call.args[i], astroid.Name):
-                return
-            if node.args.args[i].name != call.args[i].name:
-                return
-        self.add_message('unnecessary-lambda', line=node.fromlineno, node=node)
-
-    @check_messages('dangerous-default-value')
-    def visit_function(self, node):
-        """check function name, docstring, arguments, redefinition,
-        variable names, max locals
-        """
-        self.stats[node.is_method() and 'method' or 'function'] += 1
-        # check for dangerous default values as arguments
-        for default in node.args.defaults:
-            try:
-                value = default.infer().next()
-            except astroid.InferenceError:
-                continue
-            builtins = astroid.bases.BUILTINS
-            if (isinstance(value, astroid.Instance) and
-                value.qname() in ['.'.join([builtins, x]) for x in ('set', 'dict', 'list')]):
-                if value is default:
-                    msg = default.as_string()
-                elif type(value) is astroid.Instance:
-                    msg = '%s (%s)' % (default.as_string(), value.qname())
-                else:
-                    msg = '%s (%s)' % (default.as_string(), value.as_string())
-                self.add_message('dangerous-default-value', node=node, args=(msg,))
-
-    @check_messages('unreachable', 'lost-exception')
-    def visit_return(self, node):
-        """1 - check is the node has a right sibling (if so, that's some
-        unreachable code)
-        2 - check is the node is inside the finally clause of a try...finally
-        block
-        """
-        self._check_unreachable(node)
-        # Is it inside final body of a try...finally bloc ?
-        self._check_not_in_finally(node, 'return', (astroid.Function,))
-
-    @check_messages('unreachable')
-    def visit_continue(self, node):
-        """check is the node has a right sibling (if so, that's some unreachable
-        code)
-        """
-        self._check_unreachable(node)
-
-    @check_messages('unreachable', 'lost-exception')
-    def visit_break(self, node):
-        """1 - check is the node has a right sibling (if so, that's some
-        unreachable code)
-        2 - check is the node is inside the finally clause of a try...finally
-        block
-        """
-        # 1 - Is it right sibling ?
-        self._check_unreachable(node)
-        # 2 - Is it inside final body of a try...finally bloc ?
-        self._check_not_in_finally(node, 'break', (astroid.For, astroid.While,))
-
-    @check_messages('unreachable', 'old-raise-syntax')
-    def visit_raise(self, node):
-        """check if the node has a right sibling (if so, that's some unreachable
-        code)
-        """
-        self._check_unreachable(node)
-        if sys.version_info >= (3, 0):
-            return
-        if node.exc is not None and node.inst is not None and node.tback is None:
-            self.add_message('old-raise-syntax', node=node)
-
-    @check_messages('exec-used')
-    def visit_exec(self, node):
-        """just print a warning on exec statements"""
-        self.add_message('exec-used', node=node)
-
-    @check_messages('bad-builtin', 'star-args', 'eval-used', 
-                    'exec-used', 'missing-reversed-argument', 
-                    'bad-reversed-sequence')
-    def visit_callfunc(self, node):
-        """visit a CallFunc node -> check if this is not a blacklisted builtin
-        call and check for * or ** use
-        """
-        if isinstance(node.func, astroid.Name):
-            name = node.func.name
-            # ignore the name if it's not a builtin (i.e. not defined in the
-            # locals nor globals scope)
-            if not (name in node.frame() or
-                    name in node.root()):
-                if name == 'exec':
-                    self.add_message('exec-used', node=node)
-                elif name == 'reversed':
-                    self._check_reversed(node)
-                elif name == 'eval':
-                    self.add_message('eval-used', node=node)
-                if name in self.config.bad_functions:
-                    self.add_message('bad-builtin', node=node, args=name)
-        if node.starargs or node.kwargs:
-            scope = node.scope()
-            if isinstance(scope, astroid.Function):
-                toprocess = [(n, vn) for (n, vn) in ((node.starargs, scope.args.vararg),
-                                                     (node.kwargs, scope.args.kwarg)) if n]
-                if toprocess:
-                    for cfnode, fargname in toprocess[:]:
-                        if getattr(cfnode, 'name', None) == fargname:
-                            toprocess.remove((cfnode, fargname))
-                    if not toprocess:
-                        return # star-args can be skipped
-            self.add_message('star-args', node=node.func)
-
-    @check_messages('assert-on-tuple')
-    def visit_assert(self, node):
-        """check the use of an assert statement on a tuple."""
-        if node.fail is None and isinstance(node.test, astroid.Tuple) and \
-           len(node.test.elts) == 2:
-            self.add_message('assert-on-tuple', node=node)
-
-    @check_messages('duplicate-key')
-    def visit_dict(self, node):
-        """check duplicate key in dictionary"""
-        keys = set()
-        for k, _ in node.items:
-            if isinstance(k, astroid.Const):
-                key = k.value
-                if key in keys:
-                    self.add_message('duplicate-key', node=node, args=key)
-                keys.add(key)
-
-    def visit_tryfinally(self, node):
-        """update try...finally flag"""
-        self._tryfinallys.append(node)
-
-    def leave_tryfinally(self, node):
-        """update try...finally flag"""
-        self._tryfinallys.pop()
-
-    def _check_unreachable(self, node):
-        """check unreachable code"""
-        unreach_stmt = node.next_sibling()
-        if unreach_stmt is not None:
-            self.add_message('unreachable', node=unreach_stmt)
-
-    def _check_not_in_finally(self, node, node_name, breaker_classes=()):
-        """check that a node is not inside a finally clause of a
-        try...finally statement.
-        If we found before a try...finally bloc a parent which its type is
-        in breaker_classes, we skip the whole check."""
-        # if self._tryfinallys is empty, we're not a in try...finally bloc
-        if not self._tryfinallys:
-            return
-        # the node could be a grand-grand...-children of the try...finally
-        _parent = node.parent
-        _node = node
-        while _parent and not isinstance(_parent, breaker_classes):
-            if hasattr(_parent, 'finalbody') and _node in _parent.finalbody:
-                self.add_message('lost-exception', node=node, args=node_name)
-                return
-            _node = _parent
-            _parent = _node.parent
-    
-    def _check_reversed(self, node):
-        """ check that the argument to `reversed` is a sequence """
-        try:
-            argument = safe_infer(get_argument_from_call(node, position=0))
-        except NoSuchArgumentError:
-            self.add_message('missing-reversed-argument', node=node)
-        else:
-            if argument is astroid.YES:
-                return
-            if argument is None:
-                # nothing was infered
-                # try to see if we have iter()
-                if isinstance(node.args[0], astroid.CallFunc):
-                    try:
-                        func = node.args[0].func.infer().next()
-                    except InferenceError:
-                        return
-                    if (getattr(func, 'name', None) == 'iter' and
-                        is_builtin_object(func)):
-                        self.add_message('bad-reversed-sequence', node=node)
-                return
-
-            if isinstance(argument, astroid.Instance):
-                if (argument._proxied.name == 'dict' and 
-                    is_builtin_object(argument._proxied)):
-                     self.add_message('bad-reversed-sequence', node=node)
-                     return
-                elif any(ancestor.name == 'dict' and is_builtin_object(ancestor)
-                       for ancestor in argument._proxied.ancestors()):
-                    # mappings aren't accepted by reversed()
-                    self.add_message('bad-reversed-sequence', node=node)
-                    return
-
-                for methods in REVERSED_METHODS:
-                    for meth in methods:
-                        try:
-                            argument.getattr(meth)
-                        except astroid.NotFoundError:
-                            break
-                    else:
-                        break
-                else:             
-                    # check if it is a .deque. It doesn't seem that
-                    # we can retrieve special methods 
-                    # from C implemented constructs    
-                    if argument._proxied.qname().endswith(".deque"):
-                        return
-                    self.add_message('bad-reversed-sequence', node=node)
-            elif not isinstance(argument, (astroid.List, astroid.Tuple)):
-                # everything else is not a proper sequence for reversed()
-                self.add_message('bad-reversed-sequence', node=node)
-
-_NAME_TYPES = {
-    'module': (MOD_NAME_RGX, 'module'),
-    'const': (CONST_NAME_RGX, 'constant'),
-    'class': (CLASS_NAME_RGX, 'class'),
-    'function': (DEFAULT_NAME_RGX, 'function'),
-    'method': (DEFAULT_NAME_RGX, 'method'),
-    'attr': (DEFAULT_NAME_RGX, 'attribute'),
-    'argument': (DEFAULT_NAME_RGX, 'argument'),
-    'variable': (DEFAULT_NAME_RGX, 'variable'),
-    'class_attribute': (CLASS_ATTRIBUTE_RGX, 'class attribute'),
-    'inlinevar': (COMP_VAR_RGX, 'inline iteration'),
-}
-
-def _create_naming_options():
-    name_options = []
-    for name_type, (rgx, human_readable_name) in _NAME_TYPES.iteritems():
-        name_type = name_type.replace('_', '-')
-        name_options.append((
-            '%s-rgx' % (name_type,), 
-            {'default': rgx, 'type': 'regexp', 'metavar': '<regexp>',
-             'help': 'Regular expression matching correct %s names' % (human_readable_name,)}))
-        name_options.append((
-            '%s-name-hint' % (name_type,), 
-            {'default': rgx.pattern, 'type': 'string', 'metavar': '<string>',
-             'help': 'Naming hint for %s names' % (human_readable_name,)}))
-
-    return tuple(name_options) 
-
-class NameChecker(_BasicChecker):
-    msgs = {
-    'C0102': ('Black listed name "%s"',
-              'blacklisted-name',
-              'Used when the name is listed in the black list (unauthorized \
-              names).'),
-    'C0103': ('Invalid %s name "%s"%s',
-              'invalid-name',
-              'Used when the name doesn\'t match the regular expression \
-              associated to its type (constant, variable, class...).'),
-    }
-
-    options = (# XXX use set
-               ('good-names',
-                {'default' : ('i', 'j', 'k', 'ex', 'Run', '_'),
-                 'type' :'csv', 'metavar' : '<names>',
-                 'help' : 'Good variable names which should always be accepted,'
-                          ' separated by a comma'}
-                ),
-               ('bad-names',
-                {'default' : ('foo', 'bar', 'baz', 'toto', 'tutu', 'tata'),
-                 'type' :'csv', 'metavar' : '<names>',
-                 'help' : 'Bad variable names which should always be refused, '
-                          'separated by a comma'}
-                ),
-               ('name-group',
-                {'default' : (),
-                 'type' :'csv', 'metavar' : '<name1:name2>',
-                 'help' : ('Colon-delimited sets of names that determine each'
-                           ' other\'s naming style when the name regexes'
-                           ' allow several styles.')}
-                ),
-               ('include-naming-hint',
-                {'default': False, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                 'help': 'Include a hint for the correct naming format with invalid-name'}
-                ),
-               ) + _create_naming_options()
-
-
-    def __init__(self, linter):
-        _BasicChecker.__init__(self, linter)
-        self._name_category = {}
-        self._name_group = {}
-
-    def open(self):
-        self.stats = self.linter.add_stats(badname_module=0,
-                                           badname_class=0, badname_function=0,
-                                           badname_method=0, badname_attr=0,
-                                           badname_const=0,
-                                           badname_variable=0,
-                                           badname_inlinevar=0,
-                                           badname_argument=0,
-                                           badname_class_attribute=0)
-        for group in self.config.name_group:
-            for name_type in group.split(':'):
-                self._name_group[name_type] = 'group_%s' % (group,)
-
-    @check_messages('blacklisted-name', 'invalid-name')
-    def visit_module(self, node):
-        self._check_name('module', node.name.split('.')[-1], node)
-
-    @check_messages('blacklisted-name', 'invalid-name')
-    def visit_class(self, node):
-        self._check_name('class', node.name, node)
-        for attr, anodes in node.instance_attrs.iteritems():
-            if not list(node.instance_attr_ancestors(attr)):
-                self._check_name('attr', attr, anodes[0])
-
-    @check_messages('blacklisted-name', 'invalid-name')
-    def visit_function(self, node):
-        # Do not emit any warnings if the method is just an implementation
-        # of a base class method.
-        if node.is_method() and overrides_a_method(node.parent.frame(), node.name):
-            return
-        self._check_name(_determine_function_name_type(node),
-                         node.name, node)
-        # Check argument names
-        args = node.args.args
-        if args is not None:
-            self._recursive_check_names(args, node)
-
-    @check_messages('blacklisted-name', 'invalid-name')
-    def visit_global(self, node):
-        for name in node.names:
-            self._check_name('const', name, node)
-
-    @check_messages('blacklisted-name', 'invalid-name')
-    def visit_assname(self, node):
-        """check module level assigned names"""
-        frame = node.frame()
-        ass_type = node.ass_type()
-        if isinstance(ass_type, astroid.Comprehension):
-            self._check_name('inlinevar', node.name, node)
-        elif isinstance(frame, astroid.Module):
-            if isinstance(ass_type, astroid.Assign) and not in_loop(ass_type):
-                if isinstance(safe_infer(ass_type.value), astroid.Class):
-                    self._check_name('class', node.name, node)
-                else:
-                    self._check_name('const', node.name, node)
-            elif isinstance(ass_type, astroid.ExceptHandler):
-                self._check_name('variable', node.name, node)
-        elif isinstance(frame, astroid.Function):
-            # global introduced variable aren't in the function locals
-            if node.name in frame and node.name not in frame.argnames():
-                self._check_name('variable', node.name, node)
-        elif isinstance(frame, astroid.Class):
-            if not list(frame.local_attr_ancestors(node.name)):
-                self._check_name('class_attribute', node.name, node)
-
-    def _recursive_check_names(self, args, node):
-        """check names in a possibly recursive list <arg>"""
-        for arg in args:
-            if isinstance(arg, astroid.AssName):
-                self._check_name('argument', arg.name, node)
-            else:
-                self._recursive_check_names(arg.elts, node)
-
-    def _find_name_group(self, node_type):
-        return self._name_group.get(node_type, node_type)
-
-    def _is_multi_naming_match(self, match):
-        return (match is not None and
-                match.lastgroup is not None and
-                match.lastgroup not in EXEMPT_NAME_CATEGORIES)
-
-    def _check_name(self, node_type, name, node):
-        """check for a name using the type's regexp"""
-        if is_inside_except(node):
-            clobbering, _ = clobber_in_except(node)
-            if clobbering:
-                return
-        if name in self.config.good_names:
-            return
-        if name in self.config.bad_names:
-            self.stats['badname_' + node_type] += 1
-            self.add_message('blacklisted-name', node=node, args=name)
-            return
-        regexp = getattr(self.config, node_type + '_rgx')
-        match = regexp.match(name)
-
-        if self._is_multi_naming_match(match):
-            name_group = self._find_name_group(node_type)
-            if name_group not in self._name_category:
-                self._name_category[name_group] = match.lastgroup
-            elif self._name_category[name_group] != match.lastgroup:
-                match = None
-
-        if match is None:
-            type_label = _NAME_TYPES[node_type][1]
-            hint = ''
-            if self.config.include_naming_hint:
-                hint = ' (hint: %s)' % (getattr(self.config, node_type + '_name_hint'))
-            self.add_message('invalid-name', node=node, args=(type_label, name, hint))
-            self.stats['badname_' + node_type] += 1
-
-
-class DocStringChecker(_BasicChecker):
-    msgs = {
-    'C0111': ('Missing %s docstring', # W0131
-              'missing-docstring',
-              'Used when a module, function, class or method has no docstring.\
-              Some special methods like __init__ doesn\'t necessary require a \
-              docstring.'),
-    'C0112': ('Empty %s docstring', # W0132
-              'empty-docstring',
-              'Used when a module, function, class or method has an empty \
-              docstring (it would be too easy ;).'),
-    }
-    options = (('no-docstring-rgx',
-                {'default' : NO_REQUIRED_DOC_RGX,
-                 'type' : 'regexp', 'metavar' : '<regexp>',
-                 'help' : 'Regular expression which should only match '
-                          'function or class names that do not require a '
-                          'docstring.'}
-                ),
-               ('docstring-min-length',
-                {'default' : -1,
-                 'type' : 'int', 'metavar' : '<int>',
-                 'help': ('Minimum line length for functions/classes that'
-                          ' require docstrings, shorter ones are exempt.')}
-                ),
-               )
-
-
-    def open(self):
-        self.stats = self.linter.add_stats(undocumented_module=0,
-                                           undocumented_function=0,
-                                           undocumented_method=0,
-                                           undocumented_class=0)
-    @check_messages('missing-docstring', 'empty-docstring')
-    def visit_module(self, node):
-        self._check_docstring('module', node)
-
-    @check_messages('missing-docstring', 'empty-docstring')
-    def visit_class(self, node):
-        if self.config.no_docstring_rgx.match(node.name) is None:
-            self._check_docstring('class', node)
-    @check_messages('missing-docstring', 'empty-docstring')
-    def visit_function(self, node):
-        if self.config.no_docstring_rgx.match(node.name) is None:
-            ftype = node.is_method() and 'method' or 'function'
-            if isinstance(node.parent.frame(), astroid.Class):
-                overridden = False
-                # check if node is from a method overridden by its ancestor
-                for ancestor in node.parent.frame().ancestors():
-                    if node.name in ancestor and \
-                       isinstance(ancestor[node.name], astroid.Function):
-                        overridden = True
-                        break
-                self._check_docstring(ftype, node,
-                                      report_missing=not overridden)
-            else:
-                self._check_docstring(ftype, node)
-
-    def _check_docstring(self, node_type, node, report_missing=True):
-        """check the node has a non empty docstring"""
-        docstring = node.doc
-        if docstring is None:
-            if not report_missing:
-                return
-            if node.body:
-                lines = node.body[-1].lineno - node.body[0].lineno + 1
-            else:
-                lines = 0
-            max_lines = self.config.docstring_min_length
-
-            if node_type != 'module' and max_lines > -1 and lines < max_lines:
-                return
-            self.stats['undocumented_'+node_type] += 1
-            self.add_message('missing-docstring', node=node, args=(node_type,))
-        elif not docstring.strip():
-            self.stats['undocumented_'+node_type] += 1
-            self.add_message('empty-docstring', node=node, args=(node_type,))
-
-
-class PassChecker(_BasicChecker):
-    """check if the pass statement is really necessary"""
-    msgs = {'W0107': ('Unnecessary pass statement',
-                      'unnecessary-pass',
-                      'Used when a "pass" statement that can be avoided is '
-                      'encountered.'),
-            }
-    @check_messages('unnecessary-pass')
-    def visit_pass(self, node):
-        if len(node.parent.child_sequence(node)) > 1:
-            self.add_message('unnecessary-pass', node=node)
-
-
-class LambdaForComprehensionChecker(_BasicChecker):
-    """check for using a lambda where a comprehension would do.
-
-    See <http://www.artima.com/weblogs/viewpost.jsp?thread=98196>
-    where GvR says comprehensions would be clearer.
-    """
-
-    msgs = {'W0110': ('map/filter on lambda could be replaced by comprehension',
-                      'deprecated-lambda',
-                      'Used when a lambda is the first argument to "map" or '
-                      '"filter". It could be clearer as a list '
-                      'comprehension or generator expression.',
-                      {'maxversion': (3, 0)}),
-            }
-
-    @check_messages('deprecated-lambda')
-    def visit_callfunc(self, node):
-        """visit a CallFunc node, check if map or filter are called with a
-        lambda
-        """
-        if not node.args:
-            return
-        if not isinstance(node.args[0], astroid.Lambda):
-            return
-        infered = safe_infer(node.func)
-        if (is_builtin_object(infered)
-            and infered.name in ['map', 'filter']):
-            self.add_message('deprecated-lambda', node=node)
-
-
-def register(linter):
-    """required method to auto register this checker"""
-    linter.register_checker(BasicErrorChecker(linter))
-    linter.register_checker(BasicChecker(linter))
-    linter.register_checker(NameChecker(linter))
-    linter.register_checker(DocStringChecker(linter))
-    linter.register_checker(PassChecker(linter))
-    linter.register_checker(LambdaForComprehensionChecker(linter))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/classes.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/classes.py
deleted file mode 100644
index f5e2783f..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/classes.py
+++ /dev/null
@@ -1,792 +0,0 @@
-# Copyright (c) 2003-2014 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""classes checker for Python code
-"""
-from __future__ import generators
-
-import sys
-
-import astroid
-from astroid import YES, Instance, are_exclusive, AssAttr
-from astroid.bases import Generator
-
-from pylint.interfaces import IAstroidChecker
-from pylint.checkers import BaseChecker
-from pylint.checkers.utils import (PYMETHODS, overrides_a_method,
-    check_messages, is_attr_private, is_attr_protected, node_frame_class)
-
-if sys.version_info >= (3, 0):
-    NEXT_METHOD = '__next__'
-else:
-    NEXT_METHOD = 'next'
-ITER_METHODS = ('__iter__', '__getitem__')
-
-def class_is_abstract(node):
-    """return true if the given class node should be considered as an abstract
-    class
-    """
-    for method in node.methods():
-        if method.parent.frame() is node:
-            if method.is_abstract(pass_is_abstract=False):
-                return True
-    return False
-
-
-MSGS = {
-    'F0202': ('Unable to check methods signature (%s / %s)',
-              'method-check-failed',
-              'Used when PyLint has been unable to check methods signature \
-              compatibility for an unexpected reason. Please report this kind \
-              if you don\'t make sense of it.'),
-
-    'E0202': ('An attribute defined in %s line %s hides this method',
-              'method-hidden',
-              'Used when a class defines a method which is hidden by an '
-              'instance attribute from an ancestor class or set by some '
-              'client code.'),
-    'E0203': ('Access to member %r before its definition line %s',
-              'access-member-before-definition',
-              'Used when an instance member is accessed before it\'s actually\
-              assigned.'),
-    'W0201': ('Attribute %r defined outside __init__',
-              'attribute-defined-outside-init',
-              'Used when an instance attribute is defined outside the __init__\
-              method.'),
-
-    'W0212': ('Access to a protected member %s of a client class', # E0214
-              'protected-access',
-              'Used when a protected member (i.e. class member with a name \
-              beginning with an underscore) is access outside the class or a \
-              descendant of the class where it\'s defined.'),
-
-    'E0211': ('Method has no argument',
-              'no-method-argument',
-              'Used when a method which should have the bound instance as \
-              first argument has no argument defined.'),
-    'E0213': ('Method should have "self" as first argument',
-              'no-self-argument',
-              'Used when a method has an attribute different the "self" as\
-              first argument. This is considered as an error since this is\
-              a so common convention that you shouldn\'t break it!'),
-    'C0202': ('Class method %s should have %s as first argument', # E0212
-              'bad-classmethod-argument',
-              'Used when a class method has a first argument named differently '
-              'than the value specified in valid-classmethod-first-arg option '
-              '(default to "cls"), recommended to easily differentiate them '
-              'from regular instance methods.'),
-    'C0203': ('Metaclass method %s should have %s as first argument', # E0214
-              'bad-mcs-method-argument',
-              'Used when a metaclass method has a first agument named '
-              'differently than the value specified in valid-classmethod-first'
-              '-arg option (default to "cls"), recommended to easily '
-              'differentiate them from regular instance methods.'),
-    'C0204': ('Metaclass class method %s should have %s as first argument',
-              'bad-mcs-classmethod-argument',
-              'Used when a metaclass class method has a first argument named '
-              'differently than the value specified in valid-metaclass-'
-              'classmethod-first-arg option (default to "mcs"), recommended to '
-              'easily differentiate them from regular instance methods.'),
-
-    'W0211': ('Static method with %r as first argument',
-              'bad-staticmethod-argument',
-              'Used when a static method has "self" or a value specified in '
-              'valid-classmethod-first-arg option or '
-              'valid-metaclass-classmethod-first-arg option as first argument.'
-              ),
-    'R0201': ('Method could be a function',
-              'no-self-use',
-              'Used when a method doesn\'t use its bound instance, and so could\
-              be written as a function.'
-              ),
-
-    'E0221': ('Interface resolved to %s is not a class',
-              'interface-is-not-class',
-              'Used when a class claims to implement an interface which is not \
-              a class.'),
-    'E0222': ('Missing method %r from %s interface',
-              'missing-interface-method',
-              'Used when a method declared in an interface is missing from a \
-              class implementing this interface'),
-    'W0221': ('Arguments number differs from %s method',
-              'arguments-differ',
-              'Used when a method has a different number of arguments than in \
-              the implemented interface or in an overridden method.'),
-    'W0222': ('Signature differs from %s method',
-              'signature-differs',
-              'Used when a method signature is different than in the \
-              implemented interface or in an overridden method.'),
-    'W0223': ('Method %r is abstract in class %r but is not overridden',
-              'abstract-method',
-              'Used when an abstract method (i.e. raise NotImplementedError) is \
-              not overridden in concrete class.'
-              ),
-    'F0220': ('failed to resolve interfaces implemented by %s (%s)', # W0224
-              'unresolved-interface',
-              'Used when a PyLint as failed to find interfaces implemented by \
-               a class'),
-
-
-    'W0231': ('__init__ method from base class %r is not called',
-              'super-init-not-called',
-              'Used when an ancestor class method has an __init__ method \
-              which is not called by a derived class.'),
-    'W0232': ('Class has no __init__ method',
-              'no-init',
-              'Used when a class has no __init__ method, neither its parent \
-              classes.'),
-    'W0233': ('__init__ method from a non direct base class %r is called',
-              'non-parent-init-called',
-              'Used when an __init__ method is called on a class which is not \
-              in the direct ancestors for the analysed class.'),
-    'W0234': ('__iter__ returns non-iterator',
-              'non-iterator-returned',
-              'Used when an __iter__ method returns something which is not an \
-               iterable (i.e. has no `%s` method)' % NEXT_METHOD),
-    'E0235': ('__exit__ must accept 3 arguments: type, value, traceback',
-              'bad-context-manager',
-              'Used when the __exit__ special method, belonging to a \
-               context manager, does not accept 3 arguments \
-               (type, value, traceback).'),
-    'E0236': ('Invalid object %r in __slots__, must contain '
-              'only non empty strings',
-              'invalid-slots-object',
-              'Used when an invalid (non-string) object occurs in __slots__.'),
-    'E0238': ('Invalid __slots__ object',
-              'invalid-slots',
-              'Used when an invalid __slots__ is found in class. '
-              'Only a string, an iterable or a sequence is permitted.')
-
-
-    }
-
-
-class ClassChecker(BaseChecker):
-    """checks for :
-    * methods without self as first argument
-    * overridden methods signature
-    * access only to existent members via self
-    * attributes not defined in the __init__ method
-    * supported interfaces implementation
-    * unreachable code
-    """
-
-    __implements__ = (IAstroidChecker,)
-
-    # configuration section name
-    name = 'classes'
-    # messages
-    msgs = MSGS
-    priority = -2
-    # configuration options
-    options = (('ignore-iface-methods',
-                {'default' : (#zope interface
-        'isImplementedBy', 'deferred', 'extends', 'names',
-        'namesAndDescriptions', 'queryDescriptionFor', 'getBases',
-        'getDescriptionFor', 'getDoc', 'getName', 'getTaggedValue',
-        'getTaggedValueTags', 'isEqualOrExtendedBy', 'setTaggedValue',
-        'isImplementedByInstancesOf',
-        # twisted
-        'adaptWith',
-        # logilab.common interface
-        'is_implemented_by'),
-                 'type' : 'csv',
-                 'metavar' : '<method names>',
-                 'help' : 'List of interface methods to ignore, \
-separated by a comma. This is used for instance to not check methods defines \
-in Zope\'s Interface base class.'}
-                ),
-
-               ('defining-attr-methods',
-                {'default' : ('__init__', '__new__', 'setUp'),
-                 'type' : 'csv',
-                 'metavar' : '<method names>',
-                 'help' : 'List of method names used to declare (i.e. assign) \
-instance attributes.'}
-                ),
-               ('valid-classmethod-first-arg',
-                {'default' : ('cls',),
-                 'type' : 'csv',
-                 'metavar' : '<argument names>',
-                 'help' : 'List of valid names for the first argument in \
-a class method.'}
-                ),
-               ('valid-metaclass-classmethod-first-arg',
-                {'default' : ('mcs',),
-                 'type' : 'csv',
-                 'metavar' : '<argument names>',
-                 'help' : 'List of valid names for the first argument in \
-a metaclass class method.'}
-                ),
-
-               )
-
-    def __init__(self, linter=None):
-        BaseChecker.__init__(self, linter)
-        self._accessed = []
-        self._first_attrs = []
-        self._meth_could_be_func = None
-
-    def visit_class(self, node):
-        """init visit variable _accessed and check interfaces
-        """
-        self._accessed.append({})
-        self._check_bases_classes(node)
-        self._check_interfaces(node)
-        # if not an interface, exception, metaclass
-        if node.type == 'class':
-            try:
-                node.local_attr('__init__')
-            except astroid.NotFoundError:
-                self.add_message('no-init', args=node, node=node)
-        self._check_slots(node)
-
-    @check_messages('access-member-before-definition', 'attribute-defined-outside-init')
-    def leave_class(self, cnode):
-        """close a class node:
-        check that instance attributes are defined in __init__ and check
-        access to existent members
-        """
-        # check access to existent members on non metaclass classes
-        accessed = self._accessed.pop()
-        if cnode.type != 'metaclass':
-            self._check_accessed_members(cnode, accessed)
-        # checks attributes are defined in an allowed method such as __init__
-        if not self.linter.is_message_enabled('attribute-defined-outside-init'):
-            return
-        defining_methods = self.config.defining_attr_methods
-        for attr, nodes in cnode.instance_attrs.iteritems():
-            nodes = [n for n in nodes if not
-                    isinstance(n.statement(), (astroid.Delete, astroid.AugAssign))]
-            if not nodes:
-                continue # error detected by typechecking
-            attr_defined = False
-            # check if any method attr is defined in is a defining method
-            for node in nodes:
-                if node.frame().name in defining_methods:
-                    attr_defined = True
-            if not attr_defined:
-                # check attribute is defined in a parent's __init__
-                for parent in cnode.instance_attr_ancestors(attr):
-                    attr_defined = False
-                    # check if any parent method attr is defined in is a defining method
-                    for node in parent.instance_attrs[attr]:
-                        if node.frame().name in defining_methods:
-                            attr_defined = True
-                    if attr_defined:
-                        # we're done :)
-                        break
-                else:
-                    # check attribute is defined as a class attribute
-                    try:
-                        cnode.local_attr(attr)
-                    except astroid.NotFoundError:
-                        self.add_message('attribute-defined-outside-init', args=attr, node=node)
-
-    def visit_function(self, node):
-        """check method arguments, overriding"""
-        # ignore actual functions
-        if not node.is_method():
-            return
-        klass = node.parent.frame()
-        self._meth_could_be_func = True
-        # check first argument is self if this is actually a method
-        self._check_first_arg_for_type(node, klass.type == 'metaclass')
-        if node.name == '__init__':
-            self._check_init(node)
-            return
-        # check signature if the method overloads inherited method
-        for overridden in klass.local_attr_ancestors(node.name):
-            # get astroid for the searched method
-            try:
-                meth_node = overridden[node.name]
-            except KeyError:
-                # we have found the method but it's not in the local
-                # dictionary.
-                # This may happen with astroid build from living objects
-                continue
-            if not isinstance(meth_node, astroid.Function):
-                continue
-            self._check_signature(node, meth_node, 'overridden')
-            break
-        if node.decorators:
-            for decorator in node.decorators.nodes:
-                if isinstance(decorator, astroid.Getattr) and \
-                        decorator.attrname in ('getter', 'setter', 'deleter'):
-                    # attribute affectation will call this method, not hiding it
-                    return
-                if isinstance(decorator, astroid.Name) and decorator.name == 'property':
-                    # attribute affectation will either call a setter or raise
-                    # an attribute error, anyway not hiding the function
-                    return
-        # check if the method is hidden by an attribute
-        try:
-            overridden = klass.instance_attr(node.name)[0] # XXX
-            args = (overridden.root().name, overridden.fromlineno)
-            self.add_message('method-hidden', args=args, node=node)
-        except astroid.NotFoundError:
-            pass
-
-        # check non-iterators in __iter__
-        if node.name == '__iter__':
-            self._check_iter(node)
-        elif node.name == '__exit__':
-            self._check_exit(node)
-
-    def _check_slots(self, node):
-        if '__slots__' not in node.locals:
-            return
-        for slots in node.igetattr('__slots__'):
-            # check if __slots__ is a valid type
-            for meth in ITER_METHODS:
-                try:
-                    slots.getattr(meth)
-                    break
-                except astroid.NotFoundError:
-                    continue
-            else:
-                self.add_message('invalid-slots', node=node)
-                continue
-
-            if isinstance(slots, astroid.Const):
-                # a string, ignore the following checks
-                continue
-            if not hasattr(slots, 'itered'):
-                # we can't obtain the values, maybe a .deque?
-                continue
-
-            if isinstance(slots, astroid.Dict):
-                values = [item[0] for item in slots.items]
-            else:
-                values = slots.itered()
-            if values is YES:
-                return
-
-            for elt in values:
-                try:
-                    self._check_slots_elt(elt)
-                except astroid.InferenceError:
-                    continue
-
-    def _check_slots_elt(self, elt):
-        for infered in elt.infer():
-            if infered is YES:
-                continue
-            if (not isinstance(infered, astroid.Const) or
-                not isinstance(infered.value, str)):
-                self.add_message('invalid-slots-object',
-                                 args=infered.as_string(),
-                                 node=elt)
-                continue
-            if not infered.value:
-                self.add_message('invalid-slots-object',
-                                 args=infered.as_string(),
-                                 node=elt)
-
-    def _check_iter(self, node):
-        try:
-            infered = node.infer_call_result(node)
-        except astroid.InferenceError:
-            return
-
-        for infered_node in infered:
-            if (infered_node is YES
-                or isinstance(infered_node, Generator)):
-                continue
-            if isinstance(infered_node, astroid.Instance):
-                try:
-                    infered_node.local_attr(NEXT_METHOD)
-                except astroid.NotFoundError:
-                    self.add_message('non-iterator-returned',
-                                     node=node)
-                    break
-
-    def _check_exit(self, node):
-        positional = sum(1 for arg in node.args.args if arg.name != 'self')
-        if positional < 3 and not node.args.vararg:
-            self.add_message('bad-context-manager',
-                             node=node)
-        elif positional > 3:
-            self.add_message('bad-context-manager',
-                             node=node)
-
-    def leave_function(self, node):
-        """on method node, check if this method couldn't be a function
-
-        ignore class, static and abstract methods, initializer,
-        methods overridden from a parent class and any
-        kind of method defined in an interface for this warning
-        """
-        if node.is_method():
-            if node.args.args is not None:
-                self._first_attrs.pop()
-            if not self.linter.is_message_enabled('no-self-use'):
-                return
-            class_node = node.parent.frame()
-            if (self._meth_could_be_func and node.type == 'method'
-                and not node.name in PYMETHODS
-                and not (node.is_abstract() or
-                         overrides_a_method(class_node, node.name))
-                and class_node.type != 'interface'):
-                self.add_message('no-self-use', node=node)
-
-    def visit_getattr(self, node):
-        """check if the getattr is an access to a class member
-        if so, register it. Also check for access to protected
-        class member from outside its class (but ignore __special__
-        methods)
-        """
-        attrname = node.attrname
-        # Check self
-        if self.is_first_attr(node):
-            self._accessed[-1].setdefault(attrname, []).append(node)
-            return
-        if not self.linter.is_message_enabled('protected-access'):
-            return
-
-        self._check_protected_attribute_access(node)
-
-    def visit_assattr(self, node):
-        if isinstance(node.ass_type(), astroid.AugAssign) and self.is_first_attr(node):
-            self._accessed[-1].setdefault(node.attrname, []).append(node)
-
-    @check_messages('protected-access')
-    def visit_assign(self, assign_node):
-        node = assign_node.targets[0]
-        if not isinstance(node, AssAttr):
-            return
-
-        if self.is_first_attr(node):
-            return
-
-        self._check_protected_attribute_access(node)
-
-    def _check_protected_attribute_access(self, node):
-        '''Given an attribute access node (set or get), check if attribute
-        access is legitimate. Call _check_first_attr with node before calling
-        this method. Valid cases are:
-        * self._attr in a method or cls._attr in a classmethod. Checked by
-        _check_first_attr.
-        * Klass._attr inside "Klass" class.
-        * Klass2._attr inside "Klass" class when Klass2 is a base class of
-            Klass.
-        '''
-        attrname = node.attrname
-
-        if is_attr_protected(attrname):
-
-            klass = node_frame_class(node)
-
-            # XXX infer to be more safe and less dirty ??
-            # in classes, check we are not getting a parent method
-            # through the class object or through super
-            callee = node.expr.as_string()
-
-            # We are not in a class, no remaining valid case
-            if klass is None:
-                self.add_message('protected-access', node=node, args=attrname)
-                return
-
-            # If the expression begins with a call to super, that's ok.
-            if isinstance(node.expr, astroid.CallFunc) and \
-               isinstance(node.expr.func, astroid.Name) and \
-               node.expr.func.name == 'super':
-                return
-
-            # We are in a class, one remaining valid cases, Klass._attr inside
-            # Klass
-            if not (callee == klass.name or callee in klass.basenames):
-                self.add_message('protected-access', node=node, args=attrname)
-
-    def visit_name(self, node):
-        """check if the name handle an access to a class member
-        if so, register it
-        """
-        if self._first_attrs and (node.name == self._first_attrs[-1] or
-                                  not self._first_attrs[-1]):
-            self._meth_could_be_func = False
-
-    def _check_accessed_members(self, node, accessed):
-        """check that accessed members are defined"""
-        # XXX refactor, probably much simpler now that E0201 is in type checker
-        for attr, nodes in accessed.iteritems():
-            # deactivate "except doesn't do anything", that's expected
-            # pylint: disable=W0704
-            try:
-                # is it a class attribute ?
-                node.local_attr(attr)
-                # yes, stop here
-                continue
-            except astroid.NotFoundError:
-                pass
-            # is it an instance attribute of a parent class ?
-            try:
-                node.instance_attr_ancestors(attr).next()
-                # yes, stop here
-                continue
-            except StopIteration:
-                pass
-            # is it an instance attribute ?
-            try:
-                defstmts = node.instance_attr(attr)
-            except astroid.NotFoundError:
-                pass
-            else:
-                # filter out augment assignment nodes
-                defstmts = [stmt for stmt in defstmts if stmt not in nodes]
-                if not defstmts:
-                    # only augment assignment for this node, no-member should be
-                    # triggered by the typecheck checker
-                    continue
-                # filter defstmts to only pick the first one when there are
-                # several assignments in the same scope
-                scope = defstmts[0].scope()
-                defstmts = [stmt for i, stmt in enumerate(defstmts)
-                            if i == 0 or stmt.scope() is not scope]
-                # if there are still more than one, don't attempt to be smarter
-                # than we can be
-                if len(defstmts) == 1:
-                    defstmt = defstmts[0]
-                    # check that if the node is accessed in the same method as
-                    # it's defined, it's accessed after the initial assignment
-                    frame = defstmt.frame()
-                    lno = defstmt.fromlineno
-                    for _node in nodes:
-                        if _node.frame() is frame and _node.fromlineno < lno \
-                           and not are_exclusive(_node.statement(), defstmt, ('AttributeError', 'Exception', 'BaseException')):
-                            self.add_message('access-member-before-definition',
-                                             node=_node, args=(attr, lno))
-
-    def _check_first_arg_for_type(self, node, metaclass=0):
-        """check the name of first argument, expect:
-
-        * 'self' for a regular method
-        * 'cls' for a class method or a metaclass regular method (actually
-          valid-classmethod-first-arg value)
-        * 'mcs' for a metaclass class method (actually
-          valid-metaclass-classmethod-first-arg)
-        * not one of the above for a static method
-        """
-        # don't care about functions with unknown argument (builtins)
-        if node.args.args is None:
-            return
-        first_arg = node.args.args and node.argnames()[0]
-        self._first_attrs.append(first_arg)
-        first = self._first_attrs[-1]
-        # static method
-        if node.type == 'staticmethod':
-            if (first_arg == 'self' or
-                first_arg in self.config.valid_classmethod_first_arg or
-                first_arg in self.config.valid_metaclass_classmethod_first_arg):
-                self.add_message('bad-staticmethod-argument', args=first, node=node)
-                return
-            self._first_attrs[-1] = None
-        # class / regular method with no args
-        elif not node.args.args:
-            self.add_message('no-method-argument', node=node)
-        # metaclass
-        elif metaclass:
-            # metaclass __new__ or classmethod
-            if node.type == 'classmethod':
-                self._check_first_arg_config(first,
-                    self.config.valid_metaclass_classmethod_first_arg, node,
-                    'bad-mcs-classmethod-argument', node.name)
-            # metaclass regular method
-            else:
-                self._check_first_arg_config(first,
-                    self.config.valid_classmethod_first_arg, node, 'bad-mcs-method-argument',
-                    node.name)
-        # regular class
-        else:
-            # class method
-            if node.type == 'classmethod':
-                self._check_first_arg_config(first,
-                    self.config.valid_classmethod_first_arg, node, 'bad-classmethod-argument',
-                    node.name)
-            # regular method without self as argument
-            elif first != 'self':
-                self.add_message('no-self-argument', node=node)
-
-    def _check_first_arg_config(self, first, config, node, message,
-                                method_name):
-        if first not in config:
-            if len(config) == 1:
-                valid = repr(config[0])
-            else:
-                valid = ', '.join(
-                  repr(v)
-                  for v in config[:-1])
-                valid = '%s or %r' % (
-                    valid, config[-1])
-            self.add_message(message, args=(method_name, valid), node=node)
-
-    def _check_bases_classes(self, node):
-        """check that the given class node implements abstract methods from
-        base classes
-        """
-        # check if this class abstract
-        if class_is_abstract(node):
-            return
-        for method in node.methods():
-            owner = method.parent.frame()
-            if owner is node:
-                continue
-            # owner is not this class, it must be a parent class
-            # check that the ancestor's method is not abstract
-            if method.name in node.locals:
-                # it is redefined as an attribute or with a descriptor
-                continue
-            if method.is_abstract(pass_is_abstract=False):
-                self.add_message('abstract-method', node=node,
-                                 args=(method.name, owner.name))
-
-    def _check_interfaces(self, node):
-        """check that the given class node really implements declared
-        interfaces
-        """
-        e0221_hack = [False]
-        def iface_handler(obj):
-            """filter interface objects, it should be classes"""
-            if not isinstance(obj, astroid.Class):
-                e0221_hack[0] = True
-                self.add_message('interface-is-not-class', node=node,
-                                 args=(obj.as_string(),))
-                return False
-            return True
-        ignore_iface_methods = self.config.ignore_iface_methods
-        try:
-            for iface in node.interfaces(handler_func=iface_handler):
-                for imethod in iface.methods():
-                    name = imethod.name
-                    if name.startswith('_') or name in ignore_iface_methods:
-                        # don't check method beginning with an underscore,
-                        # usually belonging to the interface implementation
-                        continue
-                    # get class method astroid
-                    try:
-                        method = node_method(node, name)
-                    except astroid.NotFoundError:
-                        self.add_message('missing-interface-method', args=(name, iface.name),
-                                         node=node)
-                        continue
-                    # ignore inherited methods
-                    if method.parent.frame() is not node:
-                        continue
-                    # check signature
-                    self._check_signature(method, imethod,
-                                         '%s interface' % iface.name)
-        except astroid.InferenceError:
-            if e0221_hack[0]:
-                return
-            implements = Instance(node).getattr('__implements__')[0]
-            assignment = implements.parent
-            assert isinstance(assignment, astroid.Assign)
-            # assignment.expr can be a Name or a Tuple or whatever.
-            # Use as_string() for the message
-            # FIXME: in case of multiple interfaces, find which one could not
-            #        be resolved
-            self.add_message('unresolved-interface', node=implements,
-                             args=(node.name, assignment.value.as_string()))
-
-    def _check_init(self, node):
-        """check that the __init__ method call super or ancestors'__init__
-        method
-        """
-        if (not self.linter.is_message_enabled('super-init-not-called') and
-            not self.linter.is_message_enabled('non-parent-init-called')):
-            return
-        klass_node = node.parent.frame()
-        to_call = _ancestors_to_call(klass_node)
-        not_called_yet = dict(to_call)
-        for stmt in node.nodes_of_class(astroid.CallFunc):
-            expr = stmt.func
-            if not isinstance(expr, astroid.Getattr) \
-                   or expr.attrname != '__init__':
-                continue
-            # skip the test if using super
-            if isinstance(expr.expr, astroid.CallFunc) and \
-               isinstance(expr.expr.func, astroid.Name) and \
-               expr.expr.func.name == 'super':
-                return
-            try:
-                klass = expr.expr.infer().next()
-                if klass is YES:
-                    continue
-                try:
-                    del not_called_yet[klass]
-                except KeyError:
-                    if klass not in to_call:
-                        self.add_message('non-parent-init-called', node=expr, args=klass.name)
-            except astroid.InferenceError:
-                continue
-        for klass, method in not_called_yet.iteritems():
-            if klass.name == 'object' or method.parent.name == 'object':
-                continue
-            self.add_message('super-init-not-called', args=klass.name, node=node)
-
-    def _check_signature(self, method1, refmethod, class_type):
-        """check that the signature of the two given methods match
-
-        class_type is in 'class', 'interface'
-        """
-        if not (isinstance(method1, astroid.Function)
-                and isinstance(refmethod, astroid.Function)):
-            self.add_message('method-check-failed', args=(method1, refmethod), node=method1)
-            return
-        # don't care about functions with unknown argument (builtins)
-        if method1.args.args is None or refmethod.args.args is None:
-            return
-        # if we use *args, **kwargs, skip the below checks
-        if method1.args.vararg or method1.args.kwarg:
-            return
-        if is_attr_private(method1.name):
-            return
-        if len(method1.args.args) != len(refmethod.args.args):
-            self.add_message('arguments-differ', args=class_type, node=method1)
-        elif len(method1.args.defaults) < len(refmethod.args.defaults):
-            self.add_message('signature-differs', args=class_type, node=method1)
-
-    def is_first_attr(self, node):
-        """Check that attribute lookup name use first attribute variable name
-        (self for method, cls for classmethod and mcs for metaclass).
-        """
-        return self._first_attrs and isinstance(node.expr, astroid.Name) and \
-                   node.expr.name == self._first_attrs[-1]
-
-def _ancestors_to_call(klass_node, method='__init__'):
-    """return a dictionary where keys are the list of base classes providing
-    the queried method, and so that should/may be called from the method node
-    """
-    to_call = {}
-    for base_node in klass_node.ancestors(recurs=False):
-        try:
-            to_call[base_node] = base_node.igetattr(method).next()
-        except astroid.InferenceError:
-            continue
-    return to_call
-
-
-def node_method(node, method_name):
-    """get astroid for <method_name> on the given class node, ensuring it
-    is a Function node
-    """
-    for n in node.local_attr(method_name):
-        if isinstance(n, astroid.Function):
-            return n
-    raise astroid.NotFoundError(method_name)
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(ClassChecker(linter))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/design_analysis.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/design_analysis.py
deleted file mode 100644
index c9ef4dfa..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/design_analysis.py
+++ /dev/null
@@ -1,367 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""check for signs of poor design"""
-
-from astroid import Function, If, InferenceError
-
-from pylint.interfaces import IAstroidChecker
-from pylint.checkers import BaseChecker
-from pylint.checkers.utils import check_messages
-
-import re
-
-# regexp for ignored argument name
-IGNORED_ARGUMENT_NAMES = re.compile('_.*')
-
-
-def class_is_abstract(klass):
-    """return true if the given class node should be considered as an abstract
-    class
-    """
-    for attr in klass.values():
-        if isinstance(attr, Function):
-            if attr.is_abstract(pass_is_abstract=False):
-                return True
-    return False
-
-
-MSGS = {
-    'R0901': ('Too many ancestors (%s/%s)',
-              'too-many-ancestors',
-              'Used when class has too many parent classes, try to reduce \
-              this to get a simpler (and so easier to use) class.'),
-    'R0902': ('Too many instance attributes (%s/%s)',
-              'too-many-instance-attributes',
-              'Used when class has too many instance attributes, try to reduce \
-              this to get a simpler (and so easier to use) class.'),
-    'R0903': ('Too few public methods (%s/%s)',
-              'too-few-public-methods',
-              'Used when class has too few public methods, so be sure it\'s \
-              really worth it.'),
-    'R0904': ('Too many public methods (%s/%s)',
-              'too-many-public-methods',
-              'Used when class has too many public methods, try to reduce \
-              this to get a simpler (and so easier to use) class.'),
-
-    'R0911': ('Too many return statements (%s/%s)',
-              'too-many-return-statements',
-              'Used when a function or method has too many return statement, \
-              making it hard to follow.'),
-    'R0912': ('Too many branches (%s/%s)',
-              'too-many-branches',
-              'Used when a function or method has too many branches, \
-              making it hard to follow.'),
-    'R0913': ('Too many arguments (%s/%s)',
-              'too-many-arguments',
-              'Used when a function or method takes too many arguments.'),
-    'R0914': ('Too many local variables (%s/%s)',
-              'too-many-locals',
-              'Used when a function or method has too many local variables.'),
-    'R0915': ('Too many statements (%s/%s)',
-              'too-many-statements',
-              'Used when a function or method has too many statements. You \
-              should then split it in smaller functions / methods.'),
-
-    'R0921': ('Abstract class not referenced',
-              'abstract-class-not-used',
-              'Used when an abstract class is not used as ancestor anywhere.'),
-    'R0922': ('Abstract class is only referenced %s times',
-              'abstract-class-little-used',
-              'Used when an abstract class is used less than X times as \
-              ancestor.'),
-    'R0923': ('Interface not implemented',
-              'interface-not-implemented',
-              'Used when an interface class is not implemented anywhere.'),
-    }
-
-
-class MisdesignChecker(BaseChecker):
-    """checks for sign of poor/misdesign:
-    * number of methods, attributes, local variables...
-    * size, complexity of functions, methods
-    """
-
-    __implements__ = (IAstroidChecker,)
-
-    # configuration section name
-    name = 'design'
-    # messages
-    msgs = MSGS
-    priority = -2
-    # configuration options
-    options = (('max-args',
-                {'default' : 5, 'type' : 'int', 'metavar' : '<int>',
-                 'help': 'Maximum number of arguments for function / method'}
-                ),
-               ('ignored-argument-names',
-                {'default' : IGNORED_ARGUMENT_NAMES,
-                 'type' :'regexp', 'metavar' : '<regexp>',
-                 'help' : 'Argument names that match this expression will be '
-                          'ignored. Default to name with leading underscore'}
-                ),
-               ('max-locals',
-                {'default' : 15, 'type' : 'int', 'metavar' : '<int>',
-                 'help': 'Maximum number of locals for function / method body'}
-                ),
-               ('max-returns',
-                {'default' : 6, 'type' : 'int', 'metavar' : '<int>',
-                 'help': 'Maximum number of return / yield for function / '
-                         'method body'}
-                ),
-               ('max-branches',
-                {'default' : 12, 'type' : 'int', 'metavar' : '<int>',
-                 'help': 'Maximum number of branch for function / method body'}
-                ),
-               ('max-statements',
-                {'default' : 50, 'type' : 'int', 'metavar' : '<int>',
-                 'help': 'Maximum number of statements in function / method '
-                         'body'}
-                ),
-               ('max-parents',
-                {'default' : 7,
-                 'type' : 'int',
-                 'metavar' : '<num>',
-                 'help' : 'Maximum number of parents for a class (see R0901).'}
-                ),
-               ('max-attributes',
-                {'default' : 7,
-                 'type' : 'int',
-                 'metavar' : '<num>',
-                 'help' : 'Maximum number of attributes for a class \
-(see R0902).'}
-                ),
-               ('min-public-methods',
-                {'default' : 2,
-                 'type' : 'int',
-                 'metavar' : '<num>',
-                 'help' : 'Minimum number of public methods for a class \
-(see R0903).'}
-                ),
-               ('max-public-methods',
-                {'default' : 20,
-                 'type' : 'int',
-                 'metavar' : '<num>',
-                 'help' : 'Maximum number of public methods for a class \
-(see R0904).'}
-                ),
-               )
-
-    def __init__(self, linter=None):
-        BaseChecker.__init__(self, linter)
-        self.stats = None
-        self._returns = None
-        self._branches = None
-        self._used_abstracts = None
-        self._used_ifaces = None
-        self._abstracts = None
-        self._ifaces = None
-        self._stmts = 0
-
-    def open(self):
-        """initialize visit variables"""
-        self.stats = self.linter.add_stats()
-        self._returns = []
-        self._branches = []
-        self._used_abstracts = {}
-        self._used_ifaces = {}
-        self._abstracts = []
-        self._ifaces = []
-
-    # Check 'R0921', 'R0922', 'R0923'
-    def close(self):
-        """check that abstract/interface classes are used"""
-        for abstract in self._abstracts:
-            if not abstract in self._used_abstracts:
-                self.add_message('abstract-class-not-used', node=abstract)
-            elif self._used_abstracts[abstract] < 2:
-                self.add_message('abstract-class-little-used', node=abstract,
-                                 args=self._used_abstracts[abstract])
-        for iface in self._ifaces:
-            if not iface in self._used_ifaces:
-                self.add_message('interface-not-implemented', node=iface)
-
-    @check_messages('too-many-ancestors', 'too-many-instance-attributes',
-                    'too-few-public-methods', 'too-many-public-methods',
-                    'abstract-class-not-used', 'abstract-class-little-used',
-                    'interface-not-implemented')
-    def visit_class(self, node):
-        """check size of inheritance hierarchy and number of instance attributes
-        """
-        self._inc_branch()
-        # Is the total inheritance hierarchy is 7 or less?
-        nb_parents = len(list(node.ancestors()))
-        if nb_parents > self.config.max_parents:
-            self.add_message('too-many-ancestors', node=node,
-                             args=(nb_parents, self.config.max_parents))
-        # Does the class contain less than 20 attributes for
-        # non-GUI classes (40 for GUI)?
-        # FIXME detect gui classes
-        if len(node.instance_attrs) > self.config.max_attributes:
-            self.add_message('too-many-instance-attributes', node=node,
-                             args=(len(node.instance_attrs),
-                                   self.config.max_attributes))
-        # update abstract / interface classes structures
-        if class_is_abstract(node):
-            self._abstracts.append(node)
-        elif node.type == 'interface' and node.name != 'Interface':
-            self._ifaces.append(node)
-            for parent in node.ancestors(False):
-                if parent.name == 'Interface':
-                    continue
-                self._used_ifaces[parent] = 1
-        try:
-            for iface in node.interfaces():
-                self._used_ifaces[iface] = 1
-        except InferenceError:
-            # XXX log ?
-            pass
-        for parent in node.ancestors():
-            try:
-                self._used_abstracts[parent] += 1
-            except KeyError:
-                self._used_abstracts[parent] = 1
-
-    @check_messages('too-many-ancestors', 'too-many-instance-attributes',
-                    'too-few-public-methods', 'too-many-public-methods',
-                    'abstract-class-not-used', 'abstract-class-little-used',
-                    'interface-not-implemented')
-    def leave_class(self, node):
-        """check number of public methods"""
-        nb_public_methods = 0
-        special_methods = set()
-        for method in node.methods():
-            if not method.name.startswith('_'):
-                nb_public_methods += 1
-            if method.name.startswith("__"):
-                special_methods.add(method.name)
-        # Does the class contain less than 20 public methods ?
-        if nb_public_methods > self.config.max_public_methods:
-            self.add_message('too-many-public-methods', node=node,
-                             args=(nb_public_methods,
-                                   self.config.max_public_methods))
-        # stop here for exception, metaclass and interface classes
-        if node.type != 'class':
-            return
-        # Does the class contain more than 5 public methods ?
-        if nb_public_methods < self.config.min_public_methods:
-            self.add_message('R0903', node=node,
-                             args=(nb_public_methods,
-                                   self.config.min_public_methods))
-
-    @check_messages('too-many-return-statements', 'too-many-branches',
-                    'too-many-arguments', 'too-many-locals', 'too-many-statements')
-    def visit_function(self, node):
-        """check function name, docstring, arguments, redefinition,
-        variable names, max locals
-        """
-        self._inc_branch()
-        # init branch and returns counters
-        self._returns.append(0)
-        self._branches.append(0)
-        # check number of arguments
-        args = node.args.args
-        if args is not None:
-            ignored_args_num = len(
-                [arg for arg in args
-                 if self.config.ignored_argument_names.match(arg.name)])
-            argnum = len(args) - ignored_args_num
-            if  argnum > self.config.max_args:
-                self.add_message('too-many-arguments', node=node,
-                                 args=(len(args), self.config.max_args))
-        else:
-            ignored_args_num = 0
-        # check number of local variables
-        locnum = len(node.locals) - ignored_args_num
-        if locnum > self.config.max_locals:
-            self.add_message('too-many-locals', node=node,
-                             args=(locnum, self.config.max_locals))
-        # init statements counter
-        self._stmts = 1
-
-    @check_messages('too-many-return-statements', 'too-many-branches', 'too-many-arguments', 'too-many-locals', 'too-many-statements')
-    def leave_function(self, node):
-        """most of the work is done here on close:
-        checks for max returns, branch, return in __init__
-        """
-        returns = self._returns.pop()
-        if returns > self.config.max_returns:
-            self.add_message('too-many-return-statements', node=node,
-                             args=(returns, self.config.max_returns))
-        branches = self._branches.pop()
-        if branches > self.config.max_branches:
-            self.add_message('too-many-branches', node=node,
-                             args=(branches, self.config.max_branches))
-        # check number of statements
-        if self._stmts > self.config.max_statements:
-            self.add_message('too-many-statements', node=node,
-                             args=(self._stmts, self.config.max_statements))
-
-    def visit_return(self, _):
-        """count number of returns"""
-        if not self._returns:
-            return # return outside function, reported by the base checker
-        self._returns[-1] += 1
-
-    def visit_default(self, node):
-        """default visit method -> increments the statements counter if
-        necessary
-        """
-        if node.is_statement:
-            self._stmts += 1
-
-    def visit_tryexcept(self, node):
-        """increments the branches counter"""
-        branches = len(node.handlers)
-        if node.orelse:
-            branches += 1
-        self._inc_branch(branches)
-        self._stmts += branches
-
-    def visit_tryfinally(self, _):
-        """increments the branches counter"""
-        self._inc_branch(2)
-        self._stmts += 2
-
-    def visit_if(self, node):
-        """increments the branches counter"""
-        branches = 1
-        # don't double count If nodes coming from some 'elif'
-        if node.orelse and (len(node.orelse) > 1 or
-                            not isinstance(node.orelse[0], If)):
-            branches += 1
-        self._inc_branch(branches)
-        self._stmts += branches
-
-    def visit_while(self, node):
-        """increments the branches counter"""
-        branches = 1
-        if node.orelse:
-            branches += 1
-        self._inc_branch(branches)
-
-    visit_for = visit_while
-
-    def _inc_branch(self, branchesnum=1):
-        """increments the branches counter"""
-        branches = self._branches
-        for i in xrange(len(branches)):
-            branches[i] += branchesnum
-
-    # FIXME: make a nice report...
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(MisdesignChecker(linter))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/exceptions.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/exceptions.py
deleted file mode 100644
index 7e0f3fca..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/exceptions.py
+++ /dev/null
@@ -1,306 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""exceptions handling (raising, catching, exceptions classes) checker
-"""
-import sys
-
-from logilab.common.compat import builtins
-BUILTINS_NAME = builtins.__name__
-import astroid
-from astroid import YES, Instance, unpack_infer
-
-from pylint.checkers import BaseChecker
-from pylint.checkers.utils import is_empty, is_raising, check_messages
-from pylint.interfaces import IAstroidChecker
-
-def infer_bases(klass):
-    """ Fully infer the bases of the klass node.
-
-    This doesn't use .ancestors(), because we need
-    the non-inferable nodes (YES nodes),
-    which can't be retrieved from .ancestors()
-    """
-    for base in klass.bases:
-        try:
-            inferit = base.infer().next()
-        except astroid.InferenceError:
-            continue
-        if inferit is YES:
-            yield inferit
-        else:
-            for base in infer_bases(inferit):
-                yield base
-
-PY3K = sys.version_info >= (3, 0)
-OVERGENERAL_EXCEPTIONS = ('Exception',)
-
-MSGS = {
-    'E0701': ('Bad except clauses order (%s)',
-              'bad-except-order',
-              'Used when except clauses are not in the correct order (from the '
-              'more specific to the more generic). If you don\'t fix the order, '
-              'some exceptions may not be catched by the most specific handler.'),
-    'E0702': ('Raising %s while only classes, instances or string are allowed',
-              'raising-bad-type',
-              'Used when something which is neither a class, an instance or a \
-              string is raised (i.e. a `TypeError` will be raised).'),
-    'E0703': ('Exception context set to something which is not an '
-              'exception, nor None',
-              'bad-exception-context',
-              'Used when using the syntax "raise ... from ...", '
-              'where the exception context is not an exception, '
-              'nor None.',
-              {'minversion': (3, 0)}),
-    'E0710': ('Raising a new style class which doesn\'t inherit from BaseException',
-              'raising-non-exception',
-              'Used when a new style class which doesn\'t inherit from \
-               BaseException is raised.'),
-    'E0711': ('NotImplemented raised - should raise NotImplementedError',
-              'notimplemented-raised',
-              'Used when NotImplemented is raised instead of \
-              NotImplementedError'),
-    'E0712': ('Catching an exception which doesn\'t inherit from BaseException: %s',
-              'catching-non-exception',
-              'Used when a class which doesn\'t inherit from \
-               BaseException is used as an exception in an except clause.'),
-
-    'W0701': ('Raising a string exception',
-              'raising-string',
-              'Used when a string exception is raised.'),
-    'W0702': ('No exception type(s) specified',
-              'bare-except',
-              'Used when an except clause doesn\'t specify exceptions type to \
-              catch.'),
-    'W0703': ('Catching too general exception %s',
-              'broad-except',
-              'Used when an except catches a too general exception, \
-              possibly burying unrelated errors.'),
-    'W0704': ('Except doesn\'t do anything',
-              'pointless-except',
-              'Used when an except clause does nothing but "pass" and there is\
-              no "else" clause.'),
-    'W0710': ('Exception doesn\'t inherit from standard "Exception" class',
-              'nonstandard-exception',
-              'Used when a custom exception class is raised but doesn\'t \
-              inherit from the builtin "Exception" class.',
-              {'maxversion': (3, 0)}),
-    'W0711': ('Exception to catch is the result of a binary "%s" operation',
-              'binary-op-exception',
-              'Used when the exception to catch is of the form \
-              "except A or B:".  If intending to catch multiple, \
-              rewrite as "except (A, B):"'),
-    'W0712': ('Implicit unpacking of exceptions is not supported in Python 3',
-              'unpacking-in-except',
-              'Python3 will not allow implicit unpacking of exceptions in except '
-              'clauses. '
-              'See http://www.python.org/dev/peps/pep-3110/',
-              {'maxversion': (3, 0)}),
-    'W0713': ('Indexing exceptions will not work on Python 3',
-              'indexing-exception',
-              'Indexing exceptions will not work on Python 3. Use '
-              '`exception.args[index]` instead.',
-              {'maxversion': (3, 0)}),
-    }
-
-
-if sys.version_info < (3, 0):
-    EXCEPTIONS_MODULE = "exceptions"
-else:
-    EXCEPTIONS_MODULE = "builtins"
-
-class ExceptionsChecker(BaseChecker):
-    """checks for
-    * excepts without exception filter
-    * type of raise argument : string, Exceptions, other values
-    """
-
-    __implements__ = IAstroidChecker
-
-    name = 'exceptions'
-    msgs = MSGS
-    priority = -4
-    options = (('overgeneral-exceptions',
-                {'default' : OVERGENERAL_EXCEPTIONS,
-                 'type' :'csv', 'metavar' : '<comma-separated class names>',
-                 'help' : 'Exceptions that will emit a warning '
-                          'when being caught. Defaults to "%s"' % (
-                              ', '.join(OVERGENERAL_EXCEPTIONS),)}
-                ),
-               )
-
-    @check_messages('raising-string', 'nonstandard-exception', 'raising-bad-type',
-                    'raising-non-exception', 'notimplemented-raised', 'bad-exception-context')
-    def visit_raise(self, node):
-        """visit raise possibly inferring value"""
-        # ignore empty raise
-        if node.exc is None:
-            return
-        if PY3K and node.cause:
-            try:
-                cause = node.cause.infer().next()
-            except astroid.InferenceError:
-                pass
-            else:
-                if cause is YES:
-                    return
-                if isinstance(cause, astroid.Const):
-                    if cause.value is not None:
-                        self.add_message('bad-exception-context',
-                                         node=node)
-                elif (not isinstance(cause, astroid.Class) and
-                      not inherit_from_std_ex(cause)):
-                    self.add_message('bad-exception-context',
-                                      node=node)
-        expr = node.exc
-        if self._check_raise_value(node, expr):
-            return
-        else:
-            try:
-                value = unpack_infer(expr).next()
-            except astroid.InferenceError:
-                return
-            self._check_raise_value(node, value)
-
-    def _check_raise_value(self, node, expr):
-        """check for bad values, string exception and class inheritance
-        """
-        value_found = True
-        if isinstance(expr, astroid.Const):
-            value = expr.value
-            if isinstance(value, str):
-                self.add_message('raising-string', node=node)
-            else:
-                self.add_message('raising-bad-type', node=node,
-                                 args=value.__class__.__name__)
-        elif (isinstance(expr, astroid.Name) and \
-                 expr.name in ('None', 'True', 'False')) or \
-                 isinstance(expr, (astroid.List, astroid.Dict, astroid.Tuple,
-                                   astroid.Module, astroid.Function)):
-            self.add_message('raising-bad-type', node=node, args=expr.name)
-        elif ((isinstance(expr, astroid.Name) and expr.name == 'NotImplemented')
-              or (isinstance(expr, astroid.CallFunc) and
-                  isinstance(expr.func, astroid.Name) and
-                  expr.func.name == 'NotImplemented')):
-            self.add_message('notimplemented-raised', node=node)
-        elif isinstance(expr, astroid.BinOp) and expr.op == '%':
-            self.add_message('raising-string', node=node)
-        elif isinstance(expr, (Instance, astroid.Class)):
-            if isinstance(expr, Instance):
-                expr = expr._proxied
-            if (isinstance(expr, astroid.Class) and
-                    not inherit_from_std_ex(expr) and
-                    expr.root().name != BUILTINS_NAME):
-                if expr.newstyle:
-                    self.add_message('raising-non-exception', node=node)
-                else:
-                    self.add_message('nonstandard-exception', node=node)
-            else:
-                value_found = False
-        else:
-            value_found = False
-        return value_found
-
-    @check_messages('unpacking-in-except')
-    def visit_excepthandler(self, node):
-        """Visit an except handler block and check for exception unpacking."""
-        if isinstance(node.name, (astroid.Tuple, astroid.List)):
-            self.add_message('unpacking-in-except', node=node)
-
-    @check_messages('indexing-exception')
-    def visit_subscript(self, node):
-        """ Look for indexing exceptions. """
-        try:
-            for infered in node.value.infer():
-                if not isinstance(infered, astroid.Instance):
-                    continue
-                if inherit_from_std_ex(infered):
-                    self.add_message('indexing-exception', node=node)
-        except astroid.InferenceError:
-            return
-
-    @check_messages('bare-except', 'broad-except', 'pointless-except',
-                    'binary-op-exception', 'bad-except-order',
-                    'catching-non-exception')
-    def visit_tryexcept(self, node):
-        """check for empty except"""
-        exceptions_classes = []
-        nb_handlers = len(node.handlers)
-        for index, handler  in enumerate(node.handlers):
-            # single except doing nothing but "pass" without else clause
-            if nb_handlers == 1 and is_empty(handler.body) and not node.orelse:
-                self.add_message('pointless-except', node=handler.type or handler.body[0])
-            if handler.type is None:
-                if nb_handlers == 1 and not is_raising(handler.body):
-                    self.add_message('bare-except', node=handler)
-                # check if a "except:" is followed by some other
-                # except
-                elif index < (nb_handlers - 1):
-                    msg = 'empty except clause should always appear last'
-                    self.add_message('bad-except-order', node=node, args=msg)
-
-            elif isinstance(handler.type, astroid.BoolOp):
-                self.add_message('binary-op-exception', node=handler, args=handler.type.op)
-            else:
-                try:
-                    excs = list(unpack_infer(handler.type))
-                except astroid.InferenceError:
-                    continue
-                for exc in excs:
-                    # XXX skip other non class nodes
-                    if exc is YES or not isinstance(exc, astroid.Class):
-                        continue
-                    exc_ancestors = [anc for anc in exc.ancestors()
-                                     if isinstance(anc, astroid.Class)]
-                    for previous_exc in exceptions_classes:
-                        if previous_exc in exc_ancestors:
-                            msg = '%s is an ancestor class of %s' % (
-                                previous_exc.name, exc.name)
-                            self.add_message('bad-except-order', node=handler.type, args=msg)
-                    if (exc.name in self.config.overgeneral_exceptions
-                        and exc.root().name == EXCEPTIONS_MODULE
-                        and nb_handlers == 1 and not is_raising(handler.body)):
-                        self.add_message('broad-except', args=exc.name, node=handler.type)
-
-                    if (not inherit_from_std_ex(exc) and
-                        exc.root().name != BUILTINS_NAME):
-                        # try to see if the exception is based on a C based
-                        # exception, by infering all the base classes and
-                        # looking for inference errors
-                        bases = infer_bases(exc)
-                        fully_infered = all(inferit is not YES
-                                            for inferit in bases)
-                        if fully_infered:
-                            self.add_message('catching-non-exception',
-                                             node=handler.type,
-                                             args=(exc.name, ))
-
-                exceptions_classes += excs
-
-
-def inherit_from_std_ex(node):
-    """return true if the given class node is subclass of
-    exceptions.Exception
-    """
-    if node.name in ('Exception', 'BaseException') \
-            and node.root().name == EXCEPTIONS_MODULE:
-        return True
-    for parent in node.ancestors(recurs=False):
-        if inherit_from_std_ex(parent):
-            return True
-    return False
-
-def register(linter):
-    """required method to auto register this checker"""
-    linter.register_checker(ExceptionsChecker(linter))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/format.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/format.py
deleted file mode 100644
index 8b73049c..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/format.py
+++ /dev/null
@@ -1,943 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""Python code format's checker.
-
-By default try to follow Guido's style guide :
-
-http://www.python.org/doc/essays/styleguide.html
-
-Some parts of the process_token method is based from The Tab Nanny std module.
-"""
-
-import keyword
-import sys
-import tokenize
-
-if not hasattr(tokenize, 'NL'):
-    raise ValueError("tokenize.NL doesn't exist -- tokenize module too old")
-
-from astroid import nodes
-
-from pylint.interfaces import ITokenChecker, IAstroidChecker, IRawChecker
-from pylint.checkers import BaseTokenChecker
-from pylint.checkers.utils import check_messages
-from pylint.utils import WarningScope, OPTION_RGX
-
-_CONTINUATION_BLOCK_OPENERS = ['elif', 'except', 'for', 'if', 'while', 'def', 'class']
-_KEYWORD_TOKENS = ['assert', 'del', 'elif', 'except', 'for', 'if', 'in', 'not',
-                   'raise', 'return', 'while', 'yield']
-if sys.version_info < (3, 0):
-    _KEYWORD_TOKENS.append('print')
-
-_SPACED_OPERATORS = ['==', '<', '>', '!=', '<>', '<=', '>=',
-                     '+=', '-=', '*=', '**=', '/=', '//=', '&=', '|=', '^=',
-                     '%=', '>>=', '<<=']
-_OPENING_BRACKETS = ['(', '[', '{']
-_CLOSING_BRACKETS = [')', ']', '}']
-_TAB_LENGTH = 8
-
-_EOL = frozenset([tokenize.NEWLINE, tokenize.NL, tokenize.COMMENT])
-_JUNK_TOKENS = (tokenize.COMMENT, tokenize.NL)
-
-# Whitespace checking policy constants
-_MUST = 0
-_MUST_NOT = 1
-_IGNORE = 2
-
-# Whitespace checking config constants
-_DICT_SEPARATOR = 'dict-separator'
-_TRAILING_COMMA = 'trailing-comma'
-_NO_SPACE_CHECK_CHOICES = [_TRAILING_COMMA, _DICT_SEPARATOR]
-
-MSGS = {
-    'C0301': ('Line too long (%s/%s)',
-              'line-too-long',
-              'Used when a line is longer than a given number of characters.'),
-    'C0302': ('Too many lines in module (%s)', # was W0302
-              'too-many-lines',
-              'Used when a module has too much lines, reducing its readability.'
-              ),
-    'C0303': ('Trailing whitespace',
-              'trailing-whitespace',
-              'Used when there is whitespace between the end of a line and the '
-              'newline.'),
-    'C0304': ('Final newline missing',
-              'missing-final-newline',
-              'Used when the last line in a file is missing a newline.'),
-    'W0311': ('Bad indentation. Found %s %s, expected %s',
-              'bad-indentation',
-              'Used when an unexpected number of indentation\'s tabulations or '
-              'spaces has been found.'),
-    'C0330': ('Wrong %s indentation%s.\n%s%s',
-              'bad-continuation',
-              'TODO'),
-    'W0312': ('Found indentation with %ss instead of %ss',
-              'mixed-indentation',
-              'Used when there are some mixed tabs and spaces in a module.'),
-    'W0301': ('Unnecessary semicolon', # was W0106
-              'unnecessary-semicolon',
-              'Used when a statement is ended by a semi-colon (";"), which \
-              isn\'t necessary (that\'s python, not C ;).'),
-    'C0321': ('More than one statement on a single line',
-              'multiple-statements',
-              'Used when more than on statement are found on the same line.',
-              {'scope': WarningScope.NODE}),
-    'C0325' : ('Unnecessary parens after %r keyword',
-               'superfluous-parens',
-               'Used when a single item in parentheses follows an if, for, or '
-               'other keyword.'),
-    'C0326': ('%s space %s %s %s\n%s',
-              'bad-whitespace',
-              ('Used when a wrong number of spaces is used around an operator, '
-               'bracket or block opener.'),
-              {'old_names': [('C0323', 'no-space-after-operator'),
-                             ('C0324', 'no-space-after-comma'),
-                             ('C0322', 'no-space-before-operator')]})
-    }
-
-
-if sys.version_info < (3, 0):
-
-    MSGS.update({
-    'W0331': ('Use of the <> operator',
-              'old-ne-operator',
-              'Used when the deprecated "<>" operator is used instead \
-              of "!=".'),
-    'W0332': ('Use of "l" as long integer identifier',
-              'lowercase-l-suffix',
-              'Used when a lower case "l" is used to mark a long integer. You '
-              'should use a upper case "L" since the letter "l" looks too much '
-              'like the digit "1"'),
-    'W0333': ('Use of the `` operator',
-              'backtick',
-              'Used when the deprecated "``" (backtick) operator is used '
-              'instead  of the str() function.',
-              {'scope': WarningScope.NODE}),
-    })
-
-
-def _underline_token(token):
-    length = token[3][1] - token[2][1]
-    offset = token[2][1]
-    return token[4] + (' ' * offset) + ('^' * length)
-
-
-def _column_distance(token1, token2):
-    if token1 == token2:
-        return 0
-    if token2[3] < token1[3]:
-        token1, token2 = token2, token1
-    if token1[3][0] != token2[2][0]:
-        return None
-    return token2[2][1] - token1[3][1]
-
-
-def _last_token_on_line_is(tokens, line_end, token):
-    return (
-        line_end > 0 and tokens.token(line_end-1) == token or
-        line_end > 1 and tokens.token(line_end-2) == token 
-        and tokens.type(line_end-1) == tokenize.COMMENT)
-
-
-def _token_followed_by_eol(tokens, position):
-  return (tokens.type(position+1) == tokenize.NL or
-          tokens.type(position+1) == tokenize.COMMENT and
-          tokens.type(position+2) == tokenize.NL)
-
-
-def _get_indent_length(line):
-  """Return the length of the indentation on the given token's line."""
-  result = 0
-  for char in line:
-    if char == ' ':
-      result += 1
-    elif char == '\t':
-      result += _TAB_LENGTH
-    else:
-      break
-  return result
-
-
-def _get_indent_hint_line(bar_positions, bad_position):
-    """Return a line with |s for each of the positions in the given lists."""
-    if not bar_positions:
-        return ''
-    markers = [(pos, '|') for pos in bar_positions]
-    markers.append((bad_position, '^'))
-    markers.sort()
-    line = [' '] * (markers[-1][0] + 1)
-    for position, marker in markers:
-        line[position] = marker
-    return ''.join(line)
-
-
-class _ContinuedIndent(object):
-    __slots__ = ('valid_outdent_offsets',
-                 'valid_continuation_offsets',
-                 'context_type',
-                 'token',
-                 'position')
-
-    def __init__(self,
-                 context_type,
-                 token,
-                 position,
-                 valid_outdent_offsets,
-                 valid_continuation_offsets):
-        self.valid_outdent_offsets = valid_outdent_offsets
-        self.valid_continuation_offsets = valid_continuation_offsets
-        self.context_type = context_type
-        self.position = position
-        self.token = token
-
-
-# The contexts for hanging indents.
-# A hanging indented dictionary value after :
-HANGING_DICT_VALUE = 'dict-value'
-# Hanging indentation in an expression.
-HANGING = 'hanging'
-# Hanging indentation in a block header.
-HANGING_BLOCK = 'hanging-block'
-# Continued indentation inside an expression.
-CONTINUED = 'continued'
-# Continued indentation in a block header.
-CONTINUED_BLOCK = 'continued-block'
-
-SINGLE_LINE = 'single'
-WITH_BODY = 'multi'
-
-_CONTINUATION_MSG_PARTS = {
-    HANGING_DICT_VALUE: ('hanging', ' in dict value'),
-    HANGING: ('hanging', ''),
-    HANGING_BLOCK: ('hanging', ' before block'),
-    CONTINUED: ('continued', ''),
-    CONTINUED_BLOCK: ('continued', ' before block'),
-}
-
-
-def _Offsets(*args):
-    """Valid indentation offsets for a continued line."""
-    return dict((a, None) for a in args)
-
-
-def _BeforeBlockOffsets(single, with_body):
-    """Valid alternative indent offsets for continued lines before blocks.
-
-    :param single: Valid offset for statements on a single logical line.
-    :param with_body: Valid offset for statements on several lines.
-    """
-    return {single: SINGLE_LINE, with_body: WITH_BODY}
-
-
-class TokenWrapper(object):
-    """A wrapper for readable access to token information."""
-
-    def __init__(self, tokens):
-        self._tokens = tokens
-
-    def token(self, idx):
-        return self._tokens[idx][1]
-
-    def type(self, idx):
-        return self._tokens[idx][0]
-
-    def start_line(self, idx):
-        return self._tokens[idx][2][0]
-
-    def start_col(self, idx):
-        return self._tokens[idx][2][1]
-
-    def line(self, idx):
-        return self._tokens[idx][4]
-
-
-class ContinuedLineState(object):
-    """Tracker for continued indentation inside a logical line."""
-
-    def __init__(self, tokens, config):
-        self._line_start = -1
-        self._cont_stack = []
-        self._is_block_opener = False
-        self.retained_warnings = []
-        self._config = config
-        self._tokens = TokenWrapper(tokens)
-
-    @property
-    def has_content(self):
-        return bool(self._cont_stack)
-
-    @property
-    def _block_indent_size(self):
-        return len(self._config.indent_string.replace('\t', ' ' * _TAB_LENGTH))
-
-    @property
-    def _continuation_size(self):
-        return self._config.indent_after_paren
-
-    def handle_line_start(self, pos):
-        """Record the first non-junk token at the start of a line."""
-        if self._line_start > -1:
-            return
-        self._is_block_opener = self._tokens.token(pos) in _CONTINUATION_BLOCK_OPENERS
-        self._line_start = pos
-
-    def next_physical_line(self):
-        """Prepares the tracker for a new physical line (NL)."""
-        self._line_start = -1
-        self._is_block_opener = False
-
-    def next_logical_line(self):
-        """Prepares the tracker for a new logical line (NEWLINE).
-
-        A new logical line only starts with block indentation.
-        """
-        self.next_physical_line()
-        self.retained_warnings = []
-        self._cont_stack = []
-
-    def add_block_warning(self, token_position, state, valid_offsets):
-        self.retained_warnings.append((token_position, state, valid_offsets))
-
-    def get_valid_offsets(self, idx):
-        """"Returns the valid offsets for the token at the given position."""
-        # The closing brace on a dict or the 'for' in a dict comprehension may
-        # reset two indent levels because the dict value is ended implicitly
-        stack_top = -1
-        if self._tokens.token(idx) in ('}', 'for') and self._cont_stack[-1].token == ':':
-            stack_top = -2
-        indent = self._cont_stack[stack_top]
-        if self._tokens.token(idx) in _CLOSING_BRACKETS:
-            valid_offsets = indent.valid_outdent_offsets
-        else:
-            valid_offsets = indent.valid_continuation_offsets
-        return indent, valid_offsets.copy()
-
-    def _hanging_indent_after_bracket(self, bracket, position):
-        """Extracts indentation information for a hanging indent."""
-        indentation = _get_indent_length(self._tokens.line(position))
-        if self._is_block_opener and self._continuation_size == self._block_indent_size:
-            return _ContinuedIndent(
-                HANGING_BLOCK,
-                bracket,
-                position,
-                _Offsets(indentation + self._continuation_size, indentation),
-                _BeforeBlockOffsets(indentation + self._continuation_size,
-                                    indentation + self._continuation_size * 2))
-        elif bracket == ':':
-            if self._cont_stack[-1].context_type == CONTINUED:
-                # If the dict key was on the same line as the open brace, the new
-                # correct indent should be relative to the key instead of the
-                # current indent level
-                paren_align = self._cont_stack[-1].valid_outdent_offsets
-                next_align = self._cont_stack[-1].valid_continuation_offsets.copy()
-                next_align[next_align.keys()[0] + self._continuation_size] = True
-            else:
-                next_align = _Offsets(indentation + self._continuation_size, indentation)
-                paren_align = _Offsets(indentation + self._continuation_size, indentation)
-            return _ContinuedIndent(HANGING_DICT_VALUE, bracket, position, paren_align, next_align)
-        else:
-            return _ContinuedIndent(
-                HANGING,
-                bracket,
-                position,
-                _Offsets(indentation, indentation + self._continuation_size),
-                _Offsets(indentation + self._continuation_size))
-
-    def _continuation_inside_bracket(self, bracket, pos):
-        """Extracts indentation information for a continued indent."""
-        indentation = _get_indent_length(self._tokens.line(pos))
-        if self._is_block_opener and self._tokens.start_col(pos+1) - indentation == self._block_indent_size:
-            return _ContinuedIndent(
-                CONTINUED_BLOCK,
-                bracket,
-                pos,
-                _Offsets(self._tokens.start_col(pos)),
-                _BeforeBlockOffsets(self._tokens.start_col(pos+1),
-                                    self._tokens.start_col(pos+1) + self._continuation_size))
-        else:
-            return _ContinuedIndent(
-                CONTINUED,
-                bracket,
-                pos,
-                _Offsets(self._tokens.start_col(pos)),
-                _Offsets(self._tokens.start_col(pos+1)))
-
-    def pop_token(self):
-        self._cont_stack.pop()
-
-    def push_token(self, token, position):
-        """Pushes a new token for continued indentation on the stack.
-
-        Tokens that can modify continued indentation offsets are:
-          * opening brackets
-          * 'lambda'
-          * : inside dictionaries
-
-        push_token relies on the caller to filter out those
-        interesting tokens.
-
-        :param token: The concrete token
-        :param position: The position of the token in the stream.
-        """
-        if _token_followed_by_eol(self._tokens, position):
-            self._cont_stack.append(
-                self._hanging_indent_after_bracket(token, position))
-        else:
-            self._cont_stack.append(
-                self._continuation_inside_bracket(token, position))
-
-
-class FormatChecker(BaseTokenChecker):
-    """checks for :
-    * unauthorized constructions
-    * strict indentation
-    * line length
-    * use of <> instead of !=
-    """
-
-    __implements__ = (ITokenChecker, IAstroidChecker, IRawChecker)
-
-    # configuration section name
-    name = 'format'
-    # messages
-    msgs = MSGS
-    # configuration options
-    # for available dict keys/values see the optik parser 'add_option' method
-    options = (('max-line-length',
-                {'default' : 80, 'type' : "int", 'metavar' : '<int>',
-                 'help' : 'Maximum number of characters on a single line.'}),
-               ('ignore-long-lines',
-                {'type': 'regexp', 'metavar': '<regexp>',
-                 'default': r'^\s*(# )?<?https?://\S+>?$',
-                 'help': ('Regexp for a line that is allowed to be longer than '
-                          'the limit.')}),
-               ('single-line-if-stmt',
-                 {'default': False, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                  'help' : ('Allow the body of an if to be on the same '
-                            'line as the test if there is no else.')}),
-               ('no-space-check',
-                {'default': ','.join(_NO_SPACE_CHECK_CHOICES),
-                 'type': 'multiple_choice',
-                 'choices': _NO_SPACE_CHECK_CHOICES,
-                 'help': ('List of optional constructs for which whitespace '
-                          'checking is disabled')}),
-               ('max-module-lines',
-                {'default' : 1000, 'type' : 'int', 'metavar' : '<int>',
-                 'help': 'Maximum number of lines in a module'}
-                ),
-               ('indent-string',
-                {'default' : '    ', 'type' : "string", 'metavar' : '<string>',
-                 'help' : 'String used as indentation unit. This is usually \
-"    " (4 spaces) or "\\t" (1 tab).'}),
-               ('indent-after-paren',
-                {'type': 'int', 'metavar': '<int>', 'default': 4,
-                 'help': 'Number of spaces of indent required inside a hanging '
-                         ' or continued line.'}),
-               )
-
-    def __init__(self, linter=None):
-        BaseTokenChecker.__init__(self, linter)
-        self._lines = None
-        self._visited_lines = None
-        self._bracket_stack = [None]
-
-    def _pop_token(self):
-        self._bracket_stack.pop()
-        self._current_line.pop_token()
-
-    def _push_token(self, token, idx):
-        self._bracket_stack.append(token)
-        self._current_line.push_token(token, idx)
-
-    def new_line(self, tokens, line_end, line_start):
-        """a new line has been encountered, process it if necessary"""
-        if _last_token_on_line_is(tokens, line_end, ';'):
-            self.add_message('unnecessary-semicolon', line=tokens.start_line(line_end))
-
-        line_num = tokens.start_line(line_start)
-        line = tokens.line(line_start)
-        if tokens.type(line_start) not in _JUNK_TOKENS:
-            self._lines[line_num] = line.split('\n')[0]
-        self.check_lines(line, line_num)
-
-    def process_module(self, module):
-        self._keywords_with_parens = set()
-        if 'print_function' in module.future_imports:
-            self._keywords_with_parens.add('print')
-
-    def _check_keyword_parentheses(self, tokens, start):
-        """Check that there are not unnecessary parens after a keyword.
-
-        Parens are unnecessary if there is exactly one balanced outer pair on a
-        line, and it is followed by a colon, and contains no commas (i.e. is not a
-        tuple).
-
-        Args:
-        tokens: list of Tokens; the entire list of Tokens.
-        start: int; the position of the keyword in the token list.
-        """
-        # If the next token is not a paren, we're fine.
-        if self._inside_brackets(':') and tokens[start][1] == 'for':
-            self._pop_token()
-        if tokens[start+1][1] != '(':
-            return
-
-        found_and_or = False
-        depth = 0
-        keyword_token = tokens[start][1]
-        line_num = tokens[start][2][0]
-
-        for i in xrange(start, len(tokens) - 1):
-            token = tokens[i]
-
-            # If we hit a newline, then assume any parens were for continuation.
-            if token[0] == tokenize.NL:
-                return
-
-            if token[1] == '(':
-                depth += 1
-            elif token[1] == ')':
-                depth -= 1
-                if not depth:
-                    # ')' can't happen after if (foo), since it would be a syntax error.
-                    if (tokens[i+1][1] in (':', ')', ']', '}', 'in') or
-                        tokens[i+1][0] in (tokenize.NEWLINE, tokenize.ENDMARKER,
-                                             tokenize.COMMENT)):
-                        # The empty tuple () is always accepted.
-                        if i == start + 2:
-                            return
-                        if keyword_token == 'not':
-                            if not found_and_or:
-                                self.add_message('superfluous-parens', line=line_num,
-                                                 args=keyword_token)
-                        elif keyword_token in ('return', 'yield'):
-                            self.add_message('superfluous-parens', line=line_num,
-                                             args=keyword_token)
-                        elif keyword_token not in self._keywords_with_parens:
-                            if not (tokens[i+1][1] == 'in' and found_and_or):
-                                self.add_message('superfluous-parens', line=line_num,
-                                                 args=keyword_token)
-                    return
-            elif depth == 1:
-                # This is a tuple, which is always acceptable.
-                if token[1] == ',':
-                    return
-                # 'and' and 'or' are the only boolean operators with lower precedence
-                # than 'not', so parens are only required when they are found.
-                elif token[1] in ('and', 'or'):
-                    found_and_or = True
-                # A yield inside an expression must always be in parentheses,
-                # quit early without error.
-                elif token[1] == 'yield':
-                    return
-                # A generator expression always has a 'for' token in it, and
-                # the 'for' token is only legal inside parens when it is in a
-                # generator expression.  The parens are necessary here, so bail
-                # without an error.
-                elif token[1] == 'for':
-                    return
-
-    def _opening_bracket(self, tokens, i):
-        self._push_token(tokens[i][1], i)
-        # Special case: ignore slices
-        if tokens[i][1] == '[' and tokens[i+1][1] == ':':
-            return
-
-        if (i > 0 and (tokens[i-1][0] == tokenize.NAME and
-                       not (keyword.iskeyword(tokens[i-1][1]))
-                       or tokens[i-1][1] in _CLOSING_BRACKETS)):
-            self._check_space(tokens, i, (_MUST_NOT, _MUST_NOT))
-        else:
-            self._check_space(tokens, i, (_IGNORE, _MUST_NOT))
-
-    def _closing_bracket(self, tokens, i):
-        if self._inside_brackets(':'):
-            self._pop_token()
-        self._pop_token()
-        # Special case: ignore slices
-        if tokens[i-1][1] == ':' and tokens[i][1] == ']':
-            return
-        policy_before = _MUST_NOT
-        if tokens[i][1] in _CLOSING_BRACKETS and tokens[i-1][1] == ',':
-            if _TRAILING_COMMA in self.config.no_space_check:
-                policy_before = _IGNORE
-
-        self._check_space(tokens, i, (policy_before, _IGNORE))
-
-    def _check_equals_spacing(self, tokens, i):
-        """Check the spacing of a single equals sign."""
-        if self._inside_brackets('(') or self._inside_brackets('lambda'):
-            self._check_space(tokens, i, (_MUST_NOT, _MUST_NOT))
-        else:
-            self._check_space(tokens, i, (_MUST, _MUST))
-
-    def _open_lambda(self, tokens, i): # pylint:disable=unused-argument
-        self._push_token('lambda', i)
-
-    def _handle_colon(self, tokens, i):
-        # Special case: ignore slices
-        if self._inside_brackets('['):
-            return
-        if (self._inside_brackets('{') and
-            _DICT_SEPARATOR in self.config.no_space_check):
-            policy = (_IGNORE, _IGNORE)
-        else:
-            policy = (_MUST_NOT, _MUST)
-        self._check_space(tokens, i, policy)
-
-        if self._inside_brackets('lambda'):
-            self._pop_token()
-        elif self._inside_brackets('{'):
-            self._push_token(':', i)
-
-    def _handle_comma(self, tokens, i):
-        # Only require a following whitespace if this is
-        # not a hanging comma before a closing bracket.
-        if tokens[i+1][1] in _CLOSING_BRACKETS:
-            self._check_space(tokens, i, (_MUST_NOT, _IGNORE))
-        else:
-            self._check_space(tokens, i, (_MUST_NOT, _MUST))
-        if self._inside_brackets(':'):
-            self._pop_token()
-
-    def _check_surrounded_by_space(self, tokens, i):
-        """Check that a binary operator is surrounded by exactly one space."""
-        self._check_space(tokens, i, (_MUST, _MUST))
-
-    def _check_space(self, tokens, i, policies):
-        def _policy_string(policy):
-            if policy == _MUST:
-                return 'Exactly one', 'required'
-            else:
-                return 'No', 'allowed'
-
-        def _name_construct(token):
-            if tokens[i][1] == ',':
-                return 'comma'
-            elif tokens[i][1] == ':':
-                return ':'
-            elif tokens[i][1] in '()[]{}':
-                return 'bracket'
-            elif tokens[i][1] in ('<', '>', '<=', '>=', '!=', '=='):
-                return 'comparison'
-            else:
-                if self._inside_brackets('('):
-                    return 'keyword argument assignment'
-                else:
-                    return 'assignment'
-
-        good_space = [True, True]
-        pairs = [(tokens[i-1], tokens[i]), (tokens[i], tokens[i+1])]
-
-        for other_idx, (policy, token_pair) in enumerate(zip(policies, pairs)):
-            if token_pair[other_idx][0] in _EOL or policy == _IGNORE:
-                continue
-
-            distance = _column_distance(*token_pair)
-            if distance is None:
-                continue
-            good_space[other_idx] = (
-                (policy == _MUST and distance == 1) or
-                (policy == _MUST_NOT and distance == 0))
-
-        warnings = []
-        if not any(good_space) and policies[0] == policies[1]:
-            warnings.append((policies[0], 'around'))
-        else:
-            for ok, policy, position in zip(good_space, policies, ('before', 'after')):
-                if not ok:
-                    warnings.append((policy, position))
-        for policy, position in warnings:
-            construct = _name_construct(tokens[i])
-            count, state = _policy_string(policy)
-            self.add_message('bad-whitespace', line=tokens[i][2][0],
-                             args=(count, state, position, construct,
-                                   _underline_token(tokens[i])))
-
-    def _inside_brackets(self, left):
-        return self._bracket_stack[-1] == left
-
-    def _handle_old_ne_operator(self, tokens, i):
-        if tokens[i][1] == '<>':
-            self.add_message('old-ne-operator', line=tokens[i][2][0])
-
-    def _prepare_token_dispatcher(self):
-        raw = [
-            (_KEYWORD_TOKENS,
-             self._check_keyword_parentheses),
-
-            (_OPENING_BRACKETS, self._opening_bracket),
-
-            (_CLOSING_BRACKETS, self._closing_bracket),
-
-            (['='], self._check_equals_spacing),
-
-            (_SPACED_OPERATORS, self._check_surrounded_by_space),
-
-            ([','], self._handle_comma),
-
-            ([':'], self._handle_colon),
-
-            (['lambda'], self._open_lambda),
-
-            (['<>'], self._handle_old_ne_operator),
-            ]
-
-        dispatch = {}
-        for tokens, handler in raw:
-            for token in tokens:
-                dispatch[token] = handler
-        return dispatch
-
-    def process_tokens(self, tokens):
-        """process tokens and search for :
-
-         _ non strict indentation (i.e. not always using the <indent> parameter as
-           indent unit)
-         _ too long lines (i.e. longer than <max_chars>)
-         _ optionally bad construct (if given, bad_construct must be a compiled
-           regular expression).
-        """
-        self._bracket_stack = [None]
-        indents = [0]
-        check_equal = False
-        line_num = 0
-        self._lines = {}
-        self._visited_lines = {}
-        token_handlers = self._prepare_token_dispatcher()
-
-        self._current_line = ContinuedLineState(tokens, self.config)
-        for idx, (tok_type, token, start, _, line) in enumerate(tokens):
-            if start[0] != line_num:
-                line_num = start[0]
-                # A tokenizer oddity: if an indented line contains a multi-line
-                # docstring, the line member of the INDENT token does not contain
-                # the full line; therefore we check the next token on the line.
-                if tok_type == tokenize.INDENT:
-                    self.new_line(TokenWrapper(tokens), idx-1, idx+1)
-                else:
-                    self.new_line(TokenWrapper(tokens), idx-1, idx)
-            
-            if tok_type == tokenize.NEWLINE:
-                # a program statement, or ENDMARKER, will eventually follow,
-                # after some (possibly empty) run of tokens of the form
-                #     (NL | COMMENT)* (INDENT | DEDENT+)?
-                # If an INDENT appears, setting check_equal is wrong, and will
-                # be undone when we see the INDENT.
-                check_equal = True
-                self._process_retained_warnings(TokenWrapper(tokens), idx)
-                self._current_line.next_logical_line()
-            elif tok_type == tokenize.INDENT:
-                check_equal = False
-                self.check_indent_level(token, indents[-1]+1, line_num)
-                indents.append(indents[-1]+1)
-            elif tok_type == tokenize.DEDENT:
-                # there's nothing we need to check here!  what's important is
-                # that when the run of DEDENTs ends, the indentation of the
-                # program statement (or ENDMARKER) that triggered the run is
-                # equal to what's left at the top of the indents stack
-                check_equal = True
-                if len(indents) > 1:
-                    del indents[-1]
-            elif tok_type == tokenize.NL:
-                self._check_continued_indentation(TokenWrapper(tokens), idx+1)
-                self._current_line.next_physical_line()
-            elif tok_type != tokenize.COMMENT:
-                self._current_line.handle_line_start(idx)
-                # This is the first concrete token following a NEWLINE, so it
-                # must be the first token of the next program statement, or an
-                # ENDMARKER; the "line" argument exposes the leading whitespace
-                # for this statement; in the case of ENDMARKER, line is an empty
-                # string, so will properly match the empty string with which the
-                # "indents" stack was seeded
-                if check_equal:
-                    check_equal = False
-                    self.check_indent_level(line, indents[-1], line_num)
-
-            if tok_type == tokenize.NUMBER and token.endswith('l'):
-                self.add_message('lowercase-l-suffix', line=line_num)
-
-            try:
-                handler = token_handlers[token]
-            except KeyError:
-                pass
-            else:
-                handler(tokens, idx)
-
-        line_num -= 1 # to be ok with "wc -l"
-        if line_num > self.config.max_module_lines:
-            self.add_message('too-many-lines', args=line_num, line=1)
-
-    def _process_retained_warnings(self, tokens, current_pos):
-        single_line_block_stmt = not _last_token_on_line_is(tokens, current_pos, ':')
-
-        for indent_pos, state, offsets in self._current_line.retained_warnings:
-            block_type = offsets[tokens.start_col(indent_pos)]
-            hints = dict((k, v) for k, v in offsets.iteritems()
-                         if v != block_type)
-            if single_line_block_stmt and block_type == WITH_BODY:
-                self._add_continuation_message(state, hints, tokens, indent_pos)
-            elif not single_line_block_stmt and block_type == SINGLE_LINE:
-                self._add_continuation_message(state, hints, tokens, indent_pos)
-
-    def _check_continued_indentation(self, tokens, next_idx):
-        # Do not issue any warnings if the next line is empty.
-        if not self._current_line.has_content or tokens.type(next_idx) == tokenize.NL:
-            return
-
-        state, valid_offsets = self._current_line.get_valid_offsets(next_idx)
-        # Special handling for hanging comments. If the last line ended with a
-        # comment and the new line contains only a comment, the line may also be
-        # indented to the start of the previous comment.
-        if (tokens.type(next_idx) == tokenize.COMMENT and
-                tokens.type(next_idx-2) == tokenize.COMMENT):
-            valid_offsets[tokens.start_col(next_idx-2)] = True
-
-        # We can only decide if the indentation of a continued line before opening
-        # a new block is valid once we know of the body of the block is on the
-        # same line as the block opener. Since the token processing is single-pass,
-        # emitting those warnings is delayed until the block opener is processed.
-        if (state.context_type in (HANGING_BLOCK, CONTINUED_BLOCK)
-                and tokens.start_col(next_idx) in valid_offsets):
-            self._current_line.add_block_warning(next_idx, state, valid_offsets)
-        elif tokens.start_col(next_idx) not in valid_offsets:
-            self._add_continuation_message(state, valid_offsets, tokens, next_idx)
-
-    def _add_continuation_message(self, state, offsets, tokens, position):
-        readable_type, readable_position = _CONTINUATION_MSG_PARTS[state.context_type]
-        hint_line = _get_indent_hint_line(offsets, tokens.start_col(position))
-        self.add_message(
-            'bad-continuation',
-            line=tokens.start_line(position),
-            args=(readable_type, readable_position, tokens.line(position), hint_line))
-
-    @check_messages('multiple-statements')
-    def visit_default(self, node):
-        """check the node line number and check it if not yet done"""
-        if not node.is_statement:
-            return
-        if not node.root().pure_python:
-            return # XXX block visit of child nodes
-        prev_sibl = node.previous_sibling()
-        if prev_sibl is not None:
-            prev_line = prev_sibl.fromlineno
-        else:
-            # The line on which a finally: occurs in a try/finally
-            # is not directly represented in the AST. We infer it
-            # by taking the last line of the body and adding 1, which
-            # should be the line of finally:
-            if (isinstance(node.parent, nodes.TryFinally)
-                and node in node.parent.finalbody):
-                prev_line = node.parent.body[0].tolineno + 1
-            else:
-                prev_line = node.parent.statement().fromlineno
-        line = node.fromlineno
-        assert line, node
-        if prev_line == line and self._visited_lines.get(line) != 2:
-            self._check_multi_statement_line(node, line)
-            return
-        if line in self._visited_lines:
-            return
-        try:
-            tolineno = node.blockstart_tolineno
-        except AttributeError:
-            tolineno = node.tolineno
-        assert tolineno, node
-        lines = []
-        for line in xrange(line, tolineno + 1):
-            self._visited_lines[line] = 1
-            try:
-                lines.append(self._lines[line].rstrip())
-            except KeyError:
-                lines.append('')
-
-    def _check_multi_statement_line(self, node, line):
-        """Check for lines containing multiple statements."""
-        # Do not warn about multiple nested context managers
-        # in with statements.
-        if isinstance(node, nodes.With):
-            return
-        # For try... except... finally..., the two nodes
-        # appear to be on the same line due to how the AST is built.
-        if (isinstance(node, nodes.TryExcept) and
-            isinstance(node.parent, nodes.TryFinally)):
-            return
-        if (isinstance(node.parent, nodes.If) and not node.parent.orelse
-            and self.config.single_line_if_stmt):
-            return
-        self.add_message('multiple-statements', node=node)
-        self._visited_lines[line] = 2
-
-    @check_messages('backtick')
-    def visit_backquote(self, node):
-        self.add_message('backtick', node=node)
-
-    def check_lines(self, lines, i):
-        """check lines have less than a maximum number of characters
-        """
-        max_chars = self.config.max_line_length
-        ignore_long_line = self.config.ignore_long_lines
-
-        for line in lines.splitlines(True):
-            if not line.endswith('\n'):
-                self.add_message('missing-final-newline', line=i)
-            else:
-                stripped_line = line.rstrip()
-                if line[len(stripped_line):] not in ('\n', '\r\n'):
-                    self.add_message('trailing-whitespace', line=i)
-                # Don't count excess whitespace in the line length.
-                line = stripped_line
-            mobj = OPTION_RGX.search(line)
-            if mobj and mobj.group(1).split('=', 1)[0].strip() == 'disable':
-                line = line.split('#')[0].rstrip()
-
-            if len(line) > max_chars and not ignore_long_line.search(line):
-                self.add_message('line-too-long', line=i, args=(len(line), max_chars))
-            i += 1
-
-    def check_indent_level(self, string, expected, line_num):
-        """return the indent level of the string
-        """
-        indent = self.config.indent_string
-        if indent == '\\t': # \t is not interpreted in the configuration file
-            indent = '\t'
-        level = 0
-        unit_size = len(indent)
-        while string[:unit_size] == indent:
-            string = string[unit_size:]
-            level += 1
-        suppl = ''
-        while string and string[0] in ' \t':
-            if string[0] != indent[0]:
-                if string[0] == '\t':
-                    args = ('tab', 'space')
-                else:
-                    args = ('space', 'tab')
-                self.add_message('mixed-indentation', args=args, line=line_num)
-                return level
-            suppl += string[0]
-            string = string[1:]
-        if level != expected or suppl:
-            i_type = 'spaces'
-            if indent[0] == '\t':
-                i_type = 'tabs'
-            self.add_message('bad-indentation', line=line_num,
-                             args=(level * unit_size + len(suppl), i_type,
-                                   expected * unit_size))
-
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(FormatChecker(linter))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/imports.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/imports.py
deleted file mode 100644
index 8b73c6f6..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/imports.py
+++ /dev/null
@@ -1,394 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""imports checkers for Python code"""
-
-import sys
-
-from logilab.common.graph import get_cycles, DotBackend
-from logilab.common.modutils import get_module_part, is_standard_module
-from logilab.common.ureports import VerbatimText, Paragraph
-
-import astroid
-from astroid import are_exclusive
-
-from pylint.interfaces import IAstroidChecker
-from pylint.utils import EmptyReport
-from pylint.checkers import BaseChecker
-from pylint.checkers.utils import check_messages
-
-
-def get_first_import(node, context, name, base, level):
-    """return the node where [base.]<name> is imported or None if not found
-    """
-    fullname = '%s.%s' % (base, name) if base else name
-
-    first = None
-    found = False
-    for first in context.body:
-        if first is node:
-            continue
-        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
-            continue
-        if isinstance(first, astroid.Import):
-            if any(fullname == iname[0] for iname in first.names):
-                found = True
-                break
-        elif isinstance(first, astroid.From):
-            if level == first.level and any(
-                fullname == '%s.%s' % (first.modname, iname[0]) for iname in first.names):
-                found = True
-                break
-    if found and not are_exclusive(first, node):
-        return first
-
-# utilities to represents import dependencies as tree and dot graph ###########
-
-def make_tree_defs(mod_files_list):
-    """get a list of 2-uple (module, list_of_files_which_import_this_module),
-    it will return a dictionary to represent this as a tree
-    """
-    tree_defs = {}
-    for mod, files in mod_files_list:
-        node = (tree_defs, ())
-        for prefix in mod.split('.'):
-            node = node[0].setdefault(prefix, [{}, []])
-        node[1] += files
-    return tree_defs
-
-def repr_tree_defs(data, indent_str=None):
-    """return a string which represents imports as a tree"""
-    lines = []
-    nodes = data.items()
-    for i, (mod, (sub, files)) in enumerate(sorted(nodes, key=lambda x: x[0])):
-        if not files:
-            files = ''
-        else:
-            files = '(%s)' % ','.join(files)
-        if indent_str is None:
-            lines.append('%s %s' % (mod, files))
-            sub_indent_str = '  '
-        else:
-            lines.append(r'%s\-%s %s' % (indent_str, mod, files))
-            if i == len(nodes)-1:
-                sub_indent_str = '%s  ' % indent_str
-            else:
-                sub_indent_str = '%s| ' % indent_str
-        if sub:
-            lines.append(repr_tree_defs(sub, sub_indent_str))
-    return '\n'.join(lines)
-
-
-def dependencies_graph(filename, dep_info):
-    """write dependencies as a dot (graphviz) file
-    """
-    done = {}
-    printer = DotBackend(filename[:-4], rankdir='LR')
-    printer.emit('URL="." node[shape="box"]')
-    for modname, dependencies in sorted(dep_info.iteritems()):
-        done[modname] = 1
-        printer.emit_node(modname)
-        for modname in dependencies:
-            if modname not in done:
-                done[modname] = 1
-                printer.emit_node(modname)
-    for depmodname, dependencies in sorted(dep_info.iteritems()):
-        for modname in dependencies:
-            printer.emit_edge(modname, depmodname)
-    printer.generate(filename)
-
-
-def make_graph(filename, dep_info, sect, gtype):
-    """generate a dependencies graph and add some information about it in the
-    report's section
-    """
-    dependencies_graph(filename, dep_info)
-    sect.append(Paragraph('%simports graph has been written to %s'
-                          % (gtype, filename)))
-
-
-# the import checker itself ###################################################
-
-MSGS = {
-    'F0401': ('Unable to import %s',
-              'import-error',
-              'Used when pylint has been unable to import a module.'),
-    'R0401': ('Cyclic import (%s)',
-              'cyclic-import',
-              'Used when a cyclic import between two or more modules is \
-              detected.'),
-
-    'W0401': ('Wildcard import %s',
-              'wildcard-import',
-              'Used when `from module import *` is detected.'),
-    'W0402': ('Uses of a deprecated module %r',
-              'deprecated-module',
-              'Used a module marked as deprecated is imported.'),
-    'W0403': ('Relative import %r, should be %r',
-              'relative-import',
-              'Used when an import relative to the package directory is \
-              detected.'),
-    'W0404': ('Reimport %r (imported line %s)',
-              'reimported',
-              'Used when a module is reimported multiple times.'),
-    'W0406': ('Module import itself',
-              'import-self',
-              'Used when a module is importing itself.'),
-
-    'W0410': ('__future__ import is not the first non docstring statement',
-              'misplaced-future',
-              'Python 2.5 and greater require __future__ import to be the \
-              first non docstring statement in the module.',
-              {'maxversion': (3, 0)}),
-    }
-
-class ImportsChecker(BaseChecker):
-    """checks for
-    * external modules dependencies
-    * relative / wildcard imports
-    * cyclic imports
-    * uses of deprecated modules
-    """
-
-    __implements__ = IAstroidChecker
-
-    name = 'imports'
-    msgs = MSGS
-    priority = -2
-
-    if sys.version_info < (3,):
-        deprecated_modules = ('regsub', 'TERMIOS', 'Bastion', 'rexec')
-    else:
-        deprecated_modules = ('stringprep', 'optparse')
-    options = (('deprecated-modules',
-                {'default' : deprecated_modules,
-                 'type' : 'csv',
-                 'metavar' : '<modules>',
-                 'help' : 'Deprecated modules which should not be used, \
-separated by a comma'}
-                ),
-               ('import-graph',
-                {'default' : '',
-                 'type' : 'string',
-                 'metavar' : '<file.dot>',
-                 'help' : 'Create a graph of every (i.e. internal and \
-external) dependencies in the given file (report RP0402 must not be disabled)'}
-                ),
-               ('ext-import-graph',
-                {'default' : '',
-                 'type' : 'string',
-                 'metavar' : '<file.dot>',
-                 'help' : 'Create a graph of external dependencies in the \
-given file (report RP0402 must not be disabled)'}
-                ),
-               ('int-import-graph',
-                {'default' : '',
-                 'type' : 'string',
-                 'metavar' : '<file.dot>',
-                 'help' : 'Create a graph of internal dependencies in the \
-given file (report RP0402 must not be disabled)'}
-                ),
-
-               )
-
-    def __init__(self, linter=None):
-        BaseChecker.__init__(self, linter)
-        self.stats = None
-        self.import_graph = None
-        self.__int_dep_info = self.__ext_dep_info = None
-        self.reports = (('RP0401', 'External dependencies',
-                         self.report_external_dependencies),
-                        ('RP0402', 'Modules dependencies graph',
-                         self.report_dependencies_graph),
-                        )
-
-    def open(self):
-        """called before visiting project (i.e set of modules)"""
-        self.linter.add_stats(dependencies={})
-        self.linter.add_stats(cycles=[])
-        self.stats = self.linter.stats
-        self.import_graph = {}
-
-    def close(self):
-        """called before visiting project (i.e set of modules)"""
-        # don't try to compute cycles if the associated message is disabled
-        if self.linter.is_message_enabled('cyclic-import'):
-            for cycle in get_cycles(self.import_graph):
-                self.add_message('cyclic-import', args=' -> '.join(cycle))
-
-    def visit_import(self, node):
-        """triggered when an import statement is seen"""
-        modnode = node.root()
-        for name, _ in node.names:
-            importedmodnode = self.get_imported_module(modnode, node, name)
-            if importedmodnode is None:
-                continue
-            self._check_relative_import(modnode, node, importedmodnode, name)
-            self._add_imported_module(node, importedmodnode.name)
-            self._check_deprecated_module(node, name)
-            self._check_reimport(node, name)
-
-    # TODO This appears to be the list of all messages of the checker...
-    # @check_messages('W0410', 'W0401', 'W0403', 'W0402', 'W0404', 'W0406', 'F0401')
-    @check_messages(*(MSGS.keys()))
-    def visit_from(self, node):
-        """triggered when a from statement is seen"""
-        basename = node.modname
-        if basename == '__future__':
-            # check if this is the first non-docstring statement in the module
-            prev = node.previous_sibling()
-            if prev:
-                # consecutive future statements are possible
-                if not (isinstance(prev, astroid.From)
-                       and prev.modname == '__future__'):
-                    self.add_message('misplaced-future', node=node)
-            return
-        for name, _ in node.names:
-            if name == '*':
-                self.add_message('wildcard-import', args=basename, node=node)
-        modnode = node.root()
-        importedmodnode = self.get_imported_module(modnode, node, basename)
-        if importedmodnode is None:
-            return
-        self._check_relative_import(modnode, node, importedmodnode, basename)
-        self._check_deprecated_module(node, basename)
-        for name, _ in node.names:
-            if name != '*':
-                self._add_imported_module(node, '%s.%s' % (importedmodnode.name, name))
-                self._check_reimport(node, name, basename, node.level)
-
-    def get_imported_module(self, modnode, importnode, modname):
-        try:
-            return importnode.do_import_module(modname)
-        except astroid.InferenceError, ex:
-            if str(ex) != modname:
-                args = '%r (%s)' % (modname, ex)
-            else:
-                args = repr(modname)
-            self.add_message("import-error", args=args, node=importnode)
-
-    def _check_relative_import(self, modnode, importnode, importedmodnode,
-                               importedasname):
-        """check relative import. node is either an Import or From node, modname
-        the imported module name.
-        """
-        if not self.linter.is_message_enabled('relative-import'):
-            return
-        if importedmodnode.file is None:
-            return False # built-in module
-        if modnode is importedmodnode:
-            return False # module importing itself
-        if modnode.absolute_import_activated() or getattr(importnode, 'level', None):
-            return False
-        if importedmodnode.name != importedasname:
-            # this must be a relative import...
-            self.add_message('relative-import', args=(importedasname, importedmodnode.name),
-                             node=importnode)
-
-    def _add_imported_module(self, node, importedmodname):
-        """notify an imported module, used to analyze dependencies"""
-        importedmodname = get_module_part(importedmodname)
-        context_name = node.root().name
-        if context_name == importedmodname:
-            # module importing itself !
-            self.add_message('import-self', node=node)
-        elif not is_standard_module(importedmodname):
-            # handle dependencies
-            importedmodnames = self.stats['dependencies'].setdefault(
-                importedmodname, set())
-            if not context_name in importedmodnames:
-                importedmodnames.add(context_name)
-            # update import graph
-            mgraph = self.import_graph.setdefault(context_name, set())
-            if not importedmodname in mgraph:
-                mgraph.add(importedmodname)
-
-    def _check_deprecated_module(self, node, mod_path):
-        """check if the module is deprecated"""
-        for mod_name in self.config.deprecated_modules:
-            if mod_path == mod_name or mod_path.startswith(mod_name + '.'):
-                self.add_message('deprecated-module', node=node, args=mod_path)
-
-    def _check_reimport(self, node, name, basename=None, level=None):
-        """check if the import is necessary (i.e. not already done)"""
-        if not self.linter.is_message_enabled('reimported'):
-            return
-        frame = node.frame()
-        root = node.root()
-        contexts = [(frame, level)]
-        if root is not frame:
-            contexts.append((root, None))
-        for context, level in contexts:
-            first = get_first_import(node, context, name, basename, level)
-            if first is not None:
-                self.add_message('reimported', node=node,
-                                 args=(name, first.fromlineno))
-
-
-    def report_external_dependencies(self, sect, _, dummy):
-        """return a verbatim layout for displaying dependencies"""
-        dep_info = make_tree_defs(self._external_dependencies_info().iteritems())
-        if not dep_info:
-            raise EmptyReport()
-        tree_str = repr_tree_defs(dep_info)
-        sect.append(VerbatimText(tree_str))
-
-    def report_dependencies_graph(self, sect, _, dummy):
-        """write dependencies as a dot (graphviz) file"""
-        dep_info = self.stats['dependencies']
-        if not dep_info or not (self.config.import_graph
-                                or self.config.ext_import_graph
-                                or self.config.int_import_graph):
-            raise EmptyReport()
-        filename = self.config.import_graph
-        if filename:
-            make_graph(filename, dep_info, sect, '')
-        filename = self.config.ext_import_graph
-        if filename:
-            make_graph(filename, self._external_dependencies_info(),
-                       sect, 'external ')
-        filename = self.config.int_import_graph
-        if filename:
-            make_graph(filename, self._internal_dependencies_info(),
-                       sect, 'internal ')
-
-    def _external_dependencies_info(self):
-        """return cached external dependencies information or build and
-        cache them
-        """
-        if self.__ext_dep_info is None:
-            package = self.linter.base_name
-            self.__ext_dep_info = result = {}
-            for importee, importers in self.stats['dependencies'].iteritems():
-                if not importee.startswith(package):
-                    result[importee] = importers
-        return self.__ext_dep_info
-
-    def _internal_dependencies_info(self):
-        """return cached internal dependencies information or build and
-        cache them
-        """
-        if self.__int_dep_info is None:
-            package = self.linter.base_name
-            self.__int_dep_info = result = {}
-            for importee, importers in self.stats['dependencies'].iteritems():
-                if importee.startswith(package):
-                    result[importee] = importers
-        return self.__int_dep_info
-
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(ImportsChecker(linter))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/logging.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/logging.py
deleted file mode 100644
index cbdf0f2a..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/logging.py
+++ /dev/null
@@ -1,213 +0,0 @@
-# Copyright (c) 2009-2010 Google, Inc.
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""checker for use of Python logging
-"""
-
-import astroid
-from pylint import checkers
-from pylint import interfaces
-from pylint.checkers import utils
-from pylint.checkers.utils import check_messages
-
-MSGS = {
-    'W1201': ('Specify string format arguments as logging function parameters',
-             'logging-not-lazy',
-             'Used when a logging statement has a call form of '
-             '"logging.<logging method>(format_string % (format_args...))". '
-             'Such calls should leave string interpolation to the logging '
-             'method itself and be written '
-             '"logging.<logging method>(format_string, format_args...)" '
-             'so that the program may avoid incurring the cost of the '
-             'interpolation in those cases in which no message will be '
-             'logged. For more, see '
-             'http://www.python.org/dev/peps/pep-0282/.'),
-    'E1200': ('Unsupported logging format character %r (%#02x) at index %d',
-              'logging-unsupported-format',
-              'Used when an unsupported format character is used in a logging\
-              statement format string.'),
-    'E1201': ('Logging format string ends in middle of conversion specifier',
-              'logging-format-truncated',
-              'Used when a logging statement format string terminates before\
-              the end of a conversion specifier.'),
-    'E1205': ('Too many arguments for logging format string',
-              'logging-too-many-args',
-              'Used when a logging format string is given too few arguments.'),
-    'E1206': ('Not enough arguments for logging format string',
-              'logging-too-few-args',
-              'Used when a logging format string is given too many arguments'),
-    }
-
-
-CHECKED_CONVENIENCE_FUNCTIONS = set([
-    'critical', 'debug', 'error', 'exception', 'fatal', 'info', 'warn',
-    'warning'])
-
-
-class LoggingChecker(checkers.BaseChecker):
-    """Checks use of the logging module."""
-
-    __implements__ = interfaces.IAstroidChecker
-    name = 'logging'
-    msgs = MSGS
-
-    options = (('logging-modules',
-                {'default' : ('logging',),
-                 'type' : 'csv',
-                 'metavar' : '<comma separated list>',
-                 'help' : ('Logging modules to check that the string format '
-                           'arguments are in logging function parameter format')}
-                ),
-               )
-
-    def visit_module(self, unused_node):
-        """Clears any state left in this checker from last module checked."""
-        # The code being checked can just as easily "import logging as foo",
-        # so it is necessary to process the imports and store in this field
-        # what name the logging module is actually given.
-        self._logging_names = set()
-        logging_mods = self.config.logging_modules
-
-        self._logging_modules = set(logging_mods)
-        self._from_imports = {}
-        for logging_mod in logging_mods:
-            parts = logging_mod.rsplit('.', 1)
-            if len(parts) > 1:
-                self._from_imports[parts[0]] = parts[1]
-
-    def visit_from(self, node):
-        """Checks to see if a module uses a non-Python logging module."""
-        try:
-            logging_name = self._from_imports[node.modname]
-            for module, as_name in node.names:
-                if module == logging_name:
-                    self._logging_names.add(as_name or module)
-        except KeyError:
-            pass
-
-    def visit_import(self, node):
-        """Checks to see if this module uses Python's built-in logging."""
-        for module, as_name in node.names:
-            if module in self._logging_modules:
-                self._logging_names.add(as_name or module)
-
-    @check_messages(*(MSGS.keys()))
-    def visit_callfunc(self, node):
-        """Checks calls to logging methods."""
-        def is_logging_name():
-           return (isinstance(node.func, astroid.Getattr) and
-                   isinstance(node.func.expr, astroid.Name) and 
-                   node.func.expr.name in self._logging_names)
-
-        def is_logger_class():
-            try:
-                for inferred in node.func.infer():
-                    if isinstance(inferred, astroid.BoundMethod):
-                        parent = inferred._proxied.parent
-                        if (isinstance(parent, astroid.Class) and 
-                            (parent.qname() == 'logging.Logger' or 
-                             any(ancestor.qname() == 'logging.Logger' 
-                                 for ancestor in parent.ancestors()))):
-                            return True, inferred._proxied.name
-            except astroid.exceptions.InferenceError:
-                pass
-            return False, None
-
-        if is_logging_name():
-            name = node.func.attrname
-        else:
-            result, name = is_logger_class()
-            if not result:
-                return
-        self._check_log_method(node, name)
-
-    def _check_log_method(self, node, name):
-        """Checks calls to logging.log(level, format, *format_args)."""
-        if name == 'log':
-            if node.starargs or node.kwargs or len(node.args) < 2:
-                # Either a malformed call, star args, or double-star args. Beyond
-                # the scope of this checker.
-                return
-            format_pos = 1
-        elif name in CHECKED_CONVENIENCE_FUNCTIONS:
-            if node.starargs or node.kwargs or not node.args:
-                # Either no args, star args, or double-star args. Beyond the
-                # scope of this checker.
-                return
-            format_pos = 0
-        else:
-            return
-
-        if isinstance(node.args[format_pos], astroid.BinOp) and node.args[format_pos].op == '%':
-            self.add_message('logging-not-lazy', node=node)
-        elif isinstance(node.args[format_pos], astroid.Const):
-            self._check_format_string(node, format_pos)
-
-    def _check_format_string(self, node, format_arg):
-        """Checks that format string tokens match the supplied arguments.
-
-        Args:
-          node: AST node to be checked.
-          format_arg: Index of the format string in the node arguments.
-        """
-        num_args = _count_supplied_tokens(node.args[format_arg + 1:])
-        if not num_args:
-            # If no args were supplied, then all format strings are valid -
-            # don't check any further.
-            return
-        format_string = node.args[format_arg].value
-        if not isinstance(format_string, basestring):
-            # If the log format is constant non-string (e.g. logging.debug(5)),
-            # ensure there are no arguments.
-            required_num_args = 0
-        else:
-            try:
-                keyword_args, required_num_args = \
-                    utils.parse_format_string(format_string)
-                if keyword_args:
-                    # Keyword checking on logging strings is complicated by
-                    # special keywords - out of scope.
-                    return
-            except utils.UnsupportedFormatCharacter, ex:
-                char = format_string[ex.index]
-                self.add_message('logging-unsupported-format', node=node,
-                                 args=(char, ord(char), ex.index))
-                return
-            except utils.IncompleteFormatString:
-                self.add_message('logging-format-truncated', node=node)
-                return
-        if num_args > required_num_args:
-            self.add_message('logging-too-many-args', node=node)
-        elif num_args < required_num_args:
-            self.add_message('logging-too-few-args', node=node)
-
-
-def _count_supplied_tokens(args):
-    """Counts the number of tokens in an args list.
-
-    The Python log functions allow for special keyword arguments: func,
-    exc_info and extra. To handle these cases correctly, we only count
-    arguments that aren't keywords.
-
-    Args:
-      args: List of AST nodes that are arguments for a log format string.
-
-    Returns:
-      Number of AST nodes that aren't keywords.
-    """
-    return sum(1 for arg in args if not isinstance(arg, astroid.Keyword))
-
-
-def register(linter):
-    """Required method to auto-register this checker."""
-    linter.register_checker(LoggingChecker(linter))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/misc.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/misc.py
deleted file mode 100644
index d1b7c216..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/misc.py
+++ /dev/null
@@ -1,90 +0,0 @@
-# pylint: disable=W0511
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-""" Copyright (c) 2000-2010 LOGILAB S.A. (Paris, FRANCE).
- http://www.logilab.fr/ -- mailto:contact@logilab.fr
-
-Check source code is ascii only or has an encoding declaration (PEP 263)
-"""
-
-import re
-
-from pylint.interfaces import IRawChecker
-from pylint.checkers import BaseChecker
-
-
-MSGS = {
-    'W0511': ('%s',
-              'fixme',
-              'Used when a warning note as FIXME or XXX is detected.'),
-    'W0512': ('Cannot decode using encoding "%s", unexpected byte at position %d',
-              'invalid-encoded-data',
-              'Used when a source line cannot be decoded using the specified '
-              'source file encoding.',
-              {'maxversion': (3, 0)}),
-    }
-
-
-class EncodingChecker(BaseChecker):
-    """checks for:
-    * warning notes in the code like FIXME, XXX
-    * encoding issues.
-    """
-    __implements__ = IRawChecker
-
-    # configuration section name
-    name = 'miscellaneous'
-    msgs = MSGS
-
-    options = (('notes',
-                {'type' : 'csv', 'metavar' : '<comma separated values>',
-                 'default' : ('FIXME', 'XXX', 'TODO'),
-                 'help' : 'List of note tags to take in consideration, \
-separated by a comma.'
-                 }),
-               )
-
-    def _check_note(self, notes, lineno, line):
-        match = notes.search(line)
-        if match:
-            self.add_message('fixme', args=line[match.start():-1], line=lineno)
-
-    def _check_encoding(self, lineno, line, file_encoding):
-        try:
-            return unicode(line, file_encoding)
-        except UnicodeDecodeError, ex:
-            self.add_message('invalid-encoded-data', line=lineno,
-                             args=(file_encoding, ex.args[2]))
-
-    def process_module(self, module):
-        """inspect the source file to find encoding problem or fixmes like
-        notes
-        """
-        stream = module.file_stream
-        stream.seek(0) # XXX may be removed with astroid > 0.23
-        if self.config.notes:
-            notes = re.compile('|'.join(self.config.notes))
-        else:
-            notes = None
-        if module.file_encoding:
-            encoding = module.file_encoding
-        else:
-            encoding = 'ascii'
-        for lineno, line in enumerate(stream):
-            line = self._check_encoding(lineno+1, line, encoding)
-            if line is not None and notes:
-                self._check_note(notes, lineno+1, line)
-
-def register(linter):
-    """required method to auto register this checker"""
-    linter.register_checker(EncodingChecker(linter))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/newstyle.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/newstyle.py
deleted file mode 100644
index f801c443..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/newstyle.py
+++ /dev/null
@@ -1,151 +0,0 @@
-# Copyright (c) 2005-2014 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""check for new / old style related problems
-"""
-import sys
-
-import astroid
-
-from pylint.interfaces import IAstroidChecker
-from pylint.checkers import BaseChecker
-from pylint.checkers.utils import check_messages
-
-MSGS = {
-    'E1001': ('Use of __slots__ on an old style class',
-              'slots-on-old-class',
-              'Used when an old style class uses the __slots__ attribute.',
-              {'maxversion': (3, 0)}),
-    'E1002': ('Use of super on an old style class',
-              'super-on-old-class',
-              'Used when an old style class uses the super builtin.',
-              {'maxversion': (3, 0)}),
-    'E1003': ('Bad first argument %r given to super()',
-              'bad-super-call',
-              'Used when another argument than the current class is given as \
-              first argument of the super builtin.'),
-    'E1004': ('Missing argument to super()',
-              'missing-super-argument',
-              'Used when the super builtin didn\'t receive an \
-               argument.',
-              {'maxversion': (3, 0)}),
-    'W1001': ('Use of "property" on an old style class',
-              'property-on-old-class',
-              'Used when PyLint detect the use of the builtin "property" \
-              on an old style class while this is relying on new style \
-              classes features.',
-              {'maxversion': (3, 0)}),
-    'C1001': ('Old-style class defined.',
-              'old-style-class',
-              'Used when a class is defined that does not inherit from another'
-              'class and does not inherit explicitly from "object".',
-              {'maxversion': (3, 0)})
-    }
-
-
-class NewStyleConflictChecker(BaseChecker):
-    """checks for usage of new style capabilities on old style classes and
-    other new/old styles conflicts problems
-    * use of property, __slots__, super
-    * "super" usage
-    """
-
-    __implements__ = (IAstroidChecker,)
-
-    # configuration section name
-    name = 'newstyle'
-    # messages
-    msgs = MSGS
-    priority = -2
-    # configuration options
-    options = ()
-
-    @check_messages('slots-on-old-class', 'old-style-class')
-    def visit_class(self, node):
-        """check __slots__ usage
-        """
-        if '__slots__' in node and not node.newstyle:
-            self.add_message('slots-on-old-class', node=node)
-        # The node type could be class, exception, metaclass, or
-        # interface.  Presumably, the non-class-type nodes would always
-        # have an explicit base class anyway.
-        if not node.bases and node.type == 'class':
-            self.add_message('old-style-class', node=node)
-
-    @check_messages('property-on-old-class')
-    def visit_callfunc(self, node):
-        """check property usage"""
-        parent = node.parent.frame()
-        if (isinstance(parent, astroid.Class) and
-            not parent.newstyle and
-            isinstance(node.func, astroid.Name)):
-            name = node.func.name
-            if name == 'property':
-                self.add_message('property-on-old-class', node=node)
-
-    @check_messages('super-on-old-class', 'bad-super-call', 'missing-super-argument')
-    def visit_function(self, node):
-        """check use of super"""
-        # ignore actual functions or method within a new style class
-        if not node.is_method():
-            return
-        klass = node.parent.frame()
-        for stmt in node.nodes_of_class(astroid.CallFunc):
-            expr = stmt.func
-            if not isinstance(expr, astroid.Getattr):
-                continue
-            call = expr.expr
-            # skip the test if using super
-            if isinstance(call, astroid.CallFunc) and \
-               isinstance(call.func, astroid.Name) and \
-               call.func.name == 'super':
-                if not klass.newstyle:
-                    # super should not be used on an old style class
-                    self.add_message('super-on-old-class', node=node)
-                else:
-                    # super first arg should be the class
-                    if not call.args and sys.version_info[0] == 3:
-                        # unless Python 3
-                        continue
-
-                    try:
-                        supcls = (call.args and call.args[0].infer().next()
-                                  or None)
-                    except astroid.InferenceError:
-                        continue
-
-                    if supcls is None:
-                        self.add_message('missing-super-argument', node=call)
-                        continue
-
-                    if klass is not supcls:
-                        name = None
-                        # if supcls is not YES, then supcls was infered
-                        # and use its name. Otherwise, try to look
-                        # for call.args[0].name
-                        if supcls is not astroid.YES:
-                            name = supcls.name
-                        else:
-                            if hasattr(call.args[0], 'name'):
-                                name = call.args[0].name
-                        if name is not None:
-                            self.add_message('bad-super-call',
-                                             node=call,
-                                             args=(name, ))
-
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(NewStyleConflictChecker(linter))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/raw_metrics.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/raw_metrics.py
deleted file mode 100644
index 71fecf68..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/raw_metrics.py
+++ /dev/null
@@ -1,129 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-""" Copyright (c) 2003-2010 LOGILAB S.A. (Paris, FRANCE).
- http://www.logilab.fr/ -- mailto:contact@logilab.fr
-
-Raw metrics checker
-"""
-
-import tokenize
-
-# pylint now requires pylint >= 2.2, so this is no longer necessary
-#if not hasattr(tokenize, 'NL'):
-#    raise ValueError("tokenize.NL doesn't exist -- tokenize module too old")
-
-from logilab.common.ureports import Table
-
-from pylint.interfaces import ITokenChecker
-from pylint.utils import EmptyReport
-from pylint.checkers import BaseTokenChecker
-from pylint.reporters import diff_string
-
-def report_raw_stats(sect, stats, old_stats):
-    """calculate percentage of code / doc / comment / empty
-    """
-    total_lines = stats['total_lines']
-    if not total_lines:
-        raise EmptyReport()
-    sect.description = '%s lines have been analyzed' % total_lines
-    lines = ('type', 'number', '%', 'previous', 'difference')
-    for node_type in ('code', 'docstring', 'comment', 'empty'):
-        key = node_type + '_lines'
-        total = stats[key]
-        percent = float(total * 100) / total_lines
-        old = old_stats.get(key, None)
-        if old is not None:
-            diff_str = diff_string(old, total)
-        else:
-            old, diff_str = 'NC', 'NC'
-        lines += (node_type, str(total), '%.2f' % percent,
-                  str(old), diff_str)
-    sect.append(Table(children=lines, cols=5, rheaders=1))
-
-
-class RawMetricsChecker(BaseTokenChecker):
-    """does not check anything but gives some raw metrics :
-    * total number of lines
-    * total number of code lines
-    * total number of docstring lines
-    * total number of comments lines
-    * total number of empty lines
-    """
-
-    __implements__ = (ITokenChecker,)
-
-    # configuration section name
-    name = 'metrics'
-    # configuration options
-    options = ()
-    # messages
-    msgs = {}
-    # reports
-    reports = (('RP0701', 'Raw metrics', report_raw_stats),)
-
-    def __init__(self, linter):
-        BaseTokenChecker.__init__(self, linter)
-        self.stats = None
-
-    def open(self):
-        """init statistics"""
-        self.stats = self.linter.add_stats(total_lines=0, code_lines=0,
-                                           empty_lines=0, docstring_lines=0,
-                                           comment_lines=0)
-
-    def process_tokens(self, tokens):
-        """update stats"""
-        i = 0
-        tokens = list(tokens)
-        while i < len(tokens):
-            i, lines_number, line_type = get_type(tokens, i)
-            self.stats['total_lines'] += lines_number
-            self.stats[line_type] += lines_number
-
-
-JUNK = (tokenize.NL, tokenize.INDENT, tokenize.NEWLINE, tokenize.ENDMARKER)
-
-def get_type(tokens, start_index):
-    """return the line type : docstring, comment, code, empty"""
-    i = start_index
-    tok_type = tokens[i][0]
-    start = tokens[i][2]
-    pos = start
-    line_type = None
-    while i < len(tokens) and tokens[i][2][0] == start[0]:
-        tok_type = tokens[i][0]
-        pos = tokens[i][3]
-        if line_type is None:
-            if tok_type == tokenize.STRING:
-                line_type = 'docstring_lines'
-            elif tok_type == tokenize.COMMENT:
-                line_type = 'comment_lines'
-            elif tok_type in JUNK:
-                pass
-            else:
-                line_type = 'code_lines'
-        i += 1
-    if line_type is None:
-        line_type = 'empty_lines'
-    elif i < len(tokens) and tok_type == tokenize.NEWLINE:
-        i += 1
-    return i, pos[0] - start[0] + 1, line_type
-
-
-def register(linter):
-    """ required method to auto register this checker """
-    linter.register_checker(RawMetricsChecker(linter))
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/similar.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/similar.py
deleted file mode 100644
index cf671bf6..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/similar.py
+++ /dev/null
@@ -1,365 +0,0 @@
-# pylint: disable=W0622
-# Copyright (c) 2004-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""a similarities / code duplication command line tool and pylint checker
-"""
-import sys
-from itertools import izip
-
-from logilab.common.ureports import Table
-
-from pylint.interfaces import IRawChecker
-from pylint.checkers import BaseChecker, table_lines_from_stats
-
-
-class Similar(object):
-    """finds copy-pasted lines of code in a project"""
-
-    def __init__(self, min_lines=4, ignore_comments=False,
-                 ignore_docstrings=False, ignore_imports=False):
-        self.min_lines = min_lines
-        self.ignore_comments = ignore_comments
-        self.ignore_docstrings = ignore_docstrings
-        self.ignore_imports = ignore_imports
-        self.linesets = []
-
-    def append_stream(self, streamid, stream, encoding=None):
-        """append a file to search for similarities"""
-        stream.seek(0) # XXX may be removed with astroid > 0.23
-        if encoding is None:
-            readlines = stream.readlines
-        else:
-            readlines = lambda: [line.decode(encoding) for line in stream]
-        try:
-            self.linesets.append(LineSet(streamid,
-                                         readlines(),
-                                         self.ignore_comments,
-                                         self.ignore_docstrings,
-                                         self.ignore_imports))
-        except UnicodeDecodeError:
-            pass
-
-    def run(self):
-        """start looking for similarities and display results on stdout"""
-        self._display_sims(self._compute_sims())
-
-    def _compute_sims(self):
-        """compute similarities in appended files"""
-        no_duplicates = {}
-        for num, lineset1, idx1, lineset2, idx2 in self._iter_sims():
-            duplicate = no_duplicates.setdefault(num, [])
-            for couples in duplicate:
-                if (lineset1, idx1) in couples or (lineset2, idx2) in couples:
-                    couples.add((lineset1, idx1))
-                    couples.add((lineset2, idx2))
-                    break
-            else:
-                duplicate.append(set([(lineset1, idx1), (lineset2, idx2)]))
-        sims = []
-        for num, ensembles in no_duplicates.iteritems():
-            for couples in ensembles:
-                sims.append((num, couples))
-        sims.sort()
-        sims.reverse()
-        return sims
-
-    def _display_sims(self, sims):
-        """display computed similarities on stdout"""
-        nb_lignes_dupliquees = 0
-        for num, couples in sims:
-            print
-            print num, "similar lines in", len(couples), "files"
-            couples = sorted(couples)
-            for lineset, idx in couples:
-                print "==%s:%s" % (lineset.name, idx)
-            # pylint: disable=W0631
-            for line in lineset._real_lines[idx:idx+num]:
-                print "  ", line.rstrip()
-            nb_lignes_dupliquees += num * (len(couples)-1)
-        nb_total_lignes = sum([len(lineset) for lineset in self.linesets])
-        print "TOTAL lines=%s duplicates=%s percent=%.2f" \
-            % (nb_total_lignes, nb_lignes_dupliquees,
-               nb_lignes_dupliquees*100. / nb_total_lignes)
-
-    def _find_common(self, lineset1, lineset2):
-        """find similarities in the two given linesets"""
-        lines1 = lineset1.enumerate_stripped
-        lines2 = lineset2.enumerate_stripped
-        find = lineset2.find
-        index1 = 0
-        min_lines = self.min_lines
-        while index1 < len(lineset1):
-            skip = 1
-            num = 0
-            for index2 in find(lineset1[index1]):
-                non_blank = 0
-                for num, ((_, line1), (_, line2)) in enumerate(
-                    izip(lines1(index1), lines2(index2))):
-                    if line1 != line2:
-                        if non_blank > min_lines:
-                            yield num, lineset1, index1, lineset2, index2
-                        skip = max(skip, num)
-                        break
-                    if line1:
-                        non_blank += 1
-                else:
-                    # we may have reach the end
-                    num += 1
-                    if non_blank > min_lines:
-                        yield num, lineset1, index1, lineset2, index2
-                    skip = max(skip, num)
-            index1 += skip
-
-    def _iter_sims(self):
-        """iterate on similarities among all files, by making a cartesian
-        product
-        """
-        for idx, lineset in enumerate(self.linesets[:-1]):
-            for lineset2 in self.linesets[idx+1:]:
-                for sim in self._find_common(lineset, lineset2):
-                    yield sim
-
-def stripped_lines(lines, ignore_comments, ignore_docstrings, ignore_imports):
-    """return lines with leading/trailing whitespace and any ignored code
-    features removed
-    """
-
-    strippedlines = []
-    docstring = None
-    for line in lines:
-        line = line.strip()
-        if ignore_docstrings:
-            if not docstring and \
-                   (line.startswith('"""') or line.startswith("'''")):
-                docstring = line[:3]
-                line = line[3:]
-            if docstring:
-                if line.endswith(docstring):
-                    docstring = None
-                line = ''
-        if ignore_imports:
-            if line.startswith("import ") or line.startswith("from "):
-                line = ''
-        if ignore_comments:
-            # XXX should use regex in checkers/format to avoid cutting
-            # at a "#" in a string
-            line = line.split('#', 1)[0].strip()
-        strippedlines.append(line)
-    return strippedlines
-
-
-class LineSet(object):
-    """Holds and indexes all the lines of a single source file"""
-    def __init__(self, name, lines, ignore_comments=False,
-                 ignore_docstrings=False, ignore_imports=False):
-        self.name = name
-        self._real_lines = lines
-        self._stripped_lines = stripped_lines(lines, ignore_comments,
-                                              ignore_docstrings,
-                                              ignore_imports)
-        self._index = self._mk_index()
-
-    def __str__(self):
-        return '<Lineset for %s>' % self.name
-
-    def __len__(self):
-        return len(self._real_lines)
-
-    def __getitem__(self, index):
-        return self._stripped_lines[index]
-
-    def __lt__(self, other):
-        return self.name < other.name
-
-    def __hash__(self):
-        return id(self)
-
-    def enumerate_stripped(self, start_at=0):
-        """return an iterator on stripped lines, starting from a given index
-        if specified, else 0
-        """
-        idx = start_at
-        if start_at:
-            lines = self._stripped_lines[start_at:]
-        else:
-            lines = self._stripped_lines
-        for line in lines:
-            #if line:
-            yield idx, line
-            idx += 1
-
-    def find(self, stripped_line):
-        """return positions of the given stripped line in this set"""
-        return self._index.get(stripped_line, ())
-
-    def _mk_index(self):
-        """create the index for this set"""
-        index = {}
-        for line_no, line in enumerate(self._stripped_lines):
-            if line:
-                index.setdefault(line, []).append(line_no)
-        return index
-
-
-MSGS = {'R0801': ('Similar lines in %s files\n%s',
-                  'duplicate-code',
-                  'Indicates that a set of similar lines has been detected \
-                  among multiple file. This usually means that the code should \
-                  be refactored to avoid this duplication.')}
-
-def report_similarities(sect, stats, old_stats):
-    """make a layout with some stats about duplication"""
-    lines = ['', 'now', 'previous', 'difference']
-    lines += table_lines_from_stats(stats, old_stats,
-                                    ('nb_duplicated_lines',
-                                     'percent_duplicated_lines'))
-    sect.append(Table(children=lines, cols=4, rheaders=1, cheaders=1))
-
-
-# wrapper to get a pylint checker from the similar class
-class SimilarChecker(BaseChecker, Similar):
-    """checks for similarities and duplicated code. This computation may be
-    memory / CPU intensive, so you should disable it if you experiment some
-    problems.
-    """
-
-    __implements__ = (IRawChecker,)
-    # configuration section name
-    name = 'similarities'
-    # messages
-    msgs = MSGS
-    # configuration options
-    # for available dict keys/values see the optik parser 'add_option' method
-    options = (('min-similarity-lines',
-                {'default' : 4, 'type' : "int", 'metavar' : '<int>',
-                 'help' : 'Minimum lines number of a similarity.'}),
-               ('ignore-comments',
-                {'default' : True, 'type' : 'yn', 'metavar' : '<y or n>',
-                 'help': 'Ignore comments when computing similarities.'}
-                ),
-               ('ignore-docstrings',
-                {'default' : True, 'type' : 'yn', 'metavar' : '<y or n>',
-                 'help': 'Ignore docstrings when computing similarities.'}
-                ),
-               ('ignore-imports',
-                {'default' : False, 'type' : 'yn', 'metavar' : '<y or n>',
-                 'help': 'Ignore imports when computing similarities.'}
-                ),
-               )
-    # reports
-    reports = (('RP0801', 'Duplication', report_similarities),)
-
-    def __init__(self, linter=None):
-        BaseChecker.__init__(self, linter)
-        Similar.__init__(self, min_lines=4,
-                         ignore_comments=True, ignore_docstrings=True)
-        self.stats = None
-
-    def set_option(self, optname, value, action=None, optdict=None):
-        """method called to set an option (registered in the options list)
-
-        overridden to report options setting to Similar
-        """
-        BaseChecker.set_option(self, optname, value, action, optdict)
-        if optname == 'min-similarity-lines':
-            self.min_lines = self.config.min_similarity_lines
-        elif optname == 'ignore-comments':
-            self.ignore_comments = self.config.ignore_comments
-        elif optname == 'ignore-docstrings':
-            self.ignore_docstrings = self.config.ignore_docstrings
-        elif optname == 'ignore-imports':
-            self.ignore_imports = self.config.ignore_imports
-
-    def open(self):
-        """init the checkers: reset linesets and statistics information"""
-        self.linesets = []
-        self.stats = self.linter.add_stats(nb_duplicated_lines=0,
-                                           percent_duplicated_lines=0)
-
-    def process_module(self, node):
-        """process a module
-
-        the module's content is accessible via the stream object
-
-        stream must implement the readlines method
-        """
-        self.append_stream(self.linter.current_name, node.file_stream, node.file_encoding)
-
-    def close(self):
-        """compute and display similarities on closing (i.e. end of parsing)"""
-        total = sum([len(lineset) for lineset in self.linesets])
-        duplicated = 0
-        stats = self.stats
-        for num, couples in self._compute_sims():
-            msg = []
-            for lineset, idx in couples:
-                msg.append("==%s:%s" % (lineset.name, idx))
-            msg.sort()
-            # pylint: disable=W0631
-            for line in lineset._real_lines[idx:idx+num]:
-                msg.append(line.rstrip())
-            self.add_message('R0801', args=(len(couples), '\n'.join(msg)))
-            duplicated += num * (len(couples) - 1)
-        stats['nb_duplicated_lines'] = duplicated
-        stats['percent_duplicated_lines'] = total and duplicated * 100. / total
-
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(SimilarChecker(linter))
-
-def usage(status=0):
-    """display command line usage information"""
-    print "finds copy pasted blocks in a set of files"
-    print
-    print 'Usage: symilar [-d|--duplicates min_duplicated_lines] \
-[-i|--ignore-comments] [--ignore-docstrings] [--ignore-imports] file1...'
-    sys.exit(status)
-
-def Run(argv=None):
-    """standalone command line access point"""
-    if argv is None:
-        argv = sys.argv[1:]
-    from getopt import getopt
-    s_opts = 'hdi'
-    l_opts = ('help', 'duplicates=', 'ignore-comments', 'ignore-imports',
-              'ignore-docstrings')
-    min_lines = 4
-    ignore_comments = False
-    ignore_docstrings = False
-    ignore_imports = False
-    opts, args = getopt(argv, s_opts, l_opts)
-    for opt, val in opts:
-        if opt in ('-d', '--duplicates'):
-            min_lines = int(val)
-        elif opt in ('-h', '--help'):
-            usage()
-        elif opt in ('-i', '--ignore-comments'):
-            ignore_comments = True
-        elif opt in ('--ignore-docstrings',):
-            ignore_docstrings = True
-        elif opt in ('--ignore-imports',):
-            ignore_imports = True
-    if not args:
-        usage(1)
-    sim = Similar(min_lines, ignore_comments, ignore_docstrings, ignore_imports)
-    for filename in args:
-        sim.append_stream(filename, open(filename))
-    sim.run()
-    sys.exit(0)
-
-if __name__ == '__main__':
-    Run()
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/stdlib.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/stdlib.py
deleted file mode 100644
index a1c31337..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/stdlib.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# Copyright 2012 Google Inc.
-#
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""Checkers for various standard library functions."""
-
-import re
-import sys
-
-import astroid
-
-from pylint.interfaces import IAstroidChecker
-from pylint.checkers import BaseChecker
-from pylint.checkers import utils
-
-_VALID_OPEN_MODE_REGEX = r'^(r?U|[rwa]\+?b?)$'
-
-if sys.version_info >= (3, 0):
-    OPEN_MODULE = '_io'
-else:
-    OPEN_MODULE = '__builtin__'
-
-class OpenModeChecker(BaseChecker):
-    __implements__ = (IAstroidChecker,)
-    name = 'open_mode'
-
-    msgs = {
-        'W1501': ('"%s" is not a valid mode for open.',
-                  'bad-open-mode',
-                  'Python supports: r, w, a modes with b, +, and U options. '
-                  'See http://docs.python.org/2/library/functions.html#open'),
-        }
-
-    @utils.check_messages('bad-open-mode')
-    def visit_callfunc(self, node):
-        """Visit a CallFunc node."""
-        if hasattr(node, 'func'):
-            infer = utils.safe_infer(node.func)
-            if infer and infer.root().name == OPEN_MODULE:
-                if getattr(node.func, 'name', None) in ('open', 'file'):
-                    self._check_open_mode(node)
-
-    def _check_open_mode(self, node):
-        """Check that the mode argument of an open or file call is valid."""
-        try:
-            mode_arg = utils.get_argument_from_call(node, position=1, keyword='mode')
-            if mode_arg:
-                mode_arg = utils.safe_infer(mode_arg)
-                if (isinstance(mode_arg, astroid.Const)
-                    and not re.match(_VALID_OPEN_MODE_REGEX, mode_arg.value)):
-                    self.add_message('bad-open-mode', node=node, args=(mode_arg.value))
-        except (utils.NoSuchArgumentError, TypeError):
-            pass
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(OpenModeChecker(linter))
-
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/strings.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/strings.py
deleted file mode 100644
index 04cf1bc7..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/strings.py
+++ /dev/null
@@ -1,304 +0,0 @@
-# Copyright (c) 2009-2010 Arista Networks, Inc. - James Lingard
-# Copyright (c) 2004-2013 LOGILAB S.A. (Paris, FRANCE).
-# Copyright 2012 Google Inc.
-#
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""Checker for string formatting operations.
-"""
-
-import sys
-import tokenize
-
-import astroid
-
-from pylint.interfaces import ITokenChecker, IAstroidChecker, IRawChecker
-from pylint.checkers import BaseChecker, BaseTokenChecker
-from pylint.checkers import utils
-from pylint.checkers.utils import check_messages
-
-_PY3K = sys.version_info >= (3, 0)
-
-MSGS = {
-    'E1300': ("Unsupported format character %r (%#02x) at index %d",
-              "bad-format-character",
-              "Used when a unsupported format character is used in a format\
-              string."),
-    'E1301': ("Format string ends in middle of conversion specifier",
-              "truncated-format-string",
-              "Used when a format string terminates before the end of a \
-              conversion specifier."),
-    'E1302': ("Mixing named and unnamed conversion specifiers in format string",
-              "mixed-format-string",
-              "Used when a format string contains both named (e.g. '%(foo)d') \
-              and unnamed (e.g. '%d') conversion specifiers.  This is also \
-              used when a named conversion specifier contains * for the \
-              minimum field width and/or precision."),
-    'E1303': ("Expected mapping for format string, not %s",
-              "format-needs-mapping",
-              "Used when a format string that uses named conversion specifiers \
-              is used with an argument that is not a mapping."),
-    'W1300': ("Format string dictionary key should be a string, not %s",
-              "bad-format-string-key",
-              "Used when a format string that uses named conversion specifiers \
-              is used with a dictionary whose keys are not all strings."),
-    'W1301': ("Unused key %r in format string dictionary",
-              "unused-format-string-key",
-              "Used when a format string that uses named conversion specifiers \
-              is used with a dictionary that conWtains keys not required by the \
-              format string."),
-    'E1304': ("Missing key %r in format string dictionary",
-              "missing-format-string-key",
-              "Used when a format string that uses named conversion specifiers \
-              is used with a dictionary that doesn't contain all the keys \
-              required by the format string."),
-    'E1305': ("Too many arguments for format string",
-              "too-many-format-args",
-              "Used when a format string that uses unnamed conversion \
-              specifiers is given too many arguments."),
-    'E1306': ("Not enough arguments for format string",
-              "too-few-format-args",
-              "Used when a format string that uses unnamed conversion \
-              specifiers is given too few arguments"),
-    }
-
-OTHER_NODES = (astroid.Const, astroid.List, astroid.Backquote,
-               astroid.Lambda, astroid.Function,
-               astroid.ListComp, astroid.SetComp, astroid.GenExpr)
-
-class StringFormatChecker(BaseChecker):
-    """Checks string formatting operations to ensure that the format string
-    is valid and the arguments match the format string.
-    """
-
-    __implements__ = (IAstroidChecker,)
-    name = 'string'
-    msgs = MSGS
-
-    @check_messages(*(MSGS.keys()))
-    def visit_binop(self, node):
-        if node.op != '%':
-            return
-        left = node.left
-        args = node.right
-
-        if not (isinstance(left, astroid.Const)
-            and isinstance(left.value, basestring)):
-            return
-        format_string = left.value
-        try:
-            required_keys, required_num_args = \
-                utils.parse_format_string(format_string)
-        except utils.UnsupportedFormatCharacter, e:
-            c = format_string[e.index]
-            self.add_message('bad-format-character', node=node, args=(c, ord(c), e.index))
-            return
-        except utils.IncompleteFormatString:
-            self.add_message('truncated-format-string', node=node)
-            return
-        if required_keys and required_num_args:
-            # The format string uses both named and unnamed format
-            # specifiers.
-            self.add_message('mixed-format-string', node=node)
-        elif required_keys:
-            # The format string uses only named format specifiers.
-            # Check that the RHS of the % operator is a mapping object
-            # that contains precisely the set of keys required by the
-            # format string.
-            if isinstance(args, astroid.Dict):
-                keys = set()
-                unknown_keys = False
-                for k, _ in args.items:
-                    if isinstance(k, astroid.Const):
-                        key = k.value
-                        if isinstance(key, basestring):
-                            keys.add(key)
-                        else:
-                            self.add_message('bad-format-string-key', node=node, args=key)
-                    else:
-                        # One of the keys was something other than a
-                        # constant.  Since we can't tell what it is,
-                        # supress checks for missing keys in the
-                        # dictionary.
-                        unknown_keys = True
-                if not unknown_keys:
-                    for key in required_keys:
-                        if key not in keys:
-                            self.add_message('missing-format-string-key', node=node, args=key)
-                for key in keys:
-                    if key not in required_keys:
-                        self.add_message('unused-format-string-key', node=node, args=key)
-            elif isinstance(args, OTHER_NODES + (astroid.Tuple,)):
-                type_name = type(args).__name__
-                self.add_message('format-needs-mapping', node=node, args=type_name)
-            # else:
-                # The RHS of the format specifier is a name or
-                # expression.  It may be a mapping object, so
-                # there's nothing we can check.
-        else:
-            # The format string uses only unnamed format specifiers.
-            # Check that the number of arguments passed to the RHS of
-            # the % operator matches the number required by the format
-            # string.
-            if isinstance(args, astroid.Tuple):
-                num_args = len(args.elts)
-            elif isinstance(args, OTHER_NODES + (astroid.Dict, astroid.DictComp)):
-                num_args = 1
-            else:
-                # The RHS of the format specifier is a name or
-                # expression.  It could be a tuple of unknown size, so
-                # there's nothing we can check.
-                num_args = None
-            if num_args is not None:
-                if num_args > required_num_args:
-                    self.add_message('too-many-format-args', node=node)
-                elif num_args < required_num_args:
-                    self.add_message('too-few-format-args', node=node)
-
-
-class StringMethodsChecker(BaseChecker):
-    __implements__ = (IAstroidChecker,)
-    name = 'string'
-    msgs = {
-        'E1310': ("Suspicious argument in %s.%s call",
-                  "bad-str-strip-call",
-                  "The argument to a str.{l,r,}strip call contains a"
-                  " duplicate character, "),
-        }
-
-    @check_messages(*(MSGS.keys()))
-    def visit_callfunc(self, node):
-        func = utils.safe_infer(node.func)
-        if (isinstance(func, astroid.BoundMethod)
-            and isinstance(func.bound, astroid.Instance)
-            and func.bound.name in ('str', 'unicode', 'bytes')
-            and func.name in ('strip', 'lstrip', 'rstrip')
-            and node.args):
-            arg = utils.safe_infer(node.args[0])
-            if not isinstance(arg, astroid.Const):
-                return
-            if len(arg.value) != len(set(arg.value)):
-                self.add_message('bad-str-strip-call', node=node,
-                                 args=(func.bound.name, func.name))
-
-
-class StringConstantChecker(BaseTokenChecker):
-    """Check string literals"""
-    __implements__ = (ITokenChecker, IRawChecker)
-    name = 'string_constant'
-    msgs = {
-        'W1401': ('Anomalous backslash in string: \'%s\'. '
-                  'String constant might be missing an r prefix.',
-                  'anomalous-backslash-in-string',
-                  'Used when a backslash is in a literal string but not as an '
-                  'escape.'),
-        'W1402': ('Anomalous Unicode escape in byte string: \'%s\'. '
-                  'String constant might be missing an r or u prefix.',
-                  'anomalous-unicode-escape-in-string',
-                  'Used when an escape like \\u is encountered in a byte '
-                  'string where it has no effect.'),
-        }
-
-    # Characters that have a special meaning after a backslash in either
-    # Unicode or byte strings.
-    ESCAPE_CHARACTERS = 'abfnrtvx\n\r\t\\\'\"01234567'
-
-    # TODO(mbp): Octal characters are quite an edge case today; people may
-    # prefer a separate warning where they occur.  \0 should be allowed.
-
-    # Characters that have a special meaning after a backslash but only in
-    # Unicode strings.
-    UNICODE_ESCAPE_CHARACTERS = 'uUN'
-
-    def process_module(self, module):
-        self._unicode_literals = 'unicode_literals' in module.future_imports
-
-    def process_tokens(self, tokens):
-        for (tok_type, token, (start_row, start_col), _, _) in tokens:
-            if tok_type == tokenize.STRING:
-                # 'token' is the whole un-parsed token; we can look at the start
-                # of it to see whether it's a raw or unicode string etc.
-                self.process_string_token(token, start_row, start_col)
-
-    def process_string_token(self, token, start_row, start_col):
-        for i, c in enumerate(token):
-            if c in '\'\"':
-                quote_char = c
-                break
-        prefix = token[:i].lower() #  markers like u, b, r.
-        after_prefix = token[i:]
-        if after_prefix[:3] == after_prefix[-3:] == 3 * quote_char:
-            string_body = after_prefix[3:-3]
-        else:
-            string_body = after_prefix[1:-1]  # Chop off quotes
-        # No special checks on raw strings at the moment.
-        if 'r' not in prefix:
-            self.process_non_raw_string_token(prefix, string_body,
-                start_row, start_col)
-
-    def process_non_raw_string_token(self, prefix, string_body, start_row,
-                                     start_col):
-        """check for bad escapes in a non-raw string.
-
-        prefix: lowercase string of eg 'ur' string prefix markers.
-        string_body: the un-parsed body of the string, not including the quote
-        marks.
-        start_row: integer line number in the source.
-        start_col: integer column number in the source.
-        """
-        # Walk through the string; if we see a backslash then escape the next
-        # character, and skip over it.  If we see a non-escaped character,
-        # alert, and continue.
-        #
-        # Accept a backslash when it escapes a backslash, or a quote, or
-        # end-of-line, or one of the letters that introduce a special escape
-        # sequence <http://docs.python.org/reference/lexical_analysis.html>
-        #
-        # TODO(mbp): Maybe give a separate warning about the rarely-used
-        # \a \b \v \f?
-        #
-        # TODO(mbp): We could give the column of the problem character, but
-        # add_message doesn't seem to have a way to pass it through at present.
-        i = 0
-        while True:
-            i = string_body.find('\\', i)
-            if i == -1:
-                break
-            # There must be a next character; having a backslash at the end
-            # of the string would be a SyntaxError.
-            next_char = string_body[i+1]
-            match = string_body[i:i+2]
-            if next_char in self.UNICODE_ESCAPE_CHARACTERS:
-                if 'u' in prefix:
-                    pass
-                elif (_PY3K or self._unicode_literals) and 'b' not in prefix:
-                    pass  # unicode by default
-                else:
-                    self.add_message('anomalous-unicode-escape-in-string', 
-                                     line=start_row, args=(match, ))
-            elif next_char not in self.ESCAPE_CHARACTERS:
-                self.add_message('anomalous-backslash-in-string', 
-                                 line=start_row, args=(match, ))
-            # Whether it was a valid escape or not, backslash followed by
-            # another character can always be consumed whole: the second
-            # character can never be the start of a new backslash escape.
-            i += 2
-
-
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(StringFormatChecker(linter))
-    linter.register_checker(StringMethodsChecker(linter))
-    linter.register_checker(StringConstantChecker(linter))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/typecheck.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/typecheck.py
deleted file mode 100644
index 25f7612e..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/typecheck.py
+++ /dev/null
@@ -1,451 +0,0 @@
-# Copyright (c) 2006-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""try to find more bugs in the code using astroid inference capabilities
-"""
-
-import re
-import shlex
-
-import astroid
-from astroid import InferenceError, NotFoundError, YES, Instance
-
-from pylint.interfaces import IAstroidChecker
-from pylint.checkers import BaseChecker
-from pylint.checkers.utils import safe_infer, is_super, check_messages
-
-MSGS = {
-    'E1101': ('%s %r has no %r member',
-              'no-member',
-              'Used when a variable is accessed for an unexistent member.'),
-    'E1102': ('%s is not callable',
-              'not-callable',
-              'Used when an object being called has been inferred to a non \
-              callable object'),
-    'E1103': ('%s %r has no %r member (but some types could not be inferred)',
-              'maybe-no-member',
-              'Used when a variable is accessed for an unexistent member, but \
-              astroid was not able to interpret all possible types of this \
-              variable.'),
-    'E1111': ('Assigning to function call which doesn\'t return',
-              'assignment-from-no-return',
-              'Used when an assignment is done on a function call but the \
-              inferred function doesn\'t return anything.'),
-    'W1111': ('Assigning to function call which only returns None',
-              'assignment-from-none',
-              'Used when an assignment is done on a function call but the \
-              inferred function returns nothing but None.'),
-
-    'E1120': ('No value for argument %s in %s call',
-              'no-value-for-parameter',
-              'Used when a function call passes too few arguments.'),
-    'E1121': ('Too many positional arguments for %s call',
-              'too-many-function-args',
-              'Used when a function call passes too many positional \
-              arguments.'),
-    'E1122': ('Duplicate keyword argument %r in %s call',
-              'duplicate-keyword-arg',
-              'Used when a function call passes the same keyword argument \
-              multiple times.',
-              {'maxversion': (2, 6)}),
-    'E1123': ('Unexpected keyword argument %r in %s call',
-              'unexpected-keyword-arg',
-              'Used when a function call passes a keyword argument that \
-              doesn\'t correspond to one of the function\'s parameter names.'),
-    'E1124': ('Argument %r passed by position and keyword in %s call',
-              'redundant-keyword-arg',
-              'Used when a function call would result in assigning multiple \
-              values to a function parameter, one value from a positional \
-              argument and one from a keyword argument.'),
-    'E1125': ('Missing mandatory keyword argument %r in %s call',
-              'missing-kwoa',
-              ('Used when a function call does not pass a mandatory'
-              ' keyword-only argument.'),
-              {'minversion': (3, 0)}),
-    }
-
-def _determine_callable(callable_obj):
-    # Ordering is important, since BoundMethod is a subclass of UnboundMethod,
-    # and Function inherits Lambda.
-    if isinstance(callable_obj, astroid.BoundMethod):
-        # Bound methods have an extra implicit 'self' argument.
-        return callable_obj, 1, callable_obj.type
-    elif isinstance(callable_obj, astroid.UnboundMethod):
-        return callable_obj, 0, 'unbound method'
-    elif isinstance(callable_obj, astroid.Function):
-        return callable_obj, 0, callable_obj.type
-    elif isinstance(callable_obj, astroid.Lambda):
-        return callable_obj, 0, 'lambda'
-    elif isinstance(callable_obj, astroid.Class):
-        # Class instantiation, lookup __new__ instead.
-        # If we only find object.__new__, we can safely check __init__
-        # instead.
-        try:
-            # Use the last definition of __new__.
-            new = callable_obj.local_attr('__new__')[-1]
-        except astroid.NotFoundError:
-            new = None
-
-        if not new or new.parent.scope().name == 'object':
-            try:
-                # Use the last definition of __init__.
-                callable_obj = callable_obj.local_attr('__init__')[-1]
-            except astroid.NotFoundError:
-                # do nothing, covered by no-init.
-                raise ValueError
-        else:
-            callable_obj = new
-
-        if not isinstance(callable_obj, astroid.Function):
-            raise ValueError
-        # both have an extra implicit 'cls'/'self' argument.
-        return callable_obj, 1, 'constructor'
-    else:
-        raise ValueError
-
-class TypeChecker(BaseChecker):
-    """try to find bugs in the code using type inference
-    """
-
-    __implements__ = (IAstroidChecker,)
-
-    # configuration section name
-    name = 'typecheck'
-    # messages
-    msgs = MSGS
-    priority = -1
-    # configuration options
-    options = (('ignore-mixin-members',
-                {'default' : True, 'type' : 'yn', 'metavar': '<y_or_n>',
-                 'help' : 'Tells whether missing members accessed in mixin \
-class should be ignored. A mixin class is detected if its name ends with \
-"mixin" (case insensitive).'}
-                ),
-                ('ignored-modules',
-                 {'default': (),
-                  'type': 'csv',
-                  'metavar': '<module names>',
-                  'help': 'List of module names for which member attributes \
-should not be checked (useful for modules/projects where namespaces are \
-manipulated during runtime and thus existing member attributes cannot be \
-deduced by static analysis'},
-                 ),
-               ('ignored-classes',
-                {'default' : ('SQLObject',),
-                 'type' : 'csv',
-                 'metavar' : '<members names>',
-                 'help' : 'List of classes names for which member attributes \
-should not be checked (useful for classes with attributes dynamically set).'}
-                 ),
-
-               ('zope',
-                {'default' : False, 'type' : 'yn', 'metavar': '<y_or_n>',
-                 'help' : 'When zope mode is activated, add a predefined set \
-of Zope acquired attributes to generated-members.'}
-                ),
-               ('generated-members',
-                {'default' : (
-        'REQUEST', 'acl_users', 'aq_parent'),
-                 'type' : 'string',
-                 'metavar' : '<members names>',
-                 'help' : 'List of members which are set dynamically and \
-missed by pylint inference system, and so shouldn\'t trigger E0201 when \
-accessed. Python regular expressions are accepted.'}
-                ),
-        )
-
-    def open(self):
-        # do this in open since config not fully initialized in __init__
-        self.generated_members = list(self.config.generated_members)
-        if self.config.zope:
-            self.generated_members.extend(('REQUEST', 'acl_users', 'aq_parent'))
-
-    def visit_assattr(self, node):
-        if isinstance(node.ass_type(), astroid.AugAssign):
-            self.visit_getattr(node)
-
-    def visit_delattr(self, node):
-        self.visit_getattr(node)
-
-    @check_messages('no-member', 'maybe-no-member')
-    def visit_getattr(self, node):
-        """check that the accessed attribute exists
-
-        to avoid to much false positives for now, we'll consider the code as
-        correct if a single of the inferred nodes has the accessed attribute.
-
-        function/method, super call and metaclasses are ignored
-        """
-        # generated_members may containt regular expressions
-        # (surrounded by quote `"` and followed by a comma `,`)
-        # REQUEST,aq_parent,"[a-zA-Z]+_set{1,2}"' =>
-        # ('REQUEST', 'aq_parent', '[a-zA-Z]+_set{1,2}')
-        if isinstance(self.config.generated_members, str):
-            gen = shlex.shlex(self.config.generated_members)
-            gen.whitespace += ','
-            gen.wordchars += '[]-+'
-            self.config.generated_members = tuple(tok.strip('"') for tok in gen)
-        for pattern in self.config.generated_members:
-            # attribute is marked as generated, stop here
-            if re.match(pattern, node.attrname):
-                return
-        try:
-            infered = list(node.expr.infer())
-        except InferenceError:
-            return
-        # list of (node, nodename) which are missing the attribute
-        missingattr = set()
-        ignoremim = self.config.ignore_mixin_members
-        inference_failure = False
-        for owner in infered:
-            # skip yes object
-            if owner is YES:
-                inference_failure = True
-                continue
-            # skip None anyway
-            if isinstance(owner, astroid.Const) and owner.value is None:
-                continue
-            # XXX "super" / metaclass call
-            if is_super(owner) or getattr(owner, 'type', None) == 'metaclass':
-                continue
-            name = getattr(owner, 'name', 'None')
-            if name in self.config.ignored_classes:
-                continue
-            if ignoremim and name[-5:].lower() == 'mixin':
-                continue
-            try:
-                if not [n for n in owner.getattr(node.attrname)
-                        if not isinstance(n.statement(), astroid.AugAssign)]:
-                    missingattr.add((owner, name))
-                    continue
-            except AttributeError:
-                # XXX method / function
-                continue
-            except NotFoundError:
-                if isinstance(owner, astroid.Function) and owner.decorators:
-                    continue
-                if isinstance(owner, Instance) and owner.has_dynamic_getattr():
-                    continue
-                # explicit skipping of module member access
-                if owner.root().name in self.config.ignored_modules:
-                    continue
-                missingattr.add((owner, name))
-                continue
-            # stop on the first found
-            break
-        else:
-            # we have not found any node with the attributes, display the
-            # message for infered nodes
-            done = set()
-            for owner, name in missingattr:
-                if isinstance(owner, Instance):
-                    actual = owner._proxied
-                else:
-                    actual = owner
-                if actual in done:
-                    continue
-                done.add(actual)
-                if inference_failure:
-                    msgid = 'maybe-no-member'
-                else:
-                    msgid = 'no-member'
-                self.add_message(msgid, node=node,
-                                 args=(owner.display_type(), name,
-                                       node.attrname))
-
-    @check_messages('assignment-from-no-return', 'assignment-from-none')
-    def visit_assign(self, node):
-        """check that if assigning to a function call, the function is
-        possibly returning something valuable
-        """
-        if not isinstance(node.value, astroid.CallFunc):
-            return
-        function_node = safe_infer(node.value.func)
-        # skip class, generator and incomplete function definition
-        if not (isinstance(function_node, astroid.Function) and
-                function_node.root().fully_defined()):
-            return
-        if function_node.is_generator() \
-               or function_node.is_abstract(pass_is_abstract=False):
-            return
-        returns = list(function_node.nodes_of_class(astroid.Return,
-                                                    skip_klass=astroid.Function))
-        if len(returns) == 0:
-            self.add_message('assignment-from-no-return', node=node)
-        else:
-            for rnode in returns:
-                if not (isinstance(rnode.value, astroid.Const)
-                        and rnode.value.value is None
-                        or rnode.value is None):
-                    break
-            else:
-                self.add_message('assignment-from-none', node=node)
-
-    @check_messages(*(MSGS.keys()))
-    def visit_callfunc(self, node):
-        """check that called functions/methods are inferred to callable objects,
-        and that the arguments passed to the function match the parameters in
-        the inferred function's definition
-        """
-        # Build the set of keyword arguments, checking for duplicate keywords,
-        # and count the positional arguments.
-        keyword_args = set()
-        num_positional_args = 0
-        for arg in node.args:
-            if isinstance(arg, astroid.Keyword):
-                keyword = arg.arg
-                if keyword in keyword_args:
-                    self.add_message('duplicate-keyword-arg', node=node, args=keyword)
-                keyword_args.add(keyword)
-            else:
-                num_positional_args += 1
-
-        called = safe_infer(node.func)
-        # only function, generator and object defining __call__ are allowed
-        if called is not None and not called.callable():
-            self.add_message('not-callable', node=node, args=node.func.as_string())
-
-        try:
-            called, implicit_args, callable_name = _determine_callable(called)
-        except ValueError:
-            # Any error occurred during determining the function type, most of 
-            # those errors are handled by different warnings.
-            return
-        num_positional_args += implicit_args
-        if called.args.args is None:
-            # Built-in functions have no argument information.
-            return
-
-        if len(called.argnames()) != len(set(called.argnames())):
-            # Duplicate parameter name (see E9801).  We can't really make sense
-            # of the function call in this case, so just return.
-            return
-
-        # Analyze the list of formal parameters.
-        num_mandatory_parameters = len(called.args.args) - len(called.args.defaults)
-        parameters = []
-        parameter_name_to_index = {}
-        for i, arg in enumerate(called.args.args):
-            if isinstance(arg, astroid.Tuple):
-                name = None
-                # Don't store any parameter names within the tuple, since those
-                # are not assignable from keyword arguments.
-            else:
-                if isinstance(arg, astroid.Keyword):
-                    name = arg.arg
-                else:
-                    assert isinstance(arg, astroid.AssName)
-                    # This occurs with:
-                    #    def f( (a), (b) ): pass
-                    name = arg.name
-                parameter_name_to_index[name] = i
-            if i >= num_mandatory_parameters:
-                defval = called.args.defaults[i - num_mandatory_parameters]
-            else:
-                defval = None
-            parameters.append([(name, defval), False])
-
-        kwparams = {}
-        for i, arg in enumerate(called.args.kwonlyargs):
-            if isinstance(arg, astroid.Keyword):
-                name = arg.arg
-            else:
-                assert isinstance(arg, astroid.AssName)
-                name = arg.name
-            kwparams[name] = [called.args.kw_defaults[i], False]
-
-        # Match the supplied arguments against the function parameters.
-
-        # 1. Match the positional arguments.
-        for i in range(num_positional_args):
-            if i < len(parameters):
-                parameters[i][1] = True
-            elif called.args.vararg is not None:
-                # The remaining positional arguments get assigned to the *args
-                # parameter.
-                break
-            else:
-                # Too many positional arguments.
-                self.add_message('too-many-function-args', node=node, args=(callable_name,))
-                break
-
-        # 2. Match the keyword arguments.
-        for keyword in keyword_args:
-            if keyword in parameter_name_to_index:
-                i = parameter_name_to_index[keyword]
-                if parameters[i][1]:
-                    # Duplicate definition of function parameter.
-                    self.add_message('redundant-keyword-arg', node=node, args=(keyword, callable_name))
-                else:
-                    parameters[i][1] = True
-            elif keyword in kwparams:
-                if kwparams[keyword][1]:  # XXX is that even possible?
-                    # Duplicate definition of function parameter.
-                    self.add_message('redundant-keyword-arg', node=node, args=(keyword, callable_name))
-                else:
-                    kwparams[keyword][1] = True
-            elif called.args.kwarg is not None:
-                # The keyword argument gets assigned to the **kwargs parameter.
-                pass
-            else:
-                # Unexpected keyword argument.
-                self.add_message('unexpected-keyword-arg', node=node, args=(keyword, callable_name))
-
-        # 3. Match the *args, if any.  Note that Python actually processes
-        #    *args _before_ any keyword arguments, but we wait until after
-        #    looking at the keyword arguments so as to make a more conservative
-        #    guess at how many values are in the *args sequence.
-        if node.starargs is not None:
-            for i in range(num_positional_args, len(parameters)):
-                [(name, defval), assigned] = parameters[i]
-                # Assume that *args provides just enough values for all
-                # non-default parameters after the last parameter assigned by
-                # the positional arguments but before the first parameter
-                # assigned by the keyword arguments.  This is the best we can
-                # get without generating any false positives.
-                if (defval is not None) or assigned:
-                    break
-                parameters[i][1] = True
-
-        # 4. Match the **kwargs, if any.
-        if node.kwargs is not None:
-            for i, [(name, defval), assigned] in enumerate(parameters):
-                # Assume that *kwargs provides values for all remaining
-                # unassigned named parameters.
-                if name is not None:
-                    parameters[i][1] = True
-                else:
-                    # **kwargs can't assign to tuples.
-                    pass
-
-        # Check that any parameters without a default have been assigned
-        # values.
-        for [(name, defval), assigned] in parameters:
-            if (defval is None) and not assigned:
-                if name is None:
-                    display_name = '<tuple>'
-                else:
-                    display_name = repr(name)
-                self.add_message('no-value-for-parameter', node=node, args=(display_name, callable_name))
-
-        for name in kwparams:
-            defval, assigned = kwparams[name]
-            if defval is None and not assigned:
-                self.add_message('missing-kwoa', node=node, args=(name, callable_name))
-
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(TypeChecker(linter))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/utils.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/utils.py
deleted file mode 100644
index e7d85d41..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/utils.py
+++ /dev/null
@@ -1,416 +0,0 @@
-# pylint: disable=W0611
-#
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""some functions that may be useful for various checkers
-"""
-
-import re
-import string
-
-import astroid
-from astroid import scoped_nodes
-from logilab.common.compat import builtins
-
-BUILTINS_NAME = builtins.__name__
-
-COMP_NODE_TYPES = astroid.ListComp, astroid.SetComp, astroid.DictComp, astroid.GenExpr
-
-
-class NoSuchArgumentError(Exception):
-    pass
-
-def is_inside_except(node):
-    """Returns true if node is inside the name of an except handler."""
-    current = node
-    while current and not isinstance(current.parent, astroid.ExceptHandler):
-        current = current.parent
-
-    return current and current is current.parent.name
-
-
-def get_all_elements(node):
-    """Recursively returns all atoms in nested lists and tuples."""
-    if isinstance(node, (astroid.Tuple, astroid.List)):
-        for child in node.elts:
-            for e in get_all_elements(child):
-                yield e
-    else:
-        yield node
-
-
-def clobber_in_except(node):
-    """Checks if an assignment node in an except handler clobbers an existing
-    variable.
-
-    Returns (True, args for W0623) if assignment clobbers an existing variable,
-    (False, None) otherwise.
-    """
-    if isinstance(node, astroid.AssAttr):
-        return (True, (node.attrname, 'object %r' % (node.expr.as_string(),)))
-    elif isinstance(node, astroid.AssName):
-        name = node.name
-        if is_builtin(name):
-            return (True, (name, 'builtins'))
-        else:
-            scope, stmts = node.lookup(name)
-            if (stmts and
-                not isinstance(stmts[0].ass_type(),
-                               (astroid.Assign, astroid.AugAssign,
-                                astroid.ExceptHandler))):
-                return (True, (name, 'outer scope (line %s)' % stmts[0].fromlineno))
-    return (False, None)
-
-
-def safe_infer(node):
-    """return the inferred value for the given node.
-    Return None if inference failed or if there is some ambiguity (more than
-    one node has been inferred)
-    """
-    try:
-        inferit = node.infer()
-        value = inferit.next()
-    except astroid.InferenceError:
-        return
-    try:
-        inferit.next()
-        return # None if there is ambiguity on the inferred node
-    except astroid.InferenceError:
-        return # there is some kind of ambiguity
-    except StopIteration:
-        return value
-
-def is_super(node):
-    """return True if the node is referencing the "super" builtin function
-    """
-    if getattr(node, 'name', None) == 'super' and \
-           node.root().name == BUILTINS_NAME:
-        return True
-    return False
-
-def is_error(node):
-    """return true if the function does nothing but raising an exception"""
-    for child_node in node.get_children():
-        if isinstance(child_node, astroid.Raise):
-            return True
-        return False
-
-def is_raising(body):
-    """return true if the given statement node raise an exception"""
-    for node in body:
-        if isinstance(node, astroid.Raise):
-            return True
-    return False
-
-def is_empty(body):
-    """return true if the given node does nothing but 'pass'"""
-    return len(body) == 1 and isinstance(body[0], astroid.Pass)
-
-builtins = builtins.__dict__.copy()
-SPECIAL_BUILTINS = ('__builtins__',) # '__path__', '__file__')
-
-def is_builtin_object(node):
-    """Returns True if the given node is an object from the __builtin__ module."""
-    return node and node.root().name == BUILTINS_NAME
-
-def is_builtin(name): # was is_native_builtin
-    """return true if <name> could be considered as a builtin defined by python
-    """
-    if name in builtins:
-        return True
-    if name in SPECIAL_BUILTINS:
-        return True
-    return False
-
-def is_defined_before(var_node):
-    """return True if the variable node is defined by a parent node (list,
-    set, dict, or generator comprehension, lambda) or in a previous sibling
-    node on the same line (statement_defining ; statement_using)
-    """
-    varname = var_node.name
-    _node = var_node.parent
-    while _node:
-        if isinstance(_node, COMP_NODE_TYPES):
-            for ass_node in _node.nodes_of_class(astroid.AssName):
-                if ass_node.name == varname:
-                    return True
-        elif isinstance(_node, astroid.For):
-            for ass_node in _node.target.nodes_of_class(astroid.AssName):
-                if ass_node.name == varname:
-                    return True
-        elif isinstance(_node, astroid.With):
-            for expr, vars in _node.items:
-                if expr.parent_of(var_node):
-                    break                
-                if (vars and
-                    isinstance(vars, astroid.AssName) and
-                    vars.name == varname):
-                    return True
-        elif isinstance(_node, (astroid.Lambda, astroid.Function)):
-            if _node.args.is_argument(varname):
-                return True
-            if getattr(_node, 'name', None) == varname:
-                return True
-            break
-        elif isinstance(_node, astroid.ExceptHandler):
-            if isinstance(_node.name, astroid.AssName):
-                ass_node = _node.name
-                if ass_node.name == varname:
-                    return True
-        _node = _node.parent
-    # possibly multiple statements on the same line using semi colon separator
-    stmt = var_node.statement()
-    _node = stmt.previous_sibling()
-    lineno = stmt.fromlineno
-    while _node and _node.fromlineno == lineno:
-        for ass_node in _node.nodes_of_class(astroid.AssName):
-            if ass_node.name == varname:
-                return True
-        for imp_node in _node.nodes_of_class((astroid.From, astroid.Import)):
-            if varname in [name[1] or name[0] for name in imp_node.names]:
-                return True
-        _node = _node.previous_sibling()
-    return False
-
-def is_func_default(node):
-    """return true if the given Name node is used in function default argument's
-    value
-    """
-    parent = node.scope()
-    if isinstance(parent, astroid.Function):
-        for default_node in parent.args.defaults:
-            for default_name_node in default_node.nodes_of_class(astroid.Name):
-                if default_name_node is node:
-                    return True
-    return False
-
-def is_func_decorator(node):
-    """return true if the name is used in function decorator"""
-    parent = node.parent
-    while parent is not None:
-        if isinstance(parent, astroid.Decorators):
-            return True
-        if (parent.is_statement or
-            isinstance(parent, astroid.Lambda) or
-            isinstance(parent, (scoped_nodes.ComprehensionScope,
-                                scoped_nodes.ListComp))):
-            break
-        parent = parent.parent
-    return False
-
-def is_ancestor_name(frame, node):
-    """return True if `frame` is a astroid.Class node with `node` in the
-    subtree of its bases attribute
-    """
-    try:
-        bases = frame.bases
-    except AttributeError:
-        return False
-    for base in bases:
-        if node in base.nodes_of_class(astroid.Name):
-            return True
-    return False
-
-def assign_parent(node):
-    """return the higher parent which is not an AssName, Tuple or List node
-    """
-    while node and isinstance(node, (astroid.AssName,
-                                     astroid.Tuple,
-                                     astroid.List)):
-        node = node.parent
-    return node
-
-def overrides_an_abstract_method(class_node, name):
-    """return True if pnode is a parent of node"""
-    for ancestor in class_node.ancestors():
-        if name in ancestor and isinstance(ancestor[name], astroid.Function) and \
-               ancestor[name].is_abstract(pass_is_abstract=False):
-            return True
-    return False
-
-def overrides_a_method(class_node, name):
-    """return True if <name> is a method overridden from an ancestor"""
-    for ancestor in class_node.ancestors():
-        if name in ancestor and isinstance(ancestor[name], astroid.Function):
-            return True
-    return False
-
-PYMETHODS = set(('__new__', '__init__', '__del__', '__hash__',
-                 '__str__', '__repr__',
-                 '__len__', '__iter__',
-                 '__delete__', '__get__', '__set__',
-                 '__getitem__', '__setitem__', '__delitem__', '__contains__',
-                 '__getattribute__', '__getattr__', '__setattr__', '__delattr__',
-                 '__call__',
-                 '__enter__', '__exit__',
-                 '__cmp__', '__ge__', '__gt__', '__le__', '__lt__', '__eq__',
-                 '__nonzero__', '__neg__', '__invert__',
-                 '__mul__', '__imul__', '__rmul__',
-                 '__div__', '__idiv__', '__rdiv__',
-                 '__add__', '__iadd__', '__radd__',
-                 '__sub__', '__isub__', '__rsub__',
-                 '__pow__', '__ipow__', '__rpow__',
-                 '__mod__', '__imod__', '__rmod__',
-                 '__and__', '__iand__', '__rand__',
-                 '__or__', '__ior__', '__ror__',
-                 '__xor__', '__ixor__', '__rxor__',
-                 # XXX To be continued
-                 ))
-
-def check_messages(*messages):
-    """decorator to store messages that are handled by a checker method"""
-
-    def store_messages(func):
-        func.checks_msgs = messages
-        return func
-    return store_messages
-
-class IncompleteFormatString(Exception):
-    """A format string ended in the middle of a format specifier."""
-    pass
-
-class UnsupportedFormatCharacter(Exception):
-    """A format character in a format string is not one of the supported
-    format characters."""
-    def __init__(self, index):
-        Exception.__init__(self, index)
-        self.index = index
-
-def parse_format_string(format_string):
-    """Parses a format string, returning a tuple of (keys, num_args), where keys
-    is the set of mapping keys in the format string, and num_args is the number
-    of arguments required by the format string.  Raises
-    IncompleteFormatString or UnsupportedFormatCharacter if a
-    parse error occurs."""
-    keys = set()
-    num_args = 0
-    def next_char(i):
-        i += 1
-        if i == len(format_string):
-            raise IncompleteFormatString
-        return (i, format_string[i])
-    i = 0
-    while i < len(format_string):
-        char = format_string[i]
-        if char == '%':
-            i, char = next_char(i)
-            # Parse the mapping key (optional).
-            key = None
-            if char == '(':
-                depth = 1
-                i, char = next_char(i)
-                key_start = i
-                while depth != 0:
-                    if char == '(':
-                        depth += 1
-                    elif char == ')':
-                        depth -= 1
-                    i, char = next_char(i)
-                key_end = i - 1
-                key = format_string[key_start:key_end]
-
-            # Parse the conversion flags (optional).
-            while char in '#0- +':
-                i, char = next_char(i)
-            # Parse the minimum field width (optional).
-            if char == '*':
-                num_args += 1
-                i, char = next_char(i)
-            else:
-                while char in string.digits:
-                    i, char = next_char(i)
-            # Parse the precision (optional).
-            if char == '.':
-                i, char = next_char(i)
-                if char == '*':
-                    num_args += 1
-                    i, char = next_char(i)
-                else:
-                    while char in string.digits:
-                        i, char = next_char(i)
-            # Parse the length modifier (optional).
-            if char in 'hlL':
-                i, char = next_char(i)
-            # Parse the conversion type (mandatory).
-            if char not in 'diouxXeEfFgGcrs%':
-                raise UnsupportedFormatCharacter(i)
-            if key:
-                keys.add(key)
-            elif char != '%':
-                num_args += 1
-        i += 1
-    return keys, num_args
-
-def is_attr_protected(attrname):
-    """return True if attribute name is protected (start with _ and some other
-    details), False otherwise.
-    """
-    return attrname[0] == '_' and not attrname == '_' and not (
-             attrname.startswith('__') and attrname.endswith('__'))
-
-def node_frame_class(node):
-    """return klass node for a method node (or a staticmethod or a
-    classmethod), return null otherwise
-    """
-    klass = node.frame()
-
-    while klass is not None and not isinstance(klass, astroid.Class):
-        if klass.parent is None:
-            klass = None
-        else:
-            klass = klass.parent.frame()
-
-    return klass
-
-def is_super_call(expr):
-    """return True if expression node is a function call and if function name
-    is super. Check before that you're in a method.
-    """
-    return (isinstance(expr, astroid.CallFunc) and
-        isinstance(expr.func, astroid.Name) and
-        expr.func.name == 'super')
-
-def is_attr_private(attrname):
-    """Check that attribute name is private (at least two leading underscores,
-    at most one trailing underscore)
-    """
-    regex = re.compile('^_{2,}.*[^_]+_?$')
-    return regex.match(attrname)
-
-def get_argument_from_call(callfunc_node, position=None, keyword=None):
-    """Returns the specified argument from a function call.
-
-    :param callfunc_node: Node representing a function call to check.
-    :param int position: position of the argument.
-    :param str keyword: the keyword of the argument.
-
-    :returns: The node representing the argument, None if the argument is not found.
-    :raises ValueError: if both position and keyword are None.
-    :raises NoSuchArgumentError: if no argument at the provided position or with
-    the provided keyword.
-    """
-    if position is None and keyword is None:
-        raise ValueError('Must specify at least one of: position or keyword.')
-    try:
-        if position is not None and not isinstance(callfunc_node.args[position], astroid.Keyword):
-            return callfunc_node.args[position]
-    except IndexError, error:
-        raise NoSuchArgumentError(error)
-    if keyword:
-        for arg in callfunc_node.args:
-            if isinstance(arg, astroid.Keyword) and arg.arg == keyword:
-                return arg.value
-    raise NoSuchArgumentError
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/variables.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/variables.py
deleted file mode 100644
index dc8d1115..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/checkers/variables.py
+++ /dev/null
@@ -1,741 +0,0 @@
-# Copyright (c) 2003-2014 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""variables checkers for Python code
-"""
-import os
-import sys
-from copy import copy
-
-import astroid
-from astroid import are_exclusive, builtin_lookup, AstroidBuildingException
-
-from logilab.common.modutils import file_from_modpath
-
-from pylint.interfaces import IAstroidChecker
-from pylint.checkers import BaseChecker
-from pylint.checkers.utils import (PYMETHODS, is_ancestor_name, is_builtin,
-     is_defined_before, is_error, is_func_default, is_func_decorator,
-     assign_parent, check_messages, is_inside_except, clobber_in_except,
-     get_all_elements)
-
-
-def in_for_else_branch(parent, stmt):
-    """Returns True if stmt in inside the else branch for a parent For stmt."""
-    return (isinstance(parent, astroid.For) and
-            any(else_stmt.parent_of(stmt) for else_stmt in parent.orelse))
-
-def overridden_method(klass, name):
-    """get overridden method if any"""
-    try:
-        parent = klass.local_attr_ancestors(name).next()
-    except (StopIteration, KeyError):
-        return None
-    try:
-        meth_node = parent[name]
-    except KeyError:
-        # We have found an ancestor defining <name> but it's not in the local
-        # dictionary. This may happen with astroid built from living objects.
-        return None
-    if isinstance(meth_node, astroid.Function):
-        return meth_node
-    return None
-
-def _get_unpacking_extra_info(node, infered):
-    """return extra information to add to the message for unpacking-non-sequence
-    and unbalanced-tuple-unpacking errors
-    """
-    more = ''
-    infered_module = infered.root().name
-    if node.root().name == infered_module:
-        if node.lineno == infered.lineno:
-            more = ' %s' % infered.as_string()
-        elif infered.lineno:
-            more = ' defined at line %s' % infered.lineno
-    elif infered.lineno:
-        more = ' defined at line %s of %s' % (infered.lineno, infered_module)
-    return more
-
-MSGS = {
-    'E0601': ('Using variable %r before assignment',
-              'used-before-assignment',
-              'Used when a local variable is accessed before it\'s \
-              assignment.'),
-    'E0602': ('Undefined variable %r',
-              'undefined-variable',
-              'Used when an undefined variable is accessed.'),
-    'E0603': ('Undefined variable name %r in __all__',
-              'undefined-all-variable',
-              'Used when an undefined variable name is referenced in __all__.'),
-    'E0604': ('Invalid object %r in __all__, must contain only strings',
-              'invalid-all-object',
-              'Used when an invalid (non-string) object occurs in __all__.'),
-    'E0611': ('No name %r in module %r',
-              'no-name-in-module',
-              'Used when a name cannot be found in a module.'),
-
-    'W0601': ('Global variable %r undefined at the module level',
-              'global-variable-undefined',
-              'Used when a variable is defined through the "global" statement \
-              but the variable is not defined in the module scope.'),
-    'W0602': ('Using global for %r but no assignment is done',
-              'global-variable-not-assigned',
-              'Used when a variable is defined through the "global" statement \
-              but no assignment to this variable is done.'),
-    'W0603': ('Using the global statement', # W0121
-              'global-statement',
-              'Used when you use the "global" statement to update a global \
-              variable. PyLint just try to discourage this \
-              usage. That doesn\'t mean you can not use it !'),
-    'W0604': ('Using the global statement at the module level', # W0103
-              'global-at-module-level',
-              'Used when you use the "global" statement at the module level \
-              since it has no effect'),
-    'W0611': ('Unused import %s',
-              'unused-import',
-              'Used when an imported module or variable is not used.'),
-    'W0612': ('Unused variable %r',
-              'unused-variable',
-              'Used when a variable is defined but not used.'),
-    'W0613': ('Unused argument %r',
-              'unused-argument',
-              'Used when a function or method argument is not used.'),
-    'W0614': ('Unused import %s from wildcard import',
-              'unused-wildcard-import',
-              'Used when an imported module or variable is not used from a \
-              \'from X import *\' style import.'),
-
-    'W0621': ('Redefining name %r from outer scope (line %s)',
-              'redefined-outer-name',
-              'Used when a variable\'s name hide a name defined in the outer \
-              scope.'),
-    'W0622': ('Redefining built-in %r',
-              'redefined-builtin',
-              'Used when a variable or function override a built-in.'),
-    'W0623': ('Redefining name %r from %s in exception handler',
-              'redefine-in-handler',
-              'Used when an exception handler assigns the exception \
-               to an existing name'),
-
-    'W0631': ('Using possibly undefined loop variable %r',
-              'undefined-loop-variable',
-              'Used when an loop variable (i.e. defined by a for loop or \
-              a list comprehension or a generator expression) is used outside \
-              the loop.'),
-
-    'W0632': ('Possible unbalanced tuple unpacking with '
-              'sequence%s: '
-              'left side has %d label(s), right side has %d value(s)',
-              'unbalanced-tuple-unpacking',
-              'Used when there is an unbalanced tuple unpacking in assignment'),
-
-    'W0633': ('Attempting to unpack a non-sequence%s',
-              'unpacking-non-sequence',
-              'Used when something which is not '
-              'a sequence is used in an unpack assignment'),
-
-    'W0640': ('Cell variable %s defined in loop',
-              'cell-var-from-loop', 
-              'A variable used in a closure is defined in a loop. '
-              'This will result in all closures using the same value for '
-              'the closed-over variable.'),
-
-    }
-
-class VariablesChecker(BaseChecker):
-    """checks for
-    * unused variables / imports
-    * undefined variables
-    * redefinition of variable from builtins or from an outer scope
-    * use of variable before assignment
-    * __all__ consistency
-    """
-
-    __implements__ = IAstroidChecker
-
-    name = 'variables'
-    msgs = MSGS
-    priority = -1
-    options = (
-               ("init-import",
-                {'default': 0, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                 'help' : 'Tells whether we should check for unused import in \
-__init__ files.'}),
-               ("dummy-variables-rgx",
-                {'default': ('_$|dummy'),
-                 'type' :'regexp', 'metavar' : '<regexp>',
-                 'help' : 'A regular expression matching the name of dummy \
-variables (i.e. expectedly not used).'}),
-               ("additional-builtins",
-                {'default': (), 'type' : 'csv',
-                 'metavar' : '<comma separated list>',
-                 'help' : 'List of additional names supposed to be defined in \
-builtins. Remember that you should avoid to define new builtins when possible.'
-                 }),
-               )
-    def __init__(self, linter=None):
-        BaseChecker.__init__(self, linter)
-        self._to_consume = None
-        self._checking_mod_attr = None
-
-    def visit_module(self, node):
-        """visit module : update consumption analysis variable
-        checks globals doesn't overrides builtins
-        """
-        self._to_consume = [(copy(node.locals), {}, 'module')]
-        for name, stmts in node.locals.iteritems():
-            if is_builtin(name) and not is_inside_except(stmts[0]):
-                # do not print Redefining builtin for additional builtins
-                self.add_message('redefined-builtin', args=name, node=stmts[0])
-
-    @check_messages('unused-import', 'unused-wildcard-import', 'redefined-builtin', 'undefined-all-variable', 'invalid-all-object')
-    def leave_module(self, node):
-        """leave module: check globals
-        """
-        assert len(self._to_consume) == 1
-        not_consumed = self._to_consume.pop()[0]
-        # attempt to check for __all__ if defined
-        if '__all__' in node.locals:
-            assigned = node.igetattr('__all__').next()
-            if assigned is not astroid.YES:
-                for elt in getattr(assigned, 'elts', ()):
-                    try:
-                        elt_name = elt.infer().next()
-                    except astroid.InferenceError:
-                        continue
-
-                    if not isinstance(elt_name, astroid.Const) \
-                             or not isinstance(elt_name.value, basestring):
-                        self.add_message('invalid-all-object', args=elt.as_string(), node=elt)
-                        continue
-                    elt_name = elt_name.value
-                    # If elt is in not_consumed, remove it from not_consumed
-                    if elt_name in not_consumed:
-                        del not_consumed[elt_name]
-                        continue
-                    if elt_name not in node.locals:
-                        if not node.package:
-                            self.add_message('undefined-all-variable',
-                                             args=elt_name,
-                                             node=elt)
-                        else:
-                            basename = os.path.splitext(node.file)[0]
-                            if os.path.basename(basename) == '__init__':
-                                name = node.name + "." + elt_name
-                                try:
-                                    file_from_modpath(name.split("."))
-                                except ImportError:
-                                    self.add_message('undefined-all-variable',
-                                                     args=elt_name,
-                                                     node=elt)
-                                except SyntaxError, exc:
-                                    # don't yield an syntax-error warning,
-                                    # because it will be later yielded
-                                    # when the file will be checked
-                                    pass
-        # don't check unused imports in __init__ files
-        if not self.config.init_import and node.package:
-            return
-        for name, stmts in not_consumed.iteritems():
-            if any(isinstance(stmt, astroid.AssName)
-                   and isinstance(stmt.ass_type(), astroid.AugAssign)
-                   for stmt in stmts):
-                continue
-            stmt = stmts[0]
-            if isinstance(stmt, astroid.Import):
-                self.add_message('unused-import', args=name, node=stmt)
-            elif isinstance(stmt, astroid.From) and stmt.modname != '__future__':
-                if stmt.names[0][0] == '*':
-                    self.add_message('unused-wildcard-import', args=name, node=stmt)
-                else:
-                    self.add_message('unused-import', args=name, node=stmt)
-        del self._to_consume
-
-    def visit_class(self, node):
-        """visit class: update consumption analysis variable
-        """
-        self._to_consume.append((copy(node.locals), {}, 'class'))
-
-    def leave_class(self, _):
-        """leave class: update consumption analysis variable
-        """
-        # do not check for not used locals here (no sense)
-        self._to_consume.pop()
-
-    def visit_lambda(self, node):
-        """visit lambda: update consumption analysis variable
-        """
-        self._to_consume.append((copy(node.locals), {}, 'lambda'))
-
-    def leave_lambda(self, _):
-        """leave lambda: update consumption analysis variable
-        """
-        # do not check for not used locals here
-        self._to_consume.pop()
-
-    def visit_genexpr(self, node):
-        """visit genexpr: update consumption analysis variable
-        """
-        self._to_consume.append((copy(node.locals), {}, 'comprehension'))
-
-    def leave_genexpr(self, _):
-        """leave genexpr: update consumption analysis variable
-        """
-        # do not check for not used locals here
-        self._to_consume.pop()
-
-    def visit_dictcomp(self, node):
-        """visit dictcomp: update consumption analysis variable
-        """
-        self._to_consume.append((copy(node.locals), {}, 'comprehension'))
-
-    def leave_dictcomp(self, _):
-        """leave dictcomp: update consumption analysis variable
-        """
-        # do not check for not used locals here
-        self._to_consume.pop()
-
-    def visit_setcomp(self, node):
-        """visit setcomp: update consumption analysis variable
-        """
-        self._to_consume.append((copy(node.locals), {}, 'comprehension'))
-
-    def leave_setcomp(self, _):
-        """leave setcomp: update consumption analysis variable
-        """
-        # do not check for not used locals here
-        self._to_consume.pop()
-
-    def visit_function(self, node):
-        """visit function: update consumption analysis variable and check locals
-        """
-        self._to_consume.append((copy(node.locals), {}, 'function'))
-        if not (self.linter.is_message_enabled('redefined-outer-name') or
-                self.linter.is_message_enabled('redefined-builtin')):
-            return
-        globs = node.root().globals
-        for name, stmt in node.items():
-            if is_inside_except(stmt):
-                continue
-            if name in globs and not isinstance(stmt, astroid.Global):
-                line = globs[name][0].fromlineno
-                dummy_rgx = self.config.dummy_variables_rgx
-                if not dummy_rgx.match(name):
-                    self.add_message('redefined-outer-name', args=(name, line), node=stmt)
-            elif is_builtin(name):
-                # do not print Redefining builtin for additional builtins
-                self.add_message('redefined-builtin', args=name, node=stmt)
-
-    def leave_function(self, node):
-        """leave function: check function's locals are consumed"""
-        not_consumed = self._to_consume.pop()[0]
-        if not (self.linter.is_message_enabled('unused-variable') or
-                self.linter.is_message_enabled('unused-argument')):
-            return
-        # don't check arguments of function which are only raising an exception
-        if is_error(node):
-            return
-        # don't check arguments of abstract methods or within an interface
-        is_method = node.is_method()
-        klass = node.parent.frame()
-        if is_method and (klass.type == 'interface' or node.is_abstract()):
-            return
-        authorized_rgx = self.config.dummy_variables_rgx
-        called_overridden = False
-        argnames = node.argnames()
-        for name, stmts in not_consumed.iteritems():
-            # ignore some special names specified by user configuration
-            if authorized_rgx.match(name):
-                continue
-            # ignore names imported by the global statement
-            # FIXME: should only ignore them if it's assigned latter
-            stmt = stmts[0]
-            if isinstance(stmt, astroid.Global):
-                continue
-            # care about functions with unknown argument (builtins)
-            if name in argnames:
-                if is_method:
-                    # don't warn for the first argument of a (non static) method
-                    if node.type != 'staticmethod' and name == argnames[0]:
-                        continue
-                    # don't warn for argument of an overridden method
-                    if not called_overridden:
-                        overridden = overridden_method(klass, node.name)
-                        called_overridden = True
-                    if overridden is not None and name in overridden.argnames():
-                        continue
-                    if node.name in PYMETHODS and node.name not in ('__init__', '__new__'):
-                        continue
-                # don't check callback arguments XXX should be configurable
-                if node.name.startswith('cb_') or node.name.endswith('_cb'):
-                    continue
-                self.add_message('unused-argument', args=name, node=stmt)
-            else:
-                self.add_message('unused-variable', args=name, node=stmt)
-
-    @check_messages('global-variable-undefined', 'global-variable-not-assigned', 'global-statement',
-                    'global-at-module-level', 'redefined-builtin')
-    def visit_global(self, node):
-        """check names imported exists in the global scope"""
-        frame = node.frame()
-        if isinstance(frame, astroid.Module):
-            self.add_message('global-at-module-level', node=node)
-            return
-        module = frame.root()
-        default_message = True
-        for name in node.names:
-            try:
-                assign_nodes = module.getattr(name)
-            except astroid.NotFoundError:
-                # unassigned global, skip
-                assign_nodes = []
-            for anode in assign_nodes:
-                if anode.parent is None:
-                    # node returned for builtin attribute such as __file__,
-                    # __doc__, etc...
-                    continue
-                if anode.frame() is frame:
-                    # same scope level assignment
-                    break
-            else:
-                # global but no assignment
-                self.add_message('global-variable-not-assigned', args=name, node=node)
-                default_message = False
-            if not assign_nodes:
-                continue
-            for anode in assign_nodes:
-                if anode.parent is None:
-                    self.add_message('redefined-builtin', args=name, node=node)
-                    break
-                if anode.frame() is module:
-                    # module level assignment
-                    break
-            else:
-                # global undefined at the module scope
-                self.add_message('global-variable-undefined', args=name, node=node)
-                default_message = False
-        if default_message:
-            self.add_message('global-statement', node=node)
-
-    def _check_late_binding_closure(self, node, assignment_node, scope_type):
-        node_scope = node.scope()
-        if not isinstance(node_scope, (astroid.Lambda, astroid.Function)):
-            return
-
-        if isinstance(assignment_node, astroid.Comprehension):
-            if assignment_node.parent.parent_of(node.scope()):
-                self.add_message('cell-var-from-loop', node=node, args=node.name)
-        else:
-            assign_scope = assignment_node.scope()
-            maybe_for = assignment_node
-            while not isinstance(maybe_for, astroid.For):
-                if maybe_for is assign_scope:
-                    break
-                maybe_for = maybe_for.parent
-            else:
-                if maybe_for.parent_of(node_scope) and not isinstance(node_scope.statement(), astroid.Return):
-                    self.add_message('cell-var-from-loop', node=node, args=node.name)
-        
-    def _loopvar_name(self, node, name):
-        # filter variables according to node's scope
-        # XXX used to filter parents but don't remember why, and removing this
-        # fixes a W0631 false positive reported by Paul Hachmann on 2008/12 on
-        # python-projects (added to func_use_for_or_listcomp_var test)
-        #astmts = [stmt for stmt in node.lookup(name)[1]
-        #          if hasattr(stmt, 'ass_type')] and
-        #          not stmt.statement().parent_of(node)]
-        if not self.linter.is_message_enabled('undefined-loop-variable'):
-            return
-        astmts = [stmt for stmt in node.lookup(name)[1]
-                  if hasattr(stmt, 'ass_type')]
-        # filter variables according their respective scope test is_statement
-        # and parent to avoid #74747. This is not a total fix, which would
-        # introduce a mechanism similar to special attribute lookup in
-        # modules. Also, in order to get correct inference in this case, the
-        # scope lookup rules would need to be changed to return the initial
-        # assignment (which does not exist in code per se) as well as any later
-        # modifications.
-        if not astmts or (astmts[0].is_statement or astmts[0].parent) \
-             and astmts[0].statement().parent_of(node):
-            _astmts = []
-        else:
-            _astmts = astmts[:1]
-        for i, stmt in enumerate(astmts[1:]):
-            if (astmts[i].statement().parent_of(stmt)
-                and not in_for_else_branch(astmts[i].statement(), stmt)):
-                continue
-            _astmts.append(stmt)
-        astmts = _astmts
-        if len(astmts) == 1:
-            ass = astmts[0].ass_type()
-            if isinstance(ass, (astroid.For, astroid.Comprehension, astroid.GenExpr)) \
-                   and not ass.statement() is node.statement():
-                self.add_message('undefined-loop-variable', args=name, node=node)
-
-    @check_messages('redefine-in-handler')
-    def visit_excepthandler(self, node):
-        for name in get_all_elements(node.name):
-            clobbering, args = clobber_in_except(name)
-            if clobbering:
-                self.add_message('redefine-in-handler', args=args, node=name)
-
-    def visit_assname(self, node):
-        if isinstance(node.ass_type(), astroid.AugAssign):
-            self.visit_name(node)
-
-    def visit_delname(self, node):
-        self.visit_name(node)
-
-    @check_messages(*(MSGS.keys()))
-    def visit_name(self, node):
-        """check that a name is defined if the current scope and doesn't
-        redefine a built-in
-        """
-        stmt = node.statement()
-        if stmt.fromlineno is None:
-            # name node from a astroid built from live code, skip
-            assert not stmt.root().file.endswith('.py')
-            return
-        name = node.name
-        frame = stmt.scope()
-        # if the name node is used as a function default argument's value or as
-        # a decorator, then start from the parent frame of the function instead
-        # of the function frame - and thus open an inner class scope
-        if (is_func_default(node) or is_func_decorator(node)
-            or is_ancestor_name(frame, node)):
-            start_index = len(self._to_consume) - 2
-        else:
-            start_index = len(self._to_consume) - 1
-        # iterates through parent scopes, from the inner to the outer
-        base_scope_type = self._to_consume[start_index][-1]
-        for i in range(start_index, -1, -1):
-            to_consume, consumed, scope_type = self._to_consume[i]
-            # if the current scope is a class scope but it's not the inner
-            # scope, ignore it. This prevents to access this scope instead of
-            # the globals one in function members when there are some common
-            # names. The only exception is when the starting scope is a
-            # comprehension and its direct outer scope is a class
-            if scope_type == 'class' and i != start_index and not (
-                base_scope_type == 'comprehension' and i == start_index-1):
-                # XXX find a way to handle class scope in a smoother way
-                continue
-            # the name has already been consumed, only check it's not a loop
-            # variable used outside the loop
-            if name in consumed:
-                defnode = assign_parent(consumed[name][0])
-                self._check_late_binding_closure(node, defnode, scope_type)
-                self._loopvar_name(node, name)
-                break
-            # mark the name as consumed if it's defined in this scope
-            # (i.e. no KeyError is raised by "to_consume[name]")
-            try:
-                consumed[name] = to_consume[name]
-            except KeyError:
-                continue
-            # checks for use before assignment
-            defnode = assign_parent(to_consume[name][0])
-            if defnode is not None:
-                self._check_late_binding_closure(node, defnode, scope_type)
-                defstmt = defnode.statement()
-                defframe = defstmt.frame()
-                maybee0601 = True
-                if not frame is defframe:
-                    maybee0601 = False
-                elif defframe.parent is None:
-                    # we are at the module level, check the name is not
-                    # defined in builtins
-                    if name in defframe.scope_attrs or builtin_lookup(name)[1]:
-                        maybee0601 = False
-                else:
-                    # we are in a local scope, check the name is not
-                    # defined in global or builtin scope
-                    if defframe.root().lookup(name)[1]:
-                        maybee0601 = False
-                    else:
-                        # check if we have a nonlocal
-                        if name in defframe.locals:
-                            maybee0601 = not any(isinstance(child, astroid.Nonlocal)
-                                                 and name in child.names
-                                                 for child in defframe.get_children())
-                if (maybee0601
-                    and stmt.fromlineno <= defstmt.fromlineno
-                    and not is_defined_before(node)
-                    and not are_exclusive(stmt, defstmt, ('NameError', 'Exception', 'BaseException'))):
-                    if defstmt is stmt and isinstance(node, (astroid.DelName,
-                                                             astroid.AssName)):
-                        self.add_message('undefined-variable', args=name, node=node)
-                    elif self._to_consume[-1][-1] != 'lambda':
-                        # E0601 may *not* occurs in lambda scope
-                        self.add_message('used-before-assignment', args=name, node=node)
-            if isinstance(node, astroid.AssName): # Aug AssName
-                del consumed[name]
-            else:
-                del to_consume[name]
-            # check it's not a loop variable used outside the loop
-            self._loopvar_name(node, name)
-            break
-        else:
-            # we have not found the name, if it isn't a builtin, that's an
-            # undefined name !
-            if not (name in astroid.Module.scope_attrs or is_builtin(name)
-                    or name in self.config.additional_builtins):
-                self.add_message('undefined-variable', args=name, node=node)
-
-    @check_messages('no-name-in-module')
-    def visit_import(self, node):
-        """check modules attribute accesses"""
-        for name, _ in node.names:
-            parts = name.split('.')
-            try:
-                module = node.infer_name_module(parts[0]).next()
-            except astroid.ResolveError:
-                continue
-            self._check_module_attrs(node, module, parts[1:])
-
-    @check_messages('no-name-in-module')
-    def visit_from(self, node):
-        """check modules attribute accesses"""
-        name_parts = node.modname.split('.')
-        level = getattr(node, 'level', None)
-        try:
-            module = node.root().import_module(name_parts[0], level=level)
-        except AstroidBuildingException:
-            return
-        except Exception, exc:
-            print 'Unhandled exception in VariablesChecker:', exc
-            return
-        module = self._check_module_attrs(node, module, name_parts[1:])
-        if not module:
-            return
-        for name, _ in node.names:
-            if name == '*':
-                continue
-            self._check_module_attrs(node, module, name.split('.'))
-
-    @check_messages('unbalanced-tuple-unpacking', 'unpacking-non-sequence')
-    def visit_assign(self, node):
-        """Check unbalanced tuple unpacking for assignments
-        and unpacking non-sequences.
-        """
-        if not isinstance(node.targets[0], (astroid.Tuple, astroid.List)):
-            return
-
-        targets = node.targets[0].itered()
-        try:
-            for infered in node.value.infer():
-                self._check_unpacking(infered, node, targets)
-        except astroid.InferenceError:
-            return
-
-    def _check_unpacking(self, infered, node, targets):
-        """ Check for unbalanced tuple unpacking
-        and unpacking non sequences.
-        """
-        if infered is astroid.YES:
-            return
-        if isinstance(infered, (astroid.Tuple, astroid.List)):
-            # attempt to check unpacking is properly balanced
-            values = infered.itered()
-            if len(targets) != len(values):
-                self.add_message('unbalanced-tuple-unpacking', node=node,
-                                 args=(_get_unpacking_extra_info(node, infered),
-                                       len(targets),
-                                       len(values)))
-        # attempt to check unpacking may be possible (ie RHS is iterable)
-        elif isinstance(infered, astroid.Instance):
-            for meth in ('__iter__', '__getitem__'):
-                try:
-                    infered.getattr(meth)
-                    break
-                except astroid.NotFoundError:
-                    continue
-            else:
-                self.add_message('unpacking-non-sequence', node=node,
-                                 args=(_get_unpacking_extra_info(node, infered),))
-        else:
-            self.add_message('unpacking-non-sequence', node=node,
-                             args=(_get_unpacking_extra_info(node, infered),))
-
-
-    def _check_module_attrs(self, node, module, module_names):
-        """check that module_names (list of string) are accessible through the
-        given module
-        if the latest access name corresponds to a module, return it
-        """
-        assert isinstance(module, astroid.Module), module
-        while module_names:
-            name = module_names.pop(0)
-            if name == '__dict__':
-                module = None
-                break
-            try:
-                module = module.getattr(name)[0].infer().next()
-                if module is astroid.YES:
-                    return None
-            except astroid.NotFoundError:
-                self.add_message('no-name-in-module', args=(name, module.name), node=node)
-                return None
-            except astroid.InferenceError:
-                return None
-        if module_names:
-            # FIXME: other message if name is not the latest part of
-            # module_names ?
-            modname = module and module.name or '__dict__'
-            self.add_message('no-name-in-module', node=node,
-                             args=('.'.join(module_names), modname))
-            return None
-        if isinstance(module, astroid.Module):
-            return module
-        return None
-
-
-class VariablesChecker3k(VariablesChecker):
-    '''Modified variables checker for 3k'''
-    # listcomp have now also their scope
-
-    def visit_listcomp(self, node):
-        """visit dictcomp: update consumption analysis variable
-        """
-        self._to_consume.append((copy(node.locals), {}, 'comprehension'))
-
-    def leave_listcomp(self, _):
-        """leave dictcomp: update consumption analysis variable
-        """
-        # do not check for not used locals here
-        self._to_consume.pop()
-
-    def leave_module(self, node):
-        """ Update consumption analysis variable
-        for metaclasses.
-        """
-        for klass in node.nodes_of_class(astroid.Class):
-            if klass._metaclass:
-                metaclass = klass.metaclass()
-                module_locals = self._to_consume[0][0]
-
-                if isinstance(klass._metaclass, astroid.Name):
-                    module_locals.pop(klass._metaclass.name, None)
-                if metaclass:                
-                    # if it uses a `metaclass=module.Class`                            
-                    module_locals.pop(metaclass.root().name, None)
-        super(VariablesChecker3k, self).leave_module(node)
-
-if sys.version_info >= (3, 0):
-    VariablesChecker = VariablesChecker3k
-
-
-def register(linter):
-    """required method to auto register this checker"""
-    linter.register_checker(VariablesChecker(linter))
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/config.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/config.py
deleted file mode 100644
index 992c2934..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/config.py
+++ /dev/null
@@ -1,156 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""utilities for Pylint configuration :
-
-* pylintrc
-* pylint.d (PYLINTHOME)
-"""
-from __future__ import with_statement
-
-import pickle
-import os
-import sys
-from os.path import exists, isfile, join, expanduser, abspath, dirname
-
-# pylint home is used to save old runs results ################################
-
-USER_HOME = expanduser('~')
-if 'PYLINTHOME' in os.environ:
-    PYLINT_HOME = os.environ['PYLINTHOME']
-    if USER_HOME == '~':
-        USER_HOME = dirname(PYLINT_HOME)
-elif USER_HOME == '~':
-    PYLINT_HOME = ".pylint.d"
-else:
-    PYLINT_HOME = join(USER_HOME, '.pylint.d')
-
-def get_pdata_path(base_name, recurs):
-    """return the path of the file which should contain old search data for the
-    given base_name with the given options values
-    """
-    base_name = base_name.replace(os.sep, '_')
-    return join(PYLINT_HOME, "%s%s%s"%(base_name, recurs, '.stats'))
-
-def load_results(base):
-    """try to unpickle and return data from file if it exists and is not
-    corrupted
-
-    return an empty dictionary if it doesn't exists
-    """
-    data_file = get_pdata_path(base, 1)
-    try:
-        with open(data_file) as stream:
-            return pickle.load(stream)
-    except:
-        return {}
-
-if sys.version_info < (3, 0):
-    _PICK_MOD = 'w'
-else:
-    _PICK_MOD = 'wb'
-
-def save_results(results, base):
-    """pickle results"""
-    if not exists(PYLINT_HOME):
-        try:
-            os.mkdir(PYLINT_HOME)
-        except OSError:
-            print >> sys.stderr, 'Unable to create directory %s' % PYLINT_HOME
-    data_file = get_pdata_path(base, 1)
-    try:
-        with open(data_file, _PICK_MOD) as stream:
-            pickle.dump(results, stream)
-    except (IOError, OSError), ex:
-        print >> sys.stderr, 'Unable to create file %s: %s' % (data_file, ex)
-
-# location of the configuration file ##########################################
-
-
-def find_pylintrc():
-    """search the pylint rc file and return its path if it find it, else None
-    """
-    # is there a pylint rc file in the current directory ?
-    if exists('pylintrc'):
-        return abspath('pylintrc')
-    if isfile('__init__.py'):
-        curdir = abspath(os.getcwd())
-        while isfile(join(curdir, '__init__.py')):
-            curdir = abspath(join(curdir, '..'))
-            if isfile(join(curdir, 'pylintrc')):
-                return join(curdir, 'pylintrc')
-    if 'PYLINTRC' in os.environ and exists(os.environ['PYLINTRC']):
-        pylintrc = os.environ['PYLINTRC']
-    else:
-        user_home = expanduser('~')
-        if user_home == '~' or user_home == '/root':
-            pylintrc = ".pylintrc"
-        else:
-            pylintrc = join(user_home, '.pylintrc')
-            if not isfile(pylintrc):
-                pylintrc = join(user_home, '.config', 'pylintrc')
-    if not isfile(pylintrc):
-        if isfile('/etc/pylintrc'):
-            pylintrc = '/etc/pylintrc'
-        else:
-            pylintrc = None
-    return pylintrc
-
-PYLINTRC = find_pylintrc()
-
-ENV_HELP = '''
-The following environment variables are used:                                   
-    * PYLINTHOME                                                                
-    Path to the directory where the persistent for the run will be stored. If 
-not found, it defaults to ~/.pylint.d/ or .pylint.d (in the current working 
-directory).                                                                     
-    * PYLINTRC                                                                  
-    Path to the configuration file. See the documentation for the method used
-to search for configuration file.
-''' % globals()
-
-# evaluation messages #########################################################
-
-def get_note_message(note):
-    """return a message according to note
-    note is a float < 10  (10 is the highest note)
-    """
-    assert note <= 10, "Note is %.2f. Either you cheated, or pylint's \
-broken!" % note
-    if note < 0:
-        msg = 'You have to do something quick !'
-    elif note < 1:
-        msg = 'Hey! This is really dreadful. Or maybe pylint is buggy?'
-    elif note < 2:
-        msg = "Come on! You can't be proud of this code"
-    elif note < 3:
-        msg = 'Hum... Needs work.'
-    elif note < 4:
-        msg = 'Wouldn\'t you be a bit lazy?'
-    elif note < 5:
-        msg = 'A little more work would make it acceptable.'
-    elif note < 6:
-        msg = 'Just the bare minimum. Give it a bit more polish. '
-    elif note < 7:
-        msg = 'This is okay-ish, but I\'m sure you can do better.'
-    elif note < 8:
-        msg = 'If you commit now, people should not be making nasty \
-comments about you on c.l.py'
-    elif note < 9:
-        msg = 'That\'s pretty good. Good work mate.'
-    elif note < 10:
-        msg = 'So close to being perfect...'
-    else:
-        msg = 'Wow ! Now this deserves our uttermost respect.\nPlease send \
-your code to python-projects@logilab.org'
-    return msg
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/interfaces.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/interfaces.py
deleted file mode 100644
index 50f2c839..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/interfaces.py
+++ /dev/null
@@ -1,72 +0,0 @@
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""Interfaces for PyLint objects"""
-
-from logilab.common.interface import Interface
-
-
-class IChecker(Interface):
-    """This is an base interface, not designed to be used elsewhere than for
-    sub interfaces definition.
-    """
-
-    def open(self):
-        """called before visiting project (i.e set of modules)"""
-
-    def close(self):
-        """called after visiting project (i.e set of modules)"""
-
-
-class IRawChecker(IChecker):
-    """interface for checker which need to parse the raw file
-    """
-
-    def process_module(self, astroid):
-        """ process a module
-
-        the module's content is accessible via astroid.file_stream
-        """
-
-
-class ITokenChecker(IChecker):
-    """Interface for checkers that need access to the token list."""
-    def process_tokens(self, tokens):
-        """Process a module.
-
-        tokens is a list of all source code tokens in the file.
-        """
-
-
-class IAstroidChecker(IChecker):
-    """ interface for checker which prefers receive events according to
-    statement type
-    """
-
-
-class IReporter(Interface):
-    """ reporter collect messages and display results encapsulated in a layout
-    """
-    def add_message(self, msg_id, location, msg):
-        """add a message of a given type
-
-        msg_id is a message identifier
-        location is a 3-uple (module, object, line)
-        msg is the actual message
-        """
-
-    def display_results(self, layout):
-        """display results encapsulated in the layout tree
-        """
-
-
-__all__ = ('IRawChecker', 'IAstroidChecker', 'ITokenChecker', 'IReporter')
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/lint.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/lint.py
deleted file mode 100644
index 529fbd44..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/lint.py
+++ /dev/null
@@ -1,1106 +0,0 @@
-# Copyright (c) 2003-2014 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-""" %prog [options] module_or_package
-
-  Check that a module satisfies a coding standard (and more !).
-
-    %prog --help
-
-  Display this help message and exit.
-
-    %prog --help-msg <msg-id>[,<msg-id>]
-
-  Display help messages about given message identifiers and exit.
-"""
-
-# import this first to avoid builtin namespace pollution
-from pylint.checkers import utils
-
-import functools
-import sys
-import os
-import tokenize
-from warnings import warn
-
-from logilab.common.configuration import UnsupportedAction, OptionsManagerMixIn
-from logilab.common.optik_ext import check_csv
-from logilab.common.modutils import load_module_from_name, get_module_part
-from logilab.common.interface import implements
-from logilab.common.textutils import splitstrip, unquote
-from logilab.common.ureports import Table, Text, Section
-from logilab.common.__pkginfo__ import version as common_version
-
-from astroid import MANAGER, nodes, AstroidBuildingException
-from astroid.__pkginfo__ import version as astroid_version
-
-from pylint.utils import (
-    MSG_TYPES, OPTION_RGX,
-    PyLintASTWalker, UnknownMessage, MessagesHandlerMixIn, ReportsHandlerMixIn,
-    EmptyReport, WarningScope,
-    expand_modules, tokenize_module)
-from pylint.interfaces import IRawChecker, ITokenChecker, IAstroidChecker
-from pylint.checkers import (BaseTokenChecker,
-                             table_lines_from_stats,
-                             initialize as checkers_initialize)
-from pylint.reporters import initialize as reporters_initialize
-from pylint import config
-
-from pylint.__pkginfo__ import version
-
-
-
-def _get_python_path(filepath):
-    dirname = os.path.dirname(os.path.realpath(
-            os.path.expanduser(filepath)))
-    while True:
-        if not os.path.exists(os.path.join(dirname, "__init__.py")):
-            return dirname
-        old_dirname = dirname
-        dirname = os.path.dirname(dirname)
-        if old_dirname == dirname:
-            return os.getcwd()
-
-
-# Python Linter class #########################################################
-
-MSGS = {
-    'F0001': ('%s',
-              'fatal',
-              'Used when an error occurred preventing the analysis of a \
-              module (unable to find it for instance).'),
-    'F0002': ('%s: %s',
-              'astroid-error',
-              'Used when an unexpected error occurred while building the '
-              'Astroid  representation. This is usually accompanied by a '
-              'traceback. Please report such errors !'),
-    'F0003': ('ignored builtin module %s',
-              'ignored-builtin-module',
-              'Used to indicate that the user asked to analyze a builtin '
-              'module which has been skipped.'),
-    'F0010': ('error while code parsing: %s',
-              'parse-error',
-              'Used when an exception occured while building the Astroid '
-               'representation which could be handled by astroid.'),
-
-    'I0001': ('Unable to run raw checkers on built-in module %s',
-              'raw-checker-failed',
-              'Used to inform that a built-in module has not been checked '
-              'using the raw checkers.'),
-
-    'I0010': ('Unable to consider inline option %r',
-              'bad-inline-option',
-              'Used when an inline option is either badly formatted or can\'t '
-              'be used inside modules.'),
-
-    'I0011': ('Locally disabling %s (%s)',
-              'locally-disabled',
-              'Used when an inline option disables a message or a messages '
-              'category.'),
-    'I0012': ('Locally enabling %s (%s)',
-              'locally-enabled',
-              'Used when an inline option enables a message or a messages '
-              'category.'),
-    'I0013': ('Ignoring entire file',
-              'file-ignored',
-              'Used to inform that the file will not be checked'),
-    'I0020': ('Suppressed %s (from line %d)',
-              'suppressed-message',
-              'A message was triggered on a line, but suppressed explicitly '
-              'by a disable= comment in the file. This message is not '
-              'generated for messages that are ignored due to configuration '
-              'settings.'),
-    'I0021': ('Useless suppression of %s',
-              'useless-suppression',
-              'Reported when a message is explicitly disabled for a line or '
-              'a block of code, but never triggered.'),
-    'I0022': ('Pragma "%s" is deprecated, use "%s" instead',
-              'deprecated-pragma',
-              'Some inline pylint options have been renamed or reworked, '
-              'only the most recent form should be used. '
-              'NOTE:skip-all is only available with pylint >= 0.26', 
-              {'old_names': [('I0014', 'deprecated-disable-all')]}),
-
-    'E0001': ('%s',
-              'syntax-error',
-              'Used when a syntax error is raised for a module.'),
-
-    'E0011': ('Unrecognized file option %r',
-              'unrecognized-inline-option',
-              'Used when an unknown inline option is encountered.'),
-    'E0012': ('Bad option value %r',
-              'bad-option-value',
-              'Used when a bad value for an inline option is encountered.'),
-    }
-
-
-def _deprecated_option(shortname, opt_type):
-    def _warn_deprecated(option, optname, *args):
-        sys.stderr.write('Warning: option %s is deprecated and ignored.\n' % (optname,))
-    return {'short': shortname, 'help': 'DEPRECATED', 'hide': True,
-            'type': opt_type, 'action': 'callback', 'callback': _warn_deprecated}
-
-
-class PyLinter(OptionsManagerMixIn, MessagesHandlerMixIn, ReportsHandlerMixIn,
-               BaseTokenChecker):
-    """lint Python modules using external checkers.
-
-    This is the main checker controlling the other ones and the reports
-    generation. It is itself both a raw checker and an astroid checker in order
-    to:
-    * handle message activation / deactivation at the module level
-    * handle some basic but necessary stats'data (number of classes, methods...)
-
-    IDE plugins developpers: you may have to call
-    `astroid.builder.MANAGER.astroid_cache.clear()` accross run if you want
-    to ensure the latest code version is actually checked.
-    """
-
-    __implements__ = (ITokenChecker,)
-
-    name = 'master'
-    priority = 0
-    level = 0
-    msgs = MSGS
-    may_be_disabled = False
-
-    @staticmethod
-    def make_options():
-        return (('ignore',
-                 {'type' : 'csv', 'metavar' : '<file>[,<file>...]',
-                  'dest' : 'black_list', 'default' : ('CVS',),
-                  'help' : 'Add files or directories to the blacklist. '
-                  'They should be base names, not paths.'}),
-                ('persistent',
-                 {'default': True, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                  'level': 1,
-                  'help' : 'Pickle collected data for later comparisons.'}),
-
-                ('load-plugins',
-                 {'type' : 'csv', 'metavar' : '<modules>', 'default' : (),
-                  'level': 1,
-                  'help' : 'List of plugins (as comma separated values of '
-                  'python modules names) to load, usually to register '
-                  'additional checkers.'}),
-
-                ('output-format',
-                 {'default': 'text', 'type': 'string', 'metavar' : '<format>',
-                  'short': 'f',
-                  'group': 'Reports',
-                  'help' : 'Set the output format. Available formats are text,'
-                  ' parseable, colorized, msvs (visual studio) and html. You '
-                  'can also give a reporter class, eg mypackage.mymodule.'
-                  'MyReporterClass.'}),
-
-                ('files-output',
-                 {'default': 0, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                  'group': 'Reports', 'level': 1,
-                  'help' : '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]".'}),
-
-                ('reports',
-                 {'default': 1, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                  'short': 'r',
-                  'group': 'Reports',
-                  'help' : 'Tells whether to display a full report or only the '
-                  'messages'}),
-
-                ('evaluation',
-                 {'type' : 'string', 'metavar' : '<python_expression>',
-                  'group': 'Reports', 'level': 1,
-                  'default': '10.0 - ((float(5 * error + warning + refactor + '
-                  'convention) / statement) * 10)',
-                  'help' : 'Python expression which should return a note less \
-than 10 (10 is the highest note). You have access to the variables errors \
-warning, statement which respectively contain the number of errors / warnings\
- messages and the total number of statements analyzed. This is used by the \
- global evaluation report (RP0004).'}),
-
-                ('comment',
-                 {'default': 0, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                  'group': 'Reports', 'level': 1,
-                  'help' : 'Add a comment according to your evaluation note. '
-                  'This is used by the global evaluation report (RP0004).'}),
-
-                ('enable',
-                 {'type' : 'csv', 'metavar': '<msg ids>',
-                  'short': 'e',
-                  'group': 'Messages control',
-                  'help' : '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. '}),
-
-                ('disable',
-                 {'type' : 'csv', 'metavar': '<msg ids>',
-                  'short': 'd',
-                  'group': 'Messages control',
-                  'help' : 'Disable the message, report, category or checker '
-                  'with the given id(s). You can either give multiple identifiers'
-                  ' separated by comma (,) or put this option multiple times '
-                  '(only on the command line, not in the configuration file '
-                  'where it should appear only once).'
-                  'You can also use "--disable=all" to disable everything first '
-                  'and then reenable specific checks. For example, if you want '
-                  'to run only the similarities checker, you can use '
-                  '"--disable=all --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"'}),
-
-                ('msg-template',
-                 {'type' : 'string', 'metavar': '<template>',
-                 #'short': 't',
-                  'group': 'Reports',
-                  'help' : ('Template used to display messages. '
-                            'This is a python new-style format string '
-                            'used to format the message information. '
-                            'See doc for all details')
-                  }),
-
-                ('include-ids', _deprecated_option('i', 'yn')),
-                ('symbols', _deprecated_option('s', 'yn')),
-               )
-
-    option_groups = (
-        ('Messages control', 'Options controling analysis messages'),
-        ('Reports', 'Options related to output formating and reporting'),
-        )
-
-    def __init__(self, options=(), reporter=None, option_groups=(),
-                 pylintrc=None):
-        # some stuff has to be done before ancestors initialization...
-        #
-        # checkers / reporter / astroid manager
-        self.reporter = None
-        self._reporter_name = None
-        self._reporters = {}
-        self._checkers = {}
-        self._ignore_file = False
-        # visit variables
-        self.base_name = None
-        self.base_file = None
-        self.current_name = None
-        self.current_file = None
-        self.stats = None
-        # init options
-        self.options = options + PyLinter.make_options()
-        self.option_groups = option_groups + PyLinter.option_groups
-        self._options_methods = {
-            'enable': self.enable,
-            'disable': self.disable}
-        self._bw_options_methods = {'disable-msg': self.disable,
-                                    'enable-msg': self.enable}
-        full_version = '%%prog %s, \nastroid %s, common %s\nPython %s' % (
-            version, astroid_version, common_version, sys.version)
-        OptionsManagerMixIn.__init__(self, usage=__doc__,
-                                     version=full_version,
-                                     config_file=pylintrc or config.PYLINTRC)
-        MessagesHandlerMixIn.__init__(self)
-        ReportsHandlerMixIn.__init__(self)
-        BaseTokenChecker.__init__(self)
-        # provided reports
-        self.reports = (('RP0001', 'Messages by category',
-                         report_total_messages_stats),
-                        ('RP0002', '% errors / warnings by module',
-                         report_messages_by_module_stats),
-                        ('RP0003', 'Messages',
-                         report_messages_stats),
-                        ('RP0004', 'Global evaluation',
-                         self.report_evaluation),
-                        )
-        self.register_checker(self)
-        self._dynamic_plugins = set()
-        self.load_provider_defaults()
-        if reporter:
-            self.set_reporter(reporter)
-
-    def load_default_plugins(self):
-        checkers_initialize(self)
-        reporters_initialize(self)
-        # Make sure to load the default reporter, because
-        # the option has been set before the plugins had been loaded.
-        if not self.reporter:
-            self._load_reporter()
-
-    def prepare_import_path(self, args):
-        """Prepare sys.path for running the linter checks."""
-        if len(args) == 1:
-            sys.path.insert(0, _get_python_path(args[0]))
-        else:
-            sys.path.insert(0, os.getcwd())
-
-    def cleanup_import_path(self):
-        """Revert any changes made to sys.path in prepare_import_path."""
-        sys.path.pop(0)
-
-    def load_plugin_modules(self, modnames):
-        """take a list of module names which are pylint plugins and load
-        and register them
-        """
-        for modname in modnames:
-            if modname in self._dynamic_plugins:
-                continue
-            self._dynamic_plugins.add(modname)
-            module = load_module_from_name(modname)
-            module.register(self)
-
-    def _load_reporter(self):
-        name = self._reporter_name.lower()
-        if name in self._reporters:
-            self.set_reporter(self._reporters[name]())
-        else:
-            qname = self._reporter_name
-            module = load_module_from_name(get_module_part(qname))
-            class_name = qname.split('.')[-1]
-            reporter_class = getattr(module, class_name)
-            self.set_reporter(reporter_class())
-
-    def set_reporter(self, reporter):
-        """set the reporter used to display messages and reports"""
-        self.reporter = reporter
-        reporter.linter = self
-
-    def set_option(self, optname, value, action=None, optdict=None):
-        """overridden from configuration.OptionsProviderMixin to handle some
-        special options
-        """
-        if optname in self._options_methods or \
-                optname in self._bw_options_methods:
-            if value:
-                try:
-                    meth = self._options_methods[optname]
-                except KeyError:
-                    meth = self._bw_options_methods[optname]
-                    warn('%s is deprecated, replace it by %s' % (
-                        optname, optname.split('-')[0]), DeprecationWarning)
-                value = check_csv(None, optname, value)
-                if isinstance(value, (list, tuple)):
-                    for _id in value:
-                        meth(_id, ignore_unknown=True)
-                else:
-                    meth(value)
-        elif optname == 'output-format':
-            self._reporter_name = value
-            # If the reporters are already available, load
-            # the reporter class.
-            if self._reporters:
-                self._load_reporter()
-        try:
-            BaseTokenChecker.set_option(self, optname, value, action, optdict)
-        except UnsupportedAction:
-            print >> sys.stderr, 'option %s can\'t be read from config file' % \
-                  optname
-
-    def register_reporter(self, reporter_class):
-        self._reporters[reporter_class.name] = reporter_class
-
-    # checkers manipulation methods ############################################
-
-    def register_checker(self, checker):
-        """register a new checker
-
-        checker is an object implementing IRawChecker or / and IAstroidChecker
-        """
-        assert checker.priority <= 0, 'checker priority can\'t be >= 0'
-        self._checkers.setdefault(checker.name, []).append(checker)
-        for r_id, r_title, r_cb in checker.reports:
-            self.register_report(r_id, r_title, r_cb, checker)
-        self.register_options_provider(checker)
-        if hasattr(checker, 'msgs'):
-            self.register_messages(checker)
-        checker.load_defaults()
-
-    def disable_noerror_messages(self):
-        for msgcat, msgids in self._msgs_by_category.iteritems():
-            if msgcat == 'E':
-                for msgid in msgids:
-                    self.enable(msgid)
-            else:
-                for msgid in msgids:
-                    self.disable(msgid)
-
-    def disable_reporters(self):
-        """disable all reporters"""
-        for reporters in self._reports.itervalues():
-            for report_id, _title, _cb in reporters:
-                self.disable_report(report_id)
-
-    def error_mode(self):
-        """error mode: enable only errors; no reports, no persistent"""
-        self.disable_noerror_messages()
-        self.disable('miscellaneous')
-        self.set_option('reports', False)
-        self.set_option('persistent', False)
-
-    # block level option handling #############################################
-    #
-    # see func_block_disable_msg.py test case for expected behaviour
-
-    def process_tokens(self, tokens):
-        """process tokens from the current module to search for module/block
-        level options
-        """
-        for (tok_type, content, start, _, _) in tokens:
-            if tok_type != tokenize.COMMENT:
-                continue
-            match = OPTION_RGX.search(content)
-            if match is None:
-                continue
-            if match.group(1).strip() == "disable-all" or \
-                    match.group(1).strip() == 'skip-file':
-                if match.group(1).strip() == "disable-all":
-                    self.add_message('deprecated-pragma', line=start[0],
-                                     args=('disable-all', 'skip-file'))
-                self.add_message('file-ignored', line=start[0])
-                self._ignore_file = True
-                return
-            try:
-                opt, value = match.group(1).split('=', 1)
-            except ValueError:
-                self.add_message('bad-inline-option', args=match.group(1).strip(),
-                                 line=start[0])
-                continue
-            opt = opt.strip()
-            if opt in self._options_methods or opt in self._bw_options_methods:
-                try:
-                    meth = self._options_methods[opt]
-                except KeyError:
-                    meth = self._bw_options_methods[opt]
-                    # found a "(dis|en)able-msg" pragma deprecated suppresssion
-                    self.add_message('deprecated-pragma', line=start[0], args=(opt, opt.replace('-msg', '')))
-                for msgid in splitstrip(value):
-                    try:
-                        if (opt, msgid) == ('disable', 'all'):
-                            self.add_message('deprecated-pragma', line=start[0], args=('disable=all', 'skip-file'))
-                            self.add_message('file-ignored', line=start[0])
-                            self._ignore_file = True
-                            return
-                        meth(msgid, 'module', start[0])
-                    except UnknownMessage:
-                        self.add_message('bad-option-value', args=msgid, line=start[0])
-            else:
-                self.add_message('unrecognized-inline-option', args=opt, line=start[0])
-
-    def collect_block_lines(self, node, msg_state):
-        """walk ast to collect block level options line numbers"""
-        # recurse on children (depth first)
-        for child in node.get_children():
-            self.collect_block_lines(child, msg_state)
-        first = node.fromlineno
-        last = node.tolineno
-        # first child line number used to distinguish between disable
-        # which are the first child of scoped node with those defined later.
-        # For instance in the code below:
-        #
-        # 1.   def meth8(self):
-        # 2.        """test late disabling"""
-        # 3.        # pylint: disable=E1102
-        # 4.        print self.blip
-        # 5.        # pylint: disable=E1101
-        # 6.        print self.bla
-        #
-        # E1102 should be disabled from line 1 to 6 while E1101 from line 5 to 6
-        #
-        # this is necessary to disable locally messages applying to class /
-        # function using their fromlineno
-        if isinstance(node, (nodes.Module, nodes.Class, nodes.Function)) and node.body:
-            firstchildlineno = node.body[0].fromlineno
-        else:
-            firstchildlineno = last
-        for msgid, lines in msg_state.iteritems():
-            for lineno, state in lines.items():
-                original_lineno = lineno
-                if first <= lineno <= last:
-                    # Set state for all lines for this block, if the
-                    # warning is applied to nodes.
-                    if self.check_message_id(msgid).scope == WarningScope.NODE:
-                        if lineno > firstchildlineno:
-                            state = True
-                        first_, last_ = node.block_range(lineno)
-                    else:
-                        first_ = lineno
-                        last_ = last
-                    for line in xrange(first_, last_+1):
-                        # do not override existing entries
-                        if not line in self._module_msgs_state.get(msgid, ()):
-                            if line in lines: # state change in the same block
-                                state = lines[line]
-                                original_lineno = line
-                            if not state:
-                                self._suppression_mapping[(msgid, line)] = original_lineno
-                            try:
-                                self._module_msgs_state[msgid][line] = state
-                            except KeyError:
-                                self._module_msgs_state[msgid] = {line: state}
-                    del lines[lineno]
-
-
-    # code checking methods ###################################################
-
-    def get_checkers(self):
-        """return all available checkers as a list"""
-        return [self] + [c for checkers in self._checkers.itervalues()
-                         for c in checkers if c is not self]
-
-    def prepare_checkers(self):
-        """return checkers needed for activated messages and reports"""
-        if not self.config.reports:
-            self.disable_reporters()
-        # get needed checkers
-        neededcheckers = [self]
-        for checker in self.get_checkers()[1:]:
-            # fatal errors should not trigger enable / disabling a checker
-            messages = set(msg for msg in checker.msgs
-                           if msg[0] != 'F' and self.is_message_enabled(msg))
-            if (messages or
-                any(self.report_is_enabled(r[0]) for r in checker.reports)):
-                neededcheckers.append(checker)
-        return neededcheckers
-
-    def should_analyze_file(self, modname, path): # pylint: disable=unused-argument
-        """Returns whether or not a module should be checked.
-
-        This implementation returns True for all python source file, indicating
-        that all files should be linted.
-
-        Subclasses may override this method to indicate that modules satisfying
-        certain conditions should not be linted.
-
-        :param str modname: The name of the module to be checked.
-        :param str path: The full path to the source code of the module.
-        :returns: True if the module should be checked.
-        :rtype: bool
-        """
-        return path.endswith('.py')
-
-    def check(self, files_or_modules):
-        """main checking entry: check a list of files or modules from their
-        name.
-        """
-        if not isinstance(files_or_modules, (list, tuple)):
-            files_or_modules = (files_or_modules,)
-        walker = PyLintASTWalker(self)
-        checkers = self.prepare_checkers()
-        tokencheckers = [c for c in checkers if implements(c, ITokenChecker)
-                         and c is not self]
-        rawcheckers = [c for c in checkers if implements(c, IRawChecker)]
-        # notify global begin
-        for checker in checkers:
-            checker.open()
-            if implements(checker, IAstroidChecker):
-                walker.add_checker(checker)
-        # build ast and check modules or packages
-        for descr in self.expand_files(files_or_modules):
-            modname, filepath = descr['name'], descr['path']
-            if not descr['isarg'] and not self.should_analyze_file(modname, filepath):
-                continue
-            if self.config.files_output:
-                reportfile = 'pylint_%s.%s' % (modname, self.reporter.extension)
-                self.reporter.set_output(open(reportfile, 'w'))
-            self.set_current_module(modname, filepath)
-            # get the module representation
-            astroid = self.get_ast(filepath, modname)
-            if astroid is None:
-                continue
-            self.base_name = descr['basename']
-            self.base_file = descr['basepath']
-            self._ignore_file = False
-            # fix the current file (if the source file was not available or
-            # if it's actually a c extension)
-            self.current_file = astroid.file # pylint: disable=maybe-no-member
-            self.check_astroid_module(astroid, walker, rawcheckers, tokencheckers)
-            self._add_suppression_messages()
-        # notify global end
-        self.set_current_module('')
-        self.stats['statement'] = walker.nbstatements
-        checkers.reverse()
-        for checker in checkers:
-            checker.close()
-
-    def expand_files(self, modules):
-        """get modules and errors from a list of modules and handle errors
-        """
-        result, errors = expand_modules(modules, self.config.black_list)
-        for error in errors:
-            message = modname = error["mod"]
-            key = error["key"]
-            self.set_current_module(modname)
-            if key == "fatal":
-                message = str(error["ex"]).replace(os.getcwd() + os.sep, '')
-            self.add_message(key, args=message)
-        return result
-
-    def set_current_module(self, modname, filepath=None):
-        """set the name of the currently analyzed module and
-        init statistics for it
-        """
-        if not modname and filepath is None:
-            return
-        self.reporter.on_set_current_module(modname, filepath)
-        self.current_name = modname
-        self.current_file = filepath or modname
-        self.stats['by_module'][modname] = {}
-        self.stats['by_module'][modname]['statement'] = 0
-        for msg_cat in MSG_TYPES.itervalues():
-            self.stats['by_module'][modname][msg_cat] = 0
-        # XXX hack, to be correct we need to keep module_msgs_state
-        # for every analyzed module (the problem stands with localized
-        # messages which are only detected in the .close step)
-        if modname:
-            self._module_msgs_state = {}
-            self._raw_module_msgs_state = {}
-            self._ignored_msgs = {}
-
-    def get_ast(self, filepath, modname):
-        """return a ast(roid) representation for a module"""
-        try:
-            return MANAGER.ast_from_file(filepath, modname, source=True)
-        except SyntaxError, ex:
-            self.add_message('syntax-error', line=ex.lineno, args=ex.msg)
-        except AstroidBuildingException, ex:
-            self.add_message('parse-error', args=ex)
-        except Exception, ex:
-            import traceback
-            traceback.print_exc()
-            self.add_message('astroid-error', args=(ex.__class__, ex))
-
-    def check_astroid_module(self, astroid, walker, rawcheckers, tokencheckers):
-        """check a module from its astroid representation, real work"""
-        # call raw checkers if possible
-        try:
-            tokens = tokenize_module(astroid)
-        except tokenize.TokenError, ex:
-            self.add_message('syntax-error', line=ex.args[1][0], args=ex.args[0])
-            return
-
-        if not astroid.pure_python:
-            self.add_message('raw-checker-failed', args=astroid.name)
-        else:
-            #assert astroid.file.endswith('.py')
-            # invoke ITokenChecker interface on self to fetch module/block
-            # level options
-            self.process_tokens(tokens)
-            if self._ignore_file:
-                return False
-            # walk ast to collect line numbers
-            for msg, lines in self._module_msgs_state.iteritems():
-                self._raw_module_msgs_state[msg] = lines.copy()
-            orig_state = self._module_msgs_state.copy()
-            self._module_msgs_state = {}
-            self._suppression_mapping = {}
-            self.collect_block_lines(astroid, orig_state)
-            for checker in rawcheckers:
-                checker.process_module(astroid)
-            for checker in tokencheckers:
-                checker.process_tokens(tokens)
-        # generate events to astroid checkers
-        walker.walk(astroid)
-        return True
-
-    # IAstroidChecker interface #################################################
-
-    def open(self):
-        """initialize counters"""
-        self.stats = {'by_module' : {},
-                      'by_msg' : {},
-                       }
-        for msg_cat in MSG_TYPES.itervalues():
-            self.stats[msg_cat] = 0
-
-    def close(self):
-        """close the whole package /module, it's time to make reports !
-
-        if persistent run, pickle results for later comparison
-        """
-        if self.base_name is not None:
-            # load previous results if any
-            previous_stats = config.load_results(self.base_name)
-            # XXX code below needs refactoring to be more reporter agnostic
-            self.reporter.on_close(self.stats, previous_stats)
-            if self.config.reports:
-                sect = self.make_reports(self.stats, previous_stats)
-                if self.config.files_output:
-                    filename = 'pylint_global.' + self.reporter.extension
-                    self.reporter.set_output(open(filename, 'w'))
-            else:
-                sect = Section()
-            if self.config.reports or self.config.output_format == 'html':
-                self.reporter.display_results(sect)
-            # save results if persistent run
-            if self.config.persistent:
-                config.save_results(self.stats, self.base_name)
-        else:
-            self.reporter.on_close(self.stats, {})
-
-    # specific reports ########################################################
-
-    def _add_suppression_messages(self):
-        for warning, lines in self._raw_module_msgs_state.iteritems():
-            for line, enable in lines.iteritems():
-                if not enable and (warning, line) not in self._ignored_msgs:
-                    self.add_message('useless-suppression', line, None,
-                                     (self.get_msg_display_string(warning),))
-        # don't use iteritems here, _ignored_msgs may be modified by add_message
-        for (warning, from_), lines in self._ignored_msgs.items():
-            for line in lines:
-                self.add_message('suppressed-message', line, None,
-                                 (self.get_msg_display_string(warning), from_))
-
-    def report_evaluation(self, sect, stats, previous_stats):
-        """make the global evaluation report"""
-        # check with at least check 1 statements (usually 0 when there is a
-        # syntax error preventing pylint from further processing)
-        if stats['statement'] == 0:
-            raise EmptyReport()
-        # get a global note for the code
-        evaluation = self.config.evaluation
-        try:
-            note = eval(evaluation, {}, self.stats)
-        except Exception, ex:
-            msg = 'An exception occurred while rating: %s' % ex
-        else:
-            stats['global_note'] = note
-            msg = 'Your code has been rated at %.2f/10' % note
-            pnote = previous_stats.get('global_note')
-            if pnote is not None:
-                msg += ' (previous run: %.2f/10, %+.2f)' % (pnote, note - pnote)
-            if self.config.comment:
-                msg = '%s\n%s' % (msg, config.get_note_message(note))
-        sect.append(Text(msg))
-
-# some reporting functions ####################################################
-
-def report_total_messages_stats(sect, stats, previous_stats):
-    """make total errors / warnings report"""
-    lines = ['type', 'number', 'previous', 'difference']
-    lines += table_lines_from_stats(stats, previous_stats,
-                                    ('convention', 'refactor',
-                                     'warning', 'error'))
-    sect.append(Table(children=lines, cols=4, rheaders=1))
-
-def report_messages_stats(sect, stats, _):
-    """make messages type report"""
-    if not stats['by_msg']:
-        # don't print this report when we didn't detected any errors
-        raise EmptyReport()
-    in_order = sorted([(value, msg_id)
-                       for msg_id, value in stats['by_msg'].iteritems()
-                       if not msg_id.startswith('I')])
-    in_order.reverse()
-    lines = ('message id', 'occurrences')
-    for value, msg_id in in_order:
-        lines += (msg_id, str(value))
-    sect.append(Table(children=lines, cols=2, rheaders=1))
-
-def report_messages_by_module_stats(sect, stats, _):
-    """make errors / warnings by modules report"""
-    if len(stats['by_module']) == 1:
-        # don't print this report when we are analysing a single module
-        raise EmptyReport()
-    by_mod = {}
-    for m_type in ('fatal', 'error', 'warning', 'refactor', 'convention'):
-        total = stats[m_type]
-        for module in stats['by_module'].iterkeys():
-            mod_total = stats['by_module'][module][m_type]
-            if total == 0:
-                percent = 0
-            else:
-                percent = float((mod_total)*100) / total
-            by_mod.setdefault(module, {})[m_type] = percent
-    sorted_result = []
-    for module, mod_info in by_mod.iteritems():
-        sorted_result.append((mod_info['error'],
-                              mod_info['warning'],
-                              mod_info['refactor'],
-                              mod_info['convention'],
-                              module))
-    sorted_result.sort()
-    sorted_result.reverse()
-    lines = ['module', 'error', 'warning', 'refactor', 'convention']
-    for line in sorted_result:
-        if line[0] == 0 and line[1] == 0:
-            break
-        lines.append(line[-1])
-        for val in line[:-1]:
-            lines.append('%.2f' % val)
-    if len(lines) == 5:
-        raise EmptyReport()
-    sect.append(Table(children=lines, cols=5, rheaders=1))
-
-
-# utilities ###################################################################
-
-# this may help to import modules using gettext
-# XXX syt, actually needed since we don't import code?
-
-from logilab.common.compat import builtins
-builtins._ = str
-
-
-class ArgumentPreprocessingError(Exception):
-    """Raised if an error occurs during argument preprocessing."""
-
-
-def preprocess_options(args, search_for):
-    """look for some options (keys of <search_for>) which have to be processed
-    before others
-
-    values of <search_for> are callback functions to call when the option is
-    found
-    """
-    i = 0
-    while i < len(args):
-        arg = args[i]
-        if arg.startswith('--'):
-            try:
-                option, val = arg[2:].split('=', 1)
-            except ValueError:
-                option, val = arg[2:], None
-            try:
-                cb, takearg = search_for[option]
-            except KeyError:
-                i += 1
-            else:
-                del args[i]
-                if takearg and val is None:
-                    if i >= len(args) or args[i].startswith('-'):
-                        msg = 'Option %s expects a value' % option
-                        raise ArgumentPreprocessingError(msg)
-                    val = args[i]
-                    del args[i]
-                elif not takearg and val is not None:
-                    msg = "Option %s doesn't expects a value" % option
-                    raise ArgumentPreprocessingError(msg)
-                cb(option, val)
-        else:
-            i += 1
-
-class Run(object):
-    """helper class to use as main for pylint :
-
-    run(*sys.argv[1:])
-    """
-    LinterClass = PyLinter
-    option_groups = (
-        ('Commands', 'Options which are actually commands. Options in this \
-group are mutually exclusive.'),
-        )
-
-    def __init__(self, args, reporter=None, exit=True):
-        self._rcfile = None
-        self._plugins = []
-        try:
-            preprocess_options(args, {
-                    # option: (callback, takearg)
-                    'init-hook':   (cb_init_hook, True),
-                    'rcfile':       (self.cb_set_rcfile, True),
-                    'load-plugins': (self.cb_add_plugins, True),
-                    })
-        except ArgumentPreprocessingError, ex:
-            print >> sys.stderr, ex
-            sys.exit(32)
-
-        self.linter = linter = self.LinterClass((
-            ('rcfile',
-             {'action' : 'callback', 'callback' : lambda *args: 1,
-              'type': 'string', 'metavar': '<file>',
-              'help' : 'Specify a configuration file.'}),
-
-            ('init-hook',
-             {'action' : 'callback', 'callback' : lambda *args: 1,
-              'type' : 'string', 'metavar': '<code>',
-              'level': 1,
-              'help' : 'Python code to execute, usually for sys.path \
-manipulation such as pygtk.require().'}),
-
-            ('help-msg',
-             {'action' : 'callback', 'type' : 'string', 'metavar': '<msg-id>',
-              'callback' : self.cb_help_message,
-              'group': 'Commands',
-              'help' : '''Display a help message for the given message id and \
-exit. The value may be a comma separated list of message ids.'''}),
-
-            ('list-msgs',
-             {'action' : 'callback', 'metavar': '<msg-id>',
-              'callback' : self.cb_list_messages,
-              'group': 'Commands', 'level': 1,
-              'help' : "Generate pylint's messages."}),
-
-            ('full-documentation',
-             {'action' : 'callback', 'metavar': '<msg-id>',
-              'callback' : self.cb_full_documentation,
-              'group': 'Commands', 'level': 1,
-              'help' : "Generate pylint's full documentation."}),
-
-            ('generate-rcfile',
-             {'action' : 'callback', 'callback' : self.cb_generate_config,
-              'group': 'Commands',
-              'help' : '''Generate a sample configuration file according to \
-the current configuration. You can put other options before this one to get \
-them in the generated configuration.'''}),
-
-            ('generate-man',
-             {'action' : 'callback', 'callback' : self.cb_generate_manpage,
-              'group': 'Commands',
-              'help' : "Generate pylint's man page.", 'hide': True}),
-
-            ('errors-only',
-             {'action' : 'callback', 'callback' : self.cb_error_mode,
-              'short': 'E',
-              'help' : '''In error mode, checkers without error messages are \
-disabled and for others, only the ERROR messages are displayed, and no reports \
-are done by default'''}),
-
-            ('profile',
-             {'type' : 'yn', 'metavar' : '<y_or_n>',
-              'default': False, 'hide': True,
-              'help' : 'Profiled execution.'}),
-
-            ), option_groups=self.option_groups, pylintrc=self._rcfile)
-        # register standard checkers
-        linter.load_default_plugins()
-        # load command line plugins
-        linter.load_plugin_modules(self._plugins)
-        # add some help section
-        linter.add_help_section('Environment variables', config.ENV_HELP, level=1)
-        linter.add_help_section('Output',
-'Using the default text output, the message format is :                          \n'
-'                                                                                \n'
-'        MESSAGE_TYPE: LINE_NUM:[OBJECT:] MESSAGE                                \n'
-'                                                                                \n'
-'There are 5 kind of message types :                                             \n'
-'    * (C) convention, for programming standard violation                        \n'
-'    * (R) refactor, for bad code smell                                          \n'
-'    * (W) warning, for python specific problems                                 \n'
-'    * (E) error, for probable bugs in the code                                  \n'
-'    * (F) fatal, if an error occurred which prevented pylint from doing further\n'
-'processing.\n'
-        , level=1)
-        linter.add_help_section('Output status code',
-'Pylint should leave with following status code:                                 \n'
-'    * 0 if everything went fine                                                 \n'
-'    * 1 if a fatal message was issued                                           \n'
-'    * 2 if an error message was issued                                          \n'
-'    * 4 if a warning message was issued                                         \n'
-'    * 8 if a refactor message was issued                                        \n'
-'    * 16 if a convention message was issued                                     \n'
-'    * 32 on usage error                                                         \n'
-'                                                                                \n'
-'status 1 to 16 will be bit-ORed so you can know which different categories has\n'
-'been issued by analysing pylint output status code\n',
-        level=1)
-        # read configuration
-        linter.disable('pointless-except')
-        linter.disable('suppressed-message')
-        linter.disable('useless-suppression')
-        linter.read_config_file()
-        config_parser = linter.cfgfile_parser
-        # run init hook, if present, before loading plugins
-        if config_parser.has_option('MASTER', 'init-hook'):
-            cb_init_hook('init-hook',
-                         unquote(config_parser.get('MASTER', 'init-hook')))
-        # is there some additional plugins in the file configuration, in
-        if config_parser.has_option('MASTER', 'load-plugins'):
-            plugins = splitstrip(config_parser.get('MASTER', 'load-plugins'))
-            linter.load_plugin_modules(plugins)
-        # now we can load file config and command line, plugins (which can
-        # provide options) have been registered
-        linter.load_config_file()
-        if reporter:
-            # if a custom reporter is provided as argument, it may be overridden
-            # by file parameters, so re-set it here, but before command line
-            # parsing so it's still overrideable by command line option
-            linter.set_reporter(reporter)
-        try:
-            args = linter.load_command_line_configuration(args)
-        except SystemExit, exc:
-            if exc.code == 2: # bad options
-                exc.code = 32
-            raise
-        if not args:
-            print linter.help()
-            sys.exit(32)
-        # insert current working directory to the python path to have a correct
-        # behaviour
-        linter.prepare_import_path(args)
-        if self.linter.config.profile:
-            print >> sys.stderr, '** profiled run'
-            import cProfile, pstats
-            cProfile.runctx('linter.check(%r)' % args, globals(), locals(),
-                            'stones.prof')
-            data = pstats.Stats('stones.prof')
-            data.strip_dirs()
-            data.sort_stats('time', 'calls')
-            data.print_stats(30)
-        else:
-            linter.check(args)
-        linter.cleanup_import_path()
-        if exit:
-            sys.exit(self.linter.msg_status)
-
-    def cb_set_rcfile(self, name, value):
-        """callback for option preprocessing (i.e. before option parsing)"""
-        self._rcfile = value
-
-    def cb_add_plugins(self, name, value):
-        """callback for option preprocessing (i.e. before option parsing)"""
-        self._plugins.extend(splitstrip(value))
-
-    def cb_error_mode(self, *args, **kwargs):
-        """error mode:
-        * disable all but error messages
-        * disable the 'miscellaneous' checker which can be safely deactivated in
-          debug
-        * disable reports
-        * do not save execution information
-        """
-        self.linter.error_mode()
-
-    def cb_generate_config(self, *args, **kwargs):
-        """optik callback for sample config file generation"""
-        self.linter.generate_config(skipsections=('COMMANDS',))
-        sys.exit(0)
-
-    def cb_generate_manpage(self, *args, **kwargs):
-        """optik callback for sample config file generation"""
-        from pylint import __pkginfo__
-        self.linter.generate_manpage(__pkginfo__)
-        sys.exit(0)
-
-    def cb_help_message(self, option, optname, value, parser):
-        """optik callback for printing some help about a particular message"""
-        self.linter.help_message(splitstrip(value))
-        sys.exit(0)
-
-    def cb_full_documentation(self, option, optname, value, parser):
-        """optik callback for printing full documentation"""
-        self.linter.print_full_documentation()
-        sys.exit(0)
-
-    def cb_list_messages(self, option, optname, value, parser): # FIXME
-        """optik callback for printing available messages"""
-        self.linter.list_messages()
-        sys.exit(0)
-
-def cb_init_hook(optname, value):
-    """exec arbitrary code to set sys.path for instance"""
-    exec value
-
-
-if __name__ == '__main__':
-    Run(sys.argv[1:])
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/__init__.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/__init__.py
deleted file mode 100644
index a767a052..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/__init__.py
+++ /dev/null
@@ -1,138 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""utilities methods and classes for reporters"""
-
-import sys
-import locale
-import os
-
-from pylint.utils import MSG_TYPES
-
-from pylint import utils
-
-CMPS = ['=', '-', '+']
-
-# py3k has no more cmp builtin
-if sys.version_info >= (3, 0):
-    def cmp(a, b):
-        return (a > b) - (a < b)
-
-if sys.version_info < (2, 6):
-    import stringformat
-    stringformat.init(True)
-
-def diff_string(old, new):
-    """given a old and new int value, return a string representing the
-    difference
-    """
-    diff = abs(old - new)
-    diff_str = "%s%s" % (CMPS[cmp(old, new)], diff and ('%.2f' % diff) or '')
-    return diff_str
-
-
-class Message(object):
-    """This class represent a message to be issued by the reporters"""
-
-    def __init__(self, reporter, msg_id, location, msg):
-        self.msg_id = msg_id
-        self.abspath, self.module, self.obj, self.line, self.column = location
-        self.path = self.abspath.replace(reporter.path_strip_prefix, '')
-        self.msg = msg
-        self.C = msg_id[0]
-        self.category = MSG_TYPES[msg_id[0]]
-        self.symbol = reporter.linter.check_message_id(msg_id).symbol
-
-    def format(self, template):
-        """Format the message according to the given template.
-
-        The template format is the one of the format method :
-        cf. http://docs.python.org/2/library/string.html#formatstrings
-        """
-        return template.format(**(self.__dict__))
-
-
-class BaseReporter(object):
-    """base class for reporters
-
-    symbols: show short symbolic names for messages.
-    """
-
-    extension = ''
-
-    def __init__(self, output=None):
-        self.linter = None
-        # self.include_ids = None # Deprecated
-        # self.symbols = None # Deprecated
-        self.section = 0
-        self.out = None
-        self.out_encoding = None
-        self.encode = None
-        self.set_output(output)
-        # Build the path prefix to strip to get relative paths
-        self.path_strip_prefix = os.getcwd() + os.sep
-
-    def add_message(self, msg_id, location, msg):
-        """Client API to send a message"""
-        # Shall we store the message objects somewhere, do some validity checking ?
-        raise NotImplementedError
-
-    def set_output(self, output=None):
-        """set output stream"""
-        self.out = output or sys.stdout
-        # py3k streams handle their encoding :
-        if sys.version_info >= (3, 0):
-            self.encode = lambda x: x
-            return
-
-        def encode(string):
-            if not isinstance(string, unicode):
-                return string
-            encoding = (getattr(self.out, 'encoding', None) or
-                        locale.getdefaultlocale()[1] or
-                        sys.getdefaultencoding())
-            # errors=replace, we don't want to crash when attempting to show
-            # source code line that can't be encoded with the current locale
-            # settings
-            return string.encode(encoding, 'replace')
-        self.encode = encode
-
-    def writeln(self, string=''):
-        """write a line in the output buffer"""
-        print >> self.out, self.encode(string)
-
-    def display_results(self, layout):
-        """display results encapsulated in the layout tree"""
-        self.section = 0
-        if hasattr(layout, 'report_id'):
-            layout.children[0].children[0].data += ' (%s)' % layout.report_id
-        self._display(layout)
-
-    def _display(self, layout):
-        """display the layout"""
-        raise NotImplementedError()
-
-    # Event callbacks
-
-    def on_set_current_module(self, module, filepath):
-        """starting analyzis of a module"""
-        pass
-
-    def on_close(self, stats, previous_stats):
-        """global end of analyzis"""
-        pass
-
-
-def initialize(linter):
-    """initialize linter with reporters in this package """
-    utils.register_plugins(linter, __path__[0])
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/guireporter.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/guireporter.py
deleted file mode 100644
index 331eb179..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/guireporter.py
+++ /dev/null
@@ -1,28 +0,0 @@
-""" reporter used by gui.py """
-
-import sys
-
-from pylint.interfaces import IReporter
-from pylint.reporters import BaseReporter, Message
-from logilab.common.ureports import TextWriter
-
-
-class GUIReporter(BaseReporter):
-    """saves messages"""
-
-    __implements__ = IReporter
-    extension = ''
-
-    def __init__(self, gui, output=sys.stdout):
-        """init"""
-        BaseReporter.__init__(self, output)
-        self.gui = gui
-
-    def add_message(self, msg_id, location, msg):
-        """manage message of different type and in the context of path"""
-        message = Message(self, msg_id, location, msg)
-        self.gui.msg_queue.put(message)
-
-    def _display(self, layout):
-        """launch layouts display"""
-        TextWriter().format(layout, self.out)
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/html.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/html.py
deleted file mode 100644
index 71d46eba..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/html.py
+++ /dev/null
@@ -1,70 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""HTML reporter"""
-
-import sys
-from cgi import escape
-
-from logilab.common.ureports import HTMLWriter, Section, Table
-
-from pylint.interfaces import IReporter
-from pylint.reporters import BaseReporter, Message
-
-
-class HTMLReporter(BaseReporter):
-    """report messages and layouts in HTML"""
-
-    __implements__ = IReporter
-    name = 'html'
-    extension = 'html'
-
-    def __init__(self, output=sys.stdout):
-        BaseReporter.__init__(self, output)
-        self.msgs = []
-
-    def add_message(self, msg_id, location, msg):
-        """manage message of different type and in the context of path"""
-        msg = Message(self, msg_id, location, msg)
-        self.msgs += (msg.category, msg.module, msg.obj,
-                      str(msg.line), str(msg.column), escape(msg.msg))
-
-    def set_output(self, output=None):
-        """set output stream
-
-        messages buffered for old output is processed first"""
-        if self.out and self.msgs:
-            self._display(Section())
-        BaseReporter.set_output(self, output)
-
-    def _display(self, layout):
-        """launch layouts display
-
-        overridden from BaseReporter to add insert the messages section
-        (in add_message, message is not displayed, just collected so it
-        can be displayed in an html table)
-        """
-        if self.msgs:
-            # add stored messages to the layout
-            msgs = ['type', 'module', 'object', 'line', 'col_offset', 'message']
-            msgs += self.msgs
-            sect = Section('Messages')
-            layout.append(sect)
-            sect.append(Table(cols=6, children=msgs, rheaders=1))
-            self.msgs = []
-        HTMLWriter().format(layout, self.out)
-
-
-def register(linter):
-    """Register the reporter classes with the linter."""
-    linter.register_reporter(HTMLReporter)
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/text.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/text.py
deleted file mode 100644
index bd99837b..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/reporters/text.py
+++ /dev/null
@@ -1,143 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""Plain text reporters:
-
-:text: the default one grouping messages by module
-:colorized: an ANSI colorized text reporter
-"""
-
-import warnings
-
-from logilab.common.ureports import TextWriter
-from logilab.common.textutils import colorize_ansi
-
-from pylint.interfaces import IReporter
-from pylint.reporters import BaseReporter, Message
-
-TITLE_UNDERLINES = ['', '=', '-', '.']
-
-
-class TextReporter(BaseReporter):
-    """reports messages and layouts in plain text"""
-
-    __implements__ = IReporter
-    name = 'text'
-    extension = 'txt'
-    line_format = '{C}:{line:3d},{column:2d}: {msg} ({symbol})'
-
-    def __init__(self, output=None):
-        BaseReporter.__init__(self, output)
-        self._modules = {}
-        self._template = None
-
-    def on_set_current_module(self, module, filepath):
-        self._template = unicode(self.linter.config.msg_template or self.line_format)
-
-    def write_message(self, msg):
-        """Convenience method to write a formated message with class default template"""
-        self.writeln(msg.format(self._template))
-
-    def add_message(self, msg_id, location, msg):
-        """manage message of different type and in the context of path"""
-        m = Message(self, msg_id, location, msg)
-        if m.module not in self._modules:
-            if m.module:
-                self.writeln('************* Module %s' % m.module)
-                self._modules[m.module] = 1
-            else:
-                self.writeln('************* ')
-        self.write_message(m)
-
-    def _display(self, layout):
-        """launch layouts display"""
-        print >> self.out
-        TextWriter().format(layout, self.out)
-
-
-class ParseableTextReporter(TextReporter):
-    """a reporter very similar to TextReporter, but display messages in a form
-    recognized by most text editors :
-
-    <filename>:<linenum>:<msg>
-    """
-    name = 'parseable'
-    line_format = '{path}:{line}: [{msg_id}({symbol}), {obj}] {msg}'
-
-    def __init__(self, output=None):
-        warnings.warn('%s output format is deprecated. This is equivalent '
-                      'to --msg-template=%s' % (self.name, self.line_format))
-        TextReporter.__init__(self, output)
-
-
-class VSTextReporter(ParseableTextReporter):
-    """Visual studio text reporter"""
-    name = 'msvs'
-    line_format = '{path}({line}): [{msg_id}({symbol}){obj}] {msg}'
-
-
-class ColorizedTextReporter(TextReporter):
-    """Simple TextReporter that colorizes text output"""
-
-    name = 'colorized'
-    COLOR_MAPPING = {
-        "I" : ("green", None),
-        'C' : (None, "bold"),
-        'R' : ("magenta", "bold, italic"),
-        'W' : ("blue", None),
-        'E' : ("red", "bold"),
-        'F' : ("red", "bold, underline"),
-        'S' : ("yellow", "inverse"), # S stands for module Separator
-    }
-
-    def __init__(self, output=None, color_mapping=None):
-        TextReporter.__init__(self, output)
-        self.color_mapping = color_mapping or \
-                             dict(ColorizedTextReporter.COLOR_MAPPING)
-
-    def _get_decoration(self, msg_id):
-        """Returns the tuple color, style associated with msg_id as defined
-        in self.color_mapping
-        """
-        try:
-            return self.color_mapping[msg_id[0]]
-        except KeyError:
-            return None, None
-
-    def add_message(self, msg_id, location, msg):
-        """manage message of different types, and colorize output
-        using ansi escape codes
-        """
-        msg = Message(self, msg_id, location, msg)
-        if msg.module not in self._modules:
-            color, style = self._get_decoration('S')
-            if msg.module:
-                modsep = colorize_ansi('************* Module %s' % msg.module,
-                                       color, style)
-            else:
-                modsep = colorize_ansi('************* %s' % msg.module,
-                                       color, style)
-            self.writeln(modsep)
-            self._modules[msg.module] = 1
-        color, style = self._get_decoration(msg.C)
-        for attr in ('msg', 'symbol', 'category', 'C'):
-            setattr(msg, attr, colorize_ansi(getattr(msg, attr), color, style))
-        self.write_message(msg)
-
-
-def register(linter):
-    """Register the reporter classes with the linter."""
-    linter.register_reporter(TextReporter)
-    linter.register_reporter(ParseableTextReporter)
-    linter.register_reporter(VSTextReporter)
-    linter.register_reporter(ColorizedTextReporter)
diff --git a/pymode/libs/pylama/lint/pylama_pylint/pylint/utils.py b/pymode/libs/pylama/lint/pylama_pylint/pylint/utils.py
deleted file mode 100644
index c6a73713..00000000
--- a/pymode/libs/pylama/lint/pylama_pylint/pylint/utils.py
+++ /dev/null
@@ -1,744 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU 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 General Public License for more details
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-"""some various utilities and helper classes, most of them used in the
-main pylint class
-"""
-
-import re
-import sys
-import tokenize
-import os
-from warnings import warn
-from os.path import dirname, basename, splitext, exists, isdir, join, normpath
-
-from logilab.common.interface import implements
-from logilab.common.modutils import modpath_from_file, get_module_files, \
-                                    file_from_modpath, load_module_from_file
-from logilab.common.textutils import normalize_text
-from logilab.common.configuration import rest_format_section
-from logilab.common.ureports import Section
-
-from astroid import nodes, Module
-
-from pylint.interfaces import IRawChecker, ITokenChecker
-
-
-class UnknownMessage(Exception):
-    """raised when a unregistered message id is encountered"""
-
-class EmptyReport(Exception):
-    """raised when a report is empty and so should not be displayed"""
-
-
-MSG_TYPES = {
-    'I' : 'info',
-    'C' : 'convention',
-    'R' : 'refactor',
-    'W' : 'warning',
-    'E' : 'error',
-    'F' : 'fatal'
-    }
-MSG_TYPES_LONG = dict([(v, k) for k, v in MSG_TYPES.iteritems()])
-
-MSG_TYPES_STATUS = {
-    'I' : 0,
-    'C' : 16,
-    'R' : 8,
-    'W' : 4,
-    'E' : 2,
-    'F' : 1
-    }
-
-_MSG_ORDER = 'EWRCIF'
-MSG_STATE_SCOPE_CONFIG = 0
-MSG_STATE_SCOPE_MODULE = 1
-
-OPTION_RGX = re.compile(r'\s*#.*\bpylint:(.*)')
-
-# The line/node distinction does not apply to fatal errors and reports.
-_SCOPE_EXEMPT = 'FR'
-
-class WarningScope(object):
-    LINE = 'line-based-msg'
-    NODE = 'node-based-msg'
-
-
-def get_module_and_frameid(node):
-    """return the module name and the frame id in the module"""
-    frame = node.frame()
-    module, obj = '', []
-    while frame:
-        if isinstance(frame, Module):
-            module = frame.name
-        else:
-            obj.append(getattr(frame, 'name', '<lambda>'))
-        try:
-            frame = frame.parent.frame()
-        except AttributeError:
-            frame = None
-    obj.reverse()
-    return module, '.'.join(obj)
-
-def category_id(id):
-    id = id.upper()
-    if id in MSG_TYPES:
-        return id
-    return MSG_TYPES_LONG.get(id)
-
-
-def tokenize_module(module):
-    stream = module.file_stream
-    stream.seek(0)
-    readline = stream.readline
-    if sys.version_info < (3, 0):
-        if module.file_encoding is not None:
-            readline = lambda: stream.readline().decode(module.file_encoding,
-                                                    'replace')
-        return list(tokenize.generate_tokens(readline))
-    return list(tokenize.tokenize(readline))
-
-def build_message_def(checker, msgid, msg_tuple):
-    if implements(checker, (IRawChecker, ITokenChecker)):
-        default_scope = WarningScope.LINE
-    else:
-        default_scope = WarningScope.NODE
-    options = {}
-    if len(msg_tuple) > 3:
-        (msg, symbol, descr, options) = msg_tuple
-    elif len(msg_tuple) > 2:
-        (msg, symbol, descr) = msg_tuple[:3]
-    else:
-        # messages should have a symbol, but for backward compatibility
-        # they may not.
-        (msg, descr) = msg_tuple
-        warn("[pylint 0.26] description of message %s doesn't include "
-             "a symbolic name" % msgid, DeprecationWarning)
-        symbol = None
-    options.setdefault('scope', default_scope)
-    return MessageDefinition(checker, msgid, msg, descr, symbol, **options)
-
-
-class MessageDefinition(object):
-    def __init__(self, checker, msgid, msg, descr, symbol, scope,
-                 minversion=None, maxversion=None, old_names=None):
-        self.checker = checker
-        assert len(msgid) == 5, 'Invalid message id %s' % msgid
-        assert msgid[0] in MSG_TYPES, \
-               'Bad message type %s in %r' % (msgid[0], msgid)
-        self.msgid = msgid
-        self.msg = msg
-        self.descr = descr
-        self.symbol = symbol
-        self.scope = scope
-        self.minversion = minversion
-        self.maxversion = maxversion
-        self.old_names = old_names or []
-
-    def may_be_emitted(self):
-        """return True if message may be emitted using the current interpreter"""
-        if self.minversion is not None and self.minversion > sys.version_info:
-            return False
-        if self.maxversion is not None and self.maxversion <= sys.version_info:
-            return False
-        return True
-
-    def format_help(self, checkerref=False):
-        """return the help string for the given message id"""
-        desc = self.descr
-        if checkerref:
-            desc += ' This message belongs to the %s checker.' % \
-                   self.checker.name
-        title = self.msg
-        if self.symbol:
-            msgid = '%s (%s)' % (self.symbol, self.msgid)
-        else:
-            msgid = self.msgid
-        if self.minversion or self.maxversion:
-            restr = []
-            if self.minversion:
-                restr.append('< %s' % '.'.join([str(n) for n in self.minversion]))
-            if self.maxversion:
-                restr.append('>= %s' % '.'.join([str(n) for n in self.maxversion]))
-            restr = ' or '.join(restr)
-            if checkerref:
-                desc += " It can't be emitted when using Python %s." % restr
-            else:
-                desc += " This message can't be emitted when using Python %s." % restr
-        desc = normalize_text(' '.join(desc.split()), indent='  ')
-        if title != '%s':
-            title = title.splitlines()[0]
-            return ':%s: *%s*\n%s' % (msgid, title, desc)
-        return ':%s:\n%s' % (msgid, desc)
-
-
-class MessagesHandlerMixIn(object):
-    """a mix-in class containing all the messages related methods for the main
-    lint class
-    """
-
-    def __init__(self):
-        # Primary registry for all active messages (i.e. all messages
-        # that can be emitted by pylint for the underlying Python
-        # version). It contains the 1:1 mapping from symbolic names
-        # to message definition objects.
-        self._messages = {}
-        # Maps alternative names (numeric IDs, deprecated names) to
-        # message definitions. May contain several names for each definition
-        # object.
-        self._alternative_names = {}
-        self._msgs_state = {}
-        self._module_msgs_state = {} # None
-        self._raw_module_msgs_state = {}
-        self._msgs_by_category = {}
-        self.msg_status = 0
-        self._ignored_msgs = {}
-        self._suppression_mapping = {}
-
-    def add_renamed_message(self, old_id, old_symbol, new_symbol):
-        """Register the old ID and symbol for a warning that was renamed.
-
-        This allows users to keep using the old ID/symbol in suppressions.
-        """
-        msg = self.check_message_id(new_symbol)
-        msg.old_names.append((old_id, old_symbol))
-        self._alternative_names[old_id] = msg
-        self._alternative_names[old_symbol] = msg
-
-    def register_messages(self, checker):
-        """register a dictionary of messages
-
-        Keys are message ids, values are a 2-uple with the message type and the
-        message itself
-
-        message ids should be a string of len 4, where the two first characters
-        are the checker id and the two last the message id in this checker
-        """
-        chkid = None
-        for msgid, msg_tuple in checker.msgs.iteritems():
-            msg = build_message_def(checker, msgid, msg_tuple)
-            assert msg.symbol not in self._messages, \
-                    'Message symbol %r is already defined' % msg.symbol
-            # avoid duplicate / malformed ids
-            assert msg.msgid not in self._alternative_names, \
-                   'Message id %r is already defined' % msgid
-            assert chkid is None or chkid == msg.msgid[1:3], \
-                   'Inconsistent checker part in message id %r' % msgid
-            chkid = msg.msgid[1:3]
-            if not msg.may_be_emitted():
-                self._msgs_state[msg.msgid] = False
-            self._messages[msg.symbol] = msg
-            self._alternative_names[msg.msgid] = msg
-            for old_id, old_symbol in msg.old_names:
-                self._alternative_names[old_id] = msg
-                self._alternative_names[old_symbol] = msg
-            self._msgs_by_category.setdefault(msg.msgid[0], []).append(msg.msgid)
-
-    def disable(self, msgid, scope='package', line=None, ignore_unknown=False):
-        """don't output message of the given id"""
-        assert scope in ('package', 'module')
-        # handle disable=all by disabling all categories
-        if msgid == 'all':
-            for msgid in MSG_TYPES:
-                self.disable(msgid, scope, line)
-            return
-        # msgid is a category?
-        catid = category_id(msgid)
-        if catid is not None:
-            for _msgid in self._msgs_by_category.get(catid):
-                self.disable(_msgid, scope, line)
-            return
-        # msgid is a checker name?
-        if msgid.lower() in self._checkers:
-            for checker in self._checkers[msgid.lower()]:
-                for _msgid in checker.msgs:
-                    if _msgid in self._alternative_names:
-                        self.disable(_msgid, scope, line)
-            return
-        # msgid is report id?
-        if msgid.lower().startswith('rp'):
-            self.disable_report(msgid)
-            return
-
-        try:
-            # msgid is a symbolic or numeric msgid.
-            msg = self.check_message_id(msgid)
-        except UnknownMessage:
-            if ignore_unknown:
-                return
-            raise
-
-        if scope == 'module':
-            assert line > 0
-            try:
-                self._module_msgs_state[msg.msgid][line] = False
-            except KeyError:
-                self._module_msgs_state[msg.msgid] = {line: False}
-                if msg.symbol != 'locally-disabled':
-                    self.add_message('locally-disabled', line=line, 
-                                     args=(msg.symbol, msg.msgid))
-
-        else:
-            msgs = self._msgs_state
-            msgs[msg.msgid] = False
-            # sync configuration object
-            self.config.disable_msg = [mid for mid, val in msgs.iteritems()
-                                       if not val]
-
-    def enable(self, msgid, scope='package', line=None, ignore_unknown=False):
-        """reenable message of the given id"""
-        assert scope in ('package', 'module')
-        catid = category_id(msgid)
-        # msgid is a category?
-        if catid is not None:
-            for msgid in self._msgs_by_category.get(catid):
-                self.enable(msgid, scope, line)
-            return
-        # msgid is a checker name?
-        if msgid.lower() in self._checkers:
-            for checker in self._checkers[msgid.lower()]:
-                for msgid_ in checker.msgs:
-                    self.enable(msgid_, scope, line)
-            return
-        # msgid is report id?
-        if msgid.lower().startswith('rp'):
-            self.enable_report(msgid)
-            return
-
-        try:
-            # msgid is a symbolic or numeric msgid.
-            msg = self.check_message_id(msgid)
-        except UnknownMessage:
-            if ignore_unknown:
-                return
-            raise
-
-        if scope == 'module':
-            assert line > 0
-            try:
-                self._module_msgs_state[msg.msgid][line] = True
-            except KeyError:
-                self._module_msgs_state[msg.msgid] = {line: True}
-                self.add_message('locally-enabled', line=line, args=(msg.symbol, msg.msgid))
-        else:
-            msgs = self._msgs_state
-            msgs[msg.msgid] = True
-            # sync configuration object
-            self.config.enable = [mid for mid, val in msgs.iteritems() if val]
-
-    def check_message_id(self, msgid):
-        """returns the Message object for this message.
-
-        msgid may be either a numeric or symbolic id.
-
-        Raises UnknownMessage if the message id is not defined.
-        """
-        if msgid[1:].isdigit():
-            msgid = msgid.upper()
-        for source in (self._alternative_names, self._messages):
-            try:
-                return source[msgid]
-            except KeyError:
-                pass
-        raise UnknownMessage('No such message id %s' % msgid)
-
-    def get_msg_display_string(self, msgid):
-        """Generates a user-consumable representation of a message.
-
-        Can be just the message ID or the ID and the symbol.
-        """
-        return repr(self.check_message_id(msgid).symbol)
-
-    def get_message_state_scope(self, msgid, line=None):
-        """Returns the scope at which a message was enabled/disabled."""
-        try:
-            if line in self._module_msgs_state[msgid]:
-                return MSG_STATE_SCOPE_MODULE
-        except (KeyError, TypeError):
-            return MSG_STATE_SCOPE_CONFIG
-
-    def is_message_enabled(self, msg_descr, line=None):
-        """return true if the message associated to the given message id is
-        enabled
-
-        msgid may be either a numeric or symbolic message id.
-        """
-        try:
-            msgid = self.check_message_id(msg_descr).msgid
-        except UnknownMessage:
-            # The linter checks for messages that are not registered
-            # due to version mismatch, just treat them as message IDs
-            # for now.
-            msgid = msg_descr
-        if line is None:
-            return self._msgs_state.get(msgid, True)
-        try:
-            return self._module_msgs_state[msgid][line]
-        except (KeyError, TypeError):
-            return self._msgs_state.get(msgid, True)
-
-    def handle_ignored_message(self, state_scope, msgid, line, node, args):
-        """Report an ignored message.
-
-        state_scope is either MSG_STATE_SCOPE_MODULE or MSG_STATE_SCOPE_CONFIG,
-        depending on whether the message was disabled locally in the module,
-        or globally. The other arguments are the same as for add_message.
-        """
-        if state_scope == MSG_STATE_SCOPE_MODULE:
-            try:
-                orig_line = self._suppression_mapping[(msgid, line)]
-                self._ignored_msgs.setdefault((msgid, orig_line), set()).add(line)
-            except KeyError:
-                pass
-
-    def add_message(self, msg_descr, line=None, node=None, args=None):
-        """Adds a message given by ID or name.
-
-        If provided, the message string is expanded using args
-
-        AST checkers should must the node argument (but may optionally
-        provide line if the line number is different), raw and token checkers
-        must provide the line argument.
-        """
-        msg_info = self.check_message_id(msg_descr)
-        msgid = msg_info.msgid
-        # backward compatibility, message may not have a symbol
-        symbol = msg_info.symbol or msgid
-        # Fatal messages and reports are special, the node/scope distinction
-        # does not apply to them.
-        if msgid[0] not in _SCOPE_EXEMPT:
-            if msg_info.scope == WarningScope.LINE:
-                assert node is None and line is not None, (
-                    'Message %s must only provide line, got line=%s, node=%s' % (msgid, line, node))
-            elif msg_info.scope == WarningScope.NODE:
-                # Node-based warnings may provide an override line.
-                assert node is not None, 'Message %s must provide Node, got None'
-
-        if line is None and node is not None:
-            line = node.fromlineno
-        if hasattr(node, 'col_offset'):
-            col_offset = node.col_offset # XXX measured in bytes for utf-8, divide by two for chars?
-        else:
-            col_offset = None
-        # should this message be displayed
-        if not self.is_message_enabled(msgid, line):
-            self.handle_ignored_message(
-                self.get_message_state_scope(msgid, line), msgid, line, node, args)
-            return
-        # update stats
-        msg_cat = MSG_TYPES[msgid[0]]
-        self.msg_status |= MSG_TYPES_STATUS[msgid[0]]
-        self.stats[msg_cat] += 1
-        self.stats['by_module'][self.current_name][msg_cat] += 1
-        try:
-            self.stats['by_msg'][symbol] += 1
-        except KeyError:
-            self.stats['by_msg'][symbol] = 1
-        # expand message ?
-        msg = msg_info.msg
-        if args:
-            msg %= args
-        # get module and object
-        if node is None:
-            module, obj = self.current_name, ''
-            path = self.current_file
-        else:
-            module, obj = get_module_and_frameid(node)
-            path = node.root().file
-        # add the message
-        self.reporter.add_message(msgid, (path, module, obj, line or 1, col_offset or 0), msg)
-
-    def help_message(self, msgids):
-        """display help messages for the given message identifiers"""
-        for msgid in msgids:
-            try:
-                print self.check_message_id(msgid).format_help(checkerref=True)
-                print
-            except UnknownMessage, ex:
-                print ex
-                print
-                continue
-
-    def print_full_documentation(self):
-        """output a full documentation in ReST format"""
-        by_checker = {}
-        for checker in self.get_checkers():
-            if checker.name == 'master':
-                prefix = 'Main '
-                print "Options"
-                print '-------\n'
-                if checker.options:
-                    for section, options in checker.options_by_section():
-                        if section is None:
-                            title = 'General options'
-                        else:
-                            title = '%s options' % section.capitalize()
-                        print title
-                        print '~' * len(title)
-                        rest_format_section(sys.stdout, None, options)
-                        print
-            else:
-                try:
-                    by_checker[checker.name][0] += checker.options_and_values()
-                    by_checker[checker.name][1].update(checker.msgs)
-                    by_checker[checker.name][2] += checker.reports
-                except KeyError:
-                    by_checker[checker.name] = [list(checker.options_and_values()),
-                                                dict(checker.msgs),
-                                                list(checker.reports)]
-        for checker, (options, msgs, reports) in by_checker.iteritems():
-            prefix = ''
-            title = '%s checker' % checker
-            print title
-            print '-' * len(title)
-            print
-            if options:
-                title = 'Options'
-                print title
-                print '~' * len(title)
-                rest_format_section(sys.stdout, None, options)
-                print
-            if msgs:
-                title = ('%smessages' % prefix).capitalize()
-                print title
-                print '~' * len(title)
-                for msgid, msg in sorted(msgs.iteritems(),
-                                         key=lambda (k, v): (_MSG_ORDER.index(k[0]), k)):
-                    msg = build_message_def(checker, msgid, msg)
-                    print msg.format_help(checkerref=False)
-                print
-            if reports:
-                title = ('%sreports' % prefix).capitalize()
-                print title
-                print '~' * len(title)
-                for report in reports:
-                    print ':%s: %s' % report[:2]
-                print
-            print
-
-    @property
-    def messages(self):
-        """The list of all active messages."""
-        return self._messages.itervalues()
-
-    def list_messages(self):
-        """output full messages list documentation in ReST format"""
-        msgs = sorted(self._messages.itervalues(), key=lambda msg: msg.msgid)
-        for msg in msgs:
-            if not msg.may_be_emitted():
-                continue
-            print msg.format_help(checkerref=False)
-        print
-
-
-class ReportsHandlerMixIn(object):
-    """a mix-in class containing all the reports and stats manipulation
-    related methods for the main lint class
-    """
-    def __init__(self):
-        self._reports = {}
-        self._reports_state = {}
-
-    def register_report(self, reportid, r_title, r_cb, checker):
-        """register a report
-
-        reportid is the unique identifier for the report
-        r_title the report's title
-        r_cb the method to call to make the report
-        checker is the checker defining the report
-        """
-        reportid = reportid.upper()
-        self._reports.setdefault(checker, []).append((reportid, r_title, r_cb))
-
-    def enable_report(self, reportid):
-        """disable the report of the given id"""
-        reportid = reportid.upper()
-        self._reports_state[reportid] = True
-
-    def disable_report(self, reportid):
-        """disable the report of the given id"""
-        reportid = reportid.upper()
-        self._reports_state[reportid] = False
-
-    def report_is_enabled(self, reportid):
-        """return true if the report associated to the given identifier is
-        enabled
-        """
-        return self._reports_state.get(reportid, True)
-
-    def make_reports(self, stats, old_stats):
-        """render registered reports"""
-        sect = Section('Report',
-                       '%s statements analysed.'% (self.stats['statement']))
-        for checker in self._reports:
-            for reportid, r_title, r_cb in self._reports[checker]:
-                if not self.report_is_enabled(reportid):
-                    continue
-                report_sect = Section(r_title)
-                try:
-                    r_cb(report_sect, stats, old_stats)
-                except EmptyReport:
-                    continue
-                report_sect.report_id = reportid
-                sect.append(report_sect)
-        return sect
-
-    def add_stats(self, **kwargs):
-        """add some stats entries to the statistic dictionary
-        raise an AssertionError if there is a key conflict
-        """
-        for key, value in kwargs.iteritems():
-            if key[-1] == '_':
-                key = key[:-1]
-            assert key not in self.stats
-            self.stats[key] = value
-        return self.stats
-
-
-def expand_modules(files_or_modules, black_list):
-    """take a list of files/modules/packages and return the list of tuple
-    (file, module name) which have to be actually checked
-    """
-    result = []
-    errors = []
-    for something in files_or_modules:
-        if exists(something):
-            # this is a file or a directory
-            try:
-                modname = '.'.join(modpath_from_file(something))
-            except ImportError:
-                modname = splitext(basename(something))[0]
-            if isdir(something):
-                filepath = join(something, '__init__.py')
-            else:
-                filepath = something
-        else:
-            # suppose it's a module or package
-            modname = something
-            try:
-                filepath = file_from_modpath(modname.split('.'))
-                if filepath is None:
-                    errors.append({'key' : 'ignored-builtin-module', 'mod': modname})
-                    continue
-            except (ImportError, SyntaxError), ex:
-                # FIXME p3k : the SyntaxError is a Python bug and should be
-                # removed as soon as possible http://bugs.python.org/issue10588
-                errors.append({'key': 'fatal', 'mod': modname, 'ex': ex})
-                continue
-        filepath = normpath(filepath)
-        result.append({'path': filepath, 'name': modname, 'isarg': True,
-                       'basepath': filepath, 'basename': modname})
-        if not (modname.endswith('.__init__') or modname == '__init__') \
-                and '__init__.py' in filepath:
-            for subfilepath in get_module_files(dirname(filepath), black_list):
-                if filepath == subfilepath:
-                    continue
-                submodname = '.'.join(modpath_from_file(subfilepath))
-                result.append({'path': subfilepath, 'name': submodname,
-                               'isarg': False,
-                               'basepath': filepath, 'basename': modname})
-    return result, errors
-
-
-class PyLintASTWalker(object):
-
-    def __init__(self, linter):
-        # callbacks per node types
-        self.nbstatements = 1
-        self.visit_events = {}
-        self.leave_events = {}
-        self.linter = linter
-
-    def _is_method_enabled(self, method):
-        if not hasattr(method, 'checks_msgs'):
-            return True
-        for msg_desc in method.checks_msgs:
-            if self.linter.is_message_enabled(msg_desc):
-                return True
-        return False
-
-    def add_checker(self, checker):
-        """walk to the checker's dir and collect visit and leave methods"""
-        # XXX : should be possible to merge needed_checkers and add_checker
-        vcids = set()
-        lcids = set()
-        visits = self.visit_events
-        leaves = self.leave_events
-        for member in dir(checker):
-            cid = member[6:]
-            if cid == 'default':
-                continue
-            if member.startswith('visit_'):
-                v_meth = getattr(checker, member)
-                # don't use visit_methods with no activated message:
-                if self._is_method_enabled(v_meth):
-                    visits.setdefault(cid, []).append(v_meth)
-                    vcids.add(cid)
-            elif member.startswith('leave_'):
-                l_meth = getattr(checker, member)
-                # don't use leave_methods with no activated message:
-                if self._is_method_enabled(l_meth):
-                    leaves.setdefault(cid, []).append(l_meth)
-                    lcids.add(cid)
-        visit_default = getattr(checker, 'visit_default', None)
-        if visit_default:
-            for cls in nodes.ALL_NODE_CLASSES:
-                cid = cls.__name__.lower()
-                if cid not in vcids:
-                    visits.setdefault(cid, []).append(visit_default)
-        # for now we have no "leave_default" method in Pylint
-
-    def walk(self, astroid):
-        """call visit events of astroid checkers for the given node, recurse on
-        its children, then leave events.
-        """
-        cid = astroid.__class__.__name__.lower()
-        if astroid.is_statement:
-            self.nbstatements += 1
-        # generate events for this node on each checker
-        for cb in self.visit_events.get(cid, ()):
-            cb(astroid)
-        # recurse on children
-        for child in astroid.get_children():
-            self.walk(child)
-        for cb in self.leave_events.get(cid, ()):
-            cb(astroid)
-
-
-PY_EXTS = ('.py', '.pyc', '.pyo', '.pyw', '.so', '.dll')
-
-def register_plugins(linter, directory):
-    """load all module and package in the given directory, looking for a
-    'register' function in each one, used to register pylint checkers
-    """
-    imported = {}
-    for filename in os.listdir(directory):
-        base, extension = splitext(filename)
-        if base in imported or base == '__pycache__':
-            continue
-        if extension in PY_EXTS and base != '__init__' or (
-             not extension and isdir(join(directory, base))):
-            try:
-                module = load_module_from_file(join(directory, filename))
-            except ValueError:
-                # empty module name (usually emacs auto-save files)
-                continue
-            except ImportError, exc:
-                print >> sys.stderr, "Problem importing module %s: %s" % (filename, exc)
-            else:
-                if hasattr(module, 'register'):
-                    module.register(linter)
-                    imported[base] = 1
-
diff --git a/pymode/libs/pylama/main.py b/pymode/libs/pylama/main.py
index 9ce91c37..cabc3595 100644
--- a/pymode/libs/pylama/main.py
+++ b/pymode/libs/pylama/main.py
@@ -6,7 +6,54 @@
 from os import walk, path as op
 
 from .config import parse_options, CURDIR, setup_logger
-from .core import LOGGER
+from .core import LOGGER, run
+from .async import check_async
+
+
+def check_path(options, rootdir=None, candidates=None):
+    """ Check path.
+
+    :param path: Path to file or directory for code checking.
+    :param rootdir: Root directory (for making relative file paths)
+    :param options: Parsed pylama options (from pylama.config.parse_options)
+
+    :returns: (list) Errors list
+
+    """
+    if not candidates:
+        candidates = []
+        path = op.abspath(options.path)
+        if op.isdir(options.path):
+            for root, _, files in walk(options.path):
+                candidates += [op.relpath(op.join(root, f), CURDIR) for f in files]
+        else:
+            candidates.append(options.path)
+
+    if rootdir is None:
+        rootdir = path if op.isdir(path) else op.dirname(path)
+
+    paths = []
+    for path in candidates:
+
+        if not options.force and not any(l.allow(path) for _, l in options.linters): # noqa
+            continue
+
+        if not op.exists(path):
+            continue
+
+        if options.skip and any(p.match(path) for p in options.skip):
+            LOGGER.info('Skip path: %s', path)
+            continue
+
+        paths.append(path)
+
+    if options.async:
+        return check_async(paths, options, rootdir)
+
+    errors = []
+    for path in paths:
+        errors += run(path=path, rootdir=rootdir, options=options)
+    return errors
 
 
 def shell(args=None, error=True):
@@ -30,47 +77,15 @@ def shell(args=None, error=True):
         from .hook import install_hook
         return install_hook(options.path)
 
-    paths = [options.path]
+    return process_paths(options, error=error)
 
-    if op.isdir(options.path):
-        paths = []
-        for root, _, files in walk(options.path):
-            paths += [op.relpath(op.join(root, f), CURDIR) for f in files]
 
-    return check_files(paths, options, error=error)
-
-
-def check_files(paths, options, rootpath=None, error=True):
-    """ Check files.
-
-    :return list: list of errors
-    :raise SystemExit:
-
-    """
-    from .tasks import async_check_files
-
-    if rootpath is None:
-        rootpath = CURDIR
-
-    pattern = "%(rel)s:%(lnum)s:%(col)s: %(text)s"
+def process_paths(options, candidates=None, error=True):
+    """ Process files and log errors. """
+    errors = check_path(options, rootdir=CURDIR, candidates=candidates)
+    pattern = "%(filename)s:%(lnum)s:%(col)s: %(text)s"
     if options.format == 'pylint':
-        pattern = "%(rel)s:%(lnum)s: [%(type)s] %(text)s"
-
-    work_paths = []
-    for path in paths:
-
-        if not options.force and not any(l.allow(path) for _, l in options.linters): # noqa
-            continue
-
-        if not op.exists(path):
-            continue
-
-        if options.skip and any(p.match(path) for p in options.skip):
-            LOGGER.info('Skip path: %s', path)
-            continue
-        work_paths.append(path)
-
-    errors = async_check_files(work_paths, options, rootpath=rootpath)
+        pattern = "%(filename)s:%(lnum)s: [%(type)s] %(text)s"
 
     for er in errors:
         LOGGER.warning(pattern, er._info)
diff --git a/pymode/libs/pylama/pytest.py b/pymode/libs/pylama/pytest.py
index cbfe787d..44916788 100644
--- a/pymode/libs/pylama/pytest.py
+++ b/pymode/libs/pylama/pytest.py
@@ -76,11 +76,11 @@ def repr_failure(self, excinfo):
 
 
 def check_file(path):
-    from pylama.main import parse_options, check_files
+    from pylama.main import parse_options, process_paths
     from pylama.config import CURDIR
 
     options = parse_options()
     path = op.relpath(str(path), CURDIR)
-    return check_files([path], options, error=False)
+    return process_paths(options, candidates=[path], error=False)
 
 # pylama:ignore=D,E1002,W0212