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

fal/cli/runners.py

@@ -15,7 +15,10 @@ from datetime import datetime, timedelta, timezone
 from http import HTTPStatus
 from queue import Empty, Queue
 from threading import Thread
-from typing import Iterator, List
+from typing import TYPE_CHECKING, Iterator, List
+
+if TYPE_CHECKING:
+    from openapi_fal_rest.client import Client
 
 import grpc
 import httpx
@@ -24,7 +27,6 @@ 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 RunnerInfo, RunnerState
 
 from .parser import FalClientParser, SinceAction, get_output_parser
@@ -154,8 +156,11 @@ def _shell(args):
 
     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)
+        # 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
@@ -238,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: "
@@ -252,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)}")
@@ -312,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)."),
@@ -378,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:
@@ -415,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,
@@ -451,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,
@@ -478,6 +500,7 @@ def _iter_logs(
 
 
 def _get_logs(
+    rest_client: Client,
     params: dict[str, str],
     since: datetime | None,
     until: datetime | None,
@@ -486,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
@@ -500,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
@@ -543,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:
@@ -589,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)
 

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/sdk.py

@@ -246,6 +246,7 @@ class ApplicationInfo:
     min_concurrency: int
     concurrency_buffer: int
     concurrency_buffer_perc: int
+    scaling_delay: int
     machine_types: list[str]
     request_timeout: int
     startup_timeout: int
@@ -265,6 +266,7 @@ class AliasInfo:
     min_concurrency: int
     concurrency_buffer: int
     concurrency_buffer_perc: int
+    scaling_delay: int
     machine_types: list[str]
     request_timeout: int
     startup_timeout: int
@@ -272,27 +274,14 @@ class AliasInfo:
 
 
 class RunnerState(Enum):
-    RUNNING = "running"
-    PENDING = "pending"
-    SETUP = "setup"
-    DOCKER_PULL = "docker_pull"
-    DEAD = "dead"
-    UNKNOWN = "unknown"
-
-    @staticmethod
-    def from_proto(proto: isolate_proto.RunnerInfo.State) -> RunnerState:
-        if proto is isolate_proto.RunnerInfo.State.RUNNING:
-            return RunnerState.RUNNING
-        elif proto is isolate_proto.RunnerInfo.State.PENDING:
-            return RunnerState.PENDING
-        elif proto is isolate_proto.RunnerInfo.State.SETUP:
-            return RunnerState.SETUP
-        elif proto is isolate_proto.RunnerInfo.State.DEAD:
-            return RunnerState.DEAD
-        elif proto is isolate_proto.RunnerInfo.State.DOCKER_PULL:
-            return RunnerState.DOCKER_PULL
-        else:
-            return RunnerState.UNKNOWN
+    RUNNING = "RUNNING"
+    PENDING = "PENDING"
+    SETUP = "SETUP"
+    DOCKER_PULL = "DOCKER_PULL"
+    DEAD = "DEAD"
+    DRAINING = "DRAINING"
+    TERMINATING = "TERMINATING"
+    TERMINATED = "TERMINATED"
 
 
 @dataclass
@@ -414,6 +403,7 @@ def _from_grpc_application_info(
         min_concurrency=message.min_concurrency,
         concurrency_buffer=message.concurrency_buffer,
         concurrency_buffer_perc=message.concurrency_buffer_perc,
+        scaling_delay=message.scaling_delay_seconds,
         machine_types=list(message.machine_types),
         request_timeout=message.request_timeout,
         startup_timeout=message.startup_timeout,
@@ -444,6 +434,7 @@ def _from_grpc_alias_info(message: isolate_proto.AliasInfo) -> AliasInfo:
         min_concurrency=message.min_concurrency,
         concurrency_buffer=message.concurrency_buffer,
         concurrency_buffer_perc=message.concurrency_buffer_perc,
+        scaling_delay=message.scaling_delay_seconds,
         machine_types=list(message.machine_types),
         request_timeout=message.request_timeout,
         startup_timeout=message.startup_timeout,
@@ -468,7 +459,7 @@ def _from_grpc_runner_info(message: isolate_proto.RunnerInfo) -> RunnerInfo:
         external_metadata=external_metadata,
         revision=message.revision,
         alias=message.alias,
-        state=RunnerState.from_proto(message.state),
+        state=RunnerState(isolate_proto.RunnerInfo.State.Name(message.state)),
     )
 
 
@@ -537,8 +528,10 @@ class MachineRequirements:
     min_concurrency: int | None = None
     concurrency_buffer: int | None = None
     concurrency_buffer_perc: int | None = None
+    scaling_delay: int | None = None
     request_timeout: int | None = None
     startup_timeout: int | None = None
+    valid_regions: list[str] | None = None
 
     def __post_init__(self):
         if isinstance(self.machine_types, str):
@@ -633,6 +626,7 @@ class FalServerlessConnection:
         auth_mode: Optional[AuthModeLiteral] = None,
         *,
         source_code: str | None = None,
+        health_check_path: str | None = None,
         serialization_method: str = _DEFAULT_SERIALIZATION_METHOD,
         machine_requirements: MachineRequirements | None = None,
         metadata: dict[str, Any] | None = None,
@@ -640,7 +634,7 @@ class FalServerlessConnection:
         scale: bool = True,
         private_logs: bool = False,
         files: list[File] | None = None,
-    ) -> Iterator[isolate_proto.RegisterApplicationResult]:
+    ) -> Iterator[RegisterApplicationResult]:
         wrapped_function = to_serialized_object(function, serialization_method)
         if machine_requirements:
             wrapped_requirements = isolate_proto.MachineRequirements(
@@ -659,9 +653,11 @@ class FalServerlessConnection:
                 min_concurrency=machine_requirements.min_concurrency,
                 concurrency_buffer=machine_requirements.concurrency_buffer,
                 concurrency_buffer_perc=machine_requirements.concurrency_buffer_perc,
+                scaling_delay_seconds=machine_requirements.scaling_delay,
                 max_multiplexing=machine_requirements.max_multiplexing,
                 request_timeout=machine_requirements.request_timeout,
                 startup_timeout=machine_requirements.startup_timeout,
+                valid_regions=machine_requirements.valid_regions,
             )
         else:
             wrapped_requirements = None
