tba-storage-core 0.4.0.dev2__py3-none-any.whl

tba_storage_core/tables/dpop_replay/_table.py

@@ -0,0 +1,97 @@
+"""Durable DPoP replay ledger."""
+
+from __future__ import annotations
+
+import datetime as dt
+import hashlib
+from datetime import timezone
+from typing import Any
+
+from tba_storage_core.framework import (
+    GUIDPk,
+    Mapped,
+    RestOltpTable,
+    S,
+    String,
+    TZDateTime,
+    Timestamped,
+    acol,
+)
+
+
+class DpopReplay(RestOltpTable, GUIDPk, Timestamped):
+    __tablename__ = "dpop_replays"
+    __table_args__ = ({"schema": "authn"},)
+
+    replay_key: Mapped[str] = acol(storage=S(String(64), nullable=False, unique=True, index=True))
+    jkt: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    jti: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    htm: Mapped[str] = acol(storage=S(String(16), nullable=False, index=True))
+    htu: Mapped[str] = acol(storage=S(String(2000), nullable=False, index=True))
+    ath: Mapped[str | None] = acol(storage=S(String(512), nullable=True, index=True))
+    proof_iat: Mapped[dt.datetime] = acol(storage=S(TZDateTime, nullable=False, index=True))
+    first_seen_at: Mapped[dt.datetime] = acol(storage=S(TZDateTime, nullable=False, index=True))
+    expires_at: Mapped[dt.datetime] = acol(storage=S(TZDateTime, nullable=False, index=True))
+
+
+def _as_aware(value: Any) -> dt.datetime:
+    if isinstance(value, dt.datetime):
+        parsed = value
+    elif isinstance(value, (int, float)):
+        parsed = dt.datetime.fromtimestamp(value, tz=timezone.utc)
+    else:
+        parsed = dt.datetime.fromisoformat(str(value))
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def replay_key(*, jkt: str, jti: str, htm: str, htu: str, ath: str | None = None) -> str:
+    material = "\x1f".join(
+        (
+            str(jkt).strip(),
+            str(jti).strip(),
+            str(htm).upper().strip(),
+            str(htu).strip(),
+            str(ath or "").strip(),
+        )
+    ).encode("utf-8")
+    return hashlib.sha256(material).hexdigest()
+
+
+def replay_payload(
+    *,
+    jkt: str,
+    jti: str,
+    htm: str,
+    htu: str,
+    ath: str | None,
+    proof_iat: dt.datetime | int | float,
+    first_seen_at: dt.datetime,
+    expires_at: dt.datetime,
+) -> dict[str, Any]:
+    normalized_jkt = str(jkt).strip()
+    normalized_jti = str(jti).strip()
+    normalized_htm = str(htm).upper().strip()
+    normalized_htu = str(htu).strip()
+    normalized_ath = str(ath).strip() if ath not in {None, ""} else None
+    return {
+        "replay_key": replay_key(
+            jkt=normalized_jkt,
+            jti=normalized_jti,
+            htm=normalized_htm,
+            htu=normalized_htu,
+            ath=normalized_ath,
+        ),
+        "jkt": normalized_jkt,
+        "jti": normalized_jti,
+        "htm": normalized_htm,
+        "htu": normalized_htu,
+        "ath": normalized_ath,
+        "proof_iat": _as_aware(proof_iat),
+        "first_seen_at": _as_aware(first_seen_at),
+        "expires_at": _as_aware(expires_at),
+    }
+
+
+__all__ = ["DpopReplay", "replay_key", "replay_payload"]

tba_storage_core/tables/entitlement/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from . import _table as _table
+from ._table import *
+
+try:
+    __all__ = list(_table.__all__)
+except AttributeError:
+    __all__ = [name for name in globals() if not name.startswith("_")]

tba_storage_core/tables/entitlement/_table.py

