fal 1.12.1__tar.gz → 1.13.0__tar.gz

{fal-1.12.1/fal.egg-info → fal-1.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fal
-Version: 1.12.1
+Version: 1.13.0
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8

{fal-1.12.1 → fal-1.13.0/fal.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fal
-Version: 1.12.1
+Version: 1.13.0
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8

{fal-1.12.1 → fal-1.13.0}/src/fal/_fal_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.12.1'
-__version_tuple__ = version_tuple = (1, 12, 1)
+__version__ = version = '1.13.0'
+__version_tuple__ = version_tuple = (1, 13, 0)

{fal-1.12.1 → fal-1.13.0}/src/fal/api.py

@@ -12,6 +12,7 @@ from functools import wraps
 from os import PathLike
 from queue import Queue
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     ClassVar,
@@ -27,15 +28,11 @@ from typing import (
 
 import cloudpickle
 import grpc
-import isolate
 import tblib
 import uvicorn
 import yaml
 from fastapi import FastAPI
 from fastapi import __version__ as fastapi_version
-from isolate.backends.common import active_python
-from isolate.backends.settings import DEFAULT_SETTINGS
-from isolate.connections import PythonIPC
 from packaging.requirements import Requirement
 from packaging.utils import canonicalize_name
 from pydantic import __version__ as pydantic_version
@@ -66,6 +63,9 @@ from fal.sdk import (
     get_default_credentials,
 )
 
+if TYPE_CHECKING:
+    from isolate.backends import BaseEnvironment
+
 ArgsT = ParamSpec("ArgsT")
 ReturnT = TypeVar("ReturnT", covariant=True)  # noqa: PLC0105
 
@@ -83,9 +83,6 @@ SERVE_REQUIREMENTS = [
 ]
 
 
-THREAD_POOL = ThreadPoolExecutor()
-
-
 @dataclass
 class FalServerlessError(FalServerlessException):
     message: str
@@ -222,9 +219,10 @@ def cached(func: Callable[ArgsT, ReturnT]) -> Callable[ArgsT, ReturnT]:
     ) -> ReturnT:
         from functools import lru_cache
 
-        # HACK: Using the isolate module as a global cache.
         import isolate
 
+        # HACK: Using the isolate module as a global cache.
+
         if not hasattr(isolate, "__cached_functions__"):
             isolate.__cached_functions__ = {}
 
@@ -269,17 +267,23 @@ def _prepare_partial_func(
     return wrapper
 
 
-@dataclass
-class LocalHost(Host):
-    # The environment which provides the default set of
-    # packages for isolate agent to run.
-    _AGENT_ENVIRONMENT = isolate.prepare_environment(
+def _prepare_environment() -> BaseEnvironment:
+    import isolate
+
+    return isolate.prepare_environment(
         "virtualenv",
         requirements=[
             f"cloudpickle=={cloudpickle.__version__}",
             f"tblib=={tblib.__version__}",
         ],
     )
+
+
+@dataclass
+class LocalHost(Host):
+    # The environment which provides the default set of
+    # packages for isolate agent to run.
+    _AGENT_ENVIRONMENT: BaseEnvironment = field(default_factory=_prepare_environment)
     _log_printer = IsolateLogPrinter(debug=flags.DEBUG)
 
     def run(
@@ -289,6 +293,10 @@ class LocalHost(Host):
         args: tuple[Any, ...],
         kwargs: dict[str, Any],
     ) -> ReturnT:
+        import isolate
+        from isolate.backends.settings import DEFAULT_SETTINGS
+        from isolate.connections import PythonIPC
+
         settings = replace(
             DEFAULT_SETTINGS,
             serialization_method="cloudpickle",
@@ -419,8 +427,16 @@ class FalServerlessHost(Host):
 
     _log_printer = IsolateLogPrinter(debug=flags.DEBUG)
 
+    _thread_pool: ThreadPoolExecutor = field(default_factory=ThreadPoolExecutor)
+
+    def __getstate__(self) -> dict[str, Any]:
+        state = self.__dict__.copy()
+        state["_thread_pool"] = None
+        return state
+
     def __setstate__(self, state: dict[str, Any]) -> None:
         self.__dict__.update(state)
+        self._thread_pool = ThreadPoolExecutor()
         self.credentials = get_agent_credentials(self.credentials)
 
     @property
@@ -440,6 +456,8 @@ class FalServerlessHost(Host):
         deployment_strategy: Literal["recreate", "rolling"] = "recreate",
         scale: bool = True,
     ) -> str | None:
+        from isolate.backends.common import active_python
+
         environment_options = options.environment.copy()
         environment_options.setdefault("python_version", active_python())
         environments = [self._connection.define_environment(**environment_options)]
@@ -517,6 +535,8 @@ class FalServerlessHost(Host):
         kwargs: dict[str, Any],
         result_handler: Callable[..., None],
     ) -> ReturnT:
+        from isolate.backends.common import active_python
+
         environment_options = options.environment.copy()
         environment_options.setdefault("python_version", active_python())
         environments = [self._connection.define_environment(**environment_options)]
@@ -611,7 +631,7 @@ class FalServerlessHost(Host):
                     ret.url = log.message.rsplit()[-1]
                 ret.logs.put(log)
 
-        THREAD_POOL.submit(
+        self._thread_pool.submit(
             self._run,
             func,
             options,
@@ -654,7 +674,6 @@ class Options:
             return self.gateway.get("exposed_port")
 
 
-_DEFAULT_HOST = FalServerlessHost()
 _SERVE_PORT = 8080
 
 # Overload @function to help users identify the correct signature.
@@ -704,7 +723,7 @@ def function(
     python_version: str | None = None,
     requirements: list[str] | None = None,
     # Common options
-    host: FalServerlessHost = _DEFAULT_HOST,
+    host: FalServerlessHost | None = None,
     serve: Literal[False] = False,
     exposed_port: int | None = None,
     max_concurrency: int | None = None,
@@ -733,7 +752,7 @@ def function(
     python_version: str | None = None,
     requirements: list[str] | None = None,
     # Common options
-    host: FalServerlessHost = _DEFAULT_HOST,
+    host: FalServerlessHost | None = None,
     serve: Literal[True],
     exposed_port: int | None = None,
     max_concurrency: int | None = None,
@@ -812,7 +831,7 @@ def function(
     pip: list[str] | None = None,
     channels: list[str] | None = None,
     # Common options
-    host: FalServerlessHost = _DEFAULT_HOST,
+    host: FalServerlessHost | None = None,
     serve: Literal[False] = False,
     exposed_port: int | None = None,
     max_concurrency: int | None = None,
@@ -846,7 +865,7 @@ def function(
     pip: list[str] | None = None,
     channels: list[str] | None = None,
     # Common options
-    host: FalServerlessHost = _DEFAULT_HOST,
+    host: FalServerlessHost | None = None,
     serve: Literal[True],
     exposed_port: int | None = None,
     max_concurrency: int | None = None,
@@ -874,7 +893,7 @@ def function(
     *,
     image: ContainerImage | None = None,
     # Common options
-    host: FalServerlessHost = _DEFAULT_HOST,
+    host: FalServerlessHost | None = None,
     serve: Literal[False] = False,
     exposed_port: int | None = None,
     max_concurrency: int | None = None,
@@ -902,7 +921,7 @@ def function(
     *,
     image: ContainerImage | None = None,
     # Common options
-    host: FalServerlessHost = _DEFAULT_HOST,
+    host: FalServerlessHost | None = None,
     serve: Literal[True],
     exposed_port: int | None = None,
     max_concurrency: int | None = None,
@@ -928,15 +947,17 @@ def function(
 def function(  # type: ignore
     kind: str = "virtualenv",
     *,
-    host: Host = _DEFAULT_HOST,
+    host: Host | None = None,
     **config: Any,
 ):
+    if host is None:
+        host = FalServerlessHost()
     options = host.parse_options(kind=kind, **config)
 
     def wrapper(func: Callable[ArgsT, ReturnT]):
         include_modules_from(func)
         proxy = IsolatedFunction(
-            host=host,
+            host=host,  # type: ignore
             raw_func=func,  # type: ignore
             options=options,
         )

{fal-1.12.1 → fal-1.13.0}/src/fal/app.py

@@ -16,11 +16,17 @@ from typing import Any, Callable, ClassVar, Literal, TypeVar
 import fastapi
 import grpc.aio as async_grpc
 import httpx
-from isolate.server import definitions
 
-import fal.api
 from fal._serialization import include_modules_from
-from fal.api import RouteSignature
+from fal.api import (
+    SERVE_REQUIREMENTS,
+    BaseServable,
+    IsolatedFunction,
+    RouteSignature,
+)
+from fal.api import (
+    function as fal_function,
+)
 from fal.exceptions import FalServerlessException, RequestCancelledException
 from fal.logging import get_logger
 from fal.toolkit.file import request_lifecycle_preference
@@ -70,6 +76,8 @@ async def _set_logger_labels(
     try:
         import sys
 
+        from isolate.server import definitions
+
         # Flush any prints that were buffered before setting the logger labels
         sys.stderr.flush()
         sys.stdout.flush()
@@ -89,7 +97,7 @@ async def _set_logger_labels(
         pass
 
 
-def wrap_app(cls: type[App], **kwargs) -> fal.api.IsolatedFunction:
+def wrap_app(cls: type[App], **kwargs) -> IsolatedFunction:
     include_modules_from(cls)
 
     def initialize_and_serve():
@@ -111,7 +119,7 @@ def wrap_app(cls: type[App], **kwargs) -> fal.api.IsolatedFunction:
     if kind == "container":
         cls.host_kwargs.pop("resolver", None)
 
-    wrapper = fal.api.function(
+    wrapper = fal_function(
         kind,
         requirements=cls.requirements,
         machine_type=cls.machine_type,
@@ -123,7 +131,7 @@ def wrap_app(cls: type[App], **kwargs) -> fal.api.IsolatedFunction:
         serve=False,
     )
     fn = wrapper(initialize_and_serve)
-    fn.options.add_requirements(fal.api.SERVE_REQUIREMENTS)
+    fn.options.add_requirements(SERVE_REQUIREMENTS)
     if realtime_app:
         fn.options.add_requirements(REALTIME_APP_REQUIREMENTS)
 
@@ -255,7 +263,7 @@ def _print_python_packages() -> None:
     print("[debug] Python packages installed:", ", ".join(packages))
 
 
-class App(fal.api.BaseServable):
+class App(BaseServable):
     requirements: ClassVar[list[str]] = []
     machine_type: ClassVar[str] = "S"
     num_gpus: ClassVar[int | None] = None

{fal-1.12.1 → fal-1.13.0}/src/fal/apps.py

@@ -4,6 +4,7 @@ import json
 import time
 from contextlib import contextmanager
 from dataclasses import dataclass, field
+from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Iterator
 
 import httpx
@@ -14,6 +15,7 @@ from fal.sdk import Credentials, get_default_credentials
 if TYPE_CHECKING:
     from websockets.sync.connection import Connection
 
+_STREAM_URL_FORMAT = f"https://{flags.FAL_RUN_HOST}/{{app_id}}"
 _QUEUE_URL_FORMAT = f"https://queue.{flags.FAL_RUN_HOST}/{{app_id}}"
 _REALTIME_URL_FORMAT = f"wss://{flags.FAL_RUN_HOST}/{{app_id}}"
 _WS_URL_FORMAT = f"wss://ws.{flags.FAL_RUN_HOST}/{{app_id}}"
@@ -55,6 +57,11 @@ class Completed(_Status):
     logs: list[dict[str, Any]] | None = field()
 
 
+@lru_cache(maxsize=1)
+def _get_http_client() -> httpx.Client:
+    return httpx.Client(headers={"User-Agent": "Fal/Python"})
+
+
 @dataclass
 class RequestHandle:
     """A handle to an async inference request."""
@@ -62,6 +69,8 @@ class RequestHandle:
     app_id: str
     request_id: str
 
+    _client: httpx.Client = field(default_factory=_get_http_client)
+
     # Use the credentials that were used to submit the request by default.
     _creds: Credentials = field(default_factory=get_default_credentials, repr=False)
 
@@ -82,7 +91,7 @@ class RequestHandle:
             _QUEUE_URL_FORMAT.format(app_id=self.app_id)
             + f"/requests/{self.request_id}/status/"
         )
-        response = _HTTP_CLIENT.get(
+        response = self._client.get(
             url,
             headers=self._creds.to_headers(),
             params={"logs": int(logs)},
@@ -107,7 +116,7 @@ class RequestHandle:
             _QUEUE_URL_FORMAT.format(app_id=self.app_id)
             + f"/requests/{self.request_id}/cancel"
         )
-        response = _HTTP_CLIENT.put(url, headers=self._creds.to_headers())
+        response = self._client.put(url, headers=self._creds.to_headers())
         response.raise_for_status()
 
     def iter_events(
@@ -134,7 +143,7 @@ class RequestHandle:
             _QUEUE_URL_FORMAT.format(app_id=self.app_id)
             + f"/requests/{self.request_id}/"
         )
-        response = _HTTP_CLIENT.get(url, headers=self._creds.to_headers())
+        response = self._client.get(url, headers=self._creds.to_headers())
         try:
             response.raise_for_status()
         except httpx.HTTPStatusError as e:
@@ -159,7 +168,33 @@ class RequestHandle:
         return self.fetch_result()
 
 
-_HTTP_CLIENT = httpx.Client(headers={"User-Agent": "Fal/Python"})
+def stream(
+    app_id: str, arguments: dict[str, Any], *, path: str = ""
+) -> Iterator[str | bytes]:
+    """Stream an inference task on a Fal app."""
+
+    app_id = _backwards_compatible_app_id(app_id)
+    url = _STREAM_URL_FORMAT.format(app_id=app_id)
+    if path:
+        _path = path[len("/") :] if path.startswith("/") else path
+        url += "/" + _path
+
+    creds = get_default_credentials()
+    client = _get_http_client()
+
+    response = client.post(
+        url,
+        json=arguments,
+        headers=creds.to_headers(),
+    )
+    response.raise_for_status()
+
+    if response.headers["Content-Type"].startswith("text/event-stream"):
+        for line in response.iter_lines():
+            if line:
+                yield line
+    else:
+        yield from response.iter_bytes()
 
 
 def run(app_id: str, arguments: dict[str, Any], *, path: str = "") -> dict[str, Any]:
@@ -181,8 +216,9 @@ def submit(app_id: str, arguments: dict[str, Any], *, path: str = "") -> Request
         url += "/" + _path
 
     creds = get_default_credentials()
+    client = _get_http_client()
 
-    response = _HTTP_CLIENT.post(
+    response = client.post(
         url,
         json=arguments,
         headers=creds.to_headers(),
@@ -194,6 +230,7 @@ def submit(app_id: str, arguments: dict[str, Any], *, path: str = "") -> Request
         app_id=app_id,
         request_id=data["request_id"],
         _creds=creds,
+        _client=client,
     )
 
 

{fal-1.12.1 → fal-1.13.0}/src/fal/auth/__init__.py

@@ -7,8 +7,6 @@ from typing import Optional
 
 from fal.auth import auth0, local
 from fal.config import Config
-from fal.console import console
-from fal.console.icons import CHECK_ICON
 from fal.exceptions import FalServerlessException
 from fal.exceptions.auth import UnauthenticatedException
 
@@ -73,26 +71,6 @@ def key_credentials() -> tuple[str, str] | None:
         return None
 
 
-def login():
-    token_data = auth0.login()
-    with local.lock_token():
-        local.save_token(token_data["refresh_token"])
-
-    USER.invalidate()
-
-
-def logout():
-    refresh_token, _ = local.load_token()
-    if refresh_token is None:
-        raise FalServerlessException("You're not logged in")
-    auth0.revoke(refresh_token)
-    with local.lock_token():
-        local.delete_token()
-
-    USER.invalidate()
-    console.print(f"{CHECK_ICON} Logged out of [cyan bold]fal[/]. Bye!")
-
-
 def _fetch_access_token() -> str:
     """
     Load the refresh token, request a new access_token (refreshing the refresh token)
@@ -147,6 +125,21 @@ def _fetch_teams(bearer_token: str) -> list[dict]:
         raise FalServerlessException("Failed to fetch teams") from exc
 
 
+def login(console):
+    token_data = auth0.login(console)
+    with local.lock_token():
+        local.save_token(token_data["refresh_token"])
+
+
+def logout(console):
+    refresh_token, _ = local.load_token()
+    if refresh_token is None:
+        raise FalServerlessException("You're not logged in")
+    auth0.revoke(refresh_token, console)
+    with local.lock_token():
+        local.delete_token()
+
+
 @dataclass
 class UserAccess:
     _access_token: str | None = field(repr=False, default=None)
@@ -154,12 +147,6 @@ class UserAccess:
     _exc: Exception | None = field(repr=False, default=None)
     _accounts: list[dict] | None = field(repr=False, default=None)
 
-    def invalidate(self) -> None:
-        self._access_token = None
-        self._user_info = None
-        self._exc = None
-        self._accounts = None
-
     @property
     def info(self) -> dict:
         if self._user_info is None:
@@ -203,6 +190,3 @@ class UserAccess:
             if t["nickname"].lower() == team.lower():
                 return t
         raise ValueError(f"Team {team} not found")
-
-
-USER = UserAccess()

{fal-1.12.1 → fal-1.13.0}/src/fal/auth/auth0.py

@@ -6,8 +6,6 @@ import warnings
 
 import httpx
 
-from fal.console import console
-from fal.console.icons import CHECK_ICON
 from fal.console.ux import maybe_open_browser_tab
 from fal.exceptions import FalServerlessException
 
@@ -26,7 +24,7 @@ def logout_url(return_url: str):
     return f"https://{AUTH0_DOMAIN}/v2/logout?client_id={AUTH0_CLIENT_ID}&returnTo={return_url}"
 
 
-def _open_browser(url: str, code: str | None) -> None:
+def _open_browser(url: str, code: str | None, console) -> None:
     maybe_open_browser_tab(url)
 
     console.print(
@@ -41,7 +39,7 @@ def _open_browser(url: str, code: str | None) -> None:
         )
 
 
-def login() -> dict:
+def login(console) -> dict:
     """
     Runs the device authorization flow and stores the user object in memory
     """
@@ -63,7 +61,7 @@ def login() -> dict:
 
     url = logout_url(device_confirmation_url)
 
-    _open_browser(url, device_user_code)
+    _open_browser(url, device_user_code, console)
 
     # This is needed to suppress the ResourceWarning emitted
     # when the process is waiting for user confirmation
@@ -84,7 +82,6 @@ def login() -> dict:
             token_data = token_response.json()
             if token_response.status_code == 200:
                 status.update(spinner=None)
-                console.print(f"{CHECK_ICON} Authenticated successfully, welcome!")
 
                 validate_id_token(token_data["id_token"])
 
@@ -118,7 +115,7 @@ def refresh(token: str) -> dict:
         raise FalServerlessException(token_data["error_description"])
 
 
-def revoke(token: str):
+def revoke(token: str, console):
     token_payload = {
         "client_id": AUTH0_CLIENT_ID,
         "token": token,
@@ -132,7 +129,7 @@ def revoke(token: str):
         token_data = token_response.json()
         raise FalServerlessException(token_data["error_description"])
 
-    _open_browser(logout_url(WEBSITE_URL), None)
+    _open_browser(logout_url(WEBSITE_URL), None, console)
 
 
 def get_user_info(bearer_token: str) -> dict:

{fal-1.12.1 → fal-1.13.0}/src/fal/cli/api.py

@@ -10,19 +10,38 @@ KV_SPLIT_RE = re.compile(r"(=|:=)")
 
 def _api(args):
     """Handle the api command execution."""
-    from rich.console import Group
-    from rich.live import Live
-    from rich.panel import Panel
-    from rich.text import Text
-
     from . import cli_nested_json
 
-    params = [KV_SPLIT_RE.split(param) for param in args.params]
+    params_split = [KV_SPLIT_RE.split(param) for param in args.params]
     params = cli_nested_json.interpret_nested_json(  # type: ignore
-        [(key, value) for key, _, value in params]
+        [(key, value) for key, _, value in params_split]
     )
 
-    handle = fal.apps.submit(args.model_id, params)  # type: ignore
+    if args.model_id.endswith("/stream"):
+        stream_run(args.model_id, params)
+    else:
+        queue_run(args.model_id, params)
+
+
+def stream_run(model_id: str, params: dict):
+    res = fal.apps.stream(model_id, params)  # type: ignore
+    for line in res:
+        if isinstance(line, str):
+            rich.print(line)
+        else:
+            if isinstance(line, memoryview):
+                rich.print(line.tobytes().decode())
+            else:
+                rich.print(line.decode())
+
+
+def queue_run(model_id: str, params: dict):
+    from rich.console import Group
+    from rich.live import Live
+    from rich.panel import Panel
+    from rich.text import Text
+
+    handle = fal.apps.submit(model_id, params)  # type: ignore
     logs = []  # type: ignore
 
     with Live(auto_refresh=False) as live: