fal 1.6.2__tar.gz → 1.7.1__tar.gz

{fal-1.6.2/fal.egg-info → fal-1.7.1}/PKG-INFO

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

{fal-1.6.2 → fal-1.7.1/fal.egg-info}/PKG-INFO

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

{fal-1.6.2 → fal-1.7.1}/fal.egg-info/SOURCES.txt

@@ -84,6 +84,7 @@ src/fal/_version.py
 src/fal/api.py
 src/fal/app.py
 src/fal/apps.py
+src/fal/config.py
 src/fal/container.py
 src/fal/files.py
 src/fal/flags.py
@@ -125,6 +126,7 @@ src/fal/logging/user.py
 src/fal/toolkit/__init__.py
 src/fal/toolkit/exceptions.py
 src/fal/toolkit/optimize.py
+src/fal/toolkit/types.py
 src/fal/toolkit/file/__init__.py
 src/fal/toolkit/file/file.py
 src/fal/toolkit/file/types.py
@@ -162,5 +164,6 @@ tests/mainify_package/impl.py
 tests/mainify_package/utils.py
 tests/toolkit/file_test.py
 tests/toolkit/image_test.py
+tests/toolkit/test_types.py
 tests/toolkit/utils/retry.py
 tools/demo_script.py

{fal-1.6.2 → fal-1.7.1}/src/fal/_fal_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.6.2'
-__version_tuple__ = version_tuple = (1, 6, 2)
+__version__ = version = '1.7.1'
+__version_tuple__ = version_tuple = (1, 7, 1)

{fal-1.6.2 → fal-1.7.1}/src/fal/app.py

@@ -249,9 +249,9 @@ def _to_fal_app_name(name: str) -> str:
 
 
 def _print_python_packages() -> None:
-    from pkg_resources import working_set
+    from importlib.metadata import distributions
 
-    packages = [f"{package.key}=={package.version}" for package in working_set]
+    packages = [f"{dist.metadata['Name']}=={dist.version}" for dist in distributions()]
 
     print("[debug] Python packages installed:", ", ".join(packages))
 

{fal-1.6.2 → fal-1.7.1}/src/fal/auth/__init__.py

@@ -2,22 +2,70 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass, field
+from threading import Lock
+from typing import Optional
 
 import click
 
 from fal.auth import auth0, local
+from fal.config import Config
 from fal.console import console
 from fal.console.icons import CHECK_ICON
 from fal.exceptions.auth import UnauthenticatedException
 
 
+class GoogleColabState:
+    def __init__(self):
+        self.is_checked = False
+        self.lock = Lock()
+        self.secret: Optional[str] = None
+
+
+_colab_state = GoogleColabState()
+
+
+def is_google_colab() -> bool:
+    try:
+        from IPython import get_ipython
+
+        return "google.colab" in str(get_ipython())
+    except ModuleNotFoundError:
+        return False
+    except NameError:
+        return False
+
+
+def get_colab_token() -> Optional[str]:
+    if not is_google_colab():
+        return None
+    with _colab_state.lock:
+        if _colab_state.is_checked:  # request access only once
+            return _colab_state.secret
+
+        try:
+            from google.colab import userdata  # noqa: I001
+        except ImportError:
+            return None
+
+        try:
+            token = userdata.get("FAL_KEY")
+            _colab_state.secret = token.strip()
+        except Exception:
+            _colab_state.secret = None
+
+        _colab_state.is_checked = True
+        return _colab_state.secret
+
+
 def key_credentials() -> tuple[str, str] | None:
     # Ignore key credentials when the user forces auth by user.
     if os.environ.get("FAL_FORCE_AUTH_BY_USER") == "1":
         return None
 
-    if "FAL_KEY" in os.environ:
-        key = os.environ["FAL_KEY"]
+    config = Config()
+
+    key = os.environ.get("FAL_KEY") or config.get("key") or get_colab_token()
+    if key:
         key_id, key_secret = key.split(":", 1)
         return (key_id, key_secret)
     elif "FAL_KEY_ID" in os.environ and "FAL_KEY_SECRET" in os.environ:

fal-1.7.1/src/fal/config.py

