darn! I converted half of the files the wrong way.

1 files changed, 271 insertions, 271 deletions

diff --git a/Lib/multiprocessing/__init__.py b/Lib/multiprocessing/__init__.py
index decb2ad..f965056 100644
--- a/Lib/multiprocessing/__init__.py
+++ b/Lib/multiprocessing/__init__.py
@@ -1,271 +1,271 @@
-#

-# 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

-

-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

-

-# This is down here because _multiprocessing uses BufferTooShort

-import _multiprocessing

-

-#

-# 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']

+#
+# 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
+
+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
+
+# This is down here because _multiprocessing uses BufferTooShort
+import _multiprocessing
+
+#
+# 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']