Struct PipCompileArgs 

pub struct PipCompileArgs {

    pub src_file: Vec<PathBuf>,
    pub constraints: Vec<Maybe<PathBuf>>,
    pub overrides: Vec<Maybe<PathBuf>>,
    pub excludes: Vec<Maybe<PathBuf>>,
    pub build_constraints: Vec<Maybe<PathBuf>>,
    pub extra: Option<Vec<ExtraName>>,
    pub all_extras: bool,
    pub no_all_extras: bool,
    pub group: Vec<PipGroupName>,
    pub resolver: ResolverArgs,
    pub refresh: RefreshArgs,
    pub no_deps: bool,
    pub deps: bool,
    pub output_file: Option<PathBuf>,
    pub format: Option<PipCompileFormat>,
    pub no_strip_extras: bool,
    pub strip_extras: bool,
    pub no_strip_markers: bool,
    pub strip_markers: bool,
    pub no_annotate: bool,
    pub annotate: bool,
    pub no_header: bool,
    pub header: bool,
    pub annotation_style: Option<AnnotationStyle>,
    pub custom_compile_command: Option<String>,
    pub python: Option<Maybe<String>>,
    pub system: bool,
    pub no_system: bool,
    pub generate_hashes: bool,
    pub no_generate_hashes: bool,
    pub no_build: bool,
    pub build: bool,
    pub no_binary: Option<Vec<PackageNameSpecifier>>,
    pub only_binary: Option<Vec<PackageNameSpecifier>>,
    pub python_version: Option<PythonVersion>,
    pub python_platform: Option<TargetTriple>,
    pub universal: bool,
    pub no_universal: bool,
    pub no_emit_package: Option<Vec<PackageName>>,
    pub emit_index_url: bool,
    pub no_emit_index_url: bool,
    pub emit_find_links: bool,
    pub no_emit_find_links: bool,
    pub emit_build_options: bool,
    pub no_emit_build_options: bool,
    pub emit_marker_expression: bool,
    pub no_emit_marker_expression: bool,
    pub emit_index_annotation: bool,
    pub no_emit_index_annotation: bool,
    pub torch_backend: Option<TorchMode>,
    pub compat_args: PipCompileCompatArgs,
}

Fields

src_file: Vec<PathBuf>

Include the packages listed in the given files.

The following formats are supported: requirements.txt, .py files with inline metadata, pylock.toml, pyproject.toml, setup.py, and setup.cfg.

If a pyproject.toml, setup.py, or setup.cfg file is provided, uv will extract the requirements for the relevant project.

If - is provided, then requirements will be read from stdin.

The order of the requirements files and the requirements in them is used to determine priority during resolution.

constraints: Vec<Maybe<PathBuf>>

Constrain versions using the given requirements files.

Constraints files are requirements.txt-like files that only control the version of a requirement that’s installed. However, including a package in a constraints file will not trigger the installation of that package.

This is equivalent to pip’s --constraint option.

overrides: Vec<Maybe<PathBuf>>

Override versions using the given requirements files.

Overrides files are requirements.txt-like files that force a specific version of a requirement to be installed, regardless of the requirements declared by any constituent package, and regardless of whether this would be considered an invalid resolution.

While constraints are additive, in that they’re combined with the requirements of the constituent packages, overrides are absolute, in that they completely replace the requirements of the constituent packages.

excludes: Vec<Maybe<PathBuf>>

Exclude packages from resolution using the given requirements files.

Excludes files are requirements.txt-like files that specify packages to exclude from the resolution. When a package is excluded, it will be omitted from the dependency list entirely and its own dependencies will be ignored during the resolution phase. Excludes are unconditional in that requirement specifiers and markers are ignored; any package listed in the provided file will be omitted from all resolved environments.

build_constraints: Vec<Maybe<PathBuf>>

Constrain build dependencies using the given requirements files when building source distributions.

Constraints files are requirements.txt-like files that only control the version of a requirement that’s installed. However, including a package in a constraints file will not trigger the installation of that package.

extra: Option<Vec<ExtraName>>

Include optional dependencies from the specified extra name; may be provided more than once.

Only applies to pyproject.toml, setup.py, and setup.cfg sources.

all_extras: bool

Include all optional dependencies.

Only applies to pyproject.toml, setup.py, and setup.cfg sources.

no_all_extras: bool

group: Vec<PipGroupName>

Install the specified dependency group from a pyproject.toml.

If no path is provided, the pyproject.toml in the working directory is used.

May be provided multiple times.

resolver: ResolverArgs

refresh: RefreshArgs

no_deps: bool

Ignore package dependencies, instead only add those packages explicitly listed on the command line to the resulting requirements file.

deps: bool

output_file: Option<PathBuf>

Write the compiled requirements to the given requirements.txt or pylock.toml file.

If the file already exists, the existing versions will be preferred when resolving dependencies, unless --upgrade is also specified.

format: Option<PipCompileFormat>

The format in which the resolution should be output.

Supports both requirements.txt and pylock.toml (PEP 751) output formats.

uv will infer the output format from the file extension of the output file, if provided. Otherwise, defaults to requirements.txt.

no_strip_extras: bool

Include extras in the output file.

By default, uv strips extras, as any packages pulled in by the extras are already included as dependencies in the output file directly. Further, output files generated with --no-strip-extras cannot be used as constraints files in install and sync invocations.