@@ -0,0 +1,22 @@
+"""Durable entitlement definitions."""
+
+from __future__ import annotations
+
+
+from tba_storage_core.framework import RestOltpTable, GUIDPk, Mapped, S, String, Timestamped, acol
+
+
+
+class Entitlement(RestOltpTable, GUIDPk, Timestamped):
+    __tablename__ = "entitlements"
+    __table_args__ = ({"schema": "authn"},)
+
+    entitlement_id: Mapped[str] = acol(storage=S(String(255), nullable=False, unique=True, index=True))
+    tenant_id: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    name: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    owner: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    description: Mapped[str] = acol(storage=S(String(1000), nullable=False))
+    status: Mapped[str] = acol(storage=S(String(32), nullable=False, default="active", index=True))
+
+
+__all__ = ["Entitlement"]

tba_storage_core/tables/entitlement_assignment/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from . import _table as _table
+from ._table import *
+
+try:
+    __all__ = list(_table.__all__)
+except AttributeError:
+    __all__ = [name for name in globals() if not name.startswith("_")]

tba_storage_core/tables/entitlement_assignment/_table.py

@@ -0,0 +1,26 @@
+"""Durable entitlement assignments."""
+
+from __future__ import annotations
+
+import datetime as dt
+
+from tba_storage_core.framework import RestOltpTable, GUIDPk, Mapped, S, String, TZDateTime, Timestamped, acol
+
+
+
+class EntitlementAssignment(RestOltpTable, GUIDPk, Timestamped):
+    __tablename__ = "entitlement_assignments"
+    __table_args__ = ({"schema": "authn"},)
+
+    assignment_id: Mapped[str] = acol(storage=S(String(255), nullable=False, unique=True, index=True))
+    entitlement_id: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    tenant_id: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    subject_id: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    justification: Mapped[str] = acol(storage=S(String(1000), nullable=False))
+    assigned_by: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    expires_at: Mapped[dt.datetime | None] = acol(storage=S(TZDateTime, nullable=True, index=True))
+    status: Mapped[str] = acol(storage=S(String(32), nullable=False, default="active", index=True))
+    revoked_reason: Mapped[str | None] = acol(storage=S(String(1000), nullable=True))
+
+
+__all__ = ["EntitlementAssignment"]

tba_storage_core/tables/federated_session/__init__.py

@@ -0,0 +1,5 @@
+"""Federated session table export."""
+
+from ._table import FederatedSession
+
+__all__ = ["FederatedSession"]

tba_storage_core/tables/federated_session/_table.py

@@ -0,0 +1,32 @@
+"""Durable federated login session records."""
+
+from __future__ import annotations
+
+from tba_storage_core.framework import (
+    Boolean,
+    GUIDPk,
+    JSON,
+    Mapped,
+    RestOltpTable,
+    S,
+    String,
+    Timestamped,
+    acol,
+)
+
+
+class FederatedSession(RestOltpTable, GUIDPk, Timestamped):
+    __tablename__ = "federated_sessions"
+    __table_args__ = ({"schema": "authn"},)
+
+    session_id: Mapped[str] = acol(storage=S(String(255), nullable=False, unique=True, index=True))
+    provider_id: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    tenant_id: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    issuer: Mapped[str] = acol(storage=S(String(1000), nullable=False, index=True))
+    audience: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    logout_supported: Mapped[bool] = acol(storage=S(Boolean, nullable=False, default=False, index=True))
+    normalized_claims: Mapped[dict] = acol(storage=S(JSON, nullable=False, default=dict))
+    bound_at: Mapped[str] = acol(storage=S(String(64), nullable=False, index=True))
+
+
+__all__ = ["FederatedSession"]

tba_storage_core/tables/federation/__init__.py

@@ -0,0 +1,5 @@
+"""Federation registry table export."""
+
+from ._table import Federation
+
+__all__ = ["Federation"]

tba_storage_core/tables/federation/_table.py

