fal 1.45.2__py3-none-any.whl → 1.46.0__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.45.2'
-__version_tuple__ = version_tuple = (1, 45, 2)
+__version__ = version = '1.46.0'
+__version_tuple__ = version_tuple = (1, 46, 0)
 
 __commit_id__ = commit_id = None

fal/api/__init__.py

@@ -0,0 +1 @@
+from .api import *  # noqa: F403

fal/api/apps.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, List, Optional
+
+from fal.sdk import AliasInfo, FalServerlessClient, RunnerInfo
+
+if TYPE_CHECKING:
+    from .client import SyncServerlessClient
+
+
+def list_apps(
+    client: SyncServerlessClient,
+    *,
+    filter: Optional[str] = None,
+) -> List[AliasInfo]:
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        apps = conn.list_aliases()
+
+    if filter:
+        apps = [a for a in apps if filter in a.alias]
+    return apps
+
+
+def apps_runners(
+    client: SyncServerlessClient,
+    app_name: str,
+    *,
+    since: Optional[datetime] = None,
+    state: Optional[list[str]] = None,
+) -> List[RunnerInfo]:
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        alias_runners = conn.list_alias_runners(alias=app_name, start_time=since)
+
+    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]
+    return alias_runners
+
+
+def scale_app(
+    client: SyncServerlessClient,
+    app_name: str,
+    *,
+    keep_alive: int | None = None,
+    max_multiplexing: int | None = None,
+    max_concurrency: int | None = None,
+    min_concurrency: int | None = None,
+    concurrency_buffer: int | None = None,
+    concurrency_buffer_perc: int | None = None,
+    request_timeout: int | None = None,
+    startup_timeout: int | None = None,
+    machine_types: list[str] | None = None,
+    regions: list[str] | None = None,
+) -> AliasInfo:
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        return conn.update_application(
+            application_name=app_name,
+            keep_alive=keep_alive,
+            max_multiplexing=max_multiplexing,
+            max_concurrency=max_concurrency,
+            min_concurrency=min_concurrency,
+            concurrency_buffer=concurrency_buffer,
+            concurrency_buffer_perc=concurrency_buffer_perc,
+            request_timeout=request_timeout,
+            startup_timeout=startup_timeout,
+            machine_types=machine_types,
+            valid_regions=regions,
+        )

fal/api/client.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import List, Optional
+
+from fal.api import FAL_SERVERLESS_DEFAULT_URL
+from fal.sdk import (
+    AliasInfo,
+    Credentials,
+    RunnerInfo,
+)
+
+from . import apps as apps_api
+from . import deploy as deploy_api
+from . import runners as runners_api
+
+
+class _AppsNamespace:
+    def __init__(self, client: SyncServerlessClient):
+        self.client = client
+
+    def list(self, *, filter: str | None = None) -> List[AliasInfo]:
+        return apps_api.list_apps(self.client, filter=filter)
+
+    def runners(
+        self, app_name: str, *, since=None, state: List[str] | None = None
+    ) -> List[RunnerInfo]:
+        return apps_api.apps_runners(self.client, app_name, since=since, state=state)
+
+    def scale(
+        self,
+        app_name: str,
+        *,
+        keep_alive: int | None = None,
+        max_multiplexing: int | None = None,
+        max_concurrency: int | None = None,
+        min_concurrency: int | None = None,
+        concurrency_buffer: int | None = None,
+        concurrency_buffer_perc: int | None = None,
+        request_timeout: int | None = None,
+        startup_timeout: int | None = None,
+        machine_types: List[str] | None = None,
+        regions: List[str] | None = None,
+    ) -> apps_api.AliasInfo:
+        return apps_api.scale_app(
+            self.client,
+            app_name,
+            keep_alive=keep_alive,
+            max_multiplexing=max_multiplexing,
+            max_concurrency=max_concurrency,
+            min_concurrency=min_concurrency,
+            concurrency_buffer=concurrency_buffer,
+            concurrency_buffer_perc=concurrency_buffer_perc,
+            request_timeout=request_timeout,
+            startup_timeout=startup_timeout,
+            machine_types=machine_types,
+            regions=regions,
+        )
+
+
+class _RunnersNamespace:
+    def __init__(self, client: SyncServerlessClient):
+        self.client = client
+
+    def list(self, *, since=None) -> List[RunnerInfo]:
+        return runners_api.list_runners(self.client, since=since)
+
+
+@dataclass
+class SyncServerlessClient:
+    host: Optional[str] = None
+    api_key: Optional[str] = None
+    profile: Optional[str] = None
+    team: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        self.apps = _AppsNamespace(self)
+        self.runners = _RunnersNamespace(self)
+
+    # Top-level verbs
+    def deploy(self, *args, **kwargs):
+        return deploy_api.deploy(self, *args, **kwargs)
+
+    # Internal helpers
+    @property
+    def _grpc_host(self) -> str:
+        return self.host or FAL_SERVERLESS_DEFAULT_URL
+
+    @property
+    def _credentials(self) -> Credentials:
+        from fal.sdk import FalServerlessKeyCredentials, get_default_credentials
+
+        if self.api_key:
+            if self.team:
+                raise ValueError(
+                    "Using explicit team with key credentials is not allowed"
+                )
+            try:
+                key_id, key_secret = self.api_key.split(":", 1)
+            except ValueError:
+                raise ValueError("api_key must be in 'KEY_ID:KEY_SECRET' format")
+            return FalServerlessKeyCredentials(key_id, key_secret)
+
+        if self.profile:
+            prev = os.environ.get("FAL_PROFILE")
+            os.environ["FAL_PROFILE"] = self.profile
+            try:
+                return get_default_credentials(team=self.team)
+            finally:
+                if prev is None:
+                    os.environ.pop("FAL_PROFILE", None)
+                else:
+                    os.environ["FAL_PROFILE"] = prev
+
+        return get_default_credentials(team=self.team)

