openexit 0.1.0__tar.gz

openexit-0.1.0/IMPLEMENTATION_NOTES.md

@@ -0,0 +1,25 @@
+# Python 0.1 implementation notes
+
+## Canonical PASP assumptions
+
+`protocol/pasp/v1/` and its shared conformance suite define PASP 1.0. Directory bundles use `openexit.bundle`, `manifest.json`, resource descriptors and direct-record NDJSON chunks, optional relationship and asset indexes, and SHA-256 integrity. Package paths use protocol / separators. SDK version 0.1.0 is independent of PASP version 1.0.
+
+## Python API mapping
+
+`parse_manifest` parses JSON into a `Manifest` dataclass without protocol validation. It accepts a mapping, JSON text, UTF-8 bytes, or an explicit PathLike file. `validate_manifest` returns None or raises `PaspError`. `inspect_bundle` returns a metadata summary; `verify_bundle` performs full streaming integrity and record verification and returns that summary. Dataclasses are ergonomic views; packaged canonical JSON Schemas are normative.
+
+## Error mapping
+
+All protocol failures raise `PaspError` with a stable `PASP_*` code. Missing manifest maps to `PASP_MALFORMED_PACKAGE`; schema, resource, record, asset, relationship, path, version, and checksum failures map to their corresponding frozen codes.
+
+## Bundle inspection strategy
+
+Read small JSON metadata files directly. Stream NDJSON chunks and asset index line by line during verification; hash chunk and asset bytes in bounded blocks. Inspection reads descriptors and summary metadata without loading record or asset contents. Reject unsafe package paths and symlinks escaping the bundle root.
+
+## Schema-loading strategy
+
+Copy canonical `protocol/pasp/v1/schemas/*.json` into `src/openexit/schemas/` as package data. Load with `importlib.resources`; resolve schema references from those packaged copies. Tests compare copies byte-for-byte with canonical files. An installed wheel never traverses back into the repository.
+
+## Chunk sequence interpretation
+
+The frozen chunk schema permits nonnegative sequence values and the specification requires deterministic order, without requiring a starting value or contiguous values. Python accepts strictly increasing sequences whose eight-digit filenames match their sequence. The shared fixtures use one-based contiguous sequences; this interpretation may be worth an explicit future conformance case.

openexit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenExit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

openexit-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md LICENSE IMPLEMENTATION_NOTES.md
+recursive-include src/openexit/schemas *.json

openexit-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: openexit
+Version: 0.1.0
+Summary: Python SDK for OpenExit and the PASP portable application state protocol.
+Author: OpenExit contributors
+License-Expression: MIT
+Keywords: data portability,PASP,application state,export,openexit
+Classifier: Development Status :: 3 - Alpha
+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
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema<5,>=4.18
+Provides-Extra: dev
+Requires-Dist: pytest<10,>=8; extra == "dev"
+Requires-Dist: build<2,>=1; extra == "dev"
+Requires-Dist: twine<7,>=6; extra == "dev"
+Dynamic: license-file
+
+# OpenExit
+
+> Portable state for any application.
+
+This package implements PASP — the Portable Application State Protocol — for Python. OpenExit is the implementation and ecosystem; PASP 1.0 is the language-neutral protocol. SDK version 0.1.0 is separate from protocol version 1.0.
+
+## Install
+
+```bash
+pip install openexit
+```
+
+## Inspect and verify
+
+```python
+from openexit import inspect_bundle, verify_bundle
+
+bundle = inspect_bundle("./acme.pasp")
+print(bundle.pasp_version)
+print(bundle.scope)
+print(bundle.resources)
+
+verified = verify_bundle("./acme.pasp")
+print(verified.verified)
+```
+
+`inspect_bundle` reads the manifest, descriptors, relationship metadata, and asset index. `verify_bundle` additionally streams all resource records and asset bytes, checks record schemas and identities, counts, and SHA-256 hashes. Both accept directory bundles.
+
+## Manifest validation
+
+```python
+from pathlib import Path
+from openexit import parse_manifest, validate_manifest
+
+manifest = parse_manifest(Path("./acme.pasp/manifest.json"))
+validate_manifest(manifest)  # returns None or raises PaspError
+```
+
+`parse_manifest` also accepts a mapping, JSON text, or UTF-8 JSON bytes. A string is treated as JSON text; pass a `Path` to read a file. Parsing does not imply validation. Models retain the raw manifest fields. Protocol errors expose a stable `code`:
+
+```python
+from openexit import PaspError
+
+try:
+    verify_bundle("./acme.pasp")
+except PaspError as exc:
+    print(exc.code)
+```
+
+## Protocol source
+
+The canonical PASP definition is in the repository at `protocol/pasp/v1/`; the shared suite is `protocol/pasp/v1/conformance/suite.json`. Installed wheels contain exact copies of the canonical JSON Schemas and do not require the repository at runtime.
+
+## Current limits
+
+This SDK reads PASP 1.0 directory bundles. It does not export or import application state, run adapters, execute external processes, unpack archives, or check full referential integrity. Inspection and verification use bounded file reads; one NDJSON record or metadata file is parsed at a time. Symlinks that leave the bundle root are rejected.

