fal 1.26.3__tar.gz → 1.26.5__tar.gz

{fal-1.26.3/fal.egg-info → fal-1.26.5}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: fal
-Version: 1.26.3
+Version: 1.26.5
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: isolate[build]<0.19.0,>=0.18.0
-Requires-Dist: isolate-proto<0.11.0,>=0.10.0
+Requires-Dist: isolate-proto<0.11.0,>=0.10.2
 Requires-Dist: grpcio<2,>=1.64.0
 Requires-Dist: dill==0.3.7
 Requires-Dist: cloudpickle==3.0.0

{fal-1.26.3 → fal-1.26.5/fal.egg-info}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: fal
-Version: 1.26.3
+Version: 1.26.5
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: isolate[build]<0.19.0,>=0.18.0
-Requires-Dist: isolate-proto<0.11.0,>=0.10.0
+Requires-Dist: isolate-proto<0.11.0,>=0.10.2
 Requires-Dist: grpcio<2,>=1.64.0
 Requires-Dist: dill==0.3.7
 Requires-Dist: cloudpickle==3.0.0

{fal-1.26.3 → fal-1.26.5}/fal.egg-info/SOURCES.txt

@@ -162,6 +162,7 @@ tests/conftest.py
 tests/integration_test.py
 tests/mainify_target.py
 tests/test_apps.py
+tests/test_files.py
 tests/test_kv.py
 tests/test_stability.py
 tests/assets/cat.png

{fal-1.26.3 → fal-1.26.5}/fal.egg-info/requires.txt

@@ -1,5 +1,5 @@
 isolate[build]<0.19.0,>=0.18.0
-isolate-proto<0.11.0,>=0.10.0
+isolate-proto<0.11.0,>=0.10.2
 grpcio<2,>=1.64.0
 dill==0.3.7
 cloudpickle==3.0.0

{fal-1.26.3 → fal-1.26.5}/pyproject.toml

@@ -23,7 +23,7 @@ readme = "README.md"
 requires-python = ">=3.8"
 dependencies = [
     "isolate[build]>=0.18.0,<0.19.0",
-    "isolate-proto>=0.10.0,<0.11.0",
+    "isolate-proto>=0.10.2,<0.11.0",
     "grpcio>=1.64.0,<2",
     "dill==0.3.7",
     "cloudpickle==3.0.0",

{fal-1.26.3 → fal-1.26.5}/src/fal/_fal_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.26.3'
-__version_tuple__ = version_tuple = (1, 26, 3)
+__version__ = version = '1.26.5'
+__version_tuple__ = version_tuple = (1, 26, 5)

{fal-1.26.3 → fal-1.26.5}/src/fal/cli/apps.py

@@ -246,7 +246,10 @@ def _add_scale_parser(subparsers, parents):
 def _set_rev(args):
     client = get_client(args.host, args.team)
     with client.connect() as connection:
-        connection.create_alias(args.app_name, args.app_rev, args.auth)
+        alias_info = connection.create_alias(args.app_name, args.app_rev, args.auth)
+        table = _apps_table([alias_info])
+
+    args.console.print(table)
 
 
 def _add_set_rev_parser(subparsers, parents):

{fal-1.26.3 → fal-1.26.5}/src/fal/cli/profile.py

@@ -23,14 +23,38 @@ def _list(args):
 
 
 def _set(args):
-    with Config().edit() as config:
-        config.set_internal("profile", args.PROFILE)
-        args.console.print(f"Default profile set to [cyan]{args.PROFILE}[/].")
-        config.profile = args.PROFILE
-        if not config.get("key"):
+    config = Config()
+
+    # Check if the profile exists
+    if args.PROFILE not in config._config:
+        # Profile doesn't exist, offer to create it
+        args.console.print(f"Profile [cyan]{args.PROFILE}[/] does not exist.")
+        create_profile = input("Would you like to create it? (y/N): ").strip().lower()
+
+        if create_profile in ["y", "yes"]:
+            # Create the profile by setting it
+            with config.edit() as config:
+                config.set_internal("profile", args.PROFILE)
+                config._config[args.PROFILE] = {}
+                config._profile = args.PROFILE
             args.console.print(
-                "No key set for profile. Use [bold]fal profile key[/] to set a key."
+                f"Profile [cyan]{args.PROFILE}[/] created and set as default."
             )
+        else:
+            args.console.print("Profile creation cancelled.")
+            return
+    else:
+        # Profile exists, just set it as default
+        with config.edit() as config:
+            config.set_internal("profile", args.PROFILE)
+            config._profile = args.PROFILE
+        args.console.print(f"Default profile set to [cyan]{args.PROFILE}[/].")
+
+    # Check if key is set for the profile
+    if not config.get("key"):
+        args.console.print(
+            "No key set for profile. Use [bold]fal profile key[/] to set a key."
+        )
 
 
 def _unset(args, config: Config | None = None):
@@ -42,6 +66,8 @@ def _unset(args, config: Config | None = None):
 
 
 def _key_set(args):
+    config = Config(validate_profile=True)
+
     while True:
         key = input("Enter the key: ")
         if ":" in key:
@@ -50,7 +76,7 @@ def _key_set(args):
             "[red]Invalid key. The key must be in the format [bold]key:value[/].[/]"
         )
 
