splime 0.1.4__tar.gz → 0.2.0__tar.gz

{splime-0.1.4/src/splime.egg-info → splime-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splime
-Version: 0.1.4
+Version: 0.2.0
 Summary: Reuse Python functions across projects without rewriting or redeploying them.
 Author-email: Yastrebov Kirill <yastrebovks@gmail.com>
 License-Expression: Apache-2.0
@@ -105,7 +105,8 @@ client.publish(daily_total, name="daily_total")
 
 result = client.call("daily_total", kwargs={"date": "2026-06-08"})
 print(result.mode)     # "local"
-print(result.output)   # 42.0  (unwrapped value; result.value keeps the raw port dict)
+print(result.output)   # 42.0  (.output always yields the plain value;
+                       #  for pipelines .value keeps the raw port dict)
 ```
 
 That is the whole loop: define a function, `publish` it as a versioned node, then `call`

{splime-0.1.4 → splime-0.2.0}/README.md

@@ -53,7 +53,8 @@ client.publish(daily_total, name="daily_total")
 
 result = client.call("daily_total", kwargs={"date": "2026-06-08"})
 print(result.mode)     # "local"
-print(result.output)   # 42.0  (unwrapped value; result.value keeps the raw port dict)
+print(result.output)   # 42.0  (.output always yields the plain value;
+                       #  for pipelines .value keeps the raw port dict)
 ```
 
 That is the whole loop: define a function, `publish` it as a versioned node, then `call`

{splime-0.1.4 → splime-0.2.0}/pyproject.toml

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

{splime-0.1.4 → splime-0.2.0}/src/spl/__init__.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 __path__ = __import__("pkgutil").extend_path(__path__, __name__)
 
-from spl.client import PublishedObject, RemoteResult, RemoteRun, SPLClient
+from spl._client import PublishedObject, RemoteResult, RemoteRun, SPLClient
 from spl.core import spl_export_to_dir, spl_export_to_file, spl_import_from_file
-from spl.core.common import Deployment, lift
+from spl.core._common import Deployment, lift
 from spl.core.entities.distribution import DDistribution
 from spl.core.entities.node import DEFAULT_PORT, InputPort, OutputPort
 from spl.core.entities.node_remote import NodeRemote

splime-0.1.4/src/spl/client.py → splime-0.2.0/src/spl/_client.py

@@ -4,7 +4,7 @@ This module is the thin "framework side" of the daemon integration.  Code that
 already uses SPL should not need to know about HTTP endpoints, run directories,
 or worker subprocesses.  The intended workflow is:
 
-    from spl.client import SPLClient
+    from spl import SPLClient
 
     client = SPLClient()
     client.publish(my_function, name="sum", env="default")
@@ -18,7 +18,6 @@ dependencies imported yet.
 
 from __future__ import annotations
 
-import warnings
 from dataclasses import dataclass, field, replace
 from html import escape
 from pathlib import Path
@@ -31,12 +30,15 @@ from spl.daemon_client import (
     DEFAULT_SERVER_URL,
     Client,
     ClientError,
+    RunProgressPrinter,
+    RunStateCallback,
 )
 from spl.server_client import SPLServerClient
 
 OfflinePolicy = Literal["queue", "wait", "fail_fast"]
 ObjectScope = Literal["auto", "local", "server", "all"]
 RunSource = Literal["auto", "local"]
+ProgressOption = bool | RunStateCallback
 _NO_SERVER_CONNECTION_MESSAGE = "active server connection is not found"
 
 
@@ -54,15 +56,18 @@ def _is_missing_server_connection(exc: Exception) -> bool:
     )
 
 
-def _warn_deprecated(old: str, new: str) -> None:
-    """Emit the standard 0.2.0 deprecation warning (see docs/migration-0.2.0.md)."""
+def _progress_callback(progress: ProgressOption) -> RunStateCallback | None:
+    """Turn a ``progress`` option into a wait-loop state callback.
 
-    warnings.warn(
-        f"{old} is deprecated and will be removed in splime 0.2.0; "
-        f"use {new} instead.",
-        DeprecationWarning,
-        stacklevel=3,
-    )
+    ``True`` builds a fresh stderr printer (fresh throttling state per wait),
+    ``False`` disables feedback, and a callable is passed through as-is.
+    """
+
+    if callable(progress):
+        return progress
+    if progress:
+        return RunProgressPrinter()
+    return None
 
 
 @dataclass(frozen=True, repr=False)
@@ -378,20 +383,30 @@ class RemoteRun:
         *,
         poll_interval: float = 0.25,
         timeout_seconds: float | None = None,
