Struct python_packaging::licensing::LicensedComponents

pub struct LicensedComponents { /* private fields */ }

A collection of licensed components.

Implementations

impl LicensedComponents

pub fn into_components(self) -> impl Iterator<Item = LicensedComponent>

Obtain an iterator over the components, consuming self.

pub fn iter_components(&self) -> impl Iterator<Item = &LicensedComponent>

Iterate over components in this collection.

pub fn add_component(&mut self, component: LicensedComponent)

Add a component to this collection.

pub fn add_spdx_only_component(
    &mut self,
    component: LicensedComponent
) -> Result<()>

Add a component to this collection, but only if it only contains SPDX license identifiers.

pub fn has_python_module(&self, name: &str) -> bool

Whether a Python module exists in the collection.

pub fn normalize_python_modules(&self) -> Self

Adjusts Python modules in the components set.

Standard library modules that have identical licensing to the Python distribution are removed.

Missing top-level packages are added with an unknown license annotation.

Modules that aren’t top-level modules are removed.

pub fn all_spdx_licenses(&self) -> BTreeSet<(LicenseId, Option<ExceptionId>)>

Obtain all SPDX license identifiers referenced by registered components.

pub fn all_spdx_license_ids(&self) -> BTreeSet<LicenseId>

Obtain all SPDX license IDs referenced by all components.

Unlike Self::all_spdx_licenses(), this returns just the LicenseId, without exceptions.

pub fn all_spdx_license_names(&self, full: bool) -> Vec<String>

Obtain all SPDX license names referenced by registered components.

pub fn components_by_spdx_license(
    &self
) -> BTreeMap<(LicenseId, Option<ExceptionId>), BTreeSet<&LicensedComponent>>

Obtain a mapping of all SPDX licenses to components having them.

pub fn license_spdx_components(
    &self
) -> impl Iterator<Item = &LicensedComponent>

Obtain all components with valid SPDX license expressions.

pub fn license_missing_components(
    &self
) -> impl Iterator<Item = &LicensedComponent>

Obtain components that are missing license annotations.

pub fn license_public_domain_components(
    &self
) -> impl Iterator<Item = &LicensedComponent>

Obtain components that are licensed to the public domain.

pub fn license_unknown_components(
    &self
) -> impl Iterator<Item = &LicensedComponent>

Obtain components that have unknown licensing.

There is a value for the license but that license is not recognized by us.

pub fn license_copyleft_components(
    &self
) -> impl Iterator<Item = &LicensedComponent>

Components that have copyleft licenses.

There may be false negatives if the component doesn’t have fully SPDX parsed licenses.

pub fn license_summary(&self) -> String

Generate a text summary of licesning info.

pub fn interesting_report(&self) -> Option<String>

Generate a text report of noteworthy licensing info.

This essentially emits license quirks that may warrant user attention.

pub fn spdx_license_breakdown(&self) -> String

Generate a summary of SPDX licenses in all components.

Trait Implementations

impl Clone for LicensedComponents

fn clone(&self) -> LicensedComponents

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LicensedComponents

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

Formats the value using the given formatter.

impl Default for LicensedComponents

fn default() -> LicensedComponents

Returns the “default value” for a type.

impl PartialEq<LicensedComponents> for LicensedComponents

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