fal 1.0.7__py3-none-any.whl → 1.1.0__py3-none-any.whl

fal/_fal_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.0.7'
-__version_tuple__ = version_tuple = (1, 0, 7)
+__version__ = version = '1.1.0'
+__version_tuple__ = version_tuple = (1, 1, 0)

fal/api.py

@@ -5,11 +5,12 @@ import os
 import sys
 import threading
 from collections import defaultdict
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import Future, ThreadPoolExecutor
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass, field, replace
 from functools import wraps
 from os import PathLike
+from queue import Queue
 from typing import (
     Any,
     Callable,
@@ -72,6 +73,9 @@ SERVE_REQUIREMENTS = [
 ]
 
 
+THREAD_POOL = ThreadPoolExecutor()
+
+
 @dataclass
 class FalServerlessError(FalServerlessException):
     message: str
@@ -83,8 +87,32 @@ class InternalFalServerlessError(FalServerlessException):
 
 
 @dataclass
-class FalMissingDependencyError(FalServerlessError):
-    ...
+class FalMissingDependencyError(FalServerlessError): ...
+
+
+@dataclass
+class SpawnInfo:
+    future: Future | None = None
+    logs: Queue = field(default_factory=Queue)
+    _url_ready: threading.Event = field(default_factory=threading.Event)
+    _url: str | None = None
+    stream: Any = None
+
+    @property
+    def return_value(self):
+        if self.future is None:
+            raise ValueError
+        return self.future.result()
+
+    @property
+    def url(self):
+        self._url_ready.wait()
+        return self._url
+
+    @url.setter
+    def url(self, value):
+        self._url_ready.set()
+        self._url = value
 
 
 @dataclass
@@ -150,6 +178,15 @@ class Host(Generic[ArgsT, ReturnT]):
         """Run the given function in the isolated environment."""
         raise NotImplementedError
 
+    def spawn(
+        self,
+        func: Callable[ArgsT, ReturnT],
+        options: Options,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+    ) -> SpawnInfo:
+        raise NotImplementedError
+
 
 def cached(func: Callable[ArgsT, ReturnT]) -> Callable[ArgsT, ReturnT]:
     """Cache the result of the given function in-memory."""
@@ -444,12 +481,13 @@ class FalServerlessHost(Host):
         return None
 
     @_handle_grpc_error()
-    def run(
+    def _run(
         self,
         func: Callable[..., ReturnT],
         options: Options,
         args: tuple[Any, ...],
         kwargs: dict[str, Any],
+        result_handler: Callable[..., None],
     ) -> ReturnT:
         environment_options = options.environment.copy()
         environment_options.setdefault("python_version", active_python())
@@ -490,8 +528,7 @@ class FalServerlessHost(Host):
             machine_requirements=machine_requirements,
             setup_function=setup_function,
         ):
-            for log in partial_result.logs:
-                self._log_printer.print(log)
+            result_handler(partial_result)
 
             if partial_result.status.state is not HostedRunState.IN_PROGRESS:
                 state = partial_result.status.state
@@ -511,6 +548,46 @@ class FalServerlessHost(Host):
 
         return cast(ReturnT, return_value)
 
+    def run(
+        self,
+        func: Callable[..., ReturnT],
+        options: Options,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+    ) -> ReturnT:
+        def result_handler(partial_result):
+            for log in partial_result.logs:
+                self._log_printer.print(log)
+
+        return self._run(func, options, args, kwargs, result_handler=result_handler)
+
+    def spawn(
+        self,
+        func: Callable[..., ReturnT],
+        options: Options,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+    ) -> SpawnInfo:
+        ret = SpawnInfo()
+
+        def result_handler(partial_result):
+            ret.stream = partial_result.stream
+            for log in partial_result.logs:
+                if "Access your exposed service at" in log.message:
+                    ret.url = log.message.rsplit()[-1]
+                ret.logs.put(log)
+
+        THREAD_POOL.submit(
+            self._run,
+            func,
+            options,
+            args,
+            kwargs,
+            result_handler=result_handler,
+        )
+
+        return ret
+
 
 @dataclass
 class Options:
@@ -566,8 +643,7 @@ def function(
     max_concurrency: int | None = None,
 ) -> Callable[
     [Callable[Concatenate[ArgsT], ReturnT]], IsolatedFunction[ArgsT, ReturnT]
-]:
-    ...
+]: ...
 
 
 @overload
@@ -583,8 +659,7 @@ def function(
     max_concurrency: int | None = None,
 ) -> Callable[
     [Callable[Concatenate[ArgsT], ReturnT]], ServedIsolatedFunction[ArgsT, ReturnT]
-]:
-    ...
+]: ...
 
 
 ### FalServerlessHost
