splime 0.2.5__tar.gz → 0.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splime
-Version: 0.2.5
+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
@@ -42,6 +42,8 @@ Requires-Dist: pyexpect; extra == "test"
 Requires-Dist: mypy==2.1.0; extra == "test"
 Requires-Dist: pytest==9.1.1; extra == "test"
 Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: ruff==0.15.20; extra == "test"
+Requires-Dist: types-PyYAML==6.0.12.20260518; extra == "test"
 Provides-Extra: docs
 Requires-Dist: sphinx==9.1.0; extra == "docs"
 Requires-Dist: sphinx-rtd-theme==3.1.0; extra == "docs"

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splime"
-version = "0.2.5"
+version = "0.4.0"
 
 description = "Reuse Python functions across projects without rewriting or redeploying them."
 readme = "README.md"
@@ -55,7 +55,9 @@ test = [
   "pyexpect",
   "mypy==2.1.0",
   "pytest==9.1.1",
-  "pytest-asyncio"]
+  "pytest-asyncio",
+  "ruff==0.15.20",
+  "types-PyYAML==6.0.12.20260518"]
 
 docs = [
   "sphinx==9.1.0",
@@ -105,7 +107,7 @@ strict = true
 line-length = 120
 
 [tool.ruff.lint]
-select = []
+select = ["E4", "E7", "E9", "F"]
 ignore = []
 
 # Scoped, justified allowances. These silence rules only where the pattern is
@@ -125,6 +127,9 @@ ignore = []
     "S603", "S607", "S310", "S104", "S108", "S608",
     "S105", "B904", "S110", "S112", "N818",
 ]
+# The legacy worker must repair sys.path before importing packages that can be
+# shadowed by the daemon checkout injected through PYTHONPATH.
+"src/spl/daemon/worker.py" = ["E402"]
 # The CLI and daemon bootstrap print to the console on purpose.
 "src/spl/daemon/cli.py" = ["T201"]
 "src/spl/daemon/server.py" = ["T201"]

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

@@ -18,6 +18,7 @@ dependencies imported yet.
 
 from __future__ import annotations
 
+import builtins
 from dataclasses import dataclass, field, replace
 from html import escape
 from pathlib import Path
@@ -38,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,
@@ -70,10 +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:
@@ -141,10 +141,7 @@ class PublishedObject:
             "entrypoint": self.entrypoint,
         }
         body = "".join(
-            "<tr>"
-            f"<th style='text-align:left'>{escape(key)}</th>"
-            f"<td><code>{escape(value)}</code></td>"
-            "</tr>"
+            f"<tr><th style='text-align:left'>{escape(key)}</th><td><code>{escape(value)}</code></td></tr>"
             for key, value in rows.items()
         )
         return f"<table><tbody>{body}</tbody></table>"
