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

fal/__init__.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
 from fal import apps  # noqa: F401
-from fal.api import FalServerlessHost, LocalHost, cached
-from fal.api import function
+from fal.api import FalServerlessHost, LocalHost, cached, function
 from fal.api import function as isolated  # noqa: F401
 from fal.app import App, endpoint, realtime, wrap_app  # noqa: F401
 from fal.sdk import FalServerlessKeyCredentials
 from fal.sync import sync_dir
 
+from ._version import __version__, version_tuple  # noqa: F401
+
 local = LocalHost()
 serverless = FalServerlessHost()
 
@@ -23,15 +24,6 @@ __all__ = [
     # "wrap_app",
     "FalServerlessKeyCredentials",
     "sync_dir",
+    "__version__",
+    "version_tuple",
 ]
-
-
-# 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
-# N.B.
-# This will add to the package’s __path__ all subdirectories of directories on sys.path named after the package which effectively combines both modules into a single namespace (dbt.adapters)
-# The matching statement is in plugins/postgres/dbt/adapters/__init__.py
-
-from pkgutil import extend_path  # noqa: E402
-
-__path__ = extend_path(__path__, __name__)

fal/__main__.py

@@ -1,4 +1,4 @@
-from .cli import cli
+from .cli import main
 
 if __name__ == "__main__":
-    cli()
+    main()

fal/_fal_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)

fal/_serialization.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
+import pickle
 from typing import Any, Callable
 
-import pickle
 import cloudpickle
 
 
@@ -98,11 +98,12 @@ def _patch_pydantic_field_serialization() -> None:
 
 
 def _patch_pydantic_model_serialization() -> None:
-    # If user has created new pydantic models in his namespace, we will try to pickle those
-    # by value, which means recreating class skeleton, which will stumble upon
-    # __pydantic_parent_namespace__ in its __dict__ and it may contain modules that happened
-    # to be imported in the namespace but are not actually used, resulting in pickling errors.
-    # Unfortunately this also means that `model_rebuid()` might not work.
+    # If user has created new pydantic models in his namespace, we will try to pickle
+    # those by value, which means recreating class skeleton, which will stumble upon
+    # __pydantic_parent_namespace__ in its __dict__ and it may contain modules that
+    # happened to be imported in the namespace but are not actually used, resulting
+    # in pickling errors. Unfortunately this also means that `model_rebuid()` might
+    # not work.
     try:
         import pydantic
     except ImportError:
@@ -133,7 +134,8 @@ def _patch_lru_cache() -> None:
     # https://github.com/cloudpipe/cloudpickle/issues/178
     # https://github.com/uqfoundation/dill/blob/70f569b0dd268d2b1e85c0f300951b11f53c5d53/dill/_dill.py#L1429
 
-    from functools import lru_cache, _lru_cache_wrapper as LRUCacheType
+    from functools import _lru_cache_wrapper as LRUCacheType
+    from functools import lru_cache
 
     def create_lru_cache(func: Callable, kwargs: dict) -> LRUCacheType:
         return lru_cache(**kwargs)(func)
@@ -155,8 +157,8 @@ def _patch_lru_cache() -> None:
 
 def _patch_lock() -> None:
     # https://github.com/uqfoundation/dill/blob/70f569b0dd268d2b1e85c0f300951b11f53c5d53/dill/_dill.py#L1310
-    from threading import Lock
     from _thread import LockType
+    from threading import Lock
 
     def create_lock(locked: bool) -> Lock:
         lock = Lock()
@@ -199,7 +201,11 @@ def _patch_console_thread_locals() -> None:
         return ConsoleThreadLocals(**kwargs)
 
     def pickle_locals(obj: ConsoleThreadLocals) -> tuple[Callable, tuple]:
-        kwargs = {"theme_stack": obj.theme_stack, "buffer": obj.buffer, "buffer_index": obj.buffer_index}
+        kwargs = {
+            "theme_stack": obj.theme_stack,
+            "buffer": obj.buffer,
+            "buffer_index": obj.buffer_index,
+        }
         return create_locals, (kwargs, )
 
     _register(ConsoleThreadLocals, pickle_locals)

fal/_version.py

@@ -0,0 +1,6 @@
+try:
+    from ._fal_version import version as __version__  # type: ignore[import]
+    from ._fal_version import version_tuple  # type: ignore[import]
+except ImportError:
+    __version__ = "UNKNOWN"
+    version_tuple = (0, 0, __version__)  # type: ignore[assignment]

fal/api.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import inspect
+import os
 import sys
 import threading
 from collections import defaultdict
@@ -40,8 +41,8 @@ from pydantic import __version__ as pydantic_version
 from typing_extensions import Concatenate, ParamSpec
 
 import fal.flags as flags
-from fal.exceptions import FalServerlessException
 from fal._serialization import include_modules_from, patch_pickle
