ssot-core 0.2.15.dev1__tar.gz → 0.2.16.dev1__tar.gz

{ssot_core-0.2.15.dev1 → ssot_core-0.2.16.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssot-core
-Version: 0.2.15.dev1
+Version: 0.2.16.dev1
 Summary: Core Python runtime, registry model, validation, and release workflow APIs for SSOT.
 Author-email: Jacob Stewart <jacob@swarmauri.com>
 License-Expression: Apache-2.0
@@ -34,8 +34,8 @@ Classifier: Topic :: System :: Archiving
 Classifier: Topic :: Utilities
 Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: ssot-contracts==0.2.15.dev1
-Requires-Dist: ssot-views==0.2.15.dev1
+Requires-Dist: ssot-contracts==0.2.16.dev1
+Requires-Dist: ssot-views==0.2.16.dev1
 Requires-Dist: tomli>=2.0.1; python_version < "3.11"
 
 <div align="center">

{ssot_core-0.2.15.dev1 → ssot_core-0.2.16.dev1}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ssot-core"
-version = "0.2.15.dev1"
+version = "0.2.16.dev1"
 description = "Core Python runtime, registry model, validation, and release workflow APIs for SSOT."
 readme = "README.md"
 requires-python = ">=3.10,<3.14"
 license = "Apache-2.0"
 authors = [{ name = "Jacob Stewart", email = "jacob@swarmauri.com" }]
 dependencies = [
-  "ssot-contracts==0.2.15.dev1",
-  "ssot-views==0.2.15.dev1",
+  "ssot-contracts==0.2.16.dev1",
+  "ssot-views==0.2.16.dev1",
   "tomli>=2.0.1; python_version < '3.11'",
 ]
 keywords = ["ssot", "core", "registry", "validation", "release-management", "governance", "compliance"]

{ssot_core-0.2.15.dev1 → ssot_core-0.2.16.dev1}/src/ssot_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssot-core
-Version: 0.2.15.dev1
+Version: 0.2.16.dev1
 Summary: Core Python runtime, registry model, validation, and release workflow APIs for SSOT.
 Author-email: Jacob Stewart <jacob@swarmauri.com>
 License-Expression: Apache-2.0
@@ -34,8 +34,8 @@ Classifier: Topic :: System :: Archiving
 Classifier: Topic :: Utilities
 Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: ssot-contracts==0.2.15.dev1
-Requires-Dist: ssot-views==0.2.15.dev1
+Requires-Dist: ssot-contracts==0.2.16.dev1
+Requires-Dist: ssot-views==0.2.16.dev1
 Requires-Dist: tomli>=2.0.1; python_version < "3.11"
 
 <div align="center">

{ssot_core-0.2.15.dev1 → ssot_core-0.2.16.dev1}/src/ssot_core.egg-info/SOURCES.txt

@@ -94,6 +94,7 @@ src/ssot_registry/util/formatting.py
 src/ssot_registry/util/fs.py
 src/ssot_registry/util/jcs.py
 src/ssot_registry/util/jsonio.py
+src/ssot_registry/util/registry_lock.py
 src/ssot_registry/util/time.py
 src/ssot_registry/validators/__init__.py
 src/ssot_registry/validators/bidirectional.py

ssot_core-0.2.16.dev1/src/ssot_core.egg-info/requires.txt

@@ -0,0 +1,5 @@
+ssot-contracts==0.2.16.dev1
+ssot-views==0.2.16.dev1
+
+[:python_version < "3.11"]
+tomli>=2.0.1

{ssot_core-0.2.15.dev1 → ssot_core-0.2.16.dev1}/src/ssot_registry/api/init.py

@@ -6,7 +6,7 @@ from ssot_contracts.schema import list_schema_names, load_schema_text
 from ssot_registry.api.documents import sync_all_documents
 from ssot_registry.model.registry import build_minimal_registry, default_paths
 from ssot_registry.util.errors import RegistryError
-from ssot_registry.util.jsonio import save_json
+from .save import save_registry
 from .validate import validate_registry
 
 
@@ -36,7 +36,7 @@ def initialize_repo(
         (repo_root / relative_path).mkdir(parents=True, exist_ok=True)
 
     registry = build_minimal_registry(repo_id, repo_name, version)
-    save_json(registry_path, registry)
+    save_registry(registry_path, registry)
 
     _copy_schema_tree(repo_root / paths["schema_root"])
     sync_all_documents(registry_path)

{ssot_core-0.2.15.dev1 → ssot_core-0.2.16.dev1}/src/ssot_registry/api/save.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from pathlib import Path
 
-from ssot_registry.util.jsonio import save_json
+from ssot_registry.util.registry_lock import save_registry_json_locked
 
 
 def save_registry(registry_path: str | Path, registry: dict[str, object]) -> None:
-    save_json(registry_path, registry)
+    save_registry_json_locked(registry_path, registry)

{ssot_core-0.2.15.dev1 → ssot_core-0.2.16.dev1}/src/ssot_registry/api/status_sync.py

@@ -18,6 +18,13 @@ CLAIM_TERMINAL_STATUSES = {"retired"}
 CLAIM_RELEASE_STATUSES = {"promoted", "published"}
 
 
+def _is_planned_path(path: object, marker: str) -> bool:
+    if not isinstance(path, str):
+        return False
+    normalized = path.replace("\\", "/")
+    return marker in normalized
+
+
 def _build_current_index(registry: dict[str, Any]) -> dict[str, dict[str, dict[str, object]]]:
     failures: list[str] = []
     return build_index(registry, failures)
@@ -65,7 +72,10 @@ def _sync_evidence(registry: dict[str, Any], repo_root: Path) -> list[dict[str,
         evidence_id = evidence["id"]
         reason = "evidence artifact exists and linked claim tiers are satisfied"
         status = "passed"
-        if not (repo_root / evidence["path"]).exists():
+        if _is_planned_path(evidence.get("path"), "/evidence/planned/"):
+            status = "planned"
+            reason = "evidence path is a planned placeholder"
+        elif not (repo_root / evidence["path"]).exists():
             status = "planned"
             reason = "evidence artifact path does not exist"
         elif _missing_refs(evidence, "claim_ids", index["claims"]) or _missing_refs(evidence, "test_ids", index["tests"]):
@@ -95,7 +105,10 @@ def _sync_tests(registry: dict[str, Any], repo_root: Path) -> list[dict[str, obj
         test_id = test["id"]
         reason = "test path exists and linked evidence is passed"
         status = "passing"
-        if not (repo_root / test["path"]).exists():
+        if _is_planned_path(test.get("path"), "tests/planned/"):
+            status = "planned"
+            reason = "test path is a planned placeholder"
+        elif not (repo_root / test["path"]).exists():
             status = "planned"
             reason = "test path does not exist"
         elif _missing_refs(test, "feature_ids", index["features"]) or _missing_refs(test, "claim_ids", index["claims"]):
@@ -133,6 +146,10 @@ def _claim_support_status(claim: dict[str, Any], index: dict[str, dict[str, dict
     linked_evidence = [index["evidence"][evidence_id] for evidence_id in claim.get("evidence_ids", []) if evidence_id in index["evidence"]]
     if linked_evidence and any(evidence.get("status") in {"failed", "stale"} for evidence in linked_evidence):
         return "blocked", "claim has failed or stale linked evidence"
+    if (linked_tests or linked_evidence) and not any(test.get("status") != "planned" for test in linked_tests) and not any(
+        evidence.get("status") != "planned" for evidence in linked_evidence
+    ):
+        return "proposed", "claim has only planned verification support"
     if linked_tests and all(test.get("status") == "passing" for test in linked_tests) and linked_evidence:
         tier_met = any(
             evidence.get("status") == "passed" and CLAIM_TIER_RANK[evidence["tier"]] >= CLAIM_TIER_RANK[claim["tier"]]
@@ -191,9 +208,17 @@ def _sync_features_once(registry: dict[str, Any]) -> list[dict[str, object]]:
             tests_pass = bool(linked_tests) and all(test.get("status") == "passing" for test in linked_tests)
             claims_pass = any(_claim_satisfies_feature(claim, required_tier) for claim in linked_claims)
             requirements_pass = all(required.get("implementation_status") == "implemented" for required in required_features)
+            only_planned_support = (
+                bool(linked_tests or linked_claims)
+                and all(test.get("status") == "planned" for test in linked_tests)
+                and all(CLAIM_STATUS_RANK.get(claim.get("status"), -999) <= CLAIM_STATUS_RANK["proposed"] for claim in linked_claims)
+            )
             if tests_pass and claims_pass and requirements_pass:
                 status = "implemented"
                 reason = "feature has passing tests, satisfying claims, and implemented requirements"
+            elif only_planned_support:
+                status = "absent"
+                reason = "feature has only planned verification support"
             elif linked_tests or linked_claims or required_features:
                 status = "partial"
                 reason = "feature has linked support but does not yet satisfy implementation criteria"

{ssot_core-0.2.15.dev1 → ssot_core-0.2.16.dev1}/src/ssot_registry/util/__init__.py

@@ -1,14 +1,18 @@
-from .errors import GuardError, RegistryError, ValidationError
+from .errors import GuardError, RegistryError, RegistryLockError, ValidationError
 from .fs import ensure_directory, resolve_registry_path, repo_root_from_registry_path, sha256_path
 from .jsonio import load_json, save_json, stable_json_dumps
+from .registry_lock import RegistryFileLock, registry_lock_path
 from .time import utc_now_iso
 
 __all__ = [
     "GuardError",
     "RegistryError",
+    "RegistryLockError",
     "ValidationError",
+    "RegistryFileLock",
     "ensure_directory",
     "load_json",
+    "registry_lock_path",
     "repo_root_from_registry_path",
     "resolve_registry_path",
     "save_json",

{ssot_core-0.2.15.dev1 → ssot_core-0.2.16.dev1}/src/ssot_registry/util/errors.py

@@ -8,3 +8,7 @@ class ValidationError(RegistryError):
 
 class GuardError(RegistryError):
     """Raised when a gate or fence refuses a state transition."""
+
+
+class RegistryLockError(RegistryError):
+    """Raised when the registry file lock cannot be acquired or released."""

ssot_core-0.2.16.dev1/src/ssot_registry/util/registry_lock.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import time
+import uuid
+from contextlib import AbstractContextManager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from ssot_registry.util.errors import RegistryLockError
+from ssot_registry.util.jsonio import stable_json_dumps
+
+DEFAULT_REGISTRY_LOCK_TTL_SECONDS = 300
+
+
+def _utc_epoch_seconds() -> float:
+    return time.time()
+
+
+def registry_lock_path(registry_path: str | Path) -> Path:
+    return Path(registry_path).with_name(f"{Path(registry_path).name}.lock")
+
+
+def _read_lock_metadata(lock_path: Path) -> dict[str, Any]:
+    try:
+        payload = json.loads(lock_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return payload if isinstance(payload, dict) else {}
+
+
+def _is_stale(lock_path: Path, now: float) -> bool:
+    metadata = _read_lock_metadata(lock_path)
+    expires_at = metadata.get("expires_at_epoch")
+    if isinstance(expires_at, int | float):
+        return float(expires_at) <= now
+    try:
+        stat = lock_path.stat()
+    except OSError:
+        return False
+    return stat.st_mtime + DEFAULT_REGISTRY_LOCK_TTL_SECONDS <= now
+
+
+@dataclass
+class RegistryFileLock(AbstractContextManager["RegistryFileLock"]):
+    registry_path: Path
+    reason: str = "registry mutation"
+    ttl_seconds: int = DEFAULT_REGISTRY_LOCK_TTL_SECONDS
+    owner: str | None = None
+
+    def __post_init__(self) -> None:
+        self.registry_path = Path(self.registry_path)
+        self.lock_path = registry_lock_path(self.registry_path)
+        self.token = uuid.uuid4().hex
+        self.owner = self.owner or f"pid:{os.getpid()}"
+        self._acquired = False
+
+    def __enter__(self) -> "RegistryFileLock":
+        self.acquire()
+        return self
+
+    def __exit__(self, exc_type: object, exc_value: object, traceback: object) -> None:
+        self.release()
+
+    def acquire(self) -> None:
+        self.lock_path.parent.mkdir(parents=True, exist_ok=True)
+        now = _utc_epoch_seconds()
+        metadata = {
+            "target": self.registry_path.as_posix(),
+            "owner": self.owner,
+            "pid": os.getpid(),
+            "reason": self.reason,
+            "token": self.token,
+            "created_at_epoch": now,
+            "expires_at_epoch": now + self.ttl_seconds,
+        }
+        payload = stable_json_dumps(metadata)
+        while True:
+            try:
+                fd = os.open(str(self.lock_path), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+            except FileExistsError as exc:
+                if _is_stale(self.lock_path, _utc_epoch_seconds()):
+                    try:
+                        self.lock_path.unlink()
+                    except FileNotFoundError:
+                        continue
+                    except OSError as unlink_error:
+                        raise RegistryLockError(f"Failed to remove stale registry lock {self.lock_path}: {unlink_error}") from unlink_error
+                    continue
+                holder = _read_lock_metadata(self.lock_path)
+                owner = holder.get("owner", "unknown")
+                reason = holder.get("reason", "unknown")
+                raise RegistryLockError(f"Registry is locked by {owner} for {reason}: {self.lock_path}") from exc
+            with os.fdopen(fd, "w", encoding="utf-8") as lock_file:
+                lock_file.write(payload)
+                lock_file.flush()
+                os.fsync(lock_file.fileno())
+            self._acquired = True
+            return
+
+    def release(self) -> None:
+        if not self._acquired:
+            return
+        metadata = _read_lock_metadata(self.lock_path)
+        if metadata.get("token") != self.token:
+            raise RegistryLockError(f"Registry lock owner mismatch; refusing to release {self.lock_path}")
+        try:
+            self.lock_path.unlink()
+        except FileNotFoundError:
+            pass
+        self._acquired = False
+
+
+def save_registry_json_locked(registry_path: str | Path, registry: dict[str, object], *, reason: str = "registry mutation") -> None:
+    target = Path(registry_path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    with RegistryFileLock(target, reason=reason):
+        payload = stable_json_dumps(registry)
+        temp_name: str | None = None
+        try:
+            with tempfile.NamedTemporaryFile("w", encoding="utf-8", dir=target.parent, prefix=f".{target.name}.", suffix=".tmp", delete=False) as temp_file:
+                temp_name = temp_file.name
+                temp_file.write(payload)
+                temp_file.flush()
+                os.fsync(temp_file.fileno())
+            os.replace(temp_name, target)
+        finally:
+            if temp_name is not None:
+                temp_path = Path(temp_name)
+                if temp_path.exists():
+                    try:
+                        temp_path.unlink()
+                    except OSError:
+                        pass

ssot_core-0.2.15.dev1/src/ssot_core.egg-info/requires.txt

@@ -1,5 +0,0 @@
-ssot-contracts==0.2.15.dev1
-ssot-views==0.2.15.dev1
-
-[:python_version < "3.11"]
-tomli>=2.0.1