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

fal/api.py

@@ -76,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(
@@ -118,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,
@@ -311,6 +308,7 @@ class FalServerlessHost(Host):
         {
             "machine_type",
             "keep_alive",
+            "max_concurrency",
             "max_multiplexing",
             "setup_function",
             "metadata",
@@ -341,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,
@@ -354,9 +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_multiplexing = options.host.get(
-            "max_multiplexing", FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING
-        )
+        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)
@@ -370,6 +366,7 @@ class FalServerlessHost(Host):
             scheduler=scheduler,
             scheduler_options=scheduler_options,
             max_multiplexing=max_multiplexing,
+            max_concurrency=max_concurrency,
         )
 
         partial_func = _prepare_partial_func(func)
@@ -394,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:
@@ -419,9 +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_multiplexing = options.host.get(
-            "max_multiplexing", FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING
-        )
+        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)
@@ -436,6 +431,7 @@ class FalServerlessHost(Host):
             scheduler=scheduler,
             scheduler_options=scheduler_options,
             max_multiplexing=max_multiplexing,
+            max_concurrency=max_concurrency,
         )
 
         return_value = _UNSET

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={},
     )
 
@@ -341,57 +344,113 @@ def alias_cli(ctx, host: str, port: str):
     ctx.obj = api.FalServerlessClient(f"{host}:{port}")
 
 
-@alias_cli.command("list")
+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 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),
+        )
+
+    return table
+
+
+@alias_cli.command("set")
+@click.argument("alias", required=True)
+@click.argument("revision", required=True)
+@click.option(
+    "--auth",
+    "auth_mode",
+    type=click.Choice(ALIAS_AUTH_OPTIONS),
+    default="private",
+)
 @click.pass_obj
-def alias_list(client: api.FalServerlessClient):
+def alias_set(
+    client: api.FalServerlessClient,
+    alias: str,
+    revision: str,
+    auth_mode: ALIAS_AUTH_TYPE,
+):
     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")
+        connection.create_alias(alias, revision, auth_mode)
 
-        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),
-            )
 
-    console.print(table)
+@alias_cli.command("delete")
+@click.argument("alias", required=True)
+@click.pass_obj
+def alias_delete(client: api.FalServerlessClient, alias: str):
+    with client.connect() as connection:
+        application_id = connection.delete_alias(alias)
 
+        console.print(f"Deleted alias '{alias}' for application '{application_id}'.")
 
-@alias_cli.command("scale")
-@click.argument("alias", required=True)
-@click.argument("max_concurrency", required=True, type=int)
+
+@alias_cli.command("list")
 @click.pass_obj
-def alias_scale(client: api.FalServerlessClient, alias: str, max_concurrency: int):
+def alias_list(client: api.FalServerlessClient):
     with client.connect() as connection:
-        connection.scale(application_name=alias, max_concurrency=max_concurrency)
+        aliases = connection.list_aliases()
+        table = _alias_table(aliases)
+
+    console.print(table)
 
 
 @alias_cli.command("update")
 @click.argument("alias", required=True)
-@click.option("--keep-alive", type=int)
-@click.option("--max-multiplexing", type=int)
+@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 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 not (keep_alive or max_multiplexing):
+        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
 
-        connection.update_application(
+        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)
+
+
+@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 #####

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
 
 

fal/sdk.py

@@ -184,7 +184,9 @@ class AliasInfo:
     alias: str
     revision: str
     auth_mode: str
+    keep_alive: int
     max_concurrency: int
+    max_multiplexing: int
 
 
 @dataclass
@@ -258,7 +260,9 @@ def _from_grpc_alias_info(message: isolate_proto.AliasInfo) -> AliasInfo:
         alias=message.alias,
         revision=message.revision,
         auth_mode=auth_mode,
+        keep_alive=message.keep_alive,
         max_concurrency=message.max_concurrency,
+        max_multiplexing=message.max_multiplexing,
     )
 
 
@@ -306,7 +310,8 @@ class MachineRequirements:
     exposed_port: int | None = None
     scheduler: str | None = None
     scheduler_options: dict[str, Any] | None = None