openexit-0.1.0/README.md

@@ -0,0 +1,56 @@
+# OpenExit
+
+> Portable state for any application.
+
+This package implements PASP — the Portable Application State Protocol — for Python. OpenExit is the implementation and ecosystem; PASP 1.0 is the language-neutral protocol. SDK version 0.1.0 is separate from protocol version 1.0.
+
+## Install
+
+```bash
+pip install openexit
+```
+
+## Inspect and verify
+
+```python
+from openexit import inspect_bundle, verify_bundle
+
+bundle = inspect_bundle("./acme.pasp")
+print(bundle.pasp_version)
+print(bundle.scope)
+print(bundle.resources)
+
+verified = verify_bundle("./acme.pasp")
+print(verified.verified)
+```
+
+`inspect_bundle` reads the manifest, descriptors, relationship metadata, and asset index. `verify_bundle` additionally streams all resource records and asset bytes, checks record schemas and identities, counts, and SHA-256 hashes. Both accept directory bundles.
+
+## Manifest validation
+
+```python
+from pathlib import Path
+from openexit import parse_manifest, validate_manifest
+
+manifest = parse_manifest(Path("./acme.pasp/manifest.json"))
+validate_manifest(manifest)  # returns None or raises PaspError
+```
+
+`parse_manifest` also accepts a mapping, JSON text, or UTF-8 JSON bytes. A string is treated as JSON text; pass a `Path` to read a file. Parsing does not imply validation. Models retain the raw manifest fields. Protocol errors expose a stable `code`:
+
+```python
+from openexit import PaspError
+
+try:
+    verify_bundle("./acme.pasp")
+except PaspError as exc:
+    print(exc.code)
+```
+
+## Protocol source
+
+The canonical PASP definition is in the repository at `protocol/pasp/v1/`; the shared suite is `protocol/pasp/v1/conformance/suite.json`. Installed wheels contain exact copies of the canonical JSON Schemas and do not require the repository at runtime.
+
+## Current limits
+
+This SDK reads PASP 1.0 directory bundles. It does not export or import application state, run adapters, execute external processes, unpack archives, or check full referential integrity. Inspection and verification use bounded file reads; one NDJSON record or metadata file is parsed at a time. Symlinks that leave the bundle root are rejected.

