fal 1.10.0__tar.gz → 1.11.1__tar.gz

{fal-1.10.0/fal.egg-info → fal-1.11.1}/PKG-INFO

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

{fal-1.10.0 → fal-1.11.1/fal.egg-info}/PKG-INFO

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

{fal-1.10.0 → fal-1.11.1}/src/fal/_fal_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.10.0'
-__version_tuple__ = version_tuple = (1, 10, 0)
+__version__ = version = '1.11.1'
+__version_tuple__ = version_tuple = (1, 11, 1)

{fal-1.10.0 → fal-1.11.1}/src/fal/cli/_utils.py

@@ -25,7 +25,7 @@ def get_app_data_from_toml(app_name):
         raise ValueError(f"App {app_name} not found in pyproject.toml")
 
     try:
-        app_ref = app_data["ref"]
+        app_ref = app_data.pop("ref")
     except KeyError:
         raise ValueError(f"App {app_name} does not have a ref key in pyproject.toml")
 
@@ -33,8 +33,11 @@ def get_app_data_from_toml(app_name):
     project_root, _ = find_project_root(None)
     app_ref = str(project_root / app_ref)
 
-    app_auth = app_data.get("auth", "private")
-    app_deployment_strategy = app_data.get("deployment_strategy", "recreate")
-    app_no_scale = app_data.get("no_scale", False)
+    app_auth = app_data.pop("auth", "private")
+    app_deployment_strategy = app_data.pop("deployment_strategy", "recreate")
+    app_no_scale = app_data.pop("no_scale", False)
+
+    if len(app_data) > 0:
+        raise ValueError(f"Found unexpected keys in pyproject.toml: {app_data}")
 
     return app_ref, app_auth, app_deployment_strategy, app_no_scale

{fal-1.10.0 → fal-1.11.1}/src/fal/container.py

@@ -4,6 +4,8 @@ from typing import Dict, Literal
 Builder = Literal["depot", "service", "worker"]
 BUILDERS = {"depot", "service", "worker"}
 DEFAULT_BUILDER: Builder = "depot"
+DEFAULT_COMPRESSION: str = "gzip"
+DEFAULT_FORCE_COMPRESSION: bool = False
 
 
 @dataclass
@@ -16,6 +18,8 @@ class ContainerImage:
     build_args: Dict[str, str] = field(default_factory=dict)
     registries: Dict[str, Dict[str, str]] = field(default_factory=dict)
     builder: Builder = field(default=DEFAULT_BUILDER)
+    compression: str = DEFAULT_COMPRESSION
+    force_compression: bool = DEFAULT_FORCE_COMPRESSION
 
     def __post_init__(self) -> None:
         if self.registries:
@@ -46,4 +50,6 @@ class ContainerImage:
             "build_args": self.build_args,
             "registries": self.registries,
             "builder": self.builder,
+            "compression": self.compression,
+            "force_compression": self.force_compression,
         }

{fal-1.10.0 → fal-1.11.1}/src/fal/toolkit/utils/download_utils.py

@@ -126,11 +126,12 @@ def download_file(
     *,
     force: bool = False,
     request_headers: dict[str, str] | None = None,
+    filesize_limit: int | None = None,
 ) -> Path:
     """Downloads a file from the specified URL to the target directory.
 
     The function downloads the file from the given URL and saves it in the specified
-    target directory.
+    target directory, provided it is below the given filesize limit.
 
     It also checks whether the local file already exists and whether its content length
     matches the expected content length from the remote file. If the local file already
@@ -151,6 +152,8 @@ def download_file(
             Defaults to `False`.
         request_headers: A dictionary containing additional headers to be included in
             the HTTP request. Defaults to `None`.
+        filesize_limit: An integer specifying the maximum downloadable size,
+            in megabytes. Defaults to `None`.
 
 
     Returns:
@@ -160,12 +163,22 @@ def download_file(
         ValueError: If the provided `file_name` contains a forward slash ('/').
         DownloadError: If an error occurs during the download process.
     """
+    ONE_MB = 1024**2
+
     try:
-        file_name = _get_remote_file_properties(url, request_headers)[0]
+        file_name, expected_filesize = _get_remote_file_properties(url, request_headers)
     except Exception as e:
-        print(f"GOt error: {e}")
+        print(f"Got error: {e}")
         raise DownloadError(f"Failed to get remote file properties for {url}") from e
 
+    expected_filesize_mb = expected_filesize / ONE_MB
+
+    if filesize_limit is not None and expected_filesize_mb > filesize_limit:
+        raise DownloadError(
+            f"""File to be downloaded is of size {expected_filesize_mb},
+                which is over the limit of {filesize_limit}"""
+        )
+
     if "/" in file_name:
         raise ValueError(f"File name '{file_name}' cannot contain a slash.")
 
