fal 1.5.3__tar.gz → 1.5.4__tar.gz

{fal-1.5.3/fal.egg-info → fal-1.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fal
-Version: 1.5.3
+Version: 1.5.4
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8
@@ -23,6 +23,7 @@ Requires-Dist: rich_argparse
 Requires-Dist: packaging>=21.3
 Requires-Dist: pathspec<1,>=0.11.1
 Requires-Dist: pydantic!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.*,!=2.4.*,<3
+Requires-Dist: structlog>=22.0
 Requires-Dist: fastapi<1,>=0.99.1
 Requires-Dist: starlette-exporter>=0.21.0
 Requires-Dist: httpx>=0.15.4

{fal-1.5.3 → fal-1.5.4/fal.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fal
-Version: 1.5.3
+Version: 1.5.4
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8
@@ -23,6 +23,7 @@ Requires-Dist: rich_argparse
 Requires-Dist: packaging>=21.3
 Requires-Dist: pathspec<1,>=0.11.1
 Requires-Dist: pydantic!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.*,!=2.4.*,<3
+Requires-Dist: structlog>=22.0
 Requires-Dist: fastapi<1,>=0.99.1
 Requires-Dist: starlette-exporter>=0.21.0
 Requires-Dist: httpx>=0.15.4

{fal-1.5.3 → fal-1.5.4}/fal.egg-info/requires.txt

@@ -16,6 +16,7 @@ rich_argparse
 packaging>=21.3
 pathspec<1,>=0.11.1
 pydantic!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.*,!=2.4.*,<3
+structlog>=22.0
 fastapi<1,>=0.99.1
 starlette-exporter>=0.21.0
 httpx>=0.15.4

{fal-1.5.3 → fal-1.5.4}/pyproject.toml

@@ -41,6 +41,7 @@ dependencies = [
     "pathspec>=0.11.1,<1",
     "pydantic!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.*,!=2.4.*,<3",
     # serve=True dependencies
+    "structlog>=22.0",
     "fastapi>=0.99.1,<1",
     "starlette-exporter>=0.21.0",
     # rest-api-client dependencies

{fal-1.5.3 → fal-1.5.4}/src/fal/_fal_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.5.3'
-__version_tuple__ = version_tuple = (1, 5, 3)
+__version__ = version = '1.5.4'
+__version_tuple__ = version_tuple = (1, 5, 4)

{fal-1.5.3 → fal-1.5.4}/src/fal/api.py

@@ -76,6 +76,7 @@ SERVE_REQUIREMENTS = [
     f"pydantic=={pydantic_version}",
     "uvicorn",
     "starlette_exporter",
+    "structlog",
 ]
 
 

{fal-1.5.3 → fal-1.5.4}/src/fal/app.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import inspect
 import json
 import os
@@ -8,21 +9,25 @@ import re
 import threading
 import time
 import typing
-from contextlib import asynccontextmanager, contextmanager
+from contextlib import AsyncExitStack, asynccontextmanager, contextmanager
+from dataclasses import dataclass
 from typing import Any, Callable, ClassVar, Literal, TypeVar
 
+import grpc.aio as async_grpc
 import httpx
 from fastapi import FastAPI
+from isolate.server import definitions
 
 import fal.api
 from fal._serialization import include_modules_from
 from fal.api import RouteSignature
-from fal.exceptions import RequestCancelledException
+from fal.exceptions import FalServerlessException, RequestCancelledException
 from fal.logging import get_logger
 from fal.toolkit.file import get_lifecycle_preference
 from fal.toolkit.file.providers.fal import GLOBAL_LIFECYCLE_PREFERENCE
 
 REALTIME_APP_REQUIREMENTS = ["websockets", "msgpack"]
+REQUEST_ID_KEY = "x-fal-request-id"
 
 EndpointT = TypeVar("EndpointT", bound=Callable[..., Any])
 logger = get_logger(__name__)
@@ -35,6 +40,48 @@ async def _call_any_fn(fn, *args, **kwargs):
         return fn(*args, **kwargs)
 
 
+async def open_isolate_channel(address: str) -> async_grpc.Channel:
+    _stack = AsyncExitStack()
+    channel = await _stack.enter_async_context(
+        async_grpc.insecure_channel(
+            address,
+            options=[
+                ("grpc.max_send_message_length", -1),
+                ("grpc.max_receive_message_length", -1),
+                ("grpc.min_reconnect_backoff_ms", 0),
+                ("grpc.max_reconnect_backoff_ms", 100),
+                ("grpc.dns_min_time_between_resolutions_ms", 100),
+            ],
+        )
+    )
+
+    channel_status = channel.channel_ready()
+    try:
+        await asyncio.wait_for(channel_status, timeout=1)
+    except asyncio.TimeoutError:
+        await _stack.aclose()
+        raise Exception("Timed out trying to connect to local isolate")
+
+    return channel
+
+
+async def _set_logger_labels(
+    logger_labels: dict[str, str], channel: async_grpc.Channel
+):
+    try:
+        isolate = definitions.IsolateStub(channel)
+        isolate_request = definitions.SetMetadataRequest(
+            # TODO: when submit is shipped, get task_id from an env var
+            task_id="RUN",
+            metadata=definitions.TaskMetadata(logger_labels=logger_labels),
+        )
+        res = isolate.SetMetadata(isolate_request)
+        code = await res.code()
+        assert str(code) == "StatusCode.OK"
+    except BaseException:
+        logger.exception("Failed to set logger labels")
+
+
 def wrap_app(cls: type[App], **kwargs) -> fal.api.IsolatedFunction:
     include_modules_from(cls)
 
@@ -76,6 +123,12 @@ def wrap_app(cls: type[App], **kwargs) -> fal.api.IsolatedFunction:
     return fn
 
 
+@dataclass
+class AppClientError(FalServerlessException):
+    message: str
+    status_code: int
+
+
 class EndpointClient:
     def __init__(self, url, endpoint, signature, timeout: int | None = None):
         self.url = url
@@ -88,12 +141,19 @@ class EndpointClient:
 
     def __call__(self, data):
         with httpx.Client() as client:
+            url = self.url + self.signature.path
             resp = client.post(
                 self.url + self.signature.path,
                 json=data.dict() if hasattr(data, "dict") else dict(data),
                 timeout=self.timeout,
             )
-            resp.raise_for_status()
+            if not resp.is_success:
+                # allow logs to be printed before raising the exception
+                time.sleep(1)
+                raise AppClientError(
+                    f"Failed to POST {url}: {resp.status_code} {resp.text}",
+                    status_code=resp.status_code,
+                )
             resp_dict = resp.json()
 
         if not self.return_type:
@@ -146,12 +206,16 @@ class AppClient:
             with httpx.Client() as client:
                 retries = 100
                 for _ in range(retries):
-                    resp = client.get(info.url + "/health", timeout=60)
+                    url = info.url + "/health"
+                    resp = client.get(url, timeout=60)
 
                     if resp.is_success:
                         break
                     elif resp.status_code not in (500, 404):
-                        resp.raise_for_status()
+                        raise AppClientError(
+                            f"Failed to GET {url}: {resp.status_code} {resp.text}",
+                            status_code=resp.status_code,
+                        )
                     time.sleep(0.1)
 
             client = cls(app_cls, info.url)
@@ -192,6 +256,8 @@ class App(fal.api.BaseServable):
     app_auth: ClassVar[Literal["private", "public", "shared"]] = "private"
     request_timeout: ClassVar[int | None] = None
 
+    isolate_channel: async_grpc.Channel | None = None
+
     def __init_subclass__(cls, **kwargs):
         app_name = kwargs.pop("name", None) or _to_fal_app_name(cls.__name__)
         parent_settings = getattr(cls, "host_kwargs", {})
@@ -282,8 +348,27 @@ class App(fal.api.BaseServable):
                     "Failed set a global lifecycle preference %s",
                     self.__class__.__name__,
                 )
+
             return await call_next(request)
 
+        @app.middleware("http")
+        async def set_request_id(request, call_next):
+            if self.isolate_channel is None:
+                grpc_port = os.environ.get("NOMAD_ALLOC_PORT_grpc")
+                self.isolate_channel = await open_isolate_channel(
+                    f"localhost:{grpc_port}"
+                )
+
+            request_id = request.headers.get(REQUEST_ID_KEY)
+            if request_id is not None:
+                await _set_logger_labels(
+                    {"fal_request_id": request_id}, channel=self.isolate_channel
+                )
+            try:
+                return await call_next(request)
+            finally:
+                await _set_logger_labels({}, channel=self.isolate_channel)
+
         @app.exception_handler(RequestCancelledException)
         async def value_error_exception_handler(
             request, exc: RequestCancelledException

{fal-1.5.3 → fal-1.5.4}/src/fal/toolkit/file/providers/fal.py

@@ -33,9 +33,17 @@ class FalV2Token:
         return datetime.now(timezone.utc) >= self.expires_at
 
 
+class FalV3Token(FalV2Token):
+    pass
+
+
 class FalV2TokenManager:
+    token_cls: type[FalV2Token] = FalV2Token
+    storage_type: str = "fal-cdn"
+    upload_prefix = "upload."
+
     def __init__(self):
-        self._token: FalV2Token = FalV2Token(
+        self._token: FalV2Token = self.token_cls(
             token="",
             token_type="",
             base_upload_url="",
@@ -63,7 +71,7 @@ class FalV2TokenManager:
 
         grpc_host = os.environ.get("FAL_HOST", "api.alpha.fal.ai")
         rest_host = grpc_host.replace("api", "rest", 1)
-        url = f"https://{rest_host}/storage/auth/token"
+        url = f"https://{rest_host}/storage/auth/token?storage_type={self.storage_type}"
 
         req = Request(
             url,
@@ -76,10 +84,10 @@ class FalV2TokenManager:
 
         parsed_base_url = urlparse(result["base_url"])
         base_upload_url = urlunparse(
-            parsed_base_url._replace(netloc="upload." + parsed_base_url.netloc)
+            parsed_base_url._replace(netloc=self.upload_prefix + parsed_base_url.netloc)
         )
 
-        self._token = FalV2Token(
+        self._token = self.token_cls(
             token=result["token"],
             token_type=result["token_type"],
             base_upload_url=base_upload_url,
@@ -87,7 +95,14 @@ class FalV2TokenManager:
         )
 
 
+class FalV3TokenManager(FalV2TokenManager):
+    token_cls: type[FalV2Token] = FalV3Token
+    storage_type: str = "fal-cdn-v3"
+    upload_prefix = ""
+
+
 fal_v2_token_manager = FalV2TokenManager()
+fal_v3_token_manager = FalV3TokenManager()
 
 
 @dataclass
@@ -275,6 +290,128 @@ class MultipartUpload:
         return self._file_url
 
 
+class MultipartUploadV3:
+    MULTIPART_THRESHOLD = 100 * 1024 * 1024
+    MULTIPART_CHUNK_SIZE = 10 * 1024 * 1024
+    MULTIPART_MAX_CONCURRENCY = 10
+
+    def __init__(
+        self,
+        file_path: str | Path,
+        chunk_size: int | None = None,
+        content_type: str | None = None,
+        max_concurrency: int | None = None,
+    ) -> None:
+        self.file_path = file_path
+        self.chunk_size = chunk_size or self.MULTIPART_CHUNK_SIZE
+        self.content_type = content_type or "application/octet-stream"
+        self.max_concurrency = max_concurrency or self.MULTIPART_MAX_CONCURRENCY
+        self.access_url = None
+        self.upload_id = None
+
+        self._parts: list[dict] = []
+
+    @property
+    def auth_headers(self) -> dict[str, str]:
+        token = fal_v3_token_manager.get_token()
+        return {
+            "Authorization": f"{token.token_type} {token.token}",
+            "User-Agent": "fal/0.1.0",
+        }
+
+    def create(self):
+        token = fal_v3_token_manager.get_token()
+        try:
+            req = Request(
+                f"{token.base_upload_url}/files/upload/multipart",
+                method="POST",
+                headers={
+                    **self.auth_headers,
+                    "Accept": "application/json",
+                    "Content-Type": self.content_type,
+                    "X-Fal-File-Name": os.path.basename(self.file_path),
+                },
+            )
+            with urlopen(req) as response:
+                result = json.load(response)
+                self.access_url = result["access_url"]
+                self.upload_id = result["uploadId"]
+        except HTTPError as exc:
+            raise FileUploadException(
+                f"Error initiating upload. Status {exc.status}: {exc.reason}"
+            )
+
+    @retry(max_retries=5, base_delay=1, backoff_type="exponential", jitter=True)
+    def _upload_part(self, url: str, part_number: int) -> dict:
+        with open(self.file_path, "rb") as f:
+            start = (part_number - 1) * self.chunk_size
+            f.seek(start)
+            data = f.read(self.chunk_size)
+            req = Request(
+                url,
+                method="PUT",
+                headers={
+                    **self.auth_headers,
+                    "Content-Type": self.content_type,
+                },
+                data=data,
+            )
+
+            try:
+                with urlopen(req) as resp:
+                    return {
+                        "partNumber": part_number,
+                        "etag": resp.headers["ETag"],
+                    }
+            except HTTPError as exc:
+                raise FileUploadException(
+                    f"Error uploading part {part_number} to {url}. "
+                    f"Status {exc.status}: {exc.reason}"
+                )
+
+    def upload(self) -> None:
+        import concurrent.futures
+
+        parts = math.ceil(os.path.getsize(self.file_path) / self.chunk_size)
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=self.max_concurrency
+        ) as executor:
+            futures = []
+            for part_number in range(1, parts + 1):
+                upload_url = (
+                    f"{self.access_url}/multipart/{self.upload_id}/{part_number}"
+                )
+                futures.append(
+                    executor.submit(self._upload_part, upload_url, part_number)
+                )
+
+            for future in concurrent.futures.as_completed(futures):
+                entry = future.result()
+                self._parts.append(entry)
+
+    def complete(self):
+        url = f"{self.access_url}/multipart/{self.upload_id}/complete"
+        try:
+            req = Request(
+                url,
+                method="POST",
+                headers={
+                    **self.auth_headers,
+                    "Accept": "application/json",
+                    "Content-Type": "application/json",
+                },
+                data=json.dumps({"parts": self._parts}).encode(),
+            )
+            with urlopen(req):
+                pass
+        except HTTPError as e:
+            raise FileUploadException(
+                f"Error completing upload {url}. Status {e.status}: {e.reason}"
+            )
+
+        return self.access_url
+
+
 @dataclass
 class FalFileRepositoryV2(FalFileRepositoryBase):
     @retry(max_retries=3, base_delay=1, backoff_type="exponential", jitter=True)
@@ -415,16 +552,15 @@ class FalCDNFileRepository(FileRepository):
 class FalFileRepositoryV3(FileRepository):
     @retry(max_retries=3, base_delay=1, backoff_type="exponential", jitter=True)
     def save(
-        self, file: FileData, user_lifecycle_preference: dict[str, str] | None
+        self, file: FileData, object_lifecycle_preference: dict[str, str] | None
     ) -> str:
-        object_lifecycle_preference = dataclasses.asdict(GLOBAL_LIFECYCLE_PREFERENCE)
-
-        if user_lifecycle_preference is not None:
-            object_lifecycle_preference = {
-                key: user_lifecycle_preference[key]
-                if key in user_lifecycle_preference
+        lifecycle = dataclasses.asdict(GLOBAL_LIFECYCLE_PREFERENCE)
+        if object_lifecycle_preference is not None:
+            lifecycle = {
+                key: object_lifecycle_preference[key]
+                if key in object_lifecycle_preference
                 else value
-                for key, value in object_lifecycle_preference.items()
+                for key, value in lifecycle.items()
             }
 
         headers = {
@@ -432,9 +568,7 @@ class FalFileRepositoryV3(FileRepository):
             "Accept": "application/json",
             "Content-Type": file.content_type,
             "X-Fal-File-Name": file.file_name,
-            "X-Fal-Object-Lifecycle-Preference": json.dumps(
-                object_lifecycle_preference
-            ),
+            "X-Fal-Object-Lifecycle-Preference": json.dumps(lifecycle),
         }
         url = os.getenv("FAL_CDN_V3_HOST", _FAL_CDN_V3) + "/files/upload"
         request = Request(url, headers=headers, method="POST", data=file.data)
@@ -451,8 +585,58 @@ class FalFileRepositoryV3(FileRepository):
 
     @property
     def auth_headers(self) -> dict[str, str]:
-        token = fal_v2_token_manager.get_token()
+        token = fal_v3_token_manager.get_token()
         return {
             "Authorization": f"{token.token_type} {token.token}",
             "User-Agent": "fal/0.1.0",
         }
+
+    def _save_multipart(
+        self,
+        file_path: str | Path,
+        chunk_size: int | None = None,
+        content_type: str | None = None,
+        max_concurrency: int | None = None,
+    ) -> str:
+        multipart = MultipartUploadV3(
+            file_path,
+            chunk_size=chunk_size,
+            content_type=content_type,
+            max_concurrency=max_concurrency,
+        )
+        multipart.create()
+        multipart.upload()
+        return multipart.complete()
+
+    def save_file(
+        self,
+        file_path: str | Path,
+        content_type: str,
+        multipart: bool | None = None,
+        multipart_threshold: int | None = None,
+        multipart_chunk_size: int | None = None,
+        multipart_max_concurrency: int | None = None,
+        object_lifecycle_preference: dict[str, str] | None = None,
+    ) -> tuple[str, FileData | None]:
+        if multipart is None:
+            threshold = multipart_threshold or MultipartUpload.MULTIPART_THRESHOLD
+            multipart = os.path.getsize(file_path) > threshold
+
+        if multipart:
+            url = self._save_multipart(
+                file_path,
+                chunk_size=multipart_chunk_size,
+                content_type=content_type,
+                max_concurrency=multipart_max_concurrency,
+            )
+            data = None
+        else:
+            with open(file_path, "rb") as f:
+                data = FileData(
+                    f.read(),
+                    content_type=content_type,
+                    file_name=os.path.basename(file_path),
+                )
+            url = self.save(data, object_lifecycle_preference)
+
+        return url, data

{fal-1.5.3 → fal-1.5.4}/src/fal/toolkit/file/providers/gcp.py

@@ -6,6 +6,7 @@ import os
 import posixpath
 import uuid
 from dataclasses import dataclass
+from typing import Optional
 
 from fal.toolkit.file.types import FileData, FileRepository
 from fal.toolkit.utils.retry import retry
@@ -52,7 +53,11 @@ class GoogleStorageRepository(FileRepository):
         return self._bucket
 
     @retry(max_retries=3, base_delay=1, backoff_type="exponential", jitter=True)
-    def save(self, data: FileData) -> str:
+    def save(
+        self,
+        data: FileData,
+        object_lifecycle_preference: Optional[dict[str, str]] = None,
+    ) -> str:
         destination_path = posixpath.join(
             self.folder,
             f"{uuid.uuid4().hex}_{data.file_name}",

{fal-1.5.3 → fal-1.5.4}/src/fal/toolkit/file/providers/r2.py

@@ -6,6 +6,7 @@ import posixpath
 import uuid
 from dataclasses import dataclass
 from io import BytesIO
+from typing import Optional
 
 from fal.toolkit.file.types import FileData, FileRepository
 from fal.toolkit.utils.retry import retry
@@ -69,7 +70,11 @@ class R2Repository(FileRepository):
         return self._bucket
 
     @retry(max_retries=3, base_delay=1, backoff_type="exponential", jitter=True)
-    def save(self, data: FileData) -> str:
+    def save(
+        self,
+        data: FileData,
+        object_lifecycle_preference: Optional[dict[str, str]] = None,
+    ) -> str:
         destination_path = posixpath.join(
             self.key,
             f"{uuid.uuid4().hex}_{data.file_name}",

{fal-1.5.3 → fal-1.5.4}/tests/test_apps.py

@@ -12,7 +12,7 @@ import fal.api as api
 import httpx
 import pytest
 from fal import apps
-from fal.app import AppClient
+from fal.app import AppClient, AppClientError
 from fal.cli.deploy import _get_user
 from fal.container import ContainerImage
 from fal.exceptions import AppException, FieldException, RequestCancelledException
@@ -692,7 +692,7 @@ def test_workflows(test_app: str):
 def test_traceback_logs(test_exception_app: AppClient):
     date = datetime.utcnow().isoformat()
 
-    with pytest.raises(HTTPStatusError):
+    with pytest.raises(AppClientError):
         test_exception_app.fail({})
 
     with httpx.Client(
@@ -714,18 +714,18 @@ def test_traceback_logs(test_exception_app: AppClient):
 
 
 def test_app_exceptions(test_exception_app: AppClient):
-    with pytest.raises(HTTPStatusError) as app_exc:
+    with pytest.raises(AppClientError) as app_exc:
         test_exception_app.app_exception({})
 
-    assert app_exc.value.response.status_code == 401
+    assert app_exc.value.status_code == 401
 
-    with pytest.raises(HTTPStatusError) as field_exc:
+    with pytest.raises(AppClientError) as field_exc:
         test_exception_app.field_exception({"lhs": 1, "rhs": "2"})
 
-    assert field_exc.value.response.status_code == 422
+    assert field_exc.value.status_code == 422
 
-    with pytest.raises(HTTPStatusError) as cuda_exc:
+    with pytest.raises(AppClientError) as cuda_exc:
         test_exception_app.cuda_exception({})
 
-    assert cuda_exc.value.response.status_code == _CUDA_OOM_STATUS_CODE
-    assert cuda_exc.value.response.json()["detail"] == _CUDA_OOM_MESSAGE
+    assert cuda_exc.value.status_code == _CUDA_OOM_STATUS_CODE
+    assert _CUDA_OOM_MESSAGE in cuda_exc.value.message