+        progress: ProgressOption = True,
     ) -> dict[str, Any]:
-        """Wait until the run succeeds or fails, then return final state."""
+        """Wait until the run succeeds or fails, then return final state.
+
+        ``progress`` controls feedback during slow phases (first-run
+        environment builds, queued server-side runs): ``True`` prints short
+        status lines to stderr, ``False`` waits silently, and a callable
+        receives every polled state instead.
+        """
 
+        on_state = _progress_callback(progress)
         if self.server_side:
             self.state = self._client._daemon.wait_remote_run(
                 self.id,
                 poll_interval=poll_interval,
                 timeout_seconds=timeout_seconds,
+                on_state=on_state,
             )
         else:
             self.state = self._client._daemon.wait_run(
                 self.id,
                 poll_interval=poll_interval,
                 timeout_seconds=timeout_seconds,
+                on_state=on_state,
             )
         return self.state
 
@@ -437,12 +452,17 @@ class RemoteRun:
         artifacts_dir: str | Path | None = None,
         poll_interval: float = 0.25,
         timeout_seconds: float | None = None,
+        progress: ProgressOption = True,
     ) -> RemoteResult:
-        """Wait for completion, return result, and optionally download artifacts."""
+        """Wait for completion, return result, and optionally download artifacts.
+
+        See :meth:`wait` for the meaning of ``progress``.
+        """
 
         final_state = self.wait(
             poll_interval=poll_interval,
             timeout_seconds=timeout_seconds,
+            progress=progress,
         )
         if final_state["status"] != "succeeded":
             error = final_state.get("error") or "run returned no error message"
@@ -754,139 +774,10 @@ class SPLClient:
             return []
         return self._daemon.server_libraries(include_accessible=include_accessible)
 
