fal 1.25.0__py3-none-any.whl → 1.26.1__py3-none-any.whl

fal/_fal_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.25.0'
-__version_tuple__ = version_tuple = (1, 25, 0)
+__version__ = version = '1.26.1'
+__version_tuple__ = version_tuple = (1, 26, 1)

fal/api.py

@@ -319,24 +319,26 @@ def _handle_grpc_error():
             try:
                 return fn(*args, **kwargs)
             except grpc.RpcError as e:
+                msg = e.details() or str(e)
                 if e.code() == grpc.StatusCode.UNAVAILABLE:
                     raise FalServerlessError(
                         "Could not reach fal host. "
                         "This is most likely a transient problem. "
-                        "Please, try again."
+                        "If it persists, please reach out to support@fal.ai with the following details: "  # noqa: E501
+                        f"{msg}"
                     )
-                elif e.details().endswith("died with <Signals.SIGKILL: 9>.`."):
+                elif msg.endswith("died with <Signals.SIGKILL: 9>.`."):
                     raise FalServerlessError(
                         "Isolated function crashed. "
                         "This is likely due to resource overflow. "
                         "You can try again by setting a bigger `machine_type`"
                     )
                 elif e.code() == grpc.StatusCode.INVALID_ARGUMENT and (
-                    "The function function could not be deserialized" in e.details()
+                    "The function function could not be deserialized" in msg
                 ):
-                    raise FalMissingDependencyError(e.details()) from None
+                    raise FalMissingDependencyError(msg) from None
                 else:
-                    raise FalServerlessError(e.details())
+                    raise FalServerlessError(msg)
 
         return handler
 
@@ -498,7 +500,7 @@ class FalServerlessHost(Host):
             partial_func,
             environments,
             application_name=application_name,
-            application_auth_mode=application_auth_mode,
+            auth_mode=application_auth_mode,
             machine_requirements=machine_requirements,
             metadata=metadata,
             deployment_strategy=deployment_strategy,

fal/app.py

@@ -197,7 +197,14 @@ class AppClient:
 
     @classmethod
     @contextmanager
-    def connect(cls, app_cls):
+    def connect(
+        cls,
+        app_cls,
+        *,
+        health_request_timeout: int = 30,
+        startup_timeout: int = 60,
+        health_check_interval: float = 0.5,
+    ):
         app = wrap_app(app_cls)
         info = app.spawn()
         _shutdown_event = threading.Event()
@@ -214,20 +221,50 @@ class AppClient:
         _log_printer.start()
 
         try:
+            if info.url is None:
+                raise AppClientError(
+                    "App spawn failed: no URL returned",
+                    status_code=500,
+                )
+
+            start_time = time.perf_counter()
+            url = info.url + "/health"
+            last_error = None
+            attempt = 0
+
             with httpx.Client() as client:
-                retries = 100
-                for _ in range(retries):
-                    url = info.url + "/health"
-                    resp = client.get(url, timeout=60)
-
-                    if resp.is_success:
-                        break
-                    elif resp.status_code not in (500, 404):
-                        raise AppClientError(
-                            f"Failed to GET {url}: {resp.status_code} {resp.text}",
-                            status_code=resp.status_code,
+                while time.perf_counter() - start_time < startup_timeout:
+                    attempt += 1
+
+                    try:
+                        resp = client.get(url, timeout=health_request_timeout)
+                    except httpx.TimeoutException:
+                        last_error = (
+                            f"Request timed out after {health_request_timeout} seconds"
                         )
-                    time.sleep(0.1)
+                    except httpx.TransportError as e:
+                        last_error = f"Network error: {e}"
+                    else:
+                        if resp.is_success:
+                            break
+
+                        if resp.status_code in (500, 404):
+                            last_error = f"Server not ready (HTTP {resp.status_code})"
+                        else:
+                            raise AppClientError(
+                                "Health check failed with non-retryable error: "
+                                f"{resp.status_code} {resp.text}",
+                                status_code=resp.status_code,
+                            )
+
+                    time.sleep(health_check_interval)
+                else:
+                    # retry loop completed without success
+                    raise AppClientError(
+                        f"Health check failed after {startup_timeout}s "
+                        f"({attempt} attempts). Last error: {last_error}",
+                        status_code=500,
+                    )
 
             client = cls(app_cls, info.url)
             yield client

fal/cli/apps.py

@@ -270,7 +270,7 @@ def _add_set_rev_parser(subparsers, parents):
     parser.add_argument(
         "--auth",
         choices=ALIAS_AUTH_MODES,
-        default="private",
+        default=None,
         help="Application authentication mode.",
     )
     parser.set_defaults(func=_set_rev)
@@ -310,7 +310,11 @@ def _add_runners_parser(subparsers, parents):
 def _delete(args):
     client = get_client(args.host, args.team)
     with client.connect() as connection:
-        connection.delete_alias(args.app_name)
+        res = connection.delete_alias(args.app_name)
+        if res is None:
+            args.console.print(f"Application {args.app_name!r} not found.")
+        else:
+            args.console.print(f"Application {args.app_name!r} deleted ({res})")
 
 
 def _add_delete_parser(subparsers, parents):

fal/files.py

@@ -1,5 +1,8 @@
+import concurrent.futures
+import math
 import os
 import posixpath
+from concurrent.futures import ThreadPoolExecutor
 from functools import cached_property
 from typing import TYPE_CHECKING
 
@@ -9,6 +12,19 @@ if TYPE_CHECKING:
     import httpx
 
 USER_AGENT = "fal-sdk/1.14.0 (python)"
+MULTIPART_THRESHOLD = 10 * 1024 * 1024  # 10MB
+MULTIPART_CHUNK_SIZE = 10 * 1024 * 1024  # 10MB
+MULTIPART_WORKERS = 2  # only 2 because our REST is currently struggling with more
+
+
+def _compute_md5(lpath, chunk_size=8192):
+    import hashlib
+
+    hasher = hashlib.md5()
+    with open(lpath, "rb") as fobj:
+        for chunk in iter(lambda: fobj.read(chunk_size), b""):
+            hasher.update(chunk)
+    return hasher.hexdigest()
 
 
 class FalFileSystem(AbstractFileSystem):
@@ -95,16 +111,90 @@ class FalFileSystem(AbstractFileSystem):
             response = self._request("GET", f"/files/file/{rpath}")
             fobj.write(response.content)
 
+    def _put_file_part(self, rpath, lpath, upload_id, part_number, chunk_size):
+        offset = (part_number - 1) * chunk_size
+        with open(lpath, "rb") as fobj:
+            fobj.seek(offset)
+            chunk = fobj.read(chunk_size)
+            response = self._request(
+                "PUT",
+                f"/files/file/multipart/{rpath}/{upload_id}/{part_number}",
+                files={"file_upload": (posixpath.basename(lpath), chunk)},
+            )
+            data = response.json()
+            return {
+                "part_number": data["part_number"],
+                "etag": data["etag"],
+            }
+
+    def _put_file_multipart(self, lpath, rpath, size, progress):
+        response = self._request(
+            "POST",
+            f"/files/file/multipart/{rpath}/initiate",
+        )
+        upload_id = response.json()["upload_id"]
+
+        parts = []
+        num_parts = math.ceil(size / MULTIPART_CHUNK_SIZE)
+        md5 = _compute_md5(lpath)
+
+        task = progress.add_task(f"{os.path.basename(lpath)}", total=num_parts)
+
+        with ThreadPoolExecutor(max_workers=MULTIPART_WORKERS) as executor:
+            futures = []
+
+            for part_number in range(1, num_parts + 1):
+                futures.append(
+                    executor.submit(
+                        self._put_file_part,
+                        rpath,
+                        lpath,
+                        upload_id,
+                        part_number,
+                        MULTIPART_CHUNK_SIZE,
+                    )
+                )
+
+            for future in concurrent.futures.as_completed(futures):
+                parts.append(future.result())
+                progress.advance(task)
+
+        response = self._request(
+            "POST",
+            f"/files/file/multipart/{rpath}/{upload_id}/complete",
+            json={"parts": parts},
+        )
+        data = response.json()
+        if data["etag"] != md5:
+            raise RuntimeError(
+                f"MD5 mismatch on {rpath}: {data['etag']} != {md5}, "
+                "please contact support"
+            )
+
     def put_file(self, lpath, rpath, mode="overwrite", **kwargs):
+        from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
+
         if os.path.isdir(lpath):
             return
 
-        with open(lpath, "rb") as fobj:
-            self._request(
-                "POST",
-                f"/files/file/local/{rpath}",
-                files={"file_upload": (posixpath.basename(lpath), fobj, "text/plain")},
-            )
+        size = os.path.getsize(lpath)
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+        ) as progress:
+            if size > MULTIPART_THRESHOLD:
+                self._put_file_multipart(lpath, rpath, size, progress)
+            else:
+                task = progress.add_task(f"{os.path.basename(lpath)}", total=1)
+                with open(lpath, "rb") as fobj:
+                    self._request(
+                        "POST",
+                        f"/files/file/local/{rpath}",
+                        files={"file_upload": (posixpath.basename(lpath), fobj)},
+                    )
+                progress.advance(task)
         self.dircache.clear()
 
     def put_file_from_url(self, url, rpath, mode="overwrite", **kwargs):

