letify 2.1.3__tar.gz → 2.2.0__tar.gz

{letify-2.1.3 → letify-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 2.1.3
+Version: 2.2.0
 Summary: Declarations that become infrastructure.
 Project-URL: Homepage, https://github.com/DarkPyonix/letify
 Project-URL: Documentation, https://github.com/DarkPyonix/letify/tree/main/docs

{letify-2.1.3 → letify-2.2.0}/letify/__init__.py

@@ -62,7 +62,7 @@ remote: Final = Host.remote
 # The enum class stays importable from letify.declare.instance for letify's own use.
 del Host
 
-__version__ = "2.1.3"
+__version__ = "2.2.0"
 
 
 def fetch(tensor):  # type: ignore[no-untyped-def]

{letify-2.1.3 → letify-2.2.0}/letify/protocol/worker.py

@@ -64,6 +64,21 @@ widen_pipe(_FRAME_FD)
 _SENDER = (TextSender if _LETIFY_TEXT_FRAMES else Sender)(fd_writer(_FRAME_FD))
 
 
+#: Written to a captured descriptor to find out where its reader has got to. A pipe is
+#: read in order, so every byte written before this has been framed once it is reached.
+#: It is never forwarded. Spec "Worker output".
+_DRAIN_TOKEN = b"\x1a\x1aLETIFY-DRAIN-7f3a9c4e\x1a\x1a"
+
+
+def _held_back(data):
+    """How many bytes at the end of ``data`` could be the start of a split token."""
+    most = min(len(_DRAIN_TOKEN) - 1, len(data))
+    for size in range(most, 0, -1):
+        if _DRAIN_TOKEN.startswith(data[len(data) - size:]):
+            return size
+    return 0
+
+
 class _Pump(threading.Thread):
     """Reads one captured descriptor and sends what it reads as output frames."""
 
@@ -71,10 +86,23 @@ class _Pump(threading.Thread):
         threading.Thread.__init__(self, daemon=True)
         self.kind = kind
         self.busy = False
+        self.fd = fd
+        #: Bytes withheld because they may be the start of a token split across two reads.
+        self.tail = b""
+        self.reached = threading.Event()
         self.read_fd, write_fd = os.pipe()
         os.dup2(write_fd, fd)
         os.close(write_fd)
 
+    def send(self, data):
+        if not data:
+            return
+        self.busy = True
+        try:
+            _SENDER.frame(self.kind, 0, data)
+        finally:
+            self.busy = False
+
     def run(self):
         while True:
             try:
@@ -83,16 +111,48 @@ class _Pump(threading.Thread):
                 break
             if not data:
                 break
-            self.busy = True
+            data = self.tail + data
+            self.tail = b""
             try:
-                _SENDER.frame(self.kind, 0, data)
+                while True:
+                    at = data.find(_DRAIN_TOKEN)
+                    if at < 0:
+                        break
+                    self.send(data[:at])
+                    data = data[at + len(_DRAIN_TOKEN):]
+                    self.reached.set()
+                keep = _held_back(data)
+                if keep:
+                    self.tail = data[len(data) - keep:]
+                    data = data[: len(data) - keep]
+                self.send(data)
             except OSError:
                 break
-            finally:
-                self.busy = False
         os.close(self.read_fd)
 
 
+def _drain_output(timeout=2.0):
+    """Wait until everything written to the captured descriptors has been framed.
+
+    Spec "Worker output": a call's reply waits for the output its body made, so the
+    caller's own next print comes after it. Waiting on the reading thread's state is not
+    enough, because it has read bytes it has not yet framed; the token goes through the
+    pipe behind those bytes instead. It gives up rather than lose a result.
+    """
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.flush()
+        except Exception:
+            pass
+    for pump in _PUMPS:
+        pump.reached.clear()
+        try:
+            os.write(pump.fd, _DRAIN_TOKEN)
+        except OSError:
+            continue
+        pump.reached.wait(timeout)
+
+
 _PUMPS = [_Pump(1, STDOUT), _Pump(2, STDERR)]
 for _pump in _PUMPS:
     _pump.start()
@@ -2066,6 +2126,9 @@ def _run(stream, request, settle):
     request = None
     if settle:
         _settle()
+    if name == "call":
+        # Spec "Worker output": the body's output is framed before its result goes out.
+        _drain_output()
     _reply(stream, outcome)
 
 

{letify-2.1.3 → letify-2.2.0}/letify/providers/base.py

@@ -273,6 +273,17 @@ class Provider(abc.ABC):
         value = self.config.option("transfer_streams")
         return max(1, int(value)) if isinstance(value, (int, float)) else STREAMS
 
+    @property
+    def transfer_connection_cost_s(self) -> float:
+        """Seconds one more transfer connection takes to open.
+
+        Spec "Several connections at once": zero where the provider dials an address, so
+        the extra connections are free and only the round trip decides. A provider reached
+        by a hole punch overrides it, because each stream punches again.
+        """
+        value = self.config.option("transfer_connection_cost_s")
+        return max(0.0, float(value)) if isinstance(value, (int, float)) else 0.0
+
     @property
     def transfer_parallel_rtt_ms(self) -> int:
         """The round trip above which a blob is split, from ``transfer_parallel_rtt_ms``.

{letify-2.1.3 → letify-2.2.0}/letify/providers/kaggle.py

@@ -1207,6 +1207,45 @@ class Kaggle(Provider):
             name=name,
         )
 
+    @property
+    def transfer_connection_cost_s(self) -> float:
+        """A punch, which is what one more stream costs here. Measured at about 10 s."""
+        value = self.config.option("transfer_connection_cost_s")
+        return max(0.0, float(value)) if isinstance(value, (int, float)) else 10.0
+
+    def link(self, runtime: Runtime | None = None) -> Any:
+        """The link carrying this runtime, or None when the bridge is carrying it.
+
+        The placement reads ``rtt_ms`` from it to decide how many streams to use.
+        """
+        name = getattr(runtime, "name", None)
+        return self._links.get(name) if name else None
+
+    def transfer_channel(self, runtime: Runtime | None) -> Channel:
+        """One more stream for a placement, on a connection of its own.
+
+        Spec "Several connections at once": the link is asked for its own SSH command,
+        which lands on a local forwarding port of its own and so punches again. Reusing
+        the session's command would multiplex onto the one connection instead, and
+        multiplexed channels do not add up.
+        """
+        import shlex as _shlex
+
+        from ..protocol.worker import BOOTSTRAP
+        from ..runtime.channel import PersistentChannel
+
+        name = getattr(runtime, "name", None)
+        link = self._links.get(name) if name else None
+        if link is None:
+            raise UnsupportedMode(
+                f"{self.alias} is carried by the kernel bridge for {name}, which is one "
+                f"connection and offers no second stream. A punched session does."
+            )
+        return PersistentChannel(
+            link.ssh_command(f"{self.remote_python} -u -c {_shlex.quote(BOOTSTRAP)}"),
+            name=f"{self.alias}-transfer",
+        )
+
     def open_channel(self, runtime: Runtime) -> Channel:
         """Start a session from the cookie and open one worker in one cell of it.
 

{letify-2.1.3 → letify-2.2.0}/letify/runtime/bootstrap.py

@@ -130,6 +130,16 @@ def project_dir(workspace_root: str, env: Env) -> str:
     return f"{workspace_root.rstrip('/')}/project/{env.key}"
 
 
+def packages_in(files: dict[str, bytes]) -> int:
+    """How many packages the lock names, for the line the environment build prints.
+
+    The lock is already read, so counting its ``[[package]]`` entries costs nothing and
+    tells the reader whether to expect seconds or minutes. Spec "Environment".
+    """
+    lock = files.get("uv.lock") or b""
+    return lock.count(b"[[package]]")
+
+
 def project_files(env: Env) -> dict[str, bytes]:
     """Read the files a runtime syncs from, refusing what cannot give a matching interpreter.
 

{letify-2.1.3 → letify-2.2.0}/letify/runtime/session.py

@@ -613,6 +613,19 @@ class Runtime:
 
         return (environment_volume(self.provider),)
 
+    def _say(self, message: str) -> None:
+        """One decision line about this runtime, as the transport's lines are written.
+
+        Spec "Environment": the build says it is happening. Silent when the launcher was
+        built with ``announce=False``.
+        """
+        from ..transport.announce import printer
+
+        # On the instance dict, not getattr: a provider's __getattr__ answers accelerator
+        # names and raises UnknownInstance for anything else, which no default catches.
+        announce = self.provider.__dict__.get("announce", True)
+        printer(bool(announce))(f"{self.name}: {message}")
+
     def install_env(self) -> None:
         """Build the project's environment in the session and move the worker onto it.
 
@@ -641,6 +654,7 @@ class Runtime:
             digest = volume.cached_env(self.env, self.platform)
             if not digest:
                 continue
+            self._say(f"restoring the environment, cached as {digest[:12]}")
             archive = f"{where['parent']}/.{digest}.tar.gz"
             volume.materialize(
                 self, digest, path=archive, unpack=True, target=where["parent"], links=True
@@ -658,6 +672,13 @@ class Runtime:
                 self.env, files, root=root, name=self.name, workspace=workspace,
                 archive=bool(archives),
             )
+            # Spec "Environment": the longest step of a first session, and uv's own output
+            # is captured rather than streamed, so it says it is happening.
+            self._say(
+                f"building the environment, {bootstrap.packages_in(files)} packages "
+                f"from {self.env.lock}"
+            )
+            began = time.monotonic()
             try:
                 self.eval(source, timeout=3600)
             except RemoteError as exc:
@@ -665,6 +686,7 @@ class Runtime:
                 raise EnvironmentFailure(
                     message.removeprefix("RuntimeError: "), stderr=exc.remote_traceback
                 ) from exc
+            self._say(f"environment built in {time.monotonic() - began:.1f} s")
             self.env_source = "sync"
         self.python = where["python"]
         self.channel.switch_interpreter(where["python"])

{letify-2.1.3 → letify-2.2.0}/letify/store/pathdata.py

@@ -801,19 +801,38 @@ class Stream:
             )
 
 
