fal 1.44.1__py3-none-any.whl → 1.45.1__py3-none-any.whl

fal/_fal_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.44.1'
-__version_tuple__ = version_tuple = (1, 44, 1)
+__version__ = version = '1.45.1'
+__version_tuple__ = version_tuple = (1, 45, 1)
 
 __commit_id__ = commit_id = None

fal/api.py

@@ -43,6 +43,7 @@ from typing_extensions import Concatenate, ParamSpec
 
 import fal.flags as flags
 from fal._serialization import include_module, include_modules_from, patch_pickle
+from fal.console import console
 from fal.container import ContainerImage
 from fal.exceptions import (
     AppException,
@@ -51,6 +52,7 @@ from fal.exceptions import (
     FieldException,
 )
 from fal.exceptions._cuda import _is_cuda_oom_exception
+from fal.file_sync import FileSync
 from fal.logging.isolate import IsolateLogPrinter
 from fal.sdk import (
     FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
@@ -63,6 +65,7 @@ from fal.sdk import (
     DeploymentStrategyLiteral,
     FalServerlessClient,
     FalServerlessConnection,
+    File,
     HostedRunState,
     MachineRequirements,
     get_agent_credentials,
@@ -438,16 +441,25 @@ class FalServerlessHost(Host):
             "_base_image",
             "_scheduler",
             "_scheduler_options",
+            "app_files",
+            "app_files_ignore",
+            "app_files_context_dir",
         }
     )
 
     url: str = FAL_SERVERLESS_DEFAULT_URL
+    local_file_path: str = ""
     credentials: Credentials = field(default_factory=get_default_credentials)
-    _lock: threading.Lock = field(default_factory=threading.Lock)
 
-    _log_printer = IsolateLogPrinter(debug=flags.DEBUG)
+    _lock: threading.Lock = field(default_factory=threading.Lock, init=False)
+
+    _log_printer: IsolateLogPrinter = field(
+        default_factory=lambda: IsolateLogPrinter(debug=flags.DEBUG), init=False
+    )
 
-    _thread_pool: ThreadPoolExecutor = field(default_factory=ThreadPoolExecutor)
+    _thread_pool: ThreadPoolExecutor = field(
+        default_factory=ThreadPoolExecutor, init=False
+    )
 
     def __getstate__(self) -> dict[str, Any]:
         state = self.__dict__.copy()
@@ -465,6 +477,35 @@ class FalServerlessHost(Host):
             client = FalServerlessClient(self.url, self.credentials)
             return client.connect()
 
+    def _app_files_sync(self, options: Options) -> list[File]:
+        import re  # noqa: PLC0415
+
+        app_files: list[str] = options.host.get("app_files", [])
+        app_files_ignore_str = options.host.get("app_files_ignore", [])
+        app_files_ignore = [re.compile(pattern) for pattern in app_files_ignore_str]
+        app_files_context_dir = options.host.get("app_files_context_dir", None)
+        res = []
+        if app_files:
+            sync = FileSync(self.local_file_path)
+            files, errors = sync.sync_files(
+                app_files,
+                files_ignore=app_files_ignore,
+                files_context_dir=app_files_context_dir,
+            )
+            if errors:
+                for error in errors:
+                    console.print(
+                        f"Error uploading file {error.relative_path}: {error.message}"
+                    )
+
+                raise FalServerlessException("Error uploading files")
+
+            res = [
+                File(relative_path=file.relative_path, hash=file.hash) for file in files
+            ]
+
+        return res
+
     @_handle_grpc_error()
     def register(
         self,
@@ -515,6 +556,8 @@ class FalServerlessHost(Host):
             startup_timeout=startup_timeout,
         )
 
+        app_files = self._app_files_sync(options)
+
         partial_func = _prepare_partial_func(func)
 
         if metadata is None:
@@ -537,6 +580,7 @@ class FalServerlessHost(Host):
             scale=scale,
             # By default, logs are public
             private_logs=options.host.get("private_logs", False),
+            files=app_files,
         ):
             for log in partial_result.logs:
                 self._log_printer.print(log)
@@ -594,6 +638,8 @@ class FalServerlessHost(Host):
             startup_timeout=startup_timeout,
         )
 
+        app_files = self._app_files_sync(options)
+
         return_value = _UNSET
         # Allow isolate provided arguments (such as setup function) to take
         # precedence over the ones provided by the user.