+from fal.exceptions import FalServerlessException
 from fal.logging.isolate import IsolateLogPrinter
 from fal.sdk import (
     FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
@@ -57,7 +58,7 @@ from fal.sdk import (
 )
 
 ArgsT = ParamSpec("ArgsT")
-ReturnT = TypeVar("ReturnT", covariant=True)
+ReturnT = TypeVar("ReturnT", covariant=True)  # noqa: PLC0105
 
 BasicConfig = Dict[str, Any]
 _UNSET = object()
@@ -113,8 +114,8 @@ class Host(Generic[ArgsT, ReturnT]):
         environment options."""
 
         options = Options()
-        for key, value in config.items():
-            key, value = cls.parse_key(key, value)
+        for item in config.items():
+            key, value = cls.parse_key(*item)
             if key in cls._SUPPORTED_KEYS:
                 options.host[key] = value
             elif key in cls._GATEWAY_KEYS:
@@ -545,7 +546,8 @@ _DEFAULT_HOST = FalServerlessHost()
 _SERVE_PORT = 8080
 
 # Overload @function to help users identify the correct signature.
-# NOTE: This is both in sync with host options and with environment configs from `isolate` package.
+# NOTE: This is both in sync with host options and with environment configs from
+# `isolate` package.
 
 
 ## virtualenv
@@ -785,7 +787,8 @@ class FalFastAPI(FastAPI):
         """
         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.
+        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):
@@ -830,6 +833,9 @@ class BaseServable:
         """
         pass
 
+    def _add_extra_routes(self, app: FastAPI):
+        pass
+
     @asynccontextmanager
     async def lifespan(self, app: FastAPI):
         yield
@@ -840,7 +846,10 @@ class BaseServable:
         from fastapi.responses import JSONResponse
         from starlette_exporter import PrometheusMiddleware
 
-        _app = FalFastAPI(lifespan=self.lifespan)
+        _app = FalFastAPI(
+            lifespan=self.lifespan,
+            root_path=os.getenv("FAL_APP_ROOT_PATH") or "",
+        )
 
         _app.add_middleware(
             CORSMiddleware,
@@ -891,6 +900,8 @@ class BaseServable:
                     methods=["POST"],
                 )
 
+        self._add_extra_routes(_app)
+
         return _app
 
     def openapi(self) -> dict[str, Any]:
@@ -918,7 +929,9 @@ class BaseServable:
                 asyncio.create_task(metrics_server.serve()): metrics_server,
             }
 
-            _, pending = await asyncio.wait(tasks.keys(), return_when=asyncio.FIRST_COMPLETED)
+            _, pending = await asyncio.wait(
+                tasks.keys(), return_when=asyncio.FIRST_COMPLETED,
+            )
             if not pending:
                 return
 
@@ -1007,13 +1020,15 @@ class IsolatedFunction(Generic[ArgsT, ReturnT]):
                 lines = []
                 for used_modules, references in pairs:
                     lines.append(
-                        f"\t- {used_modules!r} (accessed through {', '.join(map(repr, references))})"
+                        f"\t- {used_modules!r} "
+                        f"(accessed through {', '.join(map(repr, references))})"
                     )
 
                 function_name = self.func.__name__
                 raise FalServerlessError(
-                    f"Couldn't deserialize your function on the remote server. \n\n[Hint] {function_name!r} "
-                    f"function uses the following modules which weren't present in the environment definition:\n"
+                    f"Couldn't deserialize your function on the remote server. \n\n"
+                    f"[Hint] {function_name!r} function uses the following modules "
+                    "which weren't present in the environment definition:\n"
                     + "\n".join(lines)
                 ) from None
         except Exception as exc:
@@ -1065,7 +1080,8 @@ class IsolatedFunction(Generic[ArgsT, ReturnT]):
     def func(self) -> Callable[ArgsT, ReturnT]:
         serve_mode = self.options.gateway.get("serve")
         if serve_mode:
-            # This type can be safely ignored because this case only happens when it is a ServedIsolatedFunction
+            # This type can be safely ignored because this case only happens when it
+            # is a ServedIsolatedFunction
             serve_func: Callable[[], None] = ServeWrapper(self.raw_func)
             return serve_func  # type: ignore
         else:
@@ -1098,8 +1114,10 @@ class ServedIsolatedFunction(
 
 class Server(uvicorn.Server):
     """Server is a uvicorn.Server that actually plays nicely with signals.
