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

fal/__init__.py

@@ -7,6 +7,8 @@ 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()
 
@@ -22,4 +24,6 @@ __all__ = [
     # "wrap_app",
     "FalServerlessKeyCredentials",
     "sync_dir",
+    "__version__",
+    "version_tuple",
 ]

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/_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
@@ -832,6 +833,9 @@ class BaseServable:
         """
         pass
 
+    def _add_extra_routes(self, app: FastAPI):
+        pass
+
     @asynccontextmanager
     async def lifespan(self, app: FastAPI):
         yield
@@ -842,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,
@@ -893,6 +900,8 @@ class BaseServable:
                     methods=["POST"],
                 )
 
+        self._add_extra_routes(_app)
+
         return _app
 
     def openapi(self) -> dict[str, Any]:

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
@@ -64,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(
@@ -100,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."""
 
@@ -141,6 +164,11 @@ class App(fal.api.BaseServable):
                 )
             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

fal/cli/__init__.py

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

fal/cli/apps.py

@@ -0,0 +1,313 @@
+from typing import TYPE_CHECKING
+
+from .parser import FalClientParser
+
+if TYPE_CHECKING:
+    from fal.sdk import AliasInfo, ApplicationInfo
+
+
+def _apps_table(apps: list["AliasInfo"]):
+    from rich.table import Table
+
+    table = Table()
+    table.add_column("Name", no_wrap=True)
+    table.add_column("Revision")
+    table.add_column("Auth")
+    table.add_column("Min Concurrency")
+    table.add_column("Max Concurrency")
+    table.add_column("Max Multiplexing")
+    table.add_column("Keep Alive")
+    table.add_column("Active Workers")
+
+    for app in apps:
+        table.add_row(
+            app.alias,
+            app.revision,
+            app.auth_mode,
+            str(app.min_concurrency),
+            str(app.max_concurrency),
+            str(app.max_multiplexing),
+            str(app.keep_alive),
+            str(app.active_runners),
+        )
+
+    return table
+
+
+def _list(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        apps = connection.list_aliases()
+        table = _apps_table(apps)
+
+    args.console.print(table)
+
+
+def _add_list_parser(subparsers, parents):
+    list_help = "List applications."
+    parser = subparsers.add_parser(
+        "list",
+        description=list_help,
+        help=list_help,
+        parents=parents,
+    )
+    parser.set_defaults(func=_list)
+
+
+def _app_rev_table(revs: list["ApplicationInfo"]):
+    from rich.table import Table
+
+    table = Table()
+    table.add_column("Revision", no_wrap=True)
+    table.add_column("Min Concurrency")
+    table.add_column("Max Concurrency")
+    table.add_column("Max Multiplexing")
+    table.add_column("Keep Alive")
+    table.add_column("Active Workers")
+
+    for rev in revs:
+        table.add_row(
+            rev.application_id,
+            str(rev.min_concurrency),
+            str(rev.max_concurrency),
+            str(rev.max_multiplexing),
+            str(rev.keep_alive),
+            str(rev.active_runners),
+        )
+
+    return table
+
+
+def _list_rev(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        revs = connection.list_applications()
+        table = _app_rev_table(revs)
+
+    args.console.print(table)
+
+
+def _add_list_rev_parser(subparsers, parents):
+    list_help = "List application revisions."
+    parser = subparsers.add_parser(
+        "list-rev",
+        description=list_help,
+        help=list_help,
+        parents=parents,
+    )
+    parser.set_defaults(func=_list_rev)
+
+
+def _scale(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        if (
+            args.keep_alive is None
+            and args.max_multiplexing is None
+            and args.max_concurrency is None
+            and args.min_concurrency is None
+        ):
+            args.console.log("No parameters for update were provided, ignoring.")
+            return
+
+        alias_info = connection.update_application(
+            application_name=args.app_alias,
+            keep_alive=args.keep_alive,
+            max_multiplexing=args.max_multiplexing,
+            max_concurrency=args.max_concurrency,
+            min_concurrency=args.min_concurrency,
+        )
+        table = _apps_table([alias_info])
+
+    args.console.print(table)
+
+
+def _add_scale_parser(subparsers, parents):
+    scale_help = "Scale application."
+    parser = subparsers.add_parser(
+        "scale",
+        description=scale_help,
+        help=scale_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "--keep-alive",
+        type=int,
+        help="Keep alive (seconds).",
+    )
+    parser.add_argument(
+        "--max-multiplexing",
+        type=int,
+        help="Maximum multiplexing",
+    )
+    parser.add_argument(
+        "--max-concurrency",
+        type=int,
+        help="Maximum concurrency.",
+    )
+    parser.add_argument(
+        "--min-concurrency",
+        type=int,
+        help="Minimum concurrency",
+    )
+    parser.set_defaults(func=_scale)
+
+
+def _set_rev(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        connection.create_alias(args.app_name, args.app_rev, args.auth)
+
+
+def _add_set_rev_parser(subparsers, parents):
+    from fal.sdk import ALIAS_AUTH_MODES
+
+    set_help = "Set application to a particular revision."
+    parser = subparsers.add_parser(
+        "set-rev",
+        description=set_help,
+        help=set_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "app_name",
+        help="Application name.",
+    )
+    parser.add_argument(
+        "app_rev",
+        help="Application revision.",
+    )
+    parser.add_argument(
+        "--auth",
+        choices=ALIAS_AUTH_MODES,
+        default="private",
+        help="Application authentication mode.",
+    )
+    parser.set_defaults(func=_set_rev)
+
+
+def _runners(args):
+    from rich.table import Table
+
+    from fal.sdk import FalServerlessClient
+
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        runners = connection.list_alias_runners(alias=args.app_name)
+
+    table = Table()
+    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(
+            runner.runner_id,
+            str(runner.in_flight_requests),
+            (
+                "N/A (active)"
+                if not runner.expiration_countdown
+                else f"{runner.expiration_countdown}s"
+            ),
+            f"{runner.uptime} ({runner.uptime.total_seconds()}s)",
+        )
+
+    args.console.print(table)
+
+
+def _add_runners_parser(subparsers, parents):
+    runners_help = "List application runners."
+    parser = subparsers.add_parser(
+        "runners",
+        description=runners_help,
+        help=runners_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "app_name",
+        help="Application name.",
+    )
+    parser.set_defaults(func=_runners)
+
+
+def _delete(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        connection.delete_alias(args.app_name)
+
+
+def _add_delete_parser(subparsers, parents):
+    delete_help = "Delete application."
+    parser = subparsers.add_parser(
+        "delete",
+        description=delete_help,
+        help=delete_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "app_name",
+        help="Application name.",
+    )
+    parser.set_defaults(func=_delete)
+
+
+def _delete_rev(args):
+    from fal.sdk import FalServerlessClient
+
+    client = FalServerlessClient(args.host)
+    with client.connect() as connection:
+        connection.delete_application(args.app_rev)
+
+
+def _add_delete_rev_parser(subparsers, parents):
+    delete_help = "Delete application revision."
+    parser = subparsers.add_parser(
+        "delete-rev",
+        description=delete_help,
+        help=delete_help,
+        parents=parents,
+    )
+    parser.add_argument(
+        "app_rev",
+        help="Application revision.",
+    )
+    parser.set_defaults(func=_delete_rev)
+
+
+def add_parser(main_subparsers, parents):
+    apps_help = "Manage fal applications."
+    parser = main_subparsers.add_parser(
+        "apps",
+        aliases=["app"],
+        description=apps_help,
+        help=apps_help,
+        parents=parents,
+    )
+
+    subparsers = parser.add_subparsers(
+        title="Commands",
+        metavar="command",
+        required=True,
+    )
+
+    parents = [*parents, FalClientParser(add_help=False)]
+
+    _add_list_parser(subparsers, parents)
+    _add_list_rev_parser(subparsers, parents)
+    _add_set_rev_parser(subparsers, parents)
+    _add_scale_parser(subparsers, parents)
+    _add_runners_parser(subparsers, parents)
+    _add_delete_parser(subparsers, parents)
+    _add_delete_rev_parser(subparsers, parents)

fal/cli/auth.py

@@ -0,0 +1,59 @@
+from fal.auth import USER, login, logout
+
+
+def _login(args):
+    login()
+
+
+def _logout(args):
+    logout()
+
+
+def _whoami(args):
+    user_name = USER.info["name"]
+    sub = USER.info["sub"]
+    args.console.print(f"Hello, {user_name} - '{sub}'")
+
+
+def add_parser(main_subparsers, parents):
+    auth_help = "Authenticate with fal."
+    parser = main_subparsers.add_parser(
+        "auth",
+        description=auth_help,
+        help=auth_help,
+        parents=parents,
+    )
+
+    subparsers = parser.add_subparsers(
+        title="Commands",
+        metavar="command",
+        dest="cmd",
+        required=True,
+    )
+
+    login_help = "Log in a user."
+    login_parser = subparsers.add_parser(
+        "login",
+        description=login_help,
+        help=login_help,
+        parents=parents,
+    )
+    login_parser.set_defaults(func=_login)
+
+    logout_help = "Log out the currently logged-in user."
+    logout_parser = subparsers.add_parser(
+        "logout",
+        description=logout_help,
+        help=logout_help,
+        parents=parents,
+    )
+    logout_parser.set_defaults(func=_logout)
+
+    whoami_help = "Show the currently authenticated user."
+    whoami_parser = subparsers.add_parser(
+        "whoami",
+        description=whoami_help,
+        help=whoami_help,
+        parents=parents,
+    )
+    whoami_parser.set_defaults(func=_whoami)

fal/cli/debug.py

@@ -0,0 +1,65 @@
+from contextlib import ExitStack, contextmanager
+
+from .parser import FalParser
+
+
+@contextmanager
+def _pdb():
+    try:
+        yield
+    except Exception:
+        try:
+            import ipdb as pdb  # noqa: T100
+        except ImportError:
+            import pdb  # noqa: T100
+        pdb.post_mortem()
+
+
+@contextmanager
+def _cprofile():
+    import cProfile
+
+    prof = cProfile.Profile()
+    prof.enable()
+
+    try:
+        yield
+    finally:
+        prof.disable()
+        prof.print_stats(sort="cumtime")
+
+
+@contextmanager
+def debugtools(args):
+    with ExitStack() as stack:
+        if args.pdb:
+            stack.enter_context(_pdb())
+        if args.cprofile:
+            stack.enter_context(_cprofile())
+        try:
+            yield
+        except Exception:
+            if args.debug:
+                args.console.print_exception()
+            raise
+
+
+def get_debug_parser():
+    parser = FalParser(add_help=False)
+    group = parser.add_argument_group(title="Debug")
+    group.add_argument(
+        "--debug",
+        action="store_true",
+        help="Show verbose errors."
+    )
+    group.add_argument(
+        "--pdb",
+        action="store_true",
+        help="Start pdb on error.",
+    )
+    group.add_argument(
+        "--cprofile",
+        action="store_true",
+        help="Show cProfile report.",
+    )
+    return parser