tba-protocol-credential-w3c-vcdm 0.4.0.dev2__tar.gz

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: tba-protocol-credential-w3c-vcdm
+Version: 0.4.0.dev2
+Summary: 
+License-Expression: Apache-2.0
+Requires-Python: >=3.10,<3.15
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: tba-concrete-verifiable-credential (==0.4.0.dev2)
+Requires-Dist: tba-concrete-verifiable-presentation (==0.4.0.dev2)

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name="tba-protocol-credential-w3c-vcdm"
+version="0.4.0.dev2"
+requires-python=">=3.10,<3.15"
+license="Apache-2.0"
+dependencies=["tba-concrete-verifiable-credential==0.4.0.dev2","tba-concrete-verifiable-presentation==0.4.0.dev2"]
+[build-system]
+requires=["poetry-core>=1.0.0"]
+build-backend="poetry.core.masonry.api"
+[tool.poetry]
+packages=[{include="tba_protocol_credential_w3c_vcdm",from="src"}]

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/__init__.py

@@ -0,0 +1,42 @@
+from .compatibility import VcdmCompatibility, compatibility
+from .contexts import VCDM_2_RECOMMENDATION, VC_CONTEXT_V2, validate_contexts
+from .features import FEATURES_BY_VERSION, supports
+from .errors import VcdmProtocolError
+from .migrations import migrate_document
+from .schemas import parse_verifiable_credential, parse_verifiable_presentation
+from .schema_references import CredentialSchemaReference, parse_credential_schema
+from .status import CredentialStatusEntry, parse_credential_status
+from .validation import validate_verifiable_credential, validate_verifiable_presentation
+from .versions import CURRENT_VERSION, VERSION_HISTORY, VcdmVersion, select_version
+from tba_concrete_verifiable_credential import VerifiableCredential
+from tba_concrete_verifiable_presentation import VerifiablePresentation
+
+__all__ = [
+    "CURRENT_VERSION",
+    "CAPABILITY_REQUIREMENTS",
+    "CredentialSchemaReference",
+    "CredentialStatusEntry",
+    "FEATURES_BY_VERSION",
+    "VCDM_2_RECOMMENDATION",
+    "VC_CONTEXT_V2",
+    "VERSION_HISTORY",
+    "VcdmCompatibility",
+    "VcdmProtocolError",
+    "VcdmVersion",
+    "VerifiableCredential",
+    "VerifiablePresentation",
+    "compatibility",
+    "credential_subject_claims",
+    "migrate_document",
+    "parse_credential_schema",
+    "parse_credential_status",
+    "parse_verifiable_credential",
+    "parse_verifiable_presentation",
+    "select_version",
+    "supports",
+    "validate_contexts",
+    "validate_verifiable_credential",
+    "validate_verifiable_presentation",
+]
+from .bindings import CAPABILITY_REQUIREMENTS
+from .claims import credential_subject_claims

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/bindings.py

@@ -0,0 +1,9 @@
+"""Capability bindings required by the W3C VCDM protocol owner."""
+
+CAPABILITY_REQUIREMENTS = (
+    "credential.issue.verifiable-credential",
+    "credential.verify.verifiable-credential",
+    "presentation.verify.verifiable-presentation",
+)
+
+__all__ = ["CAPABILITY_REQUIREMENTS"]

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/claims.py

@@ -0,0 +1,12 @@
+"""W3C VCDM credential-subject claim material."""
+
+from collections.abc import Mapping
+
+
+def credential_subject_claims(value: Mapping[str, object]) -> dict[str, object]:
+    """Normalize credential-subject claims without assigning assurance."""
+
+    return {str(name): claim for name, claim in value.items()}
+
+
+__all__ = ["credential_subject_claims"]

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/compatibility.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+
+from .versions import CURRENT_VERSION, VcdmVersion
+
+
+@dataclass(frozen=True, slots=True)
+class VcdmCompatibility:
+    source: str
+    target: str
+    compatible: bool
+    migration_required: bool
+
+
+def compatibility(
+    source: str, target: str = CURRENT_VERSION.value
+) -> VcdmCompatibility:
+    known = source in {version.value for version in VcdmVersion}
+    return VcdmCompatibility(source, target, known, known and source != target)
+
+
+__all__ = ["VcdmCompatibility", "compatibility"]

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/contexts.py

@@ -0,0 +1,21 @@
+from collections.abc import Sequence
+
+VCDM_2_RECOMMENDATION = "W3C Recommendation 15 May 2025"
+VC_CONTEXT_V2 = "https://www.w3.org/ns/credentials/v2"
+
+
+def validate_contexts(contexts: object) -> tuple[object, ...]:
+    if (
+        not isinstance(contexts, Sequence)
+        or isinstance(contexts, (str, bytes))
+        or not contexts
+    ):
+        raise ValueError("@context must be a non-empty array")
+    if contexts[0] != VC_CONTEXT_V2:
+        raise ValueError("VCDM 2.0 base context must be first")
+    if any(not isinstance(context, (str, dict)) for context in contexts):
+        raise ValueError("contexts must be URLs or context objects")
+    return tuple(contexts)
+
+
+__all__ = ["VCDM_2_RECOMMENDATION", "VC_CONTEXT_V2", "validate_contexts"]

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/errors.py