@@ -0,0 +1,37 @@
+"""Durable federation registry records."""
+
+from __future__ import annotations
+
+from tba_storage_core.framework import (
+    Boolean,
+    GUIDPk,
+    Integer,
+    JSON,
+    Mapped,
+    RestOltpTable,
+    S,
+    String,
+    Timestamped,
+    acol,
+)
+
+
+class Federation(RestOltpTable, GUIDPk, Timestamped):
+    __tablename__ = "federations"
+    __table_args__ = ({"schema": "authn"},)
+
+    federation_id: Mapped[str] = acol(storage=S(String(255), nullable=False, unique=True, index=True))
+    tenant_id: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    kind: Mapped[str] = acol(storage=S(String(64), nullable=False, index=True))
+    issuer: Mapped[str] = acol(storage=S(String(1000), nullable=False, index=True))
+    discovery_url: Mapped[str] = acol(storage=S(String(1000), nullable=False))
+    audience: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    logout_supported: Mapped[bool] = acol(storage=S(Boolean, nullable=False, default=False, index=True))
+    display_name: Mapped[str] = acol(storage=S(String(255), nullable=False))
+    claim_mapping: Mapped[dict] = acol(storage=S(JSON, nullable=False, default=dict))
+    scopes: Mapped[dict] = acol(storage=S(JSON, nullable=False, default=dict))
+    key_set_version: Mapped[int] = acol(storage=S(Integer, nullable=False, default=1))
+    enabled: Mapped[bool] = acol(storage=S(Boolean, nullable=False, default=True, index=True))
+
+
+__all__ = ["Federation"]

tba_storage_core/tables/gnap_client_instance/__init__.py

@@ -0,0 +1,3 @@
+from ..did_gnap_state import GnapClientInstance
+
+__all__ = ["GnapClientInstance"]

tba_storage_core/tables/gnap_continuation/__init__.py

@@ -0,0 +1,3 @@
+from ..did_gnap_state import GnapContinuation
+
+__all__ = ["GnapContinuation"]

tba_storage_core/tables/gnap_grant/__init__.py

@@ -0,0 +1,3 @@
+from ..did_gnap_state import GnapGrant
+
+__all__ = ["GnapGrant"]

tba_storage_core/tables/gnap_interaction/__init__.py

@@ -0,0 +1,3 @@
+from ..did_gnap_state import GnapInteraction
+
+__all__ = ["GnapInteraction"]

tba_storage_core/tables/identity_provider/__init__.py

@@ -0,0 +1,5 @@
+"""Identity provider table export."""
+
+from ._table import IdentityProvider
+
+__all__ = ["IdentityProvider"]

tba_storage_core/tables/identity_provider/_table.py

@@ -0,0 +1,37 @@
+"""Durable federated identity provider records."""
+
+from __future__ import annotations
+
+from tba_storage_core.framework import (
+    Boolean,
+    GUIDPk,
+    Integer,
+    JSON,
+    Mapped,
+    RestOltpTable,
+    S,
+    String,
+    Timestamped,
+    acol,
+)
+
+
+class IdentityProvider(RestOltpTable, GUIDPk, Timestamped):
+    __tablename__ = "identity_providers"
+    __table_args__ = ({"schema": "authn"},)
+
+    provider_id: Mapped[str] = acol(storage=S(String(255), nullable=False, unique=True, index=True))
+    tenant_id: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    kind: Mapped[str] = acol(storage=S(String(64), nullable=False, index=True))
+    issuer: Mapped[str] = acol(storage=S(String(1000), nullable=False, index=True))
+    discovery_url: Mapped[str] = acol(storage=S(String(1000), nullable=False))
+    audience: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    logout_supported: Mapped[bool] = acol(storage=S(Boolean, nullable=False, default=False, index=True))
+    display_name: Mapped[str] = acol(storage=S(String(255), nullable=False))
+    claim_mapping: Mapped[dict] = acol(storage=S(JSON, nullable=False, default=dict))
+    scopes: Mapped[dict] = acol(storage=S(JSON, nullable=False, default=dict))
+    key_set_version: Mapped[int] = acol(storage=S(Integer, nullable=False, default=1))
+    enabled: Mapped[bool] = acol(storage=S(Boolean, nullable=False, default=True, index=True))
+
+
+__all__ = ["IdentityProvider"]

