fal 1.16.0__tar.gz → 1.17.0__tar.gz

{fal-1.16.0/fal.egg-info → fal-1.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fal
-Version: 1.16.0
+Version: 1.17.0
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8

{fal-1.16.0 → fal-1.17.0/fal.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fal
-Version: 1.16.0
+Version: 1.17.0
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8

{fal-1.16.0 → fal-1.17.0}/fal.egg-info/SOURCES.txt

@@ -150,6 +150,7 @@ src/fal/toolkit/image/nsfw_filter/model.py
 src/fal/toolkit/image/nsfw_filter/requirements.txt
 src/fal/toolkit/utils/__init__.py
 src/fal/toolkit/utils/download_utils.py
+src/fal/toolkit/utils/endpoint.py
 src/fal/toolkit/utils/retry.py
 tests/__init__.py
 tests/conftest.py

{fal-1.16.0 → fal-1.17.0}/src/fal/_fal_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.16.0'
-__version_tuple__ = version_tuple = (1, 16, 0)
+__version__ = version = '1.17.0'
+__version_tuple__ = version_tuple = (1, 17, 0)

fal-1.17.0/src/fal/_version.py

@@ -0,0 +1,89 @@
+import json
+import os
+import tempfile
+from typing import Any, Dict, Optional
+
+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]
+
+
+_PYPI_URL = "https://pypi.org/pypi/fal/json"
+_PYPI_CACHE_TTL = 60 * 60  # 1 hour
+_PYPI_CACHE_PATH = os.path.expanduser("~/.fal/cache/pypi.json")
+_URLOPEN_TIMEOUT = 1
+
+
+def _write_pypi_cache(data: Dict[str, Any]) -> None:
+    cache_dir = os.path.dirname(_PYPI_CACHE_PATH)
+    os.makedirs(cache_dir, exist_ok=True)
+    prefix = os.path.basename(_PYPI_CACHE_PATH) + ".tmp."
+    with tempfile.NamedTemporaryFile(
+        mode="w",
+        dir=cache_dir,
+        prefix=prefix,
+        delete=False,
+    ) as fobj:
+        fobj.write(json.dumps(data))
+        os.rename(fobj.name, _PYPI_CACHE_PATH)
+
+
+def _get_pypi_cache() -> Optional[Dict[str, Any]]:
+    import time
+
+    try:
+        mtime = os.path.getmtime(_PYPI_CACHE_PATH)
+    except FileNotFoundError:
+        return None
+
+    if mtime + _PYPI_CACHE_TTL < time.time():
+        return None
+
+    with open(_PYPI_CACHE_PATH) as fobj:
+        try:
+            return json.load(fobj)
+        except ValueError:
+            return None
+
+
+def _fetch_pypi_data() -> Dict[str, Any]:
+    from urllib.request import urlopen
+
+    response = urlopen(_PYPI_URL, timeout=_URLOPEN_TIMEOUT)
+    if response.status != 200:
+        raise Exception(f"Failed to fetch {_PYPI_URL}")
+
+    data = response.read()
+    return json.loads(data)
+
+
+def get_latest_version() -> str:
+    from fal.logging import get_logger
+
+    logger = get_logger(__name__)
+
+    try:
+        data = _get_pypi_cache()
+    except Exception:
+        logger.warning("Failed to get pypi cache", exc_info=True)
+        data = None
+
+    if data is None:
+        try:
+            data = _fetch_pypi_data()
+        except Exception:
+            logger.warning("Failed to get latest fal version", exc_info=True)
+            data = {}
+
+        try:
+            _write_pypi_cache(data)
+        except Exception:
+            logger.warning("Failed to write pypi cache", exc_info=True)
+
+    try:
+        return data["info"]["version"]
+    except KeyError:
+        return "0.0.0"

{fal-1.16.0 → fal-1.17.0}/src/fal/api.py

@@ -501,12 +501,7 @@ class FalServerlessHost(Host):
         if isinstance(func, ServeWrapper):
             # Assigning in a separate property leaving a place for the user
             # to add more metadata in the future
-            try:
-                metadata["openapi"] = func.openapi()
-            except Exception as e:
-                print(
-                    f"[warning] Failed to generate OpenAPI metadata for function: {e}"
-                )
+            metadata["openapi"] = func.openapi()
 
         for partial_result in self._connection.register(
             partial_func,
@@ -1169,7 +1164,12 @@ class BaseServable:
         Build the OpenAPI specification for the served function.
         Attach needed metadata for a better integration to fal.
         """
-        return self._build_app().openapi()
+        try:
+            return self._build_app().openapi()
+        except Exception as e:
+            raise FalServerlessException(
+                "Failed to generate OpenAPI metadata for function"
+            ) from e
 
     def serve(self) -> None:
         import asyncio

{fal-1.16.0 → fal-1.17.0}/src/fal/app.py

@@ -105,15 +105,12 @@ def wrap_app(cls: type[App], **kwargs) -> IsolatedFunction:
         app.serve()
 
     metadata = {}
-    try:
-        app = cls(_allow_init=True)
-        metadata["openapi"] = app.openapi()
-    except Exception:
-        logger.warning("Failed to build OpenAPI specification for %s", cls.__name__)
-        realtime_app = False
-    else:
-        routes = app.collect_routes()
-        realtime_app = any(route.is_websocket for route in routes)
+    app = cls(_allow_init=True)
+
+    metadata["openapi"] = app.openapi()
+
+    routes = app.collect_routes()
+    realtime_app = any(route.is_websocket for route in routes)
 
     kind = cls.host_kwargs.pop("kind", "virtualenv")
     if kind == "container":

{fal-1.16.0 → fal-1.17.0}/src/fal/auth/__init__.py

@@ -63,8 +63,13 @@ def key_credentials() -> tuple[str, str] | None:
 
     key = os.environ.get("FAL_KEY") or config.get("key") or get_colab_token()
     if key:
-        key_id, key_secret = key.split(":", 1)
-        return (key_id, key_secret)
+        try:
+            key_id, key_secret = key.split(":", 1)
+            return (key_id, key_secret)
+        except ValueError:
+            print(f"Invalid key format: {key}")
+            return None
+
     elif "FAL_KEY_ID" in os.environ and "FAL_KEY_SECRET" in os.environ:
         return (os.environ["FAL_KEY_ID"], os.environ["FAL_KEY_SECRET"])
     else:

{fal-1.16.0 → fal-1.17.0}/src/fal/cli/main.py

@@ -77,11 +77,48 @@ def _print_error(msg):
     console.print(f"{CROSS_ICON} {msg}")
 
 
+def _check_latest_version():
+    from packaging.version import parse
+    from rich.emoji import Emoji
+    from rich.panel import Panel
+    from rich.text import Text
+
+    from fal._version import get_latest_version, version_tuple
+
+    latest_version = get_latest_version()
+    parsed = parse(latest_version)
+    latest_version_tuple = (parsed.major, parsed.minor, parsed.micro)
+    if latest_version_tuple <= version_tuple:
+        return
+
+    if not console.is_terminal:
+        return
+
+    line1 = Text.assemble(
+        (Emoji.replace(":warning-emoji:  "), "bold white"),
+        ("A new version of fal is available: ", "bold white"),
+        (latest_version, "bold green"),
+    )
+    line2 = Text.assemble(("pip install --upgrade fal", "bold cyan"))
+    line2.align("center", width=len(line1))
+
+    panel = Panel(
+        line1 + "\n\n" + line2,
+        border_style="yellow",
+        padding=(1, 2),
+        highlight=True,
+        expand=False,
+    )
+    console.print(panel)
+
+
 def main(argv=None) -> int:
     import grpc
 
     from fal.api import UserFunctionException
 
+    _check_latest_version()
+
     ret = 1
     try:
         args = parse_args(argv)

{fal-1.16.0 → fal-1.17.0}/src/fal/cli/profile.py

@@ -66,7 +66,7 @@ def _delete(args):
         if config.profile == args.PROFILE:
             config.set_internal("profile", None)
 
-        config.delete(args.PROFILE)
+        config.delete_profile(args.PROFILE)
         args.console.print(f"Profile [cyan]{args.PROFILE}[/] deleted.")
 
 

{fal-1.16.0 → fal-1.17.0}/src/fal/cli/runners.py

@@ -21,17 +21,21 @@ def runners_table(runners: List[RunnerInfo]):
     table.add_column("Revision")
 
     for runner in runners:
+        external_metadata = runner.external_metadata
+        present = external_metadata.get("present_in_group", True)
+
         num_leases_with_request = len(
             [
                 lease
-                for lease in runner.external_metadata.get("leases", [])
+                for lease in external_metadata.get("leases", [])
                 if lease.get("request_id") is not None
             ]
         )
 
         table.add_row(
             runner.alias,
-            runner.runner_id,
+            # Mark lost runners in red
+            runner.runner_id if present else f"[red]{runner.runner_id}[/]",
             str(runner.in_flight_requests),
             str(runner.in_flight_requests - num_leases_with_request),
             (

{fal-1.16.0 → fal-1.17.0}/src/fal/config.py

@@ -99,7 +99,7 @@ class Config:
     def unset_internal(self, key: str) -> None:
         self._config.get(SETTINGS_SECTION, {}).pop(key, None)
 
-    def delete(self, profile: str) -> None:
+    def delete_profile(self, profile: str) -> None:
         del self._config[profile]
 
     @contextmanager

{fal-1.16.0 → fal-1.17.0}/src/fal/files.py

@@ -28,26 +28,39 @@ class FalFileSystem(AbstractFileSystem):
             },
         )
 
+    def _ls(self, path):
+        response = self._client.get(f"/files/list/{path}")
+        response.raise_for_status()
+        files = response.json()
+        return sorted(
+            (
+                {
+                    "name": entry["path"],
+                    "size": entry["size"],
+                    "type": "file" if entry["is_file"] else "directory",
+                    "mtime": entry["updated_time"],
+                }
+                for entry in files
+            ),
+            key=lambda x: x["name"],
+        )
+
     def ls(self, path, detail=True, **kwargs):
-        if path in self.dircache:
-            entries = self.dircache[path]
+        abs_path = "/" + path.lstrip("/")
+        if abs_path in self.dircache:
+            entries = self.dircache[abs_path]
+        elif abs_path in ["/", "", "."]:
+            entries = [
+                {
+                    "name": "/data",
+                    "size": 0,
+                    "type": "directory",
+                    "mtime": 0,
+                }
+            ]
         else:
-            response = self._client.get(f"/files/list/{path.lstrip('/')}")
-            response.raise_for_status()
-            files = response.json()
-            entries = sorted(
-                (
-                    {
-                        "name": entry["path"].lstrip("/data/"),
-                        "size": entry["size"],
-                        "type": "file" if entry["is_file"] else "directory",
-                        "mtime": entry["updated_time"],
-                    }
-                    for entry in files
-                ),
-                key=lambda x: x["name"],
-            )
-        self.dircache[path] = entries
+            entries = self._ls(abs_path)
+        self.dircache[abs_path] = entries
 
         if detail:
             return entries
@@ -68,7 +81,7 @@ class FalFileSystem(AbstractFileSystem):
             return
 
         with open(lpath, "wb") as fobj:
-            response = self._client.get(f"/files/file/{rpath.lstrip('/')}")
+            response = self._client.get(f"/files/file/{rpath}")
             response.raise_for_status()
             fobj.write(response.content)
 
@@ -78,13 +91,13 @@ class FalFileSystem(AbstractFileSystem):
 
         with open(lpath, "rb") as fobj:
             response = self._client.post(
-                f"/files/file/local/{rpath.lstrip('/')}",
+                f"/files/file/local/{rpath}",
                 files={"file_upload": (posixpath.basename(lpath), fobj, "text/plain")},
             )
             response.raise_for_status()
         self.dircache.clear()
 
     def rm(self, path, **kwargs):
-        response = self._client.delete(f"/files/file/{path.lstrip('/')}")
+        response = self._client.delete(f"/files/file/{path}")
         response.raise_for_status()
         self.dircache.clear()

fal-1.17.0/src/fal/toolkit/utils/endpoint.py

@@ -0,0 +1,29 @@
+from contextlib import asynccontextmanager
+
+from anyio import create_task_group
+from fastapi import Request
+
+
+@asynccontextmanager
+async def cancel_on_disconnect(request: Request):
+    """
+    Async context manager for async code that needs to be cancelled if client
+    disconnects prematurely.
+    The client disconnect is monitored through the Request object.
+    """
+    async with create_task_group() as tg:
+
+        async def watch_disconnect():
+            while True:
+                message = await request.receive()
+
+                if message["type"] == "http.disconnect":
+                    tg.cancel_scope.cancel()
+                    break
+
+        tg.start_soon(watch_disconnect)
+
+        try:
+            yield
+        finally:
+            tg.cancel_scope.cancel()

{fal-1.16.0 → fal-1.17.0}/tests/test_apps.py

@@ -10,7 +10,7 @@ from typing import Generator, List, Tuple
 
 import httpx
 import pytest
-from fastapi import WebSocket
+from fastapi import Request, WebSocket
 from httpx import HTTPStatusError
 from isolate.backends.common import active_python
 from openapi_fal_rest.api.applications import app_metadata
@@ -23,9 +23,15 @@ from fal import apps
 from fal.app import AppClient, AppClientError
 from fal.cli.deploy import User, _get_user
 from fal.container import ContainerImage
-from fal.exceptions import AppException, FieldException, RequestCancelledException
+from fal.exceptions import (
+    AppException,
+    FalServerlessException,
+    FieldException,
+    RequestCancelledException,
+)
 from fal.exceptions._cuda import _CUDA_OOM_MESSAGE, _CUDA_OOM_STATUS_CODE
 from fal.rest_client import REST_CLIENT
+from fal.toolkit.utils.endpoint import cancel_on_disconnect
 from fal.workflows import Workflow
 
 
@@ -228,13 +234,17 @@ class ExceptionApp(fal.App, keep_alive=300, max_concurrency=1):
         raise RuntimeError("cuDNN error: CUDNN_STATUS_INTERNAL_ERROR")
 
 
-class CancellableApp(fal.App, keep_alive=300, max_concurrency=1):
+class CancellableApp(fal.App, keep_alive=300, max_concurrency=1, request_timeout=10):
     task = None
+    running = 0
+
+    async def _sleep(self, input: Input):
+        if self.running > 0:
+            raise Exception("App is already running")
 
-    @fal.endpoint("/")
-    async def sleep(self, input: Input) -> Output:
         self.task = asyncio.create_task(asyncio.sleep(input.wait_time))
         try:
+            self.running += 1
             await self.task
         except asyncio.CancelledError:
             print("Task was cancelled")
@@ -244,9 +254,20 @@ class CancellableApp(fal.App, keep_alive=300, max_concurrency=1):
                     await self.task
 
             raise RequestCancelledException("Request cancelled by the client.")
-
+        finally:
+            self.task = None
+            self.running -= 1
         return Output(result=input.lhs + input.rhs)
 
+    @fal.endpoint("/")
+    async def sleep(self, input: Input) -> Output:
+        return await self._sleep(input)
+
+    @fal.endpoint("/well-handled")
+    async def well_handled(self, input: Input, request: Request) -> Output:
+        async with cancel_on_disconnect(request):
+            return await self._sleep(input)
+
     @fal.endpoint("/cancel")
     async def cancel_handler(self) -> Output:
         if self.task:
@@ -301,6 +322,14 @@ class RealtimeApp(fal.App, keep_alive=300, max_concurrency=1):
         return RTOutputs(texts=[input.prompt] + [i.prompt for i in inputs])
 
 
+class BrokenApp(fal.App, keep_alive=300, max_concurrency=1):
+    machine_type = "S"
+
+    @fal.endpoint("/")
+    def broken(self) -> Exception:
+        raise Exception("this app is designed to fail")
+
+
 @pytest.fixture(scope="module")
 def host() -> Generator[api.FalServerlessHost, None, None]:
     yield addition_app.host
@@ -400,6 +429,13 @@ def test_realtime_app(host: api.FalServerlessHost, user: User):
         yield f"{user.username}/{app_alias}"
 
 
+def test_broken_app_failure(host: api.FalServerlessHost, user: User):
+    with pytest.raises(FalServerlessException) as e:
+        fal.wrap_app(BrokenApp)
+
+    assert "Failed to generate OpenAPI" in str(e)
+
+
 def test_app_client(test_app: str, test_nomad_app: str):
     response = apps.run(test_app, arguments={"lhs": 1, "rhs": 2})
     assert response["result"] == 3
@@ -467,7 +503,7 @@ def test_stateful_app_client(test_stateful_app: str):
 
 def test_app_cancellation(test_app: str, test_cancellable_app: str):
     request_handle = apps.submit(
-        test_cancellable_app, arguments={"lhs": 1, "rhs": 2, "wait_time": 10}
+        test_cancellable_app, arguments={"lhs": 1, "rhs": 2, "wait_time": 5}
     )
 
     while True:
@@ -487,7 +523,7 @@ def test_app_cancellation(test_app: str, test_cancellable_app: str):
 
     # normal app should just ignore the cancellation
     request_handle = apps.submit(
-        test_app, arguments={"lhs": 1, "rhs": 2, "wait_time": 10}
+        test_app, arguments={"lhs": 1, "rhs": 2, "wait_time": 5}
     )
 
     while True:
@@ -504,6 +540,44 @@ def test_app_cancellation(test_app: str, test_cancellable_app: str):
     assert response == {"result": 3}
 
 
+def test_app_disconnect_behavior(test_app: str, test_cancellable_app: str):
+    with pytest.raises(HTTPStatusError) as e:
+        apps.run(
+            test_cancellable_app,
+            arguments={"lhs": 1, "rhs": 2, "wait_time": 20},
+            path="/well-handled",
+        )
+    assert (
+        e.value.response.status_code == 504
+    ), "Expected Gateway Timeout even though the app handled it"
+
+    # and running it again shows the app "handled" it
+    response = apps.run(
+        test_cancellable_app,
+        arguments={"lhs": 1, "rhs": 2, "wait_time": 1},
+        path="/well-handled",
+    )
+    assert response == {"result": 3}
+
+    # vs on an unhandled one
+
+    with pytest.raises(HTTPStatusError) as e:
+        apps.run(
+            test_cancellable_app,
+            arguments={"lhs": 1, "rhs": 2, "wait_time": 20},
+        )
+    assert (
+        e.value.response.status_code == 504
+    ), "Expected Gateway Timeout even though the app handled it"
+
+    with pytest.raises(HTTPStatusError) as e:
+        apps.run(
+            test_cancellable_app,
+            arguments={"lhs": 1, "rhs": 2, "wait_time": 1},
+        )
+    assert e.value.response.status_code == 500
+
+
 @pytest.mark.xfail(
     reason="Temporary disabled while investigating backend issue. Ping @efiop"
 )

fal-1.16.0/src/fal/_version.py

@@ -1,6 +0,0 @@
-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]