fal 0.12.2__py3-none-any.whl → 0.12.3__py3-none-any.whl

fal/__init__.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
 from fal import apps
-
-# TODO: DEPRECATED - use function instead
 from fal.api import FalServerlessHost, LocalHost, cached
 from fal.api import function
 from fal.api import function as isolated
@@ -16,6 +14,17 @@ serverless = FalServerlessHost()
 # DEPRECATED - use serverless instead
 cloud = FalServerlessHost()
 
+__all__ = [
+    "function",
+    "cached",
+    "App",
+    "endpoint",
+    "realtime",
+    # "wrap_app",
+    "FalServerlessKeyCredentials",
+    "sync_dir",
+]
+
 
 # NOTE: This makes `import fal.dbt` import the `dbt-fal` module and `import fal` import the `fal` module
 # NOTE: taken from dbt-core: https://github.com/dbt-labs/dbt-core/blob/ac539fd5cf325cfb5315339077d03399d575f570/core/dbt/adapters/__init__.py#L1-L7

fal/api.py

@@ -4,7 +4,7 @@ import inspect
 import sys
 from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor
-from contextlib import suppress
+from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass, field, replace
 from functools import partial, wraps
 from os import PathLike
@@ -16,6 +16,7 @@ from typing import (
     Generic,
     Iterator,
     Literal,
+    NamedTuple,
     TypeVar,
     cast,
     overload,
@@ -26,6 +27,7 @@ import dill.detect
 import grpc
 import isolate
 import yaml
+from fastapi import FastAPI
 from isolate.backends.common import active_python
 from isolate.backends.settings import DEFAULT_SETTINGS
 from isolate.connections import PythonIPC
@@ -56,6 +58,8 @@ ReturnT = TypeVar("ReturnT", covariant=True)
 BasicConfig = Dict[str, Any]
 _UNSET = object()
 
+SERVE_REQUIREMENTS = ["fastapi==0.99.1", "uvicorn"]
+
 
 @dataclass
 class FalServerlessError(Exception):
@@ -110,7 +114,7 @@ class Host(Generic[ArgsT, ReturnT]):
                 options.environment[key] = value
 
         if options.gateway.get("serve"):
-            options.add_requirements(["fastapi==0.99.1", "uvicorn"])
+            options.add_requirements(SERVE_REQUIREMENTS)
 
         return options
 
@@ -730,53 +734,17 @@ def function(  # type: ignore
 
 
 @mainify
-class ServeWrapper:
-    _func: Callable
-
-    def __init__(self, func: Callable):
-        self._func = func
-
-    def build_app(self):
-        from fastapi import FastAPI
-        from fastapi.middleware.cors import CORSMiddleware
-
-        _app = FastAPI()
-
-        _app.add_middleware(
-            CORSMiddleware,
-            allow_credentials=True,
-            allow_headers=("*"),
-            allow_methods=("*"),
-            allow_origins=("*"),
-        )
-
-        _app.add_api_route(
-            "/",
-            self._func,  # type: ignore
-            name=self._func.__name__,
-            methods=["POST"],
-        )
-
-        return _app
-
-    def __call__(self, *args, **kwargs) -> None:
-        if len(args) != 0 or len(kwargs) != 0:
-            print(
-                f"[warning] {self._func.__name__} function is served with no arguments."
-            )
-
-        from uvicorn import run
-
-        app = self.build_app()
-        run(app, host="0.0.0.0", port=8080)
+class FalFastAPI(FastAPI):
+    """
+    A subclass of FastAPI that adds some fal-specific functionality.
+    """
 
     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()
-        spec = app.openapi()
+        spec = super().openapi()
         self._mark_order_openapi(spec)
         return spec
 
@@ -788,7 +756,8 @@ class ServeWrapper:
         """
 
         def mark_order(obj: dict[str, Any], key: str):
-            obj[f"x-fal-order-{key}"] = list(obj[key].keys())
+            if key in obj:
+                obj[f"x-fal-order-{key}"] = list(obj[key].keys())
 
         mark_order(spec, "paths")
 
@@ -797,18 +766,129 @@ class ServeWrapper:
             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 sub_schema in schema.get("allOf", []):
+                order_schema_object(sub_schema)
+
+            mark_order(schema, "properties")
 
-        for key in spec.get("components", {}).get("schemas") or {}:
+        for key in spec.get("components", {}).get("schemas", {}):
             order_schema_object(spec["components"]["schemas"][key])
 
         return spec
 
 
+@mainify
+class RouteSignature(NamedTuple):
+    path: str
+    is_websocket: bool = False
+    input_modal: type | None = None
+    buffering: int | None = None
+    session_timeout: float | None = None
+    max_batch_size: int = 1
+    emit_timings: bool = False
+
+
+@mainify
+class BaseServable:
+    def collect_routes(self) -> dict[RouteSignature, Callable[..., Any]]:
+        raise NotImplementedError
+
+    def _add_extra_middlewares(self, app: FastAPI):
+        """
+        For subclasses to add extra middlewares to the app.
+        """
+        pass
+
+    @asynccontextmanager
+    async def lifespan(self, app: FastAPI):
+        yield
+
+    def _build_app(self) -> FastAPI:
+        from fastapi import HTTPException, Request
+        from fastapi.middleware.cors import CORSMiddleware
+        from fastapi.responses import JSONResponse
+
+        _app = FalFastAPI(lifespan=self.lifespan)
+
+        _app.add_middleware(
+            CORSMiddleware,
+            allow_credentials=True,
+            allow_headers=("*"),
+            allow_methods=("*"),
+            allow_origins=("*"),
+        )
+
+        self._add_extra_middlewares(_app)
+
+        @_app.exception_handler(404)
+        async def not_found_exception_handler(request: Request, exc: HTTPException):
+            # Rewrite the message to include the path that was not found.
+            # This is supposed to make it easier to understand to the user
+            # that the error comes from the app and not our platform.
+            if exc.detail == "Not Found":
+                return JSONResponse(
+                    {"detail": f"Path {request.url.path} not found"}, 404
+                )
+            else:
+                # If it's not a generic 404, just return the original message.
+                return JSONResponse({"detail": exc.detail}, 404)
+
+        routes = self.collect_routes()
+        if not routes:
+            raise ValueError("An application must have at least one route!")
+
+        for signature, endpoint in routes.items():
+            if signature.is_websocket:
+                _app.add_api_websocket_route(
+                    signature.path,
+                    endpoint,
+                    name=endpoint.__name__,
+                )
+            else:
+                _app.add_api_route(
+                    signature.path,
+                    endpoint,
+                    name=endpoint.__name__,
+                    methods=["POST"],
+                )
+
+        return _app
+
+    def openapi(self) -> dict[str, Any]:
+        """
+        Build the OpenAPI specification for the served function.
+        Attach needed metadata for a better integration to fal.
+        """
+        return self._build_app().openapi()
+
+    def serve(self) -> None:
+        import uvicorn
+
+        app = self._build_app()
+        uvicorn.run(app, host="0.0.0.0", port=8080)
+
+
+@mainify
+class ServeWrapper(BaseServable):
+    _func: Callable
+
+    def __init__(self, func: Callable):
+        self._func = func
+
+    def collect_routes(self) -> dict[RouteSignature, Callable[..., Any]]:
+        return {
+            RouteSignature("/"): self._func,
+        }
+
+    def __call__(self, *args, **kwargs) -> None:
+        if len(args) != 0 or len(kwargs) != 0:
+            print(
+                f"[warning] {self._func.__name__} function is served with no arguments."
+            )
+
+        self.serve()
+
+
 @dataclass
 class IsolatedFunction(Generic[ArgsT, ReturnT]):
     host: Host[ArgsT, ReturnT]

fal/app.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
 import inspect
+import json
 import os
 import typing
 from contextlib import asynccontextmanager
-from typing import Any, Callable, ClassVar, NamedTuple, TypeVar
+from typing import Any, Callable, ClassVar, TypeVar
 
 from fastapi import FastAPI
 
 import fal.api
 from fal._serialization import add_serialization_listeners_for
+from fal.api import RouteSignature
 from fal.logging import get_logger
 from fal.toolkit import mainify
 
@@ -19,6 +21,13 @@ EndpointT = TypeVar("EndpointT", bound=Callable[..., Any])
 logger = get_logger(__name__)
 
 
+async def _call_any_fn(fn, *args, **kwargs):
+    if inspect.iscoroutinefunction(fn):
+        return await fn(*args, **kwargs)
+    else:
+        return fn(*args, **kwargs)
+
+
 def wrap_app(cls: type[App], **kwargs) -> fal.api.IsolatedFunction:
     add_serialization_listeners_for(cls)
 
@@ -44,25 +53,19 @@ def wrap_app(cls: type[App], **kwargs) -> fal.api.IsolatedFunction:
         **cls.host_kwargs,
         **kwargs,
         metadata=metadata,
-        serve=True,
+        exposed_port=8080,
+        serve=False,
     )
     fn = wrapper(initialize_and_serve)
+    fn.options.add_requirements(fal.api.SERVE_REQUIREMENTS)
     if realtime_app:
         fn.options.add_requirements(REALTIME_APP_REQUIREMENTS)
-    return fn.on(
-        serve=False,
-        exposed_port=8080,
-    )
 
-
-@mainify
-class RouteSignature(NamedTuple):
-    path: str
-    is_websocket: bool = False
+    return fn
 
 
 @mainify
-class App:
+class App(fal.api.BaseServable):
     requirements: ClassVar[list[str]] = []
     machine_type: ClassVar[str] = "S"
     host_kwargs: ClassVar[dict[str, Any]] = {}
@@ -83,19 +86,6 @@ class App:
                 "Running apps through SDK is not implemented yet."
             )
 
-    def setup(self):
-        """Setup the application before serving."""
-
-    def provide_hints(self) -> list[str]:
-        """Provide hints for routing the application."""
-        raise NotImplementedError
-
-    def serve(self) -> None:
-        import uvicorn
-
-        app = self._build_app()
-        uvicorn.run(app, host="0.0.0.0", port=8080)
-
     def collect_routes(self) -> dict[RouteSignature, Callable[..., Any]]:
         return {
             signature: endpoint
@@ -103,22 +93,23 @@ class App:
             if (signature := getattr(endpoint, "route_signature", None))
         }
 
-    def _build_app(self) -> FastAPI:
-        from fastapi import FastAPI
-        from fastapi.middleware.cors import CORSMiddleware
+    @asynccontextmanager
+    async def lifespan(self, app: FastAPI):
+        await _call_any_fn(self.setup)
+        try:
+            yield
+        finally:
+            await _call_any_fn(self.teardown)
 
-        @asynccontextmanager
-        async def lifespan(app: FastAPI):
-            self.setup()
-            try:
-                yield
-            finally:
-                self.teardown()
+    def setup(self):
+        """Setup the application before serving."""
 
-        _app = FastAPI(lifespan=lifespan)
+    def teardown(self):
+        """Teardown the application after serving."""
 
-        @_app.middleware("http")
-        async def provide_hints(request, call_next):
+    def _add_extra_middlewares(self, app: FastAPI):
+        @app.middleware("http")
+        async def provide_hints_headers(request, call_next):
             response = await call_next(request)
             try:
                 response.headers["X-Fal-Runner-Hints"] = ",".join(self.provide_hints())
@@ -126,57 +117,18 @@ class App:
                 # This lets us differentiate between apps that don't provide hints
                 # and apps that provide empty hints.
                 pass
-            except Exception as exc:
+            except Exception:
                 from fastapi.logger import logger
 
                 logger.exception(
                     "Failed to provide hints for %s",
                     self.__class__.__name__,
-                    exc_info=exc,
                 )
             return response
 
-        _app.add_middleware(
-            CORSMiddleware,
-            allow_credentials=True,
-            allow_headers=("*"),
-            allow_methods=("*"),
-            allow_origins=("*"),
-        )
-
-        routes = self.collect_routes()
-        if not routes:
-            raise ValueError("An application must have at least one route!")
-
-        for signature, endpoint in routes.items():
-            if signature.is_websocket:
-                _app.add_api_websocket_route(
-                    signature.path,
-                    endpoint,
-                    name=endpoint.__name__,
-                )
-            else:
-                _app.add_api_route(
-                    signature.path,
-                    endpoint,
-                    name=endpoint.__name__,
-                    methods=["POST"],
-                )
-
-        return _app
-
-    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()
-        spec = app.openapi()
-        _mark_order_openapi(spec)
-        return spec
-
-    def teardown(self):
-        """Teardown the application after serving."""
+    def provide_hints(self) -> list[str]:
+        """Provide hints for routing the application."""
+        raise NotImplementedError
 
 
 @mainify
@@ -199,10 +151,7 @@ def endpoint(
 
 def _fal_websocket_template(
     func: EndpointT,
-    buffering: int | None = None,
-    session_timeout: float | None = None,
-    input_modal: Any | None = None,
-    max_batch_size: int = 1,
+    route_signature: RouteSignature,
 ) -> EndpointT:
     # A template for fal's realtime websocket endpoints to basically
     # be a boilerplate for the user to fill in their inference function
@@ -220,14 +169,14 @@ def _fal_websocket_template(
             try:
                 raw_input = await asyncio.wait_for(
                     websocket.receive_bytes(),
-                    timeout=session_timeout,
+                    timeout=route_signature.session_timeout,
                 )
             except asyncio.TimeoutError:
                 return
 
             input = msgpack.unpackb(raw_input, raw=False)
-            if input_modal:
-                input = input_modal(**input)
+            if route_signature.input_modal:
+                input = route_signature.input_modal(**input)
 
             queue.append(input)
 
@@ -237,10 +186,18 @@ def _fal_websocket_template(
         websocket: WebSocket,
     ) -> None:
         loop = asyncio.get_event_loop()
-        outgoing_messages: asyncio.Queue[bytes] = asyncio.Queue(maxsize=buffering or 1)
+        max_allowed_buffering = route_signature.buffering or 1
+        outgoing_messages: asyncio.Queue[bytes] = asyncio.Queue(
+            maxsize=max_allowed_buffering * 2  # x2 for outgoing timings
+        )
 
         async def emit(message):
-            await websocket.send_bytes(message)
+            if isinstance(message, bytes):
+                await websocket.send_bytes(message)
+            elif isinstance(message, str):
+                await websocket.send_text(message)
+            else:
+                raise TypeError(f"Can't send message of type {type(message)}")
 
         async def background_emitter():
             while True:
@@ -266,7 +223,7 @@ def _fal_websocket_template(
                 return None  # End of input
 
             batch = [input]
-            while queue and len(batch) < max_batch_size:
+            while queue and len(batch) < route_signature.max_batch_size:
                 next_input = queue.popleft()
                 if hasattr(input, "can_batch") and not input.can_batch(
                     next_input, len(batch)
@@ -275,7 +232,9 @@ def _fal_websocket_template(
                     break
                 batch.append(next_input)
 
+            t0 = loop.time()
             output = await loop.run_in_executor(None, func, self, *batch)  # type: ignore
+            total_time = loop.time() - t0
             if not isinstance(output, dict):
                 # Handle pydantic output modal
                 if hasattr(output, "dict"):
@@ -285,18 +244,30 @@ def _fal_websocket_template(
                         f"Expected a dict or pydantic model as output, got {type(output)}"
                     )
 
-            message = msgpack.packb(output, use_bin_type=True)
-            try:
-                outgoing_messages.put_nowait(message)
-            except asyncio.QueueFull:
-                await emit(message)
+            messages = [
+                msgpack.packb(output, use_bin_type=True),
+            ]
+            if route_signature.emit_timings:
+                # We emit x-fal messages in JSON, no matter what the input/output format is.
+                timings = {
+                    "type": "x-fal-message",
+                    "action": "timings",
+                    "timing": total_time,
+                }
+                messages.append(json.dumps(timings, separators=(",", ":")))
+
+            for message in messages:
+                try:
+                    outgoing_messages.put_nowait(message)
+                except asyncio.QueueFull:
+                    await emit(message)
 
     async def websocket_template(self, websocket: WebSocket) -> None:
         import asyncio
 
         await websocket.accept()
 
-        queue: deque[Any] = deque(maxlen=buffering)
+        queue: deque[Any] = deque(maxlen=route_signature.buffering)
         input_task = asyncio.create_task(mirror_input(queue, websocket))
         input_task.add_done_callback(lambda _: queue.append(None))
         output_task = asyncio.create_task(mirror_output(self, queue, websocket))
@@ -314,7 +285,9 @@ def _fal_websocket_template(
                 # so we can just close the connection after the
                 # processing of the last input is done.
                 input_task.result()
-                await asyncio.wait_for(output_task, timeout=session_timeout)
+                await asyncio.wait_for(
+                    output_task, timeout=route_signature.session_timeout
+                )
             else:
                 assert output_task.done()
 
@@ -362,7 +335,8 @@ def _fal_websocket_template(
         "websocket": WebSocket,
         "return": None,
     }
-
+    websocket_template.route_signature = route_signature  # type: ignore
+    websocket_template.original_func = func  # type: ignore
     return typing.cast(EndpointT, websocket_template)
 
 
@@ -395,44 +369,17 @@ def realtime(
             else:
                 input_modal = None
 
-        callable = _fal_websocket_template(
-            original_func,
+        route_signature = RouteSignature(
+            path=path,
+            is_websocket=True,
+            input_modal=input_modal,
             buffering=buffering,
             session_timeout=session_timeout,
-            input_modal=input_modal,
             max_batch_size=max_batch_size,
         )
-        callable.route_signature = RouteSignature(path=path, is_websocket=True)  # type: ignore
-        callable.original_func = original_func  # type: ignore
-        return callable
+        return _fal_websocket_template(
+            original_func,
+            route_signature,
+        )
 
     return marker_fn
-
-
-def _mark_order_openapi(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

fal/apps.py

@@ -63,7 +63,10 @@ class RequestHandle:
     _creds: Credentials = field(default_factory=get_default_credentials, repr=False)
 
     def __post_init__(self):
-        self.app_id = _backwards_compatible_app_id(self.app_id)
+        app_id = _backwards_compatible_app_id(self.app_id)
+        # drop any extra path components
+        user_id, app_name = app_id.split("/")[:2]
+        self.app_id = f"{user_id}/{app_name}"
 
     def status(self, *, logs: bool = False) -> _Status:
         """Check the status of an async inference request."""
@@ -116,7 +119,16 @@ class RequestHandle:
             + f"/requests/{self.request_id}/"
         )
         response = _HTTP_CLIENT.get(url, headers=self._creds.to_headers())
-        response.raise_for_status()
+        try:
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            if response.headers["Content-Type"] != "application/json":
+                raise
+            raise httpx.HTTPStatusError(
+                f"{response.status_code}: {response.text}",
+                request=e.request,
+                response=e.response,
+            ) from e
 
         data = response.json()
         return data
@@ -134,20 +146,23 @@ class RequestHandle:
 _HTTP_CLIENT = httpx.Client(headers={"User-Agent": "Fal/Python"})
 
 
-def run(app_id: str, arguments: dict[str, Any], *, path: str = "/") -> dict[str, Any]:
+def run(app_id: str, arguments: dict[str, Any], *, path: str = "") -> dict[str, Any]:
     """Run an inference task on a Fal app and return the result."""
 
     handle = submit(app_id, arguments, path=path)
     return handle.get()
 
 
-def submit(app_id: str, arguments: dict[str, Any], *, path: str = "/") -> RequestHandle:
+def submit(app_id: str, arguments: dict[str, Any], *, path: str = "") -> RequestHandle:
     """Submit an async inference task to the app. Returns a request handle
     which can be used to check the status of the request and retrieve the
     result."""
 
     app_id = _backwards_compatible_app_id(app_id)
-    url = _QUEUE_URL_FORMAT.format(app_id=app_id) + path
+    url = _QUEUE_URL_FORMAT.format(app_id=app_id)
+    if path:
+        url += "/" + path.removeprefix("/")
+
     creds = get_default_credentials()
 
     response = _HTTP_CLIENT.post(
@@ -206,7 +221,10 @@ def _connect(app_id: str, *, path: str = "/realtime") -> Iterator[_RealtimeConne
     from websockets.sync import client
 
     app_id = _backwards_compatible_app_id(app_id)
-    url = _REALTIME_URL_FORMAT.format(app_id=app_id) + path
+    url = _REALTIME_URL_FORMAT.format(app_id=app_id)
+    if path:
+        url += "/" + path.removeprefix("/")
+
     creds = get_default_credentials()
 
     with client.connect(

fal/auth/__init__.py

@@ -62,7 +62,7 @@ def _fetch_access_token() -> str:
 
         if access_token is not None:
             try:
-                auth0.validate_access_token(access_token)
+                auth0.verify_access_token_expiration(access_token)
                 return access_token
             except:
                 # access_token expired, will refresh

fal/auth/auth0.py

@@ -1,14 +1,11 @@
 from __future__ import annotations
 
+import functools
 import time
 import warnings
 
 import click
-import requests
-from auth0.authentication.token_verifier import (
-    AsymmetricSignatureVerifier,
-    TokenVerifier,
-)
+import httpx
 
 from fal.console import console
 from fal.console.icons import CHECK_ICON
@@ -54,7 +51,7 @@ def login() -> dict:
         "client_id": AUTH0_CLIENT_ID,
         "scope": AUTH0_SCOPE,
     }
-    device_code_response = requests.post(
+    device_code_response = httpx.post(
         f"https://{AUTH0_DOMAIN}/oauth/device/code", data=device_code_payload
     )
 
@@ -81,7 +78,7 @@ def login() -> dict:
 
     with console.status("Waiting for confirmation...") as status:
         while True:
-            token_response = requests.post(
+            token_response = httpx.post(
                 f"https://{AUTH0_DOMAIN}/oauth/token", data=token_payload
             )
 
@@ -109,14 +106,12 @@ def refresh(token: str) -> dict:
         "refresh_token": token,
     }
 
-    token_response = requests.post(
+    token_response = httpx.post(
         f"https://{AUTH0_DOMAIN}/oauth/token", data=token_payload
     )
 
     token_data = token_response.json()
     if token_response.status_code == 200:
-        # DEBUG: print("Authenticated!")
-
         validate_id_token(token_data["id_token"])
 
         return token_data
@@ -130,7 +125,7 @@ def revoke(token: str):
         "token": token,
     }
 
-    token_response = requests.post(
+    token_response = httpx.post(
         f"https://{AUTH0_DOMAIN}/oauth/revoke", data=token_payload
     )
 
@@ -142,7 +137,7 @@ def revoke(token: str):
 
 
 def get_user_info(bearer_token: str) -> dict:
-    userinfo_response = requests.post(
+    userinfo_response = httpx.post(
         f"https://{AUTH0_DOMAIN}/userinfo",
         headers={"Authorization": bearer_token},
     )
@@ -153,24 +148,38 @@ def get_user_info(bearer_token: str) -> dict:
     return userinfo_response.json()
 
 
+@functools.lru_cache
+def build_jwk_client():
+    from jwt import PyJWKClient
+
+    return PyJWKClient(AUTH0_JWKS_URL, cache_keys=True)
+
+
 def validate_id_token(token: str):
     """
-    Verify the token and its precedence.
-    `id_token`s are intended for the client (this sdk) only.
-    Never send one to another service.
-
-    :param id_token:
+    id_token is intended for the client (this sdk) only. Never send one to another service.
     """
-    sv = AsymmetricSignatureVerifier(AUTH0_JWKS_URL)
-    tv = TokenVerifier(
-        signature_verifier=sv,
+    from jwt import decode
+
+    jwk_client = build_jwk_client()
+
+    decode(
+        token,
+        key=jwk_client.get_signing_key_from_jwt(token).key,
+        algorithms=AUTH0_ALGORITHMS,
         issuer=AUTH0_ISSUER,
         audience=AUTH0_CLIENT_ID,
+        options={
+            "verify_signature": True,
+            "verify_exp": True,
+            "verify_iat": True,
+            "verify_aud": True,
+            "verify_iss": True,
+        },
     )
-    tv.verify(token)
 
 
-def validate_access_token(token: str):
+def verify_access_token_expiration(token: str):
     from datetime import timedelta
 
     from jwt import decode

fal/cli.py

@@ -29,7 +29,7 @@ PORT_ENVVAR = "FAL_PORT"
 DEBUG_ENABLED = False
 
 
-log = get_logger(__name__)
+logger = get_logger(__name__)
 
 
 class ExecutionInfo:
@@ -63,13 +63,13 @@ class MainGroup(click.Group):
             qualified_name, attributes={"invocation_id": invocation_id}
         ):
             try:
-                log.debug(
+                logger.debug(
                     f"Executing command: {qualified_name}",
                     command=qualified_name,
                 )
                 return super().invoke(ctx)
             except Exception as exception:
-                log.error(exception)
+                logger.error(exception)
                 if execution_info.debug:
                     # Here we supress detailed errors on click lines because
                     # they're mostly decorator calls, irrelevant to the dev's error tracing
@@ -468,6 +468,7 @@ def alias_list_runners(
     table.add_column("Runner ID")
     table.add_column("In Flight Requests")
     table.add_column("Expires in")
+    table.add_column("Uptime")
 
     for runner in runners:
         table.add_row(
@@ -478,6 +479,7 @@ def alias_list_runners(
                 if not runner.expiration_countdown
                 else f"{runner.expiration_countdown}s"
             ),
+            f"{runner.uptime} ({runner.uptime.total_seconds()}s)",
         )
 
     console.print(table)

fal/env.py

@@ -1,7 +1,3 @@
 from __future__ import annotations
 
 CLI_ENV = "prod"
-
-DATADOG_API_KEY = "pub4cd6a1c4763c93ad5af2740b2d931145"
-DATADOG_APP_KEY = "4981bae640864a409dcfaddd69c2a157523b1585"
-

fal/logging/__init__.py

@@ -5,7 +5,6 @@ from typing import Any
 import structlog
 from structlog.typing import EventDict, WrappedLogger
 
-from .datadog import submit_to_datadog
 from .style import LEVEL_STYLES
 from .user import add_user_id
 
@@ -45,7 +44,6 @@ structlog.configure(
         structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S"),
         structlog.processors.StackInfoRenderer(),
         add_user_id,
-        submit_to_datadog,
         _console_log_output,
     ],
     wrapper_class=structlog.stdlib.BoundLogger,

fal/logging/trace.py

@@ -7,6 +7,10 @@ from grpc_interceptor import ClientCallDetails, ClientInterceptor
 from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider
 
+from fal.logging import get_logger
+
+logger = get_logger(__name__)
+
 provider = TracerProvider()
 # The line below can be used in dev to inspect opentelemetry result
 # It must be imported from opentelemetry.sdk.trace.export
@@ -41,6 +45,7 @@ class TraceContextInterceptor(ClientInterceptor):
         call_details: ClientCallDetails,
     ):
         current_span = get_current_span_context()
+
         if current_span is not None:
             new_details = call_details._replace(
                 metadata=(
@@ -50,5 +55,7 @@ class TraceContextInterceptor(ClientInterceptor):
                     ("x-fal-invocation-id", current_span.invocation_id),
                 )
             )
-            return method(request_or_iterator, new_details)
+            call_details = new_details
+
+        logger.debug("Calling %s", call_details)
         return method(request_or_iterator, call_details)

fal/sdk.py

@@ -29,7 +29,7 @@ FAL_SERVERLESS_DEFAULT_KEEP_ALIVE = 10
 FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING = 1
 FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY = 0
 
-log = get_logger(__name__)
+logger = get_logger(__name__)
 
 patch_dill()
 
@@ -39,8 +39,29 @@ class ServerCredentials:
         raise NotImplementedError
 
     @property
-    def extra_options(self) -> list[tuple[str, str]]:
-        return GRPC_OPTIONS
+    def base_options(self) -> dict[str, str | int]:
+        import json
+
+        grpc_ops: dict[str, str | int] = dict(GRPC_OPTIONS)
+        grpc_ops["grpc.enable_retries"] = 1
+        grpc_ops["grpc.service_config"] = json.dumps(
+            {
+                "methodConfig": [
+                    {
+                        "name": [{}],
+                        "retryPolicy": {
+                            "maxAttempts": 5,
+                            "initialBackoff": "0.1s",
+                            "maxBackoff": "5s",
+                            "backoffMultiplier": 2,
+                            "retryableStatusCodes": ["UNAVAILABLE"],
+                        },
+                    }
+                ]
+            }
+        )
+
+        return grpc_ops
 
 
 class LocalCredentials(ServerCredentials):
@@ -140,7 +161,7 @@ def get_default_credentials() -> Credentials:
 
     key_creds = key_credentials()
     if key_creds:
-        log.debug("Using key credentials")
+        logger.debug("Using key credentials")
         return FalServerlessKeyCredentials(key_creds[0], key_creds[1])
     else:
         return AuthenticatedCredentials()
@@ -183,6 +204,7 @@ class RunnerInfo:
     runner_id: str
     in_flight_requests: int
     expiration_countdown: int
+    uptime: timedelta
 
 
 @dataclass
@@ -270,6 +292,7 @@ def _from_grpc_runner_info(message: isolate_proto.RunnerInfo) -> RunnerInfo:
         runner_id=message.runner_id,
         in_flight_requests=message.in_flight_requests,
         expiration_countdown=message.expiration_countdown,
+        uptime=timedelta(seconds=message.uptime),
     )
 
 
@@ -346,10 +369,14 @@ class FalServerlessConnection:
         if self._stub:
             return self._stub
 
-        options = self.credentials.server_credentials.extra_options
+        options = self.credentials.server_credentials.base_options
         channel_creds = self.credentials.to_grpc()
         channel = self._stack.enter_context(
-            grpc.secure_channel(self.hostname, channel_creds, options)
+            grpc.secure_channel(
+                target=self.hostname,
+                credentials=channel_creds,
+                options=list(options.items()),
+            )
         )
         channel = grpc.intercept_channel(channel, TraceContextInterceptor())
         self._stub = isolate_proto.IsolateControllerStub(channel)

fal/toolkit/__init__.py

@@ -12,3 +12,19 @@ from fal.toolkit.utils import (
     download_file,
     download_model_weights,
 )
+
+__all__ = [
+    "CompressedFile",
+    "File",
+    "Image",
+    "ImageSizeInput",
+    "get_image_size",
+    "mainify",
+    "optimize",
+    "FAL_MODEL_WEIGHTS_DIR",
+    "FAL_PERSISTENT_DIR",
+    "FAL_REPOSITORY_DIR",
+    "clone_repository",
+    "download_file",
+    "download_model_weights",
+]

{fal-0.12.2.dist-info → fal-0.12.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fal
-Version: 0.12.2
+Version: 0.12.3
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels
 Author-email: hello@fal.ai
@@ -11,18 +11,15 @@ Classifier: Programming Language :: Python :: 3.9
 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)
 Requires-Dist: dill (==0.3.7)
 Requires-Dist: fastapi (==0.99.1)
 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: httpx (>=0.15.4)
 Requires-Dist: importlib-metadata (>=4.4) ; python_version < "3.10"
-Requires-Dist: isolate-proto (>=0.3.1,<0.4.0)
+Requires-Dist: isolate-proto (==0.3.3)
 Requires-Dist: isolate[build] (>=0.12.3,<1.0)
 Requires-Dist: msgpack (>=1.0.7,<2.0.0)
 Requires-Dist: opentelemetry-api (>=1.15.0,<2.0.0)
@@ -32,8 +29,8 @@ Requires-Dist: pathspec (>=0.11.1,<0.12.0)
 Requires-Dist: pillow (>=10.2.0,<11.0.0)
 Requires-Dist: portalocker (>=2.7.0,<3.0.0)
 Requires-Dist: pydantic (<2.0)
+Requires-Dist: pyjwt (>=2.8.0,<3.0.0)
 Requires-Dist: python-dateutil (>=2.8.0,<3.0.0)
-Requires-Dist: requests (>=2.28.1,<3.0.0)
 Requires-Dist: rich (>=13.3.2,<14.0.0)
 Requires-Dist: structlog (>=22.3.0,<23.0.0)
 Requires-Dist: types-python-dateutil (>=2.8.0,<3.0.0)

{fal-0.12.2.dist-info → fal-0.12.3.dist-info}/RECORD

@@ -19,35 +19,34 @@ openapi_fal_rest/models/lock_reason.py,sha256=3b_foCV6bZKvsbyic3hM1_qzvJk_9ZD_5m
 openapi_fal_rest/models/validation_error.py,sha256=I6tB-HbEOmE0ua27erDX5PX5YUynENv_dgPN3SrwTrQ,2091
 openapi_fal_rest/py.typed,sha256=8ZJUsxZiuOy1oJeVhsTWQhTG_6pTVHVXk5hJL79ebTk,25
 openapi_fal_rest/types.py,sha256=4xaUIOliefW-5jz_p-JT2LO7-V0wKWaniHGtjPBQfvQ,993
-fal/__init__.py,sha256=--wkZvDt27S2vPi3hk8Nc-XRUl4ac_cB6P_12VSqODw,1085
+fal/__init__.py,sha256=6SvCuotCb0tuqSWDZSFDjtySktJ5m1QpVIlefumJpvM,1199
 fal/_serialization.py,sha256=l_dZuSX5BT7SogXw1CalYLfT2H3zy3tfq4y6jHuxZqQ,4201
-fal/api.py,sha256=xEVuBRVKac82MgcHUqw10IDHims5fwv6oxqpwAmAx1Q,30353
-fal/app.py,sha256=_LFUjrf6K8qYKKpDyfJR2dOFmumJxZTgbOz64Ltea9g,13660
-fal/apps.py,sha256=utg7mGvklL1oyUBbuEDDcVN234yDLVseqnY1DJsT8nY,6126
-fal/auth/__init__.py,sha256=-s7kogdp3szq_pAxHGkfOQjrSBT1DlBx3X-Ifo_Ne1o,3124
-fal/auth/auth0.py,sha256=S7bl0ti1w8t-OaAggju12xx0lOtqkXy_qML7QP0t4uI,5303
+fal/api.py,sha256=Qack_oYNkvF4qown3P_oKvyvRfTJkhOG7PL1xpa8FUQ,32872
+fal/app.py,sha256=KAIgvBBpvzp6oY8BpH5hFOLDUpG4bjtwlV5jPGj2IE0,12487
+fal/apps.py,sha256=T387WJDtKpKEytu27b2AVqqo0uijKrRT9ymk6FcRiEw,6705
+fal/auth/__init__.py,sha256=4W_9svpsmohRPhBi4yjx9rAPaUeBTHaJvSRpdRzXA5s,3133
+fal/auth/auth0.py,sha256=hQ3ZTqqsgpL62GsNB9KvjE8k_2hxXMIJb5TNpRmaiYs,5485
 fal/auth/local.py,sha256=lZqp4j32l2xFpY8zYvLoIHHyJrNAJDcm5MxgsLpY_pw,1786
-fal/cli.py,sha256=dxnsHzsochm-u8oQ3gFy6uVHbllI_14bU54bDpyMOwk,17129
+fal/cli.py,sha256=nLk4LJsGvLicA_iW0T1ldYb_igMwYOdC2fQxUsdWCRQ,17236
 fal/console/__init__.py,sha256=ernZ4bzvvliQh5SmrEqQ7lA5eVcbw6Ra2jalKtA7dxg,132
 fal/console/icons.py,sha256=De9MfFaSkO2Lqfne13n3PrYfTXJVIzYZVqYn5BWsdrA,108
 fal/console/ux.py,sha256=4vj1aGA3grRn-ebeMuDLR6u3YjMwUGpqtNgdTG9su5s,485
-fal/env.py,sha256=g_s2FAtY2-6zyTar_2NUmswHcab--3xozEJW4E6Y9iQ,172
+fal/env.py,sha256=-fA8x62BbOX3MOuO0maupa-_QJ9PNwr8ogfeG11QUyQ,53
 fal/exceptions/__init__.py,sha256=Q4LCSqIrJ8GFQZWH5BvWL5mDPR0HwYQuIhNvsdiOkEU,938
 fal/exceptions/_base.py,sha256=LeQmx-soL_-s1742WKN18VwTVjUuYP0L0BdQHPJBpM4,460
 fal/exceptions/auth.py,sha256=01Ro7SyGJpwchubdHe14Cl6-Al1jUj16Sy4BvakNWf4,384
 fal/exceptions/handlers.py,sha256=b21a8S13euECArjpgm2N69HsShqLYVqAboIeMoWlWA4,1414
 fal/flags.py,sha256=8OaKkJg_-UvtyRbZf-rW5ZTW3B1xQpzzXnLRNFB7grA,889
-fal/logging/__init__.py,sha256=tXFlHBtPFydL3Wgzhq72-EzCFKrnDYvZIF0pKYGVxac,1649
-fal/logging/datadog.py,sha256=pC63CrJLF-bXUaF5RUxkdq9wBgklzrMglcdM9gw7teA,2542
+fal/logging/__init__.py,sha256=snqprf7-sKw6oAATS_Yxklf-a3XhLg0vIHICPwLp6TM,1583
 fal/logging/isolate.py,sha256=yDW_P4aR-t53IRmvD2Iprufv1Wn-xQXoBbMB2Ufr59s,2122
 fal/logging/style.py,sha256=ckIgHzvF4DShM5kQh8F133X53z_vF46snuDHVmo_h9g,386
-fal/logging/trace.py,sha256=-_ShrBsBl9jUlGC-Lwe2r-LIkfj21SETQAhSNrWxbGs,1807
+fal/logging/trace.py,sha256=OhzB6d4rQZimBc18WFLqH_9BGfqFFumKKTAGSsmWRMg,1904
 fal/logging/user.py,sha256=A8vbZX9z13TPZEDzvlbvCDDdD0EL1KrCP3qHdrT58-A,632
 fal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fal/rest_client.py,sha256=kGBGmuyHfX1lR910EoKCYPjsyU8MdXawT_cW2q8Sajc,568
-fal/sdk.py,sha256=Reo6xTxvDCNEEawl4GUNQi83RQ_g2isuAVhXw7fz9oU,17918
+fal/sdk.py,sha256=Z3MQsD8MMQZq_GEC2VjaYChdNafFJtsgdk77-VK6N44,18782
 fal/sync.py,sha256=Ljet584PVFz4r888-0bwV1Kio-tTneF_85TnHvBPvJw,4277
-fal/toolkit/__init__.py,sha256=uHhoAG9FjLzxkmF-Qo9fxz8lrL9t6GE-3zsa_O4Q9V0,420
+fal/toolkit/__init__.py,sha256=JDNBT_duflp93geeAzw2kFmGzG5odWnPJEXFLXE2nF4,713
 fal/toolkit/exceptions.py,sha256=--WKKYxUop6WFy_vqAPXK6uH8C-JR98gnNXwhHNCb7E,258
 fal/toolkit/file/__init__.py,sha256=YpUU6YziZV1AMuq12L0EDWToS0sgpHSGWsARbiOEHWk,56
 fal/toolkit/file/file.py,sha256=ku4agJiGXU2gdfZmFrU5mDlVsag834zoeskbo-6ErEU,5926
@@ -61,7 +60,7 @@ fal/toolkit/mainify.py,sha256=E7gE45nZQZoaJdSlIq0mqajcH-IjcuPBWFmKm5hvhAU,406
 fal/toolkit/optimize.py,sha256=OIhX0T-efRMgUJDpvL0bujdun5SovZgTdKxNOv01b_Y,1394
 fal/toolkit/utils/__init__.py,sha256=b3zVpm50Upx1saXU7RiV9r9in6-Chs4OU9KRjBv7MYI,83
 fal/toolkit/utils/download_utils.py,sha256=bigcLJjLK1OBAGxpYisJ0-5vcQCh0HAPuCykPrcCNd0,15596
-fal-0.12.2.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-fal-0.12.2.dist-info/METADATA,sha256=56jV53hKxoUJA81vNfeG1AVXiVciOE10nb6nICONR5M,3078
-fal-0.12.2.dist-info/entry_points.txt,sha256=nE9GBVV3PdBosudFwbIzZQUe_9lfPR6EH8K_FdDASnM,62
-fal-0.12.2.dist-info/RECORD,,
+fal-0.12.3.dist-info/METADATA,sha256=0eR9dtKw9ZU7y2Dxjx9NtXp--hmw7XG24LuTylD5BlE,2930
+fal-0.12.3.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+fal-0.12.3.dist-info/entry_points.txt,sha256=nE9GBVV3PdBosudFwbIzZQUe_9lfPR6EH8K_FdDASnM,62
+fal-0.12.3.dist-info/RECORD,,

fal/logging/datadog.py

@@ -1,78 +0,0 @@
-from __future__ import annotations
-
-import sys
-import traceback
-import warnings
-
-from datadog_api_client import Configuration, ThreadedApiClient
-from datadog_api_client.v2.api.logs_api import LogsApi
-from datadog_api_client.v2.model.http_log import HTTPLog
-from datadog_api_client.v2.model.http_log_item import HTTPLogItem
-from structlog.typing import EventDict, WrappedLogger
-
-from fal.env import CLI_ENV, DATADOG_API_KEY, DATADOG_APP_KEY
-from fal.logging.trace import get_current_span_context
-
-if sys.version_info >= (3, 10):
-    import importlib.metadata as importlib_metadata
-else:
-    import importlib_metadata
-
-
-configuration = Configuration()
-configuration.api_key["apiKeyAuth"] = DATADOG_API_KEY
-configuration.api_key["appKeyAuth"] = DATADOG_APP_KEY
-
-
-def _is_error_level(level: str) -> bool:
-    return level in ["error", "exception", "critical"]
-
-
-def submit_to_datadog(
-    logger: WrappedLogger, method_name: str, event_dict: EventDict
-) -> EventDict:
-    if configuration.api_key["apiKeyAuth"] is None:
-        return event_dict
-
-    log_data = dict(event_dict)
-    event = log_data.pop("event")
-    level = log_data.pop("level")
-
-    current_span = get_current_span_context()
-    attributes = log_data.copy()
-    tags: dict[str, str] = {}
-    if current_span is not None:
-        tags["invocation_id"] = current_span.invocation_id
-        attributes["dd.trace_id"] = current_span.trace_id
-        attributes["dd.span_id"] = current_span.span_id
-
-    stack = None
-    if _is_error_level(method_name):
-        attributes["error.message"] = str(event)
-        attributes["error.kind"] = type(event).__name__
-        stack = traceback.format_exc()
-
-    ddtags = ",".join([f"{key}:{value}" for (key, value) in tags.items()])
-    log_item = HTTPLogItem(
-        message=str(event),
-        level=level,
-        hostname="client",
-        service="fal-serverless-cli",
-        env=CLI_ENV,
-        version=importlib_metadata.version("fal"),
-        ddsource="python",
-        ddtags=ddtags,
-        traceback=stack,
-        **attributes,
-    )
-    with ThreadedApiClient(configuration) as api_client:
-        # Deprecation warning of underlying dependencies should not be shown to users
-        # TODO enable it only in the prod distribution (better: remove when fixed)
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-
-        # TODO improve this - add batching
-        api_instance = LogsApi(api_client)
-        _ = api_instance.submit_log(HTTPLog([log_item]))
-        api_client.close()
-
-    return event_dict