@@ -170,11 +167,7 @@ def _catalog_rows(
     rows: list[dict[str, str]] = []
     for record in records:
         library = record.get("library")
-        library_name = (
-            library.get("display_name") or library.get("slug")
-            if isinstance(library, dict)
-            else library
-        )
+        library_name = library.get("display_name") or library.get("slug") if isinstance(library, dict) else library
         version_value = record.get("version")
         if version_value is None:
             current = record.get("current_version")
@@ -197,28 +190,16 @@ def _catalog_rows(
 def _rows_to_text(rows: list[dict[str, str]], title: str) -> str:
     if not rows:
         return f"{title}: (empty)"
-    widths = {
-        header: max(len(header), *(len(row[header]) for row in rows))
-        for header in _CATALOG_HEADERS
-    }
+    widths = {header: max(len(header), *(len(row[header]) for row in rows)) for header in _CATALOG_HEADERS}
     head = "  ".join(header.ljust(widths[header]) for header in _CATALOG_HEADERS)
-    body = "\n".join(
-        "  ".join(row[header].ljust(widths[header]) for header in _CATALOG_HEADERS)
-        for row in rows
-    )
+    body = "\n".join("  ".join(row[header].ljust(widths[header]) for header in _CATALOG_HEADERS) for row in rows)
     return f"{title} ({len(rows)}):\n{head}\n{body}"
 
 
 def _rows_to_html(rows: list[dict[str, str]], title: str) -> str:
-    head = "".join(
-        f"<th style='text-align:left'>{escape(header)}</th>"
-        for header in _CATALOG_HEADERS
-    )
+    head = "".join(f"<th style='text-align:left'>{escape(header)}</th>" for header in _CATALOG_HEADERS)
     body = "".join(
-        "<tr>"
-        + "".join(f"<td>{escape(row[header])}</td>" for header in _CATALOG_HEADERS)
-        + "</tr>"
-        for row in rows
+        "<tr>" + "".join(f"<td>{escape(row[header])}</td>" for header in _CATALOG_HEADERS) + "</tr>" for row in rows
     )
     return (
         f"<div><b>{escape(title)}</b> ({len(rows)})"
@@ -258,14 +239,10 @@ class ObjectCatalog(dict[str, Any]):
     """Local+server catalog that prints per-scope tables; ``.raw`` is a plain dict."""
 
     def __repr__(self) -> str:
-        return "\n\n".join(
-            _rows_to_text(_catalog_rows(value), str(key)) for key, value in self.items()
-        )
+        return "\n\n".join(_rows_to_text(_catalog_rows(value), str(key)) for key, value in self.items())
 
     def _repr_html_(self) -> str:
-        return "".join(
-            _rows_to_html(_catalog_rows(value), str(key)) for key, value in self.items()
-        )
+        return "".join(_rows_to_html(_catalog_rows(value), str(key)) for key, value in self.items())
 
     @property
     def raw(self) -> dict[str, Any]:
@@ -343,10 +320,7 @@ class RemoteResult:
             "artifacts": str(len(self.artifacts)),
         }
         body = "".join(
-            "<tr>"
-            f"<th style='text-align:left'>{escape(key)}</th>"
-            f"<td><code>{escape(value)}</code></td>"
-            "</tr>"
+            f"<tr><th style='text-align:left'>{escape(key)}</th><td><code>{escape(value)}</code></td></tr>"
             for key, value in rows.items()
         )
         return f"<table><tbody>{body}</tbody></table>"
@@ -375,13 +349,13 @@ class RemoteRun:
     def id(self) -> str:
         """Return the daemon run id."""
 
-        return self.state["id"]
+        return cast(str, self.state["id"])
 
     @property
     def status(self) -> str:
         """Return the last known daemon status."""
 
-        return self.state["status"]
+        return cast(str, self.state["status"])
 
     @property
     def mode(self) -> str:
@@ -490,17 +464,10 @@ class RemoteRun:
         )
         if final_state["status"] != "succeeded":
             error = final_state.get("error") or "run returned no error message"
-            raise RuntimeError(
-                f"{self.mode} run {self.id!r} ended as "
-                f"{final_state.get('status')!r}: {error}"
-            )
+            raise RuntimeError(f"{self.mode} run {self.id!r} ended as {final_state.get('status')!r}: {error}")
 
         payload = self.result()
-        downloaded = (
-            self.download_artifacts(artifacts_dir)
-            if artifacts_dir is not None
-            else {}
-        )
+        downloaded = self.download_artifacts(artifacts_dir) if artifacts_dir is not None else {}
         return RemoteResult(
             run=final_state,
             payload=payload,
@@ -593,7 +560,7 @@ class _LibraryAdmin:
         grantee: str,
         *,
         grantee_type: str = "user",
-        scopes: list[str] | None = None,
+        scopes: builtins.list[str] | None = None,
     ) -> dict[str, Any]:
         """Grant a user or team access to one central-server library."""
 
@@ -779,11 +746,7 @@ class SPLClient:
             )
         conn = self.current_server_connection()
         connection = conn.get("connection")
