financial-data-protocol 0.3.0a3__py3-none-any.whl

financial_data_protocol/__init__.py

@@ -0,0 +1,187 @@
+"""Financial Data Protocol public package."""
+
+from .client import FdpClient, FdpConfig
+from .client.protocol_client import CentralClient, CentralClientError
+from .constants import API_SCHEMA_VERSION, CENTRAL_SCHEMA_REVISION, CENTRAL_SCHEMA_VERSION
+from .models import (
+    Artifact,
+    Content,
+    DeclarationProvenance,
+    DisclosurePackageRevision,
+    DisclosureReceipt,
+    DisclosureRevocation,
+    EvidenceReference,
+    LineageDeclaration,
+    LineageRelationType,
+    MaterialTransfer,
+    Package,
+    PackageMember,
+    PackageRevision,
+    RegistrySpace,
+    SpaceAccess,
+    UsageReceipt,
+    WriteConflict,
+    WriteCreated,
+    WriteIdempotent,
+    WriteResult,
+)
+from .server.api import (
+    ApiFailure,
+    ApiRequest,
+    ApiResponse,
+    ApiSuccess,
+    CentralTransport,
+    InProcessCentralTransport,
+    StaticMachineTokenAuthenticator,
+    StaticMachineTokenBinding,
+)
+from .server.authority import (
+    AuthorityCutoverRecord,
+    AuthorityRollbackPointRecord,
+    AuthorityRollbackRecord,
+    DomainAuthorityGate,
+    DomainAuthorityReadback,
+    DomainAuthorityState,
+    ShadowComparison,
+)
+from .server.config import CentralSettings
+from .server.db.mongo.schema import CENTRAL_MONGO_SCHEMA_REVISION
+from .server.errors import (
+    AuthorizationError,
+    ContentIntegrityError,
+    NotFoundError,
+    OperationStateError,
+    ServiceError,
+)
+from .server.http import CentralHttpApp, HttpCentralTransport, create_app
+from .server.object_storage import (
+    AlibabaCloudOssObjectStore,
+    InMemoryObjectStore,
+    ObjectStore,
+    S3ObjectStore,
+    StreamingObjectStore,
+)
+from .server.registries import (
+    CentralOperationState,
+    CleanupUploadRequest,
+    FinalizedUpload,
+    FinalizeUploadRequest,
+    IdempotencyRecord,
+    InMemoryRegistryCustody,
+    RegistryCustody,
+    StagedUpload,
+    StageUploadRequest,
+)
+from .server.registries.mongo_registry import CentralMongoRegistry
+from .server.registries.postgres_registry import (
+    CENTRAL_POSTGRES_SCHEMA_REVISION,
+    CentralPostgresRegistry,
+)
+from .server.schema import export_all_json_schemas, export_json_schema, schema_names
+from .server.services import (
+    ArtifactService,
+    BackupRestoreReadiness,
+    CentralAccessContext,
+    CentralService,
+    ContextSpaceAuthorizer,
+    RecoveryContentCheck,
+    RecoveryRecordCheck,
+    RecoveryRecordState,
+    RecoveryReport,
+    SpaceAuthorizer,
+)
+from .server.services.content_service import (
+    ContentVerificationState,
+    FinalizedContentInspection,
+    OrphanedObject,
+)
+
+__all__ = [
+    "API_SCHEMA_VERSION",
+    "CENTRAL_MONGO_SCHEMA_REVISION",
+    "CENTRAL_POSTGRES_SCHEMA_REVISION",
+    "CENTRAL_SCHEMA_REVISION",
+    "CENTRAL_SCHEMA_VERSION",
+    "AlibabaCloudOssObjectStore",
+    "ApiFailure",
+    "ApiRequest",
+    "ApiResponse",
+    "ApiSuccess",
+    "Artifact",
+    "ArtifactService",
+    "AuthorityCutoverRecord",
+    "AuthorityRollbackPointRecord",
+    "AuthorityRollbackRecord",
+    "AuthorizationError",
+    "BackupRestoreReadiness",
+    "CentralAccessContext",
+    "CentralClient",
+    "CentralClientError",
+    "CentralHttpApp",
+    "CentralMongoRegistry",
+    "CentralOperationState",
+    "CentralPostgresRegistry",
+    "CentralService",
+    "CentralSettings",
+    "CentralTransport",
+    "CleanupUploadRequest",
+    "Content",
+    "ContentIntegrityError",
+    "ContentVerificationState",
+    "ContextSpaceAuthorizer",
+    "DeclarationProvenance",
+    "DisclosurePackageRevision",
+    "DisclosureReceipt",
+    "DisclosureRevocation",
+    "DomainAuthorityGate",
+    "DomainAuthorityReadback",
+    "DomainAuthorityState",
+    "EvidenceReference",
+    "FdpClient",
+    "FdpConfig",
+    "FinalizeUploadRequest",
+    "FinalizedContentInspection",
+    "FinalizedUpload",
+    "HttpCentralTransport",
+    "IdempotencyRecord",
+    "InMemoryObjectStore",
+    "InMemoryRegistryCustody",
+    "InProcessCentralTransport",
+    "LineageDeclaration",
+    "LineageRelationType",
+    "MaterialTransfer",
+    "NotFoundError",
+    "ObjectStore",
+    "OperationStateError",
+    "OrphanedObject",
+    "Package",
+    "PackageMember",
+    "PackageRevision",
+    "RecoveryContentCheck",
+    "RecoveryRecordCheck",
+    "RecoveryRecordState",
+    "RecoveryReport",
+    "RegistryCustody",
+    "RegistrySpace",
+    "S3ObjectStore",
+    "ServiceError",
+    "ShadowComparison",
+    "SpaceAccess",
+    "SpaceAuthorizer",
+    "StageUploadRequest",
+    "StagedUpload",
+    "StaticMachineTokenAuthenticator",
+    "StaticMachineTokenBinding",
+    "StreamingObjectStore",
+    "UsageReceipt",
+    "WriteConflict",
+    "WriteCreated",
+    "WriteIdempotent",
+    "WriteResult",
+    "create_app",
+    "export_all_json_schemas",
+    "export_json_schema",
+    "schema_names",
+]
+
+__version__ = "0.3.0a2"