strip_extras: bool

no_strip_markers: bool

Include environment markers in the output file.

By default, uv strips environment markers, as the resolution generated by compile is only guaranteed to be correct for the target environment.

strip_markers: bool

no_annotate: bool

Exclude comment annotations indicating the source of each package.

annotate: bool

no_header: bool

Exclude the comment header at the top of the generated output file.

header: bool

annotation_style: Option<AnnotationStyle>

The style of the annotation comments included in the output file, used to indicate the source of each package.

Defaults to split.

custom_compile_command: Option<String>

The header comment to include at the top of the output file generated by uv pip compile.

Used to reflect custom build scripts and commands that wrap uv pip compile.

python: Option<Maybe<String>>

The Python interpreter to use during resolution.

A Python interpreter is required for building source distributions to determine package metadata when there are not wheels.

The interpreter is also used to determine the default minimum Python version, unless --python-version is provided.

This option respects UV_PYTHON, but when set via environment variable, it is overridden by --python-version.

See uv help python for details on Python discovery and supported request formats.

system: bool

Install packages into the system Python environment.

By default, uv uses the virtual environment in the current working directory or any parent directory, falling back to searching for a Python executable in PATH. The --system option instructs uv to avoid using a virtual environment Python and restrict its search to the system path.

no_system: bool

generate_hashes: bool

Include distribution hashes in the output file.

no_generate_hashes: bool

no_build: bool

Don’t build source distributions.

When enabled, resolving will not run arbitrary Python code. The cached wheels of already-built source distributions will be reused, but operations that require building distributions will exit with an error.

Alias for --only-binary :all:.

build: bool

no_binary: Option<Vec<PackageNameSpecifier>>

Don’t install pre-built wheels.

The given packages will be built and installed from source. The resolver will still use pre-built wheels to extract package metadata, if available.

Multiple packages may be provided. Disable binaries for all packages with :all:. Clear previously specified packages with :none:.

only_binary: Option<Vec<PackageNameSpecifier>>

Only use pre-built wheels; don’t build source distributions.

When enabled, resolving will not run code from the given packages. The cached wheels of already-built source distributions will be reused, but operations that require building distributions will exit with an error.

Multiple packages may be provided. Disable binaries for all packages with :all:. Clear previously specified packages with :none:.

python_version: Option<PythonVersion>

The Python version to use for resolution.

For example, 3.8 or 3.8.17.

Defaults to the version of the Python interpreter used for resolution.

Defines the minimum Python version that must be supported by the resolved requirements.

If a patch version is omitted, the minimum patch version is assumed. For example, 3.8 is mapped to 3.8.0.

python_platform: Option<TargetTriple>

The platform for which requirements should be resolved.

Represented as a “target triple”, a string that describes the target platform in terms of its CPU, vendor, and operating system name, like x86_64-unknown-linux-gnu or aarch64-apple-darwin.

When targeting macOS (Darwin), the default minimum version is 13.0. Use MACOSX_DEPLOYMENT_TARGET to specify a different minimum version, e.g., 14.0.

When targeting iOS, the default minimum version is 13.0. Use IPHONEOS_DEPLOYMENT_TARGET to specify a different minimum version, e.g., 14.0.

When targeting Android, the default minimum Android API level is 24. Use ANDROID_API_LEVEL to specify a different minimum version, e.g., 26.

universal: bool

Perform a universal resolution, attempting to generate a single requirements.txt output file that is compatible with all operating systems, architectures, and Python implementations.

In universal mode, the current Python version (or user-provided --python-version) will be treated as a lower bound. For example, --universal --python-version 3.7 would produce a universal resolution for Python 3.7 and later.

Implies --no-strip-markers.

no_universal: bool

no_emit_package: Option<Vec<PackageName>>

Specify a package to omit from the output resolution. Its dependencies will still be included in the resolution. Equivalent to pip-compile’s --unsafe-package option.

emit_index_url: bool

Include --index-url and --extra-index-url entries in the generated output file.

no_emit_index_url: bool

emit_find_links: bool

Include --find-links entries in the generated output file.

no_emit_find_links: bool

emit_build_options: bool

Include --no-binary and --only-binary entries in the generated output file.

no_emit_build_options: bool

emit_marker_expression: bool

Whether to emit a marker string indicating when it is known that the resulting set of pinned dependencies is valid.

The pinned dependencies may be valid even when the marker expression is false, but when the expression is true, the requirements are known to be correct.

no_emit_marker_expression: bool

emit_index_annotation: bool

Include comment annotations indicating the index used to resolve each package (e.g., # from https://pypi.org/simple).

no_emit_index_annotation: bool

torch_backend: Option<TorchMode>

The backend to use when fetching packages in the PyTorch ecosystem (e.g., cpu, cu126, or auto).

When set, uv will ignore the configured index URLs for packages in the PyTorch ecosystem, and will instead use the defined backend.

For example, when set to cpu, uv will use the CPU-only PyTorch index; when set to cu126, uv will use the PyTorch index for CUDA 12.6.

The auto mode will attempt to detect the appropriate PyTorch index based on the currently installed CUDA drivers.

This option is in preview and may change in any future release.

compat_args: PipCompileCompatArgs

Trait Implementations

impl Args for PipCompileArgs

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl FromArgMatches for PipCompileArgs

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.