@@ -0,0 +1,8 @@
+"""W3C VCDM protocol errors."""
+
+
+class VcdmProtocolError(ValueError):
+    """Raised when a VCDM document violates the selected recommendation."""
+
+
+__all__ = ["VcdmProtocolError"]

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/features.py

@@ -0,0 +1,23 @@
+from .versions import CURRENT_VERSION, VcdmVersion
+
+
+FEATURES_BY_VERSION = {
+    VcdmVersion.V1_1.value: frozenset({"credential", "presentation", "issuance-date"}),
+    VcdmVersion.V2_0.value: frozenset(
+        {
+            "credential",
+            "presentation",
+            "valid-from",
+            "valid-until",
+            "credential-status",
+            "credential-schema",
+        }
+    ),
+}
+
+
+def supports(feature: str, version: VcdmVersion = CURRENT_VERSION) -> bool:
+    return feature in FEATURES_BY_VERSION[version.value]
+
+
+__all__ = ["FEATURES_BY_VERSION", "supports"]

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/migrations.py

@@ -0,0 +1,19 @@
+from typing import Mapping
+
+from .versions import VcdmVersion
+
+
+def migrate_document(
+    value: Mapping[str, object], *, source: str, target: str = "2.0"
+) -> dict[str, object]:
+    if source == target:
+        return dict(value)
+    if source != VcdmVersion.V1_1.value or target != VcdmVersion.V2_0.value:
+        raise ValueError(f"unsupported VCDM migration: {source} -> {target}")
+    migrated = dict(value)
+    if "issuanceDate" in migrated and "validFrom" not in migrated:
+        migrated["validFrom"] = migrated.pop("issuanceDate")
+    return migrated
+
+
+__all__ = ["migrate_document"]

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/py.typed

@@ -0,0 +1 @@
+

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/schema_references.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+from typing import Mapping
+
+
+@dataclass(frozen=True, slots=True)
+class CredentialSchemaReference:
+    identifier: str
+    schema_type: str
+    properties: Mapping[str, object]
+
+
+def parse_credential_schema(value: Mapping[str, object]) -> CredentialSchemaReference:
+    identifier, schema_type = value.get("id"), value.get("type")
+    if (
+        not isinstance(identifier, str)
+        or not identifier
+        or not isinstance(schema_type, str)
+        or not schema_type
+    ):
+        raise ValueError("credentialSchema requires id and type")
+    return CredentialSchemaReference(
+        identifier,
+        schema_type,
+        {name: item for name, item in value.items() if name not in {"id", "type"}},
+    )
+
+
+__all__ = ["CredentialSchemaReference", "parse_credential_schema"]

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/schemas.py

