aswf-aces-common 0.1.0rc1__tar.gz

aswf_aces_common-0.1.0rc1/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: aswf-aces-common
+Version: 0.1.0rc1
+Summary: ACES shared protocols and data types
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# aswf-aces-common
+
+Shared protocols and types used across the ACES AMF Python packages.
+
+This is a foundation package. Most users should install [aswf-aces-amf-utils](../aces-amf-utils/) or [aswf-aces-amf-lib](../aces-amf-lib/) instead.
+
+## Installation
+
+```bash
+pip install aswf-aces-common
+```
+
+## Exports
+
+### `TransformRegistry` (Protocol)
+
+Interface for transform ID registries. Implemented by `ACESTransformRegistry` in [aswf-aces-transforms](../aces-transforms/).
+
+```python
+from aswf.aces.common import TransformRegistry
+
+class MyRegistry:
+    def is_valid_transform_id(self, transform_id: str, *, version: str | None = None) -> bool: ...
+    def get_transform_info(self, transform_id: str, *, version: str | None = None) -> dict | None: ...
+    def list_transforms(self, *, category: str | None = None, version: str | None = None) -> list[dict]: ...
+    def list_versions(self) -> list[str]: ...
+    def get_equivalent_id(self, transform_id: str) -> str | None: ...
+    def get_equivalent_ids(self, transform_id: str) -> list[str]: ...
+```
+
+### `TransformURN` (Dataclass)
+
+Parses ACES transform URNs into their component fields per the [Transform ID specification](https://docs.acescentral.com/system-components/transform-id-spec/).
+
+```
+urn:ampas:aces:transformId:v{specVersion}:{TransformType}.{Namespace}.{Name}.a{ACESRelease}.v{TransformVersion}
+```
+
+```python
+from aswf.aces.common import TransformURN
+
+urn = TransformURN.parse("urn:ampas:aces:transformId:v2.0:CSC.Academy.ACES_to_ACEScct.a2.v1")
+
+urn.raw                   # "urn:ampas:aces:transformId:v2.0:CSC.Academy.ACES_to_ACEScct.a2.v1"
+urn.spec_version          # "v2.0"
+urn.spec_major_version    # 2
+urn.spec_minor_version    # 0
+urn.transform_type        # "CSC"
+urn.namespace             # "Academy"
+urn.name                  # "ACES_to_ACEScct"
+urn.version_suffix        # "a2.v1"
+urn.aces_release_version  # 2
+urn.transform_version     # "v1"
+urn.is_v1                 # False
+urn.is_v2                 # True
+```
+
+The version suffix format varies between ACES versions:
+
+| ACES version | Suffix format | Example | `aces_release_version` | `transform_version` |
+|---|---|---|---|---|
+| v2.0 | `a{N}.v{N}` | `a2.v1` | `2` | `"v1"` |
+| v1.x (semver) | `a{N}.{N}.{N}` | `a1.0.3` | `1` | `"0.3"` |
+| v1.x (mixed) | `a{N}.v{N}.{N}` | `a1.v1.0` | `1` | `"v1.0"` |
+
+`TransformURN.parse()` returns `None` for strings that are not valid ACES transform URNs (e.g. legacy short names like `ACEScsc.ACES_to_ACEScc.a1.0.3`).
+
+#### Edge cases
+
+Internal library and utility transforms (`ACESlib`, `ACESutil`) do not include a separate namespace field — their format is `{Type}.{Name}.{VersionSuffix}` rather than `{Type}.{Namespace}.{Name}.{VersionSuffix}`. For these transforms, the `name` field will contain the version suffix and `version_suffix` will be empty, so `aces_release_version` and `transform_version` will return `None`. These transforms are not typically referenced in AMF files.
+
+```python
+urn = TransformURN.parse("urn:ampas:aces:transformId:v1.5:ACESlib.Utilities.a1.0.3")
+urn.transform_type        # "ACESlib"
+urn.namespace             # "Utilities"   (actually the name, not a namespace)
+urn.name                  # "a1.0.3"      (actually the version suffix)
+urn.version_suffix        # ""
+urn.aces_release_version  # None
+urn.transform_version     # None
+```
+
+### `TransformInfo` (Dataclass)
+
+Metadata for a single ACES transform:
+
+```python
+from aswf.aces.common import TransformInfo
+
+# Fields: transform_id, user_name, transform_type, aces_version,
+#         inverse_transform_id, previous_equivalent_ids
+```
+
+### Constants
+
+```python
+from aswf.aces.common import INPUT_TRANSFORM_TYPES, OUTPUT_TRANSFORM_TYPES
+
+INPUT_TRANSFORM_TYPES   # frozenset{"IDT", "CSC", "Input"}
+OUTPUT_TRANSFORM_TYPES  # frozenset{"ODT", "Output"}
+```
+
+## License
+
+Apache-2.0

aswf_aces_common-0.1.0rc1/README.md

@@ -0,0 +1,104 @@
+# aswf-aces-common
+
+Shared protocols and types used across the ACES AMF Python packages.
+
+This is a foundation package. Most users should install [aswf-aces-amf-utils](../aces-amf-utils/) or [aswf-aces-amf-lib](../aces-amf-lib/) instead.
+
+## Installation
+
+```bash
+pip install aswf-aces-common
+```
+
+## Exports
+
+### `TransformRegistry` (Protocol)
+
+Interface for transform ID registries. Implemented by `ACESTransformRegistry` in [aswf-aces-transforms](../aces-transforms/).
+
+```python
+from aswf.aces.common import TransformRegistry
+
+class MyRegistry:
+    def is_valid_transform_id(self, transform_id: str, *, version: str | None = None) -> bool: ...
+    def get_transform_info(self, transform_id: str, *, version: str | None = None) -> dict | None: ...
+    def list_transforms(self, *, category: str | None = None, version: str | None = None) -> list[dict]: ...
+    def list_versions(self) -> list[str]: ...
+    def get_equivalent_id(self, transform_id: str) -> str | None: ...
+    def get_equivalent_ids(self, transform_id: str) -> list[str]: ...
+```
+
+### `TransformURN` (Dataclass)
+
+Parses ACES transform URNs into their component fields per the [Transform ID specification](https://docs.acescentral.com/system-components/transform-id-spec/).
+
+```
+urn:ampas:aces:transformId:v{specVersion}:{TransformType}.{Namespace}.{Name}.a{ACESRelease}.v{TransformVersion}
+```
+
+```python
+from aswf.aces.common import TransformURN
+
+urn = TransformURN.parse("urn:ampas:aces:transformId:v2.0:CSC.Academy.ACES_to_ACEScct.a2.v1")
+
+urn.raw                   # "urn:ampas:aces:transformId:v2.0:CSC.Academy.ACES_to_ACEScct.a2.v1"
+urn.spec_version          # "v2.0"
+urn.spec_major_version    # 2
+urn.spec_minor_version    # 0
+urn.transform_type        # "CSC"
+urn.namespace             # "Academy"
+urn.name                  # "ACES_to_ACEScct"
+urn.version_suffix        # "a2.v1"
+urn.aces_release_version  # 2
+urn.transform_version     # "v1"
+urn.is_v1                 # False
+urn.is_v2                 # True
+```
+
+The version suffix format varies between ACES versions:
+
+| ACES version | Suffix format | Example | `aces_release_version` | `transform_version` |
+|---|---|---|---|---|
+| v2.0 | `a{N}.v{N}` | `a2.v1` | `2` | `"v1"` |
+| v1.x (semver) | `a{N}.{N}.{N}` | `a1.0.3` | `1` | `"0.3"` |
+| v1.x (mixed) | `a{N}.v{N}.{N}` | `a1.v1.0` | `1` | `"v1.0"` |
+
+`TransformURN.parse()` returns `None` for strings that are not valid ACES transform URNs (e.g. legacy short names like `ACEScsc.ACES_to_ACEScc.a1.0.3`).
+
+#### Edge cases
+
+Internal library and utility transforms (`ACESlib`, `ACESutil`) do not include a separate namespace field — their format is `{Type}.{Name}.{VersionSuffix}` rather than `{Type}.{Namespace}.{Name}.{VersionSuffix}`. For these transforms, the `name` field will contain the version suffix and `version_suffix` will be empty, so `aces_release_version` and `transform_version` will return `None`. These transforms are not typically referenced in AMF files.
+
+```python
+urn = TransformURN.parse("urn:ampas:aces:transformId:v1.5:ACESlib.Utilities.a1.0.3")
+urn.transform_type        # "ACESlib"
+urn.namespace             # "Utilities"   (actually the name, not a namespace)
+urn.name                  # "a1.0.3"      (actually the version suffix)
+urn.version_suffix        # ""
+urn.aces_release_version  # None
+urn.transform_version     # None
+```
+
+### `TransformInfo` (Dataclass)
+
+Metadata for a single ACES transform:
+
+```python
+from aswf.aces.common import TransformInfo
+
+# Fields: transform_id, user_name, transform_type, aces_version,
+#         inverse_transform_id, previous_equivalent_ids
+```
+
+### Constants
+
+```python
+from aswf.aces.common import INPUT_TRANSFORM_TYPES, OUTPUT_TRANSFORM_TYPES
+
+INPUT_TRANSFORM_TYPES   # frozenset{"IDT", "CSC", "Input"}
+OUTPUT_TRANSFORM_TYPES  # frozenset{"ODT", "Output"}
+```
+
+## License
+
+Apache-2.0

aswf_aces_common-0.1.0rc1/pyproject.toml

@@ -0,0 +1,25 @@
+# SPDX-License-Identifier: Apache-2.0
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aswf-aces-common"
+version = "0.1.0rc1"
+description = "ACES shared protocols and data types"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+dependencies = []
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["aswf.aces.common*"]
+
+[[tool.uv.index]]
+name = "pypi"
+url = "https://pypi.org/simple"
+default = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

aswf_aces_common-0.1.0rc1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aswf_aces_common-0.1.0rc1/src/aswf/aces/common/__init__.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright Contributors to the ACES Project.
+"""ACES shared protocols and data types."""
+
+from aswf.aces.common.constants import INPUT_TRANSFORM_TYPES, OUTPUT_TRANSFORM_TYPES
+from aswf.aces.common.protocols import TransformRegistry
+from aswf.aces.common.types import TransformInfo, TransformURN
+
+__all__ = ["INPUT_TRANSFORM_TYPES", "OUTPUT_TRANSFORM_TYPES", "TransformRegistry", "TransformInfo", "TransformURN"]

aswf_aces_common-0.1.0rc1/src/aswf/aces/common/constants.py

@@ -0,0 +1,112 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright Contributors to the ACES Project.
+"""
+Constants derived from the AMF XSD schemas.
+
+Transform type prefix constants map to XSD simpleType definitions that
+restrict which transform ID URN prefixes are valid per container type.
+The v1 and v2 schemas define different allowed prefixes.
+"""
+
+# Transform types considered as input transforms (used by bulk_generator)
+INPUT_TRANSFORM_TYPES: frozenset[str] = frozenset({"IDT", "CSC", "Input"})
+
+# Transform types considered as output transforms (used by bulk_generator)
+OUTPUT_TRANSFORM_TYPES: frozenset[str] = frozenset({"ODT", "Output"})
+
+# Transform types considered as look transforms
+LOOK_TRANSFORM_TYPES: frozenset[str] = frozenset({"LMT", "Look"})
+
+
+# ──────────────────────────────────────────────────────────────────────
+# AMF v2 XSD — allowed transform ID URN prefixes (v1.5 + v2.0 URNs)
+# Source: packages/aces-amf-lib/src/aswf/aces/amf_lib/data/amf-schema/v2/acesMetadataFile.xsd
+# ──────────────────────────────────────────────────────────────────────
+
+# tnInputTransform (v2 XSD line 71): IDT, ACEScsc (v1.5) | Input, CSC (v2.0)
+V2_INPUT_TRANSFORM_PREFIXES: frozenset[str] = frozenset({"IDT", "ACEScsc", "Input", "CSC"})
+# tnOutputTransform (v2 XSD line 78): RRTODT (v1.5) | Output (v2.0)
+V2_OUTPUT_TRANSFORM_PREFIXES: frozenset[str] = frozenset({"RRTODT", "Output"})
+# tnLookTransform (v2 XSD line 64): LMT (v1.5) | Look (v2.0)
+V2_LOOK_TRANSFORM_PREFIXES: frozenset[str] = frozenset({"LMT", "Look"})
+# tnColorSpaceConversionTransform (v2 XSD line 92): ACEScsc (v1.5) | CSC (v2.0)
+V2_CSC_TRANSFORM_PREFIXES: frozenset[str] = frozenset({"ACEScsc", "CSC"})
+# tnInverseOutputTransform (v2 XSD line 85): InvRRTODT (v1.5) | InvOutput (v2.0)
+V2_INVERSE_OUTPUT_TRANSFORM_PREFIXES: frozenset[str] = frozenset({"InvRRTODT", "InvOutput"})
+# v1.x only sub-transforms (same in v2 XSD as v1 XSD — no v2.0 equivalents)
+# tnReferenceRenderingTransform (v2 XSD line 100): RRT only
+V2_RRT_TRANSFORM_PREFIXES: frozenset[str] = frozenset({"RRT"})
+# tnInverseReferenceRenderingTransform (v2 XSD line 106): InvRRT only
+V2_INVERSE_RRT_TRANSFORM_PREFIXES: frozenset[str] = frozenset({"InvRRT"})
+# tnOutputDeviceTransform (v2 XSD line 112): ODT only
+V2_ODT_TRANSFORM_PREFIXES: frozenset[str] = frozenset({"ODT"})
+# tnInverseOutputDeviceTransform (v2 XSD line 118): InvODT only
+V2_INVERSE_ODT_TRANSFORM_PREFIXES: frozenset[str] = frozenset({"InvODT"})
+
+
+# ──────────────────────────────────────────────────────────────────────
+# XSD regex patterns for transform IDs, keyed by transform type.
+# Source: packages/aces-amf-lib/src/aswf/aces/amf_lib/data/amf-schema/v2/acesMetadataFile.xsd
+#
+# Each transform type maps to a list of regex patterns (from xs:pattern).
+# A transform ID is valid if it matches ANY pattern for its type.
+# The v2 XSD accepts both v1.5 and v2.0 URN forms.
+# ──────────────────────────────────────────────────────────────────────
+
+# Transform types that have no XSD pattern (library/utility transforms,
+# not placed in AMF pipeline slots).
+# TODO: Define patterns for these types.
+TRANSFORM_TYPES_WITHOUT_PATTERN: frozenset[str] = frozenset({
+    "ACESlib", "ACESutil", "Lib", "InvLMT", "InvLook",
+})
+
+TRANSFORM_ID_PATTERNS: dict[str, list[str]] = {
+    # tnInputTransform
+    "IDT": [
+        r"urn:ampas:aces:transformId:v1\.5:IDT\.\S+\.\S+\.a\d+\.v\d+",
+    ],
+    "ACEScsc": [
+        r"urn:ampas:aces:transformId:v1\.5:(ACEScsc\.\S+\.\S+\.a\d+\.v\d+|ACEScsc\.Academy\.\S+\.a\d+\.\d+\.\d+)",
+    ],
+    "Input": [
+        r"urn:ampas:aces:transformId:v2\.0:Input\.\S+\.\S+\.a\d+\.v\d+",
+    ],
+    "CSC": [
+        r"urn:ampas:aces:transformId:v2\.0:CSC\.\S+\.\S+\.a\d+\.v\d+",
+    ],
+    # tnOutputTransform
+    "RRTODT": [
+        r"urn:ampas:aces:transformId:v1\.5:(RRTODT\.\S+\.\S+\.a\d+\.v\d+|RRTODT\.Academy\.\S+\.a\d+\.\d+\.\d+)",
+    ],
+    "Output": [
+        r"urn:ampas:aces:transformId:v2\.0:Output\.\S+\.\S+\.a\d+\.v\d+",
+    ],
+    # tnLookTransform
+    "LMT": [
+        r"urn:ampas:aces:transformId:v1\.5:(LMT\.\S+\.\S+\.a\d+\.v\d+|LMT\.Academy\.\S+\.a\d+\.v?\d+\.\d+)",
+    ],
+    "Look": [
+        r"urn:ampas:aces:transformId:v2\.0:Look\.\S+\.\S+\.a\d+\.v\d+",
+    ],
+    # tnReferenceRenderingTransform / tnInverseReferenceRenderingTransform
+    "RRT": [
+        r"urn:ampas:aces:transformId:v1\.5:RRT\.a\d+\.\d+\.\d+",
+    ],
+    "InvRRT": [
+        r"urn:ampas:aces:transformId:v1\.5:InvRRT\.a\d+\.\d+\.\d+",
+    ],
+    # tnOutputDeviceTransform / tnInverseOutputDeviceTransform
+    "ODT": [
+        r"urn:ampas:aces:transformId:v1\.5:(ODT\.\S+\.\S+\.a\d+\.v\d+|ODT\.Academy\.\S+\.a\d+\.\d+\.\d+)",
+    ],
+    "InvODT": [
+        r"urn:ampas:aces:transformId:v1\.5:(InvODT\.\S+\.\S+\.a\d+\.v\d+|InvODT\.Academy\.\S+\.a\d+\.\d+\.\d+)",
+    ],
+    # tnInverseOutputTransform
+    "InvRRTODT": [
+        r"urn:ampas:aces:transformId:v1\.5:(InvRRTODT\.\S+\.\S+\.a\d+\.v\d+|InvRRTODT\.Academy\.\S+\.a\d+\.\d+\.\d+)",
+    ],
+    "InvOutput": [
+        r"urn:ampas:aces:transformId:v2\.0:InvOutput\.\S+\.\S+\.a\d+\.v\d+",
+    ],
+}

aswf_aces_common-0.1.0rc1/src/aswf/aces/common/protocols.py

@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright Contributors to the ACES Project.
+"""Protocol definitions for transform registry interfaces."""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class TransformRegistry(Protocol):
+    """Protocol for transform ID registries.
+
+    Implementations provide lookup and listing of known ACES transform URNs.
+    """
+
+    def is_valid_transform_id(self, transform_id: str, *, version: str | None = None) -> bool: ...
+
+    def get_transform_info(self, transform_id: str, *, version: str | None = None) -> dict | None: ...
+
+    def list_transforms(self, *, category: str | None = None, version: str | None = None) -> list[dict]: ...
+
+    def list_versions(self) -> list[str]: ...
+
+    def get_equivalent_id(self, transform_id: str) -> str | None: ...
+
+    def get_equivalent_ids(self, transform_id: str) -> list[str]: ...

aswf_aces_common-0.1.0rc1/src/aswf/aces/common/types.py

@@ -0,0 +1,111 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright Contributors to the ACES Project.
+"""Shared ACES data types."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import asdict, dataclass, field
+
+
+_TRANSFORM_URN_RE = re.compile(
+    r"^urn:ampas:aces:transformId:"
+    r"v(\d+)\.(\d+):"                         # spec version: v2.0, v1.5
+    r"([A-Za-z][A-Za-z0-9]*)"                  # transform type: CSC, Output, IDT, ACEScsc...
+    r"\.([^.]+)"                               # namespace: Academy, Arri, Red...
+    r"\.(.+)"                                  # name + version suffix
+    r"$"
+)
+
+# Matches the trailing version suffix: a2.v1, a1.0.3, a1.v1.0, etc.
+_VERSION_SUFFIX_RE = re.compile(
+    r"^(.+)\.(a\d+(?:\.(?:v?\d+))+)$"
+)
+
+@dataclass(frozen=True)
+class TransformURN:
+    """Parsed ACES transform URN per the Transform ID specification.
+
+    Format: urn:ampas:aces:transformId:v{specVersion}:{TransformType}.{Namespace}.{Name}.{VersionSuffix}
+
+    Example (v2.0):
+        urn:ampas:aces:transformId:v2.0:CSC.Academy.ACES_to_ACEScct.a2.v1
+
+    Example (v1.x):
+        urn:ampas:aces:transformId:v1.5:ACEScsc.Academy.ACES_to_ACEScct.a1.0.3
+    """
+
+    raw: str
+    spec_version: str
+    spec_major_version: int
+    spec_minor_version: int
+    transform_type: str
+    namespace: str
+    name: str
+    version_suffix: str
+
+    @classmethod
+    def parse(cls, urn: str) -> TransformURN | None:
+        """Parse a URN string. Returns None if not a valid ACES transform URN."""
+        m = _TRANSFORM_URN_RE.match(urn)
+        if m is None:
+            return None
+        spec_major, spec_minor, transform_type, namespace, name_and_version = m.groups()
+
+        # Split the trailing version suffix (e.g. "ACES_to_ACEScct.a2.v1" -> "ACES_to_ACEScct", "a2.v1")
+        vs = _VERSION_SUFFIX_RE.match(name_and_version)
+        if vs:
+            name, version_suffix = vs.groups()
+        else:
+            name = name_and_version
+            version_suffix = ""
+
+        return cls(
+            raw=urn,
+            spec_version=f"v{spec_major}.{spec_minor}",
+            spec_major_version=int(spec_major),
+            spec_minor_version=int(spec_minor),
+            transform_type=transform_type,
+            namespace=namespace,
+            name=name,
+            version_suffix=version_suffix,
+        )
+
+    @property
+    def is_v1(self) -> bool:
+        return self.spec_major_version == 1
+
+    @property
+    def is_v2(self) -> bool:
+        return self.spec_major_version == 2
+
+    @property
+    def aces_release_version(self) -> int | None:
+        """ACES release major version from the suffix (e.g. 2 from 'a2.v1')."""
+        m = re.match(r"a(\d+)", self.version_suffix)
+        return int(m.group(1)) if m else None
+
+    @property
+    def transform_version(self) -> str | None:
+        """Transform version from the suffix (e.g. 'v1' from 'a2.v1', '0.3' from 'a1.0.3')."""
+        m = re.match(r"a\d+\.(.*)", self.version_suffix)
+        return m.group(1) if m else None
+
+    def __str__(self) -> str:
+        return self.raw
+
+
+@dataclass
+class TransformInfo:
+    """Information about a single ACES transform."""
+
+    transform_id: str
+    user_name: str
+    transform_type: str
+    aces_version: str | None = None
+    inverse_transform_id: str | None = None
+    previous_equivalent_ids: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        """Return a plain dict representation."""
+        return asdict(self)

aswf_aces_common-0.1.0rc1/src/aswf_aces_common.egg-info/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: aswf-aces-common
+Version: 0.1.0rc1
+Summary: ACES shared protocols and data types
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# aswf-aces-common
+
+Shared protocols and types used across the ACES AMF Python packages.
+
+This is a foundation package. Most users should install [aswf-aces-amf-utils](../aces-amf-utils/) or [aswf-aces-amf-lib](../aces-amf-lib/) instead.
+
+## Installation
+
+```bash
+pip install aswf-aces-common
+```
+
+## Exports
+
+### `TransformRegistry` (Protocol)
+
+Interface for transform ID registries. Implemented by `ACESTransformRegistry` in [aswf-aces-transforms](../aces-transforms/).
+
+```python
+from aswf.aces.common import TransformRegistry
+
+class MyRegistry:
+    def is_valid_transform_id(self, transform_id: str, *, version: str | None = None) -> bool: ...
+    def get_transform_info(self, transform_id: str, *, version: str | None = None) -> dict | None: ...
+    def list_transforms(self, *, category: str | None = None, version: str | None = None) -> list[dict]: ...
+    def list_versions(self) -> list[str]: ...
+    def get_equivalent_id(self, transform_id: str) -> str | None: ...
+    def get_equivalent_ids(self, transform_id: str) -> list[str]: ...
+```
+
+### `TransformURN` (Dataclass)
+
+Parses ACES transform URNs into their component fields per the [Transform ID specification](https://docs.acescentral.com/system-components/transform-id-spec/).
+
+```
+urn:ampas:aces:transformId:v{specVersion}:{TransformType}.{Namespace}.{Name}.a{ACESRelease}.v{TransformVersion}
+```
+
+```python
+from aswf.aces.common import TransformURN
+
+urn = TransformURN.parse("urn:ampas:aces:transformId:v2.0:CSC.Academy.ACES_to_ACEScct.a2.v1")
+
+urn.raw                   # "urn:ampas:aces:transformId:v2.0:CSC.Academy.ACES_to_ACEScct.a2.v1"
+urn.spec_version          # "v2.0"
+urn.spec_major_version    # 2
+urn.spec_minor_version    # 0
+urn.transform_type        # "CSC"
+urn.namespace             # "Academy"
+urn.name                  # "ACES_to_ACEScct"
+urn.version_suffix        # "a2.v1"
+urn.aces_release_version  # 2
+urn.transform_version     # "v1"
+urn.is_v1                 # False
+urn.is_v2                 # True
+```
+
+The version suffix format varies between ACES versions:
+
+| ACES version | Suffix format | Example | `aces_release_version` | `transform_version` |
+|---|---|---|---|---|
+| v2.0 | `a{N}.v{N}` | `a2.v1` | `2` | `"v1"` |
+| v1.x (semver) | `a{N}.{N}.{N}` | `a1.0.3` | `1` | `"0.3"` |
+| v1.x (mixed) | `a{N}.v{N}.{N}` | `a1.v1.0` | `1` | `"v1.0"` |
+
+`TransformURN.parse()` returns `None` for strings that are not valid ACES transform URNs (e.g. legacy short names like `ACEScsc.ACES_to_ACEScc.a1.0.3`).
+
+#### Edge cases
+
+Internal library and utility transforms (`ACESlib`, `ACESutil`) do not include a separate namespace field — their format is `{Type}.{Name}.{VersionSuffix}` rather than `{Type}.{Namespace}.{Name}.{VersionSuffix}`. For these transforms, the `name` field will contain the version suffix and `version_suffix` will be empty, so `aces_release_version` and `transform_version` will return `None`. These transforms are not typically referenced in AMF files.
+
+```python
+urn = TransformURN.parse("urn:ampas:aces:transformId:v1.5:ACESlib.Utilities.a1.0.3")
+urn.transform_type        # "ACESlib"
+urn.namespace             # "Utilities"   (actually the name, not a namespace)
+urn.name                  # "a1.0.3"      (actually the version suffix)
+urn.version_suffix        # ""
+urn.aces_release_version  # None
+urn.transform_version     # None
+```
+
+### `TransformInfo` (Dataclass)
+
+Metadata for a single ACES transform:
+
+```python
+from aswf.aces.common import TransformInfo
+
+# Fields: transform_id, user_name, transform_type, aces_version,
+#         inverse_transform_id, previous_equivalent_ids
+```
+
+### Constants
+
+```python
+from aswf.aces.common import INPUT_TRANSFORM_TYPES, OUTPUT_TRANSFORM_TYPES
+
+INPUT_TRANSFORM_TYPES   # frozenset{"IDT", "CSC", "Input"}
+OUTPUT_TRANSFORM_TYPES  # frozenset{"ODT", "Output"}
+```
+
+## License
+
+Apache-2.0

aswf_aces_common-0.1.0rc1/src/aswf_aces_common.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/aswf/aces/common/__init__.py
+src/aswf/aces/common/constants.py
+src/aswf/aces/common/protocols.py
+src/aswf/aces/common/types.py
+src/aswf_aces_common.egg-info/PKG-INFO
+src/aswf_aces_common.egg-info/SOURCES.txt
+src/aswf_aces_common.egg-info/dependency_links.txt
+src/aswf_aces_common.egg-info/top_level.txt
+tests/test_transform_urn.py

aswf_aces_common-0.1.0rc1/src/aswf_aces_common.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aswf_aces_common-0.1.0rc1/src/aswf_aces_common.egg-info/top_level.txt

@@ -0,0 +1 @@
+aswf

aswf_aces_common-0.1.0rc1/tests/test_transform_urn.py

@@ -0,0 +1,107 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Tests for TransformURN parsing."""
+
+import pytest
+
+from aswf.aces.common.types import TransformURN
+
+
+class TestTransformURNParse:
+    def test_parse_v15_csc(self):
+        urn = TransformURN.parse("urn:ampas:aces:transformId:v1.5:ACEScsc.Academy.ACES_to_ACEScct.a1.0.3")
+        assert urn is not None
+        assert urn.spec_version == "v1.5"
+        assert urn.spec_major_version == 1
+        assert urn.spec_minor_version == 5
+        assert urn.transform_type == "ACEScsc"
+        assert urn.namespace == "Academy"
+        assert urn.name == "ACES_to_ACEScct"
+        assert urn.version_suffix == "a1.0.3"
+        assert urn.is_v1 is True
+        assert urn.is_v2 is False
+
+    def test_parse_v20_csc(self):
+        urn = TransformURN.parse("urn:ampas:aces:transformId:v2.0:CSC.Academy.ACES_to_ACEScct.a2.v1")
+        assert urn is not None
+        assert urn.spec_version == "v2.0"
+        assert urn.spec_major_version == 2
+        assert urn.spec_minor_version == 0
+        assert urn.transform_type == "CSC"
+        assert urn.namespace == "Academy"
+        assert urn.name == "ACES_to_ACEScct"
+        assert urn.version_suffix == "a2.v1"
+        assert urn.is_v1 is False
+        assert urn.is_v2 is True
+
+    def test_parse_v20_output(self):
+        urn = TransformURN.parse("urn:ampas:aces:transformId:v2.0:Output.Academy.Rec709-D65_100nit_in_Rec709-D65_BT1886.a2.v1")
+        assert urn is not None
+        assert urn.transform_type == "Output"
+        assert urn.namespace == "Academy"
+        assert urn.name == "Rec709-D65_100nit_in_Rec709-D65_BT1886"
+        assert urn.version_suffix == "a2.v1"
+
+    def test_parse_v15_lmt(self):
+        urn = TransformURN.parse("urn:ampas:aces:transformId:v1.5:LMT.Academy.ReferenceGamutCompress.a1.v1.0")
+        assert urn is not None
+        assert urn.transform_type == "LMT"
+        assert urn.namespace == "Academy"
+        assert urn.name == "ReferenceGamutCompress"
+        assert urn.version_suffix == "a1.v1.0"
+        assert urn.is_v1 is True
+
+    def test_parse_v15_idt_manufacturer(self):
+        urn = TransformURN.parse("urn:ampas:aces:transformId:v1.5:IDT.ARRI.ARRI-LogC4.a1.v1")
+        assert urn is not None
+        assert urn.transform_type == "IDT"
+        assert urn.namespace == "ARRI"
+        assert urn.name == "ARRI-LogC4"
+        assert urn.version_suffix == "a1.v1"
+
+    def test_parse_v20_look(self):
+        urn = TransformURN.parse("urn:ampas:aces:transformId:v2.0:Look.Academy.ReferenceGamutCompress.a2.v1")
+        assert urn is not None
+        assert urn.transform_type == "Look"
+        assert urn.name == "ReferenceGamutCompress"
+        assert urn.version_suffix == "a2.v1"
+
+    def test_parse_returns_none_for_invalid(self):
+        assert TransformURN.parse("not-a-urn") is None
+        assert TransformURN.parse("") is None
+        assert TransformURN.parse("urn:ampas:aces:transformId:v1.5:") is None
+
+    def test_parse_returns_none_for_legacy_short_name(self):
+        assert TransformURN.parse("ACEScsc.ACES_to_ACEScc.a1.0.3") is None
+
+    def test_str_returns_raw(self):
+        raw = "urn:ampas:aces:transformId:v2.0:CSC.Academy.ACES_to_ACEScct.a2.v1"
+        urn = TransformURN.parse(raw)
+        assert str(urn) == raw
+
+    def test_aces_release_version_v20(self):
+        urn = TransformURN.parse("urn:ampas:aces:transformId:v2.0:CSC.Academy.ACES_to_ACEScct.a2.v1")
+        assert urn.aces_release_version == 2
+        assert urn.transform_version == "v1"
+
+    def test_aces_release_version_v15_semver(self):
+        urn = TransformURN.parse("urn:ampas:aces:transformId:v1.5:ACEScsc.Academy.ACES_to_ACEScct.a1.0.3")
+        assert urn.aces_release_version == 1
+        assert urn.transform_version == "0.3"
+
+    def test_aces_release_version_v15_mixed(self):
+        urn = TransformURN.parse("urn:ampas:aces:transformId:v1.5:LMT.Academy.ReferenceGamutCompress.a1.v1.0")
+        assert urn.aces_release_version == 1
+        assert urn.transform_version == "v1.0"
+
+    def test_aces_release_version_empty_suffix(self):
+        """ACESlib transforms may not parse a version suffix."""
+        urn = TransformURN.parse("urn:ampas:aces:transformId:v1.5:ACESlib.ODT_Common.a1.1.0")
+        assert urn.aces_release_version is None
+        assert urn.transform_version is None
+
+    def test_frozen(self):
+        urn = TransformURN.parse("urn:ampas:aces:transformId:v2.0:CSC.Academy.ACES_to_ACEScct.a2.v1")
+        with pytest.raises(AttributeError):
+            urn.spec_version = "v3.0"
+
+