tba_storage_core/tables/invariant_evaluation/__init__.py

@@ -0,0 +1,5 @@
+"""Invariant evaluation table export."""
+
+from ._table import InvariantEvaluation
+
+__all__ = ["InvariantEvaluation"]

tba_storage_core/tables/invariant_evaluation/_table.py

@@ -0,0 +1,29 @@
+"""Durable authorization invariant evaluation records."""
+
+from __future__ import annotations
+
+from tba_storage_core.framework import (
+    Boolean,
+    GUIDPk,
+    JSON,
+    Mapped,
+    RestOltpTable,
+    S,
+    String,
+    Timestamped,
+    acol,
+)
+
+
+class InvariantEvaluation(RestOltpTable, GUIDPk, Timestamped):
+    __tablename__ = "invariant_evaluations"
+    __table_args__ = ({"schema": "authn"},)
+
+    invariant_id: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    passed: Mapped[bool] = acol(storage=S(Boolean, nullable=False, index=True))
+    message: Mapped[str] = acol(storage=S(String(2000), nullable=False))
+    evaluated_at: Mapped[str] = acol(storage=S(String(64), nullable=False, index=True))
+    evidence: Mapped[dict] = acol(storage=S(JSON, nullable=False, default=dict))
+
+
+__all__ = ["InvariantEvaluation"]

tba_storage_core/tables/invariant_violation/__init__.py

@@ -0,0 +1,5 @@
+"""Invariant violation table export."""
+
+from ._table import InvariantViolation
+
+__all__ = ["InvariantViolation"]

tba_storage_core/tables/invariant_violation/_table.py

@@ -0,0 +1,27 @@
+"""Durable authorization invariant violation records."""
+
+from __future__ import annotations
+
+from tba_storage_core.framework import (
+    GUIDPk,
+    JSON,
+    Mapped,
+    RestOltpTable,
+    S,
+    String,
+    Timestamped,
+    acol,
+)
+
+
+class InvariantViolation(RestOltpTable, GUIDPk, Timestamped):
+    __tablename__ = "invariant_violations"
+    __table_args__ = ({"schema": "authn"},)
+
+    invariant_id: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    severity: Mapped[str] = acol(storage=S(String(64), nullable=False, index=True))
+    message: Mapped[str] = acol(storage=S(String(2000), nullable=False))
+    evidence: Mapped[dict] = acol(storage=S(JSON, nullable=False, default=dict))
+
+
+__all__ = ["InvariantViolation"]

tba_storage_core/tables/key_attestation_evidence/__init__.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from . import _table as _table
+from ._table import *
+
+for _name in dir(_table):
+    if not _name.startswith("__"):
+        globals().setdefault(_name, getattr(_table, _name))
+
+try:
+    __all__ = list(_table.__all__)
+except AttributeError:
+    __all__ = [name for name in globals() if not name.startswith("_")]

tba_storage_core/tables/key_attestation_evidence/_table.py

