letify 2.1.3__tar.gz → 2.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 2.1.3
+Version: 2.3.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.3.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.3.0"
 
 
 def fetch(tensor):  # type: ignore[no-untyped-def]

{letify-2.1.3 → letify-2.3.0}/letify/launcher.py

@@ -486,7 +486,7 @@ class Launcher:
         for alias in self.config.order:
             try:
                 provider = self.provider(alias)
-                supported = provider.kind == "colab"
+                supported = provider.discovers_sessions
                 rows.append(
                     {
                         "alias": alias,

{letify-2.1.3 → letify-2.3.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.3.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``.
@@ -343,10 +354,48 @@ class Provider(abc.ABC):
             return table[name]
         if name.upper() in table:
             return table[name.upper()]
+        retired = self.retired_reason(name)
+        if retired:
+            raise UnknownInstance(f"{self.alias} does not offer {name!r}. {retired}")
         raise UnknownInstance(
             f"{self.alias} does not offer {name!r}. Available: {', '.join(sorted(table))}"
         )
 
+    #: Whether this provider can be asked what sessions the account already holds. A
+    #: launcher reads it rather than naming provider kinds. Spec "Kaggle", finding the
+    #: notebooks letify owns.
+    discovers_sessions: bool = False
+
+    def sessions(self) -> list[str]:
+        """What the account already holds, for a provider that can be asked.
+
+        Empty for one that cannot, and empty rather than raising when the answer cannot be
+        read: a command asking what exists should not fail because nothing answered.
+        """
+        return []
+
+    def expected_cards(self, instance: Any) -> tuple[str, int] | None:
+        """The card name fragment and count a session for ``instance`` must have, or None.
+
+        None means the provider gives what it is asked for, so there is nothing to check.
+        A provider whose service may answer with another card overrides it. Spec "Kaggle",
+        the accelerators.
+        """
+        return None
+
+    @property
+    def any_accelerator(self) -> bool:
+        """Whether a card other than the one asked for is accepted, from ``any_accelerator``."""
+        return self.config.option("any_accelerator") is True
+
+    def retired_reason(self, name: str) -> str | None:
+        """Why an accelerator this provider once offered is gone, or None.
+
+        A name the provider's service answers with a different card belongs here rather
+        than in the inventory, because a declaration states where a function runs.
+        """
+        return None
+
     def device(self, name: str) -> Instance:
         """Look up an accelerator by name."""
         return getattr(self, name)

{letify-2.1.3 → letify-2.3.0}/letify/providers/colab.py

@@ -300,6 +300,8 @@ class Colab(Shell):
                 stderr=exc.stderr,
             ) from exc
 
+    discovers_sessions = True
+
     def sessions(self) -> list[str]:
         """Names of the sessions this account currently holds."""
         names = []

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

@@ -32,6 +32,7 @@ import urllib.parse
 import urllib.request
 from collections.abc import Mapping
 from datetime import UTC, datetime
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from .. import tools
@@ -67,13 +68,20 @@ if TYPE_CHECKING:
     from ..runtime.session import Runtime
 
 #: GPU session shapes, with memory per card, device count and the internal API name.
-#: P100 remains available through the API although the web UI no longer lists it.
 #: CPU is the empty compute, so it carries no accelerator name.
 GPUS = {
-    "P100": {"vram_gb": 16, "devices": 1, "accelerator": "NVIDIA_TESLA_P100"},
-    "T4": {"vram_gb": 16, "devices": 2, "accelerator": "NVIDIA_TESLA_T4"},
+    "T4": {"vram_gb": 16, "devices": 2, "accelerator": "NVIDIA_TESLA_T4", "model": "T4"},
 }
 TPUS = ("TPU_V3_8",)
+#: Cards Kaggle no longer serves, and what it does instead. Offering one would let a
+#: declaration say P100 and run on something else: spec "Kaggle", the accelerators.
+RETIRED = {
+    "P100": (
+        "Kaggle retired the Tesla P100 on 2026-09-15 and switches a notebook that asks "
+        "for it to two T4s, so the card and the card count would both differ from the "
+        "declaration. Use T4, which is two cards of 16 GB"
+    ),
+}
 
 #: The internal Kaggle service surface the web app uses, authenticated by the session cookie.
 KAGGLE_INTERNAL = "https://www.kaggle.com/api/i/"
@@ -504,6 +512,9 @@ def live_session_url(
     403 on it is the account's own answer, not a stale notebook's.
     """
     kernel, slug = new_notebook(alias, cookie)
+    # Spec "Kaggle", finding the notebooks letify owns: recorded before anything can fail,
+    # so a run that dies next still leaves a trail to its notebook.
+    record_notebook(alias, slug)
     run = start_run(cookie, kernel, accelerator)
     id_token = firebase_id_token(cookie)
     webtier = webtier_session(cookie, id_token, run)
@@ -554,6 +565,116 @@ def read_notebook_owner(alias: str) -> str | None:
     return owner or None
 
 
+def notebook_record(alias: str) -> Path:
+    """Where the refs of the notebooks letify created on this account are kept."""
+    return account_directory(alias) / "notebooks"
+
+
+def recorded_notebooks(alias: str) -> list[str]:
+    """The refs letify believes it created, in the order it created them."""
+    try:
+        text = notebook_record(alias).read_text(encoding="utf-8")
+    except OSError:
+        return []
+    seen: list[str] = []
+    for line in text.splitlines():
+        ref = line.strip()
+        if ref and ref not in seen:
+            seen.append(ref)
+    return seen
+
+
+def record_notebook(alias: str, slug: str | None) -> None:
+    """Note that letify created this notebook, so a later process can still find it.
+
+    Spec "Kaggle", finding the notebooks letify owns: Kaggle names the notebook itself, so
+    the record is the only thing that tells letify's from the user's own. Never raises; a
+    notebook letify cannot record is one it may fail to clean up, not a failed run.
+    """
+    username = read_notebook_owner(alias)
+    if not slug or username is None:
+        return
+    try:
+        path = notebook_record(alias)
+        path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        with path.open("a", encoding="utf-8") as handle:
+            handle.write(f"{username}/{slug}\n")
+    except OSError:
+        pass
+
+
+def forget_notebook(alias: str, slug: str | None) -> None:
+    """Drop a notebook from the record, once it is gone from the account."""
+    username = read_notebook_owner(alias)
+    if not slug or username is None:
+        return
+    ref = f"{username}/{slug}"
+    kept = [line for line in recorded_notebooks(alias) if line != ref]
+    try:
+        notebook_record(alias).write_text(
+            "".join(f"{line}\n" for line in kept), encoding="utf-8"
+        )
+    except OSError:
+        pass
+
+
+def notebooks_on_account(alias: str) -> list[str] | None:
+    """The refs the account has, through the official CLI, or None when it cannot be asked.
+
+    None and an empty list mean different things: nothing answered, against the account
+    having no notebooks. Never raises.
+    """
+    if read_api_token(alias) is None:
+        return None
+    uv = tools.find_uv()
+    if uv is None:
+        return None
+    import csv
+    import io
+    import subprocess
+
+    try:
+        result = subprocess.run(
+            [*tools.kaggle_cli_command(uv), "kernels", "list", "--mine", "--csv"],
+            env=tools.kaggle_cli_environment(alias),
+            capture_output=True,
+            text=True,
+            timeout=REST_TIMEOUT,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if result.returncode != 0:
+        return None
+    try:
+        rows = list(csv.DictReader(io.StringIO(result.stdout or "")))
+    except csv.Error:
+        return None
+    return [(row.get("ref") or "").strip() for row in rows if (row.get("ref") or "").strip()]
+
+
+def list_notebooks_via_cli(alias: str) -> list[str]:
+    """The recorded notebooks this account still has. Spec "Kaggle", finding them.
+
+    A ref the record names and the account no longer has was deleted elsewhere, so it is
+    dropped from the record rather than reported.
+    """
+    recorded = recorded_notebooks(alias)
+    if not recorded:
+        return []
+    present = notebooks_on_account(alias)
+    if present is None:
+        return []
+    live = [ref for ref in recorded if ref in set(present)]
+    if live != recorded:
+        try:
+            notebook_record(alias).write_text(
+                "".join(f"{ref}\n" for ref in live), encoding="utf-8"
+            )
+        except OSError:
+            pass
+    return live
+
+
 def delete_notebook_via_cli(alias: str, slug: str | None) -> bool:
     """Delete the ephemeral notebook through the official CLI, the only way it is deleted.
 
@@ -596,6 +717,7 @@ def delete_notebook_best_effort(alias: str, kernel_id: int, slug: str | None) ->
     slug or id, never by its cookie, so the user can delete it by hand on kaggle.com.
     """
     if delete_notebook_via_cli(alias, slug):
+        forget_notebook(alias, slug)
         return
     import sys
 
@@ -1025,6 +1147,24 @@ class Kaggle(Provider):
         table.update({name: Instance(self, tpu=name) for name in TPUS})
         return table
 
+    discovers_sessions = True
+
+    def sessions(self) -> list[str]:
+        """The notebooks letify owns on this account, which is where an orphan shows up."""
+        return list_notebooks_via_cli(self.alias)
+
+    def expected_cards(self, instance: Any) -> tuple[str, int] | None:
+        """What a Kaggle session must have, because Kaggle may answer with another card."""
+        gpu = getattr(instance, "gpu", None)
+        spec = GPUS.get(gpu) if gpu else None
+        if spec is None:
+            return None
+        return str(spec["model"]), int(spec["devices"])
+
+    def retired_reason(self, name: str) -> str | None:
+        """Why Kaggle no longer serves a card it once did. Spec "Kaggle", the accelerators."""
+        return RETIRED.get(name.upper())
+
     def store_backend(self) -> str:
         return "filesystem"
 
@@ -1207,6 +1347,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.3.0}/letify/runtime/bootstrap.py

@@ -130,6 +130,34 @@ def project_dir(workspace_root: str, env: Env) -> str:
     return f"{workspace_root.rstrip('/')}/project/{env.key}"
 
 
+#: Reads the cards a runtime has, without nvidia-smi, which a Kaggle image lacks on PATH.
+#: Spec "Kaggle", the accelerators.
+CARD_SOURCE = (
+    "import glob\n"
+    "__letify_cards = []\n"
+    "for _letify_path in sorted(glob.glob('/proc/driver/nvidia/gpus/*/information')):\n"
+    "    try:\n"
+    "        with open(_letify_path) as _letify_handle:\n"
+    "            for _letify_line in _letify_handle:\n"
+    "                if _letify_line.startswith('Model:'):\n"
+    "                    __letify_cards.append(_letify_line.split(':', 1)[1].strip())\n"
+    "                    break\n"
+    "    except OSError:\n"
+    "        pass\n"
+    "__letify_value__ = __letify_cards\n"
+)
+
+
+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.
 
@@ -148,6 +176,15 @@ def project_files(env: Env) -> dict[str, bytes]:
                 f"pyproject.toml and uv.lock, and {directory.resolve()} has no {name}. "
                 f"Run 'uv lock' in the project first"
             )
+    lock = files.get("uv.lock") or b""
+    if b'name = "letify"' not in lock and b'name = "cloudpickle"' not in lock:
+        raise ConfigError(
+            f"the worker unpickles a declared body with cloudpickle, and a body that uses "
+            f"letify's own names imports letify on the runtime, so "
+            f"{(directory / 'uv.lock').resolve()} has to name letify or at least cloudpickle. "
+            f"It names neither, and the session would fail there with ModuleNotFoundError. "
+            f"Add letify to the project and run 'uv lock' again"
+        )
     local = local_python()
     pinned = files.get(".python-version")
     if pinned is not None:

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

@@ -130,6 +130,7 @@ class Runtime:
             self.worker_pid = int(self.stat()["pid"])
             self.provider.add_worker_pid(self.worker_pid)
         self.restrict_devices()
+        self.check_devices()
         if self.provider.needs_lease:
             self.lease = Lease(self)
             self.lease.arm()
@@ -613,6 +614,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 +655,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 +673,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,10 +687,48 @@ 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"])
 
+    def check_devices(self) -> None:
+        """Refuse a session whose cards are not the ones the instance asked for.
+
+        Spec "Kaggle", the accelerators: a provider may answer a request with a different
+        card. Run before the environment is built, so a wrong card costs seconds rather
+        than the minutes a sync takes.
+        """
+        from ..errors import InsufficientDevices
+        from . import bootstrap
+
+        instance = getattr(self, "instance", None)
+        expected = self.provider.expected_cards(instance)
+        if expected is None:
+            return
+        fragment, count = expected
+        try:
+            cards = self.eval(bootstrap.CARD_SOURCE, timeout=120)
+        except Exception:
+            # Reading /proc is not worth failing a session over when it cannot be read.
+            return
+        cards = [str(card) for card in cards or ()]
+        matched = [card for card in cards if fragment.casefold() in card.casefold()]
+        if len(matched) == count and len(cards) == count:
+            return
+        asked = getattr(instance, "accelerator", None) or fragment
+        arrived = ", ".join(cards) if cards else "no GPU at all"
+        message = (
+            f"{self.name}: {self.provider.alias} was asked for {count} x {asked} and the "
+            f"session has {arrived}. A declaration says where a function runs, so the "
+            f"session is not used. Set any_accelerator = true on the account to accept "
+            f"whatever card it is given"
+        )
+        if self.provider.any_accelerator:
+            self._say(f"card mismatch accepted: asked {count} x {asked}, got {arrived}")
+            return
+        raise InsufficientDevices(message)
+
     def check_interpreter(self) -> None:
         """Refuse a worker whose Python major.minor differs from this process."""
         from . import bootstrap

{letify-2.1.3 → letify-2.3.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.3.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."""