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

fal/_fal_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.50.1'
-__version_tuple__ = version_tuple = (1, 50, 1)
+__version__ = version = '1.57.2'
+__version_tuple__ = version_tuple = (1, 57, 2)
 
 __commit_id__ = commit_id = None

fal/api/api.py

@@ -68,6 +68,7 @@ from fal.sdk import (
     File,
     HostedRunState,
     MachineRequirements,
+    RegisterApplicationResult,
     get_agent_credentials,
     get_default_credentials,
 )
@@ -84,6 +85,7 @@ _UNSET = object()
 SERVE_REQUIREMENTS = [
     f"fastapi=={fastapi_version}",
     f"pydantic=={pydantic_version}",
+    f"tblib=={tblib.__version__}",
     "uvicorn",
     "starlette_exporter",
     # workaround for prometheus_client 0.23.0
@@ -426,12 +428,14 @@ class FalServerlessHost(Host):
         {
             "machine_type",
             "machine_types",
+            "regions",
             "num_gpus",
             "keep_alive",
             "max_concurrency",
             "min_concurrency",
             "concurrency_buffer",
             "concurrency_buffer_perc",
+            "scaling_delay",
             "max_multiplexing",
             "setup_function",
             "metadata",
@@ -444,6 +448,7 @@ class FalServerlessHost(Host):
             "app_files",
             "app_files_ignore",
             "app_files_context_dir",
+            "health_check_path",
         }
     )
 
@@ -518,7 +523,7 @@ class FalServerlessHost(Host):
         metadata: Optional[dict[str, Any]] = None,
         deployment_strategy: DeploymentStrategyLiteral,
         scale: bool = True,
-    ) -> Optional[str]:
+    ) -> Optional[RegisterApplicationResult]:
         from isolate.backends.common import active_python
 
         environment_options = options.environment.copy()
@@ -536,10 +541,12 @@ class FalServerlessHost(Host):
         min_concurrency = options.host.get("min_concurrency")
         concurrency_buffer = options.host.get("concurrency_buffer")
         concurrency_buffer_perc = options.host.get("concurrency_buffer_perc")
+        scaling_delay = options.host.get("scaling_delay")
         max_multiplexing = options.host.get("max_multiplexing")
         exposed_port = options.get_exposed_port()
         request_timeout = options.host.get("request_timeout")
         startup_timeout = options.host.get("startup_timeout")
+        regions = options.host.get("regions")
         machine_requirements = MachineRequirements(
             machine_types=machine_type,  # type: ignore
             num_gpus=options.host.get("num_gpus"),
@@ -553,10 +560,14 @@ class FalServerlessHost(Host):
             min_concurrency=min_concurrency,
             concurrency_buffer=concurrency_buffer,
             concurrency_buffer_perc=concurrency_buffer_perc,
+            scaling_delay=scaling_delay,
             request_timeout=request_timeout,
             startup_timeout=startup_timeout,
+            valid_regions=regions,
         )
 
+        health_check_path = options.host.get("health_check_path")
+
         app_files = self._app_files_sync(options)
 
         partial_func = _prepare_partial_func(func)
@@ -580,6 +591,7 @@ class FalServerlessHost(Host):
             metadata=metadata,
             deployment_strategy=deployment_strategy,
             scale=scale,
+            health_check_path=health_check_path,
             # By default, logs are public
             private_logs=options.host.get("private_logs", False),
             files=app_files,
@@ -588,7 +600,7 @@ class FalServerlessHost(Host):
                 self._log_printer.print(log)
 
             if partial_result.result:
-                return partial_result.result.application_id
+                return partial_result
 
         return None
 
@@ -615,6 +627,7 @@ class FalServerlessHost(Host):
         min_concurrency = options.host.get("min_concurrency")
         concurrency_buffer = options.host.get("concurrency_buffer")
         concurrency_buffer_perc = options.host.get("concurrency_buffer_perc")
+        scaling_delay = options.host.get("scaling_delay")
         max_multiplexing = options.host.get("max_multiplexing")
         base_image = options.host.get("_base_image", None)
         scheduler = options.host.get("_scheduler", None)
@@ -636,6 +649,7 @@ class FalServerlessHost(Host):
             min_concurrency=min_concurrency,
             concurrency_buffer=concurrency_buffer,
             concurrency_buffer_perc=concurrency_buffer_perc,
+            scaling_delay=scaling_delay,
             request_timeout=request_timeout,
             startup_timeout=startup_timeout,
         )
