fal 1.7.2__py3-none-any.whl → 1.7.3__py3-none-any.whl

fal/_fal_version.py

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

fal/toolkit/file/providers/fal.py

@@ -205,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
@@ -230,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(),
@@ -244,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}"
+
+        req = Request(
+            url,
+            method="PUT",
+            headers={"Content-Type": self.content_type},
+            data=data,
+        )
 
-            try:
-                with urlopen(req) as resp:
-                    return {
+        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
@@ -307,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
@@ -315,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
@@ -359,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:
@@ -373,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"
@@ -442,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}",
@@ -475,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,
@@ -507,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,
@@ -608,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",
@@ -640,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,
@@ -672,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.2.dist-info → fal-1.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fal
-Version: 1.7.2
+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.2.dist-info → fal-1.7.3.dist-info}/RECORD

@@ -1,6 +1,6 @@
 fal/__init__.py,sha256=wXs1G0gSc7ZK60-bHe-B2m0l_sA6TrFk4BxY0tMoLe8,784
 fal/__main__.py,sha256=4JMK66Wj4uLZTKbF-sT3LAxOsr6buig77PmOkJCRRxw,83
-fal/_fal_version.py,sha256=Qj1rYkRQ0hSV6NX03bgvPhjsn6HWrQ8maBXi446C5ZM,411
+fal/_fal_version.py,sha256=Lv0gR-NbC-8DxwfmwXEmOzSq6Hgx6MH4xF1fYh_opXo,411
 fal/_serialization.py,sha256=rD2YiSa8iuzCaZohZwN_MPEB-PpSKbWRDeaIDpTEjyY,7653
 fal/_version.py,sha256=EBGqrknaf1WygENX-H4fBefLvHryvJBBGtVJetaB0NY,266
 fal/api.py,sha256=u9QfJtb1nLDJu9kegKCrdvW-Cp0mfMSGTPm5X1ywoeE,43388
@@ -52,7 +52,7 @@ fal/toolkit/types.py,sha256=kkbOsDKj1qPGb1UARTBp7yuJ5JUuyy7XQurYUBCdti8,4064
 fal/toolkit/file/__init__.py,sha256=FbNl6wD-P0aSSTUwzHt4HujBXrbC3ABmaigPQA4hRfg,70
 fal/toolkit/file/file.py,sha256=-gccCKnarTu6Nfm_0yQ0sJM9aadB5tUNvKS1PTqxiFc,9071
 fal/toolkit/file/types.py,sha256=MjZ6xAhKPv4rowLo2Vcbho0sX7AQ3lm3KFyYDcw0dL4,1845
-fal/toolkit/file/providers/fal.py,sha256=Z3Bl7uzBxyckDwopRJRMwygm68nycE41voLw6mnK_BI,22464
+fal/toolkit/file/providers/fal.py,sha256=X7vz0QQg4xFdglbHvOzjgL78dleFMeUzUh1xX68K-zQ,25831
 fal/toolkit/file/providers/gcp.py,sha256=iQtkoYUqbmKKpC5srVOYtrruZ3reGRm5lz4kM8bshgk,2247
 fal/toolkit/file/providers/r2.py,sha256=G2OHcCH2yWrVtXT4hWHEXUeEjFhbKO0koqHcd7hkczk,2871
 fal/toolkit/file/providers/s3.py,sha256=CfiA6rTBFfP-empp0cB9OW2c9F5iy0Z-kGwCs5HBICU,2524
@@ -130,8 +130,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.7.2.dist-info/METADATA,sha256=WkJRSNM2kZUjycgksVYKCIH_z6GD5ks1W5bbteDQp2A,3996
-fal-1.7.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-fal-1.7.2.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
-fal-1.7.2.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
-fal-1.7.2.dist-info/RECORD,,
+fal-1.7.3.dist-info/METADATA,sha256=eTRggSeYlEsdzY5D68R6NkJbD65PrD-nkIRMd2MPa5Q,3996
+fal-1.7.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+fal-1.7.3.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
+fal-1.7.3.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
+fal-1.7.3.dist-info/RECORD,,