-    with Config().edit() as config:
+    with config.edit():
         config.set("key", key)
         args.console.print(f"Key set for profile [cyan]{config.profile}[/].")
 
@@ -61,6 +87,24 @@ def _host_set(args):
         args.console.print(f"Fal host set to [cyan]{args.HOST}[/].")
 
 
+def _create(args):
+    config = Config()
+
+    # Check if the profile already exists
+    if args.PROFILE in config._config:
+        args.console.print(f"Profile [cyan]{args.PROFILE}[/] already exists.")
+        return
+
+    # Create the profile
+    with config.edit() as config:
+        config._config[args.PROFILE] = {}
+
+    args.console.print(f"Profile [cyan]{args.PROFILE}[/] created.")
+    args.console.print(
+        f"Use [bold]fal profile set {args.PROFILE}[/] to set it as default."
+    )
+
+
 def _delete(args):
     with Config().edit() as config:
         if config.profile == args.PROFILE:
@@ -96,7 +140,7 @@ def add_parser(main_subparsers, parents):
     )
     list_parser.set_defaults(func=_list)
 
-    set_help = "Set default profile."
+    set_help = "Set default profile. If the profile doesn't exist, you'll be prompted to create it."  # noqa: E501
     set_parser = subparsers.add_parser(
         "set",
         description=set_help,
@@ -140,6 +184,19 @@ def add_parser(main_subparsers, parents):
     )
     host_set_parser.set_defaults(func=_host_set)
 
