fal 1.49.3__tar.gz → 1.50.0__tar.gz

{fal-1.49.3/fal.egg-info → fal-1.50.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: fal
-Version: 1.49.3
+Version: 1.50.0
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: isolate[build]<0.21.0,>=0.18.0
-Requires-Dist: isolate-proto<0.20.0,>=0.19.0
+Requires-Dist: isolate-proto<0.23.0,>=0.22.0
 Requires-Dist: grpcio<2,>=1.64.0
 Requires-Dist: dill==0.3.7
 Requires-Dist: cloudpickle==3.0.0

{fal-1.49.3 → fal-1.50.0/fal.egg-info}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: fal
-Version: 1.49.3
+Version: 1.50.0
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: isolate[build]<0.21.0,>=0.18.0
-Requires-Dist: isolate-proto<0.20.0,>=0.19.0
+Requires-Dist: isolate-proto<0.23.0,>=0.22.0
 Requires-Dist: grpcio<2,>=1.64.0
 Requires-Dist: dill==0.3.7
 Requires-Dist: cloudpickle==3.0.0

{fal-1.49.3 → fal-1.50.0}/fal.egg-info/requires.txt

@@ -1,5 +1,5 @@
 isolate[build]<0.21.0,>=0.18.0
-isolate-proto<0.20.0,>=0.19.0
+isolate-proto<0.23.0,>=0.22.0
 grpcio<2,>=1.64.0
 dill==0.3.7
 cloudpickle==3.0.0

{fal-1.49.3 → fal-1.50.0}/pyproject.toml

@@ -23,7 +23,7 @@ readme = "README.md"
 requires-python = ">=3.8"
 dependencies = [
     "isolate[build]>=0.18.0,<0.21.0",
-    "isolate-proto>=0.19.0,<0.20.0",
+    "isolate-proto>=0.22.0,<0.23.0",
     "grpcio>=1.64.0,<2",
     "dill==0.3.7",
     "cloudpickle==3.0.0",

{fal-1.49.3 → fal-1.50.0}/src/fal/_fal_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.49.3'
-__version_tuple__ = version_tuple = (1, 49, 3)
+__version__ = version = '1.50.0'
+__version_tuple__ = version_tuple = (1, 50, 0)
 
 __commit_id__ = commit_id = None

{fal-1.49.3 → fal-1.50.0}/src/fal/api/client.py

@@ -66,6 +66,12 @@ class _RunnersNamespace:
     def list(self, *, since=None) -> List[RunnerInfo]:
         return runners_api.list_runners(self.client, since=since)
 
+    def stop(self, runner_id: str) -> None:
+        return runners_api.stop_runner(self.client, runner_id)
+
+    def kill(self, runner_id: str) -> None:
+        return runners_api.kill_runner(self.client, runner_id)
+
 
 @dataclass
 class SyncServerlessClient:

{fal-1.49.3 → fal-1.50.0}/src/fal/api/runners.py

@@ -14,3 +14,13 @@ def list_runners(
 ) -> List[RunnerInfo]:
     with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
         return conn.list_runners(start_time=since)
+
+
+def stop_runner(client: SyncServerlessClient, runner_id: str) -> None:
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        conn.stop_runner(runner_id)
+
+
+def kill_runner(client: SyncServerlessClient, runner_id: str) -> None:
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        conn.kill_runner(runner_id)

{fal-1.49.3 → fal-1.50.0}/src/fal/cli/runners.py

@@ -1,12 +1,23 @@
 from __future__ import annotations
 
+import argparse
+import fcntl
 import json
+import os
+import signal
+import struct
+import sys
+import termios
+import tty
 from collections import deque
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from http import HTTPStatus
+from queue import Empty, Queue
+from threading import Thread
 from typing import Iterator, List
 
+import grpc
 import httpx
 from httpx_sse import connect_sse
 from rich.console import Console
@@ -14,7 +25,7 @@ from structlog.typing import EventDict
 
 from fal.api.client import SyncServerlessClient
 from fal.rest_client import REST_CLIENT
-from fal.sdk import FalServerlessClient, RunnerInfo, RunnerState
+from fal.sdk import RunnerInfo, RunnerState
 
 from .parser import FalClientParser, SinceAction, get_output_parser
 
@@ -95,12 +106,108 @@ def runners_requests_table(runners: list[RunnerInfo]):
     return table
 
 
+def _get_tty_size():
+    """Get current terminal dimensions."""
+    try:
+        h, w = struct.unpack("HH", fcntl.ioctl(0, termios.TIOCGWINSZ, b"\0" * 4))[:2]
+        return h, w
+    except (OSError, ValueError):
+        return 24, 80  # Fallback to standard size
+
+
+def _shell(args):
+    """Execute interactive shell in runner."""
+    import isolate_proto
+
+    client = SyncServerlessClient(host=args.host, team=args.team)
+    stub = client._create_host()._connection.stub
+    runner_id = args.id
+
+    # Setup terminal for raw mode
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+    tty.setraw(fd)
+
+    # Message queue for stdin data and resize events
+    messages = Queue()  # type: ignore
+    stop_flag = False
+
+    def handle_resize(*_):
+        messages.put(("resize", None))
+
+    signal.signal(signal.SIGWINCH, handle_resize)
+
+    def read_stdin():
+        """Read stdin in a background thread."""
+        nonlocal stop_flag
+        while not stop_flag:
+            try:
+                data = os.read(fd, 4096)
+                if not data:
+                    break
+                messages.put(("data", data))
+            except OSError:
+                break
+
+    reader = Thread(target=read_stdin, daemon=True)
+    reader.start()
+
+    def stream_inputs():
+        """Generate input stream for gRPC."""
+        # Send initial message with runner_id and terminal size
+        msg = isolate_proto.ShellRunnerInput(runner_id=runner_id)
+        h, w = _get_tty_size()
+        msg.tty_size.height = h
+        msg.tty_size.width = w
+        yield msg
+
+        # Stream stdin data and resize events
+        while True:
+            try:
+                msg_type, data = messages.get(timeout=0.1)
+            except Empty:
+                continue
+
+            if msg_type == "data":
+                yield isolate_proto.ShellRunnerInput(data=data)
+            elif msg_type == "resize":
+                msg = isolate_proto.ShellRunnerInput()
+                h, w = _get_tty_size()
+                msg.tty_size.height = h
+                msg.tty_size.width = w
+                yield msg
+
+    exit_code = 1
+    try:
+        for output in stub.ShellRunner(stream_inputs()):
+            if output.HasField("exit_code"):
+                exit_code = output.exit_code
+                break
+            if output.data:
+                sys.stdout.buffer.write(output.data)
+                sys.stdout.buffer.flush()
+            if output.close:
+                break
+        exit_code = exit_code or 0
+    except grpc.RpcError as exc:
+        args.console.print(f"\n[red]Connection error:[/] {exc.details()}")
+    except Exception as exc:
+        args.console.print(f"\n[red]Error:[/] {exc}")
+    finally:
+        stop_flag = True
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+    return exit_code
+
+
+def _stop(args):
+    client = SyncServerlessClient(host=args.host, team=args.team)
+    client.runners.stop(args.id)
+
+
 def _kill(args):
     client = SyncServerlessClient(host=args.host, team=args.team)
-    with FalServerlessClient(
-        client._grpc_host, client._credentials
-    ).connect() as connection:
-        connection.kill_runner(args.id)
+    client.runners.kill(args.id)
 
 
 def _list_json(args, runners: list[RunnerInfo]):
@@ -161,6 +268,21 @@ def _list(args):
         raise AssertionError(f"Invalid output format: {args.output}")
 
 
+def _add_stop_parser(subparsers, parents):
+    stop_help = "Stop a runner gracefully."
+    parser = subparsers.add_parser(
+        "stop",
+        description=stop_help,
+        help=stop_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "id",
+        help="Runner ID.",
+    )
+    parser.set_defaults(func=_stop)
+
+
 def _add_kill_parser(subparsers, parents):
     kill_help = "Kill a runner."
     parser = subparsers.add_parser(
@@ -546,6 +668,17 @@ def _add_logs_parser(subparsers, parents):
     parser.set_defaults(func=_logs)
 
 
+def _add_shell_parser(subparsers, parents):
+    """Add hidden shell command parser."""
+    parser = subparsers.add_parser(
+        "shell",
+        help=argparse.SUPPRESS,
+        parents=parents,
+    )
+    parser.add_argument("id", help="Runner ID.")
+    parser.set_defaults(func=_shell)
+
+
 def add_parser(main_subparsers, parents):
     runners_help = "Manage fal runners."
     parser = main_subparsers.add_parser(
@@ -563,6 +696,8 @@ def add_parser(main_subparsers, parents):
         parser_class=FalClientParser,
     )
 
+    _add_stop_parser(subparsers, parents)
     _add_kill_parser(subparsers, parents)
     _add_list_parser(subparsers, parents)
     _add_logs_parser(subparsers, parents)
+    _add_shell_parser(subparsers, parents)

{fal-1.49.3 → fal-1.50.0}/src/fal/logging/__init__.py

@@ -7,11 +7,6 @@ from structlog.typing import EventDict, WrappedLogger
 
 from .style import LEVEL_STYLES
 
-# Unfortunately structlog console processor does not support
-# more general theming as a public API. Consider a PR on the
-# structlog repo to add better support for it.
-structlog.dev._ColorfulStyles.bright = ""
-
 
 class DebugConsoleLogProcessor:
     """

{fal-1.49.3 → fal-1.50.0}/src/fal/sdk.py

@@ -884,6 +884,10 @@ class FalServerlessConnection:
             for secret in response.secrets
         ]
 
+    def stop_runner(self, runner_id: str) -> None:
+        request = isolate_proto.StopRunnerRequest(runner_id=runner_id)
+        self.stub.StopRunner(request)
+
     def kill_runner(self, runner_id: str) -> None:
         request = isolate_proto.KillRunnerRequest(runner_id=runner_id)
         self.stub.KillRunner(request)

{fal-1.49.3 → fal-1.50.0}/src/fal/toolkit/file/providers/fal.py

@@ -56,21 +56,44 @@ def _should_retry(exc: Exception) -> bool:
     return False
 
 
+class _RetryingRequestContext:
+    def __init__(self, request: Request, kwargs: dict[str, Any]):
+        self.request = request
+        self.kwargs = kwargs
+        self._cm: Any | None = None
+        self._response: addinfourl | None = None
+
+    def __enter__(self) -> addinfourl:
+        def _enter_once() -> addinfourl:
+            # Obtain the original context manager and explicitly enter it
+            self._cm = _urlopen(self.request, **self.kwargs)
+            return self._cm.__enter__()
+
+        _enter_with_retry = retry(
+            max_retries=MAX_ATTEMPTS,
+            base_delay=BASE_DELAY,
+            max_delay=MAX_DELAY,
+            backoff_type="exponential",
+            jitter=True,
+            should_retry=_should_retry,
+        )(_enter_once)
+
+        self._response = _enter_with_retry()
+        assert self._response is not None
+        return self._response
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
+        if self._cm is not None:
+            return self._cm.__exit__(exc_type, exc_val, exc_tb)
+        return False
+
+
 @contextmanager
 def _maybe_retry_request(
     request: Request,
     **kwargs: Any,
 ) -> Generator[addinfourl, None, None]:
-    _urlopen_with_retry = retry(
-        max_retries=MAX_ATTEMPTS,
-        base_delay=BASE_DELAY,
-        max_delay=MAX_DELAY,
-        backoff_type="exponential",
-        jitter=True,
-        should_retry=_should_retry,
-    )(_urlopen)
-
-    with _urlopen_with_retry(request, **kwargs) as response:
+    with _RetryingRequestContext(request, kwargs) as response:
         yield response
 
 

{fal-1.49.3 → fal-1.50.0}/tests/test_apps.py

@@ -31,6 +31,7 @@ from fal.exceptions import (
 )
 from fal.exceptions._cuda import _CUDA_OOM_MESSAGE, _CUDA_OOM_STATUS_CODE
 from fal.rest_client import REST_CLIENT
+from fal.sdk import RunnerState
 from fal.toolkit.utils.endpoint import cancel_on_disconnect
 from fal.workflows import Workflow
 
@@ -1004,7 +1005,70 @@ def test_field_exception_billing(test_exception_app: AppClient):
         assert not hasattr(response.headers, "x-fal-billable-units")
 
 
+def test_stop_runner(host: api.FalServerlessHost, test_sleep_app: str):
+    def submit_and_wait_for_runner():
+        handle = apps.submit(test_sleep_app, arguments={"wait_time": 1})
+
+        while True:
+            status = handle.status()
+            if isinstance(status, apps.InProgress):
+                break
+            elif isinstance(status, apps.Queued):
+                time.sleep(1)
+            else:
+                raise Exception(f"Failed to start the app: {status}")
+
+        return handle
+
+    # Submit a runner and wait for it to be idle
+    submit_and_wait_for_runner()
+
+    with host._connection as client:
+        timeout = 10
+        start_time = time.time()
+        while True:
+            _, _, app_alias = test_sleep_app.partition("/")
+            runners = client.list_alias_runners(app_alias)
+            assert len(runners) == 1
+
+            if runners[0].in_flight_requests == 0:
+                break
+            elif time.time() - start_time > timeout:
+                raise Exception(f"Timeout waiting for runner to be idle: {runners[0]}")
+            time.sleep(1)
+
+    # Because the runner is not requested to be stopped, it should be reused
+    submit_and_wait_for_runner()
+
+    with host._connection as client:
+        _, _, app_alias = test_sleep_app.partition("/")
+        runners = client.list_alias_runners(app_alias)
+        assert len(runners) == 1
+
+    # Request to stop the runner
+    with host._connection as client:
+        with pytest.raises(Exception) as e:
+            client.stop_runner("1234567890")
+
+        assert "not found" in str(e).lower()
+
+        _, _, app_alias = test_sleep_app.partition("/")
+        runners = client.list_alias_runners(app_alias)
+        assert len(runners) == 1
+
+        client.stop_runner(runners[0].runner_id)
+
+    # Because the runner is requested to be stopped,
+    # it should not be reused and a new runner should be created
+    submit_and_wait_for_runner()
+
+    with host._connection as client:
+        runners = client.list_alias_runners(app_alias)
+        assert len(runners) == 2
+
+
 def test_kill_runner(host: api.FalServerlessHost, test_sleep_app: str):
+    # Kill all the replicas of the app that is already running
     handle = apps.submit(test_sleep_app, arguments={"wait_time": 10})
 
     while True:
@@ -1024,13 +1088,52 @@ def test_kill_runner(host: api.FalServerlessHost, test_sleep_app: str):
 
         _, _, app_alias = test_sleep_app.partition("/")
         runners = client.list_alias_runners(app_alias)
-        assert len(runners) == 1
+        existing_runners = len(
+            [runner for runner in runners if runner.state == RunnerState.RUNNING]
+        )
 
         client.kill_runner(runners[0].runner_id)
 
         runners = client.list_alias_runners(app_alias)
-        num_runners = len([runner for runner in runners if runner.state == "running"])
-        assert num_runners == 0
+        num_runners = len(
+            [runner for runner in runners if runner.state == RunnerState.RUNNING]
+        )
+        assert num_runners == existing_runners - 1
+
+
+def test_shell_runner(host: api.FalServerlessHost, test_sleep_app: str):
+    handle = apps.submit(test_sleep_app, arguments={"wait_time": 30})
+
+    while True:
+        status = handle.status()
+        if isinstance(status, apps.InProgress):
+            break
+        elif isinstance(status, apps.Queued):
+            time.sleep(1)
+        else:
+            raise Exception(f"Failed to start the app: {status}")
+
+    with host._connection as client:
+        _, _, app_alias = test_sleep_app.partition("/")
+        runners = client.list_alias_runners(app_alias)
+        assert len(runners) == 1
+        runner_id = runners[0].runner_id
+
+        proc = subprocess.Popen(
+            ["python", "-m", "fal", "runners", "shell", runner_id],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        try:
+            commands = b"echo 'a' > t.txt\ncat t.txt\nexit\n"
+            stdout, stderr = proc.communicate(input=commands, timeout=10)
+            assert b"a" in stdout, f"Expected 'a' in output, got: {stdout.decode()}"
+        finally:
+            if proc.poll() is None:
+                proc.kill()
+                proc.wait()
 
 
 def test_container_app_client(test_container_app: str):

{fal-1.49.3 → fal-1.50.0}/tests/toolkit/file/providers/test_fal_retry.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from unittest import mock
-from urllib.error import HTTPError
+from urllib.error import HTTPError, URLError
 from urllib.request import Request
 
 import pytest
@@ -163,3 +163,42 @@ def test_max_retries_exhausted_for_retryable_errors():
 
         assert exc_info.value.code == 500
         assert call_count == 5
+
+
+def test_retry_on_urlerror_during_context_enter():
+    request = Request("https://example.com/test")
+
+    calls = {"open": 0, "enter": 0}
+
+    class EnterRaisesOnce:
+        def __init__(self):
+            self.data = b'{"result": "success"}'
+            self.headers = {"Content-Type": "application/json"}
+
+        def read(self):
+            return self.data
+
+        def __enter__(self):
+            calls["enter"] += 1
+            if calls["enter"] == 1:
+                raise URLError("Temporary failure in name resolution")
+            return self
+
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            return False
+
+    def mock_urlopen_side_effect(*args, **kwargs):
+        calls["open"] += 1
+        return EnterRaisesOnce()
+
+    with mock.patch(
+        "fal.toolkit.file.providers.fal._urlopen", side_effect=mock_urlopen_side_effect
+    ):
+        with mock.patch("fal.toolkit.utils.retry.time.sleep"):
+            # Expect success after a retry (second __enter__ returns normally)
+            with _maybe_retry_request(request) as response:
+                assert response is not None
+
+    # Should have attempted to open at least twice due to retry
+    assert calls["open"] >= 2
+    assert calls["enter"] >= 2