splime 0.3.0__tar.gz → 0.4.0__tar.gz

{splime-0.3.0/src/splime.egg-info → splime-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splime
-Version: 0.3.0
+Version: 0.4.0
 Summary: Reuse Python functions across projects without rewriting or redeploying them.
 Author-email: Yastrebov Kirill <yastrebovks@gmail.com>
 License-Expression: Apache-2.0

{splime-0.3.0 → splime-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splime"
-version = "0.3.0"
+version = "0.4.0"
 
 description = "Reuse Python functions across projects without rewriting or redeploying them."
 readme = "README.md"

{splime-0.3.0 → splime-0.4.0}/src/spl/_client.py

@@ -39,6 +39,7 @@ from spl._views import (
     SignatureView,
     wrap_action,
 )
+from spl.core import manifest as m_manifest
 from spl.core.entities.node import DEFAULT_PORT
 from spl.daemon_client import (
     DEFAULT_DAEMON_HOST,
@@ -71,7 +72,8 @@ def _preview(value: Any, *, limit: int = 80) -> str:
 
 
 def _is_missing_server_connection(exc: Exception) -> bool:
-    return isinstance(exc, ClientError) and _NO_SERVER_CONNECTION_MESSAGE in str(exc)
+    message = str(exc)
+    return isinstance(exc, ClientError) and _NO_SERVER_CONNECTION_MESSAGE in message
 
 
 def _progress_callback(progress: ProgressOption) -> RunStateCallback | None:
@@ -767,11 +769,29 @@ class SPLClient:
         return ConnectionStatusView(state)
 
     def machines(self) -> dict[str, Any]:
-        """Return the user's machines, or an empty listing when not connected."""
+        """Return the user's machines, or an empty listing when not connected.
 
-        if not self._has_server_connection():
+        The connection-state endpoint is probed for health only: a missing
+        connection maps to an empty listing and any other state failure
+        re-raises (0.3.0 contract). A degraded-but-present state (for
+        example ``heartbeat_failed``) must not hide the daemon's machine
+        payload, so the state content itself does not gate the listing.
+        """
+
+        if self.server_connection is None:
+            try:
+                self._daemon.server_connection()
+            except Exception as exc:
+                if not _is_missing_server_connection(exc):
+                    raise
+                return MachineListView({"current_machine_id": None, "machines": []})
+        try:
+            machines = self._daemon.server_machines()
+        except Exception as exc:
+            if not _is_missing_server_connection(exc):
+                raise
             return MachineListView({"current_machine_id": None, "machines": []})
-        return MachineListView(self._daemon.server_machines())
+        return MachineListView(machines)
 
     def libraries(self, *, include_accessible: bool = True) -> list[dict[str, Any]]:
         """Return visible libraries, or an empty list when not connected."""
@@ -1368,10 +1388,89 @@ class SPLClient:
             "environment build",
         )
 
-    def runs(self) -> list[dict[str, Any]]:
+    def runs(self, *, local: bool = False) -> list[dict[str, Any]]:
         """Return known daemon runs, newest first."""
 
-        return RunListView(self._daemon.list_runs())
+        return RunListView(m_manifest.list_local_runs() if local else self._daemon.list_runs())
+
+    def run_show(self, run_id: str, *, full_inline: bool = False, local: bool = False) -> dict[str, Any]:
+        """Return one retained run manifest.
+
+        Inline JSON values are summarized by default; pass ``full_inline=True``
+        to include the full manifest values.
+        """
+
+        payload = (
+            m_manifest.show_local_run(run_id, include_inline_values=full_inline)
+            if local
+            else self._daemon.show_run(run_id, full_inline=full_inline)
+        )
+        return RunRecordView(payload)
+
+    def resume(
+        self,
+        run_id: str,
+        *,
+        from_: Any,
+        kwargs: dict[str, Any] | None = None,
+        output: str | None = None,
+        timeout_seconds: float | None = None,
+        adapters: dict[str, Any] | None = None,
+        runtimes: dict[str, str] | None = None,
+        keep: bool | str | None = None,
+        wait: bool = False,
+        artifacts_dir: str | Path | None = None,
+        progress: ProgressOption = True,
+    ) -> RemoteRun | RemoteResult:
+        """Resume a retained daemon pipeline run from selected recalculation nodes."""
+
+        state = self._daemon.resume_run(
+            run_id,
+            from_=from_,
+            kwargs=kwargs,
+            output=output,
+            timeout_seconds=timeout_seconds,
+            adapters=adapters,
+            runtimes=runtimes,
+            keep=keep,
+        )
+        run = RemoteRun(self, state)
+        if not wait:
+            return run
+        return run.collect(
+            artifacts_dir=artifacts_dir,
+            timeout_seconds=timeout_seconds,
+            progress=progress,
+        )
+
+    def prune_runs(
+        self,
+        *,
+        run_id: str | None = None,
+        status: str | list[str] | None = None,
+        older_than_seconds: float | None = None,
+        dry_run: bool = False,
+        local: bool = False,
+    ) -> dict[str, Any]:
+        """Prune inactive retained runs by id, status, age, or retention TTL."""
+
+        statuses = [status] if isinstance(status, str) else status
+        result = (
+            m_manifest.prune_local_runs(
+                run_id=run_id,
+                statuses=statuses,
+                older_than_seconds=older_than_seconds,
+                dry_run=dry_run,
+            )
+            if local
+            else self._daemon.prune_runs(
+                run_id=run_id,
+                statuses=statuses,
+                older_than_seconds=older_than_seconds,
+                dry_run=dry_run,
+            )
+        )
+        return wrap_action(result, "runs pruned")
 
     def _start_run(
         self,
@@ -1387,24 +1486,37 @@ class SPLClient:
         offline_policy: OfflinePolicy | None = None,
         function: str | None = None,
         source: RunSource = "auto",
+        adapters: Any | None = None,
+        runtimes: dict[str, str] | None = None,
+        keep: bool | str | None = None,
     ) -> RemoteRun:
         """Shared implementation behind ``submit``/``call`` (and legacy aliases)."""
 
+        if adapters is not None:
+            raise NotImplementedError(
+                "run-level adapter overrides are supported only by local Deployment.run in 0.4.0; "
+                "SPLClient daemon runs cannot serialize Python adapter callables yet"
+            )
+
         remote = target_machine is not None or owner is not None or library is not None
-        state = self._daemon.run(
-            name,
-            args=args,
-            kwargs=kwargs,
-            output=output,
-            timeout_seconds=timeout_seconds,
-            target_machine=target_machine,
-            object_owner_id=owner,
-            library=library,
-            offline_policy=offline_policy,
-            function=function,
-            source=source,
-            remote=remote or None,
-        )
+        run_kwargs: dict[str, Any] = {
+            "args": args,
+            "kwargs": kwargs,
+            "output": output,
+            "timeout_seconds": timeout_seconds,
+            "target_machine": target_machine,
+            "object_owner_id": owner,
+            "library": library,
+            "offline_policy": offline_policy,
+            "function": function,
+            "source": source,
+            "remote": remote or None,
+        }
+        if runtimes is not None:
+            run_kwargs["runtimes"] = runtimes
+        if keep is not None:
+            run_kwargs["keep"] = keep
+        state = self._daemon.run(name, **run_kwargs)
         return RemoteRun(self, state, server_side=remote)
 
     # ``start()`` warned through 0.1.4/0.1.5 and was removed in 0.2.0 — use
@@ -1424,12 +1536,17 @@ class SPLClient:
         offline_policy: OfflinePolicy | None = None,
         function: str | None = None,
         source: RunSource = "auto",
+        adapters: Any | None = None,
+        runtimes: dict[str, str] | None = None,
+        keep: bool | str | None = None,
     ) -> RemoteRun:
         """Canonical async entry point: start a run, return a handle immediately.
 
         The default path is local daemon execution.  Passing ``target_machine``,
         ``owner``, or ``library`` intentionally selects central-server remote
-        execution through the connected daemon.
+        execution through the connected daemon.  ``adapters`` is reserved for
+        run-level adapter overrides and currently raises because daemon runs do
+        not serialize Python adapter callables.
         """
 
         return self._start_run(
@@ -1444,6 +1561,9 @@ class SPLClient:
             offline_policy=offline_policy,
             function=function,
             source=source,
+            adapters=adapters,
+            runtimes=runtimes,
+            keep=keep,
         )
 
     # ``queue()`` warned through 0.1.4/0.1.5 and was removed in 0.2.0 — use
@@ -1464,6 +1584,9 @@ class SPLClient:
         offline_policy: OfflinePolicy | None = None,
         function: str | None = None,
         source: RunSource = "auto",
+        adapters: Any | None = None,
+        runtimes: dict[str, str] | None = None,
+        keep: bool | str | None = None,
         progress: ProgressOption = True,
     ) -> RemoteResult:
         """Run an object, wait for completion, and return result/artifacts.
@@ -1476,7 +1599,9 @@ class SPLClient:
         While waiting, slow phases (a first-run environment build, a queued
         server-side run) print short progress lines to stderr.  Pass
         ``progress=False`` to wait silently, or a callable to receive every
-        polled run state instead.
+        polled run state instead.  ``adapters`` is reserved for run-level
+        adapter overrides and currently raises because daemon runs do not
+        serialize Python adapter callables.
         """
 
         run = self._start_run(
@@ -1491,6 +1616,9 @@ class SPLClient:
             offline_policy=offline_policy,
             function=function,
             source=source,
+            adapters=adapters,
+            runtimes=runtimes,
+            keep=keep,
         )
         return run.collect(
             artifacts_dir=artifacts_dir,

{splime-0.3.0 → splime-0.4.0}/src/spl/_views.py

@@ -136,6 +136,20 @@ def _status(value: Any) -> str:
     return _EMPTY if value is None else str(value)
 
 
+def _mapping_rows(value: Any) -> list[Mapping[str, Any]]:
+    if not isinstance(value, list):
+        return []
+    return [item for item in value if isinstance(item, Mapping)]
+
+
+def _adapter_label(row: Mapping[str, Any]) -> str:
+    save = row.get("save")
+    load = row.get("load")
+    if save and load and save != load:
+        return "{} -> {}".format(save, load)
+    return _EMPTY if save is None and load is None else str(save or load)
+
+
 class CompactDict(dict[str, Any]):
     """A dict with compact ``repr`` and plain ``.raw`` access."""
 
@@ -516,6 +530,8 @@ class DecompositionView(CompactDict):
 
 class RunRecordView(CompactDict):
     title = "run"
+    runtime_headers = ("node", "runtime", "source")
+    edge_headers = ("edge", "tag", "adapter", "source")
 
     def _summary_rows(self) -> list[tuple[str, Any]]:
         result = self.get("result")
@@ -526,9 +542,13 @@ class RunRecordView(CompactDict):
         return [
             ("id", self.get("id")),
             ("status", self.get("status")),
+            ("keep", self.get("keep")),
             ("mode", self.get("mode") or self.get("source")),
             ("object", self.get("object") or self.get("object_name")),
             ("output", self.get("output")),
+            ("parent", self.get("parent_run_id")),
+            ("manifest", self.get("has_manifest")),
+            ("disk bytes", self.get("disk_size_bytes")),
             ("created", self.get("created_at")),
             ("started", self.get("started_at")),
             ("finished", self.get("finished_at")),
@@ -536,10 +556,51 @@ class RunRecordView(CompactDict):
             ("error", self.get("error")),
         ]
 
+    def _runtime_rows(self) -> list[dict[str, Any]]:
+        return [
+            {
+                "node": item.get("alias") or short_id(item.get("node_id")),
+                "runtime": item.get("name"),
+                "source": item.get("source"),
+            }
+            for item in _mapping_rows(self.get("node_runtimes"))
+        ]
+
+    def _edge_rows(self) -> list[dict[str, Any]]:
+        return [
+            {
+                "edge": "{} -> {}".format(item.get("source") or _EMPTY, item.get("target") or _EMPTY),
+                "tag": item.get("tag"),
+                "adapter": _adapter_label(item),
+                "source": item.get("source_level"),
+            }
+            for item in _mapping_rows(self.get("edge_adapters"))
+        ]
+
+    def __repr__(self) -> str:
+        lines = [details_to_text(self._title, self._summary_rows())]
+        runtime_rows = self._runtime_rows()
+        edge_rows = self._edge_rows()
+        if runtime_rows:
+            lines.append(table_to_text("node runtimes", self.runtime_headers, runtime_rows))
+        if edge_rows:
+            lines.append(table_to_text("edge adapters", self.edge_headers, edge_rows))
+        return "\n\n".join(lines)
+
+    def _repr_html_(self) -> str:
+        parts = [details_to_html(self._title, self._summary_rows())]
+        runtime_rows = self._runtime_rows()
+        edge_rows = self._edge_rows()
+        if runtime_rows:
+            parts.append(table_to_html("node runtimes", self.runtime_headers, runtime_rows))
+        if edge_rows:
+            parts.append(table_to_html("edge adapters", self.edge_headers, edge_rows))
+        return "".join(parts)
+
 
 class RunListView(CompactList):
     title = "runs"
-    headers = ("id", "status", "mode", "object", "output", "created", "error")
+    headers = ("id", "status", "keep", "manifest", "parent", "size", "object", "created")
 
     def __init__(self, payload: list[Any] | None = None, *, title: str | None = None):
         super().__init__(
@@ -556,11 +617,12 @@ class RunListView(CompactList):
             {
                 "id": short_id(item.get("id")),
                 "status": _status(item.get("status")),
-                "mode": item.get("mode") or item.get("source"),
+                "keep": item.get("keep"),
+                "manifest": "yes" if item.get("has_manifest") else "no",
+                "parent": short_id(item.get("parent_run_id")),
+                "size": item.get("disk_size_bytes"),
                 "object": item.get("object") or item.get("object_name"),
-                "output": item.get("output"),
                 "created": item.get("created_at"),
-                "error": item.get("error"),
             }
             for item in self
             if isinstance(item, Mapping)