letify 2.4.5__tar.gz → 2.4.7__tar.gz

{letify-2.4.5 → letify-2.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 2.4.5
+Version: 2.4.7
 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.4.5 → letify-2.4.7}/letify/__init__.py

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

{letify-2.4.5 → letify-2.4.7}/letify/providers/kaggle.py

@@ -1508,10 +1508,15 @@ class Kaggle(Provider):
             )
             return bridge
         self._links[name] = link
-        return PersistentChannel(
-            link.ssh_command(f"{self.remote_python} -u -c {_shlex.quote(BOOTSTRAP)}"),
-            name=name,
-        )
+        # Spec "Kaggle runtimes": the kernel finds libcuda through LD_LIBRARY_PATH and a
+        # worker started over SSH does not inherit it, so it is read through the bridge and
+        # set in the command's environment. The loader reads it when the process starts, so
+        # setting it from inside the worker would be too late.
+        remote = f"{self.remote_python} -u -c {_shlex.quote(BOOTSTRAP)}"
+        libraries = self.kernel_library_path(bridge)
+        if libraries:
+            remote = f"env LD_LIBRARY_PATH={_shlex.quote(libraries)} {remote}"
+        return PersistentChannel(link.ssh_command(remote), name=name)
 
     @property
     def min_session_interval_s(self) -> float:
@@ -1538,6 +1543,19 @@ class Kaggle(Provider):
         value = self.config.option("transfer_connection_cost_s")
         return max(0.0, float(value)) if isinstance(value, (int, float)) else 10.0
 