@@ -0,0 +1,99 @@
+"""Durable key attestation evidence metadata."""
+
+from __future__ import annotations
+
+import datetime as dt
+import uuid
+
+from tba_storage_core.framework import (
+    ForeignKeySpec,
+    GUIDPk,
+    JSON,
+    Mapped,
+    PgUUID,
+    RestOltpTable,
+    S,
+    String,
+    TZDateTime,
+    Timestamped,
+    acol,
+)
+
+
+class KeyAttestationEvidence(RestOltpTable, GUIDPk, Timestamped):
+    __tablename__ = "key_attestation_evidence"
+    __table_args__ = ({"schema": "authn"},)
+
+    key_id: Mapped[uuid.UUID] = acol(
+        storage=S(
+            PgUUID(as_uuid=True),
+            fk=ForeignKeySpec(target="authn.crypto_keys.id"),
+            nullable=False,
+            index=True,
+        )
+    )
+    key_version_id: Mapped[uuid.UUID | None] = acol(
+        storage=S(
+            PgUUID(as_uuid=True),
+            fk=ForeignKeySpec(target="authn.crypto_key_versions.id"),
+            nullable=True,
+            index=True,
+        )
+    )
+    issuer_key_id: Mapped[uuid.UUID | None] = acol(
+        storage=S(
+            PgUUID(as_uuid=True),
+            fk=ForeignKeySpec(target="authn.crypto_keys.id"),
+            nullable=True,
+            index=True,
+        )
+    )
+    issuer_provider: Mapped[str | None] = acol(
+        storage=S(String(255), nullable=True, index=True)
+    )
+    evidence_format: Mapped[str] = acol(
+        storage=S(String(64), nullable=False, index=True)
+    )
+    profile: Mapped[str | None] = acol(
+        storage=S(String(255), nullable=True, index=True)
+    )
+    issuer: Mapped[str | None] = acol(
+        storage=S(String(1000), nullable=True, index=True)
+    )
+    evidence_digest: Mapped[str | None] = acol(
+        storage=S(String(128), nullable=True, index=True)
+    )
+    verification_result: Mapped[str | None] = acol(
+        storage=S(String(64), nullable=True, index=True)
+    )
+    valid_until: Mapped[dt.datetime | None] = acol(
+        storage=S(TZDateTime, nullable=True, index=True)
+    )
+    evidence: Mapped[dict | str] = acol(storage=S(JSON, nullable=False))
+    claims: Mapped[dict | None] = acol(storage=S(JSON, nullable=True))
+    status: Mapped[str] = acol(
+        storage=S(String(32), nullable=False, default="unverified", index=True)
+    )
+    verified_at: Mapped[dt.datetime | None] = acol(
+        storage=S(TZDateTime, nullable=True, index=True)
+    )
+    evidence_metadata: Mapped[dict | None] = acol(storage=S(JSON, nullable=True))
+    tenant_id: Mapped[uuid.UUID | None] = acol(
+        storage=S(
+            PgUUID(as_uuid=True),
+            fk=ForeignKeySpec(target="authn.tenants.id"),
+            nullable=True,
+            index=True,
+        )
+    )
+    realm_id: Mapped[uuid.UUID | None] = acol(
+        storage=S(
+            PgUUID(as_uuid=True),
+            fk=ForeignKeySpec(target="authn.realms.id"),
+            nullable=True,
+            index=True,
+        )
+    )
+
+
+__all__ = ["KeyAttestationEvidence"]

tba_storage_core/tables/key_envelope/__init__.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from . import _table as _table
+from ._table import *
+
+for _name in dir(_table):
+    if not _name.startswith("__"):
+        globals().setdefault(_name, getattr(_table, _name))
+
+try:
+    __all__ = list(_table.__all__)
+except AttributeError:
+    __all__ = [name for name in globals() if not name.startswith("_")]

tba_storage_core/tables/key_envelope/_table.py