@@ -0,0 +1,100 @@
+from typing import Mapping, Sequence
+
+from tba_concrete_verifiable_credential import VerifiableCredential
+from tba_concrete_verifiable_presentation import VerifiablePresentation
+
+from .contexts import validate_contexts
+from .schema_references import parse_credential_schema
+from .status import parse_credential_status
+
+
+def _objects(value: object, name: str) -> tuple[Mapping[str, object], ...]:
+    values = (value,) if isinstance(value, Mapping) else value
+    if (
+        not isinstance(values, Sequence)
+        or isinstance(values, (str, bytes))
+        or not values
+        or not all(isinstance(item, Mapping) for item in values)
+    ):
+        raise ValueError(f"{name} must be an object or non-empty array of objects")
+    return tuple(dict(item) for item in values)
+
+
+def parse_verifiable_credential(value: Mapping[str, object]) -> VerifiableCredential:
+    contexts = validate_contexts(value.get("@context"))
+    types, issuer = value.get("type"), value.get("issuer")
+    if (
+        not isinstance(types, list)
+        or "VerifiableCredential" not in types
+        or not all(isinstance(item, str) for item in types)
+    ):
+        raise ValueError("type must include VerifiableCredential")
+    if not isinstance(issuer, (str, Mapping)) or not issuer:
+        raise ValueError("credential requires issuer")
+    subjects = _objects(value.get("credentialSubject"), "credentialSubject")
+    statuses = (
+        tuple(
+            parse_credential_status(item)
+            for item in _objects(value["credentialStatus"], "credentialStatus")
+        )
+        if "credentialStatus" in value
+        else ()
+    )
+    schemas = (
+        tuple(
+            parse_credential_schema(item)
+            for item in _objects(value["credentialSchema"], "credentialSchema")
+        )
+        if "credentialSchema" in value
+        else ()
+    )
+    return VerifiableCredential(
+        contexts,
+        tuple(types),
+        issuer,
+        subjects,
+        value.get("id") if isinstance(value.get("id"), str) else None,
+        value.get("validFrom") if isinstance(value.get("validFrom"), str) else None,
+        value.get("validUntil") if isinstance(value.get("validUntil"), str) else None,
+        statuses,
+        schemas,
+        value.get("proof"),
+    )
+
+
+def parse_verifiable_presentation(
+    value: Mapping[str, object],
+) -> VerifiablePresentation:
+    contexts = validate_contexts(value.get("@context"))
+    types = value.get("type")
+    if (
+        not isinstance(types, list)
+        or "VerifiablePresentation" not in types
+        or not all(isinstance(item, str) for item in types)
+    ):
+        raise ValueError("type must include VerifiablePresentation")
+    credentials = value.get("verifiableCredential", ())
+    if isinstance(credentials, (str, Mapping)):
+        credentials = (credentials,)
+    if (
+        not isinstance(credentials, Sequence)
+        or isinstance(credentials, bytes)
+        or any(not isinstance(item, (str, Mapping)) for item in credentials)
+    ):
+        raise ValueError(
+            "verifiableCredential must contain credential objects or strings"
+        )
+    holder = value.get("holder")
+    if holder is not None and not isinstance(holder, (str, Mapping)):
+        raise ValueError("holder must be a URL or object")
+    return VerifiablePresentation(
+        contexts,
+        tuple(types),
+        tuple(credentials),
+        holder,
+        value.get("id") if isinstance(value.get("id"), str) else None,
+        value.get("proof"),
+    )
+
+
+__all__ = ["parse_verifiable_credential", "parse_verifiable_presentation"]

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/status.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+from typing import Mapping
+
+
+@dataclass(frozen=True, slots=True)
+class CredentialStatusEntry:
+    identifier: str
+    status_type: str
+    properties: Mapping[str, object]
+
+
+def parse_credential_status(value: Mapping[str, object]) -> CredentialStatusEntry:
+    identifier, status_type = value.get("id"), value.get("type")
+    if (
+        not isinstance(identifier, str)
+        or not identifier
+        or not isinstance(status_type, str)
+        or not status_type
+    ):
+        raise ValueError("credentialStatus requires id and type")
+    return CredentialStatusEntry(
+        identifier,
+        status_type,
+        {name: item for name, item in value.items() if name not in {"id", "type"}},
+    )
+
+
+__all__ = ["CredentialStatusEntry", "parse_credential_status"]

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/validation.py

@@ -0,0 +1,44 @@
+from typing import Mapping
+
+from tba_concrete_verifiable_credential import VerifiableCredential
+from tba_concrete_verifiable_presentation import VerifiablePresentation
+
+from .schemas import parse_verifiable_credential, parse_verifiable_presentation
+
+
+def _validate_proof_container(proof: object) -> None:
+    if proof is None:
+        return
+    proofs = proof if isinstance(proof, list) else [proof]
+    if not proofs or not all(
+        isinstance(item, Mapping) and isinstance(item.get("type"), str)
+        for item in proofs
+    ):
+        raise ValueError("proof must be an object or array of objects with type")
+
+
+def validate_verifiable_credential(
+    value: Mapping[str, object] | VerifiableCredential,
+) -> None:
+    credential = (
+        parse_verifiable_credential(value) if isinstance(value, Mapping) else value
+    )
+    _validate_proof_container(credential.proof)
+    if (
+        credential.valid_from
+        and credential.valid_until
+        and credential.valid_from > credential.valid_until
+    ):
+        raise ValueError("validFrom must not follow validUntil")
+
+
+def validate_verifiable_presentation(
+    value: Mapping[str, object] | VerifiablePresentation,
+) -> None:
+    presentation = (
+        parse_verifiable_presentation(value) if isinstance(value, Mapping) else value
+    )
+    _validate_proof_container(presentation.proof)
+
+
+__all__ = ["validate_verifiable_credential", "validate_verifiable_presentation"]

tba_protocol_credential_w3c_vcdm-0.4.0.dev2/src/tba_protocol_credential_w3c_vcdm/versions.py

@@ -0,0 +1,26 @@
+from enum import StrEnum
+
+
+class VcdmVersion(StrEnum):
+    V1_1 = "1.1"
+    V2_0 = "2.0"
+
+
+CURRENT_VERSION = VcdmVersion.V2_0
+VERSION_HISTORY = {
+    VcdmVersion.V1_1.value: {
+        "status": "recommendation",
+        "specification": "https://www.w3.org/TR/vc-data-model/",
+    },
+    VcdmVersion.V2_0.value: {
+        "status": "recommendation",
+        "specification": "https://www.w3.org/TR/vc-data-model-2.0/",
+    },
+}
+
+
+def select_version(value: str | VcdmVersion) -> VcdmVersion:
+    return VcdmVersion(value)
+
+
+__all__ = ["CURRENT_VERSION", "VERSION_HISTORY", "VcdmVersion", "select_version"]