Enum PubGrubPackageInner 

pub enum PubGrubPackageInner {
    Root(Option<PackageName>),
    Python(PubGrubPython),
    System(PackageName),
    Package {
        name: PackageName,
        extra: Option<ExtraName>,
        group: Option<GroupName>,
        marker: MarkerTree,
    },
    Extra {
        name: PackageName,
        extra: ExtraName,
        marker: MarkerTree,
    },
    Group {
        name: PackageName,
        group: GroupName,
        marker: MarkerTree,
    },
    Marker {
        name: PackageName,
        marker: MarkerTree,
    },
}

A PubGrub-compatible wrapper around a “Python package”, with two notable characteristics:

1. Includes a [PubGrubPackage::Root] variant, to satisfy PubGrub’s requirement that a resolution starts from a single root.
2. Uses the same strategy as pip and posy to handle extras: for each extra, we create a virtual package (e.g., black[colorama]), and mark it as a dependency of the real package (e.g., black). We then discard the virtual packages at the end of the resolution process.

Variants

Root(Option<PackageName>)

The root package, which is used to start the resolution process.

Python(PubGrubPython)

A Python version.

System(PackageName)

A system package, which is used to represent a non-Python package.

Package

A Python package.

Note that it is guaranteed that extra and dev are never both Some. That is, if one is Some then the other must be None.

Fields

name: PackageName

extra: Option<ExtraName>

group: Option<GroupName>

marker: MarkerTree

Extra

A proxy package to represent a dependency with an extra (e.g., black[colorama]).

For a given package black, and an extra colorama, we create a virtual package with exactly two dependencies: PubGrubPackage::Package("black", None) and PubGrubPackage::Package("black", Some("colorama"). Both dependencies are pinned to the same version, and the virtual package is discarded at the end of the resolution process.

The benefit of the proxy package (versus PubGrubPackage::Package("black", Some("colorama") on its own) is that it enables us to avoid attempting to retrieve metadata for irrelevant versions the extra variants by making it clear to PubGrub that the extra variant must match the exact same version of the base variant. Without the proxy package, then when provided requirements like black==23.0.1 and black[colorama], PubGrub may attempt to retrieve metadata for black[colorama] versions other than 23.0.1.

Fields

name: PackageName

extra: ExtraName

marker: MarkerTree

Group

A proxy package to represent an enabled dependency group.

This is similar in spirit to PEP 735 and similar in implementation to the Extra variant. The main difference is that we treat groups as enabled globally, rather than on a per-requirement basis.

Fields

name: PackageName

group: GroupName

marker: MarkerTree

Marker

A proxy package for a base package with a marker (e.g., black; python_version >= "3.6").

If a requirement has an extra and a marker, it will be represented via the Extra variant rather than the Marker variant.

Fields

name: PackageName

marker: MarkerTree

The marker associated with this proxy package.

Trait Implementations

impl Clone for PubGrubPackageInner

fn clone(&self) -> PubGrubPackageInner

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PubGrubPackageInner

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

Formats the value using the given formatter.

impl Display for PubGrubPackageInner

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

Formats the value using the given formatter.

impl From<PubGrubPackageInner> for PubGrubPackage

fn from(package: PubGrubPackageInner) -> Self

Converts to this type from the input type.

impl Hash for PubGrubPackageInner

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 Ord for PubGrubPackageInner

fn cmp(&self, other: &PubGrubPackageInner) -> 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.

impl PartialEq for PubGrubPackageInner

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

fn partial_cmp(&self, other: &PubGrubPackageInner) -> 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 Eq for PubGrubPackageInner

impl StructuralPartialEq for PubGrubPackageInner