fal 0.11.1__py3-none-any.whl → 0.11.3__py3-none-any.whl

fal/api.py

@@ -31,6 +31,7 @@ from fal._serialization import add_serialization_listeners_for, patch_dill
 from fal.logging.isolate import IsolateLogPrinter
 from fal.sdk import (
     FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
+    FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     Credentials,
     FalServerlessClient,
     FalServerlessConnection,
@@ -75,9 +76,7 @@ class Host(Generic[ArgsT, ReturnT]):
     is executed."""
 
     _SUPPORTED_KEYS: ClassVar[frozenset[str]] = frozenset()
-    _GATEWAY_KEYS: ClassVar[frozenset[str]] = frozenset(
-        {"serve", "exposed_port", "max_concurrency"}
-    )
+    _GATEWAY_KEYS: ClassVar[frozenset[str]] = frozenset({"serve", "exposed_port"})
 
     def __post_init__(self):
         assert not self._SUPPORTED_KEYS.intersection(
@@ -117,7 +116,6 @@ class Host(Generic[ArgsT, ReturnT]):
         self,
         func: Callable[ArgsT, ReturnT],
         options: Options,
-        max_concurrency: int | None = None,
         application_name: str | None = None,
         application_auth_mode: Literal["public", "shared", "private"] | None = None,
         metadata: dict[str, Any] | None = None,
@@ -310,6 +308,8 @@ class FalServerlessHost(Host):
         {
             "machine_type",
             "keep_alive",
+            "max_concurrency",
+            "max_multiplexing",
             "setup_function",
             "metadata",
             "_base_image",
@@ -339,7 +339,6 @@ class FalServerlessHost(Host):
         self,
         func: Callable[ArgsT, ReturnT],
         options: Options,
-        max_concurrency: int | None = None,
         application_name: str | None = None,
         application_auth_mode: Literal["public", "shared", "private"] | None = None,
         metadata: dict[str, Any] | None = None,
@@ -352,6 +351,8 @@ class FalServerlessHost(Host):
             "machine_type", FAL_SERVERLESS_DEFAULT_MACHINE_TYPE
         )
         keep_alive = options.host.get("keep_alive", FAL_SERVERLESS_DEFAULT_KEEP_ALIVE)
+        max_concurrency = options.host.get("max_concurrency")
+        max_multiplexing = options.host.get("max_multiplexing")
         base_image = options.host.get("_base_image", None)
         scheduler = options.host.get("_scheduler", None)
         scheduler_options = options.host.get("_scheduler_options", None)
@@ -364,6 +365,8 @@ class FalServerlessHost(Host):
             exposed_port=exposed_port,
             scheduler=scheduler,
             scheduler_options=scheduler_options,
+            max_multiplexing=max_multiplexing,
+            max_concurrency=max_concurrency,
         )
 
         partial_func = _prepare_partial_func(func)
@@ -388,7 +391,6 @@ class FalServerlessHost(Host):
             application_name=application_name,
             application_auth_mode=application_auth_mode,
             machine_requirements=machine_requirements,
-            max_concurrency=max_concurrency,
             metadata=metadata,
         ):
             for log in partial_result.logs:
@@ -397,18 +399,6 @@ class FalServerlessHost(Host):
             if partial_result.result:
                 return partial_result.result.application_id
 
-    @_handle_grpc_error()
-    def schedule(
-        self,
-        func: Callable[ArgsT, ReturnT],
-        cron: str,
-        options: Options,
-    ) -> str | None:
-        application_id = self.register(func, options)
-        if application_id is None:
-            return None
-        return self._connection.schedule_cronjob(application_id, cron)
-
     @_handle_grpc_error()
     def run(
         self,
@@ -425,6 +415,8 @@ class FalServerlessHost(Host):
             "machine_type", FAL_SERVERLESS_DEFAULT_MACHINE_TYPE
         )
         keep_alive = options.host.get("keep_alive", FAL_SERVERLESS_DEFAULT_KEEP_ALIVE)
+        max_concurrency = options.host.get("max_concurrency")
+        max_multiplexing = options.host.get("max_multiplexing")
         base_image = options.host.get("_base_image", None)
         scheduler = options.host.get("_scheduler", None)
         scheduler_options = options.host.get("_scheduler_options", None)
@@ -438,6 +430,8 @@ class FalServerlessHost(Host):
             exposed_port=exposed_port,
             scheduler=scheduler,
             scheduler_options=scheduler_options,
+            max_multiplexing=max_multiplexing,
+            max_concurrency=max_concurrency,
         )
 
         return_value = _UNSET
@@ -560,6 +554,7 @@ def function(
     # FalServerlessHost options
     machine_type: str = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
+    max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     setup_function: Callable[..., None] | None = None,
     _base_image: str | None = None,
     _scheduler: str | None = None,
@@ -583,6 +578,7 @@ def function(
     # FalServerlessHost options
     machine_type: str = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
+    max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     setup_function: Callable[..., None] | None = None,
     _base_image: str | None = None,
     _scheduler: str | None = None,
@@ -658,6 +654,7 @@ def function(
     # FalServerlessHost options
     machine_type: str = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
+    max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     setup_function: Callable[..., None] | None = None,
     _base_image: str | None = None,
     _scheduler: str | None = None,
@@ -686,6 +683,7 @@ def function(
     # FalServerlessHost options
     machine_type: str = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
+    max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     setup_function: Callable[..., None] | None = None,
     _base_image: str | None = None,
     _scheduler: str | None = None,
@@ -758,8 +756,42 @@ class ServeWrapper:
         run(app, host="0.0.0.0", port=8080)
 
     def openapi(self) -> dict[str, Any]:
+        """
+        Build the OpenAPI specification for the served function.
+        Attach needed metadata for a better integration to fal.
+        """
         app = self.build_app()
-        return app.openapi()
+        spec = app.openapi()
+        self._mark_order_openapi(spec)
+        return spec
+
+    def _mark_order_openapi(self, spec: dict[str, Any]):
+        """
+        Add x-fal-order-* keys to the OpenAPI specification to help the rendering of UI.
+
+        NOTE: We rely on the fact that fastapi and Python dicts keep the order of properties.
+        """
+
+        def mark_order(obj: dict[str, Any], key: str):
+            obj[f"x-fal-order-{key}"] = list(obj[key].keys())
+
+        mark_order(spec, "paths")
+
+        def order_schema_object(schema: dict[str, Any]):
+            """
+            Mark the order of properties in the schema object.
+            They can have 'allOf', 'properties' or '$ref' key.
+            """
+            if "allOf" in schema:
+                for sub_schema in schema["allOf"]:
+                    order_schema_object(sub_schema)
+            if "properties" in schema:
+                mark_order(schema, "properties")
+
+        for key in spec["components"].get("schemas") or {}:
+            order_schema_object(spec["components"]["schemas"][key])
+
+        return spec
 
 
 @dataclass

fal/auth/__init__.py

@@ -10,8 +10,7 @@ from fal.exceptions.auth import UnauthenticatedException
 
 
 def login():
-    refresh_token, _ = local.load_token()
-    token_data = auth0.login(bool(refresh_token))
+    token_data = auth0.login()
     with local.lock_token():
         local.save_token(token_data["refresh_token"])
 

fal/auth/auth0.py

@@ -44,7 +44,7 @@ def _open_browser(url: str, code: str | None) -> None:
             )
 
 
-def login(logout_first: bool) -> dict:
+def login() -> dict:
     """
     Runs the device authorization flow and stores the user object in memory
     """
@@ -64,10 +64,7 @@ def login(logout_first: bool) -> dict:
     device_user_code = device_code_data["user_code"]
     device_confirmation_url = device_code_data["verification_uri_complete"]
 
-    if logout_first:
-        url = logout_url(device_confirmation_url)
-    else:
-        url = device_confirmation_url
+    url = logout_url(device_confirmation_url)
 
     _open_browser(url, device_user_code)
 

fal/cli.py

@@ -10,8 +10,6 @@ from uuid import uuid4
 import click
 import fal.auth as auth
 import grpc
-import openapi_fal_rest.api.billing.get_user_details as get_user_details
-import openapi_fal_rest.api.logs.list_since as list_logs
 from fal import api, sdk
 from fal.console import console
 from fal.exceptions import ApplicationExceptionHandler
@@ -19,10 +17,13 @@ from fal.logging import get_logger, set_debug_logging
 from fal.logging.isolate import IsolateLogPrinter
 from fal.logging.trace import get_tracer
 from fal.rest_client import REST_CLIENT
-from fal.sdk import KeyScope
+from fal.sdk import AliasInfo, KeyScope
 from isolate.logs import Log, LogLevel, LogSource
 from rich.table import Table
 
+import openapi_fal_rest.api.billing.get_user_details as get_user_details
+import openapi_fal_rest.api.logs.list_since as list_logs
+
 DEFAULT_HOST = "api.alpha.fal.ai"
 HOST_ENVVAR = "FAL_HOST"
 
@@ -231,6 +232,10 @@ def key_revoke(client: sdk.FalServerlessClient, key_id: str):
 
 
 ##### Function group #####
+ALIAS_AUTH_OPTIONS = ["public", "private", "shared"]
+ALIAS_AUTH_TYPE = Literal["public", "private", "shared"]
+
+
 @click.group
 @click.option("--host", default=DEFAULT_HOST, envvar=HOST_ENVVAR)
 @click.option("--port", default=DEFAULT_PORT, envvar=PORT_ENVVAR, hidden=True)
@@ -244,7 +249,7 @@ def function_cli(ctx, host: str, port: str):
 @click.option(
     "--auth",
     "auth_mode",
-    type=click.Choice(["public", "private", "shared"]),
+    type=click.Choice(ALIAS_AUTH_OPTIONS),
     default="private",
 )
 @click.argument("file_path", required=True)
@@ -255,7 +260,7 @@ def register_application(
     file_path: str,
     function_name: str,
     alias: str | None,
-    auth_mode: Literal["public", "private", "shared"],
+    auth_mode: ALIAS_AUTH_TYPE,
 ):
     import runpy
 
@@ -279,13 +284,11 @@ def register_application(
             "Must expose port 8080 for now. This will be configurable in the future."
         )
 
-    max_concurrency = gateway_options.get("max_concurrency")
     id = host.register(
         func=isolated_function.func,
         options=isolated_function.options,
         application_name=alias,
         application_auth_mode=auth_mode,
-        max_concurrency=max_concurrency,
         metadata={},
     )
 
@@ -304,26 +307,6 @@ def register_application(
             console.print(f"URL: https://{user_id}-{id}.{gateway_host}")
 
 
-@function_cli.command("schedule")
-@click.argument("cron_string", required=True)
-@click.argument("file_path", required=True)
-@click.argument("function_name", required=True)
-@click.pass_obj
-def register_schedulded(
-    host: api.FalServerlessHost, cron_string: str, file_path: str, function_name: str
-):
-    import runpy
-
-    module = runpy.run_path(file_path)
-    isolated_function = module[function_name]
-
-    cron_id = host.schedule(
-        func=isolated_function.func, cron=cron_string, options=isolated_function.options
-    )
-    if cron_id:
-        console.print(cron_id)
-
-
 @function_cli.command("logs")
 @click.option("--lines", default=100)
 @click.option("--url", default=None)
@@ -361,115 +344,116 @@ def alias_cli(ctx, host: str, port: str):
     ctx.obj = api.FalServerlessClient(f"{host}:{port}")
 
 
-@alias_cli.command("list")
-@click.pass_obj
-def alias_list(client: api.FalServerlessClient):
-    with client.connect() as connection:
-        table = Table(title="Function Aliases")
-        table.add_column("Alias")
-        table.add_column("Revision")
-        table.add_column("Auth")
-        table.add_column("Max Concurrency")
+def _alias_table(aliases: list[AliasInfo]):
+    table = Table(title="Function Aliases")
+    table.add_column("Alias")
+    table.add_column("Revision")
+    table.add_column("Auth")
+    table.add_column("Max Concurrency")
+    table.add_column("Max Multiplexing")
+    table.add_column("Keep Alive")
 
-        for app_alias in connection.list_aliases():
-            table.add_row(
-                app_alias.alias,
-                app_alias.revision,
-                app_alias.auth_mode,
-                str(app_alias.max_concurrency),
-            )
+    for app_alias in aliases:
+        table.add_row(
+            app_alias.alias,
+            app_alias.revision,
+            app_alias.auth_mode,
+            str(app_alias.max_concurrency),
+            str(app_alias.max_multiplexing),
+            str(app_alias.keep_alive),
+        )
 
-    console.print(table)
+    return table
 
 
-@alias_cli.command("scale")
+@alias_cli.command("set")
 @click.argument("alias", required=True)
-@click.argument("max_concurrency", required=True, type=int)
+@click.argument("revision", required=True)
+@click.option(
+    "--auth",
+    "auth_mode",
+    type=click.Choice(ALIAS_AUTH_OPTIONS),
+    default="private",
+)
 @click.pass_obj
-def alias_scale(client: api.FalServerlessClient, alias: str, max_concurrency: int):
+def alias_set(
+    client: api.FalServerlessClient,
+    alias: str,
+    revision: str,
+    auth_mode: ALIAS_AUTH_TYPE,
+):
     with client.connect() as connection:
-        connection.scale(application_name=alias, max_concurrency=max_concurrency)
+        connection.create_alias(alias, revision, auth_mode)
 
 
-@alias_cli.command("update")
+@alias_cli.command("delete")
 @click.argument("alias", required=True)
-@click.option("--keep-alive", type=int)
 @click.pass_obj
-def alias_update(client: api.FalServerlessClient, alias: str, keep_alive: int | None):
+def alias_delete(client: api.FalServerlessClient, alias: str):
     with client.connect() as connection:
-        if not keep_alive:
-            console.log("No parameters for update were provided, ignoring.")
-            return
+        application_id = connection.delete_alias(alias)
 
-        connection.update_application(application_name=alias, keep_alive=keep_alive)
+        console.print(f"Deleted alias '{alias}' for application '{application_id}'.")
 
 
-##### Crons group #####
-@click.group
-@click.option("--host", default=DEFAULT_HOST, envvar=HOST_ENVVAR)
-@click.option("--port", default=DEFAULT_PORT, envvar=PORT_ENVVAR, hidden=True)
-@click.pass_context
-def crons_cli(ctx, host: str, port: str):
-    ctx.obj = api.FalServerlessHost(f"{host}:{port}")
-
-
-@crons_cli.command(name="list")
+@alias_cli.command("list")
 @click.pass_obj
-def list_scheduled(host: api.FalServerlessHost):
-    table = Table(title="Cronjobs")
-    table.add_column("Cron ID")
-    table.add_column("Cron")
-    table.add_column("ETA next run")
-    table.add_column("State")
-    for cron in host._connection.list_scheduled_runs():
-        state_string = ["Not Active", "Active"][cron.active]
-        table.add_row(cron.cron_id, cron.cron_string, str(cron.next_run), state_string)
+def alias_list(client: api.FalServerlessClient):
+    with client.connect() as connection:
+        aliases = connection.list_aliases()
+        table = _alias_table(aliases)
 
     console.print(table)
 
 
-@crons_cli.command(name="activations")
-@click.argument("cron_id", required=True)
-@click.argument("limit", default=15)
+@alias_cli.command("update")
+@click.argument("alias", required=True)
+@click.option("--keep-alive", "-k", type=int)
+@click.option("--max-multiplexing", "-m", type=int)
+@click.option("--max-concurrency", "-c", type=int)
+# TODO: add auth_mode
+# @click.option(
+#     "--auth",
+#     "auth_mode",
+#     type=click.Choice(ALIAS_AUTH_OPTIONS),
+# )
 @click.pass_obj
-def list_activations(host: api.FalServerlessHost, cron_id: str, limit: int = 15):
-    table = Table(title="Cron activations")
-    table.add_column("Activation ID")
-    table.add_column("Start Date")
-    table.add_column("Finish Date")
+def alias_update(
+    client: api.FalServerlessClient,
+    alias: str,
+    keep_alive: int | None,
+    max_multiplexing: int | None,
+    max_concurrency: int | None,
+):
+    with client.connect() as connection:
+        if keep_alive is None and max_multiplexing is None and max_concurrency is None:
+            console.log("No parameters for update were provided, ignoring.")
+            return
 
-    for activation in host._connection.list_run_activations(cron_id)[:limit]:
-        table.add_row(
-            str(activation.activation_id),
-            str(activation.started_at),
-            str(activation.finished_at),
+        alias_info = connection.update_application(
+            application_name=alias,
+            keep_alive=keep_alive,
+            max_multiplexing=max_multiplexing,
+            max_concurrency=max_concurrency,
         )
+        table = _alias_table([alias_info])
 
     console.print(table)
 
 
-@crons_cli.command(name="logs")
-@click.argument("cron_id", required=True)
-@click.argument("activation_id", required=True)
-@click.pass_obj
-def print_logs(host: api.FalServerlessHost, cron_id: str, activation_id: str):
-    logs = host._connection.get_activation_logs(cron_id, activation_id)
-    if not logs:
-        console.print(f"No logs found for activation {activation_id}")
-        return
-    log_printer = IsolateLogPrinter(debug=True)
-    for log in logs:
-        log_printer.print(log)
-
-
-@crons_cli.command("cancel")
-@click.argument("cron_id", required=True)
-@click.pass_obj
-def cancel_scheduled(host: api.FalServerlessHost, cron_id: str):
-    host._connection.cancel_scheduled_run(cron_id)
-    console.print("Cancelled", repr(cron_id))
+@alias_cli.command("scale")
+@click.argument("alias", required=True)
+@click.argument("max_concurrency", required=True, type=int)
+def alias_scale(alias: str, max_concurrency: int):
+    alias_update.callback(
+        alias=alias,
+        keep_alive=None,
+        max_multiplexing=None,
+        max_concurrency=max_concurrency,
+    )  # type: ignore
 
 
+##### Secrets group #####
 @click.group
 @click.option("--host", default=DEFAULT_HOST, envvar=HOST_ENVVAR)
 @click.option("--port", default=DEFAULT_PORT, envvar=PORT_ENVVAR, hidden=True)
@@ -511,11 +495,11 @@ def delete_secret(client: api.FalServerlessClient, secret_name: str):
         console.print(f"Secret '{secret_name}' has deleted")
 
 
+# Setup of groups
 cli.add_command(auth_cli, name="auth")
 cli.add_command(key_cli, name="key", aliases=["keys"])
 cli.add_command(function_cli, name="function", aliases=["fn"])
 cli.add_command(alias_cli, name="alias", aliases=["aliases"])
-cli.add_command(crons_cli, name="cron", aliases=["crons"])
 cli.add_command(secrets_cli, name="secret", aliases=["secrets"])
 
 

fal/rest_client.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import fal.flags as flags
 from fal.sdk import get_default_credentials
+
 from openapi_fal_rest.client import Client