Struct UniversalMarker 

pub struct UniversalMarker { /* private fields */ }

A representation of a marker for use in universal resolution.

(This degrades gracefully to a standard PEP 508 marker in the case of non-universal resolution.)

This universal marker is meant to combine both a PEP 508 marker and a marker for conflicting extras/groups. The latter specifically expresses whether a particular edge in a dependency graph should be followed depending on the activated extras and groups.

A universal marker evaluates to true only when both its PEP 508 marker and its conflict marker evaluate to true.

Implementations

impl UniversalMarker

pub const TRUE: UniversalMarker

A constant universal marker that always evaluates to true.

pub const FALSE: UniversalMarker

A constant universal marker that always evaluates to false.

pub fn new( pep508_marker: MarkerTree, conflict_marker: ConflictMarker, ) -> UniversalMarker

Creates a new universal marker from its constituent pieces.

pub fn from_combined(marker: MarkerTree) -> UniversalMarker

Creates a new universal marker from a marker that has already been combined from a PEP 508 and conflict marker.

pub fn or(&mut self, other: UniversalMarker)

Combine this universal marker with the one given in a way that unions them. That is, the updated marker will evaluate to true if self or other evaluate to true.

pub fn and(&mut self, other: UniversalMarker)

Combine this universal marker with the one given in a way that intersects them. That is, the updated marker will evaluate to true if self and other evaluate to true.

pub fn imbibe(&mut self, conflicts: ConflictMarker)

Imbibes the world knowledge expressed by conflicts into this marker.

This will effectively simplify the conflict marker in this universal marker. In particular, it enables simplifying based on the fact that no two items from the same set in the given conflicts can be active at a given time. If every valid selection has the same nonempty environment marker, the result contains only that environment marker. Otherwise, invalid selections remain reachable so lockfile readers can discover transitive conflicts.

pub fn assume_conflict_item(&mut self, item: &ConflictItem)

Assumes that a given extra/group for the given package is activated.

This may simplify the conflicting marker component of this universal marker.

pub fn assume_not_conflict_item(&mut self, item: &ConflictItem)

Assumes that a given extra/group for the given package is not activated.

This may simplify the conflicting marker component of this universal marker.

pub fn is_true(self) -> bool

Returns true if this universal marker will always evaluate to true.

pub fn is_false(self) -> bool

Returns true if this universal marker will always evaluate to false.

pub fn has_conflict_marker(self) -> bool

Returns true if this universal marker contains a conflict marker.

Conflict items are encoded as extra expressions in marker, while pep508 is the same canonical marker with all extra expressions removed. Since MarkerTree equality is semantic, the trees differ exactly when the marker depends on a conflict item.

pub fn is_disjoint(self, other: UniversalMarker) -> bool

Returns true if this universal marker is disjoint with the one given.

Two universal markers are disjoint when it is impossible for them both to evaluate to true simultaneously.

pub fn evaluate_no_extras(self, env: &MarkerEnvironment) -> bool

Returns true if this universal marker is satisfied by the given marker environment.

This should only be used when evaluating a marker that is known not to have any extras. For example, the PEP 508 markers on a fork.

pub fn evaluate<P, E, G>( self, env: &MarkerEnvironment, projects: impl Iterator<Item = P>, extras: impl Iterator<Item = (P, E)>, groups: impl Iterator<Item = (P, G)>, ) -> bool

where P: Borrow<PackageName>, E: Borrow<ExtraName>, G: Borrow<GroupName>,

Returns true if this universal marker is satisfied by the given marker environment and list of activated projects, extras, and groups.

The activated extras and groups should be the complete set activated for a particular context. And each extra and group must be scoped to the particular package that it’s enabled for.

pub fn evaluate_activated( self, env: &MarkerEnvironment, activated: &ActivatedConflictItems, ) -> bool

Returns true if this universal marker is satisfied by an already encoded activated set.

pub fn combined(self) -> MarkerTree

Returns the internal marker that combines both the PEP 508 and conflict marker.

pub fn pep508(self) -> MarkerTree

Returns the PEP 508 marker for this universal marker.

One should be cautious using this. Generally speaking, it should only be used when one knows universal resolution isn’t in effect. When universal resolution is enabled (i.e., there may be multiple forks producing different versions of the same package), then one should always use a universal marker since it accounts for all possible ways for a package to be installed.

pub fn conflict(self) -> ConflictMarker

Returns the non-PEP 508 marker expression that represents conflicting extras/groups.

Like with UniversalMarker::pep508, one should be cautious when using this. It is generally always wrong to consider conflicts in isolation from PEP 508 markers. But this can be useful for detecting failure cases. For example, the code for emitting a ResolverOutput (even a universal one) in a requirements.txt format checks for the existence of non-trivial conflict markers and fails if any are found. (Because conflict markers cannot be represented in the requirements.txt format.)

pub fn conflict_for_environment(self, env: &MarkerEnvironment) -> ConflictMarker

Returns the conflict marker that remains after evaluating all PEP 508 expressions in the given environment.

Unlike UniversalMarker::conflict, this preserves the relationship between PEP 508 and conflict expressions. For example, given sys_platform == 'linux' or extra == 'foo', the conflict marker is always true on Linux but still depends on foo elsewhere.

Trait Implementations

impl Boolean for UniversalMarker

fn and(&mut self, other: UniversalMarker)

Perform a logical AND operation with another marker.

fn or(&mut self, other: UniversalMarker)

Perform a logical OR operation with another marker.

impl Clone for UniversalMarker

fn clone(&self) -> UniversalMarker

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for UniversalMarker

impl Debug for UniversalMarker

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

Formats the value using the given formatter.

impl Default for UniversalMarker

fn default() -> UniversalMarker

Returns the “default value” for a type.

impl Eq for UniversalMarker

impl Hash for UniversalMarker

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for UniversalMarker

fn cmp(&self, other: &UniversalMarker) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for UniversalMarker

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for UniversalMarker

fn partial_cmp(&self, other: &UniversalMarker) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Reachable<UniversalMarker> for UniversalMarker

fn true_marker() -> UniversalMarker

The marker representing the “true” value.

fn false_marker() -> UniversalMarker

The marker representing the “false” value.

fn marker(&self) -> UniversalMarker

The marker attached to the edge.

impl StructuralPartialEq for UniversalMarker