-        nested_url = (
-            connection.get("server_url")
-            if isinstance(connection, dict)
-            else None
-        )
+        nested_url = connection.get("server_url") if isinstance(connection, dict) else None
         server_url = conn.get("server_url") or nested_url or DEFAULT_SERVER_URL
         return SPLServerClient(token=self._user_token, base_url=server_url)
 
@@ -800,28 +763,42 @@ class SPLClient:
             state = self._daemon.server_connection()
         except Exception as exc:
             if _is_missing_server_connection(exc):
-                return ConnectionStatusView(
-                    {"connected": False, "offline": False, "connection": None}
-                )
+                return ConnectionStatusView({"connected": False, "offline": False, "connection": None})
             raise
         state.setdefault("connected", bool(state.get("server_url")))
         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."""
 
         if not self._has_server_connection():
             return LibraryListView([])
-        return LibraryListView(
-            self._daemon.server_libraries(include_accessible=include_accessible)
-        )
+        return LibraryListView(self._daemon.server_libraries(include_accessible=include_accessible))
 
     # The flat library aliases (create_library, get_library, update_library,
     # delete_library, grant_library, revoke_library_grant, add_reference,
@@ -1018,11 +995,7 @@ class SPLClient:
         """
 
         if scope == "auto":
-            scope = (
-                "server"
-                if owner is not None or library is not None or self._has_server_connection()
-                else "local"
-            )
+            scope = "server" if owner is not None or library is not None or self._has_server_connection() else "local"
         if scope == "local":
             if owner is not None or library is not None:
                 raise ValueError("owner/library require scope='server', scope='all', or scope='auto'")
@@ -1220,9 +1193,7 @@ class SPLClient:
         """Return normalized function/node/link metadata for one object."""
 
         if self._is_node_remote(name):
