1 files changed, 104 insertions, 0 deletions
diff --git a/astroid/brain/brain_multiprocessing.py b/astroid/brain/brain_multiprocessing.py
new file mode 100644
index 00000000..d0fb0724
--- /dev/null
+++ b/astroid/brain/brain_multiprocessing.py
@@ -0,0 +1,104 @@
+
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/master/COPYING.LESSER
+
+import sys
+
+import astroid
+from astroid import exceptions
+from astroid.interpreter import objects
+from astroid.tree.node_classes import InterpreterObject
+
+
+PY34 = sys.version_info[:2] >= (3, 4)
+
+
+def _multiprocessing_transform():
+    module = astroid.parse('''
+    from multiprocessing.managers import SyncManager
+    def Manager():
+        return SyncManager()
+    ''')
+    if not PY34:
+        return module
+
+    # On Python 3.4, multiprocessing uses a getattr lookup inside contexts,
+    # in order to get the attributes they need. Since it's extremely
+    # dynamic, we use this approach to fake it.
+    node = astroid.parse('''
+    from multiprocessing.context import DefaultContext, BaseContext
+    default = DefaultContext()
+    base = BaseContext()
+    ''')
+    try:
+        context = next(node['default'].infer())
+        base = next(node['base'].infer())
+    except exceptions.InferenceError:
+        return module
+
+    for node in (context, base):
+        for key, value in node.locals.items():
+            if key.startswith("_"):
+                continue
+
+            value = value[0]
+            if isinstance(value, astroid.FunctionDef):
+                # We need to rebind this, since otherwise
+                # it will have an extra argument (self).
+                value = objects.BoundMethod(value, node)
+            module.body.append(InterpreterObject(object_=value, name=key, parent=module))
+    return module
+
+
+def _multiprocessing_managers_transform():
+    return astroid.parse('''
+    import array
+    import threading
+    import multiprocessing.pool as pool
+
+    import six
+
+    class Namespace(object):
+        pass
+
+    class Value(object):
+        def __init__(self, typecode, value, lock=True):
+            self._typecode = typecode
+            self._value = value
+        def get(self):
+            return self._value
+        def set(self, value):
+            self._value = value
+        def __repr__(self):
+            return '%s(%r, %r)'%(type(self).__name__, self._typecode, self._value)
+        value = property(get, set)
+
+    def Array(typecode, sequence, lock=True):
+        return array.array(typecode, sequence)
+
+    class SyncManager(object):
+        Queue = JoinableQueue = six.moves.queue.Queue
+        Event = threading.Event
+        RLock = threading.RLock
+        BoundedSemaphore = threading.BoundedSemaphore
+        Condition = threading.Condition
+        Barrier = threading.Barrier
+        Pool = pool.Pool
+        list = list
+        dict = dict
+        Value = Value
+        Array = Array
+        Namespace = Namespace
+        __enter__ = lambda self: self
+        __exit__ = lambda *args: args
+        
+        def start(self, initializer=None, initargs=None):
+            pass
+        def shutdown(self):
+            pass
+    ''')
+
+
+astroid.register_module_extender(astroid.MANAGER, 'multiprocessing', _multiprocessing_transform)
+astroid.register_module_extender(astroid.MANAGER, 'multiprocessing.managers',
+                                 _multiprocessing_managers_transform)