fal 1.5.16__tar.gz → 1.5.17__tar.gz

{fal-1.5.16/fal.egg-info → fal-1.5.17}/PKG-INFO

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

{fal-1.5.16 → fal-1.5.17/fal.egg-info}/PKG-INFO

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

{fal-1.5.16 → fal-1.5.17}/src/fal/_fal_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.5.16'
-__version_tuple__ = version_tuple = (1, 5, 16)
+__version__ = version = '1.5.17'
+__version_tuple__ = version_tuple = (1, 5, 17)

{fal-1.5.16 → fal-1.5.17}/src/fal/app.py

@@ -23,8 +23,8 @@ from fal._serialization import include_modules_from
 from fal.api import RouteSignature
 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
+from fal.toolkit.file import request_lifecycle_repference
+from fal.toolkit.file.providers.fal import LIFECYCLE_PREFERENCE
 
 REALTIME_APP_REQUIREMENTS = ["websockets", "msgpack"]
 REQUEST_ID_KEY = "x-fal-request-id"
@@ -342,13 +342,11 @@ class App(fal.api.BaseServable):
         @app.middleware("http")
         async def set_global_object_preference(request, call_next):
             try:
-                preference_dict = get_lifecycle_preference(request) or {}
-                expiration_duration = preference_dict.get("expiration_duration_seconds")
-                if expiration_duration is not None:
-                    GLOBAL_LIFECYCLE_PREFERENCE.expiration_duration_seconds = int(
-                        expiration_duration
-                    )
-
+                preference_dict = request_lifecycle_repference(request)
+                if preference_dict is not None:
+                    # This will not work properly for apps with multiplexing enabled
+                    # we may mix up the preferences between requests
+                    LIFECYCLE_PREFERENCE.set(preference_dict)
             except Exception:
                 from fastapi.logger import logger
 
@@ -357,7 +355,12 @@ class App(fal.api.BaseServable):
                     self.__class__.__name__,
                 )
 
-            return await call_next(request)
+            try:
+                return await call_next(request)
+            finally:
+                # We may miss the global preference if there are operations
+                # being done in the background that go beyond the request
+                LIFECYCLE_PREFERENCE.set(None)
 
         @app.middleware("http")
         async def set_request_id(request, call_next):

{fal-1.5.16 → fal-1.5.17}/src/fal/toolkit/file/file.py

@@ -22,6 +22,7 @@ else:
 from pydantic import BaseModel, Field
 
 from fal.toolkit.file.providers.fal import (
+    LIFECYCLE_PREFERENCE,
     FalCDNFileRepository,
     FalFileRepository,
     FalFileRepositoryV2,
@@ -149,7 +150,9 @@ class File(BaseModel):
 
         fdata = FileData(data, content_type, file_name)
 
-        object_lifecycle_preference = get_lifecycle_preference(request)
+        object_lifecycle_preference = (
+            request_lifecycle_repference(request) or LIFECYCLE_PREFERENCE.get()
+        )
 
         try:
             url = repo.save(fdata, object_lifecycle_preference, **save_kwargs)
@@ -203,7 +206,9 @@ class File(BaseModel):
         fallback_save_kwargs = fallback_save_kwargs or {}
 
         content_type = content_type or "application/octet-stream"
-        object_lifecycle_preference = get_lifecycle_preference(request)
+        object_lifecycle_preference = (
+            request_lifecycle_repference(request) or LIFECYCLE_PREFERENCE.get()
+        )
 
         try:
             url, data = repo.save_file(
@@ -288,21 +293,18 @@ class CompressedFile(File):
             shutil.rmtree(self.extract_dir)
 
 
-def get_lifecycle_preference(request: Request) -> dict[str, str] | None:
+def request_lifecycle_repference(request: Optional[Request]) -> dict[str, str] | None:
     import json
 
-    preference_str = (
-        request.headers.get(OBJECT_LIFECYCLE_PREFERENCE_KEY)
-        if request is not None
-        else None
-    )
+    if request is None:
+        return None
+
+    preference_str = request.headers.get(OBJECT_LIFECYCLE_PREFERENCE_KEY)
     if preference_str is None:
         return None
 
-    object_lifecycle_preference = {}
     try:
-        object_lifecycle_preference = json.loads(preference_str)
-        return object_lifecycle_preference
+        return json.loads(preference_str)
     except Exception as e:
         print(f"Failed to parse object lifecycle preference: {e}")
         return None

{fal-1.5.16 → fal-1.5.17}/src/fal/toolkit/file/providers/fal.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import dataclasses
 import json
 import math
 import os
@@ -9,6 +8,7 @@ from base64 import b64encode
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
+from typing import Generic, TypeVar
 from urllib.error import HTTPError
 from urllib.parse import urlparse, urlunparse
 from urllib.request import Request, urlopen
@@ -105,14 +105,21 @@ fal_v2_token_manager = FalV2TokenManager()
 fal_v3_token_manager = FalV3TokenManager()
 
 
-@dataclass
-class ObjectLifecyclePreference:
-    expiration_duration_seconds: int
+VariableType = TypeVar("VariableType")
+
+
+class VariableReference(Generic[VariableType]):
+    def __init__(self, value: VariableType) -> None:
+        self.set(value)
 
+    def get(self) -> VariableType:
+        return self.value
 
-GLOBAL_LIFECYCLE_PREFERENCE = ObjectLifecyclePreference(
-    expiration_duration_seconds=86400
-)
+    def set(self, value: VariableType) -> None:
+        self.value = value
+
+
+LIFECYCLE_PREFERENCE: VariableReference[dict[str, str] | None] = VariableReference(None)
 
 
 @dataclass
@@ -298,7 +305,7 @@ class MultipartUpload:
         return self._file_url
 
 
-class MultipartUploadV3:
+class InternalMultipartUploadV3:
     MULTIPART_THRESHOLD = 100 * 1024 * 1024
     MULTIPART_CHUNK_SIZE = 10 * 1024 * 1024
     MULTIPART_MAX_CONCURRENCY = 10
@@ -314,11 +321,23 @@ class MultipartUploadV3:
         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._access_url: str | None = None
+        self._upload_id: str | None = None
 
         self._parts: list[dict] = []
 
+    @property
+    def access_url(self) -> str:
+        if not self._access_url:
+            raise FileUploadException("Upload not initiated")
+        return self._access_url
+
+    @property
+    def upload_id(self) -> str:
+        if not self._upload_id:
+            raise FileUploadException("Upload not initiated")
+        return self._upload_id
+
     @property
     def auth_headers(self) -> dict[str, str]:
         token = fal_v3_token_manager.get_token()
@@ -342,8 +361,9 @@ class MultipartUploadV3:
             )
             with urlopen(req) as response:
                 result = json.load(response)
-                self.access_url = result["access_url"]
-                self.upload_id = result["uploadId"]
+                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}"
@@ -397,7 +417,7 @@ class MultipartUploadV3:
                 entry = future.result()
                 self._parts.append(entry)
 