fal/api/deploy.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+from fal.sdk import AuthModeLiteral, DeploymentStrategyLiteral
+
+if TYPE_CHECKING:
+    from .client import SyncServerlessClient
+
+
+import json
+from collections import namedtuple
+from typing import Tuple, Union, cast
+
+from fal.cli._utils import get_app_data_from_toml, is_app_name
+from fal.cli.parser import RefAction
+
+User = namedtuple("User", ["user_id", "username"])
+
+
+@dataclass
+class DeploymentResult:
+    revision: str
+    app_name: str
+    urls: dict[str, dict[str, str]]
+
+
+def _remove_http_and_port_from_url(url):
+    # Remove http://
+    if "http://" in url:
+        url = url.replace("http://", "")
+
+    # Remove https://
+    if "https://" in url:
+        url = url.replace("https://", "")
+
+    # Remove port information
+    url_parts = url.split(":")
+    if len(url_parts) > 1:
+        url = url_parts[0]
+
+    return url
+
+
+def _get_user() -> 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,
+        )
+    except Exception as e:
+        raise FalServerlessError(f"Error fetching user details: {str(e)}")
+
+    if user_details_response.status_code != HTTPStatus.OK:
+        try:
+            content = json.loads(user_details_response.content.decode("utf8"))
+        except Exception:
+            raise FalServerlessError(
+                f"Error fetching user details: {user_details_response}"
+            )
+        else:
+            raise FalServerlessError(content["detail"])
+    try:
+        full_user_id = user_details_response.parsed.user_id
+        _provider, _, user_id = full_user_id.partition("|")
+        if not user_id:
+            user_id = full_user_id
+
+        return User(user_id=user_id, username=user_details_response.parsed.nickname)
+    except Exception as e:
+        raise FalServerlessError(f"Could not parse the user data: {e}")
+
+
+def _deploy_from_reference(
+    client: SyncServerlessClient,
+    app_ref: Tuple[Optional[Union[Path, str]], ...],
+    app_name: str,
+    auth: Optional[AuthModeLiteral],
+    strategy: Optional[DeploymentStrategyLiteral],
+    scale: bool,
+) -> DeploymentResult:
+    from fal.api import FalServerlessError, FalServerlessHost
+    from fal.utils import load_function_from
+
+    file_path, func_name = app_ref
+    if file_path is None:
+        # Try to find a python file in the current directory
+        options = list(Path(".").glob("*.py"))
+        if len(options) == 0:
+            raise FalServerlessError("No python files found in the current directory")
+        elif len(options) > 1:
+            raise FalServerlessError(
+                "Multiple python files found in the current directory. "
+                "Please specify the file path of the app you want to deploy."
+            )
+
+        [file_path] = options
+        file_path = str(file_path)  # type: ignore
+
+    user = _get_user()
+    host = FalServerlessHost(client._grpc_host, local_file_path=str(file_path))
+    loaded = load_function_from(
+        host,
+        file_path,  # type: ignore
+        func_name,  # type: ignore
+    )
+    isolated_function = loaded.function
+    app_name = app_name or loaded.app_name  # type: ignore
+    app_auth = auth or loaded.app_auth
+    strategy = strategy or "rolling"
+
+    app_id = host.register(
+        func=isolated_function.func,
+        options=isolated_function.options,
+        application_name=app_name,
+        application_auth_mode=app_auth,  # type: ignore
+        metadata=isolated_function.options.host.get("metadata", {}),
+        deployment_strategy=strategy,
+        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")
+
+    urls: dict[str, dict[str, str]] = {
+        "playground": {},
+        "sync": {},
+        "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}"
+        )
+
+    return DeploymentResult(
+        revision=app_id,
+        app_name=app_name,
+        urls=urls,
+    )
+
+
+def deploy(
+    client: SyncServerlessClient,
+    app_ref: str | tuple[str, str] | None = None,
+    *,
+    app_name: str | None = None,
+    auth: AuthModeLiteral | None = None,
+    strategy: DeploymentStrategyLiteral = "rolling",
+    reset_scale: bool = False,
+) -> DeploymentResult:
+    if isinstance(app_ref, tuple):
+        app_ref_tuple = app_ref
+    elif app_ref:
+        app_ref_tuple = RefAction.split_ref(app_ref)
+    else:
+        raise ValueError("Invalid app reference")
+
+    # my-app
+    if is_app_name(app_ref_tuple):
+        # we do not allow --app-name and --auth to be used with app name
+        if app_name or auth:
+            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_name
+        )
+        file_path, func_name = RefAction.split_ref(app_ref)
+
+    # path/to/myfile.py::MyApp
+    else:
+        file_path, func_name = app_ref_tuple
+        app_name = cast(str, app_name)
+        # default to be set in the backend
+        app_auth = cast(Optional[AuthModeLiteral], auth)
+        # default comes from the CLI
+        app_strategy = cast(DeploymentStrategyLiteral, strategy)
+        app_scale_settings = cast(bool, reset_scale)
+        file_path = str(Path(file_path).absolute())
+
+    return _deploy_from_reference(
+        client,
+        (file_path, func_name),
+        app_name,  # type: ignore
+        app_auth,
+        strategy=app_strategy,
+        scale=app_scale_settings,
+    )

