python-ort 0.8.16__tar.gz → 0.9.0__tar.gz

{python_ort-0.8.16 → python_ort-0.9.0}/PKG-INFO

@@ -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.9.0/pyproject.toml

@@ -0,0 +1,163 @@
+[project]
+name = "python-ort"
+version = "0.9.0"
+description = "A Python Ort model serialization library"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+  "license-expression>=30.4.4",
+  "packageurl-python>=0.17.6",
+  "pydantic>=2.13.4",
+]
+
+[dependency-groups]
+dev = [
+  "datamodel-code-generator[http]>=0.64.0",
+  "pytest>=9.1.0",
+  "rich>=15.0.0",
+  "ruff>=0.15.17",
+  "ty>=0.0.50",
+  "types-pyyaml>=6.0.12.20260518",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.12,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.codespell]
+skip = [
+  ".agents",
+]
+
+[tool.pylint.messages_control]
+disable = [
+  "abstract-method",
+  "arguments-differ",
+  "attribute-defined-outside-init",
+  "blacklisted-name",
+  "chained-comparison",
+  "duplicate-code",
+  "eval-used",
+  "exec-used",
+  "expression-not-assigned",
+  "fixme",
+  "global-statement",
+  "invalid-name",
+  "import-error",
+  "logging-fstring-interpolation",
+  "missing-docstring",
+  "no-member",
+  "no-name-in-module",
+  "protected-access",
+  "redefined-argument-from-local",
+  "redefined-outer-name",
+  "reimported",
+  "stop-iteration-return",
+  "too-few-public-methods",
+  "too-many-ancestors",
+  "too-many-arguments",
+  "too-many-branches",
+  "too-many-instance-attributes",
+  "too-many-lines",
+  "too-many-locals",
+  "too-many-return-statements",
+  "too-many-statements",
+  "unexpected-special-method-signature",
+  "unspecified-encoding",
+]
+
+check_untyped_defs = true
+disallow_any_generics = true
+disallow_untyped_defs = true
+disallow_untyped_calls = false
+follow_imports = "normal"
+ignore_missing_imports = true
+no_implicit_reexport = true
+strict_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+
+[tool.pytest.ini_options]
+addopts = ["--import-mode=importlib"]
+log_cli = true
+log_cli_level = "INFO"
+pythonpath = ["src"]
+testpaths = ["tests"]
+
+[tool.ruff]
+fix = true
+line-length = 120
+
+# Exclude a variety of commonly ignored directories.
+extend-exclude = [
+  ".bzr",
+  ".direnv",
+  ".eggs",
+  ".git",
+  ".hg",
+  ".mypy_cache",
+  ".nox",
+  ".pants.d",
+  ".ruff_cache",
+  ".svn",
+  ".tox",
+  ".venv",
+  "__pypackages__",
+  "_build",
+  "buck-out",
+  "build",
+  "dist",
+  "node_modules",
+  "venv",
+]
+
+# Assume Python 3.10.
+target-version = "py310"
+
+[tool.ruff.lint]
+extend-select = [
+  "E",  # pycodestyle error
+  "W",  # pycodestyle warning
+  "F",  # pyflakes
+  "A",  # flakes8-builtins
+  "C4",  # flake8-comprehensions
+  "Q",  # flake8-quotes
+  "SIM",  # flake8-simplify
+  "PTH",  # flake8-use-pathlib
+  "I",  # isort
+  "N",  # pep8 naming
+  "UP",  # pyupgrade
+  "S",  # bandit
+]
+ignore = [
+  "SIM105",  # Suggest contextlib instead of try/except with pass
+]
+# Unlike Flake8, default to a complexity level of 10.
+mccabe.max-complexity = 10
+per-file-ignores = {}
+flake8-tidy-imports.ban-relative-imports = "all"
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+
+[tool.uv]
+index-url = "https://pypi.org/simple"
+
+[tool.uv.build-backend]
+module-name = "ort"
+module-root = "src"

{python_ort-0.8.16 → python_ort-0.9.0}/src/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",

python_ort-0.9.0/src/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.",
+    )

python_ort-0.9.0/src/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].",
+    )

python_ort-0.9.0/src/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/pyproject.toml