@@ -0,0 +1,54 @@
+"""Durable wrapped data-key envelope metadata."""
+
+from __future__ import annotations
+
+import uuid
+
+from tba_storage_core.framework import (
+    ForeignKeySpec,
+    GUIDPk,
+    JSON,
+    Mapped,
+    PgUUID,
+    RestOltpTable,
+    S,
+    String,
+    Timestamped,
+    acol,
+)
+
+
+
+class KeyEnvelope(RestOltpTable, GUIDPk, Timestamped):
+    __tablename__ = "key_envelopes"
+    __table_args__ = ({"schema": "authn"},)
+
+    envelope_label: Mapped[str | None] = acol(storage=S(String(255), nullable=True, index=True))
+    wrapping_key_id: Mapped[uuid.UUID] = acol(
+        storage=S(PgUUID(as_uuid=True), fk=ForeignKeySpec(target="authn.crypto_keys.id"), nullable=False, index=True)
+    )
+    wrapping_key_version_id: Mapped[uuid.UUID | None] = acol(
+        storage=S(PgUUID(as_uuid=True), fk=ForeignKeySpec(target="authn.crypto_key_versions.id"), nullable=True, index=True)
+    )
+    wrapped_key_id: Mapped[uuid.UUID | None] = acol(
+        storage=S(PgUUID(as_uuid=True), fk=ForeignKeySpec(target="authn.crypto_keys.id"), nullable=True, index=True)
+    )
+    wrapped_key_version_id: Mapped[uuid.UUID | None] = acol(
+        storage=S(PgUUID(as_uuid=True), fk=ForeignKeySpec(target="authn.crypto_key_versions.id"), nullable=True, index=True)
+    )
+    algorithm: Mapped[str] = acol(storage=S(String(128), nullable=False, index=True))
+    material_format: Mapped[str] = acol(storage=S(String(64), nullable=False, default="wrapped", index=True))
+    wrapped_material: Mapped[dict | str] = acol(storage=S(JSON, nullable=False))
+    aad_hash: Mapped[str | None] = acol(storage=S(String(255), nullable=True, index=True))
+    status: Mapped[str] = acol(storage=S(String(32), nullable=False, default="active", index=True))
+    envelope_context: Mapped[dict | None] = acol(storage=S(JSON, nullable=True))
+    envelope_metadata: Mapped[dict | None] = acol(storage=S(JSON, nullable=True))
+    tenant_id: Mapped[uuid.UUID | None] = acol(
+        storage=S(PgUUID(as_uuid=True), fk=ForeignKeySpec(target="authn.tenants.id"), nullable=True, index=True)
+    )
+    realm_id: Mapped[uuid.UUID | None] = acol(
+        storage=S(PgUUID(as_uuid=True), fk=ForeignKeySpec(target="authn.realms.id"), nullable=True, index=True)
+    )
+
+
+__all__ = ["KeyEnvelope"]

tba_storage_core/tables/key_rotation_event/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from . import _table as _table
+from ._table import *
+
+try:
+    __all__ = list(_table.__all__)
+except AttributeError:
+    __all__ = [name for name in globals() if not name.startswith("_")]

tba_storage_core/tables/key_rotation_event/_table.py

@@ -0,0 +1,44 @@
+"""Durable key rotation audit trail."""
+
+from __future__ import annotations
+
+import datetime as dt
+import uuid
+
+from tba_storage_core.framework import (
+    RestOltpTable,
+    TenantColumn,
+    Timestamped,
+    S,
+    acol,
+    JSON,
+    Mapped,
+    String,
+    TZDateTime,
+    GUIDPk,
+    ForeignKeySpec,
+    PgUUID,
+)
+
+
+class KeyRotationEvent(RestOltpTable, GUIDPk, Timestamped, TenantColumn):
+    __tablename__ = "key_rotation_events"
+    __table_args__ = ({"schema": "authn"},)
+
+    actor_user_id: Mapped[uuid.UUID | None] = acol(
+        storage=S(PgUUID(as_uuid=True), fk=ForeignKeySpec(target="authn.users.id"), nullable=True, index=True)
+    )
+    actor_client_id: Mapped[uuid.UUID | None] = acol(
+        storage=S(PgUUID(as_uuid=True), fk=ForeignKeySpec(target="authn.clients.id"), nullable=True, index=True)
+    )
+    key_kid: Mapped[str] = acol(storage=S(String(255), nullable=False, index=True))
+    algorithm: Mapped[str | None] = acol(storage=S(String(64), nullable=True))
+    action: Mapped[str] = acol(storage=S(String(64), nullable=False, default="rotate"))
+    status: Mapped[str] = acol(storage=S(String(32), nullable=False, default="success"))
+    details: Mapped[dict | None] = acol(storage=S(JSON, nullable=True))
+    occurred_at: Mapped[dt.datetime] = acol(
+        storage=S(TZDateTime, nullable=False, default=lambda: dt.datetime.now(dt.timezone.utc))
+    )
+
+
+__all__ = ["KeyRotationEvent"]

tba_storage_core/tables/key_rotation_policy/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from . import _table as _table
+from ._table import *
+
+try:
+    __all__ = list(_table.__all__)
+except AttributeError:
+    __all__ = [name for name in globals() if not name.startswith("_")]