-    By default, uvicorn's Server class overwrites the signal handler for SIGINT, swallowing the signal and preventing other tasks from cancelling.
-    This class allows the task to be gracefully cancelled using asyncio's built-in task cancellation or with an event, like aiohttp.
+    By default, uvicorn's Server class overwrites the signal handler for SIGINT,
+    swallowing the signal and preventing other tasks from cancelling.
+    This class allows the task to be gracefully cancelled using asyncio's built-in task
+    cancellation or with an event, like aiohttp.
     """
 
     def install_signal_handlers(self) -> None:

fal/app.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import inspect
 import json
 import os
+import re
 import typing
 from contextlib import asynccontextmanager
 from typing import Any, Callable, ClassVar, TypeVar
@@ -10,9 +11,11 @@ from typing import Any, Callable, ClassVar, TypeVar
 from fastapi import FastAPI
 
 import fal.api
+from fal._serialization import include_modules_from
 from fal.api import RouteSignature
 from fal.logging import get_logger
-from fal._serialization import include_modules_from
+from fal.toolkit.file.providers import fal as fal_provider_module
+
 REALTIME_APP_REQUIREMENTS = ["websockets", "msgpack"]
 
 EndpointT = TypeVar("EndpointT", bound=Callable[..., Any])
@@ -62,14 +65,33 @@ def wrap_app(cls: type[App], **kwargs) -> fal.api.IsolatedFunction:
     return fn
 
 
+
+PART_FINDER_RE = re.compile(r"[A-Z][a-z]*")
+
+
+def _to_fal_app_name(name: str) -> str:
+    # Convert MyGoodApp into my-good-app
+    return "-".join(part.lower() for part in PART_FINDER_RE.findall(name))
+
+
 class App(fal.api.BaseServable):
     requirements: ClassVar[list[str]] = []
     machine_type: ClassVar[str] = "S"
-    host_kwargs: ClassVar[dict[str, Any]] = {}
+    host_kwargs: ClassVar[dict[str, Any]] = {
+        "_scheduler": "nomad",
+        "_scheduler_options": {
+            "storage_region": "us-east",
+        },
+        "resolver": "uv",
+        "keep_alive": 60,
+    }
+    app_name: ClassVar[str]
 
     def __init_subclass__(cls, **kwargs):
+        app_name = kwargs.pop("name", None) or _to_fal_app_name(cls.__name__)
         parent_settings = getattr(cls, "host_kwargs", {})
         cls.host_kwargs = {**parent_settings, **kwargs}
+        cls.app_name = app_name
 
         if cls.__init__ is not App.__init__:
             raise ValueError(
@@ -98,6 +120,9 @@ class App(fal.api.BaseServable):
         finally:
             await _call_any_fn(self.teardown)
 
+    def health(self):
+        return {}
+
     def setup(self):
         """Setup the application before serving."""
 
@@ -123,6 +148,27 @@ class App(fal.api.BaseServable):
                 )
             return response
 
+        @app.middleware("http")
+        async def set_global_object_preference(request, call_next):
+            response = await call_next(request)
+            try:
+                fal_provider_module.GLOBAL_LIFECYCLE_PREFERENCE = request.headers.get(
+                    "X-Fal-Object-Lifecycle-Preference"
+                )
+            except Exception:
+                from fastapi.logger import logger
+
+                logger.exception(
+                    "Failed set a global lifecycle preference %s",
+                    self.__class__.__name__,
+                )
+            return response
+
+    def _add_extra_routes(self, app: FastAPI):
+        @app.get("/health")
+        def health():
+            return self.health()
+
     def provide_hints(self) -> list[str]:
         """Provide hints for routing the application."""
         raise NotImplementedError
@@ -237,14 +283,16 @@ def _fal_websocket_template(
                     output = output.dict()
                 else:
                     raise TypeError(
-                        f"Expected a dict or pydantic model as output, got {type(output)}"
+                        "Expected a dict or pydantic model as output, got "
+                        f"{type(output)}"
                     )
 
             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.
+                # We emit x-fal messages in JSON, no matter what the
+                # input/output format is.
                 timings = {
                     "type": "x-fal-message",
                     "action": "timings",
@@ -354,7 +402,8 @@ def realtime(
 
         if hasattr(original_func, "route_signature"):
             raise ValueError(
-                f"Can't set multiple routes for the same function: {original_func.__name__}"
+                "Can't set multiple routes for the same function: "
+                f"{original_func.__name__}"
             )
 
         if input_modal is _SENTINEL:

fal/auth/__init__.py

@@ -51,7 +51,8 @@ def _fetch_access_token() -> str:
     Load the refresh token, request a new access_token (refreshing the refresh token)
     and return the access_token.
     """
-    # We need to lock both read and write access because we could be reading a soon invalid refresh_token
+    # We need to lock both read and write access because we could be reading a soon
+    # invalid refresh_token
     with local.lock_token():
         refresh_token, access_token = local.load_token()
 

fal/auth/auth0.py

@@ -30,7 +30,8 @@ def _open_browser(url: str, code: str | None) -> None:
     maybe_open_browser_tab(url)
 
     console.print(
-        "If browser didn't open automatically, on your computer or mobile device navigate to"
+        "If browser didn't open automatically, "
+        "on your computer or mobile device navigate to"
     )
     console.print(url)
 
@@ -155,7 +156,8 @@ def build_jwk_client():
 
 def validate_id_token(token: str):
     """
-    id_token is intended for the client (this sdk) only. Never send one to another service.
+    id_token is intended for the client (this sdk) only.
+    Never send one to another service.
     """
     from jwt import decode
 

fal/auth/local.py

@@ -62,7 +62,8 @@ def delete_token() -> None:
 @contextmanager
 def lock_token():
     """
-    Lock the access to the token file to avoid race conditions when running multiple scripts at the same time.
+    Lock the access to the token file to avoid race conditions when running multiple
+    scripts at the same time.
     """
     lock_file = _check_dir_exist() / _LOCK_FILE
     with portalocker.utils.TemporaryFileLock(

fal/cli/__init__.py

@@ -0,0 +1 @@
+from .main import main  # noqa: F401