fal 1.7.1__tar.gz → 1.7.3__tar.gz

{fal-1.7.1/fal.egg-info → fal-1.7.3}/PKG-INFO

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

{fal-1.7.1 → fal-1.7.3/fal.egg-info}/PKG-INFO

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

{fal-1.7.1 → fal-1.7.3}/src/fal/_fal_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.7.1'
-__version_tuple__ = version_tuple = (1, 7, 1)
+__version__ = version = '1.7.3'
+__version_tuple__ = version_tuple = (1, 7, 3)

{fal-1.7.1 → fal-1.7.3}/src/fal/api.py

@@ -77,6 +77,7 @@ SERVE_REQUIREMENTS = [
     "uvicorn",
     "starlette_exporter",
     "structlog",
+    "tomli",
 ]
 
 

{fal-1.7.1 → fal-1.7.3}/src/fal/toolkit/file/providers/fal.py

@@ -159,24 +159,27 @@ class FalFileRepositoryBase(FileRepository):
                 result = json.load(response)
 
             upload_url = result["upload_url"]
-            self._upload_file(upload_url, file)
-
-            return result["file_url"]
         except HTTPError as e:
             raise FileUploadException(
                 f"Error initiating upload. Status {e.status}: {e.reason}"
             )
 
-    def _upload_file(self, upload_url: str, file: FileData):
-        req = Request(
-            upload_url,
-            method="PUT",
-            data=file.data,
-            headers={"Content-Type": file.content_type},
-        )
+        try:
+            req = Request(
+                upload_url,
+                method="PUT",
+                data=file.data,
+                headers={"Content-Type": file.content_type},
+            )
 
-        with urlopen(req):
-            return
+            with urlopen(req):
+                pass
+
+            return result["file_url"]
+        except HTTPError as e:
+            raise FileUploadException(
+                f"Error uploading file. Status {e.status}: {e.reason}"
+            )
 
 
 @dataclass
@@ -202,12 +205,12 @@ class MultipartUpload:
 
     def __init__(
         self,
-        file_path: str | Path,
+        file_name: str,
         chunk_size: int | None = None,
         content_type: str | None = None,
         max_concurrency: int | None = None,
     ) -> None:
-        self.file_path = file_path
+        self.file_name = file_name
         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
@@ -227,7 +230,7 @@ class MultipartUpload:
                 },
                 data=json.dumps(
                     {
-                        "file_name": os.path.basename(self.file_path),
+                        "file_name": self.file_name,
                         "content_type": self.content_type,
                     }
                 ).encode(),
@@ -241,47 +244,29 @@ class MultipartUpload:
                 f"Error initiating upload. Status {exc.status}: {exc.reason}"
             )
 
-    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={"Content-Type": self.content_type},
-                data=data,
-            )
+    def upload_part(self, part_number: int, data: bytes) -> None:
+        url = f"{self._upload_url}&part_number={part_number}"
 
