parameters: (py_files,
                    optimize=0, force=0,
                    prefix=None, base_dir=None,
                    verbose=1, dry_run=0,
                    direct=None)
docstring: Byte-compile a collection of Python source files to .pyc
      files in a __pycache__ subdirectory.  'py_files' is a list
      of files to compile; any files that don't end in ".py" are silently
      skipped.  'optimize' must be one of the following:
        0 - don't optimize
        1 - normal optimization (like "python -O")
        2 - extra optimization (like "python -OO")
      If 'force' is true, all files are recompiled regardless of
      timestamps.
  
      The source filename encoded in each bytecode file defaults to the
      filenames listed in 'py_files'; you can modify these with 'prefix' and
      'basedir'.  'prefix' is a string that will be stripped off of each
      source filename, and 'base_dir' is a directory name that will be
      prepended (after 'prefix' is stripped).  You can supply either or both
      (or neither) of 'prefix' and 'base_dir', as you wish.
  
      If 'dry_run' is true, doesn't actually do anything that would
      affect the filesystem.
  
      Byte-compilation is either done directly in this interpreter process
      with the standard py_compile module, or indirectly by writing a
      temporary script and executing it.  Normally, you should let
      'byte_compile()' figure out to use direct compilation or not (see
      the source for details).  The 'direct' flag is used by the script
      generated in indirect mode; unless you know what you're doing, leave
      it set to None.
docstring_summary: Byte-compile a collection of Python source files to .pyc
      files in a __pycache__ subdirectory.  'py_files' is a list
      of files to compile; any files that don't end in ".py" are silently
      skipped.  'optimize' must be one of the following:
        0 - don't optimize
        1 - normal optimization (like "python -O")
        2 - extra optimization (like "python -OO")
      If 'force' is true, all files are recompiled regardless of
      timestamps.
