Struct Options 

pub struct Options {

    pub globals: GlobalOptions,
    pub top_level: ResolverInstallerSchema,
    pub install_mirrors: PythonInstallMirrors,
    pub publish: PublishOptions,
    pub add: AddOptions,
    pub pip: Option<PipOptions>,
    pub cache_keys: Option<Vec<CacheKey>>,
    pub override_dependencies: Option<Vec<Requirement<VerbatimParsedUrl>>>,
    pub exclude_dependencies: Option<Vec<PackageName>>,
    pub constraint_dependencies: Option<Vec<Requirement<VerbatimParsedUrl>>>,
    pub build_constraint_dependencies: Option<Vec<Requirement<VerbatimParsedUrl>>>,
    pub environments: Option<SupportedEnvironments>,
    pub required_environments: Option<SupportedEnvironments>,
    pub conflicts: Option<IgnoredAny>,
    pub workspace: Option<IgnoredAny>,
    pub sources: Option<IgnoredAny>,
    pub dev_dependencies: Option<IgnoredAny>,
    pub default_groups: Option<IgnoredAny>,
    pub dependency_groups: Option<IgnoredAny>,
    pub managed: Option<IgnoredAny>,
    pub package: Option<IgnoredAny>,
    pub build_backend: Option<IgnoredAny>,
}

A [tool.uv] section.

Fields

globals: GlobalOptions

top_level: ResolverInstallerSchema

install_mirrors: PythonInstallMirrors

publish: PublishOptions

add: AddOptions

pip: Option<PipOptions>

cache_keys: Option<Vec<CacheKey>>

The keys to consider when caching builds for the project.

Cache keys enable you to specify the files or directories that should trigger a rebuild when modified. By default, uv will rebuild a project whenever the pyproject.toml, setup.py, or setup.cfg files in the project directory are modified, or if a src directory is added or removed, i.e.:

cache-keys = [{ file = "pyproject.toml" }, { file = "setup.py" }, { file = "setup.cfg" }, { dir = "src" }]

As an example: if a project uses dynamic metadata to read its dependencies from a requirements.txt file, you can specify cache-keys = [{ file = "requirements.txt" }, { file = "pyproject.toml" }] to ensure that the project is rebuilt whenever the requirements.txt file is modified (in addition to watching the pyproject.toml).

Globs are supported, following the syntax of the glob crate. For example, to invalidate the cache whenever a .toml file in the project directory or any of its subdirectories is modified, you can specify cache-keys = [{ file = "**/*.toml" }]. Note that the use of globs can be expensive, as uv may need to walk the filesystem to determine whether any files have changed.

Cache keys can also include version control information. For example, if a project uses setuptools_scm to read its version from a Git commit, you can specify cache-keys = [{ git = { commit = true }, { file = "pyproject.toml" }] to include the current Git commit hash in the cache key (in addition to the pyproject.toml). Git tags are also supported via cache-keys = [{ git = { commit = true, tags = true } }].

Cache keys can also include environment variables. For example, if a project relies on MACOSX_DEPLOYMENT_TARGET or other environment variables to determine its behavior, you can specify cache-keys = [{ env = "MACOSX_DEPLOYMENT_TARGET" }] to invalidate the cache whenever the environment variable changes.

Cache keys only affect the project defined by the pyproject.toml in which they’re specified (as opposed to, e.g., affecting all members in a workspace), and all paths and globs are interpreted as relative to the project directory.

override_dependencies: Option<Vec<Requirement<VerbatimParsedUrl>>>

exclude_dependencies: Option<Vec<PackageName>>

constraint_dependencies: Option<Vec<Requirement<VerbatimParsedUrl>>>

build_constraint_dependencies: Option<Vec<Requirement<VerbatimParsedUrl>>>

environments: Option<SupportedEnvironments>

required_environments: Option<SupportedEnvironments>

conflicts: Option<IgnoredAny>

workspace: Option<IgnoredAny>

sources: Option<IgnoredAny>

dev_dependencies: Option<IgnoredAny>

default_groups: Option<IgnoredAny>

dependency_groups: Option<IgnoredAny>

managed: Option<IgnoredAny>

package: Option<IgnoredAny>

build_backend: Option<IgnoredAny>

Implementations

impl Options

pub fn simple( globals: GlobalOptions, top_level: ResolverInstallerSchema, ) -> Self

Construct an Options with the given global and top-level settings.

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

Resolve the Options relative to the given root directory.

Trait Implementations

impl Clone for Options

fn clone(&self) -> Options

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Combine for Options

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

Combine two values, preferring the values in self.

impl Debug for Options

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

Formats the value using the given formatter.

impl Default for Options

fn default() -> Options

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Options

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Options> for FilesystemOptions

fn from(options: Options) -> Self

Converts to this type from the input type.

impl From<OptionsWire> for Options

fn from(value: OptionsWire) -> Self

Converts to this type from the input type.

impl OptionsMetadata for Options

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.