fal 0.14.0__py3-none-any.whl → 0.15.2__py3-none-any.whl

fal/flags.py

@@ -18,8 +18,6 @@ GRPC_HOST = os.getenv("FAL_HOST", "api.alpha.fal.ai")
 if not TEST_MODE:
     assert GRPC_HOST.startswith("api"), "FAL_HOST must start with 'api'"
 
-GATEWAY_HOST = GRPC_HOST.replace("api", "gateway", 1)
-
 REST_HOST = GRPC_HOST.replace("api", "rest", 1)
 REST_SCHEME = "http" if TEST_MODE or AUTH_DISABLED else "https"
 REST_URL = f"{REST_SCHEME}://{REST_HOST}"

fal/logging/isolate.py

@@ -34,10 +34,10 @@ class IsolateLogPrinter:
             timestamp = log.timestamp
         else:
             # Default value for timestamp if user has old `isolate` version.
-            # Even if the controller version is controller by us, which means that the timestamp
-            # is being sent in the gRPC message.
-            # The `isolate` version users interpret that message with is out of our control.
-            # So we need to handle this case.
+            # Even if the controller version is controller by us, which means that
+            # the timestamp is being sent in the gRPC message.
+            # The `isolate` version users interpret that message with is out of our
+            # control. So we need to handle this case.
             timestamp = datetime.now(timezone.utc)
 
         event: EventDict = {

fal/sdk.py

@@ -8,30 +8,29 @@ from enum import Enum
 from typing import Any, Callable, Generic, Iterator, Literal, TypeVar
 
 import grpc
+import isolate_proto
 from isolate.connections.common import is_agent
 from isolate.logs import Log
 from isolate.server.interface import from_grpc, to_serialized_object, to_struct
+from isolate_proto.configuration import GRPC_OPTIONS
 
-import isolate_proto
 from fal import flags
-from fal._serialization import patch_dill, patch_pickle
+from fal._serialization import patch_pickle
 from fal.auth import USER, key_credentials
 from fal.logging import get_logger
 from fal.logging.trace import TraceContextInterceptor
-from isolate_proto.configuration import GRPC_OPTIONS
 
 ResultT = TypeVar("ResultT")
 InputT = TypeVar("InputT")
 UNSET = object()
 
-_DEFAULT_SERIALIZATION_METHOD = "dill"
+_DEFAULT_SERIALIZATION_METHOD = "cloudpickle"
 FAL_SERVERLESS_DEFAULT_KEEP_ALIVE = 10
 FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING = 1
 FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY = 0
 
 logger = get_logger(__name__)
 
-patch_dill()
 patch_pickle()
 
 
@@ -188,6 +187,16 @@ class HostedRunStatus:
     state: HostedRunState
 
 
+@dataclass
+class ApplicationInfo:
+    application_id: str
+    keep_alive: int
+    max_concurrency: int
+    max_multiplexing: int
+    active_runners: int
+    min_concurrency: int
+
+
 @dataclass
 class AliasInfo:
     alias: str
@@ -264,6 +273,20 @@ class KeyScope(enum.Enum):
             raise ValueError(f"Unknown KeyScope: {proto}")
 
 
+@from_grpc.register(isolate_proto.ApplicationInfo)
+def _from_grpc_application_info(
+    message: isolate_proto.ApplicationInfo
+) -> ApplicationInfo:
+    return ApplicationInfo(
+        application_id=message.application_id,
+        keep_alive=message.keep_alive,
+        max_concurrency=message.max_concurrency,
+        max_multiplexing=message.max_multiplexing,
+        active_runners=message.active_runners,
+        min_concurrency=message.min_concurrency,
+    )
+
+
 @from_grpc.register(isolate_proto.AliasInfo)
 def _from_grpc_alias_info(message: isolate_proto.AliasInfo) -> AliasInfo:
     if message.auth_mode is isolate_proto.ApplicationAuthMode.PUBLIC:
@@ -497,6 +520,18 @@ class FalServerlessConnection:
         )
         return from_grpc(res.alias_info)
 