fal/sdk.py

@@ -45,6 +45,9 @@ logger = get_logger(__name__)
 patch_pickle()
 
 
+AuthMode = Optional[Literal["public", "private", "shared"]]
+
+
 class ServerCredentials:
     def to_grpc(self) -> grpc.ChannelCredentials:
         raise NotImplementedError
@@ -565,7 +568,7 @@ class FalServerlessConnection:
         function: Callable[..., ResultT],
         environments: list[isolate_proto.EnvironmentDefinition],
         application_name: str | None = None,
-        application_auth_mode: Literal["public", "private", "shared"] | None = None,
+        auth_mode: AuthMode = None,
         *,
         serialization_method: str = _DEFAULT_SERIALIZATION_METHOD,
         machine_requirements: MachineRequirements | None = None,
@@ -598,13 +601,14 @@ class FalServerlessConnection:
         else:
             wrapped_requirements = None
 
-        auth_mode = None
-        if application_auth_mode == "public":
-            auth_mode = isolate_proto.ApplicationAuthMode.PUBLIC
-        elif application_auth_mode == "shared":
-            auth_mode = isolate_proto.ApplicationAuthMode.SHARED
-        elif application_auth_mode == "private":
-            auth_mode = isolate_proto.ApplicationAuthMode.PRIVATE
+        if auth_mode == "public":
+            auth = isolate_proto.ApplicationAuthMode.PUBLIC
+        elif auth_mode == "shared":
+            auth = isolate_proto.ApplicationAuthMode.SHARED
+        elif auth_mode == "private":
+            auth = isolate_proto.ApplicationAuthMode.PRIVATE
+        else:
+            auth = None
 
         struct_metadata = None
         if metadata:
@@ -620,7 +624,7 @@ class FalServerlessConnection:
             environments=environments,
             machine_requirements=wrapped_requirements,
             application_name=application_name,
-            auth_mode=auth_mode,
+            auth_mode=auth,
             metadata=struct_metadata,
             deployment_strategy=deployment_strategy_proto,
             scale=scale,
@@ -730,14 +734,16 @@ class FalServerlessConnection:
         self,
         alias: str,
         revision: str,
-        auth_mode: Literal["public", "private", "shared"],
+        auth_mode: AuthMode,
     ):
         if auth_mode == "public":
             auth = isolate_proto.ApplicationAuthMode.PUBLIC
         elif auth_mode == "shared":
             auth = isolate_proto.ApplicationAuthMode.SHARED
-        else:
+        elif auth_mode == "private":
             auth = isolate_proto.ApplicationAuthMode.PRIVATE
+        else:
+            auth = None
 
         request = isolate_proto.SetAliasRequest(
             alias=alias,
@@ -746,10 +752,15 @@ class FalServerlessConnection:
         )
         self.stub.SetAlias(request)
 
-    def delete_alias(self, alias: str) -> str:
+    def delete_alias(self, alias: str) -> str | None:
         request = isolate_proto.DeleteAliasRequest(alias=alias)
-        res: isolate_proto.DeleteAliasResult = self.stub.DeleteAlias(request)
-        return res.revision
+        try:
+            res: isolate_proto.DeleteAliasResult = self.stub.DeleteAlias(request)
+            return res.revision
+        except grpc.RpcError as e:
+            if e.code() == grpc.StatusCode.NOT_FOUND:
+                return None
+            raise
 
     def list_aliases(self) -> list[AliasInfo]:
         request = isolate_proto.ListAliasesRequest()

{fal-1.25.0.dist-info → fal-1.26.1.dist-info}/METADATA

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

{fal-1.25.0.dist-info → fal-1.26.1.dist-info}/RECORD

@@ -1,19 +1,19 @@
 fal/__init__.py,sha256=wXs1G0gSc7ZK60-bHe-B2m0l_sA6TrFk4BxY0tMoLe8,784
 fal/__main__.py,sha256=4JMK66Wj4uLZTKbF-sT3LAxOsr6buig77PmOkJCRRxw,83
