add the multiprocessing package to fulfill PEP 371

1 files changed, 269 insertions, 0 deletions

diff --git a/Lib/multiprocessing/__init__.py b/Lib/multiprocessing/__init__.py
new file mode 100644
index 0000000..5352be0
--- /dev/null
+++ b/Lib/multiprocessing/__init__.py
@@ -0,0 +1,269 @@
+#

+# Package analogous to 'threading.py' but using processes

+#

+# multiprocessing/__init__.py

+#

+# This package is intended to duplicate the functionality (and much of

+# the API) of threading.py but uses processes instead of threads.  A

+# subpackage 'multiprocessing.dummy' has the same API but is a simple

+# wrapper for 'threading'.

+#

+# Try calling `multiprocessing.doc.main()` to read the html

+# documentation in in a webbrowser.

+#

+#

+# Copyright (c) 2006-2008, R Oudkerk

+# All rights reserved.

+#

+# Redistribution and use in source and binary forms, with or without

+# modification, are permitted provided that the following conditions

+# are met:

+#

+# 1. Redistributions of source code must retain the above copyright

+#    notice, this list of conditions and the following disclaimer.

+# 2. Redistributions in binary form must reproduce the above copyright

+#    notice, this list of conditions and the following disclaimer in the

+#    documentation and/or other materials provided with the distribution.

+# 3. Neither the name of author nor the names of any contributors may be

+#    used to endorse or promote products derived from this software

+#    without specific prior written permission.

+#

+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND

+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

+# ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

+# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

+#

+

+__version__ = '0.70a1'

+

+__all__ = [

+    'Process', 'current_process', 'active_children', 'freeze_support',

+    'Manager', 'Pipe', 'cpu_count', 'log_to_stderr', 'get_logger',

+    'allow_connection_pickling', 'BufferTooShort', 'TimeoutError',

+    'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Condition',

+    'Event', 'Queue', 'JoinableQueue', 'Pool', 'Value', 'Array',

+    'RawValue', 'RawArray'

+    ]

+

+__author__ = 'R. Oudkerk (r.m.oudkerk@gmail.com)'

+

+#

+# Imports

+#

+

+import os

+import sys

+

+import _multiprocessing

+from multiprocessing.process import Process, current_process, active_children

+

+#

+# Exceptions

+#

+

+class ProcessError(Exception):

+    pass

+    

+class BufferTooShort(ProcessError):

+    pass

+    

+class TimeoutError(ProcessError):

+    pass

+

+class AuthenticationError(ProcessError):

+    pass

+

+#

+# Definitions not depending on native semaphores

+#

+

+def Manager():

+    '''

+    Returns a manager associated with a running server process

+

+    The managers methods such as `Lock()`, `Condition()` and `Queue()`

+    can be used to create shared objects.

+    '''

+    from multiprocessing.managers import SyncManager

+    m = SyncManager()

+    m.start()

+    return m

+

+def Pipe(duplex=True):

+    '''

+    Returns two connection object connected by a pipe

+    '''

+    from multiprocessing.connection import Pipe

+    return Pipe(duplex)

+

+def cpu_count():

+    '''

+    Returns the number of CPUs in the system

+    '''

+    if sys.platform == 'win32':

+        try:

+            num = int(os.environ['NUMBER_OF_PROCESSORS'])

+        except (ValueError, KeyError):

+            num = 0

+    elif sys.platform == 'darwin':

+        try:

+            num = int(os.popen('sysctl -n hw.ncpu').read())

+        except ValueError:

+            num = 0

+    else:

+        try:

+            num = os.sysconf('SC_NPROCESSORS_ONLN')

+        except (ValueError, OSError, AttributeError):

+            num = 0

+        

+    if num >= 1:

+        return num

+    else:

+        raise NotImplementedError('cannot determine number of cpus')

+

+def freeze_support():

+    '''

+    Check whether this is a fake forked process in a frozen executable.

+    If so then run code specified by commandline and exit.

+    '''

+    if sys.platform == 'win32' and getattr(sys, 'frozen', False):

+        from multiprocessing.forking import freeze_support

+        freeze_support()

+

+def get_logger():

+    '''

+    Return package logger -- if it does not already exist then it is created

+    '''

+    from multiprocessing.util import get_logger

+    return get_logger()

+

+def log_to_stderr(level=None):

+    '''

+    Turn on logging and add a handler which prints to stderr

+    '''

+    from multiprocessing.util import log_to_stderr

+    return log_to_stderr(level)

+    

+def allow_connection_pickling():

+    '''

+    Install support for sending connections and sockets between processes

+    '''

+    from multiprocessing import reduction

+    

+#

+# Definitions depending on native semaphores

+#

+

+def Lock():

+    '''

+    Returns a non-recursive lock object

+    '''

+    from multiprocessing.synchronize import Lock

+    return Lock()

+

+def RLock():

+    '''

+    Returns a recursive lock object

+    '''

+    from multiprocessing.synchronize import RLock

+    return RLock()

+

+def Condition(lock=None):

+    '''

+    Returns a condition object

+    '''

+    from multiprocessing.synchronize import Condition

+    return Condition(lock)

+

+def Semaphore(value=1):

+    '''

+    Returns a semaphore object

+    '''

+    from multiprocessing.synchronize import Semaphore

+    return Semaphore(value)

+

+def BoundedSemaphore(value=1):

+    '''

+    Returns a bounded semaphore object

+    '''

+    from multiprocessing.synchronize import BoundedSemaphore

+    return BoundedSemaphore(value)

+

+def Event():

+    '''

+    Returns an event object

+    '''

+    from multiprocessing.synchronize import Event

+    return Event()

+

+def Queue(maxsize=0):

+    '''

+    Returns a queue object

+    '''

+    from multiprocessing.queues import Queue

+    return Queue(maxsize)

+

+def JoinableQueue(maxsize=0):

+    '''

+    Returns a queue object

+    '''

+    from multiprocessing.queues import JoinableQueue

+    return JoinableQueue(maxsize)

+

+def Pool(processes=None, initializer=None, initargs=()):

+    '''

+    Returns a process pool object

+    '''

+    from multiprocessing.pool import Pool

+    return Pool(processes, initializer, initargs)

+

+def RawValue(typecode_or_type, *args):

+    '''

+    Returns a shared object

+    '''

+    from multiprocessing.sharedctypes import RawValue

+    return RawValue(typecode_or_type, *args)

+

+def RawArray(typecode_or_type, size_or_initializer):

+    '''

+    Returns a shared array

+    '''

+    from multiprocessing.sharedctypes import RawArray

+    return RawArray(typecode_or_type, size_or_initializer)

+

+def Value(typecode_or_type, *args, **kwds):

+    '''

+    Returns a synchronized shared object

+    '''

+    from multiprocessing.sharedctypes import Value

+    return Value(typecode_or_type, *args, **kwds)

+

+def Array(typecode_or_type, size_or_initializer, **kwds):

+    '''

+    Returns a synchronized shared array

+    '''

+    from multiprocessing.sharedctypes import Array

+    return Array(typecode_or_type, size_or_initializer, **kwds)

+

+#

+#

+#

+

+if sys.platform == 'win32':

+

+    def set_executable(executable):

+        '''

+        Sets the path to a python.exe or pythonw.exe binary used to run

+        child processes on Windows instead of sys.executable.

+        Useful for people embedding Python. 

+        '''

+        from multiprocessing.forking import set_executable

+        set_executable(executable)

+

+    __all__ += ['set_executable']