+    create_help = "Create a new profile. Use 'fal profile set <name>' to set it as default after creation."  # noqa: E501
+    create_parser = subparsers.add_parser(
+        "create",
+        description=create_help,
+        help=create_help,
+        parents=parents,
+    )
+    create_parser.add_argument(
+        "PROFILE",
+        help="Profile name.",
+    )
+    create_parser.set_defaults(func=_create)
+
     delete_help = "Delete profile."
     delete_parser = subparsers.add_parser(
         "delete",

{fal-1.26.3 → fal-1.26.5}/src/fal/config.py

@@ -4,8 +4,9 @@ import os
 from contextlib import contextmanager
 from typing import Dict, Iterator, List, Optional
 
-SETTINGS_SECTION = "__internal__"  # legacy
-DEFAULT_PROFILE = "default"
+SETTINGS_SECTION = "__internal__"
+
+NO_PROFILE_ERROR = ValueError("No profile set.")
 
 
 class Config:
@@ -15,7 +16,7 @@ class Config:
 
     DEFAULT_CONFIG_PATH = "~/.fal/config.toml"
 
-    def __init__(self):
+    def __init__(self, *, validate_profile: bool = False):
         import tomli
 
         self.config_path = os.path.expanduser(
@@ -28,11 +29,17 @@ class Config:
         except FileNotFoundError:
             self._config = {}
 
-        profile = (
-            os.getenv("FAL_PROFILE") or self.get_internal("profile") or DEFAULT_PROFILE
-        )
+        profile = os.getenv("FAL_PROFILE") or self.get_internal("profile")
+
+        # Try to set the profile, but don't fail if it doesn't exist
+        try:
+            self.profile = profile
+        except ValueError:
+            # Profile doesn't exist, set to None
+            self._profile = None
 
-        self.profile = profile
+        if validate_profile and not self.profile:
+            raise NO_PROFILE_ERROR
 
     @property
     def profile(self) -> Optional[str]:
@@ -41,9 +48,10 @@ class Config:
     @profile.setter
     def profile(self, value: Optional[str]) -> None:
         if value and value not in self._config:
-            # Make sure the section exists
-            self._config[value] = {}
-            self.set_internal("profile", value)
+            # Don't automatically create profiles - they should be created explicitly
+            raise ValueError(
+                f"Profile '{value}' does not exist. Create it first or use the profile set command."  # noqa: E501
+            )
         elif not value:
             self.unset_internal("profile")
 
@@ -53,11 +61,7 @@ class Config:
         keys: List[str] = []
         for key in self._config:
             if key != SETTINGS_SECTION:
-                if key == DEFAULT_PROFILE:
-                    # Add it at the beginning
-                    keys.insert(0, key)
-                else:
-                    keys.append(key)
+                keys.append(key)
 
         return keys
 
@@ -75,13 +79,13 @@ class Config:
 
     def set(self, key: str, value: str) -> None:
         if not self.profile:
-            raise ValueError("No profile set.")
+            raise NO_PROFILE_ERROR
 
         self._config[self.profile][key] = value
 
     def unset(self, key: str) -> None:
         if not self.profile:
-            raise ValueError("No profile set.")
+            raise NO_PROFILE_ERROR
 
         self._config.get(self.profile, {}).pop(key, None)
 

{fal-1.26.3 → fal-1.26.5}/src/fal/files.py

@@ -56,6 +56,16 @@ class FalFileSystem(AbstractFileSystem):
             raise FalServerlessException(detail)
         return response
 
+    def _abspath(self, rpath):
+        if rpath.startswith("/"):
+            return rpath
+
+        cwd = "/data"
+        if rpath in [".", ""]:
+            return cwd
+
+        return posixpath.join(cwd, rpath)
+
     def _ls(self, path):
         response = self._request("GET", f"/files/list/{path}")
         files = response.json()
@@ -73,7 +83,7 @@ class FalFileSystem(AbstractFileSystem):
         )
 
     def ls(self, path, detail=True, **kwargs):
-        abs_path = "/" + path.lstrip("/")
+        abs_path = self._abspath(path)
         if abs_path in self.dircache:
             entries = self.dircache[abs_path]
         elif abs_path in ["/", "", "."]:
@@ -95,20 +105,29 @@ class FalFileSystem(AbstractFileSystem):
         return [entry["name"] for entry in entries]
 
     def info(self, path, **kwargs):
-        parent = posixpath.dirname(path)
+        abs_path = self._abspath(path)
+        if abs_path == "/":
+            return {
+                "name": "/",
+                "size": 0,
+                "type": "directory",
+                "mtime": 0,
+            }
+        parent = posixpath.dirname(abs_path)
         entries = self.ls(parent, detail=True)
         for entry in entries:
-            if entry["name"] == path:
+            if entry["name"] == abs_path:
                 return entry
-        raise FileNotFoundError(f"File not found: {path}")
+        raise FileNotFoundError(f"File not found: {abs_path}")
 
     def get_file(self, rpath, lpath, **kwargs):
-        if self.isdir(rpath):
+        abs_rpath = self._abspath(rpath)
+        if self.isdir(abs_rpath):
             os.makedirs(lpath, exist_ok=True)
             return
 
         with open(lpath, "wb") as fobj:
-            response = self._request("GET", f"/files/file/{rpath}")
+            response = self._request("GET", f"/files/file/{abs_rpath}")
             fobj.write(response.content)
 
     def _put_file_part(self, rpath, lpath, upload_id, part_number, chunk_size):
@@ -177,6 +196,8 @@ class FalFileSystem(AbstractFileSystem):
         if os.path.isdir(lpath):
             return
 
+        abs_rpath = self._abspath(rpath)
+
         size = os.path.getsize(lpath)
         with Progress(
             SpinnerColumn(),
@@ -185,29 +206,31 @@ class FalFileSystem(AbstractFileSystem):
             TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
         ) as progress:
             if size > MULTIPART_THRESHOLD:
-                self._put_file_multipart(lpath, rpath, size, progress)
+                self._put_file_multipart(lpath, abs_rpath, size, progress)
             else:
                 task = progress.add_task(f"{os.path.basename(lpath)}", total=1)
                 with open(lpath, "rb") as fobj:
                     self._request(
                         "POST",
-                        f"/files/file/local/{rpath}",
+                        f"/files/file/local/{abs_rpath}",
                         files={"file_upload": (posixpath.basename(lpath), fobj)},
                     )
                 progress.advance(task)
         self.dircache.clear()
 
     def put_file_from_url(self, url, rpath, mode="overwrite", **kwargs):
+        abs_rpath = self._abspath(rpath)
         self._request(
             "POST",
-            f"/files/file/url/{rpath}",
+            f"/files/file/url/{abs_rpath}",
             json={"url": url},
         )
         self.dircache.clear()
 
     def rm(self, path, **kwargs):
+        abs_path = self._abspath(path)
         self._request(
             "DELETE",
-            f"/files/file/{path}",
+            f"/files/file/{abs_path}",
         )
         self.dircache.clear()

{fal-1.26.3 → fal-1.26.5}/src/fal/sdk.py

@@ -735,7 +735,7 @@ class FalServerlessConnection:
         alias: str,
         revision: str,
         auth_mode: AuthMode,
-    ):
+    ) -> AliasInfo:
         if auth_mode == "public":
             auth = isolate_proto.ApplicationAuthMode.PUBLIC
         elif auth_mode == "shared":
