Struct pep440_rs::VersionSpecifier

pub struct VersionSpecifier { /* private fields */ }

A version range such such as >1.2.3, <=4!5.6.7-a8.post9.dev0 or == 4.1.*. Parse with VersionSpecifier::from_str

use std::str::FromStr;
use pep440_rs::{Version, VersionSpecifier};

let version = Version::from_str("1.19").unwrap();
let version_specifier = VersionSpecifier::from_str("== 1.*").unwrap();
assert!(version_specifier.contains(&version));

Implementations

impl VersionSpecifier

pub fn new( operator: Operator, version_pattern: VersionPattern ) -> Result<Self, VersionSpecifierBuildError>

Build from parts, validating that the operator is allowed with that version. The last parameter indicates a trailing .*, to differentiate between 1.1.* and 1.1

pub fn equals_version(version: Version) -> Self

==<version>

pub fn operator(&self) -> &Operator

Get the operator, e.g. >= in >= 2.0.0

pub fn version(&self) -> &Version

Get the version, e.g. <= in <= 2.0.0

pub fn any_prerelease(&self) -> bool

Whether the version marker includes a prerelease.

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

Whether the given version satisfies the version range

e.g. >=1.19,<2.0 and 1.21 -> true https://peps.python.org/pep-0440/#version-specifiers

Unlike pypa/packaging, prereleases are included by default

I’m utterly non-confident in the description in PEP 440 and apparently even pip got some of that wrong, e.g. https://github.com/pypa/pip/issues/9121 and https://github.com/pypa/pip/issues/5503, and also i’m not sure if it produces the correct behaviour from a user perspective

This implementation is as close as possible to https://github.com/pypa/packaging/blob/e184feef1a28a5c574ec41f5c263a3a573861f5a/packaging/specifiers.py#L362-L496

Trait Implementations

impl Clone for VersionSpecifier

fn clone(&self) -> VersionSpecifier

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VersionSpecifier

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

Formats the value using the given formatter.

impl Display for VersionSpecifier

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

Formats the value using the given formatter.

impl From<VersionSpecifier> for VersionSpecifiers

fn from(specifier: VersionSpecifier) -> Self

Converts to this type from the input type.

impl FromIterator<VersionSpecifier> for VersionSpecifiers

fn from_iter<T: IntoIterator<Item = VersionSpecifier>>(iter: T) -> Self

Creates a value from an iterator.

impl FromStr for VersionSpecifier

fn from_str(spec: &str) -> Result<Self, Self::Err>

Parses a version such as >= 1.19, == 1.1.*,~=1.0+abc.5 or <=1!2012.2

type Err = VersionSpecifierParseError

The associated error which can be returned from parsing.

impl Hash for VersionSpecifier

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 VersionSpecifier

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for VersionSpecifier

impl StructuralPartialEq for VersionSpecifier