-fal/_fal_version.py,sha256=IqBVQrZCUvJywOgeXHpI90KZx4iWxpQ8Zw_N9Il6uS4,513
+fal/_fal_version.py,sha256=n2TqZzcgqBKPmTHRD9QCk0lFkU1l5_qG0eOl7E-Tdjs,513
 fal/_serialization.py,sha256=npXNsFJ5G7jzBeBIyVMH01Ww34mGY4XWhHpRbSrTtnQ,7598
 fal/_version.py,sha256=1BbTFnucNC_6ldKJ_ZoC722_UkW4S9aDBSW9L0fkKAw,2315
-fal/api.py,sha256=vTYWeKnNg3japot1vOV_JSk812aeB6a2Y7lC1ed-VmM,47277
-fal/app.py,sha256=pMf7P9iVEcw5HiFCYgSdHkjX6f-1SPe06EOwYH1ImGA,24079
+fal/api.py,sha256=wIEt21P1C7U-dYQEcyHUxxuuTnvzFyTpWDoHoaxq7tg,47385
+fal/app.py,sha256=3RDFV6JUiUk8b3WJanKQYA-kW74t5bqaNy8OYuUH5-Q,25491
 fal/apps.py,sha256=pzCd2mrKl5J_4oVc40_pggvPtFahXBCdrZXWpnaEJVs,12130
 fal/config.py,sha256=19tR4zWr2yqsBRWNhFV1jKMiXAASRz2Et62k68-1r9Y,3290
 fal/container.py,sha256=FTsa5hOW4ars-yV1lUoc0BNeIIvAZcpw7Ftyt3A4m_w,2000
-fal/files.py,sha256=1eOyrj1M0hTixZdbtQ1ogJqWpLd7UfiOt1Rxihnqh8g,3565
+fal/files.py,sha256=iwR9jXWmAruP5tSS5-NkY-mZG53Pb80C40SqB0pYRrk,6819
 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=63W0o2bp_EAJmUHL6o6lrSn1d89fRzccXeZ3ww5YYYo,25994
+fal/sdk.py,sha256=eX_OJVmD6AY5NsLS7VR-LemXTWNEMfsOEfZBgAqytoo,26158
 fal/sync.py,sha256=ZuIJA2-hTPNANG9B_NNJZUsO68EIdTH0dc9MzeVE2VU,4340
 fal/utils.py,sha256=iQTBG3-i6JZgHkkwbY_I4210g0xoW-as51yrke608u0,2208
 fal/workflows.py,sha256=Zl4f6Bs085hY40zmqScxDUyCu7zXkukDbW02iYOLTTI,14805
@@ -23,7 +23,7 @@ fal/auth/local.py,sha256=sndkM6vKpeVny6NHTacVlTbiIFqaksOmw0Viqs_RN1U,1790
 fal/cli/__init__.py,sha256=padK4o0BFqq61kxAA1qQ0jYr2SuhA2mf90B3AaRkmJA,37
 fal/cli/_utils.py,sha256=anFfy6qouB8QzH0Yho41GulGiJu3q1KKIwgyVQCzgRQ,1593
 fal/cli/api.py,sha256=ZuDE_PIC-czzneTAWMwvC7P7WnwIyluNZSuJqzCFhqI,2640
-fal/cli/apps.py,sha256=FSd6uhNlmJUSToeG89gq2159RBkg9ImXquTCrvxTfQo,10283
+fal/cli/apps.py,sha256=0ex4OWbxcopjEq_BGkwkxCBSTLqUIHmFDz1MWOv06zk,10479
 fal/cli/auth.py,sha256=Qe-Z3ycXJnOzHimz5PjCQYoni8MF4csmdL19yGN7a1o,5171
 fal/cli/cli_nested_json.py,sha256=veSZU8_bYV3Iu1PAoxt-4BMBraNIqgH5nughbs2UKvE,13539
 fal/cli/create.py,sha256=a8WDq-nJLFTeoIXqpb5cr7GR7YR9ZZrQCawNm34KXXE,627
@@ -142,8 +142,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.25.0.dist-info/METADATA,sha256=8l0JvTAUiYbMT6irgvfJooJ26Bkq3kD0G4eFGCDkgRk,4089
-fal-1.25.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fal-1.25.0.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
-fal-1.25.0.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
-fal-1.25.0.dist-info/RECORD,,
+fal-1.26.1.dist-info/METADATA,sha256=Dk0fMzu4rMEi6H9l2mWWBqjkcyS-QvzxFrVmt6rbnGY,4089
+fal-1.26.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fal-1.26.1.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
+fal-1.26.1.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
+fal-1.26.1.dist-info/RECORD,,