fal 1.49.1__py3-none-any.whl → 1.57.2__py3-none-any.whl

fal/cli/runners.py

@@ -1,20 +1,33 @@
 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 typing import Iterator, List
+from queue import Empty, Queue
+from threading import Thread
+from typing import TYPE_CHECKING, Iterator, List
 
+if TYPE_CHECKING:
+    from openapi_fal_rest.client import Client
+
+import grpc
 import httpx
 from httpx_sse import connect_sse
 from rich.console import Console
 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 +108,111 @@ 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
+        yield isolate_proto.ShellRunnerInput(runner_id=runner_id)
+
+        # Send terminal size
+        msg = isolate_proto.ShellRunnerInput()
+        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]):
@@ -131,13 +243,24 @@ def _list(args):
     if args.state:
         states = set(args.state)
         if "all" not in states:
-            runners = [r for r in runners if r.state.value in states]
+            runners = [
+                r
+                for r in runners
+                if r.state.value.lower() in states
+                or (
+                    "terminated" in states and r.state.value.lower() == "dead"
+                )  # TODO for backwards compatibility. remove later
+            ]
 
     pending_runners = [
         runner for runner in runners if runner.state == RunnerState.PENDING
     ]
     setup_runners = [runner for runner in runners if runner.state == RunnerState.SETUP]
-    dead_runners = [runner for runner in runners if runner.state == RunnerState.DEAD]
+    terminated_runners = [
+        runner
+        for runner in runners
+        if runner.state == RunnerState.DEAD or runner.state == RunnerState.TERMINATED
+    ]
     if args.output == "pretty":
         args.console.print(
             "Runners: "
@@ -145,7 +268,7 @@ def _list(args):
                 len(runners)
                 - len(pending_runners)
                 - len(setup_runners)
-                - len(dead_runners)
+                - len(terminated_runners)
             )
         )
         args.console.print(f"Runners Pending: {len(pending_runners)}")