-    max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING
+    max_concurrency: int | None = None
+    max_multiplexing: int | None = None
 
 
 @dataclass
@@ -386,7 +391,6 @@ class FalServerlessConnection:
         application_name: str | None = None,
         application_auth_mode: Literal["public", "private", "shared"] | None = None,
         *,
-        max_concurrency: int | None = None,
         serialization_method: str = _DEFAULT_SERIALIZATION_METHOD,
         machine_requirements: MachineRequirements | None = None,
         metadata: dict[str, Any] | None = None,
@@ -402,6 +406,7 @@ class FalServerlessConnection:
                 scheduler_options=to_struct(
                     machine_requirements.scheduler_options or {}
                 ),
+                max_concurrency=machine_requirements.max_concurrency,
                 max_multiplexing=machine_requirements.max_multiplexing,
             )
         else:
@@ -423,7 +428,6 @@ class FalServerlessConnection:
             function=wrapped_function,
             environments=environments,
             machine_requirements=wrapped_requirements,
-            max_concurrency=max_concurrency,
             application_name=application_name,
             auth_mode=auth_mode,
             metadata=struct_metadata,
@@ -432,24 +436,25 @@ class FalServerlessConnection:
             yield from_grpc(partial_result)
 
     def scale(self, application_name: str, max_concurrency: int | None = None) -> None:
-        request = isolate_proto.ScaleApplicationRequest(
-            application_name=application_name,
-            max_concurrency=max_concurrency,
-        )
-        self.stub.ScaleApplication(request)
+        raise NotImplementedError
 
     def update_application(
         self,
         application_name: str,
         keep_alive: int | None = None,
         max_multiplexing: int | None = None,
-    ) -> None:
+        max_concurrency: int | None = None,
+    ) -> AliasInfo:
         request = isolate_proto.UpdateApplicationRequest(
             application_name=application_name,
             keep_alive=keep_alive,
             max_multiplexing=max_multiplexing,
+            max_concurrency=max_concurrency,
+        )
+        res: isolate_proto.UpdateApplicationResult = self.stub.UpdateApplication(
+            request
         )
-        self.stub.UpdateApplication(request)
+        return from_grpc(res.alias_info)
 
     def run(
         self,
@@ -471,6 +476,7 @@ class FalServerlessConnection:
                 scheduler_options=to_struct(
                     machine_requirements.scheduler_options or {}
                 ),
+                max_concurrency=machine_requirements.max_concurrency,
                 max_multiplexing=machine_requirements.max_multiplexing,
             )
         else:
@@ -488,6 +494,31 @@ class FalServerlessConnection:
         for partial_result in self.stub.Run(request):
             yield from_grpc(partial_result)
 
+    def create_alias(
+        self,
+        alias: str,
+        revision: str,
+        auth_mode: Literal["public", "private", "shared"],
+    ):
+        if auth_mode == "public":
+            auth = isolate_proto.ApplicationAuthMode.PUBLIC
+        elif auth_mode == "shared":
+            auth = isolate_proto.ApplicationAuthMode.SHARED
+        else:
+            auth = isolate_proto.ApplicationAuthMode.PRIVATE
+
+        request = isolate_proto.SetAliasRequest(
+            alias=alias,
+            revision=revision,
+            auth_mode=auth,
+        )
+        self.stub.SetAlias(request)
+
+    def delete_alias(self, alias: str) -> str:
+        request = isolate_proto.DeleteAliasRequest(alias=alias)
+        res: isolate_proto.DeleteAliasResult = self.stub.DeleteAlias(request)
+        return res.revision
+
     def list_aliases(self) -> list[AliasInfo]:
         request = isolate_proto.ListAliasesRequest()
         response: isolate_proto.ListAliasesResult = self.stub.ListAliases(request)

fal/sync.py

@@ -5,13 +5,14 @@ import os
 import zipfile
 from pathlib import Path
 
+from fal.rest_client import REST_CLIENT
+from pathspec import PathSpec
+
 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 fal.rest_client import REST_CLIENT