@@ -750,7 +750,8 @@ class FalServerlessConnection:
             revision=revision,
             auth_mode=auth,
         )
-        self.stub.SetAlias(request)
+        res = self.stub.SetAlias(request)
+        return from_grpc(res.alias_info)
 
     def delete_alias(self, alias: str) -> str | None:
         request = isolate_proto.DeleteAliasRequest(alias=alias)

{fal-1.26.3 → fal-1.26.5}/src/fal/toolkit/file/providers/fal.py

@@ -9,7 +9,7 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Generator, Generic, TypeVar
+from typing import Any, Dict, Generator, Generic, TypeVar
 from urllib.error import HTTPError
 from urllib.parse import urlparse, urlunparse
 from urllib.request import Request, urlopen
@@ -69,6 +69,19 @@ def _maybe_retry_request(
         yield response
 
 
+def _object_lifecycle_headers(
+    headers: dict[str, str],
+    object_lifecycle_preference: dict[str, str] | None,
+):
+    if object_lifecycle_preference:
+        # Used by V3 CDN
+        headers["X-Fal-Object-Lifecycle"] = json.dumps(object_lifecycle_preference)
+        # Used by V1 CDN
+        headers["X-Fal-Object-Lifecycle-Preference"] = json.dumps(
+            object_lifecycle_preference
+        )
+
+
 @dataclass
 class FalV2Token:
     token: str
@@ -451,14 +464,6 @@ class MultipartUploadGCS:
 
 @dataclass
 class FalFileRepository(FalFileRepositoryBase):
-    def _object_lifecycle_headers(
-        self,
-        headers: dict[str, str],
-        object_lifecycle_preference: dict[str, str] | None,
-    ):
-        if object_lifecycle_preference:
-            headers["X-Fal-Object-Lifecycle"] = json.dumps(object_lifecycle_preference)
-
     def save(
         self,
         file: FileData,
@@ -479,9 +484,8 @@ class FalFileRepository(FalFileRepositoryBase):
                 max_concurrency=multipart_max_concurrency,
             )
 
-        headers = {}
-        if object_lifecycle_preference:
-            headers["X-Fal-Object-Lifecycle"] = json.dumps(object_lifecycle_preference)
+        headers: Dict[str, str] = {}
+        _object_lifecycle_headers(headers, object_lifecycle_preference)
 
         return self._save(file, "gcs", headers=headers)
 
@@ -1124,6 +1128,8 @@ class FalFileRepositoryV2(FalFileRepositoryBase):
             "Content-Type": file.content_type,
         }
 