-    def complete(self):
+    def complete(self) -> str:
         url = f"{self.access_url}/multipart/{self.upload_id}/complete"
         try:
             req = Request(
@@ -515,6 +535,16 @@ class InMemoryRepository(FileRepository):
 
 @dataclass
 class FalCDNFileRepository(FileRepository):
+    def _object_lifecycle_headers(
+        self,
+        headers: dict[str, str],
+        object_lifecycle_preference: dict[str, str] | None,
+    ):
+        if object_lifecycle_preference:
+            headers["X-Fal-Object-Lifecycle-Preference"] = json.dumps(
+                object_lifecycle_preference
+            )
+
     @retry(max_retries=3, base_delay=1, backoff_type="exponential", jitter=True)
     def save(
         self,
@@ -526,10 +556,10 @@ class FalCDNFileRepository(FileRepository):
             "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)
-            ),
         }
+
+        self._object_lifecycle_headers(headers, object_lifecycle_preference)
+
         url = os.getenv("FAL_CDN_HOST", _FAL_CDN) + "/files/upload"
         request = Request(url, headers=headers, method="POST", data=file.data)
         try:
@@ -565,26 +595,27 @@ class InternalFalFileRepositoryV3(FileRepository):
     That way it can avoid the need to refresh the token for every upload.
     """
 
+    def _object_lifecycle_headers(
+        self,
+        headers: dict[str, str],
+        object_lifecycle_preference: dict[str, str] | None,
+    ):
+        if object_lifecycle_preference:
+            headers["X-Fal-Object-Lifecycle"] = json.dumps(object_lifecycle_preference)
+
     @retry(max_retries=3, base_delay=1, backoff_type="exponential", jitter=True)
     def save(
         self, file: FileData, object_lifecycle_preference: dict[str, str] | None
     ) -> str:
-        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 lifecycle.items()
-            }
-
         headers = {
             **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(lifecycle),
         }
+
+        self._object_lifecycle_headers(headers, object_lifecycle_preference)
+
         url = os.getenv("FAL_CDN_V3_HOST", _FAL_CDN_V3) + "/files/upload"
         request = Request(url, headers=headers, method="POST", data=file.data)
         try:
@@ -613,7 +644,7 @@ class InternalFalFileRepositoryV3(FileRepository):
         content_type: str | None = None,
         max_concurrency: int | None = None,
     ) -> str:
-        multipart = MultipartUploadV3(
+        multipart = InternalMultipartUploadV3(
             file_path,
             chunk_size=chunk_size,
             content_type=content_type,