+    def list_applications(self) -> list[ApplicationInfo]:
+        request = isolate_proto.ListApplicationsRequest()
+        res: isolate_proto.ListApplicationsResult = self.stub.ListApplications(request)
+        return [from_grpc(app) for app in res.applications]
+
+    def delete_application(
+        self,
+        application_id: str,
+    ) -> None:
+        request = isolate_proto.DeleteApplicationRequest(application_id=application_id)
+        self.stub.DeleteApplication(request)
+
     def run(
         self,
         function: Callable[..., ResultT],

fal/sync.py

@@ -31,7 +31,8 @@ def _upload_file(source_path: str, target_path: str, unzip: bool = False):
         body = upload_file_model.BodyUploadLocalFile(
             rest_types.File(
                 payload=file_to_upload,
-                # We need to set a file_name, otherwise the server errors processing the file
+                # We need to set a file_name, otherwise the server errors
+                # processing the file
                 file_name=os.path.basename(source_path),
             )
         )
@@ -45,7 +46,9 @@ def _upload_file(source_path: str, target_path: str, unzip: bool = False):
 
     if response.status_code != 200:
         raise Exception(
-            f"Failed to upload file. Server returned status code {response.status_code} and message {response.parsed}"
+            "Failed to upload file. "
+            "Server returned status code "
+            f"{response.status_code} and message {response.parsed}"
         )
 
 
@@ -94,7 +97,8 @@ def sync_dir(local_dir: str | Path, remote_dir: str, force_upload=False) -> str:
     local_dir_abs = os.path.expanduser(local_dir)
     if not os.path.isabs(remote_dir) or not remote_dir.startswith("/data"):
         raise ValueError(
-            "'remote_dir' must be an absolute path starting with `/data`, e.g. '/data/sync/my_dir'"
+            "'remote_dir' must be an absolute path starting with `/data`, "
+            "e.g. '/data/sync/my_dir'"
         )
 
     remote_dir = remote_dir.replace("/data/", "", 1)

fal/toolkit/__init__.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from fal.toolkit.file import CompressedFile, File
 from fal.toolkit.image.image import Image, ImageSizeInput, get_image_size
-from fal.toolkit.mainify import mainify
 from fal.toolkit.optimize import optimize
 from fal.toolkit.utils import (
     FAL_MODEL_WEIGHTS_DIR,
@@ -19,7 +18,6 @@ __all__ = [
     "Image",
     "ImageSizeInput",
     "get_image_size",
-    "mainify",
     "optimize",
     "FAL_MODEL_WEIGHTS_DIR",
     "FAL_PERSISTENT_DIR",

fal/toolkit/exceptions.py

@@ -1,14 +1,9 @@
-from fal.toolkit.mainify import mainify
-
-
-@mainify
 class FalTookitException(Exception):
     """Base exception for all toolkit exceptions"""
 
     pass
 
 
-@mainify
 class FileUploadException(FalTookitException):
     """Raised when file upload fails"""
 

fal/toolkit/file/file.py

@@ -1,13 +1,23 @@
 from __future__ import annotations
 
+import shutil
 from pathlib import Path
-from tempfile import NamedTemporaryFile, TemporaryDirectory
-from typing import Any, Callable
+from tempfile import NamedTemporaryFile, mkdtemp
+from typing import Any, Callable, Optional
 from urllib.parse import urlparse
 from zipfile import ZipFile
 
-from pydantic import BaseModel, Field, PrivateAttr
-from pydantic.typing import Optional
+import pydantic
+
+# https://github.com/pydantic/pydantic/pull/2573
+if not hasattr(pydantic, "__version__") or pydantic.__version__.startswith("1."):
+    IS_PYDANTIC_V2 = False
+else:
+    from pydantic import GetCoreSchemaHandler
+    from pydantic_core import CoreSchema, core_schema
+    IS_PYDANTIC_V2 = True
+
+from pydantic import BaseModel, Field
 
 from fal.toolkit.file.providers.fal import (
     FalCDNFileRepository,
@@ -17,7 +27,6 @@ from fal.toolkit.file.providers.fal import (
 from fal.toolkit.file.providers.gcp import GoogleStorageRepository
 from fal.toolkit.file.providers.r2 import R2Repository
 from fal.toolkit.file.types import FileData, FileRepository, RepositoryId
-from fal.toolkit.mainify import mainify
 from fal.toolkit.utils.download_utils import download_file
 
 FileRepositoryFactory = Callable[[], FileRepository]
@@ -42,52 +51,48 @@ get_builtin_repository.__module__ = "__main__"
 DEFAULT_REPOSITORY: FileRepository | RepositoryId = "fal"
 
 
-@mainify
 class File(BaseModel):
     # public properties
-    _file_data: FileData = PrivateAttr()
     url: str = Field(
         description="The URL where the file can be downloaded from.",
     )
     content_type: Optional[str] = Field(
+        None,
         description="The mime type of the file.",
         examples=["image/png"],
     )
     file_name: Optional[str] = Field(
+        None,
         description="The name of the file. It will be auto-generated if not provided.",
         examples=["z9RV14K95DvU.png"],
     )
     file_size: Optional[int] = Field(
-        description="The size of the file in bytes.", examples=[4404019]
+        None, description="The size of the file in bytes.", examples=[4404019]
+    )
+    file_data: Optional[bytes] = Field(
+        None,
+        description="File data",
+        exclude=True,
+        repr=False,
     )
 
-    def __init__(self, **kwargs):
-        if "file_data" in kwargs:
-            data: FileData = kwargs.pop("file_data")
-            repository = kwargs.pop("repository", None)
-
-            repo = (
-                repository
-                if isinstance(repository, FileRepository)
-                else get_builtin_repository(repository)
-            )
-            self._file_data = data
-
-            kwargs.update(
-                {
-                    "url": repo.save(data),
-                    "content_type": data.content_type,
-                    "file_name": data.file_name,
-                    "file_size": len(data.data),
-                }
+    # Pydantic custom validator for input type conversion
+    if IS_PYDANTIC_V2:
+
+        @classmethod
+        def __get_pydantic_core_schema__(
+            cls, source_type: Any, handler: GetCoreSchemaHandler
+        ) -> CoreSchema:
+            return core_schema.no_info_before_validator_function(
+                cls.__convert_from_str,
+                handler(source_type),
             )
 
-        super().__init__(**kwargs)
+    else:
 
-    # Pydantic custom validator for input type conversion
-    @classmethod
-    def __get_validators__(cls):
-        yield cls.__convert_from_str
+        @classmethod
+        def __get_validators__(cls):
+            yield cls.__convert_from_str
 
     @classmethod
     def __convert_from_str(cls, value: Any):
@@ -119,9 +124,20 @@ class File(BaseModel):
         file_name: Optional[str] = None,
         repository: FileRepository | RepositoryId = DEFAULT_REPOSITORY,
     ) -> File:
+        repo = (
+            repository
+            if isinstance(repository, FileRepository)
+            else get_builtin_repository(repository)
+        )
+
+        fdata = FileData(data, content_type, file_name)
+
         return cls(
-            file_data=FileData(data, content_type, file_name),
-            repository=repository,
+            url=repo.save(fdata),
+            content_type=fdata.content_type,
+            file_name=fdata.file_name,
+            file_size=len(data),
+            file_data=data,
         )
 
     @classmethod
@@ -141,10 +157,10 @@ class File(BaseModel):
         )
 
     def as_bytes(self) -> bytes:
-        if getattr(self, "_file_data", None) is None:
+        if self.file_data is None:
             raise ValueError("File has not been downloaded")
 
-        return self._file_data.data
+        return self.file_data
 
     def save(self, path: str | Path, overwrite: bool = False) -> Path:
         file_path = Path(path).resolve()
@@ -158,37 +174,32 @@ class File(BaseModel):
         return file_path
 
 
-@mainify
 class CompressedFile(File):
-    _extract_dir: Optional[TemporaryDirectory] = PrivateAttr(default=None)
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self._extract_dir = None
+    extract_dir: Optional[str] = Field(default=None, exclude=True, repr=False)
 
     def __iter__(self):
-        if not self._extract_dir:
+        if not self.extract_dir:
             self._extract_files()
 
-        files = Path(self._extract_dir.name).iterdir()  # type: ignore
+        files = Path(self.extract_dir).iterdir()  # type: ignore
         return iter(files)
 
     def _extract_files(self):
-        self._extract_dir = TemporaryDirectory()
+        self.extract_dir = mkdtemp()
 
         with NamedTemporaryFile() as temp_file:
             file_path = temp_file.name
             self.save(file_path, overwrite=True)
 
             with ZipFile(file_path) as zip_file:
-                zip_file.extractall(self._extract_dir.name)
+                zip_file.extractall(self.extract_dir)
 
     def glob(self, pattern: str):
-        if not self._extract_dir:
+        if not self.extract_dir:
             self._extract_files()
 
-        return Path(self._extract_dir.name).glob(pattern)  # type: ignore
+        return Path(self.extract_dir).glob(pattern)  # type: ignore
 
     def __del__(self):
-        if self._extract_dir:
-            self._extract_dir.cleanup()
+        if self.extract_dir:
+            shutil.rmtree(self.extract_dir)

fal/toolkit/file/providers/fal.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import dataclasses
 import json
 import os
 from base64 import b64encode
@@ -10,12 +11,18 @@ from urllib.request import Request, urlopen
 from fal.auth import key_credentials
 from fal.toolkit.exceptions import FileUploadException
 from fal.toolkit.file.types import FileData, FileRepository
-from fal.toolkit.mainify import mainify
 
 _FAL_CDN = "https://fal.media"
 
 
-@mainify
+@dataclass
+class ObjectLifecyclePreference:
+    expriation_duration_seconds: int
+
+
+GLOBAL_LIFECYCLE_PREFERENCE = ObjectLifecyclePreference(expriation_duration_seconds=2)
+
+
 @dataclass
 class FalFileRepository(FileRepository):
     def save(self, file: FileData) -> str:
@@ -70,23 +77,29 @@ class FalFileRepository(FileRepository):
             return
 
 
-@mainify
 @dataclass
 class InMemoryRepository(FileRepository):
-    def save(self, file: FileData) -> str:
+    def save(
+        self,
+        file: FileData,
+    ) -> str:
         return f'data:{file.content_type};base64,{b64encode(file.data).decode("utf-8")}'
 
 
-@mainify
 @dataclass
 class FalCDNFileRepository(FileRepository):
-    def save(self, file: FileData) -> str:
+    def save(
+        self,
+        file: FileData,
+    ) -> str:
         headers = {
             **self.auth_headers,
             "Accept": "application/json",
             "Content-Type": file.content_type,
+            "X-Fal-Object-Lifecycle-Preference": json.dumps(
+                dataclasses.asdict(GLOBAL_LIFECYCLE_PREFERENCE)
+            ),
         }
-
         url = os.getenv("FAL_CDN_HOST", _FAL_CDN) + "/files/upload"
         request = Request(url, headers=headers, method="POST", data=file.data)
         try:

fal/toolkit/file/providers/gcp.py

@@ -6,12 +6,10 @@ import os
 from dataclasses import dataclass
 
 from fal.toolkit.file.types import FileData, FileRepository
-from fal.toolkit.mainify import mainify
 
 DEFAULT_URL_TIMEOUT = 60 * 15  # 15 minutes
 
 
-@mainify
 @dataclass
 class GoogleStorageRepository(FileRepository):
     bucket_name: str = "fal_file_storage"

fal/toolkit/file/providers/r2.py

@@ -6,12 +6,10 @@ from dataclasses import dataclass
 from io import BytesIO
 
 from fal.toolkit.file.types import FileData, FileRepository
-from fal.toolkit.mainify import mainify
 
 DEFAULT_URL_TIMEOUT = 60 * 15  # 15 minutes
 
 
-@mainify
 @dataclass
 class R2Repository(FileRepository):
     bucket_name: str = "fal_file_storage"

fal/toolkit/file/types.py

@@ -5,10 +5,7 @@ from mimetypes import guess_extension, guess_type
 from typing import Literal
 from uuid import uuid4
 
-from fal.toolkit.mainify import mainify
 
-
-@mainify
 class FileData:
     data: bytes
     content_type: str
@@ -34,7 +31,6 @@ class FileData:
 RepositoryId = Literal["fal", "in_memory", "gcp_storage", "r2", "cdn"]
 
 
-@mainify
 @dataclass
 class FileRepository:
     def save(self, data: FileData) -> str:

fal/toolkit/image/image.py

@@ -2,13 +2,12 @@ from __future__ import annotations
 
 import io
 from tempfile import NamedTemporaryFile
-from typing import TYPE_CHECKING, Literal, Union, Optional
+from typing import TYPE_CHECKING, Literal, Optional, Union
 
 from pydantic import BaseModel, Field
 
 from fal.toolkit.file.file import DEFAULT_REPOSITORY, File
-from fal.toolkit.file.types import FileData, FileRepository, RepositoryId
-from fal.toolkit.mainify import mainify
+from fal.toolkit.file.types import FileRepository, RepositoryId
 from fal.toolkit.utils.download_utils import _download_file_python
 
 if TYPE_CHECKING:
@@ -25,7 +24,6 @@ ImageSizePreset = Literal[
 ]
 
 
-@mainify
 class ImageSize(BaseModel):
     width: int = Field(
         default=512, description="The width of the generated image.", gt=0, le=14142
@@ -46,7 +44,6 @@ IMAGE_SIZE_PRESETS: dict[ImageSizePreset, ImageSize] = {
 
 ImageSizeInput = Union[ImageSize, ImageSizePreset]
 
-@mainify
 def get_image_size(source: ImageSizeInput) -> ImageSize:
     if isinstance(source, ImageSize):
         return source
@@ -59,18 +56,17 @@ def get_image_size(source: ImageSizeInput) -> ImageSize:
 ImageFormat = Literal["png", "jpeg", "jpg", "webp", "gif"]
 
 
-@mainify
 class Image(File):
     """
     Represents an image file.
     """
 
     width: Optional[int] = Field(
-        description="The width of the image in pixels.",
+        None, description="The width of the image in pixels.",
         examples=[1024],
     )
     height: Optional[int] = Field(
-        description="The height of the image in pixels.", examples=[1024]
+        None, description="The height of the image in pixels.", examples=[1024]
     )
 
     @classmethod
@@ -82,15 +78,15 @@ class Image(File):
         file_name: str | None = None,
         repository: FileRepository | RepositoryId = DEFAULT_REPOSITORY,
     ) -> Image:
-        file_data = FileData(
-            data=data, content_type=f"image/{format}", file_name=file_name
-        )
-        return cls(
-            file_data=file_data,
+        obj = super().from_bytes(
+            data,
+            content_type=f"image/{format}",
+            file_name=file_name,
             repository=repository,
-            width=size.width if size else None,
-            height=size.height if size else None,
         )
+        obj.width=size.width if size else None
+        obj.height=size.height if size else None
+        return obj
 
     @classmethod
     def from_pil(

fal/toolkit/optimize.py

@@ -4,13 +4,10 @@ import os
 import traceback
 from typing import TYPE_CHECKING, Any
 
-from fal.toolkit.mainify import mainify
-
 if TYPE_CHECKING:
     import torch
 
 
-@mainify
 def optimize(
     module: torch.nn.Module, *, optimization_config: dict[str, Any] | None = None
 ) -> torch.nn.Module: