```
$ pyoxidizer
? 2
Usage: pyoxidizer[EXE] [OPTIONS] [COMMAND]

Commands:
  analyze                              Analyze a built binary
  build                                Build a PyOxidizer enabled project
  cache-clear                          Clear PyOxidizer's user-specific cache
  find-resources                       Find resources in a file or directory
  generate-python-embedding-artifacts  Generate files useful for embedding Python in a [Rust] binary
  init-config-file                     Create a new PyOxidizer configuration file.
  init-rust-project                    Create a new Rust project embedding a Python interpreter
  list-targets                         List targets available to resolve in a configuration file
  python-distribution-extract          Extract a Python distribution archive to a directory
  python-distribution-info             Show information about a Python distribution archive
  python-distribution-licenses         Show licenses for a given Python distribution
  run-build-script                     Run functionality that a build script would perform
  run                                  Run a target in a PyOxidizer configuration file
  rust-project-licensing               Show licensing information for a Rust project
  help                                 Print this message or the help of the given subcommand(s)

Options:
      --system-rust  Use a system install of Rust instead of a self-managed Rust installation
      --verbose...   Increase logging verbosity. Can be specified multiple times
  -h, --help         Print help information (use `--help` for more detail)
  -V, --version      Print version information

```

```
$ pyoxidizer help
Build and distribute Python applications

Usage: pyoxidizer[EXE] [OPTIONS] [COMMAND]

Commands:
  analyze
          Analyze a built binary
  build
          Build a PyOxidizer enabled project
  cache-clear
          Clear PyOxidizer's user-specific cache
  find-resources
          Find resources in a file or directory
  generate-python-embedding-artifacts
          Generate files useful for embedding Python in a [Rust] binary
  init-config-file
          Create a new PyOxidizer configuration file.
  init-rust-project
          Create a new Rust project embedding a Python interpreter
  list-targets
          List targets available to resolve in a configuration file
  python-distribution-extract
          Extract a Python distribution archive to a directory
  python-distribution-info
          Show information about a Python distribution archive
  python-distribution-licenses
          Show licenses for a given Python distribution
  run-build-script
          Run functionality that a build script would perform
  run
          Run a target in a PyOxidizer configuration file
  rust-project-licensing
          Show licensing information for a Rust project
  help
          Print this message or the help of the given subcommand(s)

Options:
      --system-rust
          Use a system install of Rust instead of a self-managed Rust installation

      --verbose...
          Increase logging verbosity. Can be specified multiple times

  -h, --help
          Print help information (use `-h` for a summary)

  -V, --version
          Print version information

```

```
$ pyoxidizer analyze --help
Analyze a built binary

Usage: pyoxidizer[EXE] analyze [OPTIONS] <path>

Arguments:
  <path>  Path to executable to analyze

Options:
      --system-rust  Use a system install of Rust instead of a self-managed Rust installation
      --verbose...   Increase logging verbosity. Can be specified multiple times
  -h, --help         Print help information

```

```
$ pyoxidizer build --help
Build a PyOxidizer project.

The PATH argument is a filesystem path to a directory containing an
existing PyOxidizer enabled project.

This command will invoke Rust's build system tool (Cargo) to build
the project.


Usage: pyoxidizer[EXE] build [OPTIONS] [TARGET]...

Arguments:
  [TARGET]...
          Target to resolve

Options:
      --system-rust
          Use a system install of Rust instead of a self-managed Rust installation

      --target-triple <target_triple>
          Rust target triple to build for

      --release
          Build a release binary

      --verbose...
          Increase logging verbosity. Can be specified multiple times

      --path <PATH>
          Directory containing project to build
          
          [default: .]

      --var <name> <value>
          Defines a single string key to set in the VARS global dict.
          
          This argument can be used to inject variable content into the Starlark
          execution context to influence evaluation.
          
          <name> defines the key in the dict to set and <value> is its string
          value.
          
          For example, `--var my_var my_value` is functionally similar to the
          Starlark expression `VARS["my_var"] = "my_value"`.
          
          If a Starlark variable is defined multiple times, an error occurs.
          

      --var-env <name> <env>
          Defines a single string key to set in the VARS global dict from an environment variable.
          
          This is like --var except the value of the dict key comes from an
          environment variable.
          
          The <env> environment variable is read and becomes the value of the
          <name> key in the VARS dict.
          
          If the <env> environment variable is not set, the Starlark value will
          be `None` instead of a `string`.
          
          If a Starlark variable is defined multiple times, an error occurs.
          

  -h, --help
          Print help information (use `-h` for a summary)

```

```
$ pyoxidizer cache-clear --help
Clear PyOxidizer's user-specific cache

Usage: pyoxidizer[EXE] cache-clear [OPTIONS]

Options:
      --system-rust  Use a system install of Rust instead of a self-managed Rust installation
      --verbose...   Increase logging verbosity. Can be specified multiple times
  -h, --help         Print help information

```