-def streams_for(*, streams: int, threshold_mib: int, rtt_ms: float | None, size: int) -> int:
+def streams_for(
+    *,
+    streams: int,
+    threshold_mib: int,
+    rtt_ms: float | None,
+    size: int,
+    rate_bps: float | None = None,
+    cost_s: float = 0.0,
+) -> int:
     """How many connections this blob is worth splitting across.
 
     Spec "Several connections at once": one below the size threshold, because opening
     connections to send a few megabytes costs more than it saves; one on a short link,
-    because there a single stream already carries everything the link will carry; and
-    never more streams than there are chunks to send.
+    because there a single stream already carries everything the link will carry; never
+    more streams than there are chunks to send; and, when a connection costs something to
+    open, only as many as finish the transfer sooner than one would.
     """
     if streams <= 1 or size < threshold_mib * (1 << 20):
         return 1
     if rtt_ms is None or rtt_ms < PARALLEL_RTT_MS:
         return 1
-    return max(1, min(streams, (size + CHUNK - 1) // CHUNK))
+    count = max(1, min(streams, (size + CHUNK - 1) // CHUNK))
+    if cost_s > 0 and count > 1:
+        if not rate_bps or rate_bps <= 0:
+            # Nothing to weigh the cost against, and the cost is real, so do not pay it.
+            return 1
+        alone = size / rate_bps
+        # The connections are opened at the same time, so the cost is paid once.
+        together = size / (rate_bps * count) + cost_s
+        if together >= alone:
+            return 1
+    return count
 
 
 def _streams_for(runtime: Any, size: int) -> int:
@@ -832,9 +851,16 @@ def _streams_for(runtime: Any, size: int) -> int:
         rtt = getattr(link, "rtt_ms", None)
     except Exception:
         rtt = None
+    rate = None
+    try:
+        rate = getattr(link, "upload_bps", None)
+    except Exception:
+        rate = None
     return streams_for(
         streams=int(getattr(provider, "transfer_streams", STREAMS) or 1),
         threshold_mib=int(getattr(provider, "transfer_parallel_mib", PARALLEL_MIB) or 0),
+        rate_bps=rate,
+        cost_s=float(getattr(provider, "transfer_connection_cost_s", 0.0) or 0.0),
         rtt_ms=rtt,
         size=size,
     )

{letify-2.1.3 → letify-2.2.0}/letify/transport/link.py

@@ -34,6 +34,9 @@ class Link:
         self.rank = rank
         #: The round trip the pipeline measured over this link, when it measured one.
         self.rtt_ms: float | None = None
+        #: The probe's upload rate, which the placement weighs a connection's cost
+        #: against. Spec "Several connections at once".
+        self.upload_bps: float | None = None
 
     def probe_stream(self) -> object | None:
         """A stream the probe can run over, or None when this link cannot carry it."""

{letify-2.1.3 → letify-2.2.0}/letify/transport/pipeline.py

@@ -209,6 +209,19 @@ def _below(pairs: Sequence[tuple[str, float, float]], ratio: float, against: str
     ]
 
 
+def _measured_on(link: Any, measured: ProbeResult | None) -> Any:
+    """Record on the link what the probe measured, and return the link.
+
+    Every path out of ``connect`` goes through this, because the placement reads
+    ``rtt_ms`` to decide how many connections to use and a link with none keeps a single
+    stream. Spec "Several connections at once".
+    """
+    if measured is not None:
+        link.rtt_ms = measured.rtt_ms
+        link.upload_bps = measured.upload_bps
+    return link
+
+
 def _close(link: Any) -> None:
     try:
         link.close()
@@ -308,7 +321,7 @@ class Pipeline:
                             [*reasons, f"{link.strategy}: below the floor: {', '.join(floored)}"]
                         ),
                     )
-            return link
+            return _measured_on(link, measured)
 
         network = self.fingerprint() if self.cache is not None else None
         if self.cache is not None and network is not None:
@@ -324,9 +337,9 @@ class Pipeline:
             f"{skipped_note}{held_note}"
         )
         link, measured = self._race(applicable, reasons)
-        if measured is not None:
-            # Kept on the link so status can say how far away the machine is.
-            link.rtt_ms = measured.rtt_ms
+        # Kept on the link so status can say how far away the machine is, and so the
+        # placement knows whether splitting a blob across connections is worth it.
+        _measured_on(link, measured)
         if self.cache is not None and network is not None and measured is not None:
             self.cache.save(link.strategy, measured, network)
             self._say(f"cache rewritten: {link.strategy}")
@@ -394,7 +407,7 @@ class Pipeline:
             _close(link)
             return None
         self._say(f"cached {name} accepted")
-        return link
+        return _measured_on(link, measured)
 
     # -- the race ------------------------------------------------------------
 

{letify-2.1.3 → letify-2.2.0}/letify-core/Cargo.lock

@@ -138,7 +138,7 @@ dependencies = [
 
 [[package]]
 name = "letify-agent"
-version = "2.1.3"
+version = "2.2.0"
 dependencies = [
  "letify-wire",
  "libloading",
@@ -146,7 +146,7 @@ dependencies = [
 
 [[package]]
 name = "letify-driver"
-version = "2.1.3"
+version = "2.2.0"
 dependencies = [
  "letify-wire",
 ]
@@ -164,7 +164,7 @@ dependencies = [
 
 [[package]]
 name = "letify-wire"
-version = "2.1.3"
+version = "2.2.0"
 
 [[package]]
 name = "libc"

{letify-2.1.3 → letify-2.2.0}/letify-core/Cargo.toml

@@ -8,7 +8,7 @@ resolver = "3"
 members = ["letify-wire", "letify-driver", "letify-agent", "letify-quic"]
 
 [workspace.package]
-version = "2.1.3"
+version = "2.2.0"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/DarkPyonix/letify"

{letify-2.1.3 → letify-2.2.0}/letify-ext/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "letify-status",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "letify-status",
-      "version": "2.1.3",
+      "version": "2.2.0",
       "license": "SEE LICENSE IN LICENSE",
       "devDependencies": {
         "@types/node": "^18.19.0",

{letify-2.1.3 → letify-2.2.0}/letify-ext/package.json

@@ -2,7 +2,7 @@
   "name": "letify-status",
   "displayName": "letify Status",
   "description": "letify quota and GPU activity in the status bar, read from the letify CLI.",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "publisher": "darkpyonix",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

{letify-2.1.3 → letify-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "letify"
-version = "2.1.3"
+version = "2.2.0"
 description = "Declarations that become infrastructure."
 readme = "README.md"
 requires-python = ">=3.11"

{letify-2.1.3 → letify-2.2.0}/tests/test_core.py

@@ -553,3 +553,55 @@ def test_status_reports_the_inventory_against_what_is_reserved(launcher_from) ->
     let = launcher_from('[lab]\nkind = "local"\n[lab.devices]\nCPU = { count = 2 }\n')
     report = let.status()
     assert report["devices"]["lab"]["CPU"] == {"count": 2, "reserved": 0, "indices": []}
+
+
+def test_the_output_of_a_call_comes_before_what_the_caller_prints_next(let, cpu, capsys) -> None:
+    """Spec "Worker output": a call's reply waits for the output the body made.
+
+    The worker frames output on a thread of its own, so the reply could overtake it and
+    the caller's next print would land first, which is what a terminal shows out of order.
+    A live CI run failed the weaker form of this with `assert 'epoch 1 loss 0.5' in ''`.
+    """
+
+    @let.function(device=cpu, host=letify.remote)
+    def noisy() -> int:
+        for index in range(200):
+            print(f"line {index} of the body")
+        return 7
+
+    assert noisy() == 7
+    print("the caller speaks after the call")
+    out = capsys.readouterr().out
+    assert "line 0 of the body" in out
+    assert "line 199 of the body" in out
+    assert out.index("line 199 of the body") < out.index("the caller speaks after the call")
+
+
+def test_output_that_looks_like_the_drain_token_still_arrives(let, cpu, capsys) -> None:
+    """Spec "Worker output": the token is never forwarded, and output is never eaten.
+
+    The reader withholds a tail that could be the start of a split token, so a body whose
+    own output ends in that prefix must still see all of it arrive.
+    """
+    import re
+
+    from letify.protocol import worker
+
+    found = re.search(r'_DRAIN_TOKEN = b"([^"]+)"', worker.SOURCE)
+    assert found, "the worker no longer names a drain token"
+    token = found.group(1).encode().decode("unicode_escape")
+    prefix = token[: len(token) - 1]
+
+    @let.function(device=cpu, host=letify.remote)
+    def speaks(text: str) -> int:
+        import sys
+
+        sys.stdout.write("before|" + text)
+        sys.stdout.flush()
+        sys.stdout.write("|after\n")
+        return len(text)
+
+    assert speaks(prefix) == len(prefix)
+    out = capsys.readouterr().out
+    assert "before|" in out and "|after" in out
+    assert token not in out

{letify-2.1.3 → letify-2.2.0}/tests/test_kaggle_link.py

@@ -6,8 +6,10 @@ the strategies of Choosing a link are raced over it.
 
 from __future__ import annotations
 
+import pytest
 from conftest import provider_of
 
+from letify.errors import UnsupportedMode
 from letify.providers.kaggle import Kaggle
 
 
@@ -243,3 +245,57 @@ def test_a_kaggle_runtime_pins_its_host_key_under_its_own_alias() -> None:
     assert target.host_key_alias == "letify-kaggle_a-letify-cpu-abc123"
     command = target.forwarded_ssh(40000)
     assert command[command.index("HostKeyAlias=letify-kaggle_a-letify-cpu-abc123")]
+
+
+def test_a_punched_kaggle_transfer_stream_asks_the_link_for_a_connection(monkeypatch) -> None:
+    """Spec "Several connections at once": each stream gets a connection of its own.
+
+    Multiplexed channels do not add up. Measured on one punched Kaggle link at a 193 ms
+    round trip, four concurrent `ssh cat > /dev/null`, each asking the link for its own
+    command, carried 6.10 MiB/s against 1.57 MiB/s for one, while four channels
+    multiplexed onto the session's command carried 1.14 times one.
+    """
+    built: list[list[str]] = []
+    asked: list[str] = []
+    provider = kaggle()
+
+    class Link:
+        """Each ssh_command lands on a port of its own, as a punched link's does."""
+
+        strategy = "tcp_punch"
+        rtt_ms = 138.0
+
+        def ssh_command(self, remote_command=None):
+            asked.append("session" if not asked else "transfer")
+            return ["ssh", "-p", str(40000 + len(asked)), "root@127.0.0.1",
+                    remote_command or ""]
+
+    class Fake:
+        def __init__(self, command, name=None, **kwargs):
+            built.append(command)
+            self.name = name
+
+    class Runtime:
+        name = "k-1"
+
+    monkeypatch.setattr(provider, "link_over", lambda channel, name=None: Link())
+    monkeypatch.setattr("letify.runtime.channel.PersistentChannel", Fake)
+    provider.channel_over(object(), name="k-1")
+    assert provider.link(Runtime()).rtt_ms == 138.0
+
+    provider.transfer_channel(Runtime())
+    assert len(built) == 2
+    assert built[1] != built[0], "a transfer channel asks the link for a command of its own"
+    assert asked == ["session", "transfer"]
+
+
+def test_a_kaggle_session_on_the_bridge_offers_no_transfer_channel() -> None:
+    """Spec: a session that never punched is carried by the bridge, which has no second channel."""
+    provider = kaggle()
+
+    class Runtime:
+        name = "never-punched"
+
+    assert provider.link(Runtime()) is None
+    with pytest.raises(UnsupportedMode):
+        provider.transfer_channel(Runtime())

{letify-2.1.3 → letify-2.2.0}/tests/test_parallel_placement.py

@@ -304,14 +304,13 @@ def test_an_account_sets_the_round_trip_threshold() -> None:
 
 def test_a_provider_with_no_transfer_channel_keeps_one_stream() -> None:
     # Spec "Several connections at once": a provider whose channel is not a connection it
-    # can open more of, such as Modal's sandbox pipes or Kaggle's kernel bridge, has no
-    # transfer channel, and asking it for one would fail inside the placement.
-    from letify.providers.kaggle import Kaggle
+    # can open more of, such as Modal's sandbox pipes, has no transfer channel, and asking
+    # it for one would fail inside the placement. Kaggle has one, because a session that
+    # punched is reached over SSH and the link can punch again for each stream.
     from letify.providers.modal import Modal
     from letify.store import pathdata
 
-    for cls in (Modal, Kaggle):
-        assert not hasattr(cls, "transfer_channel"), cls.__name__
+    assert not hasattr(Modal, "transfer_channel")
 
     class Bare:
         transfer_streams = 4
@@ -349,3 +348,38 @@ def test_the_guard_does_not_go_through_a_provider_lookup() -> None:
         provider = Picky()
 
     assert pathdata._streams_for(Runtime(), 256 << 20) == 1
+
+
+def test_streams_that_cost_a_connection_are_opened_only_when_they_pay() -> None:
+    """Spec "Several connections at once": a connection that costs something pays for itself.
+
+    A Kaggle runtime at a 44.7 ms round trip carried 128 MiB at 21.0 MiB/s on one stream
+    and 9.5 MiB/s on four, because three more hole punches cost more than the transfer
+    saved.
+    """
+    from letify.store.pathdata import streams_for
+
+    MIB = 1 << 20
+    near = dict(streams=4, threshold_mib=64, rtt_ms=44.7, size=128 * MIB)
+    # Free connections: the near link still splits, as a forward SSH account does.
+    assert streams_for(**near, rate_bps=56.8 * MIB, cost_s=0.0) == 4
+    # A punch each: 128 MiB at 56.8 MiB/s takes 2.3 s, and one punch alone costs 10 s.
+    assert streams_for(**near, rate_bps=56.8 * MIB, cost_s=10.0) == 1
+    # Far and slow enough that the punch is worth it.
+    assert streams_for(
+        streams=4, threshold_mib=64, rtt_ms=193.0, size=1024 * MIB,
+        rate_bps=12.8 * MIB, cost_s=10.0,
+    ) == 4
+    # No rate to estimate with: the cost cannot be weighed, so one stream.
+    assert streams_for(**near, rate_bps=None, cost_s=10.0) == 1
+
+
+def test_a_provider_reports_what_one_more_connection_costs() -> None:
+    """Spec: 0 for a provider that dials an address, about 10 for one reached by a punch."""
+    from conftest import provider_of
+
+    from letify.providers.kaggle import Kaggle
+    from letify.providers.shell import Shell
+
+    assert float(provider_of(Shell, "dept_gpu").transfer_connection_cost_s) == 0.0
+    assert float(provider_of(Kaggle, "kaggle_a").transfer_connection_cost_s) >= 5.0