Revert "pylint: upgrade to 1.3.1"

third_party/logilab/astroid/brain/py2stdlib.py

Index: third_party/logilab/astroid/brain/py2stdlib.py
diff --git a/third_party/logilab/astroid/brain/py2stdlib.py b/third_party/logilab/astroid/brain/py2stdlib.py
deleted file mode 100644
index 2ead081b1e78b18441c25fb94258878bd65a679c..0000000000000000000000000000000000000000
--- a/third_party/logilab/astroid/brain/py2stdlib.py
+++ /dev/null
@@ -1,331 +0,0 @@
-"""Astroid hooks for the Python 2 standard library.
-
-Currently help understanding of :
-
-* hashlib.md5 and hashlib.sha1
-"""
-
-import sys
-from textwrap import dedent
-
-from astroid import (
-    MANAGER, AsStringRegexpPredicate,
-    UseInferenceDefault, inference_tip,
-    YES, InferenceError)
-from astroid import exceptions
-from astroid import nodes
-from astroid.builder import AstroidBuilder
-
-MODULE_TRANSFORMS = {}
-PY3K = sys.version_info > (3, 0)
-PY33 = sys.version_info >= (3, 3)
-
-# general function
-
-def infer_func_form(node, base_type, context=None, enum=False):
-    """Specific inference function for namedtuple or Python 3 enum. """
-    def infer_first(node):
-        try:
-            value = node.infer(context=context).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 or enums 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.replace(',', ' ').split()
-        except AttributeError:
-            if not enum:
-                attributes = [infer_first(const).value for const in names.elts]
-            else:
-                # Enums supports either iterator of (name, value) pairs
-                # or mappings.
-                # TODO: support only list, tuples and mappings.
-                if hasattr(names, 'items') and isinstance(names.items, list):
-                    attributes = [infer_first(const[0]).value
-                                  for const in names.items
-                                  if isinstance(const[0], nodes.Const)]
-                elif hasattr(names, 'elts'):
-                    # Enums can support either ["a", "b", "c"]
-                    # or [("a", 1), ("b", 2), ...], but they can't
-                    # be mixed.
-                    if all(isinstance(const, nodes.Tuple)
-                           for const in names.elts):
-                        attributes = [infer_first(const.elts[0]).value
-                                      for const in names.elts
-                                      if isinstance(const, nodes.Tuple)]
-                    else:
-                        attributes = [infer_first(const).value
-                                      for const in names.elts]
-                else:
-                    raise AttributeError
-                if not attributes:
-                    raise AttributeError
-    except (AttributeError, exceptions.InferenceError) as exc:
-        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(base_type)
-    # 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]
-    return class_node, name, attributes
-
-
-# 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__(self, 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 subprocess_transform(module):
-    if PY3K:
-        communicate = (bytes('string', 'ascii'), bytes('string', 'ascii'))
-        init = """
-    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, restore_signals=True,
-                 start_new_session=False, pass_fds=()):
-        pass
-        """
-    else:
-        communicate = ('string', 'string')
-        init = """
-    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
-        """
-    if PY33:
-        wait_signature = 'def wait(self, timeout=None)'
-    else:
-        wait_signature = 'def wait(self)'
-    fake = AstroidBuilder(MANAGER).string_build('''
-
-class Popen(object):
-    returncode = pid = 0
-    stdin = stdout = stderr = file()
-
-    %(init)s
-
-    def communicate(self, input=None):
-        return %(communicate)r
-    %(wait_signature)s:
-        return self.returncode
-    def poll(self):
-        return self.returncode
-    def send_signal(self, signal):
-        pass
-    def terminate(self):
-        pass
-    def kill(self):
-        pass
-   ''' % {'init': init,
-          'communicate': communicate,
-          'wait_signature': wait_signature})
-
-    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['subprocess'] = subprocess_transform
-
-# namedtuple support ###########################################################
-
-def infer_named_tuple(node, context=None):
-    """Specific inference function for namedtuple CallFunc node"""
-    class_node, name, attributes = infer_func_form(node, nodes.Tuple._proxied,
-                                                   context=context)
-    fake = AstroidBuilder(MANAGER).string_build('''
-class %(name)s(tuple):
-    _fields = %(fields)r
-    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']
-    class_node.locals['_fields'] = fake.body[0].locals['_fields']
-    # we use UseInferenceDefault, we can't be a generator so return an iterator
-    return iter([class_node])
-
-def infer_enum(node, context=None):
-    """ Specific inference function for enum CallFunc node. """
-    enum_meta = nodes.Class("EnumMeta", 'docstring')
-    class_node = infer_func_form(node, enum_meta,
-                                 context=context, enum=True)[0]
-    return iter([class_node.instanciate_class()])
-
-def infer_enum_class(node, context=None):
-    """ Specific inference for enums. """
-    names = set(('Enum', 'IntEnum', 'enum.Enum', 'enum.IntEnum'))
-    for basename in node.basenames:
-        # TODO: doesn't handle subclasses yet.
-        if basename not in names:
-            continue
-        if node.root().name == 'enum':
-            # Skip if the class is directly from enum module.
-            break
-        for local, values in node.locals.items():
-            if any(not isinstance(value, nodes.AssName)
-                   for value in values):
-                continue
-            parent = values[0].parent
-            real_value = parent.value
-            new_targets = []
-            for target in parent.targets:
-                # Replace all the assignments with our mocked class.
-                classdef = dedent('''
-                class %(name)s(object):
-                    @property
-                    def value(self):
-                        return %(value)s
-                    @property
-                    def name(self):
-                        return %(name)r
-                    %(name)s = %(value)s
-                ''' % {'name': target.name,
-                       'value': real_value.as_string()})
-                fake = AstroidBuilder(MANAGER).string_build(classdef)[target.name]
-                fake.parent = target.parent
-                for method in node.mymethods():
-                    fake.locals[method.name] = [method]
-                new_targets.append(fake.instanciate_class())
-            node.locals[local] = new_targets
-        break
-    return node
-
-MANAGER.register_transform(nodes.CallFunc, inference_tip(infer_named_tuple),
-                           AsStringRegexpPredicate('namedtuple', 'func'))
-MANAGER.register_transform(nodes.CallFunc, inference_tip(infer_enum),
-                           AsStringRegexpPredicate('Enum', 'func'))
-MANAGER.register_transform(nodes.Class, infer_enum_class)