Struct ResolverOutput 

pub struct ResolverOutput {
    pub graph: Graph<ResolutionGraphNode, UniversalMarker>,
    pub requires_python: RequiresPython,
    pub fork_markers: Vec<UniversalMarker>,
    pub diagnostics: Vec<ResolutionDiagnostic>,
    pub requirements: Vec<Requirement>,
    pub constraints: Constraints,
    pub overrides: Overrides,
    pub options: Options,
}

The output of a successful resolution.

Includes a complete resolution graph in which every node represents a pinned package and every edge represents a dependency between two pinned packages.

Fields

graph: Graph<ResolutionGraphNode, UniversalMarker>

The underlying graph.

requires_python: RequiresPython

The range of supported Python versions.

fork_markers: Vec<UniversalMarker>

If the resolution had non-identical forks, store the forks in the lockfile so we can recreate them in subsequent resolutions.

diagnostics: Vec<ResolutionDiagnostic>

Any diagnostics that were encountered while building the graph.

requirements: Vec<Requirement>

The requirements that were used to build the graph.

constraints: Constraints

The constraints that were used to build the graph.

overrides: Overrides

The overrides that were used to build the graph.

options: Options

The options that were used to build the graph.

Implementations

impl ResolverOutput

pub fn base_dists(&self) -> impl Iterator<Item = (NodeIndex, &AnnotatedDist)>

Returns an iterator over the base distributions in the graph.

pub fn len(&self) -> usize

Return the number of distinct packages in the graph.

pub fn is_empty(&self) -> bool

Return true if there are no packages in the graph.

pub fn retain_allowed_distribution_hashes( &mut self, build_options: &BuildOptions, )

Retain registry hashes only for artifacts permitted by package-specific build options.

All available wheel hashes remain eligible when source builds are disabled so the resulting requirements can still be installed on other supported platforms.

pub fn contains(&self, name: &PackageName) -> bool

Returns true if the graph contains the given package.

pub fn diagnostics(&self) -> &[ResolutionDiagnostic]

Return the ResolutionDiagnostics that were encountered while building the graph.

pub fn marker_tree( &self, index: &RegisteredOnceMap<DistributionId, Arc<MetadataResponse>, BuildHasherDefault<FxHasher>>, marker_env: &MarkerEnvironment, ) -> Result<MarkerTree, Box<ParsedUrlError>>

Return the marker tree specific to this resolution.

This accepts an in-memory-index and marker environment, all of which should be the same values given to the resolver that produced this graph.

The marker tree returned corresponds to an expression that, when true, this resolution is guaranteed to be correct. Note though that it’s possible for resolution to be correct even if the returned marker expression is false.

For example, if the root package has a dependency foo; sys_platform == "macos" and resolution was performed on Linux, then the marker tree returned will contain a sys_platform == "linux" expression. This means that whenever the marker expression evaluates to true (i.e., the current platform is Linux), then the resolution here is correct. But it is possible that the resolution is also correct on other platforms that aren’t macOS, such as Windows. (It is unclear at time of writing whether this is fundamentally impossible to compute, or just impossible to compute in some cases.)

pub fn find_conflicting_distributions( &self, ) -> Vec<ConflictingDistributionError>

Returns a sequence of conflicting distribution errors from this resolution.

Correct resolutions always return an empty sequence. A non-empty sequence implies there is a package with two distinct versions in the same marker environment in this resolution. This in turn implies that an installation in that marker environment could wind up trying to install different versions of the same package, which is not allowed.

Trait Implementations

impl Debug for ResolverOutput

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

Formats the value using the given formatter.