fal 0.11.3__tar.gz → 0.11.5__tar.gz

{fal-0.11.3 → fal-0.11.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fal
-Version: 0.11.3
+Version: 0.11.5
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels
 Author-email: hello@fal.ai

{fal-0.11.3 → fal-0.11.5}/openapi-fal-rest/openapi_fal_rest/models/__init__.py

@@ -12,7 +12,9 @@ from .get_gateway_request_stats_by_time_response_get_gateway_request_stats_by_ti
     GetGatewayRequestStatsByTimeResponseGetGatewayRequestStatsByTime,
 )
 from .grouped_usage_detail import GroupedUsageDetail
-from .handle_stripe_webhook_response_handle_stripe_webhook import HandleStripeWebhookResponseHandleStripeWebhook
+from .handle_stripe_webhook_response_handle_stripe_webhook import (
+    HandleStripeWebhookResponseHandleStripeWebhook,
+)
 from .hash_check import HashCheck
 from .http_validation_error import HTTPValidationError
 from .initiate_upload_info import InitiateUploadInfo

{fal-0.11.3 → fal-0.11.5}/openapi-fal-rest/openapi_fal_rest/models/grouped_usage_detail.py

@@ -12,14 +12,14 @@ class GroupedUsageDetail:
         model_id (str):
         machine_type (str):
         request_count (int):