@@ -610,8 +685,7 @@ def function(
     _scheduler: str | None = None,
 ) -> Callable[
     [Callable[Concatenate[ArgsT], ReturnT]], IsolatedFunction[ArgsT, ReturnT]
-]:
-    ...
+]: ...
 
 
 @overload
@@ -636,8 +710,7 @@ def function(
     _scheduler: str | None = None,
 ) -> Callable[
     [Callable[Concatenate[ArgsT], ReturnT]], ServedIsolatedFunction[ArgsT, ReturnT]
-]:
-    ...
+]: ...
 
 
 ## conda
@@ -660,8 +733,7 @@ def function(
     max_concurrency: int | None = None,
 ) -> Callable[
     [Callable[Concatenate[ArgsT], ReturnT]], IsolatedFunction[ArgsT, ReturnT]
-]:
-    ...
+]: ...
 
 
 @overload
@@ -682,8 +754,7 @@ def function(
     max_concurrency: int | None = None,
 ) -> Callable[
     [Callable[Concatenate[ArgsT], ReturnT]], ServedIsolatedFunction[ArgsT, ReturnT]
-]:
-    ...
+]: ...
 
 
 ### FalServerlessHost
@@ -714,8 +785,7 @@ def function(
     _scheduler: str | None = None,
 ) -> Callable[
     [Callable[Concatenate[ArgsT], ReturnT]], IsolatedFunction[ArgsT, ReturnT]
-]:
-    ...
+]: ...
 
 
 @overload
@@ -889,6 +959,9 @@ class BaseServable:
         yield
 
     def _build_app(self) -> FastAPI:
+        import json
+        import traceback
+
         from fastapi import HTTPException, Request
         from fastapi.middleware.cors import CORSMiddleware
         from fastapi.responses import JSONResponse
@@ -929,6 +1002,15 @@ class BaseServable:
                 # If it's not a generic 404, just return the original message.
                 return JSONResponse({"detail": exc.detail}, 404)
 
+        @_app.exception_handler(Exception)
+        async def traceback_logging_exception_handler(request: Request, exc: Exception):
+            print(
+                json.dumps(
+                    {"traceback": "".join(traceback.format_exception(exc)[::-1])}  # type: ignore
+                )
+            )
+            return JSONResponse({"detail": "Internal Server Error"}, 500)
+
         routes = self.collect_routes()
         if not routes:
             raise ValueError("An application must have at least one route!")
@@ -978,7 +1060,8 @@ class BaseServable:
             }
 
             _, pending = await asyncio.wait(
-                tasks.keys(), return_when=asyncio.FIRST_COMPLETED,
+                tasks.keys(),
+                return_when=asyncio.FIRST_COMPLETED,
             )
             if not pending:
                 return
@@ -1052,6 +1135,14 @@ class IsolatedFunction(Generic[ArgsT, ReturnT]):
         )
         return future
 
+    def spawn(self, *args: ArgsT.args, **kwargs: ArgsT.kwargs):
+        return self.host.spawn(
+            self.func,
+            self.options,
+            args,
+            kwargs,
+        )
+
     def __call__(self, *args: ArgsT.args, **kwargs: ArgsT.kwargs) -> ReturnT:
         try:
             return self.host.run(
@@ -1089,14 +1180,12 @@ class IsolatedFunction(Generic[ArgsT, ReturnT]):
     @overload
     def on(
         self, host: Host | None = None, *, serve: Literal[False] = False, **config: Any
-    ) -> IsolatedFunction[ArgsT, ReturnT]:
-        ...
+    ) -> IsolatedFunction[ArgsT, ReturnT]: ...
 
     @overload
     def on(
         self, host: Host | None = None, *, serve: Literal[True], **config: Any
-    ) -> ServedIsolatedFunction[ArgsT, ReturnT]:
-        ...
+    ) -> ServedIsolatedFunction[ArgsT, ReturnT]: ...
 
     def on(self, host: Host | None = None, **config: Any):  # type: ignore
         host = host or self.host
@@ -1150,14 +1239,12 @@ class ServedIsolatedFunction(
     @overload  # type: ignore[override,no-overload-impl]
     def on(  # type: ignore[no-overload-impl]
         self, host: Host | None = None, *, serve: Literal[True] = True, **config: Any
-    ) -> ServedIsolatedFunction[ArgsT, ReturnT]:
-        ...
+    ) -> ServedIsolatedFunction[ArgsT, ReturnT]: ...
 
     @overload
     def on(
         self, host: Host | None = None, *, serve: Literal[False], **config: Any
-    ) -> IsolatedFunction[ArgsT, ReturnT]:
-        ...
+    ) -> IsolatedFunction[ArgsT, ReturnT]: ...
 
 
 class Server(uvicorn.Server):

