fal 0.15.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

fal/cli/main.py

@@ -0,0 +1,82 @@
+import argparse
+
+import rich
+
+from fal import __version__
+from fal.console import console
+from fal.console.icons import CROSS_ICON
+
+from . import apps, auth, deploy, keys, run, secrets
+from .debug import debugtools, get_debug_parser
+from .parser import FalParser, FalParserExit
+
+
+def _get_main_parser() -> argparse.ArgumentParser:
+    parents = [get_debug_parser()]
+    parser = FalParser(
+        prog="fal",
+        parents=parents,
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=__version__,
+        help="Show fal version.",
+    )
+
+    subparsers = parser.add_subparsers(
+        title="Commands",
+        metavar="command",
+        required=True,
+    )
+
+    for cmd in [auth, apps, deploy, run, keys, secrets]:
+        cmd.add_parser(subparsers, parents)
+
+    return parser
+
+
+def parse_args(argv=None):
+    parser = _get_main_parser()
+    args = parser.parse_args(argv)
+    args.console = console
+    args.parser = parser
+    return args
+
+
+def main(argv=None) -> int:
+    import grpc
+
+    from fal.api import UserFunctionException
+
+    ret = 1
+    try:
+        args = parse_args(argv)
+
+        with debugtools(args):
+            ret = args.func(args)
+    except UserFunctionException as _exc:
+        cause = _exc.__cause__
+        exc: BaseException = cause or _exc
+        tb = rich.traceback.Traceback.from_exception(
+            type(exc),
+            exc,
+            exc.__traceback__,
+        )
+        console.print(tb)
+        console.print("Unhandled user exception")
+    except KeyboardInterrupt:
+        console.print("Aborted.")
+    except grpc.RpcError as exc:
+        console.print(exc.details())
+    except FalParserExit as exc:
+        ret = exc.status
+    except Exception as exc:
+        msg = f"{CROSS_ICON} {str(exc)}"
+        cause = exc.__cause__
+        if cause is not None:
+            msg += f": {str(cause)}"
+        console.print(msg)
+
+    return ret

fal/cli/parser.py

@@ -0,0 +1,74 @@
+import argparse
+import sys
+
+import rich_argparse
+
+
+class FalParserExit(Exception):
+    def __init__(self, status=0):
+        self.status = status
+
+
+class RefAction(argparse.Action):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("default", (None, None))
+        super().__init__(*args, **kwargs)
+
+    def __call__(self, parser, args, values, option_string=None):  # noqa: ARG002
+        if isinstance(values, tuple):
+            file_path, obj_path = values
+        elif values.find("::") > 1:
+            file_path, obj_path = values.split("::", 1)
+        else:
+            file_path, obj_path = values, None
+
+        setattr(args, self.dest, (file_path, obj_path))
+
+
+class DictAction(argparse.Action):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("metavar", "<name>=<value>")
+        super().__init__(*args, **kwargs)
+
+    def __call__(self, parser, args, values, option_string=None):  # noqa: ARG002
+        d = getattr(args, self.dest) or {}
+
+        if isinstance(values, list):
+            kvs = values
+        else:
+            kvs = [values]
+
+        for kv in kvs:
+            parts = kv.split("=", 1)
+            if len(parts) != 2:
+                raise argparse.ArgumentError(
+                    self,
+                    f'Could not parse argument "{values}" as k1=v1 k2=v2 ... format',
+                )
+            key, value = parts
+            d[key] = value
+
+        setattr(args, self.dest, d)
+
+
+class FalParser(argparse.ArgumentParser):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("formatter_class", rich_argparse.RawTextRichHelpFormatter)
+        super().__init__(*args, **kwargs)
+
+    def exit(self, status=0, message=None):
+        if message:
+            self._print_message(message, sys.stderr)
+        raise FalParserExit(status)
+
+
+class FalClientParser(FalParser):
+    def __init__(self, *args, **kwargs):
+        from fal.flags import GRPC_HOST
+
+        super().__init__(*args, **kwargs)
+        self.add_argument(
+            "--host",
+            default=GRPC_HOST,
+            help=argparse.SUPPRESS,
+        )

fal/cli/run.py