openexit-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openexit"
+version = "0.1.0"
+description = "Python SDK for OpenExit and the PASP portable application state protocol."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "OpenExit contributors"}]
+keywords = ["data portability", "PASP", "application state", "export", "openexit"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Programming Language :: Python :: 3",
+  "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",
+  "Operating System :: OS Independent",
+]
+dependencies = ["jsonschema>=4.18,<5"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8,<10", "build>=1,<2", "twine>=6,<7"]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"openexit.schemas" = ["*.json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--basetemp=.pytest_tmp"

openexit-0.1.0/setup.cfg

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

openexit-0.1.0/src/openexit/__init__.py

@@ -0,0 +1,20 @@
+"""OpenExit Python SDK for PASP 1.0 directory bundles."""
+
+from .bundle import Bundle
+from .constants import PASP_VERSION
+from .errors import OpenExitError, PaspError
+from .inspection import inspect_bundle, verify_bundle
+from .manifest import parse_manifest
+from .models import (AssetSummary, Consistency, InspectionResult, IntegrityInfo,
+                     Manifest, ProducerInfo, Relationship, RelationshipEndpoint,
+                     Resource, ResourceChunk, Scope)
+from .validation import load_schema, validate_manifest
+from .version import __version__
+
+__all__ = [
+    "PASP_VERSION", "__version__", "OpenExitError", "PaspError",
+    "parse_manifest", "validate_manifest", "inspect_bundle", "verify_bundle",
+    "load_schema", "Bundle", "Scope", "ProducerInfo", "IntegrityInfo", "Consistency",
+    "ResourceChunk", "Resource", "AssetSummary", "RelationshipEndpoint",
+    "Relationship", "Manifest", "InspectionResult",
+]

openexit-0.1.0/src/openexit/bundle.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from .inspection import inspect_bundle, verify_bundle
+from .models import InspectionResult
+
+
+@dataclass(frozen=True)
+class Bundle:
+    """A small optional handle for a PASP directory bundle."""
+
+    path: Path
+
+    @classmethod
+    def open(cls, path: str | Path) -> Bundle:
+        return cls(Path(path))
+
+    def inspect(self) -> InspectionResult:
+        return inspect_bundle(self.path)
+
+    def verify(self) -> InspectionResult:
+        return verify_bundle(self.path)

openexit-0.1.0/src/openexit/constants.py

@@ -0,0 +1,2 @@
+PASP_VERSION = "1.0"
+BUNDLE_FORMAT = "openexit.bundle"

openexit-0.1.0/src/openexit/errors.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class OpenExitError(Exception):
+    """Base exception for the OpenExit Python SDK."""
+
+
+class PaspError(OpenExitError):
+    """A PASP validation failure with a stable protocol error code."""
+
+    def __init__(self, code: str, message: str, *, context: Any = None) -> None:
+        self.code = code
+        self.context = context
+        super().__init__(message)

openexit-0.1.0/src/openexit/inspection.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Iterator
+
+from jsonschema import Draft202012Validator, FormatChecker
+from jsonschema.exceptions import SchemaError, ValidationError
+from referencing import Registry
+from referencing.exceptions import NoSuchResource, Unresolvable
+
+from .errors import PaspError
+from .integrity import verify_file, hash_file
+from .manifest import parse_manifest, _reject_non_json_constant
+from .models import (AssetSummary, Consistency, InspectionResult, IntegrityInfo,
+                     ProducerInfo, Resource, ResourceChunk, Scope)
+from .paths import safe_package_path
+from .validation import validate_document, validate_manifest
+
+
+def _json_file(path: Path, code: str) -> Any:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"), parse_constant=_reject_non_json_constant)
+    except (OSError, UnicodeError, ValueError) as exc:
+        raise PaspError(code, f"invalid or missing JSON file: {path}") from exc
+
+
+def _lines(path: Path, code: str) -> Iterator[tuple[int, Any]]:
+    try:
+        with path.open("r", encoding="utf-8") as stream:
+            for number, line in enumerate(stream, 1):
+                if not line.strip():
+                    continue
+                try:
+                    yield number, json.loads(line, parse_constant=_reject_non_json_constant)
+                except ValueError as exc:
+                    raise PaspError(code, f"invalid NDJSON at {path}:{number}") from exc
+    except (OSError, UnicodeError) as exc:
+        raise PaspError(code, f"cannot read NDJSON: {path}") from exc
+
+
+def _no_external_schema(uri: str):
+    raise NoSuchResource(ref=uri)
+
+
+def _schema_for_resource(root: Path, descriptor: dict[str, Any]) -> dict[str, Any]:
+    schema = descriptor["schema"]
+    if isinstance(schema, str):
+        schema_path = safe_package_path(root, schema)
+        if not schema_path.is_file():
+            raise PaspError("PASP_MISSING_SCHEMA", f"missing schema: {schema}")
+        schema = _json_file(schema_path, "PASP_MISSING_SCHEMA")
+    try:
+        Draft202012Validator.check_schema(schema)
+    except SchemaError as exc:
+        raise PaspError("PASP_INVALID_RESOURCE", "invalid record schema") from exc
+    return schema
+
+
+def _resource(root: Path, entry: dict[str, Any], deep: bool) -> Resource:
+    name = entry["name"]
+    descriptor_path = safe_package_path(root, entry["descriptor"])
+    descriptor = _json_file(descriptor_path, "PASP_INVALID_RESOURCE")
+    validate_document("resource", descriptor, "PASP_INVALID_RESOURCE")
+    if descriptor["name"] != name:
+        raise PaspError("PASP_INVALID_RESOURCE", f"descriptor name mismatch: {name}")
+    schema = _schema_for_resource(root, descriptor)
+    chunks = []
+    total_records = 0
+    for index, raw in enumerate(descriptor["chunks"], 1):
+        sequence = raw["sequence"]
+        if sequence != index or raw["path"] != f"resources/{name}/{index:08d}.ndjson":
+            raise PaspError("PASP_INVALID_RESOURCE", f"invalid chunk order/path: {name}")
+        chunk_path = safe_package_path(root, raw["path"])
+        if not chunk_path.is_file():
+            raise PaspError("PASP_INVALID_RESOURCE", f"missing chunk: {raw['path']}")
+        if deep:
+            verify_file(chunk_path, raw["sha256"], raw["uncompressedBytes"])
+            validator = Draft202012Validator(schema, format_checker=FormatChecker(), registry=Registry(retrieve=_no_external_schema))
+            count = 0
+            for line_number, record in _lines(chunk_path, "PASP_INVALID_RECORD"):
+                if not isinstance(record, dict):
+                    raise PaspError("PASP_INVALID_RECORD", f"record is not an object at {raw['path']}:{line_number}")
+                if any(identity not in record for identity in descriptor["identity"]):
+                    raise PaspError("PASP_INVALID_RECORD", f"missing identity at {raw['path']}:{line_number}")
+                try:
+                    validator.validate(record)
+                except (ValidationError, Unresolvable) as exc:
+                    raise PaspError("PASP_INVALID_RECORD", f"record schema failure at {raw['path']}:{line_number}: {exc}") from exc
+                count += 1
+            if count != raw["recordCount"]:
+                raise PaspError("PASP_INVALID_RESOURCE", f"chunk record count mismatch: {raw['path']}")
+        total_records += raw["recordCount"]
+        chunks.append(ResourceChunk(raw["sequence"], raw["path"], raw["recordCount"], raw["uncompressedBytes"], raw["sha256"]))
+    if total_records != descriptor["recordCount"]:
+        raise PaspError("PASP_INVALID_RESOURCE", f"resource record count mismatch: {name}")
+    return Resource(name, descriptor["schema"], tuple(descriptor["identity"]), descriptor["recordCount"], tuple(chunks), entry["descriptor"])
+
+
+def _assets(root: Path, raw: dict[str, Any], deep: bool) -> AssetSummary:
+    summary = AssetSummary(raw["count"], raw["totalBytes"], raw.get("index"))
+    if summary.count == 0 and summary.index is None:
+        return summary
+    index_path = safe_package_path(root, summary.index or "assets/index.ndjson")
+    if not index_path.is_file():
+        raise PaspError("PASP_MISSING_ASSET", "missing asset index")
+    count = total_bytes = 0
+    for _, asset in _lines(index_path, "PASP_MISSING_ASSET"):
+        validate_document("asset", asset, "PASP_MISSING_ASSET")
+        asset_path = safe_package_path(root, asset["path"])
+        if not asset_path.is_file():
+            raise PaspError("PASP_MISSING_ASSET", f"missing asset: {asset['path']}")
+        if deep:
+            verify_file(asset_path, asset["sha256"], asset["byteLength"])
+        count += 1
+        total_bytes += asset["byteLength"]
+    if count != summary.count or total_bytes != summary.total_bytes:
+        raise PaspError("PASP_MISSING_ASSET", "asset summary mismatch")
+    return summary
+
+
+def _relationships(root: Path, reference: str | None, names: set[str]) -> int:
+    if reference is None:
+        return 0
+    rel_path = safe_package_path(root, reference)
+    items = _json_file(rel_path, "PASP_INVALID_RELATIONSHIP")
+    if not isinstance(items, list):
+        raise PaspError("PASP_INVALID_RELATIONSHIP", "relationships must be an array")
+    for item in items:
+        validate_document("relationship", item, "PASP_INVALID_RELATIONSHIP")
+        if item["from"]["resource"] not in names or item["to"]["resource"] not in names:
+            raise PaspError("PASP_INVALID_RELATIONSHIP", "relationship endpoint resource is missing")
+    return len(items)
+
+
+def _checksum_index(root: Path, reference: str | None) -> None:
+    if reference is None:
+        return
+    index = safe_package_path(root, reference)
+    try:
+        with index.open("r", encoding="utf-8") as stream:
+            for number, line in enumerate(stream, 1):
+                if not line.strip():
+                    continue
+                parts = line.rstrip("\r\n").split(maxsplit=1)
+                if len(parts) != 2 or len(parts[0]) != 64 or any(c not in "0123456789abcdef" for c in parts[0]):
+                    raise PaspError("PASP_MALFORMED_PACKAGE", f"invalid checksums index line {number}")
+                entry = safe_package_path(root, parts[1].lstrip())
+                if not entry.is_file():
+                    raise PaspError("PASP_MALFORMED_PACKAGE", f"missing checksummed file: {parts[1]}")
+                actual, _ = hash_file(entry)
+                if actual != parts[0]:
+                    raise PaspError("PASP_CHECKSUM_MISMATCH", f"checksum index mismatch: {parts[1]}")
+    except (OSError, UnicodeError) as exc:
+        raise PaspError("PASP_MALFORMED_PACKAGE", "cannot read checksums index") from exc
+
+
+def _inspect(directory: str | Path, deep: bool) -> InspectionResult:
+    root = Path(directory)
+    if not root.is_dir():
+        raise PaspError("PASP_MALFORMED_PACKAGE", f"not a PASP directory: {root}")
+    manifest_path = safe_package_path(root, "manifest.json")
+    if not manifest_path.is_file():
+        raise PaspError("PASP_MALFORMED_PACKAGE", "missing manifest.json")
+    manifest = parse_manifest(manifest_path)
+    validate_manifest(manifest)
+    value = dict(manifest.raw)
+    names = {entry["name"] for entry in value["resources"]}
+    resources = tuple(_resource(root, entry, deep) for entry in value["resources"])
+    assets = _assets(root, value["assets"], deep)
+    relationships = _relationships(root, value.get("relationships"), names)
+    if deep:
+        _checksum_index(root, value["integrity"].get("checksums"))
+    return InspectionResult(
+        True, value["paspVersion"], value["packageId"], value["exportId"],
+        Scope(**value["scope"]), ProducerInfo(**value["producer"]),
+        Consistency(**value["consistency"]), resources, assets, relationships,
+        IntegrityInfo(**value["integrity"]), deep,
+    )
+
+
+def inspect_bundle(directory: str | Path) -> InspectionResult:
+    """Inspect a directory bundle using metadata and streamed asset index."""
+    return _inspect(directory, False)
+
+
+def verify_bundle(directory: str | Path) -> InspectionResult:
+    """Verify a directory bundle, hashing bytes and streaming records."""
+    return _inspect(directory, True)
+
+

openexit-0.1.0/src/openexit/integrity.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+from .errors import PaspError
+
+
+def hash_file(path: Path) -> tuple[str, int]:
+    """Hash a file in bounded blocks and return (lowercase SHA-256, byte count)."""
+    digest = hashlib.sha256()
+    count = 0
+    with path.open("rb") as stream:
+        while block := stream.read(1024 * 1024):
+            digest.update(block)
+            count += len(block)
+    return digest.hexdigest(), count
+
+
+def verify_file(path: Path, sha256: str, byte_length: int) -> None:
+    actual_hash, actual_length = hash_file(path)
+    if actual_hash != sha256 or actual_length != byte_length:
+        raise PaspError("PASP_CHECKSUM_MISMATCH", f"checksum or length mismatch: {path}", context=str(path))

openexit-0.1.0/src/openexit/manifest.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Mapping
+
+from .errors import PaspError
+from .models import Manifest
+
+
+def _reject_non_json_constant(value: str) -> None:
+    raise ValueError(f"invalid JSON constant: {value}")
+
+
+def parse_manifest(source: Mapping[str, Any] | os.PathLike[str] | str | bytes) -> Manifest:
+    """Parse a mapping, JSON text, UTF-8 bytes, or explicit PathLike file.
+
+    A string is always JSON text. Use pathlib.Path for filesystem input.
+    Parsing does not establish protocol validity; call validate_manifest for that.
+    """
+    try:
+        if isinstance(source, Mapping):
+            value = dict(source)
+        elif isinstance(source, os.PathLike):
+            value = json.loads(Path(source).read_text(encoding="utf-8"), parse_constant=_reject_non_json_constant)
+        elif isinstance(source, bytes):
+            value = json.loads(source.decode("utf-8"), parse_constant=_reject_non_json_constant)
+        elif isinstance(source, str):
+            value = json.loads(source, parse_constant=_reject_non_json_constant)
+        else:
+            raise TypeError("manifest source must be a mapping, PathLike, JSON str, or bytes")
+    except (OSError, UnicodeError, ValueError) as exc:
+        raise PaspError("PASP_INVALID_MANIFEST", "cannot parse manifest JSON") from exc
+    if not isinstance(value, dict):
+        raise PaspError("PASP_INVALID_MANIFEST", "manifest must be a JSON object")
+    return Manifest(value)

openexit-0.1.0/src/openexit/models.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Mapping
+
+
+@dataclass(frozen=True)
+class Scope:
+    type: str
+    id: str
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class ProducerInfo:
+    name: str
+    version: str
+
+
+@dataclass(frozen=True)
+class IntegrityInfo:
+    algorithm: str
+    checksums: str | None = None
+
+
+@dataclass(frozen=True)
+class Consistency:
+    level: str
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class ResourceChunk:
+    sequence: int
+    path: str
+    record_count: int
+    uncompressed_bytes: int
+    sha256: str
+
+
+@dataclass(frozen=True)
+class Resource:
+    name: str
+    schema: str | Mapping[str, Any]
+    identity: tuple[str, ...]
+    record_count: int
+    chunks: tuple[ResourceChunk, ...]
+    descriptor: str
+
+
+@dataclass(frozen=True)
+class AssetSummary:
+    count: int
+    total_bytes: int
+    index: str | None = None
+
+
+@dataclass(frozen=True)
+class RelationshipEndpoint:
+    resource: str
+    pointer: str
+
+
+@dataclass(frozen=True)
+class Relationship:
+    id: str
+    from_endpoint: RelationshipEndpoint
+    to_endpoint: RelationshipEndpoint
+    cardinality: str
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class Manifest:
+    """Parsed JSON with lossless access to all fields, including future fields."""
+
+    raw: Mapping[str, Any]
+
+    @property
+    def pasp_version(self) -> str | None:
+        return self.raw.get("paspVersion")
+
+    @property
+    def package_id(self) -> str | None:
+        return self.raw.get("packageId")
+
+    @property
+    def export_id(self) -> str | None:
+        return self.raw.get("exportId")
+
+    @property
+    def scope(self) -> Scope | None:
+        data = self.raw.get("scope")
+        if not isinstance(data, dict):
+            return None
+        return Scope(data.get("type"), data.get("id"), data.get("metadata", {}))
+
+
+@dataclass(frozen=True)
+class InspectionResult:
+    valid: bool
+    pasp_version: str
+    package_id: str
+    export_id: str
+    scope: Scope
+    producer: ProducerInfo
+    consistency: Consistency
+    resources: tuple[Resource, ...]
+    assets: AssetSummary
+    relationship_count: int
+    integrity: IntegrityInfo
+    verified: bool