-        avg_duration (float):
+        median_duration (float):
         total_duration (float):
     """
 
     model_id: str
     machine_type: str
     request_count: int
-    avg_duration: float
+    median_duration: float
     total_duration: float
     additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
 
@@ -27,7 +27,7 @@ class GroupedUsageDetail:
         model_id = self.model_id
         machine_type = self.machine_type
         request_count = self.request_count
-        avg_duration = self.avg_duration
+        median_duration = self.median_duration
         total_duration = self.total_duration
 
         field_dict: Dict[str, Any] = {}
@@ -37,7 +37,7 @@ class GroupedUsageDetail:
                 "model_id": model_id,
                 "machine_type": machine_type,
                 "request_count": request_count,
-                "avg_duration": avg_duration,
+                "median_duration": median_duration,
                 "total_duration": total_duration,
             }
         )
@@ -53,7 +53,7 @@ class GroupedUsageDetail:
 
         request_count = d.pop("request_count")
 
-        avg_duration = d.pop("avg_duration")
+        median_duration = d.pop("median_duration")
 
         total_duration = d.pop("total_duration")
 
@@ -61,7 +61,7 @@ class GroupedUsageDetail:
             model_id=model_id,
             machine_type=machine_type,
             request_count=request_count,
-            avg_duration=avg_duration,
+            median_duration=median_duration,
             total_duration=total_duration,
         )
 

{fal-0.11.3 → fal-0.11.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "fal"
-version = "0.11.3"
+version = "0.11.5"
 description = "fal is an easy-to-use Serverless Python Framework"
 authors = ["Features & Labels <hello@fal.ai>"]
 readme = "README.md"

{fal-0.11.3 → fal-0.11.5}/setup.py

@@ -82,7 +82,7 @@ entry_points = \
 
 setup_kwargs = {
     'name': 'fal',
-    'version': '0.11.3',
+    'version': '0.11.5',
     'description': 'fal is an easy-to-use Serverless Python Framework',
     'long_description': '# fal\n\nfal is a serverless Python runtime that lets you run and scale code in the cloud with no infra management.\n\nWith fal, you can build pipelines, serve ML models and scale them up to many users. You scale down to 0 when you don\'t use any resources.\n\n## Quickstart\n\nFirst, you need to install the `fal` package. You can do so using pip:\n```shell\npip install fal\n```\n\nThen you need to authenticate:\n```shell\nfal auth login\n```\n\nYou can also use fal keys that you can get from [our dashboard](https://fal.ai/dashboard/keys).\n\nNow can use the fal package in your Python scripts as follows:\n\n```py\nimport fal\n\n@fal.function(\n    "virtualenv",\n    requirements=["pyjokes"],\n)\ndef tell_joke() -> str:\n    import pyjokes\n\n    joke = pyjokes.get_joke()\n    return joke\n\nprint("Joke from the clouds: ", tell_joke())\n```\n\nA new virtual environment will be created by fal in the cloud and the set of requirements that we passed will be installed as soon as this function is called. From that point on, our code will be executed as if it were running locally, and the joke prepared by the pyjokes library will be returned.\n\n## Next steps\n\nIf you would like to find out more about the capabilities of fal, check out to the [docs](https://fal.ai/docs). You can learn more about persistent storage, function caches and deploying your functions as API endpoints.\n',
     'author': 'Features & Labels',

{fal-0.11.3 → fal-0.11.5}/src/fal/__init__.py

@@ -6,6 +6,7 @@ from fal import apps
 from fal.api import FalServerlessHost, LocalHost, cached
 from fal.api import function
 from fal.api import function as isolated
+from fal.app import App, endpoint, wrap_app
 from fal.sdk import FalServerlessKeyCredentials
 from fal.sync import sync_dir
 
@@ -15,35 +16,8 @@ serverless = FalServerlessHost()
 # DEPRECATED - use serverless instead
 cloud = FalServerlessHost()
 
-DBT_FAL_IMPORT_NOTICE = """
-The dbt tool `fal` and `dbt-fal` adapter have been merged into a single tool.
-Please import from the `fal.dbt` module instead.
-Running `pip install dbt-fal` will install the new tool and the adapter alongside.
-Then import from the `fal.dbt` module like
-
-    from fal.dbt import {name}
-
-"""
-
-
-# Avoid printing on non-direct imports
-def __getattr__(name: str):
-    if name in (
-        "NodeStatus",
-        "FalDbt",
-        "DbtModel",
-        "DbtSource",
-        "DbtTest",
-        "DbtGenericTest",
-        "DbtSingularTest",
-        "Context",
-        "CurrentModel",
-    ):
-        raise ImportError(DBT_FAL_IMPORT_NOTICE.format(name=name))
-
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
-
 
+# 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)

{fal-0.11.3 → fal-0.11.5}/src/fal/api.py

@@ -552,6 +552,7 @@ def function(
     exposed_port: int | None = None,
     max_concurrency: int | None = None,
     # FalServerlessHost options
+    metadata: dict[str, Any] | None = None,
     machine_type: str = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
@@ -576,6 +577,7 @@ def function(
     exposed_port: int | None = None,
     max_concurrency: int | None = None,
     # FalServerlessHost options
+    metadata: dict[str, Any] | None = None,
     machine_type: str = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
@@ -652,6 +654,7 @@ def function(
     exposed_port: int | None = None,
     max_concurrency: int | None = None,
     # FalServerlessHost options
+    metadata: dict[str, Any] | None = None,
     machine_type: str = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
@@ -681,6 +684,7 @@ def function(
     exposed_port: int | None = None,
     max_concurrency: int | None = None,
     # FalServerlessHost options
+    metadata: dict[str, Any] | None = None,
     machine_type: str = FAL_SERVERLESS_DEFAULT_MACHINE_TYPE,
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
@@ -788,7 +792,7 @@ class ServeWrapper:
             if "properties" in schema:
                 mark_order(schema, "properties")
 
-        for key in spec["components"].get("schemas") or {}:
+        for key in spec.get("components", {}).get("schemas") or {}:
             order_schema_object(spec["components"]["schemas"][key])
 
         return spec

fal-0.11.5/src/fal/app.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import inspect
+import os
+import fal.api
+from fal.toolkit import mainify
+from fastapi import FastAPI
+from typing import Any, NamedTuple, Callable, TypeVar, ClassVar
+from fal.logging import get_logger
+
+EndpointT = TypeVar("EndpointT", bound=Callable[..., Any])
+logger = get_logger(__name__)
+
+
+def wrap_app(cls: type[App], **kwargs) -> fal.api.IsolatedFunction:
+    def initialize_and_serve():
+        app = cls()
+        app.serve()
+
+    try:
+        app = cls(_allow_init=True)
+        metadata = app.openapi()
+    except Exception as exc:
+        logger.warning("Failed to build OpenAPI specification for %s", cls.__name__)
+        metadata = {}
+
+    wrapper = fal.api.function(
+        "virtualenv",
+        requirements=cls.requirements,
+        machine_type=cls.machine_type,
+        **cls.host_kwargs,
+        **kwargs,
+        metadata=metadata,
+        serve=True,
+    )
+    return wrapper(initialize_and_serve).on(
+        serve=False,
+        exposed_port=8080,
+    )
+
+
+@mainify
+class RouteSignature(NamedTuple):
+    path: str
+
+
+@mainify
+class App:
+    requirements: ClassVar[list[str]] = []
+    machine_type: ClassVar[str] = "S"
+    host_kwargs: ClassVar[dict[str, Any]] = {}
+
+    def __init_subclass__(cls, **kwargs):
+        cls.host_kwargs = kwargs
+
+        if cls.__init__ is not App.__init__:
+            raise ValueError(
+                "App classes should not override __init__ directly. "
+                "Use setup() instead."
+            )
+
+    def __init__(self, *, _allow_init: bool = False):
+        if not _allow_init and not os.getenv("IS_ISOLATE_AGENT"):
+            raise NotImplementedError(
+                "Running apps through SDK is not implemented yet."
+            )
+
+    def setup(self):
+        """Setup the application before serving."""
+
+    def serve(self) -> None:
+        import uvicorn
+
+        app = self._build_app()
+        self.setup()
+        uvicorn.run(app, host="0.0.0.0", port=8080)
+
+    def _build_app(self) -> FastAPI:
+        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=("*"),
+        )
+
+        routes: dict[RouteSignature, Callable[..., Any]] = {
+            signature: endpoint
+            for _, endpoint in inspect.getmembers(self, inspect.ismethod)
+            if (signature := getattr(endpoint, "route_signature", None))
+        }
+        if not routes:
+            raise ValueError("An application must have at least one route!")
+
+        for signature, endpoint in routes.items():
+            _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()
+        self._mark_order_openapi(spec)
+        return spec
+
+    def _mark_order_openapi(self, 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
+
+
+@mainify
+def endpoint(path: str) -> Callable[[EndpointT], EndpointT]:
+    """Designate the decorated function as an application endpoint."""
+
+    def marker_fn(callable: EndpointT) -> EndpointT:
+        if hasattr(callable, "route_signature"):
+            raise ValueError(
+                f"Can't set multiple routes for the same function: {callable.__name__}"
+            )
+
+        callable.route_signature = RouteSignature(path=path)  # type: ignore
+        return callable
+
+    return marker_fn

{fal-0.11.3 → fal-0.11.5}/src/fal/cli.py

@@ -9,7 +9,7 @@ from uuid import uuid4
 
 import click
 import fal.auth as auth
-import grpc
+import fal
 from fal import api, sdk
 from fal.console import console
 from fal.exceptions import ApplicationExceptionHandler
@@ -145,15 +145,6 @@ def auth_cli():
 @auth_cli.command(name="login")
 def auth_login():
     auth.login()
-    try:
-        client = sdk.FalServerlessClient(f"{DEFAULT_HOST}:{DEFAULT_PORT}")
-        with client.connect() as connection:
-            connection.list_aliases()
-    except grpc.RpcError as e:
-        if "Insufficient permissions" in e.details():
-            console.print(e.details())
-        else:
-            raise e
 
 
 @auth_cli.command(name="logout")
@@ -244,6 +235,28 @@ def function_cli(ctx, host: str, port: str):
     ctx.obj = api.FalServerlessHost(f"{host}:{port}")
 
 
+def load_function_from(
+    host: api.FalServerlessHost,
+    file_path: str,
+    function_name: str,
+) -> api.IsolatedFunction:
+    import runpy
+
+    module = runpy.run_path(file_path)
+    if function_name not in module:
+        raise api.FalServerlessError(f"Function '{function_name}' not found in module")
+
+    target = module[function_name]
+    if isinstance(target, type) and issubclass(target, fal.App):
+        target = fal.wrap_app(target, host=host)
+
+    if not isinstance(target, api.IsolatedFunction):
+        raise api.FalServerlessError(
+            f"Function '{function_name}' is not a fal.function or a fal.App"
+        )
+    return target
+
+
 @function_cli.command("serve")
 @click.option("--alias", default=None)
 @click.option(
@@ -262,15 +275,9 @@ def register_application(
     alias: str | None,
     auth_mode: ALIAS_AUTH_TYPE,
 ):
-    import runpy
-
     user_id = _get_user_id()
 
-    module = runpy.run_path(file_path)
-    if function_name not in module:
-        raise api.FalServerlessError(f"Function '{function_name}' not found in module")
-
-    isolated_function: api.IsolatedFunction = module[function_name]
+    isolated_function = load_function_from(host, file_path, function_name)
     gateway_options = isolated_function.options.gateway
     if "serve" not in gateway_options and "exposed_port" not in gateway_options:
         raise api.FalServerlessError(
@@ -289,7 +296,7 @@ def register_application(
         options=isolated_function.options,
         application_name=alias,
         application_auth_mode=auth_mode,
-        metadata={},
+        metadata=isolated_function.options.host.get("metadata", {}),
     )
 
     if id:
@@ -307,6 +314,15 @@ def register_application(
             console.print(f"URL: https://{user_id}-{id}.{gateway_host}")
 
 
+@function_cli.command("run")
+@click.argument("file_path", required=True)
+@click.argument("function_name", required=True)
+@click.pass_obj
+def run(host: api.FalServerlessHost, file_path: str, function_name: str):
+    isolated_function = load_function_from(host, file_path, function_name)
+    isolated_function()
+
+
 @function_cli.command("logs")
 @click.option("--lines", default=100)
 @click.option("--url", default=None)
@@ -520,30 +536,6 @@ def remove_http_and_port_from_url(url):
     return url
 
 
-# dbt-fal commands to be errored out
-DBT_FAL_COMMAND_NOTICE = """
-The dbt tool `fal` and `dbt-fal` adapter have been merged into a single tool.
-Please use the new `dbt-fal` command line tool instead.
-Running `pip install dbt-fal` will install the new tool and the adapter alongside.
-Then run your command like
-
-    dbt-fal <command>
-
-"""
-
-
-@cli.command("run", context_settings={"ignore_unknown_options": True})
-@click.argument("any", nargs=-1, type=click.UNPROCESSED)
-def dbt_run(any):
-    raise click.BadArgumentUsage(DBT_FAL_COMMAND_NOTICE)
-
-
-@cli.command("flow", context_settings={"ignore_unknown_options": True})
-@click.argument("any", nargs=-1, type=click.UNPROCESSED)
-def dbt_flow(any):
-    raise click.BadArgumentUsage(DBT_FAL_COMMAND_NOTICE)
-
-
 def _get_user_id() -> str:
     try:
         user_details_response = get_user_details.sync_detailed(

{fal-0.11.3 → fal-0.11.5}/src/fal/exceptions/_base.py

@@ -14,4 +14,4 @@ class FalServerlessException(Exception):
         super().__init__(message)
 
     def __str__(self) -> str:
-        return self.message
+        return self.message + (f"\nHint: {self.hint}" if self.hint else "")

{fal-0.11.3 → fal-0.11.5}/src/fal/exceptions/auth.py

@@ -9,5 +9,5 @@ class UnauthenticatedException(FalServerlessException):
     def __init__(self) -> None:
         super().__init__(
             message="You must be authenticated.",
-            hint="Login via `fal auth login`",
+            hint="Login via `fal auth login` or make sure to setup fal keys correctly.",
         )