@@ -0,0 +1,33 @@
+from .parser import FalClientParser, RefAction
+
+
+def _run(args):
+    from fal.api import FalServerlessHost
+    from fal.utils import load_function_from
+
+    host = FalServerlessHost(args.host)
+    isolated_function, _ = load_function_from(host, *args.func_ref)
+    # let our exc handlers handle UserFunctionException
+    isolated_function.reraise = False
+    isolated_function()
+
+
+def add_parser(main_subparsers, parents):
+    run_help = "Run fal function."
+    epilog = (
+        "Examples:\n"
+        "  fal run path/to/myfile.py::myfunc"
+    )
+    parser = main_subparsers.add_parser(
+        "run",
+        description=run_help,
+        parents=[*parents, FalClientParser(add_help=False)],
+        help=run_help,
+        epilog=epilog,
+    )
+    parser.add_argument(
+        "func_ref",
+        action=RefAction,
+        help="Function reference.",
+    )
+    parser.set_defaults(func=_run)

fal/cli/secrets.py

@@ -0,0 +1,107 @@
+
+from .parser import DictAction, FalClientParser
+
+
+def _set(args):
+    from fal.sdk import FalServerlessClient
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        for name, value in args.secrets.items():
+            connection.set_secret(name, value)
+
+
+def _add_set_parser(subparsers, parents):
+    set_help = "Set a secret."
+    epilog = (
+        "Examples:\n"
+        "  fal secrets set HF_TOKEN=hf_***"
+    )
+
+    parser = subparsers.add_parser(
+        "set",
+        description=set_help,
+        help=set_help,
+        parents=parents,
+        epilog=epilog,
+    )
+    parser.add_argument(
+        "secrets",
+        metavar="NAME=VALUE",
+        nargs="+",
+        action=DictAction,
+        help="Secret NAME=VALUE pairs.",
+    )
+    parser.set_defaults(func=_set)
+
+
+def _list(args):
+    from rich.table import Table
+
+    from fal.sdk import FalServerlessClient
+
+    table = Table()
+    table.add_column("Secret Name")
+    table.add_column("Created At")
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        for secret in connection.list_secrets():
+            table.add_row(secret.name, str(secret.created_at))
+
+    args.console.print(table)
+
+
+def _add_list_parser(subparsers, parents):
+    list_help = "List secrets."
+    parser = subparsers.add_parser(
+        "list",
+        description=list_help,
+        help=list_help,
+        parents=parents,
+    )
+    parser.set_defaults(func=_list)
+
+
+def _unset(args):
+    from fal.sdk import FalServerlessClient
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        connection.delete_secret(args.secret)
+
+
+def _add_unset_parser(subparsers, parents):
+    unset_help = "Unset a secret."
+    parser = subparsers.add_parser(
+        "unset",
+        description=unset_help,
+        help=unset_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "secret",
+        metavar="NAME",
+        help="Secret's name.",
+    )
+    parser.set_defaults(func=_unset)
+
+
+def add_parser(main_subparsers, parents):
+    secrets_help = "Manage fal secrets."
+    parser = main_subparsers.add_parser(
+        "secrets",
+        aliases=["secret"],
+        parents=parents,
+        description=secrets_help,
+        help=secrets_help,
+    )
+
+    subparsers = parser.add_subparsers(
+        title="Commands",
+        metavar="command",
+        required=True,
+        parser_class=FalClientParser,
+    )
+
+    _add_set_parser(subparsers, parents)
+    _add_list_parser(subparsers, parents)
+    _add_unset_parser(subparsers, parents)

fal/exceptions/__init__.py

@@ -1,31 +1,3 @@
 from __future__ import annotations
 
 from ._base import FalServerlessException  # noqa: F401
-from .handlers import (
-    BaseExceptionHandler,
-    GrpcExceptionHandler,
-    UserFunctionExceptionHandler,
-)
-
-
-class ApplicationExceptionHandler:
-    """Handle exceptions top-level exceptions.
-
-    This exception handler is capable of handling, i.e. customize the output
-    and add behavior, of any type of exception. Click handles all `ClickException`
-    types by default, but prints the stack for other exception not wrapped in ClickException.
-
-    The handler also allows for central metrics and logging collection.
-    """
-
-    _handlers: list[BaseExceptionHandler] = [
-        GrpcExceptionHandler(),
-        UserFunctionExceptionHandler(),
-    ]
-
-    def handle(self, exception):
-        match_handler: BaseExceptionHandler = next(
-            (h for h in self._handlers if h.should_handle(exception)),
-            BaseExceptionHandler(),
-        )
-        match_handler.handle(exception)

fal/flags.py

