python-ort 0.8.15__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/config/package_configuration.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: MIT
 
 
-from pydantic import BaseModel, ConfigDict, Field, field_serializer
+from pydantic import BaseModel, ConfigDict, Field
 
 from ort.models.config.license_finding_curation import LicenseFindingCuration
 from ort.models.config.path_exclude import PathExclude
@@ -66,7 +66,3 @@ class PackageConfiguration(BaseModel):
         default_factory=list,
         description="License finding curations.",
     )
-
-    @field_serializer("id")
-    def serialize_id(self, value: Identifier):
-        return str(value)

ort/models/identifier.py

@@ -4,7 +4,7 @@
 
 from typing import Any
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, model_serializer, model_validator
 
 
 class Identifier(BaseModel):
@@ -65,3 +65,7 @@ class Identifier(BaseModel):
 
     def __str__(self) -> str:
         return ":".join([self.orttype, self.namespace, self.name, self.version])
+
+    @model_serializer(mode="plain")
+    def serialize(self) -> str:
+        return str(self)

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.15.dist-info → python_ort-0.9.0.dist-info}/METADATA

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

{python_ort-0.8.15.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
@@ -24,7 +24,7 @@ ort/models/config/license_choices.py,sha256=Zlwzl6ZYLoIYyt8ZJsHYVV23u6FT7el29jcK
 ort/models/config/license_finding_curation.py,sha256=ZTdUv0TQVCqwXjQqN9YXoBuiOzBB21tK6IHZmz3yXik,3542
 ort/models/config/license_finding_curation_reason.py,sha256=PN_PixQH8BB_ilnMVBC_jZEQo1XqdrjAEbJb-_SWlfk,1099
 ort/models/config/local_file_storage_configuration.py,sha256=mB5_B3ly9spjwpIkHsC1t_vbsUyxlVz2s0sFW2UxCNE,653
-ort/models/config/package_configuration.py,sha256=WP2A5tlmJq1Sy75YYdJt-OWINAuNDVG-sSjgmI43O_Q,2995
+ort/models/config/package_configuration.py,sha256=EFujo40w_OmTgRNhbOxJNP6dtcq2EKMMOCUSWsgv8KQ,2875
 ort/models/config/package_manager_configuration.py,sha256=xpVwOzLNuBhGfEY2_Fz-6GagJXpKQI59kg5yzvZKHpI,1345
 ort/models/config/path_exclude.py,sha256=_2vpEwj-nxnV2qnbjx-_etPrZQTpETpm_ZVzuFesLc8,1063
 ort/models/config/path_exclude_reason.py,sha256=at0nrNOqiOlHS8q_rJEIM-tDViwKB7B1kZXz_10IsMk,1837
@@ -59,10 +59,13 @@ ort/models/dependency_reference.py,sha256=9fuqrF38c8bBW63Cp6sTnot-h2D3sGdkEuXR8S
 ort/models/evaluator_run.py,sha256=LsJJ-GMQKqdvJNdj3wnHMJuKD7EqojJ5VQKAPTzPFzY,467
 ort/models/file_list.py,sha256=SKHqLNutldJefNIzt7jKo6_aAdF9hlUd_Z7cQxAj_H4,1627
 ort/models/hash.py,sha256=fE1pPgx98WkmGid-SK3AuTBHMZrD6No1SJEEudrbP80,1160
-ort/models/identifier.py,sha256=GcP65v1KWL3uX5Ee7ZyTaTGNbIFuBo5kEZZ86d-oDkU,2525
+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.15.dist-info/licenses/LICENSE,sha256=koFhbHMglt1BNVuMKdBBlrQcgQsWLgo4pZW6cCtyGvA,1081
-python_ort-0.8.15.dist-info/WHEEL,sha256=XkDrRXQq-qVsrKMtsDUOHeLkiG7UK4Ds0JuG05OqKU4,81
-python_ort-0.8.15.dist-info/METADATA,sha256=0aKQZhyUnmwWc28toDxk4KQwhEYjAccgG773ovj9g84,1406
-python_ort-0.8.15.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.15.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