```
$ pyoxidizer find-resources --help
Scan a directory or file for Python resources.

This command invokes the logic used by various PyOxidizer functionality
walking a directory tree or parsing a file and categorizing seen files.

The directory walking functionality is used by
`oxidized_importer.find_resources_in_path()` and Starlark methods like
`PythonExecutable.pip_install()` and
`PythonExecutable.read_package_root()`.

The file parsing logic is used for parsing the contents of wheels.

This command can be used to debug failures with PyOxidizer's code
for converting files/directories into strongly typed objects. This
conversion is critical for properly packaging Python applications and
bugs can result in incorrect install layouts, missing resources, etc.


Usage: pyoxidizer[EXE] find-resources [OPTIONS] <PATH>

Arguments:
  <PATH>
          Filesystem path to scan for resources. Must be a directory or Python wheel

Options:
      --distributions-dir <PATH>
          Directory to extract downloaded Python distributions into

      --system-rust
          Use a system install of Rust instead of a self-managed Rust installation

      --scan-distribution
          Scan the Python distribution instead of a path

      --verbose...
          Increase logging verbosity. Can be specified multiple times

      --target-triple <target_triple>
          Target triple of Python distribution to use
          
          [default: [..]]

      --no-classify-files
          Whether to skip classifying files as typed resources

      --no-emit-files
          Whether to skip emitting File resources

  -h, --help
          Print help information (use `-h` for a summary)

```

```
$ pyoxidizer generate-python-embedding-artifacts --help
Generate files useful for embedding Python in a [Rust] binary.

This low-level command can be used to write files that facilitate the
embedding of Python in a larger binary. It can be used to write:

* A custom libpython that can be linked into a binary.
* A configuration file for the PyO3 Rust crate telling it how to
  link against the aforementioned custom libpython.
* A Python packed resources file containing the entirety of the Python
  standard library.
* A Rust file defining a default `pyembed::OxidizedPythonInterpreterConfig`
  struct for configuring the embedded Python interpreter.
* tcl/tk support files (for tkinter module support).
* Microsoft Visual C++ Redistributable Runtime DLLs (Windows only).

This command essentially does what the `run-build-script` command does except
it doesn't require the presence of a PyOxidizer configuration file. Instead,
it uses an opinionated default configuration suitable for producing a set of
files suitable for common Python embedding scenarios. If the defaults are not
appropriate for your use case, you can always define a configuration file to
customize them and use `run-build-script` to produce similar output files.


Usage: pyoxidizer[EXE] generate-python-embedding-artifacts [OPTIONS] <DESTINATION_PATH>

Arguments:
  <DESTINATION_PATH>
          Output directory for written files

Options:
      --system-rust
          Use a system install of Rust instead of a self-managed Rust installation

      --target-triple <target_triple>
          Rust target triple being targeted
          
          [default: [..]]

      --flavor <flavor>
          Python distribution flavor
          
          [default: standalone]

      --verbose...
          Increase logging verbosity. Can be specified multiple times

      --python-version <python_version>
          Python version (X.Y) to use

  -h, --help
          Print help information (use `-h` for a summary)

```

```
$ pyoxidizer init-config-file --help
Create a new PyOxidizer configuration file.

Usage: pyoxidizer[EXE] init-config-file [OPTIONS] <PATH>

Arguments:
  <PATH>  Directory where configuration file should be created

Options:
      --python-code <python-code>  Default Python code to execute in built executable
      --system-rust                Use a system install of Rust instead of a self-managed Rust installation
      --pip-install <pip-install>  Python package to install via `pip install`
      --verbose...                 Increase logging verbosity. Can be specified multiple times
  -h, --help                       Print help information

```

```
$ pyoxidizer init-rust-project --help
Create a new Rust project embedding Python.

The PATH argument is a filesystem path that should be created to hold the
new Rust project.

This command will call `cargo init PATH` and then install files and make
modifications required to embed a Python interpreter in that application.

The new project's binary will be configured to launch a Python REPL by
default.

Created projects inherit settings such as Python distribution URLs and
dependency crate versions and locations from the PyOxidizer executable
they were created with.

On success, instructions on potential next steps are printed.


Usage: pyoxidizer[EXE] init-rust-project [OPTIONS] <PATH>

Arguments:
  <PATH>
          Path of project directory to create

Options:
      --system-rust
          Use a system install of Rust instead of a self-managed Rust installation

      --verbose...
          Increase logging verbosity. Can be specified multiple times

  -h, --help
          Print help information (use `-h` for a summary)

```

```
$ pyoxidizer list-targets --help
List targets available to resolve in a configuration file

Usage: pyoxidizer[EXE] list-targets [OPTIONS] [PATH]

Arguments:
  [PATH]  Path to project to evaluate [default: .]

Options:
      --system-rust  Use a system install of Rust instead of a self-managed Rust installation
      --verbose...   Increase logging verbosity. Can be specified multiple times
  -h, --help         Print help information

```