fal/api/runners.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, List, Optional
+
+from fal.sdk import FalServerlessClient, RunnerInfo
+
+if TYPE_CHECKING:
+    from .client import SyncServerlessClient
+
+
+def list_runners(
+    client: SyncServerlessClient, *, since: Optional[datetime] = None
+) -> List[RunnerInfo]:
+    with FalServerlessClient(client._grpc_host, client._credentials).connect() as conn:
+        return conn.list_runners(start_time=since)

fal/cli/apps.py

@@ -5,6 +5,7 @@ from dataclasses import asdict
 from typing import TYPE_CHECKING
 
 import fal.cli.runners as runners
+from fal.api.client import SyncServerlessClient
 from fal.sdk import RunnerState
 
 from ._utils import get_client
@@ -60,27 +61,23 @@ def _apps_table(apps: list[AliasInfo]):
 
 
 def _list(args):
-    client = get_client(args.host, args.team)
-    with client.connect() as connection:
-        apps = connection.list_aliases()
+    client = SyncServerlessClient(host=args.host, team=args.team)
+    apps = client.apps.list(filter=args.filter)
 
-        if args.filter:
-            apps = [app for app in apps if args.filter in app.alias]
+    if args.sort_by_runners:
+        apps.sort(key=lambda x: x.active_runners)
+    else:
+        apps.sort(key=lambda x: x.alias)
 
