code: def parallel_map(function, sequence, numcores=None):
    
    if not callable(function):
      raise TypeError("input function '%s' is not callable" %
                repr(function))
  
    if not numpy.iterable(sequence):
      raise TypeError("input '%s' is not iterable" %
                repr(sequence))
  
    size = len(sequence)
  
    if not _multi or size == 1:
      return map(function, sequence)
  
    if numcores is None:
      numcores = _ncpus
  
    if platform.system() == 'Windows': # JB: don't think this works on Win
      return list(map(function,sequence))
  
    # Returns a started SyncManager object which can be used for sharing 
    # objects between processes. The returned manager object corresponds
    # to a spawned child process and has methods which will create shared
    # objects and return corresponding proxies.
    manager = multiprocessing.Manager()
  
    # Create FIFO queue and lock shared objects and return proxies to them.
    # The managers handles a server process that manages shared objects that
    # each slave process has access to. Bottom line -- thread-safe.
    out_q = manager.Queue()
    err_q = manager.Queue()
    lock = manager.Lock()
  
    # if sequence is less than numcores, only use len sequence number of 
    # processes
    if size < numcores:
      numcores = size 
  
    # group sequence into numcores-worth of chunks
    sequence = numpy.array_split(sequence, numcores)
  
    procs = [multiprocessing.Process(target=worker,
             args=(function, ii, chunk, out_q, err_q, lock))
           for ii, chunk in enumerate(sequence)]
  
    return run_tasks(procs, err_q, out_q, numcores)
docs: A parallelized version of the native Python map function that
    utilizes the Python multiprocessing module to divide and 
    conquer sequence.
  
    parallel_map does not yet support multiple argument sequences.
  
    :param function: callable function that accepts argument from iterable
    :param sequence: iterable sequence 
    :param numcores: number of cores to use