-    def create_library(
-        self,
-        slug: str,
-        *,
-        display_name: str | None = None,
-        description: str = "",
-        visibility: str = "private",
-        default_machine: str | None = None,
-        execution: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """Deprecated alias of :meth:`library.create` (see docs/migration-0.2.0.md)."""
-
-        _warn_deprecated("SPLClient.create_library()", "SPLClient.library.create()")
-        return self.library.create(
-            slug,
-            display_name=display_name,
-            description=description,
-            visibility=visibility,
-            default_machine=default_machine,
-            execution=execution,
-        )
-
-    def get_library(self, ref: str) -> dict[str, Any]:
-        """Deprecated alias of :meth:`library.get`."""
-
-        _warn_deprecated("SPLClient.get_library()", "SPLClient.library.get()")
-        return self.library.get(ref)
-
-    def update_library(
-        self,
-        ref: str,
-        *,
-        display_name: str | None = None,
-        description: str | None = None,
-        visibility: str | None = None,
-        default_machine: str | None = None,
-        execution: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """Deprecated alias of :meth:`library.update`."""
-
-        _warn_deprecated("SPLClient.update_library()", "SPLClient.library.update()")
-        return self.library.update(
-            ref,
-            display_name=display_name,
-            description=description,
-            visibility=visibility,
-            default_machine=default_machine,
-            execution=execution,
-        )
-
-    def delete_library(self, ref: str) -> dict[str, Any]:
-        """Deprecated alias of :meth:`library.delete`."""
-
-        _warn_deprecated("SPLClient.delete_library()", "SPLClient.library.delete()")
-        return self.library.delete(ref)
-
-    def grant_library(
-        self,
-        ref: str,
-        grantee: str,
-        *,
-        grantee_type: str = "user",
-        scopes: list[str] | None = None,
-    ) -> dict[str, Any]:
-        """Deprecated alias of :meth:`library.grant`."""
-
-        _warn_deprecated("SPLClient.grant_library()", "SPLClient.library.grant()")
-        return self.library.grant(
-            ref,
-            grantee,
-            grantee_type=grantee_type,
-            scopes=scopes,
-        )
-
-    def revoke_library_grant(self, ref: str, grantee: str) -> dict[str, Any]:
-        """Deprecated alias of :meth:`library.revoke`."""
-
-        _warn_deprecated(
-            "SPLClient.revoke_library_grant()", "SPLClient.library.revoke()",
-        )
-        return self.library.revoke(ref, grantee)
-
-    def add_reference(
-        self,
-        into_library: str,
-        name: str,
-        *,
-        owner: str | None = None,
-        from_library: str = "default",
-        version: str | int | None = "latest",
-        alias: str | None = None,
-    ) -> dict[str, Any]:
-        """Deprecated alias of :meth:`library.add_reference`."""
-
-        _warn_deprecated(
-            "SPLClient.add_reference()", "SPLClient.library.add_reference()",
-        )
-        return self.library.add_reference(
-            into_library,
-            name,
-            owner=owner,
-            from_library=from_library,
-            version=version,
-            alias=alias,
-        )
-
-    def copy_object(
-        self,
-        name: str,
-        *,
-        into_library: str,
-        from_owner: str | None = None,
-        from_library: str = "default",
-        version: str | int | None = "latest",
-        new_name: str | None = None,
-    ) -> dict[str, Any]:
-        """Deprecated alias of :meth:`library.copy_object`."""
-
-        _warn_deprecated("SPLClient.copy_object()", "SPLClient.library.copy_object()")
-        return self.library.copy_object(
-            name,
-            into_library=into_library,
-            from_owner=from_owner,
-            from_library=from_library,
-            version=version,
-            new_name=new_name,
-        )
-
-    def remove_entry(self, library: str, name: str) -> dict[str, Any]:
-        """Deprecated alias of :meth:`library.remove_entry`."""
-
-        _warn_deprecated("SPLClient.remove_entry()", "SPLClient.library.remove_entry()")
-        return self.library.remove_entry(library, name)
+    # The flat library aliases (create_library, get_library, update_library,
+    # delete_library, grant_library, revoke_library_grant, add_reference,
+    # copy_object, remove_entry) warned through 0.1.4/0.1.5 and were removed
+    # in 0.2.0 — use ``client.library.*`` (docs/migration-0.2.0.md).
 
     def register_env(self, name: str = "default", python: str | None = None) -> dict[str, Any]:
         """Register a Python executable as a daemon environment.
@@ -1019,41 +910,8 @@ class SPLClient:
             raw=record,
         )
 
-    def local_objects(self, *, compact: bool = False) -> list[dict[str, Any]]:
-        """Deprecated alias of :meth:`objects` with ``scope='local'``."""
-
-        _warn_deprecated("SPLClient.local_objects()", "SPLClient.objects(scope='local')")
-        return self._object_records(self.objects(scope="local", compact=compact))
-
-    def server_objects(
-        self,
-        *,
-        owner: str | None = None,
-        library: str | None = None,
-        compact: bool = False,
-    ) -> list[dict[str, Any]]:
-        """Deprecated alias of :meth:`objects` with ``scope='server'``."""
-
-        _warn_deprecated(
-            "SPLClient.server_objects()", "SPLClient.objects(scope='server')",
-        )
-        return list(
-            self.objects(
-                scope="server",
-                owner=owner,
-                library=library,
-                compact=compact,
-            )
-        )
-
-    @staticmethod
-    def _object_records(records: dict[str, Any] | list[dict[str, Any]]) -> list[dict[str, Any]]:
-        if isinstance(records, list):
-            return list(records)
-        return [
-            dict(record) if isinstance(record, dict) else {"name": name, "value": record}
-            for name, record in records.items()
-        ]
+    # ``local_objects()``/``server_objects()`` warned through 0.1.4/0.1.5 and
+    # were removed in 0.2.0 — use ``objects(scope='local'/'server')``.
 
     @overload
     def objects(
@@ -1335,7 +1193,7 @@ class SPLClient:
             pipeline = pipeline.name
 
         if isinstance(pipeline, NodeRemote):
-            if version is not None and pipeline.version not in {"", "latest", "current", "TODO"}:
+            if version is not None and pipeline.version not in {"", "latest", "current"}:
                 raise ValueError("pass the version either on NodeRemote or draw_pipeline(...), not both")
             response = self._remote_decomposition_response(pipeline, version=version)
             decomposition = response["decomposition"]
@@ -1557,11 +1415,8 @@ class SPLClient:
         )
         return RemoteRun(self, state, server_side=remote)
 
-    def start(self, name: str, **kwargs: Any) -> RemoteRun:
-        """Deprecated alias of :meth:`submit` (same signature and behavior)."""
-
-        _warn_deprecated("SPLClient.start()", "SPLClient.submit()")
-        return self._start_run(name, **kwargs)
+    # ``start()`` warned through 0.1.4/0.1.5 and was removed in 0.2.0 — use
+    # :meth:`submit` (same signature and behavior).
 
     def submit(
         self,
@@ -1599,38 +1454,8 @@ class SPLClient:
             source=source,
         )
 
-    def queue(
-        self,
-        name: str,
-        *,
-        args: list[Any] | None = None,
-        kwargs: dict[str, Any] | None = None,
-        output: str | None = None,
-        timeout_seconds: float | None = None,
-        target_machine: str,
-        owner: str | None = None,
-        library: str | None = None,
-        function: str | None = None,
-        source: RunSource = "auto",
-    ) -> RemoteRun:
-        """Deprecated alias of :meth:`submit` with ``offline_policy='queue'``."""
-
-        _warn_deprecated(
-            "SPLClient.queue()", "SPLClient.submit(..., offline_policy='queue')",
-        )
-        return self._start_run(
-            name,
-            args=args,
-            kwargs=kwargs,
-            output=output,
-            timeout_seconds=timeout_seconds,
-            target_machine=target_machine,
-            owner=owner,
-            library=library,
-            function=function,
-            offline_policy="queue",
-            source=source,
-        )
+    # ``queue()`` warned through 0.1.4/0.1.5 and was removed in 0.2.0 — use
+    # ``submit(..., offline_policy='queue')``.
 
     def call(
         self,
@@ -1647,6 +1472,7 @@ class SPLClient:
         offline_policy: OfflinePolicy | None = None,
         function: str | None = None,
         source: RunSource = "auto",
+        progress: ProgressOption = True,
     ) -> RemoteResult:
         """Run an object, wait for completion, and return result/artifacts.
 
@@ -1654,6 +1480,11 @@ class SPLClient:
         call.  Passing ``target_machine``, ``owner``, or ``library`` makes it a
         server-side remote run through the daemon.  The returned
         ``RemoteResult.mode`` is therefore either ``"local"`` or ``"server"``.
+
+        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.
         """
 
         run = self._start_run(
@@ -1672,6 +1503,7 @@ class SPLClient:
         return run.collect(
             artifacts_dir=artifacts_dir,
             timeout_seconds=timeout_seconds,
+            progress=progress,
         )
 
     def _run_node_value(
@@ -1691,66 +1523,9 @@ class SPLClient:
         )
         return response.get("value")
 
-    def run_node(
-        self,
-        node: Any,
-        kwargs: dict[str, Any],
-        *,
-        timeout_seconds: float | None = None,
-    ) -> Any:
-        """Deprecated: run a ``NodeRemote`` directly.
-
-        Wire the node into a pipeline instead:
-        ``Deployment(client, lift(node)...).run(...)``.
-        """
-
-        _warn_deprecated(
-            "SPLClient.run_node()",
-            "Deployment(client, pipeline).run(...) with NodeRemote.locate(...)",
-        )
-        return self._run_node_value(node, kwargs, timeout_seconds=timeout_seconds)
-
-    def run_node_result(
-        self,
-        node: Any,
-        *,
-        kwargs: dict[str, Any] | None = None,
-        timeout_seconds: float | None = None,
-    ) -> RemoteResult:
-        """Deprecated: run a ``NodeRemote`` and return metadata plus the value.
-
-        Wire the node into a pipeline instead:
-        ``Deployment(client, pipeline).run(...)``.
-        """
-
-        _warn_deprecated(
-            "SPLClient.run_node_result()",
-            "Deployment(client, pipeline).run(...) with NodeRemote.locate(...)",
-        )
-        payload = self._remote_node_payload(node)
-        response = self._daemon.run_remote_node(
-            payload,
-            kwargs=kwargs or {},
-            timeout_seconds=timeout_seconds,
-        )
-        value = response.get("value")
-        raw_payload = response.get("payload")
-        result_payload = dict(raw_payload) if isinstance(raw_payload, dict) else {}
-        result_payload["result"] = value
-        result_payload.setdefault("artifacts", response.get("artifacts") or {})
-
-        run = response.get("run")
-        if not isinstance(run, dict):
-            run = {
-                "id": response.get("run_id"),
-                "status": response.get("status") or "succeeded",
-            }
-        return RemoteResult(
-            run=run,
-            payload=result_payload,
-            mode="server",
-            downloaded_artifacts={},
-        )
+    # ``run_node()``/``run_node_result()`` warned through 0.1.4/0.1.5 and were
+    # removed in 0.2.0 — wire the node into a pipeline instead:
+    # ``Deployment(client, lift(NodeRemote.locate(...))...).run(...)``.
 
     def _is_node_remote(self, value: Any) -> bool:
         try:

splime-0.2.0/src/spl/_deprecate.py

@@ -0,0 +1,36 @@
+"""Uniform deprecation warnings for the 0.2.0 API cleanup (WP-07).
+
+Central helper so every deprecated path speaks with one voice and tests can
+match one message shape.  See ``docs/migration-0.2.0.md`` for the old → new
+table and the removal schedule.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+
+def warn_deprecated(old: str, new: str, *, stacklevel: int = 3) -> None:
+    """Emit a uniform ``DeprecationWarning`` pointing callers to ``new``.
+
+    ``stacklevel=3`` attributes the warning to the caller of the deprecated
+    API (helper frame + deprecated function frame are skipped).
+    """
+
+    warnings.warn(
+        f"{old} is deprecated; use {new} instead.",
+        DeprecationWarning,
+        stacklevel=stacklevel,
+    )
+
+
+def warn_deprecated_import(old_module: str, new_module: str) -> None:
+    """Emit a ``DeprecationWarning`` from a legacy import-location shim."""
+
+    warnings.warn(
+        f"importing from {old_module} is deprecated; "
+        f"import from {new_module} instead. "
+        f"The {old_module} shim will be removed in 0.3.0.",
+        DeprecationWarning,
+        stacklevel=3,
+    )

splime-0.2.0/src/spl/client.py

@@ -0,0 +1,65 @@
+"""Deprecated import location — the implementation lives in ``spl._client``.
+
+``from spl.client import SPLClient`` keeps working through 0.2.x, but the
+canonical spelling is ``from spl import SPLClient``.  This shim warns once on
+import and will be removed in 0.3.0 (see ``docs/migration-0.2.0.md``).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from spl import _client as _impl
+from spl._client import (  # noqa: F401 - legacy re-exports, kept intentionally.
+    ObjectCatalog as ObjectCatalog,
+    ObjectList as ObjectList,
+    ObjectScope as ObjectScope,
+    ObjectTable as ObjectTable,
+    OfflinePolicy as OfflinePolicy,
+    ProgressOption as ProgressOption,
+    PublishedObject as PublishedObject,
+    RemoteResult as RemoteResult,
+    RemoteRun as RemoteRun,
+    RunSource as RunSource,
+    SPLClient as SPLClient,
+    build_runtime_config as build_runtime_config,
+    export_object_to_yaml as export_object_to_yaml,
+    export_objects_to_yaml as export_objects_to_yaml,
+    prepare_export_object as prepare_export_object,
+    read_yaml_input as read_yaml_input,
+)
+from spl._deprecate import warn_deprecated_import
+
+# Keep ``from spl.client import *`` scoped to the curated legacy surface
+# (without ``__all__`` the star-import would also leak ``Any`` and
+# ``warn_deprecated_import`` into the caller's namespace).
+__all__ = [
+    "ObjectCatalog",
+    "ObjectList",
+    "ObjectScope",
+    "ObjectTable",
+    "OfflinePolicy",
+    "ProgressOption",
+    "PublishedObject",
+    "RemoteResult",
+    "RemoteRun",
+    "RunSource",
+    "SPLClient",
+    "build_runtime_config",
+    "export_object_to_yaml",
+    "export_objects_to_yaml",
+    "prepare_export_object",
+    "read_yaml_input",
+]
+
+warn_deprecated_import("spl.client", "spl")
+
+
+def __getattr__(name: str) -> Any:
+    """Delegate remaining lookups so legacy code keeps working unchanged."""
+
+    return getattr(_impl, name)
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(dir(_impl)))

splime-0.2.0/src/spl/core/common.py

@@ -0,0 +1,46 @@
+"""Deprecated import location — the implementation lives in ``spl.core._common``.
+
+``from spl.core.common import Deployment, lift`` keeps working through 0.2.x,
+but the canonical spelling is ``from spl import Deployment, lift``.  This shim
+warns once on import and will be removed in 0.3.0 (see
+``docs/migration-0.2.0.md``).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from spl._deprecate import warn_deprecated_import
+from spl.core import _common as _impl
+from spl.core._common import (  # noqa: F401 - legacy re-exports, kept intentionally.
+    Deployment as Deployment,
+    PipelineBuilder as PipelineBuilder,
+    Run as Run,
+    decode as decode,
+    encode as encode,
+    lift as lift,
+)
+
+# Keep ``from spl.core.common import *`` scoped to the curated legacy surface
+# (without ``__all__`` the star-import would also leak ``Any`` and
+# ``warn_deprecated_import`` into the caller's namespace).
+__all__ = [
+    "Deployment",
+    "PipelineBuilder",
+    "Run",
+    "decode",
+    "encode",
+    "lift",
+]
+
+warn_deprecated_import("spl.core.common", "spl")
+
+
+def __getattr__(name: str) -> Any:
+    """Delegate remaining lookups so legacy code keeps working unchanged."""
+
+    return getattr(_impl, name)
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(dir(_impl)))