-        if args.sort_by_runners:
-            apps.sort(key=lambda x: x.active_runners)
-        else:
-            apps.sort(key=lambda x: x.alias)
-
-        if args.output == "pretty":
-            table = _apps_table(apps)
-            args.console.print(table)
-        elif args.output == "json":
-            apps_as_dicts = [asdict(a) for a in apps]
-            res = json.dumps({"apps": apps_as_dicts})
-            args.console.print(res)
-        else:
-            raise AssertionError(f"Invalid output format: {args.output}")
+    if args.output == "pretty":
+        table = _apps_table(apps)
+        args.console.print(table)
+    elif args.output == "json":
+        apps_as_dicts = [asdict(a) for a in apps]
+        json_res = json.dumps({"apps": apps_as_dicts})
+        args.console.print(json_res)
+    else:
+        raise AssertionError(f"Invalid output format: {args.output}")
 
 
 def _add_list_parser(subparsers, parents):
@@ -164,37 +161,36 @@ def _add_list_rev_parser(subparsers, parents):
 
 
 def _scale(args):
-    client = get_client(args.host, args.team)
-    with client.connect() as connection:
-        if (
-            args.keep_alive is None
-            and args.max_multiplexing is None
-            and args.max_concurrency is None
-            and args.min_concurrency is None
-            and args.concurrency_buffer is None
-            and args.concurrency_buffer_perc is None
-            and args.request_timeout is None
-            and args.startup_timeout is None
-            and args.machine_types is None
-            and args.regions is None
-        ):
-            args.console.log("No parameters for update were provided, ignoring.")
-            return
-
-        alias_info = connection.update_application(
-            application_name=args.app_name,
-            keep_alive=args.keep_alive,
-            max_multiplexing=args.max_multiplexing,
-            max_concurrency=args.max_concurrency,
-            min_concurrency=args.min_concurrency,
-            concurrency_buffer=args.concurrency_buffer,
-            concurrency_buffer_perc=args.concurrency_buffer_perc,
-            request_timeout=args.request_timeout,
-            startup_timeout=args.startup_timeout,
-            machine_types=args.machine_types,
-            valid_regions=args.regions,
-        )
-        table = _apps_table([alias_info])
+    client = SyncServerlessClient(host=args.host, team=args.team)
+    if (
+        args.keep_alive is None
+        and args.max_multiplexing is None
+        and args.max_concurrency is None
+        and args.min_concurrency is None
+        and args.concurrency_buffer is None
+        and args.concurrency_buffer_perc is None
+        and args.request_timeout is None
+        and args.startup_timeout is None
+        and args.machine_types is None
+        and args.regions is None
+    ):
+        args.console.log("No parameters for update were provided, ignoring.")
+        return
+
+    app_info = client.apps.scale(
+        args.app_name,
+        keep_alive=args.keep_alive,
+        max_multiplexing=args.max_multiplexing,
+        max_concurrency=args.max_concurrency,
+        min_concurrency=args.min_concurrency,
+        concurrency_buffer=args.concurrency_buffer,
+        concurrency_buffer_perc=args.concurrency_buffer_perc,
+        request_timeout=args.request_timeout,
+        startup_timeout=args.startup_timeout,
+        machine_types=args.machine_types,
+        regions=args.regions,
+    )
+    table = _apps_table([app_info])
 
     args.console.print(table)
 
@@ -303,16 +299,11 @@ def _add_set_rev_parser(subparsers, parents):
 
 
 def _runners(args):
-    client = get_client(args.host, args.team)
-    with client.connect() as connection:
-        start_time = getattr(args, "since", None)
-        alias_runners = connection.list_alias_runners(
-            alias=args.app_name, start_time=start_time
-        )
-    if getattr(args, "state", None):
-        states = set(args.state)
-        if "all" not in states:
-            alias_runners = [r for r in alias_runners if r.state.value in states]
+    client = SyncServerlessClient(host=args.host, team=args.team)
+    start_time = args.since
+    alias_runners = client.apps.runners(
+        args.app_name, since=start_time, state=args.state
+    )
     if args.output == "pretty":
         runners_table = runners.runners_table(alias_runners)
         pending_runners = [