-from pathspec import PathSpec
 
 
 def _check_hash(target_path: str, hash_string: str) -> bool:

fal/toolkit/file/file.py

@@ -1,25 +1,26 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Callable, Literal
+from typing import Callable
 
 from fal.toolkit.file.providers.fal import FalFileRepository, InMemoryRepository
 from fal.toolkit.file.providers.gcp import GoogleStorageRepository
+from fal.toolkit.file.providers.r2 import R2Repository
 from fal.toolkit.file.types import FileData, FileRepository, RepositoryId
 from fal.toolkit.mainify import mainify
 from pydantic import BaseModel, Field, PrivateAttr
 
-BuiltInRepositoryId = Literal["fal", "in_memory", "gcp_storage"]
 FileRepositoryFactory = Callable[[], FileRepository]
 
-BUILT_IN_REPOSITORIES: dict[BuiltInRepositoryId, FileRepositoryFactory] = {
+BUILT_IN_REPOSITORIES: dict[RepositoryId, FileRepositoryFactory] = {
     "fal": lambda: FalFileRepository(),
     "in_memory": lambda: InMemoryRepository(),
     "gcp_storage": lambda: GoogleStorageRepository(),
+    "r2": lambda: R2Repository(),
 }
 
 
-def get_builtin_repository(id: BuiltInRepositoryId) -> FileRepository:
+def get_builtin_repository(id: RepositoryId) -> FileRepository:
     if id not in BUILT_IN_REPOSITORIES.keys():
         raise ValueError(f'"{id}" is not a valid built-in file repository')
     return BUILT_IN_REPOSITORIES[id]()
@@ -27,7 +28,7 @@ def get_builtin_repository(id: BuiltInRepositoryId) -> FileRepository:
 
 get_builtin_repository.__module__ = "__main__"
 
-DEFAULT_REPOSITORY: FileRepository | BuiltInRepositoryId = "fal"
+DEFAULT_REPOSITORY: FileRepository | RepositoryId = "fal"
 
 
 @mainify

fal/toolkit/file/providers/r2.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from io import BytesIO
+
+from fal.toolkit.file.types import FileData, FileRepository
+from fal.toolkit.mainify import mainify
+
+DEFAULT_URL_TIMEOUT = 60 * 15  # 15 minutes
+
+
+@mainify
+@dataclass
+class R2Repository(FileRepository):
+    bucket_name: str = "fal_file_storage"
+    url_expiration: int = DEFAULT_URL_TIMEOUT
+    r2_account_json: str | None = None
+    key: str = ""
+
+    _storage_client = None
+    _bucket = None
+
+    def __post_init__(self):
+        import boto3
+        from botocore.client import Config
+
+        r2_account_json = self.r2_account_json
+        if r2_account_json is None:
+            r2_account_json = os.environ.get("R2_CREDS_JSON")
+            if r2_account_json is None:
+                raise Exception("R2_CREDS_JSON environment secret is not set")
+
+        r2_account_info = json.loads(r2_account_json)
+        account_id = r2_account_info["ACCOUNT_ID"]
+        access_key_id = r2_account_info["ACCESS_KEY_ID"]
+        secret_access_key = r2_account_info["SECRET_ACCESS_KEY"]
+
+        self._s3_client = boto3.client(
+            "s3",
+            endpoint_url=f"https://{account_id}.r2.cloudflarestorage.com",
+            aws_access_key_id=access_key_id,
+            aws_secret_access_key=secret_access_key,
+            config=Config(signature_version="s3v4"),
+        )
+        self._s3_resource = boto3.resource(
+            "s3",
+            endpoint_url=f"https://{account_id}.r2.cloudflarestorage.com",
+            aws_access_key_id=access_key_id,
+            aws_secret_access_key=secret_access_key,
+        )
+
+        self._bucket = self._s3_resource.Bucket(self.bucket_name)
+
+    @property
+    def storage_client(self):
+        if self._s3_resource is None:
+            raise Exception("S3 Resource is not initialized")
+
+        return self._s3_resource
+
+    @property
+    def bucket(self):
+        if self._bucket is None:
+            raise Exception("S3 bucket is not initialized")
+
+        return self._bucket
+
+    def save(self, data: FileData) -> str:
+        destination_path = os.path.join(self.key, data.file_name)
+
+        s3_object = self.bucket.Object(destination_path)
+        s3_object.upload_fileobj(
+            BytesIO(data.data), ExtraArgs={"ContentType": data.content_type}
+        )
+
+        public_url = self._s3_client.generate_presigned_url(
+            ClientMethod="get_object",
+            Params={"Bucket": self.bucket_name, "Key": destination_path},
+            ExpiresIn=self.url_expiration,
+        )
+        return public_url

fal/toolkit/file/types.py

@@ -31,7 +31,7 @@ class FileData:
             self.file_name = file_name
 
 
-RepositoryId = Literal["fal", "in_memory", "gcp_storage"]
+RepositoryId = Literal["fal", "in_memory", "gcp_storage", "r2"]
 
 
 @mainify

fal/toolkit/image/image.py

@@ -25,10 +25,10 @@ ImageSizePreset = Literal[
 @mainify
 class ImageSize(BaseModel):
     width: int = Field(
-        default=512, description="The width of the generated image.", gt=0, le=4096
+        default=512, description="The width of the generated image.", gt=0, le=14142
     )
     height: int = Field(
-        default=512, description="The height of the generated image.", gt=0, le=4096
+        default=512, description="The height of the generated image.", gt=0, le=14142
     )
 
 

{fal-0.11.2.dist-info → fal-0.11.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fal
-Version: 0.11.2
+Version: 0.11.3
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels
 Author-email: hello@fal.ai
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: attrs (>=21.3.0)
 Requires-Dist: auth0-python (>=4.1.0,<5.0.0)
+Requires-Dist: boto3 (>=1.33.8,<2.0.0)
 Requires-Dist: click (>=8.1.3,<9.0.0)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: datadog-api-client (==2.12.0)
@@ -21,7 +22,7 @@ Requires-Dist: grpc-interceptor (>=0.15.0,<0.16.0)
 Requires-Dist: grpcio (>=1.50.0,<2.0.0)
 Requires-Dist: httpx (>=0.15.4,<0.25.0)
 Requires-Dist: importlib-metadata (>=4.4) ; python_version < "3.10"
-Requires-Dist: isolate-proto (==0.2.0)
+Requires-Dist: isolate-proto (>=0.2.1,<0.3.0)
 Requires-Dist: isolate[build] (>=0.12.3,<1.0)
 Requires-Dist: opentelemetry-api (>=1.15.0,<2.0.0)
 Requires-Dist: opentelemetry-sdk (>=1.15.0,<2.0.0)
@@ -43,5 +44,41 @@ fal is a serverless Python runtime that lets you run and scale code in the cloud
 
 With fal, you can build pipelines, serve ML models and scale them up to many users. You scale down to 0 when you don't use any resources.
 
-Check out to the [docs](https://serverless.fal.ai/docs) for more details.
+## Quickstart
+
+First, you need to install the `fal` package. You can do so using pip:
+```shell
+pip install fal
+```
+
+Then you need to authenticate:
+```shell
+fal auth login
+```
+
+You can also use fal keys that you can get from [our dashboard](https://fal.ai/dashboard/keys).
+
+Now can use the fal package in your Python scripts as follows:
+
+```py
+import fal
+
+@fal.function(
+    "virtualenv",
+    requirements=["pyjokes"],
+)
+def tell_joke() -> str:
+    import pyjokes
+
+    joke = pyjokes.get_joke()
+    return joke
+
+print("Joke from the clouds: ", tell_joke())
+```
+
+A new virtual environment will be created by fal in the cloud and the set of requirements that we passed will be installed as soon as this function is called. From that point on, our code will be executed as if it were running locally, and the joke prepared by the pyjokes library will be returned.
+
+## Next steps
+
+If you would like to find out more about the capabilities of fal, check out to the [docs](https://fal.ai/docs). You can learn more about persistent storage, function caches and deploying your functions as API endpoints.