Struct ResolverEnvironment 

pub struct ResolverEnvironment { /* private fields */ }

Represents one or more marker environments for a resolution.

Dependencies outside of the marker environments represented by this value are ignored for that particular resolution.

In normal “pip”-style resolution, one resolver environment corresponds to precisely one marker environment. In universal resolution, multiple marker environments may be specified via a PEP 508 marker expression. In either case, as mentioned above, dependencies not in these marker environments are ignored for the corresponding resolution.

Callers must provide this to the resolver to indicate, broadly, what kind of resolution it will produce. Generally speaking, callers should provide a specific marker environment for uv pip-style resolutions and ask for a universal resolution for uv’s project based commands like uv lock.

Callers can rely on this type being reasonably cheap to clone.

Internals

Inside the resolver, when doing a universal resolution, it may create many “forking” states to deal with the fact that there may be multiple incompatible dependency specifications. Specifically, in the Python world, the main constraint is that for any one specific marker environment, there must be only one version of a package in a corresponding resolution. But when doing a universal resolution, we want to support many marker environments, and in this context, the “universal” resolution may contain multiple versions of the same package. This is allowed so long as, for any marker environment supported by this resolution, an installation will select at most one version of any given package.

During resolution, a ResolverEnvironment is attached to each internal fork. For non-universal or “specific” resolution, there is only ever one fork because a ResolverEnvironment corresponds to one and exactly one marker environment. For universal resolution, the resolver may choose to split its execution into multiple branches. Each of those branches (also called “forks” or “splits”) will get its own marker expression that represents a set of marker environments that is guaranteed to be disjoint with the marker environments described by the marker expressions of all other branches.

Whether it’s universal resolution or not, and whether it’s one of many forks or one fork, this type represents the set of possible dependency specifications allowed in the resolution produced by a single fork.

An exception to this is requires-python. That is handled separately and explicitly by the resolver. (Perhaps a future refactor can incorporate requires-python into this type as well, but it’s not totally clear at time of writing if that’s a good idea or not.)

Implementations

impl ResolverEnvironment

pub fn specific(marker_env: ResolverMarkerEnvironment) -> Self

Create a resolver environment that is fixed to one and only one marker environment.

This enables uv pip-style resolutions. That is, the resolution returned is only guaranteed to be installable for this specific marker environment.

pub fn universal(initial_forks: Vec<MarkerTree>) -> Self

Create a resolver environment for producing a multi-platform resolution.

The set of marker expressions given corresponds to an initial seeded set of resolver branches. This might come from a lock file corresponding to the set of forks produced by a previous resolution, or it might come from a human crafted set of marker expressions.

The “normal” case is that the initial forks are empty. When empty, resolution will create forks as needed to deal with potentially conflicting dependency specifications across distinct marker environments.

The order of the initial forks is significant, although we don’t guarantee any specific treatment (similar to, at time of writing, how the order of dependencies specified is also significant but has no specific guarantees around it). Changing the ordering can help when our custom fork prioritization fails.

pub fn marker_environment(&self) -> Option<&MarkerEnvironment>

Returns the marker environment corresponding to this resolver environment.

This only returns a marker environment when resolving for a specific marker environment. i.e., A non-universal or “pip”-style resolution.

Trait Implementations

impl Clone for ResolverEnvironment

fn clone(&self) -> ResolverEnvironment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResolverEnvironment

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

Formats the value using the given formatter.

impl Display for ResolverEnvironment

A user visible representation of a resolver environment.

This is most useful in error and log messages.

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

Formats the value using the given formatter.

impl PartialEq for ResolverEnvironment

fn eq(&self, other: &ResolverEnvironment) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ResolverEnvironment

impl StructuralPartialEq for ResolverEnvironment