Struct PipOptions 

pub struct PipOptions {

    pub python: Option<String>,
    pub system: Option<bool>,
    pub break_system_packages: Option<bool>,
    pub target: Option<PathBuf>,
    pub prefix: Option<PathBuf>,
    pub index: Option<Vec<Index>>,
    pub index_url: Option<PipIndex>,
    pub extra_index_url: Option<Vec<PipExtraIndex>>,
    pub no_index: Option<bool>,
    pub find_links: Option<Vec<PipFindLinks>>,
    pub index_strategy: Option<IndexStrategy>,
    pub keyring_provider: Option<KeyringProviderType>,
    pub no_build: Option<bool>,
    pub no_binary: Option<Vec<PackageNameSpecifier>>,
    pub only_binary: Option<Vec<PackageNameSpecifier>>,
    pub no_build_isolation: Option<bool>,
    pub no_build_isolation_package: Option<Vec<PackageName>>,
    pub extra_build_dependencies: Option<ExtraBuildDependencies>,
    pub extra_build_variables: Option<ExtraBuildVariables>,
    pub strict: Option<bool>,
    pub extra: Option<Vec<ExtraName>>,
    pub all_extras: Option<bool>,
    pub no_extra: Option<Vec<ExtraName>>,
    pub no_deps: Option<bool>,
    pub group: Option<Vec<PipGroupName>>,
    pub allow_empty_requirements: Option<bool>,
    pub resolution: Option<ResolutionMode>,
    pub prerelease: Option<PrereleaseMode>,
    pub fork_strategy: Option<ForkStrategy>,
    pub dependency_metadata: Option<Vec<StaticMetadata>>,
    pub output_file: Option<PathBuf>,
    pub no_strip_extras: Option<bool>,
    pub no_strip_markers: Option<bool>,
    pub no_annotate: Option<bool>,
    pub no_header: Option<bool>,
    pub custom_compile_command: Option<String>,
    pub generate_hashes: Option<bool>,
    pub config_settings: Option<ConfigSettings>,
    pub config_settings_package: Option<PackageConfigSettings>,
    pub python_version: Option<PythonVersion>,
    pub python_platform: Option<TargetTriple>,
    pub universal: Option<bool>,
    pub exclude_newer: Option<ExcludeNewerTimestamp>,
    pub exclude_newer_package: Option<ExcludeNewerPackage>,
    pub no_emit_package: Option<Vec<PackageName>>,
    pub emit_index_url: Option<bool>,
    pub emit_find_links: Option<bool>,
    pub emit_build_options: Option<bool>,
    pub emit_marker_expression: Option<bool>,
    pub emit_index_annotation: Option<bool>,
    pub annotation_style: Option<AnnotationStyle>,
    pub link_mode: Option<LinkMode>,
    pub compile_bytecode: Option<bool>,
    pub require_hashes: Option<bool>,
    pub verify_hashes: Option<bool>,
    pub no_sources: Option<bool>,
    pub upgrade: Option<bool>,
    pub upgrade_package: Option<Vec<Requirement<VerbatimParsedUrl>>>,
    pub reinstall: Option<bool>,
    pub reinstall_package: Option<Vec<PackageName>>,
    pub torch_backend: Option<TorchMode>,
}

Settings that are specific to the uv pip command-line interface.

These values will be ignored when running commands outside the uv pip namespace (e.g., uv lock, uvx).

Fields

python: Option<String>

The Python interpreter into which packages should be installed.

By default, uv installs into the virtual environment in the current working directory or any parent directory. The --python option allows you to specify a different interpreter, which is intended for use in continuous integration (CI) environments or other automated workflows.

Supported formats:

• 3.10 looks for an installed Python 3.10 in the registry on Windows (see py --list-paths), or python3.10 on Linux and macOS.
• python3.10 or python.exe looks for a binary with the given name in PATH.
• /home/ferris/.local/bin/python3.10 uses the exact Python at the given path.

system: Option<bool>

Install packages into the system Python environment.

By default, uv installs into the virtual environment in the current working directory or any parent directory. The --system option instructs uv to instead use the first Python found in the system PATH.

WARNING: --system is intended for use in continuous integration (CI) environments and should be used with caution, as it can modify the system Python installation.

break_system_packages: Option<bool>

Allow uv to modify an EXTERNALLY-MANAGED Python installation.

WARNING: --break-system-packages is intended for use in continuous integration (CI) environments, when installing into Python installations that are managed by an external package manager, like apt. It should be used with caution, as such Python installations explicitly recommend against modifications by other package managers (like uv or pip).

target: Option<PathBuf>

Install packages into the specified directory, rather than into the virtual or system Python environment. The packages will be installed at the top-level of the directory.

prefix: Option<PathBuf>

Install packages into lib, bin, and other top-level folders under the specified directory, as if a virtual environment were present at that location.