@@ -702,6 +698,7 @@ class FalServerlessConnection:
             private_logs=private_logs,
             files=files,
             source_code=source_code,
+            health_check_path=health_check_path,
         )
         for partial_result in self.stub.RegisterApplication(request):
             yield from_grpc(partial_result)
@@ -718,6 +715,7 @@ class FalServerlessConnection:
         min_concurrency: int | None = None,
         concurrency_buffer: int | None = None,
         concurrency_buffer_perc: int | None = None,
+        scaling_delay: int | None = None,
         request_timeout: int | None = None,
         startup_timeout: int | None = None,
         valid_regions: list[str] | None = None,
@@ -731,6 +729,7 @@ class FalServerlessConnection:
             min_concurrency=min_concurrency,
             concurrency_buffer=concurrency_buffer,
             concurrency_buffer_perc=concurrency_buffer_perc,
+            scaling_delay_seconds=scaling_delay,
             request_timeout=request_timeout,
             startup_timeout=startup_timeout,
             valid_regions=valid_regions,
@@ -757,6 +756,17 @@ class FalServerlessConnection:
         request = isolate_proto.DeleteApplicationRequest(application_id=application_id)
         self.stub.DeleteApplication(request)
 
+    def rollout_application(
+        self,
+        application_name: str,
+        force: bool = False,
+    ) -> None:
+        request = isolate_proto.RolloutApplicationRequest(
+            application_name=application_name,
+            force=force,
+        )
+        self.stub.RolloutApplication(request)
+
     def run(
         self,
         function: Callable[..., ResultT],
@@ -786,8 +796,10 @@ class FalServerlessConnection:
                 min_concurrency=machine_requirements.min_concurrency,
                 concurrency_buffer=machine_requirements.concurrency_buffer,
                 concurrency_buffer_perc=machine_requirements.concurrency_buffer_perc,
+                scaling_delay_seconds=machine_requirements.scaling_delay,
                 request_timeout=machine_requirements.request_timeout,
                 startup_timeout=machine_requirements.startup_timeout,
+                valid_regions=machine_requirements.valid_regions,
             )
         else:
             wrapped_requirements = None

fal/sync.py

@@ -4,21 +4,21 @@ import hashlib
 import os
 import zipfile
 from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from openapi_fal_rest.client import Client
 
