tensorfs 0.3.40__tar.gz → 0.3.41__tar.gz

{tensorfs-0.3.40 → tensorfs-0.3.41}/Cargo.lock

@@ -421,7 +421,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.3.40"
+version = "0.3.41"
 dependencies = [
  "fs2",
  "minicbor",
@@ -434,7 +434,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.3.40"
+version = "0.3.41"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.3.40 → tensorfs-0.3.41}/Cargo.toml

@@ -3,5 +3,5 @@ resolver = "2"
 members = ["crates/tensorfs-core", "crates/tensorfs-py"]
 
 [workspace.package]
-version = "0.3.40"
+version = "0.3.41"
 edition = "2021"

{tensorfs-0.3.40 → tensorfs-0.3.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorfs
-Version: 0.3.40
+Version: 0.3.41
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Rust

{tensorfs-0.3.40 → tensorfs-0.3.41}/crates/tensorfs-core/src/derived.rs

@@ -2005,6 +2005,19 @@ fn inspect_retained_source(
         code: Code::ROOT_ABSENT,
         detail: "source inspection resolved no source".into(),
     })?;
+    for component in &component_names {
+        if !source
+            .header
+            .components
+            .iter()
+            .any(|(name, _)| name == component)
+        {
+            return refuse(
+                Code::MISSING_FIELD,
+                format!("source has no component {component:?}"),
+            );
+        }
+    }
     let configs = config_names
         .iter()
         .map(|name| {

{tensorfs-0.3.40 → tensorfs-0.3.41}/crates/tensorfs-py/src/store.rs

@@ -1864,7 +1864,12 @@ impl PyStore {
         let identity = source_facts(py, std::slice::from_ref(&inspection.view))?;
         out.set_item("source", identity.get_item(0)?)?;
         let component_rows = PyList::empty(py);
-        for component in &inspection.view.fact.components {
+        // The selected fact is a normalized set. Author inspection must retain
+        // the header's construction traversal, including nonlexical components.
+        for (component, _) in &inspection.view.header.components {
+            if !inspection.view.fact.components.contains(component) {
+                continue;
+            }
             let row = PyDict::new(py);
             row.set_item("name", component)?;
             row.set_item(

{tensorfs-0.3.40 → tensorfs-0.3.41}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "tensorfs"
-version = "0.3.40"
+version = "0.3.41"
 description = "TensorFS — canonical tensor artifact substrate"
 requires-python = ">=3.12"
 classifiers = [

{tensorfs-0.3.40 → tensorfs-0.3.41}/python/tensorfs/_derived_channel.py

@@ -146,6 +146,19 @@ class DerivedTransaction:
         value.receipt = dict(receipt)
         return value
 
+    @classmethod
+    def accept(cls, fd: int) -> DerivedTransaction:
+        """Receive the owner's live-writer or validated committed-result decision."""
+        value = cls(fd)
+        receipt = value._call("receipt")
+        if receipt is not None:
+            if not isinstance(receipt, dict):
+                value.close()
+                raise ChannelRefusal("WRONG_TYPE", "native receipt must be an object")
+            value.receipt = receipt
+            value.close()
+        return value
+
     def _open(self) -> _Channel:
         if self._channel is None:
             raise ChannelRefusal("TRANSACTION_CLOSED", "derived handle is closed")
@@ -406,6 +419,7 @@ def serve_derived(
                     check_current()
             else:
                 if op not in (
+                    "receipt",
                     "completed_parts",
                     "completed_configs",
                     "checkpoint",
@@ -418,7 +432,9 @@ def serve_derived(
                 _fields(frame, op, ())
                 with admit_io(op, 0):
                     check_current()
-                    if op == "completed_parts":
+                    if op == "receipt":
+                        result = None
+                    elif op == "completed_parts":
                         result = writer.completed_parts()
                     elif op == "completed_configs":
                         result = writer.completed_configs()
@@ -456,3 +472,31 @@ def serve_derived(
     finally:
         channel.close()
         writer.fence()
+
+
+def serve_derived_replay(
+    receipt: Mapping[str, Any],
+    fd: int,
+    *,
+    check_current: Callable[[], None],
+    record_receipt: Callable[[dict[str, Any]], None],
+) -> None:
+    """Deliver retained native custody selected by the trusted execution owner."""
+    channel = _Channel(fd)
+    try:
+        request = channel.receive()
+        if not isinstance(request, dict):
+            raise ChannelRefusal("WRONG_TYPE", "expected a receipt request")
+        _fields(request, "receipt", ())
+        check_current()
+        facts = dict(receipt)
+        record_receipt(facts)
+        channel.send({"result": facts})
+    except EOFError:
+        return
+    except Exception as exc:
+        with contextlib.suppress(OSError, EOFError):
+            channel.send({"error": str(getattr(exc, "code", "IO_FAILED")), "detail": "native receipt owner refused"})
+        raise
+    finally:
+        channel.close()

tensorfs-0.3.41/python/tensorfs/_source_channel.py

@@ -0,0 +1,105 @@
+"""One exact source's bounded metadata/config channel, with no Store escape."""
+
+from __future__ import annotations
+
+import contextlib
+import threading
+from collections.abc import Callable, Sequence
+from typing import Any, ContextManager
+
+from . import _ext
+from ._derived_channel import ChannelRefusal, _Channel, _CHUNK, _METADATA, _fields
+from .derived import Source, SourceInspection
+
+
+class SourceClient:
+    def __init__(self, fd: int, source: Source) -> None:
+        self.channel = _Channel(fd)
+        self.source = source
+        self.lock = threading.Lock()
+
+    def close(self) -> None:
+        self.channel.close()
+
+    def inspect(self, components: Sequence[str], configs: Sequence[str]) -> SourceInspection:
+        with self.lock:
+            try:
+                self.channel.send({"op": "inspect", "components": list(components), "configs": list(configs)})
+                answer = self.channel.reply()
+                if set(answer) != {"result"} or not isinstance(answer["result"], dict):
+                    raise ChannelRefusal("WRONG_TYPE", "invalid source inspection response")
+                value = answer["result"]
+                total = 0
+                for config in value["configs"]:
+                    length = config.pop("length")
+                    if type(length) is not int or not 0 <= length <= _METADATA - total:
+                        raise ChannelRefusal("SIZE_CAP", "source configurations exceed their bound")
+                    total += length
+                    data = bytearray(length)
+                    view = memoryview(data)
+                    while view:
+                        block = self.channel.receive()
+                        if not isinstance(block, bytes) or not block or len(block) > len(view):
+                            raise ChannelRefusal("LENGTH_MISMATCH", "invalid source configuration stream")
+                        view[:len(block)] = block
+                        view = view[len(block):]
+                    config["data"] = bytes(data)
+                result = SourceInspection.from_native(value)
+                if result.source != self.source:
+                    raise ChannelRefusal("TRANSACTION_CONFLICT", "source inspection changed identity")
+                return result
+            except BaseException:
+                self.channel.close()
+                raise
+
+
+def serve_source(
+    store: _ext.Store,
+    source: Source,
+    fd: int,
+    *,
+    check_current: Callable[[], None],
+    admit_io: Callable[[], ContextManager[None]],
+) -> None:
+    """The owner fixes the source; the peer can only select its native metadata."""
+    channel = _Channel(fd)
+    try:
+        while True:
+            request = channel.receive()
+            if not isinstance(request, dict):
+                raise ChannelRefusal("WRONG_TYPE", "expected a source inspection")
+            _fields(request, "inspect", ("components", "configs"))
+            check_current()
+            components, configs = request["components"], request["configs"]
+            if not isinstance(components, list) or not isinstance(configs, list):
+                raise ChannelRefusal("WRONG_TYPE", "source selections must be lists")
+            with admit_io():
+                check_current()
+                if not components or not configs:
+                    raw_header = store.manifest(source.manifest)["header"]
+                    if raw_header is None:
+                        raise ChannelRefusal("MISSING_FIELD", "source has no tensor header")
+                    header = _ext.parse_header(raw_header)
+                    components = components or list(header["components"])
+                    configs = configs or list(header.get("configs", {}))
+                value = store.inspect_derived_source(source.manifest, source.length, components, configs)
+            check_current()
+            configuration = value["configs"]
+            metadata: dict[str, Any] = {
+                **value,
+                "configs": [{"name": row["name"], "length": len(row["data"])} for row in configuration],
+            }
+            channel.send({"result": metadata})
+            for row in configuration:
+                data = memoryview(row["data"])
+                for start in range(0, len(data), _CHUNK):
+                    check_current()
+                    channel.data(data[start:start+_CHUNK])
+    except EOFError:
+        return
+    except Exception as exc:
+        with contextlib.suppress(OSError, EOFError):
+            channel.send({"error": str(getattr(exc, "code", "IO_FAILED")), "detail": "source owner refused inspection"})
+        raise
+    finally:
+        channel.close()

{tensorfs-0.3.40 → tensorfs-0.3.41}/python/tensorfs/derived.py

@@ -11,7 +11,7 @@ from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, field
 from typing import Any, Literal
 
-from ._derived_channel import DerivedTransaction, serve_derived
+from ._derived_channel import DerivedTransaction, serve_derived, serve_derived_replay
 
 
 @dataclass(frozen=True, slots=True)
@@ -102,12 +102,32 @@ class SourceCapability(Source):
     _inspect: Callable[[Sequence[str], Sequence[str]], SourceInspection] = field(
         repr=False, compare=False
     )
+    _close: Callable[[], None] | None = field(default=None, repr=False, compare=False)
 
     def inspect(
         self, *, components: Sequence[str] = (), configs: Sequence[str] = ()
     ) -> SourceInspection:
         return self._inspect(tuple(components), tuple(configs))
 
+    @classmethod
+    def from_fd(cls, manifest: str, length: int, fd: int) -> SourceCapability:
+        """Own a preconnected inspector for one exact already-admitted source."""
+        from ._source_channel import SourceClient
+
+        client = SourceClient(fd, Source(manifest, length))
+        return cls(manifest, length, client.inspect, client.close)
+
+    def close(self) -> None:
+        if self._close is not None:
+            self._close()
+
+    def __enter__(self) -> SourceCapability:
+        return self
+
+    def __exit__(self, *exc: object) -> Literal[False]:
+        self.close()
+        return False
+
 
 @dataclass(frozen=True, slots=True)
 class Derivation:
@@ -191,6 +211,9 @@ def derive(output: OutputCapability, declaration: Derivation) -> DerivedTransact
     return output.open(declaration)
 
 
+from ._source_channel import serve_source  # noqa: E402
+
+
 __all__ = [
     "Source",
     "PartSource",
@@ -205,4 +228,6 @@ __all__ = [
     "DerivedTransaction",
     "derive",
     "serve_derived",
+    "serve_derived_replay",
+    "serve_source",
 ]