In general, prefer the use of --python to install into an alternate environment, as scripts and other artifacts installed via --prefix will reference the installing interpreter, rather than any interpreter added to the --prefix directory, rendering them non-portable.

index: Option<Vec<Index>>

index_url: Option<PipIndex>

The URL of the Python package index (by default: https://pypi.org/simple).

Accepts either a repository compliant with PEP 503 (the simple repository API), or a local directory laid out in the same format.

The index provided by this setting is given lower priority than any indexes specified via extra_index_url.

extra_index_url: Option<Vec<PipExtraIndex>>

Extra URLs of package indexes to use, in addition to --index-url.

Accepts either a repository compliant with PEP 503 (the simple repository API), or a local directory laid out in the same format.

All indexes provided via this flag take priority over the index specified by index_url. When multiple indexes are provided, earlier values take priority.

To control uv’s resolution strategy when multiple indexes are present, see index_strategy.

no_index: Option<bool>

Ignore all registry indexes (e.g., PyPI), instead relying on direct URL dependencies and those provided via --find-links.

find_links: Option<Vec<PipFindLinks>>

Locations to search for candidate distributions, in addition to those found in the registry indexes.

If a path, the target must be a directory that contains packages as wheel files (.whl) or source distributions (e.g., .tar.gz or .zip) at the top level.

If a URL, the page must contain a flat list of links to package files adhering to the formats described above.

index_strategy: Option<IndexStrategy>

The strategy to use when resolving against multiple index URLs.

By default, uv will stop at the first index on which a given package is available, and limit resolutions to those present on that first index (first-index). This prevents “dependency confusion” attacks, whereby an attacker can upload a malicious package under the same name to an alternate index.

keyring_provider: Option<KeyringProviderType>

Attempt to use keyring for authentication for index URLs.

At present, only --keyring-provider subprocess is supported, which configures uv to use the keyring CLI to handle authentication.

no_build: Option<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:.

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:.

no_build_isolation: Option<bool>

Disable isolation when building source distributions.

Assumes that build dependencies specified by PEP 518 are already installed.

no_build_isolation_package: Option<Vec<PackageName>>

Disable isolation when building source distributions for a specific package.

Assumes that the packages’ build dependencies specified by PEP 518 are already installed.

extra_build_dependencies: Option<ExtraBuildDependencies>

Additional build dependencies for packages.

This allows extending the PEP 517 build environment for the project’s dependencies with additional packages. This is useful for packages that assume the presence of packages like pip, and do not declare them as build dependencies.

extra_build_variables: Option<ExtraBuildVariables>

Extra environment variables to set when building certain packages.

Environment variables will be added to the environment when building the specified packages.

strict: Option<bool>

Validate the Python environment, to detect packages with missing dependencies and other issues.

extra: Option<Vec<ExtraName>>

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

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

all_extras: Option<bool>

Include all optional dependencies.

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

no_extra: Option<Vec<ExtraName>>

Exclude the specified optional dependencies if all-extras is supplied.

no_deps: Option<bool>

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

group: Option<Vec<PipGroupName>>

Include the following dependency groups.

allow_empty_requirements: Option<bool>

Allow uv pip sync with empty requirements, which will clear the environment of all packages.

resolution: Option<ResolutionMode>

The strategy to use when selecting between the different compatible versions for a given package requirement.

By default, uv will use the latest compatible version of each package (highest).

prerelease: Option<PrereleaseMode>

The strategy to use when considering pre-release versions.

By default, uv will accept pre-releases for packages that only publish pre-releases, along with first-party requirements that contain an explicit pre-release marker in the declared specifiers (if-necessary-or-explicit).

fork_strategy: Option<ForkStrategy>

The strategy to use when selecting multiple versions of a given package across Python versions and platforms.

By default, uv will optimize for selecting the latest version of each package for each supported Python version (requires-python), while minimizing the number of selected versions across platforms.

Under fewest, uv will minimize the number of selected versions for each package, preferring older versions that are compatible with a wider range of supported Python versions or platforms.

dependency_metadata: Option<Vec<StaticMetadata>>

Pre-defined static metadata for dependencies of the project (direct or transitive). When provided, enables the resolver to use the specified metadata instead of querying the registry or building the relevant package from source.

Metadata should be provided in adherence with the Metadata 2.3 standard, though only the following fields are respected:

• name: The name of the package.
• (Optional) version: The version of the package. If omitted, the metadata will be applied to all versions of the package.
• (Optional) requires-dist: The dependencies of the package (e.g., werkzeug>=0.14).
• (Optional) requires-python: The Python version required by the package (e.g., >=3.10).
• (Optional) provides-extra: The extras provided by the package.

output_file: Option<PathBuf>

Write the requirements generated by uv pip compile to the given requirements.txt file.

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

no_strip_extras: Option<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.

no_strip_markers: Option<bool>

Include environment markers in the output file generated by uv pip compile.

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

no_annotate: Option<bool>

Exclude comment annotations indicating the source of each package from the output file generated by uv pip compile.

no_header: Option<bool>

Exclude the comment header at the top of output file generated by uv pip compile.

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.

generate_hashes: Option<bool>

Include distribution hashes in the output file.

config_settings: Option<ConfigSettings>

Settings to pass to the PEP 517 build backend, specified as KEY=VALUE pairs.

config_settings_package: Option<PackageConfigSettings>

Settings to pass to the PEP 517 build backend for specific packages, specified as KEY=VALUE pairs.

python_version: Option<PythonVersion>

The minimum Python version that should be supported by the resolved requirements (e.g., 3.8 or 3.8.17).

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.

universal: Option<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.

exclude_newer: Option<ExcludeNewerTimestamp>

Limit candidate packages to those that were uploaded prior to a given point in time.

Accepts a superset of RFC 3339 (e.g., 2006-12-02T02:07:43Z). A full timestamp is required to ensure that the resolver will behave consistently across timezones.

exclude_newer_package: Option<ExcludeNewerPackage>

Limit candidate packages for specific packages to those that were uploaded prior to the given date.

Accepts package-date pairs in a dictionary format.

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: Option<bool>

Include --index-url and --extra-index-url entries in the output file generated by uv pip compile.

emit_find_links: Option<bool>

Include --find-links entries in the output file generated by uv pip compile.

emit_build_options: Option<bool>

Include --no-binary and --only-binary entries in the output file generated by uv pip compile.

emit_marker_expression: Option<bool>

Whether to emit a marker string indicating the conditions under which the 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.

emit_index_annotation: Option<bool>

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

annotation_style: Option<AnnotationStyle>

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

link_mode: Option<LinkMode>

The method to use when installing packages from the global cache.

Defaults to clone (also known as Copy-on-Write) on macOS, and hardlink on Linux and Windows.

WARNING: The use of symlink link mode is discouraged, as they create tight coupling between the cache and the target environment. For example, clearing the cache (uv cache clean) will break all installed packages by way of removing the underlying source files. Use symlinks with caution.

compile_bytecode: Option<bool>

Compile Python files to bytecode after installation.

By default, uv does not compile Python (.py) files to bytecode (__pycache__/*.pyc); instead, compilation is performed lazily the first time a module is imported. For use-cases in which start time is critical, such as CLI applications and Docker containers, this option can be enabled to trade longer installation times for faster start times.

When enabled, uv will process the entire site-packages directory (including packages that are not being modified by the current operation) for consistency. Like pip, it will also ignore errors.

require_hashes: Option<bool>

Require a matching hash for each requirement.

Hash-checking mode is all or nothing. If enabled, all requirements must be provided with a corresponding hash or set of hashes. Additionally, if enabled, all requirements must either be pinned to exact versions (e.g., ==1.0.0), or be specified via direct URL.

Hash-checking mode introduces a number of additional constraints:

• Git dependencies are not supported.
• Editable installations are not supported.
• Local dependencies are not supported, unless they point to a specific wheel (.whl) or source archive (.zip, .tar.gz), as opposed to a directory.

verify_hashes: Option<bool>

Validate any hashes provided in the requirements file.

Unlike --require-hashes, --verify-hashes does not require that all requirements have hashes; instead, it will limit itself to verifying the hashes of those requirements that do include them.

no_sources: Option<bool>

Ignore the tool.uv.sources table when resolving dependencies. Used to lock against the standards-compliant, publishable package metadata, as opposed to using any local or Git sources.

upgrade: Option<bool>

Allow package upgrades, ignoring pinned versions in any existing output file.

upgrade_package: Option<Vec<Requirement<VerbatimParsedUrl>>>

Allow upgrades for a specific package, ignoring pinned versions in any existing output file.

Accepts both standalone package names (ruff) and version specifiers (ruff<0.5.0).

reinstall: Option<bool>

Reinstall all packages, regardless of whether they’re already installed. Implies refresh.

reinstall_package: Option<Vec<PackageName>>

Reinstall a specific package, regardless of whether it’s already installed. Implies refresh-package.

torch_backend: Option<TorchMode>

The backend to use when fetching packages in the PyTorch ecosystem.

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.

Implementations

impl PipOptions

pub fn relative_to(self, root_dir: &Path) -> Result<Self, IndexUrlError>

Resolve the PipOptions relative to the given root directory.

Trait Implementations

impl Clone for PipOptions

fn clone(&self) -> PipOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Combine for PipOptions

fn combine(self, other: PipOptions) -> PipOptions

Combine two values, preferring the values in self.

impl Debug for PipOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PipOptions

fn default() -> PipOptions

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PipOptions

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl OptionsMetadata for PipOptions

fn record(visit: &mut dyn Visit)

Visits the options metadata of this object by calling visit for each option.

fn documentation() -> Option<&'static str>

fn metadata() -> OptionSet

where Self: Sized + 'static,

Returns the extracted metadata.