@@ -18,8 +18,6 @@ GRPC_HOST = os.getenv("FAL_HOST", "api.alpha.fal.ai")
 if not TEST_MODE:
     assert GRPC_HOST.startswith("api"), "FAL_HOST must start with 'api'"
 
-GATEWAY_HOST = GRPC_HOST.replace("api", "gateway", 1)
-
 REST_HOST = GRPC_HOST.replace("api", "rest", 1)
 REST_SCHEME = "http" if TEST_MODE or AUTH_DISABLED else "https"
 REST_URL = f"{REST_SCHEME}://{REST_HOST}"
@@ -29,5 +27,4 @@ FAL_RUN_HOST = (
     GRPC_HOST.replace("api.", "", 1).replace("alpha.", "", 1).replace(".ai", ".run", 1)
 )
 
-FORCE_SETUP = bool_envvar("FAL_FORCE_SETUP")
 DONT_OPEN_LINKS = bool_envvar("FAL_DONT_OPEN_LINKS")

fal/logging/isolate.py

@@ -34,10 +34,10 @@ class IsolateLogPrinter:
             timestamp = log.timestamp
         else:
             # Default value for timestamp if user has old `isolate` version.
-            # Even if the controller version is controller by us, which means that the timestamp
-            # is being sent in the gRPC message.
-            # The `isolate` version users interpret that message with is out of our control.
-            # So we need to handle this case.
+            # Even if the controller version is controller by us, which means that
+            # the timestamp is being sent in the gRPC message.
+            # The `isolate` version users interpret that message with is out of our
+            # control. So we need to handle this case.
             timestamp = datetime.now(timezone.utc)
 
         event: EventDict = {

fal/sdk.py

@@ -8,17 +8,17 @@ from enum import Enum
 from typing import Any, Callable, Generic, Iterator, Literal, TypeVar
 
 import grpc
+import isolate_proto
 from isolate.connections.common import is_agent
 from isolate.logs import Log
 from isolate.server.interface import from_grpc, to_serialized_object, to_struct
+from isolate_proto.configuration import GRPC_OPTIONS
 
-import isolate_proto
 from fal import flags
 from fal._serialization import patch_pickle
 from fal.auth import USER, key_credentials
 from fal.logging import get_logger
 from fal.logging.trace import TraceContextInterceptor
-from isolate_proto.configuration import GRPC_OPTIONS
 
 ResultT = TypeVar("ResultT")
 InputT = TypeVar("InputT")
@@ -28,6 +28,7 @@ _DEFAULT_SERIALIZATION_METHOD = "cloudpickle"
 FAL_SERVERLESS_DEFAULT_KEEP_ALIVE = 10
 FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING = 1
 FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY = 0
+ALIAS_AUTH_MODES = ["public", "private", "shared"]
 
 logger = get_logger(__name__)
 
@@ -187,6 +188,16 @@ class HostedRunStatus:
     state: HostedRunState
 
 
+@dataclass
+class ApplicationInfo:
+    application_id: str
+    keep_alive: int
+    max_concurrency: int
+    max_multiplexing: int
+    active_runners: int
+    min_concurrency: int
+
+
 @dataclass
 class AliasInfo:
     alias: str
@@ -263,6 +274,20 @@ class KeyScope(enum.Enum):
             raise ValueError(f"Unknown KeyScope: {proto}")
 
 
+@from_grpc.register(isolate_proto.ApplicationInfo)
+def _from_grpc_application_info(
+    message: isolate_proto.ApplicationInfo
+) -> ApplicationInfo:
+    return ApplicationInfo(
+        application_id=message.application_id,
+        keep_alive=message.keep_alive,
+        max_concurrency=message.max_concurrency,
+        max_multiplexing=message.max_multiplexing,
+        active_runners=message.active_runners,
+        min_concurrency=message.min_concurrency,
+    )
+
+
 @from_grpc.register(isolate_proto.AliasInfo)
 def _from_grpc_alias_info(message: isolate_proto.AliasInfo) -> AliasInfo:
     if message.auth_mode is isolate_proto.ApplicationAuthMode.PUBLIC:
@@ -496,6 +521,18 @@ class FalServerlessConnection:
         )
         return from_grpc(res.alias_info)
 