docstring_tokens: Byte - compile a collection of Python source files to . pyc files in a __pycache__ subdirectory . py_files is a list of files to compile ; any files that don t end in . py are silently skipped . optimize must be one of the following : 0 - don t optimize 1 - normal optimization ( like python - O ) 2 - extra optimization ( like python - OO ) If force is true all files are recompiled regardless of timestamps .
function: def byte_compile (py_files,
                    optimize=0, force=0,
                    prefix=None, base_dir=None,
                    verbose=1, dry_run=0,
                    direct=None):
      """Byte-compile a collection of Python source files to .pyc
      files in a __pycache__ subdirectory.  'py_files' is a list
      of files to compile; any files that don't end in ".py" are silently
      skipped.  'optimize' must be one of the following:
        0 - don't optimize
        1 - normal optimization (like "python -O")
        2 - extra optimization (like "python -OO")
      If 'force' is true, all files are recompiled regardless of
      timestamps.
  
      The source filename encoded in each bytecode file defaults to the
      filenames listed in 'py_files'; you can modify these with 'prefix' and
      'basedir'.  'prefix' is a string that will be stripped off of each
      source filename, and 'base_dir' is a directory name that will be
      prepended (after 'prefix' is stripped).  You can supply either or both
      (or neither) of 'prefix' and 'base_dir', as you wish.
  
      If 'dry_run' is true, doesn't actually do anything that would
      affect the filesystem.
  
      Byte-compilation is either done directly in this interpreter process
      with the standard py_compile module, or indirectly by writing a
      temporary script and executing it.  Normally, you should let
      'byte_compile()' figure out to use direct compilation or not (see
      the source for details).  The 'direct' flag is used by the script
      generated in indirect mode; unless you know what you're doing, leave
      it set to None.
      """
  
      # Late import to fix a bootstrap issue: _posixsubprocess is built by
      # setup.py, but setup.py uses distutils.
      import subprocess
  
      # nothing is done if sys.dont_write_bytecode is True
      if sys.dont_write_bytecode:
          raise DistutilsByteCompileError('byte-compiling is disabled.')
  
      # First, if the caller didn't force us into direct or indirect mode,
      # figure out which mode we should be in.  We take a conservative
      # approach: choose direct mode *only* if the current interpreter is
      # in debug mode and optimize is 0.  If we're not in debug mode (-O
      # or -OO), we don't know which level of optimization this
      # interpreter is running with, so we can't do direct
      # byte-compilation and be certain that it's the right thing.  Thus,
      # always compile indirectly if the current interpreter is in either
      # optimize mode, or if either optimization level was requested by
      # the caller.
      if direct is None:
          direct = (__debug__ and optimize == 0)
  
      # "Indirect" byte-compilation: write a temporary script and then
      # run it with the appropriate flags.
      if not direct:
          try:
              from tempfile import mkstemp
              (script_fd, script_name) = mkstemp(".py")
          except ImportError:
              from tempfile import mktemp
              (script_fd, script_name) = None, mktemp(".py")
          log.info("writing byte-compilation script '%s'", script_name)
          if not dry_run:
              if script_fd is not None:
                  script = os.fdopen(script_fd, "w")
              else:
                  script = open(script_name, "w")
  
              script.write("""\
  from distutils.util import byte_compile
  files = [
  """)
  
              # XXX would be nice to write absolute filenames, just for
              # safety's sake (script should be more robust in the face of
              # chdir'ing before running it).  But this requires abspath'ing
              # 'prefix' as well, and that breaks the hack in build_lib's
              # 'byte_compile()' method that carefully tacks on a trailing
              # slash (os.sep really) to make sure the prefix here is "just
              # right".  This whole prefix business is rather delicate -- the
              # problem is that it's really a directory, but I'm treating it
              # as a dumb string, so trailing slashes and so forth matter.
  
              #py_files = map(os.path.abspath, py_files)
              #if prefix:
              #    prefix = os.path.abspath(prefix)
  
              script.write(",\n".join(map(repr, py_files)) + "]\n")
              script.write("""
  byte_compile(files, optimize=%r, force=%r,
               prefix=%r, base_dir=%r,
               verbose=%r, dry_run=0,
               direct=1)
  """ % (optimize, force, prefix, base_dir, verbose))
  
              script.close()
  
          cmd = [sys.executable]
          cmd.extend(subprocess._optim_args_from_interpreter_flags())
          cmd.append(script_name)
          spawn(cmd, dry_run=dry_run)
          execute(os.remove, (script_name,), "removing %s" % script_name,
                  dry_run=dry_run)
  
      # "Direct" byte-compilation: use the py_compile module to compile
      # right here, right now.  Note that the script generated in indirect
      # mode simply calls 'byte_compile()' in direct mode, a weird sort of
      # cross-process recursion.  Hey, it works!
      else:
          from py_compile import compile
  
          for file in py_files:
              if file[-3:] != ".py":
                  # This lets us be lazy and not filter filenames in
                  # the "install_lib" command.
                  continue
  
              # Terminology from the py_compile module:
              #   cfile - byte-compiled file
              #   dfile - purported source filename (same as 'file' by default)
              if optimize >= 0:
                  opt = '' if optimize == 0 else optimize
                  cfile = importlib.util.cache_from_source(
                      file, optimization=opt)
              else:
                  cfile = importlib.util.cache_from_source(file)
              dfile = file
              if prefix:
                  if file[:len(prefix)] != prefix:
                      raise ValueError("invalid prefix: filename %r doesn't start with %r"
                             % (file, prefix))
                  dfile = dfile[len(prefix):]
              if base_dir:
                  dfile = os.path.join(base_dir, dfile)
  
              cfile_base = os.path.basename(cfile)
              if direct:
                  if force or newer(file, cfile):
                      log.info("byte-compiling %s to %s", file, cfile_base)
                      if not dry_run:
                          compile(file, cfile, dfile)
                  else:
                      log.debug("skipping byte-compilation of %s to %s",
                                file, cfile_base)
