python-ort 0.8.16__py3-none-any.whl → 0.9.0__py3-none-any.whl

ort/models/__init__.py

@@ -20,6 +20,7 @@ from .dependency_reference import DependencyReference
 from .hash import Hash
 from .identifier import Identifier
 from .issue import Issue
+from .licenses.license_classifications import LicenseClassifications
 from .ort_result import OrtResult
 from .package import Package
 from .package_curation import PackageCuration
@@ -51,6 +52,7 @@ __all__ = [
     "Includes",
     "Excludes",
     "Issue",
+    "LicenseClassifications",
     "OrtResult",
     "Package",
     "PackageCuration",

ort/models/licenses/license_categorization.py

@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: 2026 Helio Chissini de Castro <heliocastro@gmail.com>
+# SPDX-License-Identifier: MIT
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class LicenseCategorization(BaseModel):
+    """
+    A class for configuring metadata for a specific license referred to by an SPDX license identifier.
+
+    The metadata consists of assignments to generic categories whose exact meaning is customer specific.
+    The categories a license belong to can be evaluated by other components, such as rules or templates,
+    which can decide - based on this information - how to handle a specific license.
+
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",
+        frozen=True,
+    )
+
+    id: str = Field(description="The [SpdxSingleLicenseExpression] of this [LicenseCategorization].")
+
+    categories: set[str] = Field(
+        default_factory=set,
+        description="The identifiers of the [license categories][LicenseCategory] this license is assigned to.",
+    )

ort/models/licenses/license_category.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: 2026 Helio Chissini de Castro <heliocastro@gmail.com>
+# SPDX-License-Identifier: MIT
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class LicenseCategory(BaseModel):
+    """
+    A category where licenses can be assigned to. The assignment is expressed via a [LicenseCategorization]. Categories
+    do not have any specific semantic, but users are free to define their own set of categories.
+
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    name: str = Field(
+        description="The name of this [LicenseCategory]. The name can be chosen freely, "
+        "but must be unique over all categories."
+    )
+
+    description: str = Field(
+        default_factory=str,
+        description="A description for this [LicenseCategory].",
+    )

ort/models/licenses/license_classifications.py

@@ -0,0 +1,124 @@
+# SPDX-FileCopyrightText: 2026 Helio Chissini de Castro <heliocastro@gmail.com>
+# SPDX-License-Identifier: MIT
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from .license_categorization import LicenseCategorization
+from .license_category import LicenseCategory
+
+
+class LicenseClassifications(BaseModel):
+    """
+    Classifications for licenses which allow assigning metadata to licenses. This allows defining rather generic
+    categories and assigning licenses to these. That way flexible classifications can be created based on
+    customizable categories. The available license categories need to be declared explicitly; when creating an
+    instance, it is checked that all the references from the [categorizations] point to existing [categories].
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    categories: list[LicenseCategory] = Field(
+        default_factory=list,
+        description="Defines metadata for the license categories.",
+    )
+
+    categorizations: list[LicenseCategorization] = Field(
+        default_factory=list,
+        description="Defines metadata for licenses.",
+    )
+
+    @model_validator(mode="after")
+    def _check_consistency(self) -> "LicenseClassifications":
+        category_names = [category.name for category in self.categories]
+        duplicate_categories = {name for name in category_names if category_names.count(name) > 1}
+        if duplicate_categories:
+            raise ValueError(f"Found multiple license categories with the same name: {sorted(duplicate_categories)}")
+
+        license_ids = [categorization.id for categorization in self.categorizations]
+        duplicate_ids = {license_id for license_id in license_ids if license_ids.count(license_id) > 1}
+        if duplicate_ids:
+            raise ValueError(f"Found multiple license categorizations with the same id: {sorted(duplicate_ids)}")
+
+        known_categories = set(category_names)
+        invalid_categorizations = {
+            categorization.id: sorted(categorization.categories - known_categories)
+            for categorization in self.categorizations
+            if categorization.categories - known_categories
+        }
+        if invalid_categorizations:
+            referenced_ids = ", ".join(invalid_categorizations.keys())
+            unknown_categories = sorted({name for names in invalid_categorizations.values() for name in names})
+            raise ValueError(
+                f"Found licenses that reference non-existing categories: {referenced_ids}; "
+                f"unknown categories are {unknown_categories}."
+            )
+
+        return self
+
+    @property
+    def category_names(self) -> set[str]:
+        """The names of all categories defined."""
+        return {category.name for category in self.categories}
+
+    @property
+    def licenses_by_category(self) -> dict[str, set[str]]:
+        """A mapping for fast look-ups of the licenses assigned to a given category."""
+        result: dict[str, set[str]] = {}
+        for categorization in self.categorizations:
+            for category in categorization.categories:
+                result.setdefault(category, set()).add(categorization.id)
+
+        for category in self.categories:
+            result.setdefault(category.name, set())
+
+        return result
+
+    @property
+    def categories_by_license(self) -> dict[str, set[str]]:
+        """A mapping for fast look-ups of the categories assigned to a given license."""
+        return {categorization.id: categorization.categories for categorization in self.categorizations}
+
+    def __getitem__(self, license_id: str) -> set[str] | None:
+        """Return the categories for the given license [license_id], or None if the license is not categorized."""
+        return self.categories_by_license.get(license_id)
+
+    def is_categorized(self, license_id: str) -> bool:
+        """Check whether there is a categorization for the given license [license_id]."""
+        return license_id in self.categories_by_license
+
+    def merge(self, other: "LicenseClassifications") -> "LicenseClassifications":
+        """Merge [other] into these classifications, overwriting any conflicting existing classifications."""
+        filtered_categories_by_license: dict[str, set[str]] = {}
+
+        # Remove categories that are also used in the other classification as different classifications might use
+        # different semantics for the same category name.
+        other_category_names = other.category_names
+        for categorization in self.categorizations:
+            filtered_categories = {
+                category for category in categorization.categories if category not in other_category_names
+            }
+            if filtered_categories:
+                filtered_categories_by_license[categorization.id] = filtered_categories
+
+        # Merge other into existing categories for each license.
+        for categorization in other.categorizations:
+            filtered_categories_by_license.setdefault(categorization.id, set()).update(categorization.categories)
+
+        used_categories = {
+            category for categories in filtered_categories_by_license.values() for category in categories
+        }
+
+        merged_categories: list[LicenseCategory] = []
+        for category in [*self.categories, *other.categories]:
+            if category.name in used_categories and category not in merged_categories:
+                merged_categories.append(category)
+
+        return LicenseClassifications(
+            categories=merged_categories,
+            categorizations=[
+                LicenseCategorization(id=license_id, categories=categories)
+                for license_id, categories in filtered_categories_by_license.items()
+            ],
+        )

{python_ort-0.8.16.dist-info → python_ort-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-ort
-Version: 0.8.16
+Version: 0.9.0
 Summary: A Python Ort model serialization library
 License-Expression: MIT
 License-File: LICENSE

{python_ort-0.8.16.dist-info → python_ort-0.9.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 ort/__init__.py,sha256=lwG8GVwXZCnL4yGOKgja1Tvrt_JeOCABZw3F8ckXuuU,469
-ort/models/__init__.py,sha256=IAqyDq-u3qlbJYbEdAbovL7V8e4r2tqjz6NOhqiCVWs,2294
+ort/models/__init__.py,sha256=v6jvd2vvIvuKIo_VN2EpyDvH_77M6LWuru-rLqQCk1I,2393
 ort/models/advisor_capability.py,sha256=u1-yQI66jVWgrOacZdIEZ_zcK_A_qZ8ma0umJs01V1o,839
 ort/models/advisor_details.py,sha256=wo5h3uKD_94ukw9nUGOBKGonCd8CF8YcPkcu7XoBR_I,754
 ort/models/advisor_result.py,sha256=LgfZRPdERNDVcIW7hRqCPyudbWXJvlSTlBLWuAONrlM,1317
@@ -63,6 +63,9 @@ ort/models/identifier.py,sha256=H3NvxZlHLZQDI2hQn8AphqieL5QBkfj5Y6JTxEItSNY,2637
 ort/models/issue.py,sha256=nUMKRABe8tF6pZzCdaPt2tjdYFf5zRgEipy-o68Ym5M,1153
 ort/models/license_finding.py,sha256=8vlnBV0LMb8cerOpZl6YH1eYwVuViuh0VseD6Sai_q0,1897
 ort/models/license_source.py,sha256=TY0HBFvOt0r9QxElpmobLF5SmjyA1wynGNPsqBxwHdo,727
+ort/models/licenses/license_categorization.py,sha256=kHAS8Aowb3V2fRYWPOr256tBWYHE0s9Pu6zBjjk3Mtk,989
+ort/models/licenses/license_category.py,sha256=ABV3QFTrEp_WiNYoGMRwUmg2QPIhhV_dT8hB4yzaQJQ,795
+ort/models/licenses/license_classifications.py,sha256=2WTo21x72D66azYj8Y0Sy8IB5B9Ln8xBlt2HtSvqelU,5760
 ort/models/ort_result.py,sha256=NQ7dsGW9C55ROGTQz2Up4lH-tJcR9vsP21i0jbeJUNg,2346
 ort/models/package.py,sha256=9AMSSDK4gjOk6S-tWQgVIPMad75p4Ydm7AgvQncCgsk,5162
 ort/models/package_curation.py,sha256=_F1GF7D_lgeCQs9j3Ft5ImSPO9RdBjepdEBo2JxuNPY,356
@@ -107,7 +110,7 @@ ort/utils/spdx/spdx_expression.py,sha256=K_ZsIGwLP_zNcS6haO2TFM1aRa2l79zFU7HZaB_
 ort/utils/spdx/spdx_license_choice.py,sha256=hop1tcSAq1ZWMd-504tAaCJ8KxzX_fp9_-r_LvEE2wc,1227
 ort/utils/validated_enum.py,sha256=UFAGP7BGzAx1nSBWEeMXn1X1teVb6507N-lfXBf5qGM,1643
 ort/utils/yaml_loader.py,sha256=kOiuRV93_q_ZUnAqHoNohAvqL7fkUn66WrvrdbgZKHs,1290
-python_ort-0.8.16.dist-info/licenses/LICENSE,sha256=koFhbHMglt1BNVuMKdBBlrQcgQsWLgo4pZW6cCtyGvA,1081
-python_ort-0.8.16.dist-info/WHEEL,sha256=XkDrRXQq-qVsrKMtsDUOHeLkiG7UK4Ds0JuG05OqKU4,81
-python_ort-0.8.16.dist-info/METADATA,sha256=URzLItVdiqwH-m3GvMTNnTliNWf9GtC40kcbZmVdiQg,1406
-python_ort-0.8.16.dist-info/RECORD,,
+python_ort-0.9.0.dist-info/licenses/LICENSE,sha256=koFhbHMglt1BNVuMKdBBlrQcgQsWLgo4pZW6cCtyGvA,1081
+python_ort-0.9.0.dist-info/WHEEL,sha256=8ZlpUMJ7mlDirmlHRhDirEx_nPnARrwDjeE92mlk68E,81
+python_ort-0.9.0.dist-info/METADATA,sha256=08LD-ojLhLWMc8_8s8MnmZ_7qkOmu546FFb2raRZd8o,1405
+python_ort-0.9.0.dist-info/RECORD,,

{python_ort-0.8.16.dist-info → python_ort-0.9.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.11.13
+Generator: uv 0.11.21
 Root-Is-Purelib: true
 Tag: py3-none-any