+    def kernel_library_path(self, bridge: Any) -> str:
+        """The kernel's own ``LD_LIBRARY_PATH``, asked through the bridge, or empty.
+
+        Spec "Kaggle runtimes". Never raises: a session whose bridge cannot answer is one
+        letify should still try, and the card check refuses it when CUDA cannot start.
+        """
+        source = "import os\n__letify_value__ = os.environ.get('LD_LIBRARY_PATH') or ''\n"
+        try:
+            value, _ = bridge.request({"op": "eval", "source": source}, timeout=60)
+        except Exception:
+            return ""
+        return value.strip() if isinstance(value, str) else ""
+
     def link(self, runtime: Runtime | None = None) -> Any:
         """The link carrying this runtime, or None when the bridge is carrying it.
 

{letify-2.4.5 → letify-2.4.7}/letify/runtime/bootstrap.py

@@ -146,9 +146,26 @@ CARD_SOURCE = (
     "        pass\n"
     # /proc can list the right cards on a session whose driver cannot be used, and the
     # first .to('cuda') then raises minutes into the call. Spec "Kaggle".
+    # cuInit is the call CUDA initialization makes, so it answers whether the driver
+    # works rather than standing in for it: a live session had the cards and the control
+    # device and still could not start CUDA. ctypes needs no torch, which the session does
+    # not have yet at this point. Spec "Kaggle".
+    # A CUresult is 0 or positive, so a sentinel of -1 would read as one. The load and
+    # the call are reported apart instead. Spec "Kaggle".
+    "__letify_libcuda = False\n"
+    "__letify_cuda = None\n"
+    "try:\n"
+    "    import ctypes as _letify_ctypes\n"
+    "    _letify_lib = _letify_ctypes.CDLL('libcuda.so.1')\n"
+    "    __letify_libcuda = True\n"
+    "    __letify_cuda = _letify_lib.cuInit(0)\n"
+    "except Exception:\n"
+    "    pass\n"
     "__letify_value__ = {\n"
     "    'cards': __letify_cards,\n"
     "    'driver': os.path.exists('/dev/nvidiactl'),\n"
+    "    'libcuda': __letify_libcuda,\n"
+    "    'cuinit': __letify_cuda,\n"
     "}\n"
 )
 

{letify-2.4.5 → letify-2.4.7}/letify/runtime/session.py

@@ -720,11 +720,15 @@ class Runtime:
         except Exception:
             # Reading /proc is not worth failing a session over when it cannot be read.
             return
-        found = found if isinstance(found, dict) else {"cards": found, "driver": True}
+        if not isinstance(found, dict):
+            found = {"cards": found, "driver": True, "libcuda": True, "cuinit": 0}
         cards = [str(card) for card in found.get("cards") or ()]
         driver = bool(found.get("driver"))
+        libcuda = bool(found.get("libcuda", True))
+        cuinit = found.get("cuinit")
+        started = libcuda and cuinit == 0
         matched = [card for card in cards if fragment.casefold() in card.casefold()]
-        if len(matched) == count and len(cards) == count and driver:
+        if len(matched) == count and len(cards) == count and driver and started:
             return
         asked = getattr(instance, "accelerator", None) or fragment
         arrived = ", ".join(cards) if cards else "no GPU at all"
@@ -735,6 +739,21 @@ class Runtime:
                 f"{arrived}, and no usable driver: /dev/nvidiactl is not there, so CUDA "
                 f"cannot start"
             )
+        elif cards and not libcuda:
+            # Spec "Kaggle": the userspace driver library is not there at all, which is a
+            # different fault from CUDA refusing to start, and reads as a GPU session on a
+            # CPU image rather than as a CUDA error.
+            arrived = (
+                f"{arrived}, and no libcuda.so.1 to load: the cards are attached and the "
+                f"userspace driver library is missing, so nothing on this session can use "
+                f"them"
+            )
+        elif cards and not started:
+            arrived = (
+                f"{arrived}, and a driver that does not start: libcuda.so.1 loaded and "
+                f"cuInit returned {cuinit}, which is the call CUDA initialization makes, "
+                f"so nothing on this session can use those cards"
+            )
         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 "

{letify-2.4.5 → letify-2.4.7}/letify-core/Cargo.lock

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

{letify-2.4.5 → letify-2.4.7}/letify-core/Cargo.toml

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

{letify-2.4.5 → letify-2.4.7}/letify-ext/package-lock.json

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

{letify-2.4.5 → letify-2.4.7}/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.4.5",
+  "version": "2.4.7",
   "publisher": "darkpyonix",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

{letify-2.4.5 → letify-2.4.7}/pyproject.toml

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

{letify-2.4.5 → letify-2.4.7}/tests/test_kaggle.py

@@ -1489,10 +1489,90 @@ def test_a_session_with_the_cards_and_a_driver_passes() -> None:
     session.name = "letify-t4-ok"
     session.provider = provider
     session.instance = type("I", (), {"gpu": "T4", "accelerator": "T4"})()
-    answer = {"cards": ["Tesla T4", "Tesla T4"], "driver": True}
+    answer = {"cards": ["Tesla T4", "Tesla T4"], "driver": True, "cuinit": 0}
     monkey = lambda self, source, timeout=None: answer  # noqa: E731
     Runtime.eval, original = monkey, Runtime.eval
     try:
         session.check_devices()
     finally:
         Runtime.eval = original
+
+
+def test_a_session_whose_cuinit_fails_is_refused() -> None:
+    """Spec "Kaggle": cuInit is the call CUDA initialization makes.
+
+    A live session listed both T4s and had /dev/nvidiactl, and the first .cuda() still
+    raised "Found no NVIDIA driver on your system" after 30 GB of shards had been sent.
+    """
+    from letify.errors import InsufficientDevices
+    from letify.runtime.session import Runtime
+
+    provider = kaggle_provider()
+    session = object.__new__(Runtime)
+    session.name = "letify-t4-fc7e27"
+    session.provider = provider
+    session.instance = type("I", (), {"gpu": "T4", "accelerator": "T4"})()
+    answer = {
+        "cards": ["Tesla T4", "Tesla T4"], "driver": True, "libcuda": True, "cuinit": 100
+    }
+    monkey = lambda self, source, timeout=None: answer  # noqa: E731
+    Runtime.eval, original = monkey, Runtime.eval
+    try:
+        with pytest.raises(InsufficientDevices) as failure:
+            session.check_devices()
+    finally:
+        Runtime.eval = original
+    message = str(failure.value)
+    assert "cuInit" in message
+    assert "100" in message
+
+
+def test_a_session_whose_cuinit_succeeds_passes() -> None:
+    """Spec: zero from cuInit is what CUDA starting looks like."""
+    from letify.runtime.session import Runtime
+
+    provider = kaggle_provider()
+    session = object.__new__(Runtime)
+    session.name = "letify-t4-ok"
+    session.provider = provider
+    session.instance = type("I", (), {"gpu": "T4", "accelerator": "T4"})()
+    answer = {
+        "cards": ["Tesla T4", "Tesla T4"], "driver": True, "libcuda": True, "cuinit": 0
+    }
+    monkey = lambda self, source, timeout=None: answer  # noqa: E731
+    Runtime.eval, original = monkey, Runtime.eval
+    try:
+        session.check_devices()
+    finally:
+        Runtime.eval = original
+
+
+def test_a_missing_libcuda_is_not_reported_as_a_cuda_error() -> None:
+    """Spec "Kaggle": a CUresult is 0 or positive, so a sentinel would read as one.
+
+    A live refusal said `cuInit returned -1`, which is not a CUresult at all: it was the
+    value for "libcuda.so.1 did not load", a different fault that reads as a GPU session
+    on a CPU image.
+    """
+    from letify.errors import InsufficientDevices
+    from letify.runtime.session import Runtime
+
+    provider = kaggle_provider()
+    session = object.__new__(Runtime)
+    session.name = "letify-t4-d3012a"
+    session.provider = provider
+    session.instance = type("I", (), {"gpu": "T4", "accelerator": "T4"})()
+    answer = {
+        "cards": ["Tesla T4", "Tesla T4"], "driver": True, "libcuda": False, "cuinit": None
+    }
+    monkey = lambda self, source, timeout=None: answer  # noqa: E731
+    Runtime.eval, original = monkey, Runtime.eval
+    try:
+        with pytest.raises(InsufficientDevices) as failure:
+            session.check_devices()
+    finally:
+        Runtime.eval = original
+    message = str(failure.value)
+    assert "no libcuda.so.1 to load" in message
+    assert "cuInit returned" not in message
+    assert "-1" not in message

{letify-2.4.5 → letify-2.4.7}/tests/test_kaggle_link.py

@@ -317,3 +317,44 @@ def test_kaggle_does_not_offer_the_retired_p100() -> None:
     message = str(failure.value)
     assert "2026-09-15" in message
     assert "T4" in message
+
+
+def test_the_worker_carries_the_kernel_s_library_path(monkeypatch) -> None:
+    """Spec "Kaggle runtimes": the loader reads LD_LIBRARY_PATH when the process starts.
+
+    A GPU session has its cards, its /dev/nvidia* nodes and a libcuda.so.1 at
+    /usr/local/nvidia/lib64 that ldconfig does not list. The kernel finds it through that
+    variable; a worker started over SSH does not inherit it, which the kernel bridge never
+    suffered and the punched link introduced.
+    """
+    built: list[list[str]] = []
+    provider = kaggle()
+
+    class Bridge:
+        def request(self, message, timeout=None):
+            source = message.get("source", "")
+            if "LD_LIBRARY_PATH" in source:
+                return "/usr/local/nvidia/lib64:/usr/local/cuda/lib64", None
+            return "", None
+
+    class Link:
+        strategy = "tcp_punch"
+        rtt_ms = 120.0
+
+        def ssh_command(self, remote_command=None):
+            return ["ssh", "-p", "40000", "root@127.0.0.1", remote_command or ""]
+
+    class Fake:
+        def __init__(self, command, name=None, **kwargs):
+            built.append(command)
+            self.name = name
+
+    monkeypatch.setattr(provider, "link_over", lambda channel, name=None: Link())
+    monkeypatch.setattr("letify.runtime.channel.PersistentChannel", Fake)
+    provider.channel_over(Bridge(), name="k-1")
+
+    remote = built[0][-1]
+    assert "LD_LIBRARY_PATH=" in remote
+    assert "/usr/local/nvidia/lib64" in remote
+    # Before the interpreter, or the loader has already read the environment.
+    assert remote.index("LD_LIBRARY_PATH=") < remote.index("python3")