# distutils.dist.Distribution - pydoc - phpman

Help on class Distribution in distutils.dist:

distutils.dist.Distribution = class Distribution(builtins.object)
 |  distutils.dist.Distribution(attrs=None)
 |
 |  The core of the Distutils.  Most of the work hiding behind 'setup'
 |  is really done within a Distribution instance, which farms the work out
 |  to the Distutils commands specified on the command line.
 |
 |  Setup scripts will almost never instantiate Distribution directly,
 |  unless the 'setup()' function is totally inadequate to their needs.
 |  However, it is conceivable that a setup script might wish to subclass
 |  Distribution for some specialized purpose, and then pass the subclass
 |  to 'setup()' as the 'distclass' keyword argument.  If so, it is
 |  necessary to respect the expectations that 'setup' has of Distribution.
 |  See the code for 'setup()', in core.py, for details.
 |
 |  Methods defined here:
 |
 |  __init__(self, attrs=None)
 |      Construct a new Distribution instance: initialize all the
 |      attributes of a Distribution, and then use 'attrs' (a dictionary
 |      mapping attribute names to values) to assign some of those
 |      attributes their "real" values.  (Any attributes not mentioned in
 |      'attrs' will be assigned to some null value: 0, None, an empty list
 |      or dictionary, etc.)  Most importantly, initialize the
 |      'command_obj' attribute to the empty dictionary; this will be
 |      filled in with real command objects by 'parse_command_line()'.
 |
 |  announce(self, msg, level=2)
 |
 |  dump_option_dicts(self, header=None, commands=None, indent='')
 |
 |  finalize_options(self)
 |      Set final values for all the options on the Distribution
 |      instance, analogous to the .finalize_options() method of Command
 |      objects.
 |
 |  find_config_files(self)
 |      Find as many configuration files as should be processed for this
 |      platform, and return a list of filenames in the order in which they
 |      should be parsed.  The filenames returned are guaranteed to exist
 |      (modulo nasty race conditions).
 |
 |      There are three possible config files: distutils.cfg in the
 |      Distutils installation directory (ie. where the top-level
 |      Distutils __inst__.py file lives), a file in the user's home
 |      directory named .pydistutils.cfg on Unix and pydistutils.cfg
 |      on Windows/Mac; and setup.cfg in the current directory.
 |
 |      The file in the user's home directory can be disabled with the
 |      --no-user-cfg option.
 |
 |  get_command_class(self, command)
 |      Return the class that implements the Distutils command named by
 |      'command'.  First we check the 'cmdclass' dictionary; if the
 |      command is mentioned there, we fetch the class object from the
 |      dictionary and return it.  Otherwise we load the command module
 |      ("distutils.command." + command) and fetch the command class from
 |      the module.  The loaded class is also stored in 'cmdclass'
 |      to speed future calls to 'get_command_class()'.
 |
 |      Raises DistutilsModuleError if the expected module could not be
 |      found, or if that module does not define the expected class.
 |
 |  get_command_list(self)
 |      Get a list of (command, description) tuples.
 |      The list is divided into "standard commands" (listed in
 |      distutils.command.__all__) and "extra commands" (mentioned in
 |      self.cmdclass, but not a standard command).  The descriptions come
 |      from the command class attribute 'description'.
 |
 |  get_command_obj(self, command, create=1)
 |      Return the command object for 'command'.  Normally this object
 |      is cached on a previous call to 'get_command_obj()'; if no command
 |      object for 'command' is in the cache, then we either create and
 |      return it (if 'create' is true) or return None.
 |
 |  get_command_packages(self)
 |      Return a list of packages from which commands are loaded.
 |
 |  get_option_dict(self, command)
 |      Get the option dictionary for a given command.  If that
 |      command's option dictionary hasn't been created yet, then create it
 |      and return the new dictionary; otherwise, return the existing
 |      option dictionary.
 |
 |  handle_display_options(self, option_order)
 |      If there were any non-global "display-only" options
 |      (--help-commands or the metadata display options) on the command
 |      line, display the requested info and return true; else return
 |      false.
 |
 |  has_c_libraries(self)
 |
 |  has_data_files(self)
 |
 |  has_ext_modules(self)
 |
 |  has_headers(self)
 |
 |  has_modules(self)
 |
 |  has_pure_modules(self)
 |
 |  has_scripts(self)
 |
 |  is_pure(self)
 |
 |  parse_command_line(self)
 |      Parse the setup script's command line, taken from the
 |      'script_args' instance attribute (which defaults to 'sys.argv[1:]'
 |      -- see 'setup()' in core.py).  This list is first processed for
 |      "global options" -- options that set attributes of the Distribution
 |      instance.  Then, it is alternately scanned for Distutils commands
 |      and options for that command.  Each new command terminates the
 |      options for the previous command.  The allowed options for a
 |      command are determined by the 'user_options' attribute of the
 |      command class -- thus, we have to be able to load command classes
 |      in order to parse the command line.  Any error in that 'options'
 |      attribute raises DistutilsGetoptError; any error on the
 |      command-line raises DistutilsArgError.  If no Distutils commands
 |      were found on the command line, raises DistutilsArgError.  Return
 |      true if command-line was successfully parsed and we should carry
 |      on with executing commands; false if no errors but we shouldn't
 |      execute commands (currently, this only happens if user asks for
 |      help).
 |
 |  parse_config_files(self, filenames=None)
 |
 |  print_command_list(self, commands, header, max_length)
 |      Print a subset of the list of all commands -- used by
 |      'print_commands()'.
 |
 |  print_commands(self)
 |      Print out a help message listing all available commands with a
 |      description of each.  The list is divided into "standard commands"
 |      (listed in distutils.command.__all__) and "extra commands"
 |      (mentioned in self.cmdclass, but not a standard command).  The
 |      descriptions come from the command class attribute
 |      'description'.
 |
 |  reinitialize_command(self, command, reinit_subcommands=0)
 |      Reinitializes a command to the state it was in when first
 |      returned by 'get_command_obj()': ie., initialized but not yet
 |      finalized.  This provides the opportunity to sneak option
 |      values in programmatically, overriding or supplementing
 |      user-supplied values from the config files and command line.
 |      You'll have to re-finalize the command object (by calling
 |      'finalize_options()' or 'ensure_finalized()') before using it for
 |      real.
 |
 |      'command' should be a command name (string) or command object.  If
 |      'reinit_subcommands' is true, also reinitializes the command's
 |      sub-commands, as declared by the 'sub_commands' class attribute (if
 |      it has one).  See the "install" command for an example.  Only
 |      reinitializes the sub-commands that actually matter, ie. those
 |      whose test predicates return true.
 |
 |      Returns the reinitialized command object.
 |
 |  run_command(self, command)
 |      Do whatever it takes to run a command (including nothing at all,
 |      if the command has already been run).  Specifically: if we have
 |      already created and run the command named by 'command', return
 |      silently without doing anything.  If the command named by 'command'
 |      doesn't even have a command object yet, create one.  Then invoke
 |      'run()' on that command object (or an existing one).
 |
 |  run_commands(self)
 |      Run each command that was seen on the setup script command line.
 |      Uses the list of commands found and cache of command objects
 |      created by 'get_command_obj()'.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  common_usage = "Common commands: (see '--help-commands' for more...'\n...
 |
 |  display_option_names = ['help_commands', 'name', 'version', 'fullname'...
 |
 |  display_options = [('help-commands', None, 'list all available command...
 |
 |  global_options = [('verbose', 'v', 'run verbosely (default)', 1), ('qu...
 |
 |  negative_opt = {'quiet': 'verbose'}