function_tokens: def byte_compile ( py_files , optimize = 0 , force = 0 , prefix = None , base_dir = None , verbose = 1 , dry_run = 0 , direct = None ) : # Late import to fix a bootstrap issue: _posixsubprocess is built by # setup.py, but setup.py uses distutils. import subprocess # nothing is done if sys.dont_write_bytecode is True if sys . dont_write_bytecode : raise DistutilsByteCompileError ( 'byte-compiling is disabled.' ) # First, if the caller didn't force us into direct or indirect mode, # figure out which mode we should be in.  We take a conservative # approach: choose direct mode *only* if the current interpreter is # in debug mode and optimize is 0.  If we're not in debug mode (-O # or -OO), we don't know which level of optimization this # interpreter is running with, so we can't do direct # byte-compilation and be certain that it's the right thing.  Thus, # always compile indirectly if the current interpreter is in either # optimize mode, or if either optimization level was requested by # the caller. if direct is None : direct = ( __debug__ and optimize == 0 ) # "Indirect" byte-compilation: write a temporary script and then # run it with the appropriate flags. if not direct : try : from tempfile import mkstemp ( script_fd , script_name ) = mkstemp ( ".py" ) except ImportError : from tempfile import mktemp ( script_fd , script_name ) = None , mktemp ( ".py" ) log . info ( "writing byte-compilation script '%s'" , script_name ) if not dry_run : if script_fd is not None : script = os . fdopen ( script_fd , "w" ) else : script = open ( script_name , "w" ) script . write ( """\
  from distutils.util import byte_compile
  files = [
  """ ) # XXX would be nice to write absolute filenames, just for # safety's sake (script should be more robust in the face of # chdir'ing before running it).  But this requires abspath'ing # 'prefix' as well, and that breaks the hack in build_lib's # 'byte_compile()' method that carefully tacks on a trailing # slash (os.sep really) to make sure the prefix here is "just # right".  This whole prefix business is rather delicate -- the # problem is that it's really a directory, but I'm treating it # as a dumb string, so trailing slashes and so forth matter. #py_files = map(os.path.abspath, py_files) #if prefix: #    prefix = os.path.abspath(prefix) script . write ( ",\n" . join ( map ( repr , py_files ) ) + "]\n" ) script . write ( """
  byte_compile(files, optimize=%r, force=%r,
               prefix=%r, base_dir=%r,
               verbose=%r, dry_run=0,
               direct=1)
  """ % ( optimize , force , prefix , base_dir , verbose ) ) script . close ( ) cmd = [ sys . executable ] cmd . extend ( subprocess . _optim_args_from_interpreter_flags ( ) ) cmd . append ( script_name ) spawn ( cmd , dry_run = dry_run ) execute ( os . remove , ( script_name , ) , "removing %s" % script_name , dry_run = dry_run ) # "Direct" byte-compilation: use the py_compile module to compile # right here, right now.  Note that the script generated in indirect # mode simply calls 'byte_compile()' in direct mode, a weird sort of # cross-process recursion.  Hey, it works! else : from py_compile import compile for file in py_files : if file [ - 3 : ] != ".py" : # This lets us be lazy and not filter filenames in # the "install_lib" command. continue # Terminology from the py_compile module: #   cfile - byte-compiled file #   dfile - purported source filename (same as 'file' by default) if optimize >= 0 : opt = '' if optimize == 0 else optimize cfile = importlib . util . cache_from_source ( file , optimization = opt ) else : cfile = importlib . util . cache_from_source ( file ) dfile = file if prefix : if file [ : len ( prefix ) ] != prefix : raise ValueError ( "invalid prefix: filename %r doesn't start with %r" % ( file , prefix ) ) dfile = dfile [ len ( prefix ) : ] if base_dir : dfile = os . path . join ( base_dir , dfile ) cfile_base = os . path . basename ( cfile ) if direct : if force or newer ( file , cfile ) : log . info ( "byte-compiling %s to %s" , file , cfile_base ) if not dry_run : compile ( file , cfile , dfile ) else : log . debug ( "skipping byte-compilation of %s to %s" , file , cfile_base )