fal 1.21.1__tar.gz → 1.23.0__tar.gz

{fal-1.21.1/fal.egg-info → fal-1.23.0}/PKG-INFO

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

{fal-1.21.1 → fal-1.23.0/fal.egg-info}/PKG-INFO

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

{fal-1.21.1 → fal-1.23.0}/src/fal/_fal_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.21.1'
-__version_tuple__ = version_tuple = (1, 21, 1)
+__version__ = version = '1.23.0'
+__version_tuple__ = version_tuple = (1, 23, 0)

{fal-1.21.1 → fal-1.23.0}/src/fal/api.py

@@ -33,6 +33,8 @@ import uvicorn
 import yaml
 from fastapi import FastAPI
 from fastapi import __version__ as fastapi_version
+from fastapi.encoders import jsonable_encoder
+from fastapi.exceptions import RequestValidationError
 from packaging.requirements import Requirement
 from packaging.utils import canonicalize_name
 from pydantic import __version__ as pydantic_version
@@ -613,8 +615,8 @@ class FalServerlessHost(Host):
         def result_handler(partial_result):
             ret.stream = partial_result.stream
             for log in partial_result.logs:
-                if "Access your exposed service at" in log.message:
-                    ret.url = log.message.rsplit()[-1]
+                if "And API access through" in log.message:
+                    ret.url = log.message.rsplit()[-1].replace("queue.", "")
                 ret.logs.put(log)
 
         self._thread_pool.submit(
@@ -954,7 +956,18 @@ def function(  # type: ignore
     def wrapper(func: Callable[ArgsT, ReturnT]):
         include_modules_from(func)
 
-        for module_name in local_python_modules or []:
+        if local_python_modules and not isinstance(local_python_modules, list):
+            raise ValueError(
+                "local_python_modules must be a list of module names as strings, got "
+                f"{repr(local_python_modules)}"
+            )
+
+        for idx, module_name in enumerate(local_python_modules or []):
+            if not isinstance(module_name, str):
+                raise ValueError(
+                    "local_python_modules must be a list of module names as strings, "
+                    f"got {repr(module_name)} at index {idx}"
+                )
             include_module(module_name)
 
         proxy = IsolatedFunction(
@@ -1092,6 +1105,17 @@ class BaseServable:
         async def field_exception_handler(request: Request, exc: FieldException):
             return JSONResponse(exc.to_pydantic_format(), exc.status_code)
 
+        # ref: https://github.com/fastapi/fastapi/blob/37c8e7d76b4b47eb2c4cced6b4de59eb3d5f08eb/fastapi/exception_handlers.py#L20
+        @_app.exception_handler(RequestValidationError)
+        async def request_val_exception_handler(
+            request: Request, exc: RequestValidationError
+        ):
+            return JSONResponse(
+                {"detail": jsonable_encoder(exc.errors())},
+                422,
+                headers={"x-fal-billable-units": "0"},
+            )
+
         @_app.exception_handler(CUDAOutOfMemoryException)
         async def cuda_out_of_memory_exception_handler(
             request: Request, exc: CUDAOutOfMemoryException

{fal-1.21.1 → fal-1.23.0}/src/fal/container.py

@@ -19,6 +19,7 @@ class ContainerImage:
     builder: Optional[Builder] = field(default=None)
     compression: str = DEFAULT_COMPRESSION
     force_compression: bool = DEFAULT_FORCE_COMPRESSION
+    secrets: Dict[str, str] = field(default_factory=dict)
 
     def __post_init__(self) -> None:
         if self.registries:
@@ -51,4 +52,5 @@ class ContainerImage:
             "builder": self.builder,
             "compression": self.compression,
             "force_compression": self.force_compression,
+            "secrets": self.secrets,
         }

{fal-1.21.1 → fal-1.23.0}/src/fal/toolkit/utils/download_utils.py

@@ -427,13 +427,22 @@ def clone_repository(
     if repo_name is None:
         repo_name = Path(https_url).stem
         if commit_hash:
+            if len(commit_hash) < 8:
+                raise ValueError(f"Commit hash '{commit_hash}' is too short.")
             repo_name += f"-{commit_hash[:8]}"
 
     local_repo_path = Path(target_dir) / repo_name  # type: ignore[arg-type]
 
     if local_repo_path.exists():
-        local_repo_commit_hash = _get_git_revision_hash(local_repo_path)
-        if local_repo_commit_hash == commit_hash and not force:
+        local_repo_commit_hash = _git_rev_parse(local_repo_path, "HEAD")
+        full_commit_hash = (
+            _git_rev_parse(local_repo_path, commit_hash) if commit_hash else None
+        )
+        if (
+            full_commit_hash
+            and local_repo_commit_hash == full_commit_hash
+            and not force
+        ):
             if include_to_path:
                 __add_local_path_to_sys_path(local_repo_path)
             return local_repo_path
@@ -516,12 +525,12 @@ def __add_local_path_to_sys_path(local_path: Path | str):
         sys.path.insert(0, local_path_str)
 
 
-def _get_git_revision_hash(repo_path: Path) -> str:
+def _git_rev_parse(repo_path: Path, ref: str) -> str:
     import subprocess
 
     try:
         return subprocess.check_output(
-            ["git", "rev-parse", "HEAD"],
+            ["git", "rev-parse", ref],
             cwd=repo_path,
             text=True,
             stderr=subprocess.STDOUT,

{fal-1.21.1 → fal-1.23.0}/tests/integration_test.py

@@ -23,7 +23,7 @@ from fal.toolkit import (
     Image as FalImage,
 )
 from fal.toolkit.file.file import CompressedFile
-from fal.toolkit.utils.download_utils import _get_git_revision_hash, _hash_url
+from fal.toolkit.utils.download_utils import _git_rev_parse, _hash_url
 
 EXAMPLE_FILE_URL = "https://raw.githubusercontent.com/fal-ai/fal/main/projects/fal/tests/assets/cat.png"
 
@@ -376,13 +376,13 @@ def test_clone_repository(isolated_client, mock_fal_persistent_dirs):
         first_path = clone_repository(
             EXAMPLE_REPO_URL, commit_hash=EXAMPLE_REPO_FIRST_COMMIT
         )
-        first_repo_hash = _get_git_revision_hash(first_path)
+        first_repo_hash = _git_rev_parse(first_path, "HEAD")
 
         second_path = clone_repository(
             EXAMPLE_REPO_URL, commit_hash=EXAMPLE_REPO_SECOND_COMMIT
         )
 
-        second_repo_hash = _get_git_revision_hash(second_path)
+        second_repo_hash = _git_rev_parse(second_path, "HEAD")
 
         return first_path, first_repo_hash, second_path, second_repo_hash
 

{fal-1.21.1 → fal-1.23.0}/tests/test_apps.py

@@ -212,6 +212,7 @@ class ExceptionApp(fal.App, keep_alive=300, max_concurrency=1):
     def app_exception(self) -> Output:
         raise AppException(message="this app is designed to fail", status_code=401)
 
+    # While making the request provide payload as {"lhs": 1, "rhs": 2}
     @fal.endpoint("/field-exception")
     def field_exception(self, input: Input) -> Output:
         raise FieldException(
@@ -402,6 +403,12 @@ def test_stateful_app(host: api.FalServerlessHost, user: User):
         yield f"{user.username}/{app_alias}"
 
 
+@pytest.fixture(scope="module")
+def test_pydantic_validation_error():
+    with AppClient.connect(StatefulAdditionApp) as client:
+        yield client
+
+
 @pytest.fixture(scope="module")
 def test_cancellable_app(host: api.FalServerlessHost, user: User):
     cancellable_app = fal.wrap_app(CancellableApp)
@@ -958,6 +965,34 @@ def test_app_exceptions(test_exception_app: AppClient):
     assert _CUDA_OOM_MESSAGE in cuda_exc.value.message
 
 
+def test_pydantic_validation_billing(test_pydantic_validation_error: AppClient):
+    with httpx.Client() as httpx_client:
+        url = test_pydantic_validation_error.url + "/increment"
+        response = httpx_client.post(
+            url,
+            json={"value": "this-is-not-an-integer"},
+            timeout=30,
+        )
+
+        assert response.status_code == 422
+        assert response.headers.get("x-fal-billable-units") == "0"
+
+
+def test_field_exception_billing(test_exception_app: AppClient):
+    with httpx.Client() as httpx_client:
+        url = test_exception_app.url + "/field-exception"
+        response = httpx_client.post(
+            url,
+            json={"lhs": 1, "rhs": 2},
+            timeout=30,
+        )
+
+        assert response.status_code == 422
+        # For errors raised on runtime, developers should be handling the billing.
+        # Therefore not adding billing units.
+        assert not hasattr(response.headers, "x-fal-billable-units")
+
+
 def test_kill_runner(host: api.FalServerlessHost, test_sleep_app: str):
     handle = apps.submit(test_sleep_app, arguments={"wait_time": 10})