+        _object_lifecycle_headers(headers, object_lifecycle_preference)
+
         storage_url = f"{token.base_upload_url}/upload"
 
         try:
@@ -1195,16 +1201,6 @@ class InMemoryRepository(FileRepository):
 
 @dataclass
 class FalCDNFileRepository(FileRepository):
-    def _object_lifecycle_headers(
-        self,
-        headers: dict[str, str],
-        object_lifecycle_preference: dict[str, str] | None,
-    ):
-        if object_lifecycle_preference:
-            headers["X-Fal-Object-Lifecycle-Preference"] = json.dumps(
-                object_lifecycle_preference
-            )
-
     def save(
         self,
         file: FileData,
@@ -1221,7 +1217,7 @@ class FalCDNFileRepository(FileRepository):
             "X-Fal-File-Name": file.file_name,
         }
 
-        self._object_lifecycle_headers(headers, object_lifecycle_preference)
+        _object_lifecycle_headers(headers, object_lifecycle_preference)
 
         url = os.getenv("FAL_CDN_HOST", _FAL_CDN) + "/files/upload"
         request = Request(url, headers=headers, method="POST", data=file.data)
@@ -1288,6 +1284,7 @@ class FalFileRepositoryV3(FileRepository):
             "Accept": "application/json",
             "Content-Type": "application/json",
         }
+        _object_lifecycle_headers(headers, object_lifecycle_preference)
 
         grpc_host = os.environ.get("FAL_HOST", "api.alpha.fal.ai")
         rest_host = grpc_host.replace("api", "rest", 1)
