#

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