@@ -194,7 +207,10 @@ def download_file(
 
     try:
         _download_file_python(
-            url=url, target_path=target_path, request_headers=request_headers
+            url=url,
+            target_path=target_path,
+            request_headers=request_headers,
+            filesize_limit=filesize_limit,
         )
     except Exception as e:
         msg = f"Failed to download {url} to {target_path}"
@@ -207,7 +223,10 @@ def download_file(
 
 
 def _download_file_python(
-    url: str, target_path: Path | str, request_headers: dict[str, str] | None = None
+    url: str,
+    target_path: Path | str,
+    request_headers: dict[str, str] | None = None,
+    filesize_limit: int | None = None,
 ) -> Path:
     """Download a file from a given URL and save it to a specified path using a
     Python interface.
@@ -217,6 +236,8 @@ def _download_file_python(
         target_path: The path where the downloaded file will be saved.
         request_headers: A dictionary containing additional headers to be included in
             the HTTP request. Defaults to `None`.
+        filesize_limit: A integer value specifying how many megabytes can be
+            downloaded at maximum. Defaults to `None`.
 
     Returns:
         The path where the downloaded file has been saved.
@@ -233,7 +254,10 @@ def _download_file_python(
             file_path = temp_file.name
 
             for progress, total_size in _stream_url_data_to_file(
-                url, temp_file.name, request_headers=request_headers
+                url,
+                temp_file.name,
+                request_headers=request_headers,
+                filesize_limit=filesize_limit,
             ):
                 if total_size:
                     progress_msg = f"Downloading {url} ... {progress:.2%}"
@@ -261,6 +285,7 @@ def _stream_url_data_to_file(
     file_path: str,
     chunk_size_in_mb: int = 64,
     request_headers: dict[str, str] | None = None,
+    filesize_limit: int | None = None,
 ):
     """Download data from a URL and stream it to a file.
 
@@ -277,6 +302,8 @@ def _stream_url_data_to_file(
             Defaults to 64.
         request_headers: A dictionary containing additional headers to be included in
             the HTTP request. Defaults to `None`.
+        filesize_limit: An integer specifying how many megabytes can be
+            downloaded at maximum. Defaults to `None`.
 
     Yields:
         A tuple containing two elements:
@@ -300,6 +327,11 @@ def _stream_url_data_to_file(
             f_stream.write(data)
 
             received_size = f_stream.tell()
+            if filesize_limit is not None and received_size > filesize_limit:
+                raise DownloadError(
+                    f"""Attempted to download more data {received_size}
+                        than the set limit of {filesize_limit}"""
+                )
 
             if total_size:
                 progress = received_size / total_size

{fal-1.10.0 → fal-1.11.1}/tests/cli/test_deploy.py

@@ -26,6 +26,10 @@ def mock_parse_pyproject_toml():
             "another-app": {
                 "ref": "src/another_app/inference.py::AnotherApp",
             },
+            "app-with-extras": {
+                "ref": "src/app_with_extras/inference.py::AppWithExtras",
+                "extra_key": "extra_value",
+            },
         }
     }
 
@@ -143,6 +147,23 @@ def test_deploy_with_toml_missing_ref_key(
         _deploy(args)
 
 
+@patch("fal.cli._utils.find_pyproject_toml", return_value="pyproject.toml")
+@patch("fal.cli._utils.parse_pyproject_toml")
+@patch("fal.cli.deploy._deploy_from_reference")
+def test_deploy_with_toml_extra_keys_in_toml(
+    mock_deploy_ref, mock_parse_toml, mock_find_toml, mock_parse_pyproject_toml
+):
+    mock_parse_toml.return_value = mock_parse_pyproject_toml
+
+    args = mock_args(app_ref=("app-with-extras", None))
+
+    with pytest.raises(
+        ValueError,
+        match="Found unexpected keys in pyproject.toml: {'extra_key': 'extra_value'}",
+    ):
+        _deploy(args)
+
+
 @patch("fal.cli._utils.find_pyproject_toml", return_value=None)
 def test_deploy_with_toml_file_not_found(mock_find_toml):
     args = mock_args(app_ref=("my-app", None))

{fal-1.10.0 → fal-1.11.1}/tests/test_apps.py

@@ -3,8 +3,9 @@ import json
 import secrets
 import subprocess
 import time
+import uuid
 from contextlib import contextmanager, suppress
-from datetime import datetime
+from datetime import datetime, timedelta
 from typing import Generator, List, Tuple
 
 import httpx
@@ -295,8 +296,6 @@ class RealtimeApp(fal.App, keep_alive=300, max_concurrency=1):
 def aliased_app() -> Generator[Tuple[str, str], None, None]:
     # Create a temporary app, register it, and return the ID of it.
 
-    import uuid
-
     app_alias = str(uuid.uuid4()) + "-alias"
     app_revision = addition_app.host.register(
         func=addition_app.func,
@@ -485,13 +484,19 @@ def test_stateful_app_client(test_stateful_app: str):
     assert response["result"] == 0
 
 
-@pytest.mark.flaky(max_runs=3)
 def test_app_cancellation(test_app: str, test_cancellable_app: str):
     request_handle = apps.submit(
         test_cancellable_app, arguments={"lhs": 1, "rhs": 2, "wait_time": 10}
     )
-    # enough time for it to start
-    time.sleep(8)
+
+    while True:
+        status = request_handle.status()
+        time.sleep(0.5)
+        if isinstance(status, apps.InProgress):
+            # The app is running
+            break
+
+    # cancel the request
     request_handle.cancel()
 
     # should still finish successfully and return 499
@@ -504,8 +509,14 @@ def test_app_cancellation(test_app: str, test_cancellable_app: str):
         test_app, arguments={"lhs": 1, "rhs": 2, "wait_time": 10}
     )
 
-    # enough time for it to start
-    time.sleep(8)
+    while True:
+        status = request_handle.status()
+        time.sleep(0.5)
+        if isinstance(status, apps.InProgress):
+            # The app is running
+            break
+
+    # cancel the request
     request_handle.cancel()
 
     response = request_handle.get()
@@ -514,8 +525,6 @@ def test_app_cancellation(test_app: str, test_cancellable_app: str):
 
 @pytest.mark.flaky(max_runs=3)
 def test_app_client_async():
-    import uuid
-
     app_alias = str(uuid.uuid4()) + "-client-async-alias"
 
     app = fal.wrap_app(SleepApp)
@@ -548,11 +557,11 @@ def test_app_client_async():
         elif isinstance(event, apps.Queued):
             assert event.position == 0
 
-    status = handle.status(logs=True)
-    assert isinstance(status, apps.Completed)
-    if not status.logs:
-        # Sometimes fetching logs times out to get faster results
+    for _ in range(10):
         status = handle.status(logs=True)
+        assert isinstance(status, apps.Completed)
+        if status.logs:
+            break
 
     assert status.logs, "Logs missing from Completed status"
     assert any("sleeping..." in log["message"] for log in status.logs)
@@ -609,7 +618,6 @@ def test_404_response(test_app: str, request: pytest.FixtureRequest):
 
 
 def test_app_deploy_scale(aliased_app: Tuple[str, str]):
-    import uuid
     from dataclasses import replace
 
     app_alias = str(uuid.uuid4()) + "-alias"
@@ -823,8 +831,10 @@ def test_workflows(test_app: str):
             assert data["result"] == 10
 
 
+# If the logging subsystem is not working for some nodes, this test will flake
+@pytest.mark.flaky(max_runs=5)
 def test_traceback_logs(test_exception_app: AppClient):
-    date = datetime.utcnow().isoformat()
+    date = (datetime.utcnow() - timedelta(seconds=1)).isoformat()
 
     with pytest.raises(AppClientError):
         test_exception_app.fail({})
@@ -835,16 +845,25 @@ def test_traceback_logs(test_exception_app: AppClient):
         timeout=300,
     ) as client:
         # Give some time for logs to propagate through the logging subsystem.
-        time.sleep(5)
-        response = client.get(
-            REST_CLIENT.base_url + f"/logs/?traceback=true&since={date}"
-        )
-        for log in json.loads(response.text):
-            assert log["message"].count("\n") > 1, "Logs are multi-line"
-            assert '{"traceback":' not in log["message"], "Logs are not JSON-wrapped"
+        for _ in range(10):
+            time.sleep(2)
+            response = client.get(
+                REST_CLIENT.base_url + f"/logs/?traceback=true&since={date}"
+            )
+
+            logs = response.json()
+            if len(logs) > 0:
+                break
+
+        assert len(logs) > 0
+        for log in logs:
+            assert log["message"].count("\n") > 1, "Logs should be multi-line"
+            assert (
+                '{"traceback":' not in log["message"]
+            ), "Logs should not be JSON-wrapped"
             assert (
                 "this app is designed to fail" in log["message"]
-            ), "Logs contain the traceback message"
+            ), "Logs should contain the traceback message"
 
 
 def test_app_exceptions(test_exception_app: AppClient):
@@ -866,8 +885,6 @@ def test_app_exceptions(test_exception_app: AppClient):
 
 
 def test_kill_runner():
-    import uuid
-
     app_alias = str(uuid.uuid4()) + "-sleep-alias"
     app = fal.wrap_app(SleepApp)
     app_revision = app.host.register(