@@ -824,12 +838,14 @@ def function(
     # FalServerlessHost options
     metadata: dict[str, Any] | None = None,
     machine_type: str | list[str] = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
+    regions: list[str] | None = None,
     num_gpus: int | None = None,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     min_concurrency: int = FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
     concurrency_buffer: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     concurrency_buffer_perc: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER_PERC,
+    scaling_delay: int | None = None,
     request_timeout: int | None = None,
     startup_timeout: int | None = None,
     setup_function: Callable[..., None] | None = None,
@@ -855,12 +871,14 @@ def function(
     # FalServerlessHost options
     metadata: dict[str, Any] | None = None,
     machine_type: str | list[str] = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
+    regions: list[str] | None = None,
     num_gpus: int | None = None,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     min_concurrency: int = FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
     concurrency_buffer: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     concurrency_buffer_perc: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER_PERC,
+    scaling_delay: int | None = None,
     request_timeout: int | None = None,
     startup_timeout: int | None = None,
     setup_function: Callable[..., None] | None = None,
@@ -938,12 +956,14 @@ def function(
     # FalServerlessHost options
     metadata: dict[str, Any] | None = None,
     machine_type: str | list[str] = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
+    regions: list[str] | None = None,
     num_gpus: int | None = None,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     min_concurrency: int = FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
     concurrency_buffer: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     concurrency_buffer_perc: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER_PERC,
+    scaling_delay: int | None = None,
     request_timeout: int | None = None,
     startup_timeout: int | None = None,
     setup_function: Callable[..., None] | None = None,
@@ -974,12 +994,14 @@ def function(
     # FalServerlessHost options
     metadata: dict[str, Any] | None = None,
     machine_type: str | list[str] = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
+    regions: list[str] | None = None,
     num_gpus: int | None = None,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     min_concurrency: int = FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
     concurrency_buffer: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     concurrency_buffer_perc: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER_PERC,
+    scaling_delay: int | None = None,
     request_timeout: int | None = None,
     startup_timeout: int | None = None,
     setup_function: Callable[..., None] | None = None,
@@ -1004,12 +1026,14 @@ def function(
     # FalServerlessHost options
     metadata: dict[str, Any] | None = None,
     machine_type: str | list[str] = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
+    regions: list[str] | None = None,
     num_gpus: int | None = None,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     min_concurrency: int = FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
     concurrency_buffer: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     concurrency_buffer_perc: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER_PERC,
+    scaling_delay: int | None = None,
     request_timeout: int | None = None,
     startup_timeout: int | None = None,
     setup_function: Callable[..., None] | None = None,
@@ -1034,12 +1058,14 @@ def function(
     # FalServerlessHost options
     metadata: dict[str, Any] | None = None,
     machine_type: str | list[str] = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
+    regions: list[str] | None = None,
     num_gpus: int | None = None,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     min_concurrency: int = FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
     concurrency_buffer: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     concurrency_buffer_perc: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER_PERC,
+    scaling_delay: int | None = None,
     request_timeout: int | None = None,
     startup_timeout: int | None = None,
     setup_function: Callable[..., None] | None = None,
@@ -1065,6 +1091,9 @@ def function(  # type: ignore
     if config.get("image"):
         kind = "container"
 
+    if kind == "container" and config.get("app_files"):
+        raise ValueError("app_files is not supported for container apps.")
+
     options = host.parse_options(kind=kind, **config)
 
     def wrapper(func: Callable[ArgsT, ReturnT]):
@@ -1141,6 +1170,7 @@ class FalFastAPI(FastAPI):
 class RouteSignature(NamedTuple):
     path: str
     is_websocket: bool = False
+    is_health_check: bool = False
     input_modal: type | None = None
     buffering: int | None = None
     session_timeout: float | None = None

fal/api/apps.py

@@ -34,7 +34,14 @@ def apps_runners(
 
     if state and "all" not in set(state):
         states = set(state)
-        alias_runners = [r for r in alias_runners if r.state.value in states]
+        alias_runners = [
+            r
+            for r in alias_runners
+            if r.state.value.lower() in states
+            or (
+                "terminated" in states and r.state.value.lower() == "dead"
+            )  # TODO for backwards compatibility. remove later
+        ]
     return alias_runners
 
 
@@ -48,6 +55,7 @@ def scale_app(
     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,
     machine_types: list[str] | None = None,
@@ -62,8 +70,22 @@ def scale_app(
             min_concurrency=min_concurrency,
             concurrency_buffer=concurrency_buffer,
             concurrency_buffer_perc=concurrency_buffer_perc,
+            scaling_delay=scaling_delay,
             request_timeout=request_timeout,
             startup_timeout=startup_timeout,
             machine_types=machine_types,
             valid_regions=regions,
         )
+
+
+def rollout_app(
+    client: SyncServerlessClient,
+    app_name: str,
+    *,
+    force: bool = False,
+) -> None:
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        conn.rollout_application(
+            application_name=app_name,
+            force=force,
+        )

fal/api/client.py

@@ -2,18 +2,26 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import TYPE_CHECKING, List, Optional
 
 from fal.api import FAL_SERVERLESS_DEFAULT_URL, FalServerlessHost
 from fal.sdk import (
     AliasInfo,
     Credentials,
+    KeyScope,
     RunnerInfo,
+    ServerlessSecret,
+    UserKeyInfo,
 )
 
+if TYPE_CHECKING:
+    from openapi_fal_rest.client import Client
+
 from . import apps as apps_api
 from . import deploy as deploy_api
+from . import keys as keys_api
 from . import runners as runners_api
+from . import secrets as secrets_api
 
 
 class _AppsNamespace:
@@ -38,6 +46,7 @@ class _AppsNamespace:
         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,
         machine_types: List[str] | None = None,
@@ -52,12 +61,16 @@ class _AppsNamespace:
             min_concurrency=min_concurrency,
             concurrency_buffer=concurrency_buffer,
             concurrency_buffer_perc=concurrency_buffer_perc,
+            scaling_delay=scaling_delay,
             request_timeout=request_timeout,
             startup_timeout=startup_timeout,
             machine_types=machine_types,
             regions=regions,
         )
 
+    def rollout(self, app_name: str, *, force: bool = False) -> None:
+        return apps_api.rollout_app(self.client, app_name, force=force)
+
 
 class _RunnersNamespace:
     def __init__(self, client: SyncServerlessClient):
@@ -73,6 +86,36 @@ class _RunnersNamespace:
         return runners_api.kill_runner(self.client, runner_id)
 
 
+class _KeysNamespace:
+    def __init__(self, client: SyncServerlessClient):
+        self.client = client
+
+    def create(
+        self, *, scope: KeyScope, description: str | None = None
+    ) -> tuple[str, str]:
+        return keys_api.create_key(self.client, scope=scope, description=description)
+
+    def list(self) -> List[UserKeyInfo]:
+        return keys_api.list_keys(self.client)
+
+    def revoke(self, key_id: str) -> None:
+        return keys_api.revoke_key(self.client, key_id)
+
+
+class _SecretsNamespace:
+    def __init__(self, client: SyncServerlessClient):
+        self.client = client
+
+    def set(self, name: str, value: str) -> None:
+        return secrets_api.set_secret(self.client, name, value)
+
+    def list(self) -> List[ServerlessSecret]:
+        return secrets_api.list_secrets(self.client)
+
+    def unset(self, name: str) -> None:
+        return secrets_api.unset_secret(self.client, name)
+
+
 @dataclass
 class SyncServerlessClient:
     host: Optional[str] = None
@@ -83,6 +126,8 @@ class SyncServerlessClient:
     def __post_init__(self) -> None:
         self.apps = _AppsNamespace(self)
         self.runners = _RunnersNamespace(self)
+        self.keys = _KeysNamespace(self)
+        self.secrets = _SecretsNamespace(self)
 
     # Top-level verbs
     def deploy(self, *args, **kwargs):
@@ -93,6 +138,12 @@ class SyncServerlessClient:
     def _grpc_host(self) -> str:
         return self.host or FAL_SERVERLESS_DEFAULT_URL
 
+    @property
+    def _rest_url(self) -> str:
+        from fal.flags import REST_SCHEME
+
+        return f"{REST_SCHEME}://{self._grpc_host.replace('api', 'rest', 1)}"
+
     @property
     def _credentials(self) -> Credentials:
         from fal.sdk import FalServerlessKeyCredentials, get_default_credentials
@@ -127,3 +178,17 @@ class SyncServerlessClient:
             local_file_path=local_file_path,
             credentials=self._credentials,
         )
+
+    def _create_rest_client(self) -> Client:
+        from openapi_fal_rest.client import Client
+
+        import fal.flags as flags
+
+        return Client(
+            self._rest_url,
+            headers=self._credentials.to_headers(),
+            timeout=30,
+            verify_ssl=not flags.TEST_MODE,
+            raise_on_unexpected_status=False,
+            follow_redirects=True,
+        )

fal/api/deploy.py

@@ -12,7 +12,10 @@ if TYPE_CHECKING:
 
 import json
 from collections import namedtuple
-from typing import Tuple, Union, cast
+from typing import TYPE_CHECKING, Tuple, Union, cast
+
+if TYPE_CHECKING:
+    from openapi_fal_rest.client import Client
 
 User = namedtuple("User", ["user_id", "username"])
 
@@ -41,17 +44,16 @@ def _remove_http_and_port_from_url(url):
     return url
 
 
-def _get_user() -> User:
+def _get_user(client: Client) -> User:
     from http import HTTPStatus
 
     import openapi_fal_rest.api.users.get_current_user as get_current_user
 
     from fal.api import FalServerlessError
-    from fal.rest_client import REST_CLIENT
 
     try:
         user_details_response = get_current_user.sync_detailed(
-            client=REST_CLIENT,
+            client=client,
         )
     except Exception as e:
         raise FalServerlessError(f"Error fetching user details: {str(e)}")
@@ -102,7 +104,6 @@ def _deploy_from_reference(
         [file_path] = options
         file_path = str(file_path)  # type: ignore
 
-    user = _get_user()
     host = client._create_host(local_file_path=str(file_path))
     loaded = load_function_from(
         host,
@@ -114,7 +115,7 @@ def _deploy_from_reference(
     app_auth = auth or loaded.app_auth
     strategy = strategy or "rolling"
 
-    app_id = host.register(
+    result = host.register(
         func=isolated_function.func,
         options=isolated_function.options,
         application_name=app_name,
@@ -125,17 +126,9 @@ def _deploy_from_reference(
         scale=scale,
     )
 
-    assert app_id
-    env_host = _remove_http_and_port_from_url(host.url)
-    env_host = env_host.replace("api.", "").replace("alpha.", "")
-
-    env_host_parts = env_host.split(".")
-
-    # keep the last 3 parts
-    playground_host = ".".join(env_host_parts[-3:])
-
-    # just replace .ai for .run
-    endpoint_host = env_host.replace(".ai", ".run")
+    assert result
+    assert result.result
+    assert result.service_urls
 
     urls: dict[str, dict[str, str]] = {
         "playground": {},
@@ -143,18 +136,12 @@ def _deploy_from_reference(
         "async": {},
     }
     for endpoint in loaded.endpoints:
-        urls["playground"][endpoint] = (
-            f"https://{playground_host}/models/{user.username}/{app_name}{endpoint}"
-        )
-        urls["sync"][endpoint] = (
-            f"https://{endpoint_host}/{user.username}/{app_name}{endpoint}"
-        )
-        urls["async"][endpoint] = (
-            f"https://queue.{endpoint_host}/{user.username}/{app_name}{endpoint}"
-        )
+        urls["playground"][endpoint] = f"{result.service_urls.playground}{endpoint}"
+        urls["sync"][endpoint] = f"{result.service_urls.run}{endpoint}"
+        urls["async"][endpoint] = f"{result.service_urls.queue}{endpoint}"
 
     return DeploymentResult(
-        revision=app_id,
+        revision=result.result.application_id,
         app_name=app_name,
         urls=urls,
     )
@@ -186,9 +173,10 @@ def deploy(
             raise ValueError("Cannot use --app-name or --auth with app name reference.")
 
         app_name = app_ref_tuple[0]
-        app_ref, app_auth, app_strategy, app_scale_settings = get_app_data_from_toml(
+        app_ref, app_auth, app_strategy, app_scale_settings, _ = get_app_data_from_toml(
             app_name
         )
+
         file_path, func_name = RefAction.split_ref(app_ref)
 
     # path/to/myfile.py::MyApp

fal/api/keys.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
+
+if TYPE_CHECKING:
+    from fal.sdk import KeyScope, UserKeyInfo
+
+    from .client import SyncServerlessClient
+
+
+def create_key(
+    client: SyncServerlessClient, *, scope: KeyScope, description: str | None = None
+) -> tuple[str, str]:
+    from fal.sdk import FalServerlessClient
+
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        return conn.create_user_key(scope, description)
+
+
+def list_keys(client: SyncServerlessClient) -> List[UserKeyInfo]:
+    from fal.sdk import FalServerlessClient
+
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        return conn.list_user_keys()
+
+
+def revoke_key(client: SyncServerlessClient, key_id: str) -> None:
+    from fal.sdk import FalServerlessClient
+
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        conn.revoke_user_key(key_id)

fal/api/secrets.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
+
+if TYPE_CHECKING:
+    from fal.sdk import ServerlessSecret
+
+    from .client import SyncServerlessClient
+
+
+def set_secret(client: SyncServerlessClient, name: str, value: str) -> None:
+    from fal.sdk import FalServerlessClient
+
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        conn.set_secret(name, value)
+
+
+def list_secrets(client: SyncServerlessClient) -> List[ServerlessSecret]:
+    from fal.sdk import FalServerlessClient
+
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        return list(conn.list_secrets())
+
+
+def unset_secret(client: SyncServerlessClient, name: str) -> None:
+    from fal.sdk import FalServerlessClient
+
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        conn.delete_secret(name)