financial_data_protocol/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

financial_data_protocol/cli/__init__.py

@@ -0,0 +1,186 @@
+"""Explicit, configuration-authenticated Central custody reconciliation CLI."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Sequence
+from typing import Any, Never
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from ..server.app import load_server_settings
+from ..server.config import OperatorSettings
+from ..server.errors import FDPError
+from ..server.http import HttpCentralTransport
+from ..server.registries.mongo_registry import CentralMongoRegistry
+
+EXIT_OK = 0
+EXIT_USAGE = 2
+EXIT_OPERATIONAL_ERROR = 4
+
+
+def _emit(payload: Any, *, stream: Any = sys.stdout) -> None:
+    print(json.dumps(payload, ensure_ascii=False, sort_keys=True), file=stream)
+
+
+class _Parser(argparse.ArgumentParser):
+    def error(self, message: str) -> Never:
+        _emit({"ok": False, "error": "invalid_arguments", "message": message}, stream=sys.stderr)
+        raise SystemExit(EXIT_USAGE)
+
+
+def _parser() -> _Parser:
+    parser = _Parser(prog="fdp-central", description="FDP Central operator commands")
+    commands = parser.add_subparsers(dest="command", required=True)
+    sweep = commands.add_parser(
+        "blob-sweep",
+        help="reconcile final Blob objects for a month, for example --month 2026-08",
+    )
+    sweep.add_argument("--registry-space-id", required=True)
+    sweep.add_argument("--caller-id", required=True)
+    sweep.add_argument(
+        "--month",
+        required=True,
+        help="UTC Blob creation month in YYYY-MM format, for example 2026-08",
+    )
+    sweep.add_argument("--max-keys", type=int, default=1000)
+    sweep.add_argument("--apply", action="store_true")
+    commands.add_parser(
+        "init-db", help="initialize the configured Central MongoDB registry (empty database only)"
+    )
+    commands.add_parser("serve", help="run the configured Central HTTP service")
+    return parser
+
+
+def _transport(caller_id: str) -> HttpCentralTransport:
+    """Read operator transport settings from the shared YAML configuration."""
+    configured = OperatorSettings.from_file()
+    if caller_id != configured.caller_id:
+        raise ValueError("Caller ID does not match the configured operator identity")
+    return HttpCentralTransport(configured.http_url, configured.machine_token, caller_id)
+
+
+def _send(
+    transport: HttpCentralTransport,
+    *,
+    caller_id: str,
+    space: str,
+    operation: str,
+    payload: dict[str, Any],
+    key: str | None = None,
+) -> dict[str, Any]:
+    if operation == "list_orphaned_objects":
+        url = transport.base_url + "/v1/content/orphaned-objects?" + urlencode(payload)
+        method, body = "GET", None
+    elif operation == "remove_orphaned_object":
+        url = transport.base_url + "/v1/content/orphaned-objects:remove"
+        method, body = "POST", json.dumps(payload).encode()
+    elif operation == "cleanup_upload":
+        operation_id = str(payload["operation_id"])
+        url = transport.base_url + f"/v1/content/stages/{operation_id}:cleanup"
+        method, body = "POST", b""
+    else:  # pragma: no cover - closed command surface
+        raise ValueError("unsupported custody-sweep operation")
+    headers = {
+        "Authorization": "Bearer " + transport.machine_token,
+        "FDP-Caller-Id": caller_id,
+        "FDP-Registry-Space-Id": space,
+    }
+    if body is not None:
+        headers["Content-Type"] = "application/json"
+    if key is not None:
+        headers["Idempotency-Key"] = key
+    try:
+        with urlopen(
+            Request(url, data=body, headers=headers, method=method), timeout=transport.timeout
+        ) as raw:
+            response = json.loads(raw.read())
+    except HTTPError as exc:
+        response = json.loads(exc.read())
+    except URLError as exc:
+        raise RuntimeError("Central HTTP transport is unavailable") from exc
+    if response.get("result") != "success":
+        raise RuntimeError(str(response.get("code", "unknown_error")))
+    return dict(response["data"])
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    if args.command == "serve":
+        try:
+            from ..server.app import main as start_server
+
+            return start_server()
+        except (FDPError, OSError, RuntimeError, ValueError) as exc:
+            _emit(
+                {
+                    "ok": False,
+                    "error": getattr(exc, "code", "operational_error"),
+                    "message": str(exc),
+                },
+                stream=sys.stderr,
+            )
+            return EXIT_OPERATIONAL_ERROR
+    if args.command == "init-db":
+        try:
+            settings = load_server_settings()
+            registry = CentralMongoRegistry(settings.database_url or "")
+            try:
+                _emit({"ok": True, "central_schema_revision": registry.migrate()})
+            finally:
+                registry.close()
+            return EXIT_OK
+        except (FDPError, OSError, RuntimeError, ValueError) as exc:
+            _emit(
+                {"ok": False, "error": "operational_error", "message": str(exc)},
+                stream=sys.stderr,
+            )
+            return EXIT_OPERATIONAL_ERROR
+    if not 1 <= args.max_keys <= 1000:
+        _emit(
+            {"ok": False, "error": "invalid_arguments", "message": "--max-keys is 1..1000"},
+            stream=sys.stderr,
+        )
+        return EXIT_USAGE
+    try:
+        transport = _transport(args.caller_id)
+        listed = _send(
+            transport,
+            caller_id=args.caller_id,
+            space=args.registry_space_id,
+            operation="list_orphaned_objects",
+            payload={"month": args.month, "max_keys": args.max_keys},
+        )
+        objects = [str(item["object_key"]) for item in listed["objects"]]
+        report: dict[str, Any] = {
+            "ok": True,
+            "mode": "apply" if args.apply else "dry_run",
+            "orphaned_objects": objects,
+        }
+        if args.apply:
+            removals: list[dict[str, Any]] = []
+            for index, object_key in enumerate(objects):
+                key = f"custody-sweep-remove-{index}-{object_key}"
+                result = _send(
+                    transport,
+                    caller_id=args.caller_id,
+                    space=args.registry_space_id,
+                    operation="remove_orphaned_object",
+                    payload={"object_key": object_key},
+                    key=key,
+                )
+                removals.append(
+                    {
+                        "object_key": object_key,
+                        "removed": result["removed"],
+                    }
+                )
+            report["removals"] = removals
+        _emit(report)
+        return EXIT_OK
+    except (OSError, RuntimeError, ValueError) as exc:
+        _emit({"ok": False, "error": "operational_error", "message": str(exc)}, stream=sys.stderr)
+        return EXIT_OPERATIONAL_ERROR

financial_data_protocol/cli/__main__.py

@@ -0,0 +1,3 @@
+from . import main
+
+raise SystemExit(main())

financial_data_protocol/client/__init__.py

@@ -0,0 +1,25 @@
+"""Reusable clients for Financial Data Protocol."""
+
+from .client import (
+    DEFAULT_FDP_CONFIG,
+    ArtifactUpload,
+    FdpClient,
+    PackageRevisionDraft,
+    PackageUploadResult,
+)
+from .httpclient import FdpConfig, HttpClient
+from .interfaces import ArtifactPackageClient
+from .protocol_client import CentralClient, CentralClientError
+
+__all__ = [
+    "DEFAULT_FDP_CONFIG",
+    "ArtifactPackageClient",
+    "ArtifactUpload",
+    "CentralClient",
+    "CentralClientError",
+    "FdpClient",
+    "FdpConfig",
+    "HttpClient",
+    "PackageRevisionDraft",
+    "PackageUploadResult",
+]