@@ -1,160 +0,0 @@
-[build-system]
-requires = ["uv_build>=0.8.12,<0.11.0"]
-build-backend = "uv_build"
-
-[project]
-name = "python-ort"
-version = "0.8.16"
-description = "A Python Ort model serialization library"
-readme = "README.md"
-license = "MIT"
-license-files = ["LICENSE"]
-requires-python = ">=3.10"
-dependencies = [
-    "license-expression>=30.4.4",
-    "packageurl-python>=0.17.6",
-    "pydantic>=2.13.4",
-]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-    "Programming Language :: Python :: 3.14",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-]
-
-[tool.uv]
-index-url = "https://pypi.org/simple"
-
-[tool.uv.build-backend]
-module-name = "ort"
-module-root = "src"
-
-[dependency-groups]
-dev = [
-    "datamodel-code-generator[http]>=0.57.0",
-    "pytest>=9.0.3",
-    "rich>=15.0.0",
-    "ruff>=0.15.12",
-    "ty>=0.0.35",
-    "types-pyyaml>=6.0.12.20260510",
-]
-
-[tool.pytest.ini_options]
-addopts = ["--import-mode=importlib"]
-log_cli = true
-log_cli_level = "INFO"
-pythonpath = ["src"]
-testpaths = ["tests"]
-
-[tool.pylint.messages_control]
-disable = [
-    "abstract-method",
-    "arguments-differ",
-    "attribute-defined-outside-init",
-    "blacklisted-name",
-    "chained-comparison",
-    "duplicate-code",
-    "eval-used",
-    "exec-used",
-    "expression-not-assigned",
-    "fixme",
-    "global-statement",
-    "invalid-name",
-    "import-error",
-    "logging-fstring-interpolation",
-    "missing-docstring",
-    "no-member",
-    "no-name-in-module",
-    "protected-access",
-    "redefined-argument-from-local",
-    "redefined-outer-name",
-    "reimported",
-    "stop-iteration-return",
-    "too-few-public-methods",
-    "too-many-ancestors",
-    "too-many-arguments",
-    "too-many-branches",
-    "too-many-instance-attributes",
-    "too-many-lines",
-    "too-many-locals",
-    "too-many-return-statements",
-    "too-many-statements",
-    "unexpected-special-method-signature",
-    "unspecified-encoding",
-]
-
-check_untyped_defs = true
-disallow_any_generics = true
-disallow_untyped_defs = true
-disallow_untyped_calls = false
-follow_imports = "normal"
-ignore_missing_imports = true
-no_implicit_reexport = true
-strict_optional = true
-warn_redundant_casts = true
-warn_unused_ignores = true
-
-[tool.ruff]
-fix = true
-line-length = 120
-
-# Exclude a variety of commonly ignored directories.
-extend-exclude = [
-    ".bzr",
-    ".direnv",
-    ".eggs",
-    ".git",
-    ".hg",
-    ".mypy_cache",
-    ".nox",
-    ".pants.d",
-    ".ruff_cache",
-    ".svn",
-    ".tox",
-    ".venv",
-    "__pypackages__",
-    "_build",
-    "buck-out",
-    "build",
-    "dist",
-    "node_modules",
-    "venv",
-]
-
-# Assume Python 3.10.
-target-version = "py310"
-
-[tool.ruff.lint]
-extend-select = [
-    "E",   # pycodestyle error
-    "W",   # pycodestyle warning
-    "F",   # pyflakes
-    "A",   # flakes8-builtins
-    "C4",  # flake8-comprehensions
-    "Q",   # flake8-quotes
-    "SIM", # flake8-simplify
-    "PTH", # flake8-use-pathlib
-    "I",   # isort
-    "N",   # pep8 naming
-    "UP",  # pyupgrade
-    "S",   # bandit
-]
-ignore = [
-    'SIM105', # Suggest contextlib instead of try/except with pass
-]
-# Unlike Flake8, default to a complexity level of 10.
-mccabe.max-complexity = 10
-per-file-ignores = {}
-flake8-tidy-imports.ban-relative-imports = "all"
-# Allow unused variables when underscore-prefixed.
-dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
-
-[tool.ruff.format]
-quote-style = "double"
-indent-style = "space"
-skip-magic-trailing-comma = false