fal 1.21.1__tar.gz → 1.22.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fal
-Version: 1.21.1
+Version: 1.22.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.22.0/fal.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fal
-Version: 1.21.1
+Version: 1.22.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.22.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.22.0'
+__version_tuple__ = version_tuple = (1, 22, 0)

{fal-1.21.1 → fal-1.22.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.22.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})