-            try:
-                with urlopen(req) as resp:
-                    return {
+        req = Request(
+            url,
+            method="PUT",
+            headers={"Content-Type": self.content_type},
+            data=data,
+        )
+
+        try:
+            with urlopen(req) as resp:
+                self._parts.append(
+                    {
                         "part_number": 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._upload_url}&part_number={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)
+        except HTTPError as exc:
+            raise FileUploadException(
+                f"Error uploading part {part_number} to {url}. "
+                f"Status {exc.status}: {exc.reason}"
+            )
 
     def complete(self):
         url = self._upload_url
@@ -304,6 +289,82 @@ class MultipartUpload:
 
         return self._file_url
 
+    @classmethod
+    def save(
+        cls,
+        file: FileData,
+        chunk_size: int | None = None,
+        max_concurrency: int | None = None,
+    ):
+        import concurrent.futures
+
+        multipart = cls(
+            file.file_name,
+            chunk_size=chunk_size,
+            content_type=file.content_type,
+            max_concurrency=max_concurrency,
+        )
+        multipart.create()
+
+        parts = math.ceil(len(file.data) / multipart.chunk_size)
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=multipart.max_concurrency
+        ) as executor:
+            futures = []
+            for part_number in range(1, parts + 1):
+                start = (part_number - 1) * multipart.chunk_size
+                data = file.data[start : start + multipart.chunk_size]
+                futures.append(
+                    executor.submit(multipart.upload_part, part_number, data)
+                )
+
+            for future in concurrent.futures.as_completed(futures):
+                future.result()
+
+        return multipart.complete()
+
+    @classmethod
+    def save_file(
+        cls,
+        file_path: str | Path,
+        chunk_size: int | None = None,
+        content_type: str | None = None,
+        max_concurrency: int | None = None,
+    ) -> str:
+        import concurrent.futures
+
+        file_name = os.path.basename(file_path)
+        size = os.path.getsize(file_path)
+
+        multipart = cls(
+            file_name,
+            chunk_size=chunk_size,
+            content_type=content_type,
+            max_concurrency=max_concurrency,
+        )
+        multipart.create()
+
+        parts = math.ceil(size / multipart.chunk_size)
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=multipart.max_concurrency
+        ) as executor:
+            futures = []
+            for part_number in range(1, parts + 1):
+
+                def _upload_part(pn: int) -> None:
+                    with open(file_path, "rb") as f:
+                        start = (pn - 1) * multipart.chunk_size
+                        f.seek(start)
+                        data = f.read(multipart.chunk_size)
+                        multipart.upload_part(pn, data)
+
+                futures.append(executor.submit(_upload_part, part_number))
+
+            for future in concurrent.futures.as_completed(futures):
+                future.result()
+
+        return multipart.complete()
+
 
 class InternalMultipartUploadV3:
     MULTIPART_THRESHOLD = 100 * 1024 * 1024
@@ -312,12 +373,12 @@ class InternalMultipartUploadV3:
 
     def __init__(
         self,
-        file_path: str | Path,
+        file_name: str,
         chunk_size: int | None = None,
         content_type: str | None = None,
         max_concurrency: int | None = None,
     ) -> None:
-        self.file_path = file_path
+        self.file_name = file_name
         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
@@ -356,7 +417,7 @@ class InternalMultipartUploadV3:
                     **self.auth_headers,
                     "Accept": "application/json",
                     "Content-Type": self.content_type,
-                    "X-Fal-File-Name": os.path.basename(self.file_path),
+                    "X-Fal-File-Name": self.file_name,
                 },
             )
             with urlopen(req) as response:
@@ -370,52 +431,32 @@ class InternalMultipartUploadV3:
             )
 
     @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,
-            )
+    def upload_part(self, part_number: int, data: bytes) -> None:
+        url = f"{self.access_url}/multipart/{self.upload_id}/{part_number}"
 
