fal 1.7.5__py3-none-any.whl → 1.7.7__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.5'
-__version_tuple__ = version_tuple = (1, 7, 5)
+__version__ = version = '1.7.7'
+__version_tuple__ = version_tuple = (1, 7, 7)

fal/app.py

@@ -374,6 +374,11 @@ class App(fal.api.BaseServable):
         @app.middleware("http")
         async def set_request_id(request, call_next):
             # NOTE: Setting request_id is not supported for websocket/realtime endpoints
+            if not os.getenv("IS_ISOLATE_AGENT") or not os.environ.get(
+                "NOMAD_ALLOC_PORT_grpc"
+            ):
+                # If not running in the expected environment, skip setting request_id
+                return await call_next(request)
 
             if self.isolate_channel is None:
                 grpc_port = os.environ.get("NOMAD_ALLOC_PORT_grpc")

fal/toolkit/file/providers/fal.py

@@ -190,14 +190,6 @@ class FalFileRepository(FalFileRepositoryBase):
         return self._save(file, "gcs")
 
 
-@dataclass
-class FalFileRepositoryV3(FalFileRepositoryBase):
-    def save(
-        self, file: FileData, object_lifecycle_preference: dict[str, str] | None = None
-    ) -> str:
-        return self._save(file, "fal-cdn-v3")
-
-
 class MultipartUpload:
     MULTIPART_THRESHOLD = 100 * 1024 * 1024
     MULTIPART_CHUNK_SIZE = 100 * 1024 * 1024
@@ -366,6 +358,212 @@ class MultipartUpload:
         return multipart.complete()
 
 
+class MultipartUploadV3:
+    MULTIPART_THRESHOLD = 100 * 1024 * 1024
+    MULTIPART_CHUNK_SIZE = 10 * 1024 * 1024
+    MULTIPART_MAX_CONCURRENCY = 10
+
+    def __init__(
+        self,
+        file_name: str,
+        chunk_size: int | None = None,
+        content_type: str | None = None,
+        max_concurrency: int | None = None,
+    ) -> None:
+        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
+
+        self._access_url: str | None = None
+        self._upload_url: str | None = None
+
+        self._parts: list[dict] = []
+
+    @property
+    def access_url(self) -> str:
+        if not self._access_url:
+            raise FileUploadException("Upload not initiated")
+        return self._access_url
+
+    @property
+    def upload_url(self) -> str:
+        if not self._upload_url:
+            raise FileUploadException("Upload not initiated")
+        return self._upload_url
+
+    @property
+    def auth_headers(self) -> dict[str, str]:
+        fal_key = key_credentials()
+        if not fal_key:
+            raise FileUploadException("FAL_KEY must be set")
+
+        key_id, key_secret = fal_key
+        return {
+            "Authorization": f"Key {key_id}:{key_secret}",
+        }
+
+    def create(self):
+        grpc_host = os.environ.get("FAL_HOST", "api.alpha.fal.ai")
+        rest_host = grpc_host.replace("api", "rest", 1)
+        url = f"https://{rest_host}/storage/upload/initiate-multipart?storage_type=fal-cdn-v3"
+
+        try:
+            req = Request(
+                url,
+                method="POST",
+                headers={
+                    **self.auth_headers,
+                    "Accept": "application/json",
+                },
+                data=json.dumps(
+                    {
+                        "file_name": self.file_name,
+                        "content_type": self.content_type,
+                    }
+                ).encode(),
+            )
+
+            with urlopen(req) as response:
+                result = json.load(response)
+                self._access_url = result["file_url"]
+                self._upload_url = result["upload_url"]
+
+        except HTTPError as exc:
+            raise FileUploadException(
+                f"Error initiating upload. Status {exc.status}: {exc.reason}"
+            )
+
+    @retry(max_retries=5, base_delay=1, backoff_type="exponential", jitter=True)
+    def upload_part(self, part_number: int, data: bytes) -> None:
+        parsed = urlparse(self.upload_url)
+        part_path = parsed.path + f"/{part_number}"
+        url = urlunparse(parsed._replace(path=part_path))
+
+        req = Request(
+            url,
+            method="PUT",
+            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 complete(self) -> str:
+        parsed = urlparse(self.upload_url)
+        complete_path = parsed.path + "/complete"
+        url = urlunparse(parsed._replace(path=complete_path))
+
+        try:
+            req = Request(
+                url,
+                method="POST",
+                headers={
+                    "Accept": "application/json",
+                    "Content-Type": "application/json",
+                },
+                data=json.dumps({"parts": self._parts}).encode(),
+            )
+            with urlopen(req):
+                pass
+        except HTTPError as e:
+            raise FileUploadException(
+                f"Error completing upload {url}. Status {e.status}: {e.reason}"
+            )
+
+        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()
+
+
 class InternalMultipartUploadV3:
     MULTIPART_THRESHOLD = 100 * 1024 * 1024
     MULTIPART_CHUNK_SIZE = 10 * 1024 * 1024
@@ -703,6 +901,122 @@ class FalCDNFileRepository(FileRepository):
         }
 
 