-            return DecompositionView(
-                self._remote_decomposition_response(name, version=version)["decomposition"]
-            )
+            return DecompositionView(self._remote_decomposition_response(name, version=version)["decomposition"])
         if owner is not None or library is not None:
             response = self._remote_decomposition_response(
                 {
@@ -1269,11 +1240,7 @@ class SPLClient:
             record = response.get("object") or {}
             remote = response.get("remote") or {}
             object_name = (
-                title
-                or record.get("display_name")
-                or record.get("name")
-                or remote.get("name")
-                or pipeline.name
+                title or record.get("display_name") or record.get("name") or remote.get("name") or pipeline.name
             )
             return PipelineGraphWidget(
                 decomposition,
@@ -1328,10 +1295,7 @@ class SPLClient:
                 theme=theme,
             )
 
-        raise TypeError(
-            "pipeline_widget expects an object name, PublishedObject, "
-            "spl.core Pipeline, or NodeRemote"
-        )
+        raise TypeError("pipeline_widget expects an object name, PublishedObject, spl.core Pipeline, or NodeRemote")
 
     def draw_pipeline(
         self,
@@ -1371,20 +1335,11 @@ class SPLClient:
             function=function,
         )
         display_name = signature.get("display_name") or signature["name"]
-        lines = [
-            (
-                f"{display_name} "
-                f"v{signature['version']} ({signature['kind']})"
-            )
-        ]
+        lines = [(f"{display_name} v{signature['version']} ({signature['kind']})")]
         if signature.get("description"):
             lines.append(signature["description"])
 
-        if (
-            function is None
-            and signature.get("kind") == "pipeline"
-            and signature.get("internal_functions")
-        ):
+        if function is None and signature.get("kind") == "pipeline" and signature.get("internal_functions"):
             lines.append("Functions:")
             for item in signature["internal_functions"]:
                 lines.append(f"  - {item['name']}")
@@ -1393,29 +1348,16 @@ class SPLClient:
         if signature["inputs"]:
             for item in signature["inputs"]:
                 required = "required" if item["required"] else "optional"
-                default = (
-                    ""
-                    if item["default"] is None
-                    else f", default={item['default']}"
-                )
-                lines.append(
-                    f"  - {item['name']}: {item['type'] or 'Any'} "
-                    f"({required}{default})"
-                )
+                default = "" if item["default"] is None else f", default={item['default']}"
+                lines.append(f"  - {item['name']}: {item['type'] or 'Any'} ({required}{default})")
         else:
             lines.append("  - none")
 
         lines.append("Outputs:")
         if signature["outputs"]:
             for item in signature["outputs"]:
-                selector = (
-                    f'output="{item["selector"]}"'
-                    if item["selector"] is not None
-                    else "no output selector"
-                )
-                lines.append(
-                    f"  - {item['name']}: {selector}; read {item['read']}"
-                )
+                selector = f'output="{item["selector"]}"' if item["selector"] is not None else "no output selector"
+                lines.append(f"  - {item['name']}: {selector}; read {item['read']}")
         else:
             lines.append("  - none")
 
@@ -1446,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,
@@ -1465,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
@@ -1502,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(
@@ -1522,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
@@ -1542,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.
@@ -1554,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(
@@ -1569,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,
@@ -1628,11 +1678,7 @@ class SPLClient:
         *,
         version: int | None = None,
     ) -> dict[str, Any]:
-        ref = (
-            self._remote_node_payload(remote, version=version)
-            if self._is_node_remote(remote)
-            else dict(remote)
-        )
+        ref = self._remote_node_payload(remote, version=version) if self._is_node_remote(remote) else dict(remote)
         if version is not None:
             ref["version"] = version
         return self._daemon.resolve_remote_decomposition(ref)
@@ -1735,11 +1781,7 @@ def export_objects_to_yaml(xs: list[Any], *, frame_offset: int = 2) -> str:
 
     top_level_deps = get_top_level_deps(frame_offset, xs)
 
-    mapping = {
-        root: DSPLSelfImport(name=cast(Any, root).name)
-        for (root, _) in top_level_deps
-        if hasattr(root, "name")
-    }
+    mapping = {root: DSPLSelfImport(name=cast(Any, root).name) for (root, _) in top_level_deps if hasattr(root, "name")}
 
     normalized_deps = {
         root: [mapping.get(dependency, dependency) for dependency in dependencies]
@@ -1762,8 +1804,7 @@ def prepare_export_object(obj: Any, entrypoint: str | None) -> tuple[Any, str]:
         if entrypoint is None:
             if obj.name is None:
                 raise ValueError(
-                    "unnamed pipeline requires entrypoint; "
-                    "use pipeline.render(name) or publish(..., entrypoint='name')"
+                    "unnamed pipeline requires entrypoint; use pipeline.render(name) or publish(..., entrypoint='name')"
                 )
             return obj, obj.name
         return replace(obj, name=entrypoint), entrypoint

{splime-0.2.5 → splime-0.4.0}/src/spl/_http.py

@@ -7,6 +7,9 @@ from functools import lru_cache
 from typing import Any
 from urllib.request import Request, urlopen
 
+DEFAULT_HTTP_TIMEOUT_SECONDS = 60.0
+DEFAULT_FILE_TRANSFER_TIMEOUT_SECONDS = 300.0
+
 
 @lru_cache(maxsize=1)
 def verified_https_context() -> ssl.SSLContext:
@@ -17,7 +20,11 @@ def verified_https_context() -> ssl.SSLContext:
     return ssl.create_default_context(cafile=certifi.where())
 
 
-def urlopen_verified(request: Request) -> Any:
+def urlopen_verified(
+    request: Request,
+    *,
+    timeout: float | None = DEFAULT_HTTP_TIMEOUT_SECONDS,
+) -> Any:
     """Open a URL request with the bundled certifi CA bundle."""
 
-    return urlopen(request, context=verified_https_context())
+    return urlopen(request, context=verified_https_context(), timeout=timeout)