@@ -603,6 +649,7 @@ class FalServerlessHost(Host):
             environments,
             machine_requirements=machine_requirements,
             setup_function=setup_function,
+            files=app_files,
         ):
             result_handler(partial_result)
 

fal/app.py

@@ -35,6 +35,13 @@ from fal.toolkit.file.providers.fal import LIFECYCLE_PREFERENCE
 
 REALTIME_APP_REQUIREMENTS = ["websockets", "msgpack"]
 REQUEST_ID_KEY = "x-fal-request-id"
+DEFAULT_APP_FILES_IGNORE = [
+    r"\.pyc$",
+    r"__pycache__/",
+    r"\.git/",
+    r"\.DS_Store$",
+]
+
 
 EndpointT = TypeVar("EndpointT", bound=Callable[..., Any])
 logger = get_logger(__name__)
@@ -298,6 +305,14 @@ def _print_python_packages() -> None:
     print("[debug] Python packages installed:", ", ".join(packages))
 
 
+def _include_app_files_path():
+    import sys  # noqa: PLC0415
+
+    # Add local files deployment path to sys.path so imports
+    # work correctly in the isolate agent
+    sys.path.append("/app_files")
+
+
 class App(BaseServable):
     requirements: ClassVar[list[str]] = []
     local_python_modules: ClassVar[list[str]] = []
@@ -313,6 +328,9 @@ class App(BaseServable):
     }
     app_name: ClassVar[Optional[str]] = None
     app_auth: ClassVar[Optional[AuthModeLiteral]] = None
+    app_files: ClassVar[list[str]] = []
+    app_files_ignore: ClassVar[list[str]] = DEFAULT_APP_FILES_IGNORE
+    app_files_context_dir: ClassVar[Optional[str]] = None
     request_timeout: ClassVar[Optional[int]] = None
     startup_timeout: ClassVar[Optional[int]] = None
     min_concurrency: ClassVar[Optional[int]] = None
@@ -334,6 +352,15 @@ class App(BaseServable):
         if cls.startup_timeout is not None:
             cls.host_kwargs["startup_timeout"] = cls.startup_timeout
 
+        if cls.app_files:
+            cls.host_kwargs["app_files"] = cls.app_files
+
+        if cls.app_files_ignore:
+            cls.host_kwargs["app_files_ignore"] = cls.app_files_ignore
+
+        if cls.app_files_context_dir is not None:
+            cls.host_kwargs["app_files_context_dir"] = cls.app_files_context_dir
+
         if cls.min_concurrency is not None:
             cls.host_kwargs["min_concurrency"] = cls.min_concurrency
 
@@ -349,7 +376,7 @@ class App(BaseServable):
         if cls.max_multiplexing is not None:
             cls.host_kwargs["max_multiplexing"] = cls.max_multiplexing
 