@@ -0,0 +1,23 @@
+import os
+
+import tomli
+
+
+class Config:
+    DEFAULT_CONFIG_PATH = "~/.fal/config.toml"
+    DEFAULT_PROFILE = "default"
+
+    def __init__(self):
+        self.config_path = os.path.expanduser(
+            os.getenv("FAL_CONFIG_PATH", self.DEFAULT_CONFIG_PATH)
+        )
+        self.profile = os.getenv("FAL_PROFILE", self.DEFAULT_PROFILE)
+
+        try:
+            with open(self.config_path, "rb") as file:
+                self.config = tomli.load(file)
+        except FileNotFoundError:
+            self.config = {}
+
+    def get(self, key):
+        return self.config.get(self.profile, {}).get(key)

{fal-1.6.2 → fal-1.7.1}/src/fal/container.py

@@ -3,7 +3,7 @@ class ContainerImage:
     from a Dockerfile.
     """
 
-    _known_keys = {"dockerfile_str", "build_args", "registries"}
+    _known_keys = {"dockerfile_str", "build_args", "registries", "builder"}
 
     @classmethod
     def from_dockerfile_str(cls, text: str, **kwargs):

{fal-1.6.2 → fal-1.7.1}/src/fal/toolkit/file/file.py

@@ -47,7 +47,10 @@ BUILT_IN_REPOSITORIES: dict[RepositoryId, FileRepositoryFactory] = {
 }
 
 
-def get_builtin_repository(id: RepositoryId) -> FileRepository:
+def get_builtin_repository(id: RepositoryId | FileRepository) -> FileRepository:
+    if isinstance(id, FileRepository):
+        return id
+
     if id not in BUILT_IN_REPOSITORIES.keys():
         raise ValueError(f'"{id}" is not a valid built-in file repository')
     return BUILT_IN_REPOSITORIES[id]()
@@ -122,7 +125,8 @@ class File(BaseModel):
             url=url,
             content_type=None,
             file_name=None,
-            repository=DEFAULT_REPOSITORY,
+            file_size=None,
+            file_data=None,
         )
 
     @classmethod
@@ -139,11 +143,7 @@ class File(BaseModel):
         save_kwargs: Optional[dict] = None,
         fallback_save_kwargs: Optional[dict] = None,
     ) -> File:
-        repo = (
-            repository
-            if isinstance(repository, FileRepository)
-            else get_builtin_repository(repository)
-        )
+        repo = get_builtin_repository(repository)
 
         save_kwargs = save_kwargs or {}
         fallback_save_kwargs = fallback_save_kwargs or {}
@@ -160,11 +160,7 @@ class File(BaseModel):
             if not fallback_repository:
                 raise
 
-            fallback_repo = (
-                fallback_repository
-                if isinstance(fallback_repository, FileRepository)
-                else get_builtin_repository(fallback_repository)
-            )
+            fallback_repo = get_builtin_repository(fallback_repository)
 
             url = fallback_repo.save(
                 fdata, object_lifecycle_preference, **fallback_save_kwargs
@@ -196,11 +192,7 @@ class File(BaseModel):
         if not file_path.exists():
             raise FileNotFoundError(f"File {file_path} does not exist")
 
-        repo = (
-            repository
-            if isinstance(repository, FileRepository)
-            else get_builtin_repository(repository)
-        )
+        repo = get_builtin_repository(repository)
 
         save_kwargs = save_kwargs or {}
         fallback_save_kwargs = fallback_save_kwargs or {}
@@ -222,11 +214,7 @@ class File(BaseModel):
             if not fallback_repository:
                 raise
 
-            fallback_repo = (
-                fallback_repository
-                if isinstance(fallback_repository, FileRepository)
-                else get_builtin_repository(fallback_repository)
-            )
+            fallback_repo = get_builtin_repository(fallback_repository)
 
             url, data = fallback_repo.save_file(
                 file_path,

fal-1.7.1/src/fal/toolkit/types.py

@@ -0,0 +1,140 @@
+import re
+import tempfile
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Dict, Generator, Union
+
+import pydantic
+from pydantic.utils import update_not_none
+
+from fal.toolkit.image import read_image_from_url
+from fal.toolkit.utils.download_utils import download_file
+
+# https://github.com/pydantic/pydantic/pull/2573
+if not hasattr(pydantic, "__version__") or pydantic.__version__.startswith("1."):
+    IS_PYDANTIC_V2 = False
+else:
+    IS_PYDANTIC_V2 = True
+
+MAX_DATA_URI_LENGTH = 10 * 1024 * 1024
+MAX_HTTPS_URL_LENGTH = 2048
+
+HTTP_URL_REGEX = (
+    r"^https:\/\/(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}(?::\d{1,5})?(?:\/[^\s]*)?$"
+)
+
+
+class DownloadFileMixin:
+    @contextmanager
+    def as_temp_file(self) -> Generator[Path, None, None]:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            yield download_file(str(self), temp_dir)
+
+
+class DownloadImageMixin:
+    def to_pil(self):
+        return read_image_from_url(str(self))
+
+
+class DataUri(DownloadFileMixin, str):
+    if IS_PYDANTIC_V2:
+
+        @classmethod
+        def __get_pydantic_core_schema__(cls, source_type: Any, handler) -> Any:
+            return {
+                "type": "str",
+                "pattern": "^data:",
+                "max_length": MAX_DATA_URI_LENGTH,
+                "strip_whitespace": True,
+            }
+
+        def __get_pydantic_json_schema__(cls, core_schema, handler) -> Dict[str, Any]:
+            json_schema = handler(core_schema)
+            json_schema.update(format="data-uri")
+            return json_schema
+    else:
+
+        @classmethod
+        def __get_validators__(cls):
+            yield cls.validate
+
+        @classmethod
+        def validate(cls, value: Any) -> "DataUri":
+            from pydantic.validators import str_validator
+
+            value = str_validator(value)
+            value = value.strip()
+
+            if not value.startswith("data:"):
+                raise ValueError("Data URI must start with 'data:'")
+
+            if len(value) > MAX_DATA_URI_LENGTH:
+                raise ValueError(
+                    f"Data URI is too long. Max length is {MAX_DATA_URI_LENGTH} bytes."
+                )
+
+            return cls(value)
+
+        @classmethod
+        def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+            update_not_none(field_schema, format="data-uri")
+
+
+class HttpsUrl(DownloadFileMixin, str):
+    if IS_PYDANTIC_V2:
+
+        @classmethod
+        def __get_pydantic_core_schema__(cls, source_type: Any, handler) -> Any:
+            return {
+                "type": "str",
+                "pattern": HTTP_URL_REGEX,
+                "max_length": MAX_HTTPS_URL_LENGTH,
+                "strip_whitespace": True,
+            }
+
+        def __get_pydantic_json_schema__(cls, core_schema, handler) -> Dict[str, Any]:
+            json_schema = handler(core_schema)
+            json_schema.update(format="https-url")
+            return json_schema
+
+    else:
+
+        @classmethod
+        def __get_validators__(cls):
+            yield cls.validate
+
+        @classmethod
+        def validate(cls, value: Any) -> "HttpsUrl":
+            from pydantic.validators import str_validator
+
+            value = str_validator(value)
+            value = value.strip()
+
+            if not re.match(HTTP_URL_REGEX, value):
+                raise ValueError(
+                    "URL must start with 'https://' and follow the correct format."
+                )
+
+            if len(value) > MAX_HTTPS_URL_LENGTH:
+                raise ValueError(
+                    f"HTTPS URL is too long. Max length is "
+                    f"{MAX_HTTPS_URL_LENGTH} characters."
+                )
+
+            return cls(value)
+
+        @classmethod
+        def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+            update_not_none(field_schema, format="https-url")
+
+
+class ImageHttpsUrl(DownloadImageMixin, HttpsUrl):
+    pass
+
+
+class ImageDataUri(DownloadImageMixin, DataUri):
+    pass
+
+
+FileInput = Union[HttpsUrl, DataUri]
+ImageInput = Union[ImageHttpsUrl, ImageDataUri]

{fal-1.6.2 → fal-1.7.1}/tests/integration_test.py

@@ -458,7 +458,7 @@ def fal_file_content_matches(file: File, content: str):
 
 
 def test_fal_file_from_path(isolated_client):
-    @isolated_client(requirements=[f"pydantic=={pydantic_version}"])
+    @isolated_client(requirements=[f"pydantic=={pydantic_version}", "tomli"])
     def fal_file_from_temp(content: str):
         with tempfile.NamedTemporaryFile() as temp_file:
             file_path = temp_file.name
@@ -475,7 +475,7 @@ def test_fal_file_from_path(isolated_client):
 
 
 def test_fal_file_from_bytes(isolated_client):
-    @isolated_client(requirements=[f"pydantic=={pydantic_version}"])
+    @isolated_client(requirements=[f"pydantic=={pydantic_version}", "tomli"])
     def fal_file_from_bytes(content: str):
         return File.from_bytes(content.encode(), repository="in_memory")
 
@@ -486,7 +486,7 @@ def test_fal_file_from_bytes(isolated_client):
 
 
 def test_fal_file_save(isolated_client):
-    @isolated_client(requirements=[f"pydantic=={pydantic_version}"])
+    @isolated_client(requirements=[f"pydantic=={pydantic_version}", "tomli"])
     def fal_file_to_local_file(content: str):
         file = File.from_bytes(content.encode(), repository="in_memory")
 
@@ -521,7 +521,7 @@ def test_fal_file_input(isolated_client, file_url: str, expected_content: str):
     class TestInput(BaseModel):
         file: File = Field()
 
-    @isolated_client(requirements=[f"pydantic=={pydantic_version}"])
+    @isolated_client(requirements=[f"pydantic=={pydantic_version}", "tomli"])
     def init_file_on_fal(input: TestInput) -> File:
         return input.file
 
@@ -542,7 +542,7 @@ def test_fal_compressed_file(isolated_client):
     class TestInput(BaseModel):
         files: CompressedFile
 
-    @isolated_client(requirements=[f"pydantic=={pydantic_version}"])
+    @isolated_client(requirements=[f"pydantic=={pydantic_version}", "tomli"])
     def init_compressed_file_on_fal(input: TestInput) -> int:
         extracted_file_paths = [file for file in input.files]
         return extracted_file_paths
@@ -557,7 +557,7 @@ def test_fal_compressed_file(isolated_client):
 
 
 def test_fal_cdn(isolated_client):
-    @isolated_client(requirements=[f"pydantic=={pydantic_version}"])
+    @isolated_client(requirements=[f"pydantic=={pydantic_version}", "tomli"])
     def upload_to_fal_cdn() -> FalImage:
         return FalImage.from_bytes(b"0", "jpeg", repository="cdn")
 

{fal-1.6.2 → fal-1.7.1}/tests/test_stability.py

@@ -595,7 +595,9 @@ def test_fal_storage(isolated_client, repo_type, url_prefix):
     assert file.url.startswith(url_prefix)
     assert file.as_bytes().decode().endswith("local")
 
-    @isolated_client(serve=True, requirements=[f"pydantic=={pydantic_version}"])
+    @isolated_client(
+        serve=True, requirements=[f"pydantic=={pydantic_version}", "tomli"]
+    )
     def hello_file():
         # Run in the isolated environment
         return File.from_bytes(

{fal-1.6.2 → fal-1.7.1}/tests/toolkit/image_test.py

@@ -77,7 +77,7 @@ def assert_fal_images_equals(fal_image_1: Image, fal_image_2: Image):
 
 
 def test_fal_image_from_pil(isolated_client):
-    @isolated_client(requirements=["pillow", f"pydantic=={pydantic_version}"])
+    @isolated_client(requirements=["pillow", f"pydantic=={pydantic_version}", "tomli"])
     def fal_image_from_bytes_remote():
         pil_image = get_image()
         return Image.from_pil(pil_image, repository="in_memory")
@@ -87,7 +87,7 @@ def test_fal_image_from_pil(isolated_client):
 
 
 def test_fal_image_from_bytes(isolated_client):
-    @isolated_client(requirements=["pillow", f"pydantic=={pydantic_version}"])
+    @isolated_client(requirements=["pillow", f"pydantic=={pydantic_version}", "tomli"])
     def fal_image_from_bytes_remote():
         image_bytes = get_image(as_bytes=True)
         return Image.from_bytes(image_bytes, repository="in_memory", format="png")
@@ -107,7 +107,7 @@ def test_fal_image_input(isolated_client, image_url):
     class TestInput(BaseModel):
         image: Image = Field()
 
-    @isolated_client(requirements=["pillow", f"pydantic=={pydantic_version}"])
+    @isolated_client(requirements=["pillow", f"pydantic=={pydantic_version}", "tomli"])
     def init_image_on_fal(input: TestInput) -> Image:
         return TestInput(image=input.image).image
 
@@ -127,7 +127,7 @@ def test_fal_image_input_to_pil(isolated_client):
     class TestInput(BaseModel):
         image: Image = Field()
 
-    @isolated_client(requirements=["pillow", f"pydantic=={pydantic_version}"])
+    @isolated_client(requirements=["pillow", f"pydantic=={pydantic_version}", "tomli"])
     def init_image_on_fal(input: TestInput) -> bytes:
         input_image = TestInput(image=input.image).image
         pil_image = input_image.to_pil()

fal-1.7.1/tests/toolkit/test_types.py

@@ -0,0 +1,99 @@
+import pytest
+from pydantic import BaseModel, ValidationError
+
+from fal.toolkit.types import MAX_DATA_URI_LENGTH, MAX_HTTPS_URL_LENGTH, FileInput
+
+
+class DummyModel(BaseModel):
+    url: FileInput
+
+
+class TestFileInput:
+    def test_valid_https_urls(self):
+        # Test basic HTTPS URL
+        model = DummyModel(url="https://example.com")
+        assert model.url == "https://example.com"
+
+        # Test HTTPS URL with path
+        model = DummyModel(url="https://example.com/path/to/resource")
+        assert model.url == "https://example.com/path/to/resource"
+
+        # Test HTTPS URL with query parameters
+        model = DummyModel(url="https://example.com/search?q=test&page=1")
+        assert model.url == "https://example.com/search?q=test&page=1"
+
+        # Test HTTPS URL with subdomain
+        model = DummyModel(url="https://sub.example.com")
+        assert model.url == "https://sub.example.com"
+
+        # Test HTTPS URL with port
+        model = DummyModel(url="https://example.com:8443")
+        assert model.url == "https://example.com:8443"
+
+        # Test HTTPS URL with whitespace
+        model = DummyModel(url="  https://example.com  ")
+        assert model.url == "https://example.com"
+
+        # TODO: should we even allow this?
+        # Test HTTPS URL with port
+        model = DummyModel(url="https://example.com:8443")
+        assert model.url == "https://example.com:8443"
+
+    def test_valid_data_uris(self):
+        # Test basic data URI
+        model = DummyModel(url="data:text/plain;base64,SGVsbG8gV29ybGQ=")
+        assert model.url == "data:text/plain;base64,SGVsbG8gV29ybGQ="
+
+        # Test data URI with image
+        image_uri = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="  # noqa: E501
+        model = DummyModel(url=image_uri)
+        assert model.url == image_uri
+
+        # Test data URI with whitespace
+        model = DummyModel(url="  data:text/plain,Hello World  ")
+        assert model.url == "data:text/plain,Hello World"
+
+    def test_invalid_inputs(self):
+        # Test HTTP URL (non-HTTPS)
+        with pytest.raises(ValueError):
+            DummyModel(url="http://example.com")
+
+        # Test malformed URL
+        with pytest.raises(ValueError):
+            DummyModel(url="not-a-url")
+
+        # Test invalid data URI
+        with pytest.raises(ValueError):
+            DummyModel(url="invalid-data-uri")
+
+        # Test empty string
+        with pytest.raises(ValueError):
+            DummyModel(url="")
+
+        # Test None value
+        with pytest.raises(ValueError):
+            DummyModel(url=None)
+
+    def test_length_limits(self):
+        # Test HTTPS URL at max length
+        domain = "example.com"
+        path_length = MAX_HTTPS_URL_LENGTH - len(f"https://{domain}/")
+        long_url = f"https://{domain}/{'a' * path_length}"
+        model = DummyModel(url=long_url)
+        assert model.url == long_url
+
+        # Test HTTPS URL exceeding max length
+        too_long_url = f"https://example.com/{'a' * MAX_HTTPS_URL_LENGTH}"
+        with pytest.raises(ValidationError):
+            DummyModel(url=too_long_url)
+
+        # Test data URI at max length
+        uri_prefix = "data:text/plain,"
+        long_uri = f"{uri_prefix}{'a' * (MAX_DATA_URI_LENGTH - len(uri_prefix))}"
+        model = DummyModel(url=long_uri)
+        assert model.url == long_uri
+
+        # Test data URI exceeding max length
+        too_long_uri = f"data:text/plain,{'a' * MAX_DATA_URI_LENGTH}"
+        with pytest.raises(ValueError):
+            DummyModel(url=too_long_uri)