nodes: 0, module; 1, function_definition; 2, function_name:iparallel_progbar; 3, parameters; 4, block; 5, identifier:mapper; 6, identifier:iterable; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, default_parameter; 14, dictionary_splat_pattern; 15, expression_statement; 16, expression_statement; 17, return_statement; 18, identifier:nprocs; 19, None; 20, identifier:starmap; 21, False; 22, identifier:flatmap; 23, False; 24, identifier:shuffle; 25, False; 26, identifier:verbose; 27, True; 28, identifier:verbose_flatmap; 29, None; 30, identifier:max_cache; 31, unary_operator; 32, identifier:kwargs; 33, comment:"""Performs a parallel mapping of the given iterable, reporting a progress bar as values get returned. Yields
      objects as soon as they're computed, but does not guarantee that they'll be in the correct order.
  
      :param mapper: The mapping function to apply to elements of the iterable
      :param iterable: The iterable to map
      :param nprocs: The number of processes (defaults to the number of cpu's)
      :param starmap: If true, the iterable is expected to contain tuples and the mapper function gets each element of a
          tuple as an argument
      :param flatmap: If true, flatten out the returned values if the mapper function returns a list of objects
      :param shuffle: If true, randomly sort the elements before processing them. This might help provide more uniform
          runtimes if processing different objects takes different amounts of time.
      :param verbose: Whether or not to print the progress bar
      :param verbose_flatmap: If performing a flatmap, whether or not to report each object as it's returned
      :param max_cache: Maximum number of mapped objects to permit in the queue at once
      :param kwargs: Any other keyword arguments to pass to the progress bar (see ``progbar``)
      :return: A list of the returned objects, in whatever order they're done being computed
      """; 34, assignment; 35, generator_expression; 36, integer:1; 37, identifier:results; 38, call; 39, identifier:x; 40, for_in_clause; 41, identifier:_parallel_progbar_launch; 42, argument_list; 43, pattern_list; 44, identifier:results; 45, identifier:mapper; 46, identifier:iterable; 47, identifier:nprocs; 48, identifier:starmap; 49, identifier:flatmap; 50, identifier:shuffle; 51, identifier:verbose; 52, identifier:verbose_flatmap; 53, identifier:max_cache; 54, dictionary_splat; 55, identifier:i; 56, identifier:x; 57, identifier:kwargs
code: def iparallel_progbar(mapper, iterable, nprocs=None, starmap=False, flatmap=False, shuffle=False,
                        verbose=True, verbose_flatmap=None, max_cache=-1, **kwargs):
      """Performs a parallel mapping of the given iterable, reporting a progress bar as values get returned. Yields
      objects as soon as they're computed, but does not guarantee that they'll be in the correct order.
  
      :param mapper: The mapping function to apply to elements of the iterable
      :param iterable: The iterable to map
      :param nprocs: The number of processes (defaults to the number of cpu's)
      :param starmap: If true, the iterable is expected to contain tuples and the mapper function gets each element of a
          tuple as an argument
      :param flatmap: If true, flatten out the returned values if the mapper function returns a list of objects
      :param shuffle: If true, randomly sort the elements before processing them. This might help provide more uniform
          runtimes if processing different objects takes different amounts of time.
      :param verbose: Whether or not to print the progress bar
      :param verbose_flatmap: If performing a flatmap, whether or not to report each object as it's returned
      :param max_cache: Maximum number of mapped objects to permit in the queue at once
      :param kwargs: Any other keyword arguments to pass to the progress bar (see ``progbar``)
      :return: A list of the returned objects, in whatever order they're done being computed
      """
  
      results = _parallel_progbar_launch(mapper, iterable, nprocs, starmap, flatmap, shuffle, verbose,
                                         verbose_flatmap, max_cache, **kwargs)
      return (x for i, x in results)