-        cls.app_name = getattr(cls, "app_name", app_name)
+        cls.app_name = getattr(cls, "app_name") or app_name
 
         if cls.__init__ is not App.__init__:
             raise ValueError(
@@ -382,6 +409,7 @@ class App(BaseServable):
 
     @asynccontextmanager
     async def lifespan(self, app: fastapi.FastAPI):
+        _include_app_files_path()
         _print_python_packages()
         await _call_any_fn(self.setup)
         try:

fal/cli/deploy.py

@@ -92,7 +92,7 @@ def _deploy_from_reference(
         file_path = str(file_path)  # type: ignore
 
     user = _get_user()
-    host = FalServerlessHost(args.host)
+    host = FalServerlessHost(args.host, local_file_path=str(file_path))
     loaded = load_function_from(
         host,
         file_path,  # type: ignore
@@ -180,6 +180,7 @@ def _deploy(args):
         # default comes from the CLI
         app_deployment_strategy = cast(DeploymentStrategyLiteral, args.strategy)
         app_scale_settings = cast(bool, args.app_scale_settings)
+        file_path = str(Path(file_path).absolute())
 
     _deploy_from_reference(
         (file_path, func_name),

fal/cli/run.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 from ._utils import get_app_data_from_toml, is_app_name
 from .parser import FalClientParser, RefAction
 
@@ -6,14 +8,16 @@ def _run(args):
     from fal.api import FalServerlessHost
     from fal.utils import load_function_from
 
-    host = FalServerlessHost(args.host)
-
     if is_app_name(args.func_ref):
         app_name = args.func_ref[0]
         app_ref, *_ = get_app_data_from_toml(app_name)
         file_path, func_name = RefAction.split_ref(app_ref)
     else:
         file_path, func_name = args.func_ref
+        # Turn relative path into absolute path for files
+        file_path = str(Path(file_path).absolute())
+
+    host = FalServerlessHost(args.host, local_file_path=file_path)
 
     loaded = load_function_from(host, file_path, func_name)
 

fal/exceptions/__init__.py

@@ -2,8 +2,10 @@ from __future__ import annotations
 
 from ._base import (
     AppException,  # noqa: F401
+    AppFileUploadException,  # noqa: F401
     FalServerlessException,  # noqa: F401
     FieldException,  # noqa: F401
+    FileTooLargeError,  # noqa: F401
     RequestCancelledException,  # noqa: F401
 )
 from ._cuda import CUDAOutOfMemoryException  # noqa: F401

fal/exceptions/_base.py

@@ -56,3 +56,18 @@ class RequestCancelledException(FalServerlessException):
     """Exception raised when the request is cancelled by the client."""
 
     message: str = "Request cancelled by the client."
+
+
+@dataclass
+class FileTooLargeError(FalServerlessException):
+    """Exception raised when the file is too large."""
+
+    message: str = "File is too large."
+
+
+@dataclass
+class AppFileUploadException(FalServerlessException):
+    """Raised when file upload fails"""
+
+    message: str
+    relative_path: str

fal/file_sync.py

@@ -0,0 +1,361 @@
+import concurrent.futures
+import hashlib
+import os
+import re
+from dataclasses import dataclass
+from functools import cached_property
+from pathlib import Path, PurePosixPath
+from typing import Dict, List, Optional, Tuple
+
+import httpx
+from rich.tree import Tree
+
+from fal._version import version_tuple
+from fal.console import console
+from fal.console.icons import CROSS_ICON
+from fal.exceptions import (
+    AppFileUploadException,
+    FalServerlessException,
+    FileTooLargeError,
+)
+
+USER_AGENT = f"fal-sdk/{'.'.join(map(str, version_tuple))} (python)"
+FILE_SIZE_LIMIT = 1024 * 1024 * 1024  # 1GB
+DEFAULT_CONCURRENCY_UPLOADS = 10
+
+
+def print_path_tree(file_paths):
+    tree = Tree("/app_files")
+
+    nodes = {"": tree}
+
+    for file_path in sorted(file_paths):
+        parts = Path(file_path).parts
+
+        for i, part in enumerate(parts):
+            current_path = str(Path(*parts[: i + 1]))
+
+            if current_path not in nodes:
+                parent_path = str(Path(*parts[:i])) if i > 0 else ""
+                parent_node = nodes[parent_path]
+
+                nodes[current_path] = parent_node.add(f"{part}")
+
+    console.print(tree)
+
+
+def sanitize_relative_path(rel_path: str) -> str:
+    pure_path = PurePosixPath(rel_path)
+
+    # Block files that are absolute or contain parent directory references
+    if pure_path.is_absolute():
+        raise FalServerlessException(f"Absolute Path is not allowed: {rel_path}")
+    if ".." in pure_path.parts or "." in pure_path.parts:
+        raise FalServerlessException(
+            f"Parent directory reference is not allowed: {rel_path}"
+        )
+
+    return pure_path.as_posix()
+
+
+# This is the same function we use in the backend to compute file hashes
+# It is important that this is the same
+def compute_hash(file_path: Path, mode: int) -> str:
+    file_hash = hashlib.sha256()
+    with file_path.open("rb") as f:
+        for chunk in iter(lambda: f.read(4096), b""):
+            file_hash.update(chunk)
+
+    # Include metadata in hash
+    metadata_string = f"{mode}"
+    file_hash.update(metadata_string.encode("utf-8"))
+
+    return file_hash.hexdigest()
+
+
+def normalize_path(
+    path_str: str, base_path_str: str, files_context_dir: Optional[str] = None
+) -> Tuple[str, str]:
+    path = Path(path_str)
+    base_path = Path(base_path_str).resolve()
+
+    if base_path.is_dir():
+        script_dir = base_path
+    else:
+        script_dir = base_path.parent
+
+    if files_context_dir:
+        context_path = Path(files_context_dir)
+        if context_path.is_absolute():
+            script_dir = context_path.resolve()
+        else:
+            script_dir = (script_dir / context_path).resolve()
+
+    absolute_path = (
+        path.resolve() if path.is_absolute() else (script_dir / path).resolve()
+    )
+
+    try:
+        relative_path = os.path.relpath(absolute_path, script_dir)
+        relative_path = sanitize_relative_path(relative_path)
+    except ValueError:
+        raise ValueError(f"Invalid relative path: {absolute_path}")
+
+    return absolute_path.as_posix(), relative_path
+
+
+@dataclass
+class FileMetadata:
+    size: int
+    mtime: float
+    mode: int
+    hash: str
+    relative_path: str
+    absolute_path: str
+
+    @classmethod
+    def from_path(
+        cls, file_path: Path, *, relative: str, absolute: str
+    ) -> "FileMetadata":
+        stat = file_path.stat()
+        # Limit allowed individual file size
+        if stat.st_size > FILE_SIZE_LIMIT:
+            raise FileTooLargeError(
+                message=f"{file_path} is larger than {FILE_SIZE_LIMIT} bytes."
+            )
+
+        file_hash = compute_hash(file_path, stat.st_mode)
+        return FileMetadata(
+            size=stat.st_size,
+            mtime=stat.st_mtime,
+            mode=stat.st_mode,
+            hash=file_hash,
+            relative_path=relative,
+            absolute_path=absolute,
+        )
+
+    def to_dict(self) -> Dict[str, str]:
+        return {
+            "size": str(self.size),
+            "mtime": str(self.mtime),
+            "mode": str(self.mode),
+            "hash": self.hash,
+        }
+
+
+class FileSync:
+    def __init__(self, local_file_path: str):
+        from fal.sdk import get_default_credentials  # noqa: PLC0415
+
+        self.creds = get_default_credentials()
+        self.local_file_path = local_file_path
+
+    @cached_property
+    def _client(self) -> httpx.Client:
+        from fal.flags import REST_URL
+
+        return httpx.Client(
+            base_url=REST_URL,
+            headers={
+                **self.creds.to_headers(),
+                "User-Agent": USER_AGENT,
+            },
+        )
+
+    @cached_property
+    def _tus_client(self):
+        # Import it here to avoid loading unless we use it
+        from tusclient import client  # noqa: PLC0415
+
+        from fal.flags import REST_URL  # noqa: PLC0415
+        from fal.sdk import get_default_credentials  # noqa: PLC0415
+
+        creds = get_default_credentials()
+        return client.TusClient(
+            f"{REST_URL}/files/tus",
+            headers={
+                **creds.to_headers(),
+                "User-Agent": USER_AGENT,
+            },
+        )
+
+    def _request(self, method: str, path: str, **kwargs) -> httpx.Response:
+        response = self._client.request(method, path, **kwargs)
+        if response.status_code == 404:
+            raise FalServerlessException("Not Found")
+        elif response.status_code != 200:
+            try:
+                detail = response.json()["detail"]
+            except Exception:
+                detail = response.text
+            raise FalServerlessException(detail)
+        return response
+
+    def collect_files(self, paths: List[str], files_context_dir: Optional[str] = None):
+        collected_files: List[FileMetadata] = []
+
+        for path in paths:
+            abs_path_str, rel_path = normalize_path(
+                path, self.local_file_path, files_context_dir
+            )
+            abs_path = Path(abs_path_str)
+            if not abs_path.exists():
+                console.print(f"{abs_path} was not found, it will be skipped")
+                continue
+
+            if abs_path.is_file():
+                metadata = FileMetadata.from_path(
+                    abs_path, relative=rel_path, absolute=abs_path_str
+                )
+                collected_files.append(metadata)
+
+            elif abs_path.is_dir():
+                # Recursively walk directory tree
+                for file_path in abs_path.rglob("*"):
+                    if file_path.is_file():
+                        file_abs_str, file_rel_path = normalize_path(
+                            str(file_path), self.local_file_path, files_context_dir
+                        )
+                        metadata = FileMetadata.from_path(
+                            Path(file_abs_str),
+                            relative=file_rel_path,
+                            absolute=file_abs_str,
+                        )
+                        collected_files.append(metadata)
+
+        return collected_files
+
+    def check_hashes_on_server(self, hashes: List[str]) -> List[str]:
+        try:
+            response = self._request(
+                "POST", "/files/missing_hashes", json={"hashes": hashes}
+            )
+            response.raise_for_status()
+            data = response.json()
+            return data
+        except Exception as e:
+            console.print(f"{CROSS_ICON} Failed to check hashes on server: {e}")
+
+            return hashes
+
+    def upload_file_tus(
+        self,
+        file_path: str,
+        metadata: FileMetadata,
+        chunk_size: int = 5 * 1024 * 1024,
+    ) -> str:
+        uploader = self._tus_client.uploader(
+            file_path, chunk_size=chunk_size, metadata=metadata.to_dict()
+        )
+        uploader.upload()
+        if not uploader.url:
+            raise AppFileUploadException("Upload failed, no URL returned", file_path)
+
+        return uploader.url
+
+    def _matches_patterns(self, relative_path: str, patterns: List[re.Pattern]) -> bool:
+        """Check if a file matches any of the patterns."""
+        return any(pattern.search(relative_path) for pattern in patterns)
+
+    def sync_files(
+        self,
+        paths: List[str],
+        chunk_size: int = 5 * 1024 * 1024,
+        max_concurrency_uploads: int = DEFAULT_CONCURRENCY_UPLOADS,
+        files_ignore: List[re.Pattern] = [],
+        files_context_dir: Optional[str] = None,
+    ) -> Tuple[List[FileMetadata], List[AppFileUploadException]]:
+        files = self.collect_files(paths, files_context_dir)
+        existing_hashes: List[FileMetadata] = []
+        uploaded_files: List[Tuple[FileMetadata, str]] = []
+        errors: List[AppFileUploadException] = []
+
+        # Filter out ignored files
+        if files_ignore:
+            filtered_files: List[FileMetadata] = []
+            for metadata in files:
+                if self._matches_patterns(metadata.relative_path, files_ignore):
+                    # TODO: hide behind DEBUG flag?
+                    console.print(f"Ignoring file: {metadata.relative_path}")
+                else:
+                    filtered_files.append(metadata)
+
+            # Update files list
+            files = filtered_files
+
+        # Remove duplicate files by absolute path
+        unique_files: List[FileMetadata] = []
+        seen_paths = set()
+        seen_relative_paths = set()
+        for metadata in files:
+            abs_path = metadata.absolute_path
+            rel_path = metadata.relative_path
+            if abs_path not in seen_paths:
+                seen_paths.add(abs_path)
+                if rel_path in seen_relative_paths:
+                    raise Exception(
+                        f"Duplicate relative path '{rel_path}' found for '{abs_path}'"
+                    )
+                seen_relative_paths.add(rel_path)
+                unique_files.append(metadata)
+            else:
+                if rel_path not in seen_relative_paths:
+                    seen_relative_paths.add(rel_path)
+
+        files_to_check: List[FileMetadata] = []
+        for metadata in unique_files:
+            files_to_check.append(metadata)
+
+        if not files_to_check:
+            return existing_hashes, errors
+
+        hashes_to_check = [metadata.hash for metadata in files_to_check]
+        missing_hashes = self.check_hashes_on_server(hashes_to_check)
+
+        # Categorize based on server response
+        files_to_upload: List[FileMetadata] = []
+        for file in files_to_check:
+            if file.hash not in missing_hashes:
+                existing_hashes.append(file)
+            else:
+                files_to_upload.append(file)
+
+        # Upload missing files in parallel with bounded concurrency
+        if files_to_upload:
+            # Embed it here to be able to pass it to the executor
+            def upload_single_file(metadata: FileMetadata):
+                console.print(f"Uploading file: {metadata.relative_path}")
+                return self.upload_file_tus(
+                    metadata.absolute_path,
+                    chunk_size=chunk_size,
+                    metadata=metadata,
+                )
+
+            with concurrent.futures.ThreadPoolExecutor(
+                max_workers=max_concurrency_uploads
+            ) as executor:
+                futures = [
+                    executor.submit(upload_single_file, metadata)
+                    for metadata in files_to_upload
+                ]
+
+                concurrent.futures.wait(futures)
+                for metadata, future in zip(files_to_upload, futures):
+                    if exc := future.exception():
+                        errors.append(
+                            AppFileUploadException(str(exc), metadata.relative_path)
+                        )
+                    else:
+                        uploaded_files.append((metadata, future.result()))
+
+        all_files = existing_hashes + [file for file, _ in uploaded_files]
+
+        # TODO: hide behind DEBUG flag?
+        console.print("File Structure:")
+        print_path_tree([m.relative_path for m in all_files])
+
+        return all_files, errors
+
+    def close(self):
+        """Close HTTP client."""
+        self._client.close()

fal/sdk.py

@@ -230,6 +230,12 @@ class HostedRunStatus:
     state: HostedRunState
 
 
+@dataclass
+class File:
+    hash: str
+    relative_path: str
+
+
 @dataclass
 class ApplicationInfo:
     application_id: str
@@ -632,6 +638,7 @@ class FalServerlessConnection:
         deployment_strategy: DeploymentStrategyLiteral,
         scale: bool = True,
         private_logs: bool = False,
+        files: list[File] | None = None,
     ) -> Iterator[isolate_proto.RegisterApplicationResult]:
         wrapped_function = to_serialized_object(function, serialization_method)
         if machine_requirements:
@@ -658,6 +665,12 @@ class FalServerlessConnection:
         else:
             wrapped_requirements = None
 
+        if files:
+            files = [
+                isolate_proto.File(hash=file.hash, relative_path=file.relative_path)
+                for file in files
+            ]
+
         if auth_mode == "public":
             auth = isolate_proto.ApplicationAuthMode.PUBLIC
         elif auth_mode == "shared":
@@ -686,6 +699,7 @@ class FalServerlessConnection:
             deployment_strategy=deployment_strategy_proto,
             scale=scale,
             private_logs=private_logs,
+            files=files,
         )
         for partial_result in self.stub.RegisterApplication(request):
             yield from_grpc(partial_result)
@@ -749,6 +763,7 @@ class FalServerlessConnection:
         serialization_method: str = _DEFAULT_SERIALIZATION_METHOD,
         machine_requirements: MachineRequirements | None = None,
         setup_function: Callable[[], InputT] | None = None,
+        files: list[File] | None = None,
     ) -> Iterator[HostedRunResult[ResultT]]:
         wrapped_function = to_serialized_object(function, serialization_method)
         if machine_requirements:
@@ -774,11 +789,16 @@ class FalServerlessConnection:
             )
         else:
             wrapped_requirements = None
