Struct RequiresPython 

pub struct RequiresPython { /* private fields */ }

The Requires-Python requirement specifier.

See: https://packaging.python.org/en/latest/guides/dropping-older-python-versions/

Implementations

impl RequiresPython

pub fn greater_than_equal_version(version: &Version) -> Self

Returns a RequiresPython to express >= equality with the given version.

pub fn from_specifiers(specifiers: &VersionSpecifiers) -> Self

Returns a RequiresPython from a version specifier.

pub fn intersection<'a>( specifiers: impl Iterator<Item = &'a VersionSpecifiers>, ) -> Option<Self>

Returns a RequiresPython to express the intersection of the given version specifiers.

For example, given >=3.8 and >=3.9, this would return >=3.9.

pub fn split(&self, bound: Bound<Version>) -> Option<(Self, Self)>

Split the RequiresPython at the given version.

For example, if the current requirement is >=3.10, and the split point is 3.11, then the result will be >=3.10 and <3.11 and >=3.11.

pub fn narrow(&self, range: &RequiresPythonRange) -> Option<Self>

Narrow the RequiresPython by computing the intersection with the given range.

Returns None if the given range is not narrower than the current range.

pub fn to_marker_tree(&self) -> MarkerTree

Returns this Requires-Python specifier as an equivalent MarkerTree utilizing the python_full_version marker field.

This is useful for comparing a Requires-Python specifier with arbitrary marker expressions. For example, one can ask whether the returned marker expression is disjoint with another marker expression. If it is, then one can conclude that the Requires-Python specifier excludes the dependency with that other marker expression.

If this Requires-Python specifier has no constraints, then this returns a marker tree that evaluates to true for all possible marker environments.

pub fn contains(&self, version: &Version) -> bool

Returns true if the Requires-Python is compatible with the given version.

N.B. This operation should primarily be used when evaluating compatibility of Python versions against the user’s own project. For example, if the user defines a requires-python in a pyproject.toml, this operation could be used to determine whether a given Python interpreter is compatible with the user’s project.

pub fn is_contained_by(&self, target: &VersionSpecifiers) -> bool

Returns true if the Requires-Python is contained by the given version specifiers.

In this context, we treat Requires-Python as a lower bound. For example, if the requirement expresses >=3.8, <4, we treat it as >=3.8. Requires-Python itself was intended to enable packages to drop support for older versions of Python without breaking installations on those versions, and packages cannot know whether they are compatible with future, unreleased versions of Python.

The specifiers are considered to “contain” the Requires-Python if the specifiers are compatible with all versions in the Requires-Python range (i.e., have a lower lower bound).

For example, if the Requires-Python is >=3.8, then >=3.7 would be considered compatible, since all versions in the Requires-Python range are also covered by the provided range. However, >=3.9 would not be considered compatible, as the Requires-Python includes Python 3.8, but >=3.9 does not.

N.B. This operation should primarily be used when evaluating the compatibility of a project’s Requires-Python specifier against a dependency’s Requires-Python specifier.

pub fn specifiers(&self) -> &VersionSpecifiers

Returns the VersionSpecifiers for the Requires-Python specifier.

pub fn is_unbounded(&self) -> bool

Returns true if the Requires-Python specifier is unbounded.

pub fn is_exact_without_patch(&self) -> bool

Returns true if the Requires-Python specifier is set to an exact version without specifying a patch version. (e.g. ==3.10)

pub fn range(&self) -> &RequiresPythonRange

Returns the [Range] bounding the Requires-Python specifier.

pub fn abi_tag(&self) -> Option<AbiTag>

Returns a wheel tag that’s compatible with the Requires-Python specifier.

pub fn simplify_markers(&self, marker: MarkerTree) -> MarkerTree

Simplifies the given markers in such a way as to assume that the Python version is constrained by this Python version bound.

For example, with requires-python = '>=3.8', a marker like this:

python_full_version >= '3.8' and python_full_version < '3.12'

Will be simplified to:

python_full_version < '3.12'

That is, python_full_version >= '3.8' is assumed to be true by virtue of requires-python, and is thus not needed in the marker.

This should be used in contexts in which this assumption is valid to make. Generally, this means it should not be used inside the resolver, but instead near the boundaries of the system (like formatting error messages and writing the lock file). The reason for this is that this simplification fundamentally changes the meaning of the marker, and the only correct way to interpret it is in a context in which requires-python is known to be true. For example, when markers from a lock file are deserialized and turned into a ResolutionGraph, the markers are “complexified” to put the requires-python assumption back into the marker explicitly.

pub fn complexify_markers(&self, marker: MarkerTree) -> MarkerTree

The inverse of simplify_markers.

This should be applied near the boundaries of uv when markers are deserialized from a context where requires-python is assumed. For example, with requires-python = '>=3.8' and a marker like:

python_full_version < '3.12'

It will be “complexified” to:

python_full_version >= '3.8' and python_full_version < '3.12'

pub fn matches_wheel_tag(&self, wheel: &WheelFilename) -> bool

Returns false if the wheel’s tags state it can’t be used in the given Python version range.

It is meant to filter out clearly unusable wheels with perfect specificity and acceptable sensitivity, we return true if the tags are unknown.

Trait Implementations

impl Clone for RequiresPython

fn clone(&self) -> RequiresPython

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RequiresPython

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RequiresPython

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for RequiresPython

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

Formats the value using the given formatter.

impl Hash for RequiresPython

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

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 PartialEq for RequiresPython

fn eq(&self, other: &RequiresPython) -> 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 Serialize for RequiresPython

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for RequiresPython

impl StructuralPartialEq for RequiresPython