```
$ pyoxidizer python-distribution-extract --help
Extract a Python distribution archive to a directory

Usage: pyoxidizer[EXE] python-distribution-extract [OPTIONS] <DESTINATION_PATH>

Arguments:
  <DESTINATION_PATH>  Path to directory where distribution should be extracted

Options:
      --download-default
          Download and extract the default distribution for this platform
      --system-rust
          Use a system install of Rust instead of a self-managed Rust installation
      --archive-path <DISTRIBUTION_PATH>
          Path to a Python distribution archive
      --verbose...
          Increase logging verbosity. Can be specified multiple times
  -h, --help
          Print help information

```

```
$ pyoxidizer python-distribution-info --help
Show information about a Python distribution archive

Usage: pyoxidizer[EXE] python-distribution-info [OPTIONS] <PATH>

Arguments:
  <PATH>  Path to Python distribution archive to analyze

Options:
      --system-rust  Use a system install of Rust instead of a self-managed Rust installation
      --verbose...   Increase logging verbosity. Can be specified multiple times
  -h, --help         Print help information

```

```
$ pyoxidizer python-distribution-licenses --help
Show licenses for a given Python distribution

Usage: pyoxidizer[EXE] python-distribution-licenses [OPTIONS] <PATH>

Arguments:
  <PATH>  Path to Python distribution to analyze

Options:
      --system-rust  Use a system install of Rust instead of a self-managed Rust installation
      --verbose...   Increase logging verbosity. Can be specified multiple times
  -h, --help         Print help information

```

```
$ pyoxidizer run --help
Run a target in a PyOxidizer configuration file

Usage: pyoxidizer[EXE] run [OPTIONS] [extra]...

Arguments:
  [extra]...
          

Options:
      --system-rust
          Use a system install of Rust instead of a self-managed Rust installation

      --target-triple <target_triple>
          Rust target triple to build for

      --release
          Run a release binary

      --verbose...
          Increase logging verbosity. Can be specified multiple times

      --path <PATH>
          Directory containing project to build
          
          [default: .]

      --target <target>
          Build target to run

      --var <name> <value>
          Defines a single string key to set in the VARS global dict.
          
          This argument can be used to inject variable content into the Starlark
          execution context to influence evaluation.
          
          <name> defines the key in the dict to set and <value> is its string
          value.
          
          For example, `--var my_var my_value` is functionally similar to the
          Starlark expression `VARS["my_var"] = "my_value"`.
          
          If a Starlark variable is defined multiple times, an error occurs.
          

      --var-env <name> <env>
          Defines a single string key to set in the VARS global dict from an environment variable.
          
          This is like --var except the value of the dict key comes from an
          environment variable.
          
          The <env> environment variable is read and becomes the value of the
          <name> key in the VARS dict.
          
          If the <env> environment variable is not set, the Starlark value will
          be `None` instead of a `string`.
          
          If a Starlark variable is defined multiple times, an error occurs.
          

  -h, --help
          Print help information (use `-h` for a summary)

```

```
$ pyoxidizer run-build-script --help
Runs a crate build script to generate Python artifacts.

When the Rust crate embedding Python is built, it needs to consume various
artifacts derived from processing the active PyOxidizer config file.
These files are typically generated when the crate's build script runs.

This command executes the functionality to derive various artifacts and
emits special lines that tell the Rust build system how to consume them.


Usage: pyoxidizer[EXE] run-build-script [OPTIONS] <build-script-name>

Arguments:
  <build-script-name>
          Value to use for Rust build script

Options:
      --system-rust
          Use a system install of Rust instead of a self-managed Rust installation

      --target <target>
          The config file target to resolve

      --var <name> <value>
          Defines a single string key to set in the VARS global dict.
          
          This argument can be used to inject variable content into the Starlark
          execution context to influence evaluation.
          
          <name> defines the key in the dict to set and <value> is its string
          value.
          
          For example, `--var my_var my_value` is functionally similar to the
          Starlark expression `VARS["my_var"] = "my_value"`.
          
          If a Starlark variable is defined multiple times, an error occurs.
          

      --verbose...
          Increase logging verbosity. Can be specified multiple times

      --var-env <name> <env>
          Defines a single string key to set in the VARS global dict from an environment variable.
          
          This is like --var except the value of the dict key comes from an
          environment variable.
          
          The <env> environment variable is read and becomes the value of the
          <name> key in the VARS dict.
          
          If the <env> environment variable is not set, the Starlark value will
          be `None` instead of a `string`.
          
          If a Starlark variable is defined multiple times, an error occurs.
          

  -h, --help
          Print help information (use `-h` for a summary)

```

```
$ pyoxidizer rust-project-licensing --help
Show licensing information for a Rust project

Usage: pyoxidizer[EXE] rust-project-licensing [OPTIONS] <project_path>

Arguments:
  <project_path>  The path to the Rust project to evaluate

Options:
      --all-features                   Activate all crate features during evaluation
      --system-rust                    Use a system install of Rust instead of a self-managed Rust installation
      --target-triple <target_triple>  Rust target triple to simulate building for
      --verbose...                     Increase logging verbosity. Can be specified multiple times
      --unified-license                Print a unified license document
  -h, --help                           Print help information

```