@@ -161,6 +284,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(
@@ -190,14 +328,14 @@ def _add_list_parser(subparsers, parents):
         action=SinceAction,
         limit="1 day",
         help=(
-            "Show dead runners since the given time. "
+            "Show terminated runners since the given time. "
             "Accepts 'now', relative like '30m', '1h', '1d', "
             "or an ISO timestamp. Max 24 hours."
         ),
     )
     parser.add_argument(
         "--state",
-        choices=["all", "running", "pending", "setup", "dead"],
+        choices=["all", "running", "pending", "setup", "terminated"],
         nargs="+",
         default=None,
         help=("Filter by runner state(s). Choose one or more, or 'all'(default)."),
@@ -256,10 +394,10 @@ class RestRunnerInfo:
     ended_at: datetime | None
 
 
-def _get_runner_info(runner_id: str) -> RestRunnerInfo:
-    headers = REST_CLIENT.get_headers()
+def _get_runner_info(rest_client: Client, runner_id: str) -> RestRunnerInfo:
+    headers = rest_client.get_headers()
     with httpx.Client(
-        base_url=REST_CLIENT.base_url, headers=headers, timeout=30
+        base_url=rest_client.base_url, headers=headers, timeout=30
     ) as client:
         resp = client.get(f"/runners/{runner_id}")
         if resp.status_code == HTTPStatus.NOT_FOUND:
@@ -293,16 +431,19 @@ def _get_runner_info(runner_id: str) -> RestRunnerInfo:
 
 
 def _stream_logs(
-    base_params: dict[str, str], since: datetime | None, until: datetime | None
+    rest_client: Client,
+    base_params: dict[str, str],
+    since: datetime | None,
+    until: datetime | None,
 ) -> Iterator[dict]:
-    headers = REST_CLIENT.get_headers()
+    headers = rest_client.get_headers()
     params: dict[str, str] = base_params.copy()
     if since is not None:
         params["since"] = _to_iso_naive(since)
     if until is not None:
         params["until"] = _to_iso_naive(until)
     with httpx.Client(
-        base_url=REST_CLIENT.base_url,
+        base_url=rest_client.base_url,
         headers=headers,
         timeout=None,
         follow_redirects=True,
@@ -329,11 +470,14 @@ DEFAULT_PAGE_SIZE = 1000
 
 
 def _iter_logs(
-    base_params: dict[str, str], start: datetime | None, end: datetime | None
+    rest_client: Client,
+    base_params: dict[str, str],
+    start: datetime | None,
+    end: datetime | None,
 ) -> Iterator[dict]:
-    headers = REST_CLIENT.get_headers()
+    headers = rest_client.get_headers()
     with httpx.Client(
-        base_url=REST_CLIENT.base_url,
+        base_url=rest_client.base_url,
         headers=headers,
         timeout=300,
         follow_redirects=True,
@@ -356,6 +500,7 @@ def _iter_logs(
 
 
 def _get_logs(
+    rest_client: Client,
     params: dict[str, str],
     since: datetime | None,
     until: datetime | None,
@@ -364,12 +509,12 @@ def _get_logs(
     oldest: bool = False,
 ) -> Iterator[dict]:
     if lines_count is None:
-        yield from _iter_logs(params, since, until)
+        yield from _iter_logs(rest_client, params, since, until)
         return
 
     if oldest:
         produced = 0
-        for log in _iter_logs(params, since, until):
+        for log in _iter_logs(rest_client, params, since, until):
             if produced >= lines_count:
                 break
             produced += 1
@@ -378,7 +523,7 @@ def _get_logs(
 
     # newest tail: collect into a fixed-size deque, then yield
     tail: deque[dict] = deque(maxlen=lines_count)
-    for log in _iter_logs(params, since, until):
+    for log in _iter_logs(rest_client, params, since, until):
         tail.append(log)
     for log in tail:
         yield log
@@ -421,7 +566,9 @@ def _logs(args):
     if args.search is not None:
         params["search"] = args.search
 
-    runner_info = _get_runner_info(args.id)
+    client = SyncServerlessClient(host=args.host, team=args.team)
+    rest_client = client._create_rest_client()
+    runner_info = _get_runner_info(rest_client, args.id)
     follow: bool = args.follow
     since = args.since
     if follow:
@@ -467,9 +614,11 @@ def _logs(args):
             args.parser.error("Invalid -n|--lines value. Use an integer or +integer.")
 
     if follow:
-        logs_gen = _stream_logs(params, since, until)
+        logs_gen = _stream_logs(rest_client, params, since, until)
     else:
-        logs_gen = _get_logs(params, since, until, lines_count, oldest=lines_oldest)
+        logs_gen = _get_logs(
+            rest_client, params, since, until, lines_count, oldest=lines_oldest
+        )
 
     printer = LogPrinter(args.console)
 
@@ -546,6 +695,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 +723,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/cli/secrets.py

@@ -1,12 +1,12 @@
-from ._utils import get_client
+from fal.api.client import SyncServerlessClient
+
 from .parser import DictAction, FalClientParser
 
 
 def _set(args):
-    client = get_client(args.host, args.team)
-    with client.connect() as connection:
-        for name, value in args.secrets.items():
-            connection.set_secret(name, value)
+    client = SyncServerlessClient(host=args.host, team=args.team)
+    for name, value in args.secrets.items():
+        client.secrets.set(name, value)
 
 
 def _add_set_parser(subparsers, parents):
@@ -33,32 +33,31 @@ def _add_set_parser(subparsers, parents):
 def _list(args):
     import json
 
-    client = get_client(args.host, args.team)
-    with client.connect() as connection:
-        secrets = list(connection.list_secrets())
+    client = SyncServerlessClient(host=args.host, team=args.team)
+    secrets = client.secrets.list()
 
-        if args.output == "json":
-            json_secrets = [
-                {
-                    "name": secret.name,
-                    "created_at": str(secret.created_at),
-                }
-                for secret in secrets
-            ]
-            args.console.print(json.dumps({"secrets": json_secrets}))
-        elif args.output == "pretty":
-            from rich.table import Table
+    if args.output == "json":
+        json_secrets = [
+            {
+                "name": secret.name,
+                "created_at": str(secret.created_at),
+            }
+            for secret in secrets
+        ]
+        args.console.print(json.dumps({"secrets": json_secrets}))
+    elif args.output == "pretty":
+        from rich.table import Table
 
-            table = Table()
-            table.add_column("Secret Name")
-            table.add_column("Created At")
+        table = Table()
+        table.add_column("Secret Name")
+        table.add_column("Created At")
 
-            for secret in secrets:
-                table.add_row(secret.name, str(secret.created_at))
+        for secret in secrets:
+            table.add_row(secret.name, str(secret.created_at))
 
-            args.console.print(table)
-        else:
-            raise AssertionError(f"Invalid output format: {args.output}")
+        args.console.print(table)
+    else:
+        raise AssertionError(f"Invalid output format: {args.output}")
 
 
 def _add_list_parser(subparsers, parents):
@@ -75,9 +74,8 @@ def _add_list_parser(subparsers, parents):
 
 
 def _unset(args):
-    client = get_client(args.host, args.team)
-    with client.connect() as connection:
-        connection.delete_secret(args.secret)
+    client = SyncServerlessClient(host=args.host, team=args.team)
+    client.secrets.unset(args.secret)
 
 
 def _add_unset_parser(subparsers, parents):

fal/files.py

@@ -4,7 +4,7 @@ import os
 import posixpath
 from concurrent.futures import ThreadPoolExecutor
 from functools import cached_property
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from fsspec import AbstractFileSystem
 
@@ -14,7 +14,7 @@ if TYPE_CHECKING:
 USER_AGENT = "fal-sdk/1.14.0 (python)"
 MULTIPART_THRESHOLD = 10 * 1024 * 1024  # 10MB
 MULTIPART_CHUNK_SIZE = 10 * 1024 * 1024  # 10MB
-MULTIPART_WORKERS = 2  # only 2 because our REST is currently struggling with more
+MULTIPART_WORKERS = 10
 
 
 def _compute_md5(lpath, chunk_size=8192):
@@ -28,20 +28,43 @@ def _compute_md5(lpath, chunk_size=8192):
 
 
 class FalFileSystem(AbstractFileSystem):
+    def __init__(
+        self,
+        *,
+        host: Optional[str] = None,
+        team: Optional[str] = None,
+        profile: Optional[str] = None,
+        **kwargs,
+    ):
+        self.host = host
+        self.team = team
+        self.profile = profile
+        super().__init__(**kwargs)
+
     @cached_property
     def _client(self) -> "httpx.Client":
-        from httpx import Client
+        from httpx import Client, Timeout
+
+        from fal.api.client import SyncServerlessClient
 
-        from fal.flags import REST_URL
-        from fal.sdk import get_default_credentials
+        client = SyncServerlessClient(
+            host=self.host,
+            team=self.team,
+            profile=self.profile,
+        )
 
-        creds = get_default_credentials()
         return Client(
-            base_url=REST_URL,
+            base_url=client._rest_url,
             headers={
-                **creds.to_headers(),
+                **client._credentials.to_headers(),
                 "User-Agent": USER_AGENT,
             },
+            timeout=Timeout(
+                connect=30,
+                read=4 * 60,  # multipart complete can take time
+                write=5 * 60,  # we could be uploading slowly
+                pool=30,
+            ),
         )
 
     def _request(self, method, path, **kwargs):
@@ -224,6 +247,7 @@ class FalFileSystem(AbstractFileSystem):
             "POST",
             f"/files/file/url/{abs_rpath}",
             json={"url": url},
+            timeout=10 * 60,  # 10 minutes in seconds
         )
         self.dircache.clear()
 

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:
     """