-import openapi_fal_rest.api.files.check_dir_hash as check_dir_hash_api
-import openapi_fal_rest.api.files.upload_local_file as upload_local_file_api
-import openapi_fal_rest.models.body_upload_local_file as upload_file_model
-import openapi_fal_rest.models.hash_check as hash_check_model
-import openapi_fal_rest.types as rest_types
 from pathspec import PathSpec
 
-from fal.rest_client import REST_CLIENT
 
+def _check_hash(client: Client, target_path: str, hash_string: str) -> bool:
+    import openapi_fal_rest.api.files.check_dir_hash as check_dir_hash_api
+    import openapi_fal_rest.models.hash_check as hash_check_model
 
-def _check_hash(target_path: str, hash_string: str) -> bool:
     response = check_dir_hash_api.sync_detailed(
         target_path,
-        client=REST_CLIENT,
+        client=client,
         json_body=hash_check_model.HashCheck(hash_string),
     )
 
@@ -26,7 +26,13 @@ def _check_hash(target_path: str, hash_string: str) -> bool:
     return response.status_code == 200 and res
 
 
-def _upload_file(source_path: str, target_path: str, unzip: bool = False):
+def _upload_file(
+    client: Client, source_path: str, target_path: str, unzip: bool = False
+):
+    import openapi_fal_rest.api.files.upload_local_file as upload_local_file_api
+    import openapi_fal_rest.models.body_upload_local_file as upload_file_model
+    import openapi_fal_rest.types as rest_types
+
     with open(source_path, "rb") as file_to_upload:
         body = upload_file_model.BodyUploadLocalFile(
             rest_types.File(
@@ -39,7 +45,7 @@ def _upload_file(source_path: str, target_path: str, unzip: bool = False):
 
         response = upload_local_file_api.sync_detailed(
             target_path,
-            client=REST_CLIENT,
+            client=client,
             unzip=unzip,
             multipart_data=body,
         )
@@ -94,6 +100,8 @@ def _zip_directory(dir_path: str, zip_path: str) -> None:
 
 
 def sync_dir(local_dir: str | Path, remote_dir: str, force_upload=False) -> str:
+    from fal.api.client import SyncServerlessClient
+
     local_dir_abs = os.path.expanduser(local_dir)
     if not os.path.isabs(remote_dir) or not remote_dir.startswith("/data"):
         raise ValueError(
@@ -106,9 +114,11 @@ def sync_dir(local_dir: str | Path, remote_dir: str, force_upload=False) -> str:
     # Compute the local directory hash
     local_hash = _compute_directory_hash(local_dir_abs)
 
+    client = SyncServerlessClient()._create_rest_client()
+
     print(f"Syncing {local_dir} with {remote_dir}...")
 
-    if _check_hash(remote_dir, local_hash) and not force_upload:
+    if _check_hash(client, remote_dir, local_hash) and not force_upload:
         print(f"{remote_dir} already uploaded and matches {local_dir}")
         return remote_dir
 
@@ -121,7 +131,7 @@ def sync_dir(local_dir: str | Path, remote_dir: str, force_upload=False) -> str:
     _zip_directory(local_dir_abs, zip_path)
 
     # Upload the zipped directory to the serverless environment
-    _upload_file(zip_path, remote_dir, unzip=True)
+    _upload_file(client, zip_path, remote_dir, unzip=True)
 
     os.remove(zip_path)
 

fal/toolkit/__init__.py

@@ -1,6 +1,12 @@
 from __future__ import annotations
 
 from fal.toolkit.audio.audio import Audio, AudioField
+from fal.toolkit.compilation import (
+    get_gpu_type,
+    load_inductor_cache,
+    sync_inductor_cache,
+    synchronized_inductor_cache,
+)
 from fal.toolkit.file import CompressedFile, File, FileField
 from fal.toolkit.image.image import Image, ImageField, ImageSizeInput, get_image_size
 from fal.toolkit.optimize import optimize
@@ -33,4 +39,8 @@ __all__ = [
     "clone_repository",
     "download_file",
     "download_model_weights",
+    "get_gpu_type",
+    "load_inductor_cache",
+    "sync_inductor_cache",
+    "synchronized_inductor_cache",
 ]