docs: def launch_frozen(in_name, out_name, script_path, frozen_tar_path=None,
                    temp_path='_hadoopy_temp', cache=True, check_script=False,
                    **kw):
      """Freezes a script and then launches it.
  
      This function will freeze your python program, and place it on HDFS
      in 'temp_path'.  It will not remove it afterwards as they are typically
      small, you can easily reuse/debug them, and to avoid any risks involved
      with removing the file.
  
      :param in_name: Input path (string or list)
      :param out_name: Output path
      :param script_path: Path to the script (e.g., script.py)
      :param frozen_tar_path: If not None, use this path to a previously frozen archive.  You can get such a path from the return value of this function, it is particularly helpful in iterative programs.
      :param cache: If True (default) then use previously frozen scripts.  Cache is stored in memory (not persistent).
      :param temp_path: HDFS path that we can use to store temporary files (default to _hadoopy_temp)
      :param partitioner: If True, the partitioner is the value.
      :param wait: If True, wait till the process is completed (default True) this is useful if you want to run multiple jobs concurrently by using the 'process' entry in the output.
      :param files: Extra files (other than the script) (iterator).  NOTE: Hadoop copies the files into working directory
      :param jobconfs: Extra jobconf parameters (iterator)
      :param cmdenvs: Extra cmdenv parameters (iterator)
      :param hstreaming: The full hadoop streaming path to call.
      :param name: Set the job name to this (default None, job name is the script name)
      :param use_typedbytes: If True (default), use typedbytes IO.
      :param use_seqoutput: True (default), output sequence file. If False, output is text.
      :param use_autoinput: If True (default), sets the input format to auto.
      :param config: If a string, set the hadoop config path
      :param pipe: If true (default) then call user code through a pipe to isolate it and stop bugs when printing to stdout.  See project docs.
      :param python_cmd: The python command to use. The default is "python". Can be used to override the system default python, e.g. python_cmd = "python2.6"
  
      :param num_mappers: The number of mappers to use, i.e. the argument given to 'numMapTasks'. If None, then do not specify this argument to hadoop streaming.
      :param num_reducers: The number of reducers to use, i.e. the argument given to 'numReduceTasks'. If None, then do not specify this argument to hadoop streaming.
      :param check_script: If True, then copy script and .py(c) files to a temporary directory and verify that it can be executed.  This catches the majority of errors related to not included locally imported files. The default is False when using launch_frozen as the freeze process packages local files.
  
      :rtype: Dictionary with some of the following entries (depending on options)
      :returns: freeze_cmds: Freeze command(s) ran
      :returns: frozen_tar_path: HDFS path to frozen file
      :returns: hadoop_cmds: Hadoopy command(s) ran
      :returns: process: subprocess.Popen object
      :returns: output: Iterator of (key, value) pairs
      :raises: subprocess.CalledProcessError: Hadoop error.
      :raises: OSError: Hadoop streaming not found.
      :raises: TypeError: Input types are not correct.
      :raises: ValueError: Script not found
      """
      if (('files' in kw and isinstance(kw['files'], (str, unicode))) or
          ('jobconfs' in kw and isinstance(kw['jobconfs'], (str, unicode))) or
          ('cmdenvs' in kw and isinstance(kw['cmdenvs'], (str, unicode)))):
          raise TypeError('files,  jobconfs, and cmdenvs must be iterators of strings and not strings!')
      if 'jobconfs' in kw:
          kw['jobconfs'] = _listeq_to_dict(kw['jobconfs'])
      if 'cmdenvs' in kw:
          kw['cmdenvs'] = _listeq_to_dict(kw['cmdenvs'])
      cmds = []
      if not frozen_tar_path:
          freeze_out = hadoopy.freeze_script(script_path, temp_path=temp_path, cache=cache)
          frozen_tar_path = freeze_out['frozen_tar_path']
          cmds += freeze_out['cmds']
      jobconfs = kw.get('jobconfs', {})
      jobconfs['mapred.cache.archives'] = '%s#_frozen' % frozen_tar_path
      jobconfs['mapreduce.job.cache.archives'] = '%s#_frozen' % frozen_tar_path
      kw['copy_script'] = False
      kw['add_python'] = False
      kw['jobconfs'] = jobconfs
      out = launch(in_name, out_name, script_path,
                   script_dir='_frozen', remove_ext=True, check_script=check_script,
                   make_executable=False, **kw)
      out['freeze_cmds'] = cmds
      out['frozen_tar_path'] = frozen_tar_path
      return out