+    def list_applications(self) -> list[ApplicationInfo]:
+        request = isolate_proto.ListApplicationsRequest()
+        res: isolate_proto.ListApplicationsResult = self.stub.ListApplications(request)
+        return [from_grpc(app) for app in res.applications]
+
+    def delete_application(
+        self,
+        application_id: str,
+    ) -> None:
+        request = isolate_proto.DeleteApplicationRequest(application_id=application_id)
+        self.stub.DeleteApplication(request)
+
     def run(
         self,
         function: Callable[..., ResultT],

fal/sync.py

@@ -31,7 +31,8 @@ def _upload_file(source_path: str, target_path: str, unzip: bool = False):
         body = upload_file_model.BodyUploadLocalFile(
             rest_types.File(
                 payload=file_to_upload,
-                # We need to set a file_name, otherwise the server errors processing the file
+                # We need to set a file_name, otherwise the server errors
+                # processing the file
                 file_name=os.path.basename(source_path),
             )
         )
@@ -45,7 +46,9 @@ def _upload_file(source_path: str, target_path: str, unzip: bool = False):
 
     if response.status_code != 200:
         raise Exception(
-            f"Failed to upload file. Server returned status code {response.status_code} and message {response.parsed}"
+            "Failed to upload file. "
+            "Server returned status code "
+            f"{response.status_code} and message {response.parsed}"
         )
 
 
@@ -94,7 +97,8 @@ def sync_dir(local_dir: str | Path, remote_dir: str, force_upload=False) -> str:
     local_dir_abs = os.path.expanduser(local_dir)
     if not os.path.isabs(remote_dir) or not remote_dir.startswith("/data"):
         raise ValueError(
-            "'remote_dir' must be an absolute path starting with `/data`, e.g. '/data/sync/my_dir'"
+            "'remote_dir' must be an absolute path starting with `/data`, "
+            "e.g. '/data/sync/my_dir'"
         )
 
     remote_dir = remote_dir.replace("/data/", "", 1)

fal/toolkit/file/file.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import shutil
 from pathlib import Path
 from tempfile import NamedTemporaryFile, mkdtemp
-from typing import Callable, Optional, Any
+from typing import Any, Callable, Optional
 from urllib.parse import urlparse
 from zipfile import ZipFile
 
@@ -13,8 +13,8 @@ import pydantic
 if not hasattr(pydantic, "__version__") or pydantic.__version__.startswith("1."):
     IS_PYDANTIC_V2 = False
 else:
-    from pydantic_core import core_schema, CoreSchema
     from pydantic import GetCoreSchemaHandler
+    from pydantic_core import CoreSchema, core_schema
     IS_PYDANTIC_V2 = True
 
 from pydantic import BaseModel, Field
@@ -57,22 +57,28 @@ class File(BaseModel):
         description="The URL where the file can be downloaded from.",
     )
     content_type: Optional[str] = Field(
-        None, description="The mime type of the file.",
+        None,
+        description="The mime type of the file.",
         examples=["image/png"],
     )
     file_name: Optional[str] = Field(
-        None, description="The name of the file. It will be auto-generated if not provided.",
+        None,
+        description="The name of the file. It will be auto-generated if not provided.",
         examples=["z9RV14K95DvU.png"],
     )
     file_size: Optional[int] = Field(
         None, description="The size of the file in bytes.", examples=[4404019]
     )
     file_data: Optional[bytes] = Field(
-        None, description="File data", exclude=True, repr=False,
+        None,
+        description="File data",
+        exclude=True,
+        repr=False,
     )
 
     # Pydantic custom validator for input type conversion
     if IS_PYDANTIC_V2:
+
         @classmethod
         def __get_pydantic_core_schema__(
             cls, source_type: Any, handler: GetCoreSchemaHandler
@@ -81,10 +87,12 @@ class File(BaseModel):
                 cls.__convert_from_str,
                 handler(source_type),
             )
+
     else:
+
         @classmethod
         def __get_validators__(cls):
-            yield cls.__convert_from_str  
+            yield cls.__convert_from_str
 
     @classmethod
     def __convert_from_str(cls, value: Any):

fal/toolkit/file/providers/fal.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import dataclasses
 import json
 import os
 from base64 import b64encode
@@ -14,6 +15,14 @@ from fal.toolkit.file.types import FileData, FileRepository
 _FAL_CDN = "https://fal.media"
 
 
+@dataclass
+class ObjectLifecyclePreference:
+    expriation_duration_seconds: int
+
+
+GLOBAL_LIFECYCLE_PREFERENCE = ObjectLifecyclePreference(expriation_duration_seconds=2)
+
+
 @dataclass
 class FalFileRepository(FileRepository):
     def save(self, file: FileData) -> str:
@@ -70,19 +79,27 @@ class FalFileRepository(FileRepository):
 
 @dataclass
 class InMemoryRepository(FileRepository):
-    def save(self, file: FileData) -> str:
+    def save(
+        self,
+        file: FileData,
+    ) -> str:
         return f'data:{file.content_type};base64,{b64encode(file.data).decode("utf-8")}'
 
 
 @dataclass
 class FalCDNFileRepository(FileRepository):
-    def save(self, file: FileData) -> str:
+    def save(
+        self,
+        file: FileData,
+    ) -> str:
         headers = {
             **self.auth_headers,
             "Accept": "application/json",
             "Content-Type": file.content_type,
+            "X-Fal-Object-Lifecycle-Preference": json.dumps(
+                dataclasses.asdict(GLOBAL_LIFECYCLE_PREFERENCE)
+            ),
         }
-
         url = os.getenv("FAL_CDN_HOST", _FAL_CDN) + "/files/upload"
         request = Request(url, headers=headers, method="POST", data=file.data)
         try:

fal/toolkit/image/image.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import io
 from tempfile import NamedTemporaryFile
-from typing import TYPE_CHECKING, Literal, Union, Optional
+from typing import TYPE_CHECKING, Literal, Optional, Union
 
 from pydantic import BaseModel, Field
 

fal/toolkit/optimize.py

@@ -4,7 +4,6 @@ import os
 import traceback
 from typing import TYPE_CHECKING, Any
 
-
 if TYPE_CHECKING:
     import torch
 

fal/toolkit/utils/download_utils.py

@@ -17,7 +17,10 @@ FAL_MODEL_WEIGHTS_DIR = FAL_PERSISTENT_DIR / ".fal" / "model_weights"
 
 # TODO: how can we randomize the user agent to avoid being blocked?
 TEMP_HEADERS = {
-    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
+    "User-Agent": (
+        "Mozilla/5.0 (Macintosh; "
+        "Intel Mac OS X 10.8; rv:21.0) Gecko/20100101 Firefox/21.0"
+    ),
 }
 
 
@@ -94,8 +97,8 @@ def _file_content_length_matches(url: str, file_path: Path) -> bool:
         file_path: The local path to the file being compared.
 
     Returns:
-        bool:`True` if the local file's content length matches the remote file's content length,
-              `False` otherwise.
+        bool: `True` if the local file's content length matches the remote file's
+            content length, `False` otherwise.
     """
     local_file_content_length = file_path.stat().st_size
     remote_file_content_length = _get_remote_file_properties(url)[1]

fal/utils.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import fal._serialization
+from fal import App, wrap_app
+
+from .api import FalServerlessError, FalServerlessHost, IsolatedFunction
+
+
+def load_function_from(
+    host: FalServerlessHost,
+    file_path: str,
+    function_name: str | None = None,
+) -> tuple[IsolatedFunction, str | None]:
+    import runpy
+
+    module = runpy.run_path(file_path)
+    if function_name is None:
+        fal_objects = {
+            obj.app_name: obj_name
+            for obj_name, obj in module.items()
+            if isinstance(obj, type)
+            and issubclass(obj, fal.App)
+            and hasattr(obj, "app_name")
+        }
+        if len(fal_objects) == 0:
+            raise FalServerlessError("No fal.App found in the module.")
+        elif len(fal_objects) > 1:
+            raise FalServerlessError(
+                "Multiple fal.Apps found in the module. "
+                "Please specify the name of the app."
+            )
+
+        [(app_name, function_name)] = fal_objects.items()
+    else:
+        app_name = None
+
+    module = runpy.run_path(file_path)
+    if function_name not in module:
+        raise FalServerlessError(f"Function '{function_name}' not found in module")
+
+    # The module for the function is set to <run_path> when runpy is used, in which
+    # case we want to manually include the package it is defined in.
+    fal._serialization.include_package_from_path(file_path)
+
+    target = module[function_name]
+    if isinstance(target, type) and issubclass(target, App):
+        app_name = target.app_name
+        target = wrap_app(target, host=host)
+
+    if not isinstance(target, IsolatedFunction):
+        raise FalServerlessError(
+            f"Function '{function_name}' is not a fal.function or a fal.App"
+        )
+    return target, app_name
+