@@ -1376,14 +1373,6 @@ class InternalFalFileRepositoryV3(FileRepository):
     That way it can avoid the need to refresh the token for every upload.
     """
 
-    def _object_lifecycle_headers(
-        self,
-        headers: dict[str, str],
-        object_lifecycle_preference: dict[str, str] | None,
-    ):
-        if object_lifecycle_preference:
-            headers["X-Fal-Object-Lifecycle"] = json.dumps(object_lifecycle_preference)
-
     def save(
         self,
         file: FileData,
@@ -1413,7 +1402,7 @@ class InternalFalFileRepositoryV3(FileRepository):
             "X-Fal-File-Name": file.file_name,
         }
 
-        self._object_lifecycle_headers(headers, object_lifecycle_preference)
+        _object_lifecycle_headers(headers, object_lifecycle_preference)
 
         url = os.getenv("FAL_CDN_V3_HOST", _FAL_CDN_V3) + "/files/upload"
         request = Request(url, headers=headers, method="POST", data=file.data)

fal-1.26.5/tests/test_files.py

@@ -0,0 +1,59 @@
+import posixpath
+import uuid
+
+from fal.files import FalFileSystem
+
+
+def test_fal_fs(tmp_path):
+    (tmp_path / "myfile").write_text("myfile")
+    (tmp_path / "mydir").mkdir()
+    (tmp_path / "mydir" / "myfile1").write_text("myfile1")
+    (tmp_path / "mydir" / "myfile2").write_text("myfile2")
+
+    (tmp_path / "downloaded").mkdir()
+
+    remote_temp_dir = f"/data/tmp/{uuid.uuid4()}"
+
+    fs = FalFileSystem()
+
+    assert fs.exists("/")
+    assert fs.isdir("/")
+    assert fs.exists("/data")
+    assert fs.isdir("/data")
+    assert fs.exists(".")
+    assert fs.isdir(".")
+
+    fs.put(str(tmp_path / "myfile"), remote_temp_dir + "/myfile")
+    assert fs.exists(remote_temp_dir + "/myfile")
+    assert fs.isdir(remote_temp_dir)
+    assert fs.isfile(remote_temp_dir + "/myfile")
+    assert not fs.isdir(remote_temp_dir + "/myfile")
+    fs.get(remote_temp_dir + "/myfile", str(tmp_path / "downloaded" / "myfile"))
+    assert (tmp_path / "downloaded" / "myfile").read_text() == "myfile"
+
+    fs.put(str(tmp_path / "mydir"), remote_temp_dir + "/mydir", recursive=True)
+    assert fs.exists(remote_temp_dir + "/mydir")
+    assert fs.isdir(remote_temp_dir + "/mydir")
+    assert fs.isfile(remote_temp_dir + "/mydir/myfile1")
+    assert fs.isfile(remote_temp_dir + "/mydir/myfile2")
+    fs.get(
+        remote_temp_dir + "/mydir",
+        str(tmp_path / "downloaded" / "mydir"),
+        recursive=True,
+    )
+    assert (tmp_path / "downloaded" / "mydir" / "myfile1").read_text() == "myfile1"
+    assert (tmp_path / "downloaded" / "mydir" / "myfile2").read_text() == "myfile2"
+
+    assert fs.ls(remote_temp_dir, detail=False) == [
+        remote_temp_dir + "/mydir",
+        remote_temp_dir + "/myfile",
+    ]
+    assert fs.ls(posixpath.relpath(remote_temp_dir, "/data"), detail=False) == [
+        remote_temp_dir + "/mydir",
+        remote_temp_dir + "/myfile",
+    ]
+
+    fs.rm(remote_temp_dir + "/myfile")
+    assert not fs.exists(remote_temp_dir + "/myfile")
+    fs.rm(remote_temp_dir + "/mydir", recursive=True)
+    assert not fs.exists(remote_temp_dir + "/mydir")

{fal-1.26.3 → fal-1.26.5}/tests/test_stability.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import subprocess
+import uuid
 from contextlib import suppress
 
 import pytest
@@ -82,6 +83,44 @@ def test_regular_function_in_a_container(isolated_client):
     assert mult(5, 2) == 10
 
 
+def test_container_no_venv(isolated_client):
+    actual_python = active_python()
+
+    @isolated_client(
+        "container",
+        image=ContainerImage.from_dockerfile_str(
+            f"""
+            FROM python:{actual_python}
+            # {uuid.uuid4()}
+            """
+        ),
+    )
+    def myfunc():
+        return 42
+
+    assert myfunc() == 42
+
+
+def test_container_venv(isolated_client):
+    actual_python = active_python()
+
+    @isolated_client(
+        "container",
+        image=ContainerImage.from_dockerfile_str(
+            f"""
+            FROM python:{actual_python}
+            # {uuid.uuid4()}
+            RUN python -m venv .venv
+            ENV PATH="/root/.venv/bin:$PATH"
+            """
+        ),
+    )
+    def myfunc():
+        return 42
+
+    assert myfunc() == 42
+
+
 def test_regular_function_in_a_container_with_custom_image(isolated_client):
     actual_python = active_python()
 
@@ -584,7 +623,7 @@ def test_worker_env_vars(isolated_client):
     [
         (
             "fal",
-            "https://storage.googleapis.com/isolate-dev-smiling-shark_toolkit_bucket/",
+            "https://storage.googleapis.com/isolate-dev-smiling-shark_toolkit_public_bucket/",
         ),
         ("fal_v2", "https://v2.fal.media/files"),
         ("fal_v3", "https://v3.fal.media/files"),