-            try:
-                with urlopen(req) as resp:
-                    return {
+        req = Request(
+            url,
+            method="PUT",
+            headers={
+                **self.auth_headers,
+                "Content-Type": self.content_type,
+            },
+            data=data,
+        )
+
+        try:
+            with urlopen(req) as resp:
+                self._parts.append(
+                    {
                         "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)
+        except HTTPError as exc:
+            raise FileUploadException(
+                f"Error uploading part {part_number} to {url}. "
+                f"Status {exc.status}: {exc.reason}"
+            )
 
     def complete(self) -> str:
         url = f"{self.access_url}/multipart/{self.upload_id}/complete"
@@ -439,13 +480,106 @@ class InternalMultipartUploadV3:
 
         return self.access_url
 
+    @classmethod
+    def save(
+        cls,
+        file: FileData,
+        chunk_size: int | None = None,
+        max_concurrency: int | None = None,
+    ):
+        import concurrent.futures
+
+        multipart = cls(
+            file.file_name,
+            chunk_size=chunk_size,
+            content_type=file.content_type,
+            max_concurrency=max_concurrency,
+        )
+        multipart.create()
+
+        parts = math.ceil(len(file.data) / multipart.chunk_size)
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=multipart.max_concurrency
+        ) as executor:
+            futures = []
+            for part_number in range(1, parts + 1):
+                start = (part_number - 1) * multipart.chunk_size
+                data = file.data[start : start + multipart.chunk_size]
+                futures.append(
+                    executor.submit(multipart.upload_part, part_number, data)
+                )
+
+            for future in concurrent.futures.as_completed(futures):
+                future.result()
+
+        return multipart.complete()
+
+    @classmethod
+    def save_file(
+        cls,
+        file_path: str | Path,
+        chunk_size: int | None = None,
+        content_type: str | None = None,
+        max_concurrency: int | None = None,
+    ) -> str:
+        import concurrent.futures
+
+        file_name = os.path.basename(file_path)
+        size = os.path.getsize(file_path)
+
+        multipart = cls(
+            file_name,
+            chunk_size=chunk_size,
+            content_type=content_type,
+            max_concurrency=max_concurrency,
+        )
+        multipart.create()
+
+        parts = math.ceil(size / multipart.chunk_size)
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=multipart.max_concurrency
+        ) as executor:
+            futures = []
+            for part_number in range(1, parts + 1):
+
+                def _upload_part(pn: int) -> None:
+                    with open(file_path, "rb") as f:
+                        start = (pn - 1) * multipart.chunk_size
+                        f.seek(start)
+                        data = f.read(multipart.chunk_size)
+                        multipart.upload_part(pn, data)
+
+                futures.append(executor.submit(_upload_part, part_number))
+
+            for future in concurrent.futures.as_completed(futures):
+                future.result()
+
+        return multipart.complete()
+
 
 @dataclass
 class FalFileRepositoryV2(FalFileRepositoryBase):
     @retry(max_retries=3, base_delay=1, backoff_type="exponential", jitter=True)
     def save(
-        self, file: FileData, object_lifecycle_preference: dict[str, str] | None = None
+        self,
+        file: FileData,
+        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,
     ) -> str:
+        if multipart is None:
+            threshold = multipart_threshold or MultipartUpload.MULTIPART_THRESHOLD
+            multipart = len(file.data) > threshold
+
+        if multipart:
+            return MultipartUpload.save(
+                file,
+                chunk_size=multipart_chunk_size,
+                max_concurrency=multipart_max_concurrency,
+            )
+
         token = fal_v2_token_manager.get_token()
         headers = {
             "Authorization": f"{token.token_type} {token.token}",
@@ -472,23 +606,6 @@ class FalFileRepositoryV2(FalFileRepositoryBase):
                 f"Error initiating upload. Status {e.status}: {e.reason}"
             )
 
-    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 = MultipartUpload(
-            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,
@@ -504,7 +621,7 @@ class FalFileRepositoryV2(FalFileRepositoryBase):
             multipart = os.path.getsize(file_path) > threshold
 
         if multipart:
-            url = self._save_multipart(
+            url = MultipartUpload.save_file(
                 file_path,
                 chunk_size=multipart_chunk_size,
                 content_type=content_type,
@@ -605,8 +722,27 @@ class InternalFalFileRepositoryV3(FileRepository):
 
     @retry(max_retries=3, base_delay=1, backoff_type="exponential", jitter=True)
     def save(
-        self, file: FileData, object_lifecycle_preference: dict[str, str] | None
+        self,
+        file: FileData,
+        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,
     ) -> str:
+        if multipart is None:
+            threshold = (
+                multipart_threshold or InternalMultipartUploadV3.MULTIPART_THRESHOLD
+            )
+            multipart = len(file.data) > threshold
+
+        if multipart:
+            return InternalMultipartUploadV3.save(
+                file,
+                chunk_size=multipart_chunk_size,
+                max_concurrency=multipart_max_concurrency,
+            )
+
         headers = {
             **self.auth_headers,
             "Accept": "application/json",
@@ -637,23 +773,6 @@ class InternalFalFileRepositoryV3(FileRepository):
             "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 = InternalMultipartUploadV3(
-            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,
@@ -669,7 +788,7 @@ class InternalFalFileRepositoryV3(FileRepository):
             multipart = os.path.getsize(file_path) > threshold
 
         if multipart:
-            url = self._save_multipart(
+            url = MultipartUpload.save_file(
                 file_path,
                 chunk_size=multipart_chunk_size,
                 content_type=content_type,

{fal-1.7.1 → fal-1.7.3}/src/fal/toolkit/utils/retry.py

@@ -1,6 +1,7 @@
 import functools
 import random
 import time
+import traceback
 from typing import Any, Callable, Literal
 
 BackoffType = Literal["exponential", "fixed"]
@@ -25,6 +26,8 @@ def retry(
                     print(f"Retrying {retries} of {max_retries}...")
                     if retries == max_retries:
                         print(f"Max retries reached. Raising exception: {e}")
+                        traceback.print_exc()
+
                         raise e
 
                     if backoff_type == "exponential":