-
+        if files:
+            files = [
+                isolate_proto.File(hash=file.hash, relative_path=file.relative_path)
+                for file in files
+            ]
         request = isolate_proto.HostedRun(
             function=wrapped_function,
             environments=environments,
             machine_requirements=wrapped_requirements,
+            files=files,
         )
         if setup_function:
             request.setup_func.MergeFrom(

fal/utils.py

@@ -56,6 +56,7 @@ def load_function_from(
     fal._serialization.include_package_from_path(file_path)
 
     target = module[function_name]
+
     endpoints = ["/"]
     if isinstance(target, type) and issubclass(target, App):
         app_name = target.app_name

{fal-1.44.1.dist-info → fal-1.45.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fal
-Version: 1.44.1
+Version: 1.45.1
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8
@@ -31,6 +31,7 @@ Requires-Dist: python-dateutil<3,>=2.8.0
 Requires-Dist: types-python-dateutil<3,>=2.8.0
 Requires-Dist: dateparser<2,>=1.2.0
 Requires-Dist: types-dateparser<2,>=1.2.0
+Requires-Dist: tuspy==1.1.0
 Requires-Dist: importlib-metadata>=4.4; python_version < "3.10"
 Requires-Dist: msgpack<2,>=1.0.7
 Requires-Dist: websockets>=12.0

{fal-1.44.1.dist-info → fal-1.45.1.dist-info}/RECORD

@@ -1,21 +1,22 @@
 fal/__init__.py,sha256=wXs1G0gSc7ZK60-bHe-B2m0l_sA6TrFk4BxY0tMoLe8,784
 fal/__main__.py,sha256=4JMK66Wj4uLZTKbF-sT3LAxOsr6buig77PmOkJCRRxw,83
-fal/_fal_version.py,sha256=73blOGzFK4FrWGbYE2HJnV8ith86Rc7LVyHw9fSMK94,706
+fal/_fal_version.py,sha256=hS2nkZk1TAFymzpFeuitVosHfjkjk8EjDI7oUpx2yT8,706
 fal/_serialization.py,sha256=npXNsFJ5G7jzBeBIyVMH01Ww34mGY4XWhHpRbSrTtnQ,7598
 fal/_version.py,sha256=1BbTFnucNC_6ldKJ_ZoC722_UkW4S9aDBSW9L0fkKAw,2315
-fal/api.py,sha256=6LkGbbqGUC4tcMBlTL-l7DBkl7t9FpZFSZY1doIdI5o,50284
-fal/app.py,sha256=dZm2PW4zLH7JBeueN-s3vvpWty66M-ujCSgN33ipXQY,26909
+fal/api.py,sha256=tW3B4AbprSnpKDtGb_mjUwUwImd9VaaxUpMtS0f45ks,51860
+fal/app.py,sha256=MsHx1UeUbV-FLqAifS6XkUfa0jYYl00UK51yHuqY9fE,27739
 fal/apps.py,sha256=pzCd2mrKl5J_4oVc40_pggvPtFahXBCdrZXWpnaEJVs,12130
 fal/config.py,sha256=1HRaOJFOAjB7fbQoEPCSH85gMvEEMIMPeupVWgrHVgU,3572
 fal/container.py,sha256=FTsa5hOW4ars-yV1lUoc0BNeIIvAZcpw7Ftyt3A4m_w,2000
+fal/file_sync.py,sha256=Ql8mB5tb-qz8z-IK3QmhD_bxWrx2tay8bLdeykzPIr8,12143
 fal/files.py,sha256=9hA7mC3Xm794I-P2_YMf0QRebrnBIDz_kUnUd4O3BiQ,7904
 fal/flags.py,sha256=QonyDM7R2GqfAB1bJr46oriu-fHJCkpUwXuSdanePWg,987
 fal/project.py,sha256=QgfYfMKmNobMPufrAP_ga1FKcIAlSbw18Iar1-0qepo,2650
 fal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fal/rest_client.py,sha256=kGBGmuyHfX1lR910EoKCYPjsyU8MdXawT_cW2q8Sajc,568
-fal/sdk.py,sha256=13NXGsuoiXM94zzZi9p7PwWSeucYH8Yez6obWa64LBc,28891
+fal/sdk.py,sha256=Nk3dbVyYXQi2XtzBd5Bdex-6TK8iYMS6vPDqJvlhxyk,29431
 fal/sync.py,sha256=ZuIJA2-hTPNANG9B_NNJZUsO68EIdTH0dc9MzeVE2VU,4340
-fal/utils.py,sha256=Xt-05UzuyNMkjrYAM3eLX9fMdm2VzSFNfM6mBtIrh2o,2178
+fal/utils.py,sha256=sYjJLl68AG21BOmmE9H2aW161DMvCh3qIduH-CyZhk4,2179
 fal/workflows.py,sha256=Zl4f6Bs085hY40zmqScxDUyCu7zXkukDbW02iYOLTTI,14805
 fal/auth/__init__.py,sha256=mtyQou8DGHC-COjW9WbtRyyzjyt7fMlhVmsB4U-CBh4,6509
 fal/auth/auth0.py,sha256=g5OgEKe4rsbkLQp6l7EauOAVL6WsmKjuA1wmzmyvvhc,5354
@@ -28,7 +29,7 @@ fal/cli/auth.py,sha256=ZLjxuF4LobETJ2CLGMj_QurE0PiJxzKdFJZkux8uLHM,5977
 fal/cli/cli_nested_json.py,sha256=veSZU8_bYV3Iu1PAoxt-4BMBraNIqgH5nughbs2UKvE,13539
 fal/cli/create.py,sha256=a8WDq-nJLFTeoIXqpb5cr7GR7YR9ZZrQCawNm34KXXE,627
 fal/cli/debug.py,sha256=mTCjSpEZaNKcX225VZtry-BspFKSHURUuxUFuX6x5Cc,1488
-fal/cli/deploy.py,sha256=vX8TpLwoyoLZnK03B005MEBi3wP0M5Pm6AKQ2tHOyjM,8903
+fal/cli/deploy.py,sha256=fxqfYmLgFveSNMF-13rlAqwJ531dP2iIyTAuxBI9YEo,8987
 fal/cli/doctor.py,sha256=8SZrYG9Ku0F6LLUHtFdKopdIgZfFkw5E3Mwrxa9KOSk,1613
 fal/cli/files.py,sha256=-j0q4g53A7CWSczGLdfeUCTSd4zXoV3pfZFdman7JOw,3450
 fal/cli/keys.py,sha256=iQVMr3WT8CUqSQT3qeCCiy6rRwoux9F-UEaC4bCwMWo,3754
@@ -36,15 +37,15 @@ fal/cli/main.py,sha256=LDy3gze9TRsvGa4uSNc8NMFmWMLpsyoC-msteICNiso,3371
 fal/cli/parser.py,sha256=siSY1kxqczZIs3l_jLwug_BpVzY_ZqHpewON3am83Ow,6658
 fal/cli/profile.py,sha256=PAY_ffifCT71VJ8VxfDVaXPT0U1oN8drvWZDFRXwvek,6678
 fal/cli/queue.py,sha256=9Kid3zR6VOFfAdDgnqi2TNN4ocIv5Vs61ASEZnwMa9o,2713
-fal/cli/run.py,sha256=nAC12Qss4Fg1XmV0qOS9RdGNLYcdoHeRgQMvbTN4P9I,1202
+fal/cli/run.py,sha256=xFcNxBWD60PTbW51R4qqLifUL7dqgYYvw38Nz-18ZWc,1365
 fal/cli/runners.py,sha256=OWSsvk01IkwQhibewZQgC-iWMOXl43tWJSi9F81x8n4,17481
 fal/cli/secrets.py,sha256=HfIeO2IZpCEiBC6Cs5Kpi3zckfDnc7GsLwLdgj3NnPU,3085
 fal/cli/teams.py,sha256=_JcNcf659ZoLBFOxKnVP5A6Pyk1jY1vh4_xzMweYIDo,1285
 fal/console/__init__.py,sha256=lGPUuTqIM9IKTa1cyyA-MA2iZJKVHp2YydsITZVlb6g,148
 fal/console/icons.py,sha256=De9MfFaSkO2Lqfne13n3PrYfTXJVIzYZVqYn5BWsdrA,108
 fal/console/ux.py,sha256=KMQs3UHQvVHDxDQQqlot-WskVKoMQXOE3jiVkkfmIMY,356
-fal/exceptions/__init__.py,sha256=m2okJEpax11mnwmoqO_pCGtbt-FvzKiiuMhKo2ok-_8,270
-fal/exceptions/_base.py,sha256=LwzpMaW_eYQEC5s26h2qGXbNA-S4bOqC8s-bMCX6HjE,1491
+fal/exceptions/__init__.py,sha256=4hq-sy3dMZs6YxvbO_p6R-bK4Tzf7ubvA8AyUR0GVPo,349
+fal/exceptions/_base.py,sha256=PLSOHQs7lftDaRYDHKz9xkB6orQvynmUTi4DrdPnYMs,1797
 fal/exceptions/_cuda.py,sha256=L3qvDNaPTthp95IFSBI6pMt3YbRfn1H0inQkj_7NKF8,1719
 fal/exceptions/auth.py,sha256=fHea3SIeguInJVB5M33IuP4I5e_pVEifck1C_XJTYvc,351
 fal/logging/__init__.py,sha256=U7DhMpnNqmVdC2XCT5xZkNmYhpL0Q85iDYPeSo_56LU,1532
@@ -143,8 +144,8 @@ openapi_fal_rest/models/workflow_node_type.py,sha256=-FzyeY2bxcNmizKbJI8joG7byRi
 openapi_fal_rest/models/workflow_schema.py,sha256=4K5gsv9u9pxx2ItkffoyHeNjBBYf6ur5bN4m_zePZNY,2019
 openapi_fal_rest/models/workflow_schema_input.py,sha256=2OkOXWHTNsCXHWS6EGDFzcJKkW5FIap-2gfO233EvZQ,1191
 openapi_fal_rest/models/workflow_schema_output.py,sha256=EblwSPAGfWfYVWw_WSSaBzQVju296is9o28rMBAd0mc,1196
-fal-1.44.1.dist-info/METADATA,sha256=qePSYb_G_ZJHCGhXE9Mf9H0dFkVUmlQkMe3Ey_Y4ziQ,4157
-fal-1.44.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fal-1.44.1.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
-fal-1.44.1.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
-fal-1.44.1.dist-info/RECORD,,
+fal-1.45.1.dist-info/METADATA,sha256=DlOG91iUSQLMXxdumfXsxAb2wV93HO_Or6EWj5RlYk0,4185
+fal-1.45.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fal-1.45.1.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
+fal-1.45.1.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
+fal-1.45.1.dist-info/RECORD,,