cks-runtime 0.4.4__tar.gz → 0.4.6__tar.gz

{cks_runtime-0.4.4 → cks_runtime-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cks-runtime
-Version: 0.4.4
+Version: 0.4.6
 Summary: Canonical Runtime for the Canonical Knowledge Structure ecosystem
 Author: Vladyslav Hruznov
 License: MIT
@@ -17,7 +17,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cks-core>=1.2.1
+Requires-Dist: cks-core>=1.3.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"

{cks_runtime-0.4.4 → cks_runtime-0.4.6}/cks_runtime/config.py

@@ -28,7 +28,7 @@ def _runtime_version() -> str:
     try:
         return version("cks-runtime")
     except PackageNotFoundError:
-        return "0.4.4"
+        return "0.4.6"
 
 
 @dataclass(slots=True)

{cks_runtime-0.4.4 → cks_runtime-0.4.6}/cks_runtime/operations/operation_types.py

@@ -32,13 +32,17 @@ class ValidateOperation(Operation):
         executor,
     ) -> ExecutionResult:
         result = executor.core.validate(self.knowledge_structure)
-        error = None if result.valid else RuntimeError("Validation failed")
+        # Determining that a Knowledge Structure is invalid is a
+        # successful outcome of *running* validation, not an
+        # operation failure -- it must be reported as diagnostics,
+        # never as a raised exception. Only unexpected execution
+        # errors (caught by OperationExecutor) are OperationStatus.FAILED.
         return ExecutionResult(
             operation_id=self.operation_id,
-            status=OperationStatus.COMPLETED if result.valid else OperationStatus.FAILED,
+            status=OperationStatus.COMPLETED,
             payload=result,
             diagnostics=result.diagnostics,
-            error=error,
+            error=None,
         )
 
 

cks_runtime-0.4.6/cks_runtime/versioning/version.py

@@ -0,0 +1,103 @@
+"""
+Runtime Version.
+
+Represents an immutable Runtime snapshot.
+"""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from types import MappingProxyType
+from typing import Any, Mapping
+from uuid import uuid4
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeVersion:
+    """Immutable Runtime snapshot."""
+
+    session_id: str
+    transaction_id: str
+    knowledge_structure: Any
+    metadata: Mapping[str, Any]
+
+    version_id: str = field(default_factory=lambda: str(uuid4()))
+    created_at: datetime = field(default_factory=lambda: datetime.now(UTC))
+
+    def __post_init__(self) -> None:
+        """Deep-copy mutable state and freeze metadata."""
+        object.__setattr__(
+            self,
+            "knowledge_structure",
+            deepcopy(self.knowledge_structure),
+        )
+        object.__setattr__(
+            self,
+            "metadata",
+            MappingProxyType(deepcopy(dict(self.metadata))),
+        )
+
+    #
+    # ------------------------------------------------------------------
+    # Copy semantics
+    # ------------------------------------------------------------------
+    #
+    # RuntimeVersion.knowledge_structure is `Any`: Runtime is
+    # storage-independent and must not assume a plugged-in Core's
+    # structure type is immutable, so a blanket `return self` here
+    # would silently break the isolation InMemoryStorage relies on
+    # for non-cks-core adapters with mutable structures.
+    #
+    # The only thing the stdlib `copy` module actually can't handle is
+    # `metadata`, which we wrap in MappingProxyType (immutable by our
+    # own contract) — so we deep-copy every field explicitly instead of
+    # deferring to the default pickle-based reduction.
+
+    def __copy__(self) -> "RuntimeVersion":
+        return type(self)(
+            session_id=self.session_id,
+            transaction_id=self.transaction_id,
+            knowledge_structure=self.knowledge_structure,
+            metadata=dict(self.metadata),
+            version_id=self.version_id,
+            created_at=self.created_at,
+        )
+
+    def __deepcopy__(self, memo: dict[int, Any]) -> "RuntimeVersion":
+        new = type(self)(
+            session_id=self.session_id,
+            transaction_id=self.transaction_id,
+            knowledge_structure=deepcopy(self.knowledge_structure, memo),
+            metadata=dict(self.metadata),
+            version_id=self.version_id,
+            created_at=self.created_at,
+        )
+        memo[id(self)] = new
+        return new
+
+    #
+    # ------------------------------------------------------------------
+    # Metadata
+    # ------------------------------------------------------------------
+
+    @property
+    def has_metadata(self) -> bool:
+        return bool(self.metadata)
+
+    @property
+    def age(self):
+        return datetime.now(UTC) - self.created_at
+
+    #
+    # ------------------------------------------------------------------
+    # Debugging
+    # ------------------------------------------------------------------
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}("
+            f"id={self.version_id!r}, "
+            f"session={self.session_id!r})"
+        )

{cks_runtime-0.4.4 → cks_runtime-0.4.6}/cks_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cks-runtime
-Version: 0.4.4
+Version: 0.4.6
 Summary: Canonical Runtime for the Canonical Knowledge Structure ecosystem
 Author: Vladyslav Hruznov
 License: MIT
@@ -17,7 +17,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cks-core>=1.2.1
+Requires-Dist: cks-core>=1.3.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"

{cks_runtime-0.4.4 → cks_runtime-0.4.6}/cks_runtime.egg-info/requires.txt

@@ -1,4 +1,4 @@
-cks-core>=1.2.1
+cks-core>=1.3.0
 
 [dev]
 pytest>=8.0

{cks_runtime-0.4.4 → cks_runtime-0.4.6}/cks_runtime_plugins/cks_core/adapter.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 from typing import Any
 
 import cks
+from cks.diagnostics import DiagnosticSeverity as CoreSeverity
 from cks.evolution import compose
 from cks.interface import inspect as cks_inspect
 
@@ -20,6 +21,42 @@ from cks_runtime.core_api.interfaces import CoreInterface
 from cks_runtime.core_api.validation_result import (
     RuntimeValidationResult,
 )
+from cks_runtime.diagnostics.diagnostic import (
+    Diagnostic as RuntimeDiagnostic,
+    DiagnosticSeverity as RuntimeSeverity,
+    DiagnosticSource,
+)
+
+_SEVERITY_MAP = {
+    CoreSeverity.INFORMATION: RuntimeSeverity.INFO,
+    CoreSeverity.WARNING: RuntimeSeverity.WARNING,
+    CoreSeverity.ERROR: RuntimeSeverity.ERROR,
+}
+
+
+def _translate_diagnostic(diagnostic: Any) -> RuntimeDiagnostic:
+    """
+    Translate a cks-core Diagnostic into a Runtime-native Diagnostic.
+
+    cks-core diagnostics freeze ``metadata`` into a MappingProxyType,
+    which the stdlib ``copy`` module cannot deepcopy. Runtime persists
+    Diagnostics via deepcopy (see InMemoryStorage), so foreign
+    cks-core Diagnostic instances must never be stored as-is -- they
+    are always translated into the Runtime's own, deepcopy-safe
+    Diagnostic type at this boundary.
+    """
+
+    metadata = dict(diagnostic.metadata)
+    if diagnostic.location is not None:
+        metadata.setdefault("location", diagnostic.location)
+
+    return RuntimeDiagnostic(
+        message=diagnostic.message,
+        source=DiagnosticSource.CORE,
+        severity=_SEVERITY_MAP[diagnostic.severity],
+        code=diagnostic.identity,
+        metadata=metadata,
+    )
 
 
 class CksCoreAdapter(CoreInterface):
@@ -46,7 +83,7 @@ class CksCoreAdapter(CoreInterface):
         return RuntimeValidationResult(
             valid=result.is_valid,
             diagnostics=tuple(
-                result.diagnostics,
+                _translate_diagnostic(d) for d in result.diagnostics
             ),
             metadata=dict(
                 result.metadata,

{cks_runtime-0.4.4 → cks_runtime-0.4.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cks-runtime"
-version = "0.4.4"
+version = "0.4.6"
 
 description = "Canonical Runtime for the Canonical Knowledge Structure ecosystem"
 
@@ -19,7 +19,7 @@ license = { text = "MIT" }
 requires-python = ">=3.12"
 
 dependencies = [
-    "cks-core>=1.2.1",
+    "cks-core>=1.3.0",
 ]
 
 keywords = [

cks_runtime-0.4.4/cks_runtime/versioning/version.py

@@ -1,110 +0,0 @@
-"""
-Runtime Version.
-
-Represents an immutable Runtime snapshot.
-
-A RuntimeVersion records the operational state of a
-RuntimeSession immediately after a committed RuntimeTransaction.
-
-RuntimeVersions are immutable snapshots.
-"""
-
-from __future__ import annotations
-
-from copy import deepcopy
-from dataclasses import dataclass
-from dataclasses import field
-from datetime import UTC
-from datetime import datetime
-from typing import Any
-from uuid import uuid4
-
-
-@dataclass(frozen=True, slots=True)
-class RuntimeVersion:
-    """
-    Immutable Runtime snapshot.
-
-    Ownership:
-
-    - belongs to exactly one RuntimeSession;
-    - originates from exactly one committed RuntimeTransaction;
-    - stores operational state only.
-
-    RuntimeVersion never owns semantic behaviour.
-    """
-
-    session_id: str
-
-    transaction_id: str
-
-    knowledge_structure: Any
-
-    metadata: dict[str, Any]
-
-    version_id: str = field(
-        default_factory=lambda: str(uuid4()),
-    )
-
-    created_at: datetime = field(
-        default_factory=lambda: datetime.now(
-            UTC,
-        ),
-    )
-
-    def __post_init__(self) -> None:
-        """
-        Deep-copy mutable state.
-
-        RuntimeVersion must never share mutable objects
-        with a live RuntimeSession.
-        """
-
-        object.__setattr__(
-            self,
-            "knowledge_structure",
-            deepcopy(self.knowledge_structure),
-        )
-
-        object.__setattr__(
-            self,
-            "metadata",
-            deepcopy(self.metadata),
-        )
-
-    #
-    # ------------------------------------------------------------------
-    # Metadata
-    # ------------------------------------------------------------------
-    #
-
-    @property
-    def has_metadata(self) -> bool:
-        """
-        Whether this RuntimeVersion contains metadata.
-        """
-
-        return bool(self.metadata)
-
-    @property
-    def age(self):
-        """
-        Time elapsed since this RuntimeVersion was created.
-        """
-
-        return datetime.now(
-            UTC,
-        ) - self.created_at
-
-    #
-    # ------------------------------------------------------------------
-    # Debugging
-    # ------------------------------------------------------------------
-    #
-
-    def __repr__(self) -> str:
-        return (
-            f"{self.__class__.__name__}("
-            f"id={self.version_id!r}, "
-            f"session={self.session_id!r})"
-        )