fal/app.py

@@ -4,10 +4,12 @@ import inspect
 import json
 import os
 import re
+import time
 import typing
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, contextmanager
 from typing import Any, Callable, ClassVar, TypeVar
 
+import httpx
 from fastapi import FastAPI
 
 import fal.api
@@ -69,6 +71,66 @@ def wrap_app(cls: type[App], **kwargs) -> fal.api.IsolatedFunction:
     return fn
 
 
+class EndpointClient:
+    def __init__(self, url, endpoint, signature):
+        self.url = url
+        self.endpoint = endpoint
+        self.signature = signature
+
+        annotations = endpoint.__annotations__ or {}
+        self.return_type = annotations.get("return") or None
+
+    def __call__(self, data):
+        with httpx.Client() as client:
+            resp = client.post(self.url + self.signature.path, json=dict(data))
+            resp.raise_for_status()
+            resp_dict = resp.json()
+
+        if not self.return_type:
+            return resp_dict
+
+        return self.return_type(**resp_dict)
+
+
+class AppClient:
+    def __init__(self, cls, url):
+        self.url = url
+        self.cls = cls
+
+        for name, endpoint in inspect.getmembers(cls, inspect.isfunction):
+            signature = getattr(endpoint, "route_signature", None)
+            if signature is None:
+                continue
+
+            setattr(self, name, EndpointClient(self.url, endpoint, signature))
+
+    @classmethod
+    @contextmanager
+    def connect(cls, app_cls):
+        app = wrap_app(app_cls)
+        info = app.spawn()
+        try:
+            with httpx.Client() as client:
+                retries = 100
+                while retries:
+                    resp = client.get(info.url + "/health")
+                    if resp.is_success:
+                        break
+                    elif resp.status_code != 500:
+                        resp.raise_for_status()
+                    time.sleep(0.1)
+                    retries -= 1
+
+            yield cls(app_cls, info.url)
+        finally:
+            info.stream.cancel()
+
+    def health(self):
+        with httpx.Client() as client:
+            resp = client.get(self.url + "/health")
+            resp.raise_for_status()
+            return resp.json()
+
 
 PART_FINDER_RE = re.compile(r"[A-Z][a-z]*")
 

fal/cli/deploy.py

@@ -1,7 +1,11 @@
+import argparse
+from collections import namedtuple
 from pathlib import Path
 
 from .parser import FalClientParser, RefAction
 
+User = namedtuple("User", ["user_id", "username"])
+
 
 def _remove_http_and_port_from_url(url):
     # Remove http://
@@ -20,17 +24,17 @@ def _remove_http_and_port_from_url(url):
     return url
 
 
-def _get_user_id() -> str:
+def _get_user() -> User:
     import json
     from http import HTTPStatus
 
-    import openapi_fal_rest.api.billing.get_user_details as get_user_details
+    import openapi_fal_rest.api.users.get_current_user as get_current_user
 
     from fal.api import FalServerlessError
     from fal.rest_client import REST_CLIENT
 
     try:
-        user_details_response = get_user_details.sync_detailed(
+        user_details_response = get_current_user.sync_detailed(
             client=REST_CLIENT,
         )
     except Exception as e:
@@ -51,7 +55,7 @@ def _get_user_id() -> str:
         if not user_id:
             user_id = full_user_id
 
-        return user_id
+        return User(user_id=user_id, username=user_details_response.parsed.nickname)
     except Exception as e:
         raise FalServerlessError(f"Could not parse the user data: {e}")
 
@@ -77,7 +81,7 @@ def _deploy(args):
         [file_path] = options
         file_path = str(file_path)
 
-    user_id = _get_user_id()
+    user = _get_user()
     host = FalServerlessHost(args.host)
     isolated_function, app_name = load_function_from(
         host,
@@ -103,12 +107,18 @@ def _deploy(args):
             "Registered a new revision for function "
             f"'{app_name}' (revision='{app_id}')."
         )
-        args.console.print(f"URL: https://{gateway_host}/{user_id}/{app_name}")
+        args.console.print(f"Playground: https://fal.ai/models/{user.username}/{app_name}")
+        args.console.print(f"Endpoint: https://{gateway_host}/{user.username}/{app_name}")
 
 
 def add_parser(main_subparsers, parents):
     from fal.sdk import ALIAS_AUTH_MODES
 
+    def valid_auth_option(option):
+        if option not in ALIAS_AUTH_MODES:
+            raise argparse.ArgumentTypeError(f"{option} is not a auth option")
+        return option
+
     deploy_help = "Deploy a fal application."
     epilog = (
         "Examples:\n"
@@ -139,8 +149,8 @@ def add_parser(main_subparsers, parents):
     )
     parser.add_argument(
         "--auth",
-        choices=ALIAS_AUTH_MODES,
+        type=valid_auth_option,
         default="private",
-        help="Application authentication mode.",
+        help="Application authentication mode (private, public).",
     )
     parser.set_defaults(func=_deploy)

fal/cli/doctor.py

@@ -0,0 +1,37 @@
+import os
+import platform
+
+
+def _doctor(args):
+    import isolate
+    from rich.table import Table
+
+    import fal
+
+    table = Table(show_header=False, show_lines=False, box=None)
+    table.add_column("name", no_wrap=True, style="bold")
+    table.add_column("value", no_wrap=True)
+
+    table.add_row("fal", fal.__version__)
+    table.add_row("isolate", isolate.__version__)
+
+    table.add_row("", "")
+    table.add_row("python", platform.python_version())
+    table.add_row("platform", platform.platform())
+
+    table.add_row("", "")
+    table.add_row("FAL_HOST", fal.flags.GRPC_HOST)
+    table.add_row("FAL_KEY", os.getenv("FAL_KEY", "").split(":")[0])
+
+    args.console.print(table)
+
+
+def add_parser(main_subparsers, parents):
+    doctor_help = "fal version and misc environment information."
+    parser = main_subparsers.add_parser(
+        "doctor",
+        description=doctor_help,
+        help=doctor_help,
+        parents=parents,
+    )
+    parser.set_defaults(func=_doctor)

fal/cli/main.py

@@ -6,7 +6,7 @@ from fal import __version__
 from fal.console import console
 from fal.console.icons import CROSS_ICON
 
-from . import apps, auth, deploy, keys, run, secrets
+from . import apps, auth, deploy, doctor, keys, run, secrets
 from .debug import debugtools, get_debug_parser
 from .parser import FalParser, FalParserExit
 
@@ -31,7 +31,7 @@ def _get_main_parser() -> argparse.ArgumentParser:
         required=True,
     )
 
-    for cmd in [auth, apps, deploy, run, keys, secrets]:
+    for cmd in [auth, apps, deploy, run, keys, secrets, doctor]:
         cmd.add_parser(subparsers, parents)
 
     return parser

fal/sdk.py

@@ -224,6 +224,7 @@ class HostedRunResult(Generic[ResultT]):
     status: HostedRunStatus
     logs: list[Log] = field(default_factory=list)
     result: ResultT | None = None
+    stream: Any = None
 
 
 @dataclass
@@ -569,8 +570,11 @@ class FalServerlessConnection:
             request.setup_func.MergeFrom(
                 to_serialized_object(setup_function, serialization_method)
             )
-        for partial_result in self.stub.Run(request):
-            yield from_grpc(partial_result)
+        stream = self.stub.Run(request)
+        for partial_result in stream:
+            res = from_grpc(partial_result)
+            res.stream = stream
+            yield res
 
     def create_alias(
         self,

fal/toolkit/file/providers/fal.py

@@ -98,6 +98,7 @@ class FalCDNFileRepository(FileRepository):
             **self.auth_headers,
             "Accept": "application/json",
             "Content-Type": file.content_type,
+            "X-Fal-File-Name": file.file_name,
             "X-Fal-Object-Lifecycle-Preference": json.dumps(
                 dataclasses.asdict(GLOBAL_LIFECYCLE_PREFERENCE)
             ),

fal/workflows.py

@@ -10,7 +10,7 @@ from typing import Any, Iterator, Union, cast
 import graphlib
 import rich
 from openapi_fal_rest.api.workflows import (
-    create_or_update_workflow_workflows_post as publish_workflow,
+    create_workflow as publish_workflow,
 )
 from openapi_fal_rest.models.http_validation_error import HTTPValidationError
 from pydantic import BaseModel

{fal-1.0.7.dist-info → fal-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fal
-Version: 1.0.7
+Version: 1.1.0
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8
@@ -43,6 +43,7 @@ Requires-Dist: pytest <8 ; extra == 'test'
 Requires-Dist: pytest-asyncio ; extra == 'test'
 Requires-Dist: pytest-xdist ; extra == 'test'
 Requires-Dist: flaky ; extra == 'test'
+Requires-Dist: boto3 ; extra == 'test'
 
 [![PyPI](https://img.shields.io/pypi/v/fal.svg?logo=PyPI)](https://pypi.org/project/fal)
 [![Tests](https://img.shields.io/github/actions/workflow/status/fal-ai/fal/integration_tests.yaml?label=Tests)](https://github.com/fal-ai/fal/actions)