+@dataclass
+class FalFileRepositoryV3(FileRepository):
+    @property
+    def auth_headers(self) -> dict[str, str]:
+        fal_key = key_credentials()
+        if not fal_key:
+            raise FileUploadException("FAL_KEY must be set")
+
+        key_id, key_secret = fal_key
+        return {
+            "Authorization": f"Key {key_id}:{key_secret}",
+            "User-Agent": "fal/0.1.0",
+        }
+
+    @retry(max_retries=3, base_delay=1, backoff_type="exponential", jitter=True)
+    def save(
+        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 MultipartUploadV3.MULTIPART_THRESHOLD
+            multipart = len(file.data) > threshold
+
+        if multipart:
+            return MultipartUploadV3.save(
+                file,
+                chunk_size=multipart_chunk_size,
+                max_concurrency=multipart_max_concurrency,
+            )
+
+        headers = {
+            **self.auth_headers,
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        grpc_host = os.environ.get("FAL_HOST", "api.alpha.fal.ai")
+        rest_host = grpc_host.replace("api", "rest", 1)
+        url = f"https://{rest_host}/storage/upload/initiate?storage_type=fal-cdn-v3"
+
+        request = Request(
+            url,
+            headers=headers,
+            method="POST",
+            data=json.dumps(
+                {
+                    "file_name": file.file_name,
+                    "content_type": file.content_type,
+                }
+            ).encode(),
+        )
+        try:
+            with urlopen(request) as response:
+                result = json.load(response)
+                file_url = result["file_url"]
+                upload_url = result["upload_url"]
+        except HTTPError as e:
+            raise FileUploadException(
+                f"Error initiating upload. Status {e.status}: {e.reason}"
+            )
+
+        request = Request(
+            upload_url,
+            headers={"Content-Type": file.content_type},
+            method="PUT",
+            data=file.data,
+        )
+        try:
+            with urlopen(request):
+                pass
+        except HTTPError as e:
+            raise FileUploadException(
+                f"Error uploading file. Status {e.status}: {e.reason}"
+            )
+
+        return file_url
+
+    def save_file(
+        self,
+        file_path: str | Path,
+        content_type: str,
+        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,
+    ) -> tuple[str, FileData | None]:
+        if multipart is None:
+            threshold = multipart_threshold or MultipartUploadV3.MULTIPART_THRESHOLD
+            multipart = os.path.getsize(file_path) > threshold
+
+        if multipart:
+            url = MultipartUploadV3.save_file(
+                file_path,
+                chunk_size=multipart_chunk_size,
+                content_type=content_type,
+                max_concurrency=multipart_max_concurrency,
+            )
+            data = None
+        else:
+            with open(file_path, "rb") as f:
+                data = FileData(
+                    f.read(),
+                    content_type=content_type,
+                    file_name=os.path.basename(file_path),
+                )
+            url = self.save(data, object_lifecycle_preference)
+
+        return url, data
+
+
 # This is only available for internal users to have long-lived access tokens
 @dataclass
 class InternalFalFileRepositoryV3(FileRepository):
@@ -784,11 +1098,13 @@ class InternalFalFileRepositoryV3(FileRepository):
         object_lifecycle_preference: dict[str, str] | None = None,
     ) -> tuple[str, FileData | None]:
         if multipart is None:
-            threshold = multipart_threshold or MultipartUpload.MULTIPART_THRESHOLD
+            threshold = (
+                multipart_threshold or InternalMultipartUploadV3.MULTIPART_THRESHOLD
+            )
             multipart = os.path.getsize(file_path) > threshold
 
         if multipart:
-            url = MultipartUpload.save_file(
+            url = InternalMultipartUploadV3.save_file(
                 file_path,
                 chunk_size=multipart_chunk_size,
                 content_type=content_type,

{fal-1.7.5.dist-info → fal-1.7.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fal
-Version: 1.7.5
+Version: 1.7.7
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8
@@ -64,11 +64,13 @@ With fal, you can build pipelines, serve ML models and scale them up to many use
 ## Quickstart
 
 First, you need to install the `fal` package. You can do so using pip:
+
 ```shell
 pip install fal
 ```
 
 Then you need to authenticate:
+
 ```shell
 fal auth login
 ```
@@ -117,7 +119,7 @@ pytest
 
 ### Pre-commit
 
-```
+```bash
 cd projects/fal
 pre-commit install
 ```

{fal-1.7.5.dist-info → fal-1.7.7.dist-info}/RECORD

@@ -1,10 +1,10 @@
 fal/__init__.py,sha256=wXs1G0gSc7ZK60-bHe-B2m0l_sA6TrFk4BxY0tMoLe8,784
 fal/__main__.py,sha256=4JMK66Wj4uLZTKbF-sT3LAxOsr6buig77PmOkJCRRxw,83
-fal/_fal_version.py,sha256=1PmSWdbIl6FG3GO33tTDihvotemU0-1S8uTOfaXKRIY,411
+fal/_fal_version.py,sha256=ZBOMWZOUYZwPmwzK5AfGuLs4eexHW3xVZhNkn6LSpEQ,411
 fal/_serialization.py,sha256=rD2YiSa8iuzCaZohZwN_MPEB-PpSKbWRDeaIDpTEjyY,7653
 fal/_version.py,sha256=EBGqrknaf1WygENX-H4fBefLvHryvJBBGtVJetaB0NY,266
 fal/api.py,sha256=u9QfJtb1nLDJu9kegKCrdvW-Cp0mfMSGTPm5X1ywoeE,43388
-fal/app.py,sha256=C1dTWjit90XdTKmrwd5Aqv3SD0MA1JDZoLLtmStn2Xc,22917
+fal/app.py,sha256=0cm7wZXdusZXyV9nJmlFJl-7Jgxir6954OaO9Lj2ITk,23178
 fal/apps.py,sha256=RpmElElJnDYjsTRQOdNYiJwd74GEOGYA38L5O5GzNEg,11068
 fal/config.py,sha256=hgI3kW4_2NoFsrYEiPss0mnDTr8_Td2z0pVgm93wi9o,600
 fal/container.py,sha256=EjokKTULJ3fPUjDttjir-jmg0gqcUDe0iVzW2j5njec,634
@@ -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=X7vz0QQg4xFdglbHvOzjgL78dleFMeUzUh1xX68K-zQ,25831
+fal/toolkit/file/providers/fal.py,sha256=7JWTFXvAbtqakCIlA5gfKI8qU1umlWgWhvU5cXqzGVQ,36050
 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.5.dist-info/METADATA,sha256=4sk9VPsm0DqhrFWOypGkBhAQMomJvP0jTXoxJ2_eENk,3996
-fal-1.7.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-fal-1.7.5.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
-fal-1.7.5.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
-fal-1.7.5.dist-info/RECORD,,
+fal-1.7.7.dist-info/METADATA,sha256=HWsZ9TnJjqWxDoTaa2QqWTHXEX19JTW-FEBg1U-Ri9U,4002
+fal-1.7.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+fal-1.7.7.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
+fal-1.7.7.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
+fal-1.7.7.dist-info/RECORD,,