text: #
  # Support for the API of the multiprocessing package using threads
  #
  # multiprocessing/dummy/__init__.py
  #
  # 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
  # SUCH DAMAGE.
  #
  
  __all__ = [
      'Process', 'current_process', 'active_children', 'freeze_support',
      'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Condition',
      'Event', 'Barrier', 'Queue', 'Manager', 'Pipe', 'Pool', 'JoinableQueue'
      ]
  
  #
  # Imports
  #
  
  import threading
  import sys
  import weakref
  import array
  
  from multiprocess.dummy.connection import Pipe
  from threading import Lock, RLock, Semaphore, BoundedSemaphore
  from threading import Event, Condition, Barrier
  from queue import Queue
  
  #
  #
  #
  
  class DummyProcess(threading.Thread):
  
      def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
          threading.Thread.__init__(self, group, target, name, args, kwargs)
          self._pid = None
          self._children = weakref.WeakKeyDictionary()
          self._start_called = False
          self._parent = current_process()
  
      def start(self):
          assert self._parent is current_process()
          self._start_called = True
          if hasattr(self._parent, '_children'):
              self._parent._children[self] = None
          threading.Thread.start(self)
  
      @property
      def exitcode(self):
          if self._start_called and not self.is_alive():
              return 0
          else:
              return None
  
  #
  #
  #
  
  Process = DummyProcess
  current_process = threading.current_thread
  current_process()._children = weakref.WeakKeyDictionary()
  
  def active_children():
      children = current_process()._children
      for p in list(children):
          if not p.is_alive():
              children.pop(p, None)
      return list(children)
  
  def freeze_support():
      pass
  
  #
  #
  #
  
  class Namespace(object):
      def __init__(self, **kwds):
          self.__dict__.update(kwds)
      def __repr__(self):
          items = list(self.__dict__.items())
          temp = []
          for name, value in items:
              if not name.startswith('_'):
                  temp.append('%s=%r' % (name, value))
          temp.sort()
          return 'Namespace(%s)' % str.join(', ', temp)
  
  dict = dict
  list = list
  
  def Array(typecode, sequence, lock=True):
      return array.array(typecode, sequence)
  
  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
      value = property(_get, _set)
      def __repr__(self):
          return '<%r(%r, %r)>'%(type(self).__name__,self._typecode,self._value)
  
  def Manager():
      return sys.modules[__name__]
  
  def shutdown():
      pass
  
  def Pool(processes=None, initializer=None, initargs=()):
      from multiprocess.pool import ThreadPool
      return ThreadPool(processes, initializer, initargs)
  
  JoinableQueue = Queue
  