fal 1.9.4__py3-none-any.whl → 1.11.0__py3-none-any.whl

fal/_fal_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.9.4'
-__version_tuple__ = version_tuple = (1, 9, 4)
+__version__ = version = '1.11.0'
+__version_tuple__ = version_tuple = (1, 11, 0)

fal/api.py

@@ -53,6 +53,7 @@ from fal.exceptions import (
 from fal.exceptions._cuda import _is_cuda_oom_exception
 from fal.logging.isolate import IsolateLogPrinter
 from fal.sdk import (
+    FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
@@ -400,6 +401,7 @@ class FalServerlessHost(Host):
             "keep_alive",
             "max_concurrency",
             "min_concurrency",
+            "concurrency_buffer",
             "max_multiplexing",
             "setup_function",
             "metadata",
@@ -451,6 +453,7 @@ class FalServerlessHost(Host):
         scheduler_options = options.host.get("_scheduler_options", None)
         max_concurrency = options.host.get("max_concurrency")
         min_concurrency = options.host.get("min_concurrency")
+        concurrency_buffer = options.host.get("concurrency_buffer")
         max_multiplexing = options.host.get("max_multiplexing")
         exposed_port = options.get_exposed_port()
         request_timeout = options.host.get("request_timeout")
@@ -466,6 +469,7 @@ class FalServerlessHost(Host):
             max_multiplexing=max_multiplexing,
             max_concurrency=max_concurrency,
             min_concurrency=min_concurrency,
+            concurrency_buffer=concurrency_buffer,
             request_timeout=request_timeout,
             startup_timeout=startup_timeout,
         )
@@ -523,6 +527,7 @@ class FalServerlessHost(Host):
         keep_alive = options.host.get("keep_alive", FAL_SERVERLESS_DEFAULT_KEEP_ALIVE)
         max_concurrency = options.host.get("max_concurrency")
         min_concurrency = options.host.get("min_concurrency")
+        concurrency_buffer = options.host.get("concurrency_buffer")
         max_multiplexing = options.host.get("max_multiplexing")
         base_image = options.host.get("_base_image", None)
         scheduler = options.host.get("_scheduler", None)
@@ -542,6 +547,7 @@ class FalServerlessHost(Host):
             max_multiplexing=max_multiplexing,
             max_concurrency=max_concurrency,
             min_concurrency=min_concurrency,
+            concurrency_buffer=concurrency_buffer,
             request_timeout=request_timeout,
             startup_timeout=startup_timeout,
         )
@@ -709,6 +715,7 @@ def function(
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     min_concurrency: int = FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
+    concurrency_buffer: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     request_timeout: int | None = None,
     startup_timeout: int | None = None,
     setup_function: Callable[..., None] | None = None,
@@ -737,6 +744,7 @@ def function(
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     min_concurrency: int = FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
+    concurrency_buffer: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     request_timeout: int | None = None,
     startup_timeout: int | None = None,
     setup_function: Callable[..., None] | None = None,
@@ -815,6 +823,7 @@ def function(
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     min_concurrency: int = FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
+    concurrency_buffer: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     request_timeout: int | None = None,
     startup_timeout: int | None = None,
     setup_function: Callable[..., None] | None = None,
@@ -848,6 +857,7 @@ def function(
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     min_concurrency: int = FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
+    concurrency_buffer: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     request_timeout: int | None = None,
     startup_timeout: int | None = None,
     setup_function: Callable[..., None] | None = None,
@@ -875,6 +885,7 @@ def function(
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     min_concurrency: int = FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
+    concurrency_buffer: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     request_timeout: int | None = None,
     startup_timeout: int | None = None,
     setup_function: Callable[..., None] | None = None,
@@ -902,6 +913,7 @@ def function(
     keep_alive: int = FAL_SERVERLESS_DEFAULT_KEEP_ALIVE,
     max_multiplexing: int = FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING,
     min_concurrency: int = FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY,
+    concurrency_buffer: int = FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER,
     request_timeout: int | None = None,
     startup_timeout: int | None = None,
     setup_function: Callable[..., None] | None = None,

fal/cli/api.py

@@ -0,0 +1,72 @@
+import re
+
+import rich
+
+import fal.apps
+
+# = or := only
+KV_SPLIT_RE = re.compile(r"(=|:=)")
+
+
+def _api(args):
+    """Handle the api command execution."""
+    from rich.console import Group
+    from rich.live import Live
+    from rich.panel import Panel
+    from rich.text import Text
+
+    from . import cli_nested_json
+
+    params = [KV_SPLIT_RE.split(param) for param in args.params]
+    params = cli_nested_json.interpret_nested_json(  # type: ignore
+        [(key, value) for key, _, value in params]
+    )
+
+    handle = fal.apps.submit(args.model_id, params)  # type: ignore
+    logs = []  # type: ignore
+
+    with Live(auto_refresh=False) as live:
+        for event in handle.iter_events(logs=True):
+            if isinstance(event, fal.apps.Queued):
+                status = Text(f"⏳ Queued (position: {event.position})", style="yellow")
+            elif isinstance(event, fal.apps.InProgress):
+                status = Text("🔄 In Progress", style="blue")
+                if event.logs:
+                    logs.extend(log.get("message", str(log)) for log in event.logs)
+                    logs = logs[-10:]  # Keep only last 10 logs
+            else:
+                status = Text("✅ Done", style="green")
+
+            status_panel = Panel(status, title="Status")
+            logs_panel = Panel("\n".join(logs), title="Logs")
+
+            live.update(Group(status_panel, logs_panel))
+            live.refresh()
+
+        # Show final result
+        result = handle.get()
+        live.update(rich.pretty.Pretty(result))
+
+
+def add_parser(main_subparsers, parents):
+    """Add the api command to the main parser."""
+    api_help = "Call a fal API endpoint directly"
+    parser = main_subparsers.add_parser(
+        "api",
+        description=api_help,
+        help=api_help,
+        parents=parents,
+    )
+
+    parser.add_argument(
+        "model_id",
+        help="Name of the Model ID to call",
+    )
+
+    parser.add_argument(
+        "params",
+        nargs="*",
+        help="Key-value pairs (e.g. key=value or nested[a][b]=value)",
+    )
+
+    parser.set_defaults(func=_api)

fal/cli/apps.py

@@ -17,6 +17,7 @@ def _apps_table(apps: list[AliasInfo]):
     table.add_column("Auth")
     table.add_column("Min Concurrency")
     table.add_column("Max Concurrency")
+    table.add_column("Concurrency Buffer")
     table.add_column("Max Multiplexing")
     table.add_column("Keep Alive")
     table.add_column("Request Timeout")
@@ -32,6 +33,7 @@ def _apps_table(apps: list[AliasInfo]):
             app.auth_mode,
             str(app.min_concurrency),
             str(app.max_concurrency),
+            str(app.concurrency_buffer),
             str(app.max_multiplexing),
             str(app.keep_alive),
             str(app.request_timeout),
@@ -50,6 +52,15 @@ def _list(args):
     client = FalServerlessClient(args.host)
     with client.connect() as connection:
         apps = connection.list_aliases()
+
+        if args.filter:
+            apps = [app for app in apps if args.filter in app.alias]
+
+        if args.sort_by_runners:
+            apps.sort(key=lambda x: x.active_runners)
+        else:
+            apps.sort(key=lambda x: x.alias)
+
         table = _apps_table(apps)
 
     args.console.print(table)
@@ -63,6 +74,16 @@ def _add_list_parser(subparsers, parents):
         help=list_help,
         parents=parents,
     )
+    parser.add_argument(
+        "--sort-by-runners",
+        action="store_true",
+        help="Sort by number of runners ascending",
+    )
+    parser.add_argument(
+        "--filter",
+        type=str,
+        help="Filter applications by alias contents",
+    )
     parser.set_defaults(func=_list)
 
 
@@ -130,6 +151,7 @@ def _scale(args):
             and args.max_multiplexing is None
             and args.max_concurrency is None
             and args.min_concurrency is None
+            and args.concurrency_buffer is None
             and args.request_timeout is None
             and args.startup_timeout is None
             and args.machine_types is None
@@ -144,6 +166,7 @@ def _scale(args):
             max_multiplexing=args.max_multiplexing,
             max_concurrency=args.max_concurrency,
             min_concurrency=args.min_concurrency,
+            concurrency_buffer=args.concurrency_buffer,
             request_timeout=args.request_timeout,
             startup_timeout=args.startup_timeout,
             machine_types=args.machine_types,
@@ -186,6 +209,11 @@ def _add_scale_parser(subparsers, parents):
         type=int,
         help="Minimum concurrency",
     )
+    parser.add_argument(
+        "--concurrency-buffer",
+        type=int,
+        help="Concurrency buffer",
+    )
     parser.add_argument(
         "--request-timeout",
         type=int,
@@ -258,13 +286,23 @@ def _runners(args):
     table = Table()
     table.add_column("Runner ID")
     table.add_column("In Flight Requests")
-    table.add_column("Expires in")
+    table.add_column("Missing Leases")
+    table.add_column("Expires In")
     table.add_column("Uptime")
 
     for runner in runners:
+        num_leases_with_request = len(
+            [
+                lease
+                for lease in runner.external_metadata.get("leases", [])
+                if lease.get("request_id") is not None
+            ]
+        )
+
         table.add_row(
             runner.runner_id,
             str(runner.in_flight_requests),
+            str(runner.in_flight_requests - num_leases_with_request),
             (
                 "N/A (active)"
                 if runner.expiration_countdown is None

fal/cli/cli_nested_json.py

@@ -0,0 +1,421 @@
+# Originally from https://github.com/httpie/cli/blob/master/httpie/cli/nested_json/interpret.py
+#
+# Copyright © 2012-2022 Jakub Roztocil <jakub@roztocil.co>
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     1. Redistributions of source code must retain the above copyright notice,
+#        this list of conditions and the following disclaimer.
+#
+#     2. Redistributions in binary form must reproduce the above copyright
+#        notice, this list of conditions and the following disclaimer in the
+#        documentation and/or other materials provided with the distribution.
+#
+#     3. Neither the name of the copyright holder nor the names of its contributors
+#        may be used to endorse or promote products derived from this software
+#        without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Iterator
+from enum import Enum, auto
+from typing import Any, NamedTuple, Union
+
+EMPTY_STRING = ""
+HIGHLIGHTER = "^"
+OPEN_BRACKET = "["
+CLOSE_BRACKET = "]"
+BACKSLASH = "\\"
+
+
+class TokenKind(Enum):
+    TEXT = auto()
+    NUMBER = auto()
+    LEFT_BRACKET = auto()
+    RIGHT_BRACKET = auto()
+    PSEUDO = auto()  # Not a real token, use when representing location only.
+
+    def to_name(self) -> str:
+        for key, value in OPERATORS.items():
+            if value is self:
+                return repr(key)
+        return "a " + self.name.lower()
+
+
+OPERATORS = {
+    OPEN_BRACKET: TokenKind.LEFT_BRACKET,
+    CLOSE_BRACKET: TokenKind.RIGHT_BRACKET,
+}
+SPECIAL_CHARS = OPERATORS.keys() | {BACKSLASH}
+LITERAL_TOKENS = [
+    TokenKind.TEXT,
+    TokenKind.NUMBER,
+]
+
+
+class Token(NamedTuple):
+    kind: TokenKind
+    value: str | int
+    start: int
+    end: int
+
+
+class PathAction(Enum):
+    KEY = auto()
+    INDEX = auto()
+    APPEND = auto()
+    # Pseudo action, used by the interpreter
+    SET = auto()
+
+    def to_string(self) -> str:
+        return self.name.lower()
+
+
+class Path:
+    def __init__(
+        self,
+        kind: PathAction,
+        accessor: str | int | None = None,
+        tokens: list[Token] | None = None,
+        is_root: bool = False,
+    ):
+        self.kind = kind
+        self.accessor = accessor
+        self.tokens = tokens or []
+        self.is_root = is_root
+
+    def reconstruct(self) -> str:
+        if self.kind is PathAction.KEY:
+            if self.is_root:
+                return str(self.accessor)
+            return OPEN_BRACKET + str(self.accessor) + CLOSE_BRACKET
+        elif self.kind is PathAction.INDEX:
+            return OPEN_BRACKET + str(self.accessor) + CLOSE_BRACKET
+        elif self.kind is PathAction.APPEND:
+            return OPEN_BRACKET + CLOSE_BRACKET
+        else:
+            raise ValueError(f"Unexpected path action: {self.kind}")
+
+
+class NestedJSONArray(list):
+    """Denotes a top-level JSON array."""
+
+
+class NestedJSONSyntaxError(ValueError):
+    def __init__(
+        self,
+        source: str,
+        token: Token | None,
+        message: str,
+        message_kind: str = "Syntax",
+    ) -> None:
+        self.source = source
+        self.token = token
+        self.message = message
+        self.message_kind = message_kind
+
+    def __str__(self):
+        lines = [f"Nested JSON Error {self.message_kind} Error: {self.message}"]
+        if self.token is not None:
+            lines.append(self.source)
+            lines.append(
+                " " * self.token.start
+                + HIGHLIGHTER * (self.token.end - self.token.start)
+            )
+        return "\n".join(lines)
+
+
+def parse(source: str) -> Iterator[Path]:
+    """
+    start: root_path path*
+    root_path: (literal | index_path | append_path)
+    literal: TEXT | NUMBER
+
+    path:
+        key_path
+        | index_path
+        | append_path
+    key_path: LEFT_BRACKET TEXT RIGHT_BRACKET
+    index_path: LEFT_BRACKET NUMBER RIGHT_BRACKET
+    append_path: LEFT_BRACKET RIGHT_BRACKET
+
+    """
+
+    tokens = list(tokenize(source))
+    cursor = 0
+
+    def can_advance():
+        return cursor < len(tokens)
+
+    # noinspection PyShadowingNames
+    def expect(*kinds):
+        nonlocal cursor
+        assert kinds
+        if can_advance():
+            token = tokens[cursor]
+            cursor += 1
+            if token.kind in kinds:
+                return token
+        elif tokens:
+            token = tokens[-1]._replace(
+                start=tokens[-1].end + 0,
+                end=tokens[-1].end + 1,
+            )
+        else:
+            token = None
+        if len(kinds) == 1:
+            suffix = kinds[0].to_name()
+        else:
+            suffix = ", ".join(kind.to_name() for kind in kinds[:-1])
+            suffix += " or " + kinds[-1].to_name()
+        message = f"Expecting {suffix}"
+        raise NestedJSONSyntaxError(source, token, message)
+
+    # noinspection PyShadowingNames
+    def parse_root():
+        tokens = []
+        if not can_advance():
+            return Path(kind=PathAction.KEY, accessor=EMPTY_STRING, is_root=True)
+        # (literal | index_path | append_path)?
+        token = expect(*LITERAL_TOKENS, TokenKind.LEFT_BRACKET)
+        tokens.append(token)
+        if token.kind in LITERAL_TOKENS:
+            action = PathAction.KEY
+            value = str(token.value)
+        elif token.kind is TokenKind.LEFT_BRACKET:
+            token = expect(TokenKind.NUMBER, TokenKind.RIGHT_BRACKET)
+            tokens.append(token)
+            if token.kind is TokenKind.NUMBER:
+                action = PathAction.INDEX
+                value = token.value
+                tokens.append(expect(TokenKind.RIGHT_BRACKET))
+            elif token.kind is TokenKind.RIGHT_BRACKET:
+                action = PathAction.APPEND
+                value = None
+            else:
+                assert_cant_happen()
+        else:
+            assert_cant_happen()
+        # noinspection PyUnboundLocalVariable
+        return Path(kind=action, accessor=value, tokens=tokens, is_root=True)
+
+    yield parse_root()
+
+    # path*
+    while can_advance():
+        path_tokens = [expect(TokenKind.LEFT_BRACKET)]
+        token = expect(TokenKind.TEXT, TokenKind.NUMBER, TokenKind.RIGHT_BRACKET)
+        path_tokens.append(token)
+        if token.kind is TokenKind.RIGHT_BRACKET:
+            path = Path(PathAction.APPEND, tokens=path_tokens)
+        elif token.kind is TokenKind.TEXT:
+            path = Path(PathAction.KEY, token.value, tokens=path_tokens)
+            path_tokens.append(expect(TokenKind.RIGHT_BRACKET))
+        elif token.kind is TokenKind.NUMBER:
+            path = Path(PathAction.INDEX, token.value, tokens=path_tokens)
+            path_tokens.append(expect(TokenKind.RIGHT_BRACKET))
+        else:
+            assert_cant_happen()
+        # noinspection PyUnboundLocalVariable
+        yield path
+
+
+def tokenize(source: str) -> Iterator[Token]:
+    cursor = 0
+    backslashes = 0
+    buffer: list[str] = []
+
+    def send_buffer() -> Iterator[Token]:
+        nonlocal backslashes
+        if not buffer:
+            return None
+
+        value = "".join(buffer)
+        kind = TokenKind.TEXT
+        if not backslashes:
+            for variation, kind in [
+                (int, TokenKind.NUMBER),
+                (check_escaped_int, TokenKind.TEXT),
+            ]:
+                try:
+                    value = variation(value)  # type: ignore[operator]
+                except ValueError:
+                    continue
+                else:
+                    break
+        yield Token(
+            kind=kind,
+            value=value,
+            start=cursor - (len(buffer) + backslashes),
+            end=cursor,
+        )
+        buffer.clear()
+        backslashes = 0
+
+    def can_advance() -> bool:
+        return cursor < len(source)
+
+    while can_advance():
+        index = source[cursor]
+        if index in OPERATORS:
+            yield from send_buffer()
+            yield Token(OPERATORS[index], index, cursor, cursor + 1)
+        elif index == BACKSLASH and can_advance():
+            if source[cursor + 1] in SPECIAL_CHARS:
+                backslashes += 1
+            else:
+                buffer.append(index)
+            buffer.append(source[cursor + 1])
+            cursor += 1
+        else:
+            buffer.append(index)
+        cursor += 1
+
+    yield from send_buffer()
+
+
+def check_escaped_int(value: str) -> str:
+    if not value.startswith(BACKSLASH):
+        raise ValueError("Not an escaped int")
+    try:
+        int(value[1:])
+    except ValueError as exc:
+        raise ValueError("Not an escaped int") from exc
+    else:
+        return value[1:]
+
+
+def assert_cant_happen():
+    raise ValueError("Unexpected value")
+
+
+JSONType = type[Union[dict, list, int, float, str]]
+JSON_TYPE_MAPPING = {
+    dict: "object",
+    list: "array",
+    int: "number",
+    float: "number",
+    str: "string",
+}
+
+
+def interpret_nested_json(pairs: Iterable[tuple[str, str]]) -> dict:
+    context = None
+    for key, value in pairs:
+        context = interpret(context, key, value)
+    return wrap_with_dict(context)
+
+
+def interpret(context: Any, key: str, value: Any) -> Any:
+    cursor = context
+    paths = list(parse(key))
+    paths.append(Path(PathAction.SET, value))
+
+    # noinspection PyShadowingNames
+    def type_check(index: int, path: Path, expected_type: JSONType):
+        if not isinstance(cursor, expected_type):
+            if path.tokens:
+                pseudo_token = Token(
+                    kind=TokenKind.PSEUDO,
+                    value="",
+                    start=path.tokens[0].start,
+                    end=path.tokens[-1].end,
+                )
+            else:
+                pseudo_token = None
+            cursor_type = JSON_TYPE_MAPPING.get(type(cursor), type(cursor).__name__)
+            required_type = JSON_TYPE_MAPPING[expected_type]
+            message = f"Cannot perform {path.kind.to_string()!r} based access on "
+            message += repr("".join(path.reconstruct() for path in paths[:index]))
+            message += f" which has a type of {cursor_type!r} but this operation"
+            message += f" requires a type of {required_type!r}."
+            raise NestedJSONSyntaxError(
+                source=key,
+                token=pseudo_token,
+                message=message,
+                message_kind="Type",
+            )
+
+    def object_for(kind: PathAction) -> Any:
+        if kind is PathAction.KEY:
+            return {}
+        elif kind in {PathAction.INDEX, PathAction.APPEND}:
+            return []
+        else:
+            assert_cant_happen()
+
+    for index, (path, next_path) in enumerate(zip(paths, paths[1:])):
+        # If there is no context yet, set it.
+        if cursor is None:
+            context = cursor = object_for(path.kind)
+        if path.kind is PathAction.KEY:
+            type_check(index, path, dict)
+            if next_path.kind is PathAction.SET:
+                cursor[path.accessor] = next_path.accessor
+                break
+            cursor = cursor.setdefault(path.accessor, object_for(next_path.kind))
+        elif path.kind is PathAction.INDEX:
+            type_check(index, path, list)
+            assert isinstance(path.accessor, int)
+            if path.accessor < 0:
+                raise NestedJSONSyntaxError(
+                    source=key,
+                    token=path.tokens[1],
+                    message="Negative indexes are not supported.",
+                    message_kind="Value",
+                )
+            cursor.extend([None] * (path.accessor - len(cursor) + 1))
+            if next_path.kind is PathAction.SET:
+                cursor[path.accessor] = next_path.accessor
+                break
+            if cursor[path.accessor] is None:
+                cursor[path.accessor] = object_for(next_path.kind)
+            cursor = cursor[path.accessor]
+        elif path.kind is PathAction.APPEND:
+            type_check(index, path, list)
+            if next_path.kind is PathAction.SET:
+                cursor.append(next_path.accessor)
+                break
+            cursor.append(object_for(next_path.kind))
+            cursor = cursor[-1]
+        else:
+            assert_cant_happen()
+
+    return context
+
+
+def wrap_with_dict(context):
+    if context is None:
+        return {}
+    elif isinstance(context, list):
+        return {
+            EMPTY_STRING: NestedJSONArray(context),
+        }
+    else:
+        assert isinstance(context, dict)
+        return context
+
+
+def unwrap_top_level_list_if_needed(data: dict):
+    """
+    Propagate the top-level list, if that's what we got.
+
+    """
+    if len(data) == 1:
+        key, value = list(data.items())[0]
+        if isinstance(value, NestedJSONArray):
+            assert key == EMPTY_STRING
+            return value
+    return data

fal/cli/deploy.py

@@ -235,9 +235,9 @@ def add_parser(main_subparsers, parents):
         "--no-scale",
         action="store_true",
         help=(
-            "Use min_concurrency/max_concurrency/max_multiplexing from previous "
-            "deployment of application with this name, if exists. Otherwise will "
-            "use the values from the application code."
+            "Use min_concurrency/max_concurrency/concurrency_buffer/max_multiplexing "
+            "from previous deployment of application with this name, if exists. "
+            "Otherwise will use the values from the application code."
         ),
     )
 

fal/cli/main.py

@@ -6,7 +6,19 @@ from fal import __version__
 from fal.console import console
 from fal.console.icons import CROSS_ICON
 
-from . import apps, auth, create, deploy, doctor, keys, profile, run, runners, secrets
+from . import (
+    api,
+    apps,
+    auth,
+    create,
+    deploy,
+    doctor,
+    keys,
+    profile,
+    run,
+    runners,
+    secrets,
+)
 from .debug import debugtools, get_debug_parser
 from .parser import FalParser, FalParserExit
 
@@ -32,6 +44,7 @@ def _get_main_parser() -> argparse.ArgumentParser:
     )
 
     for cmd in [
+        api,
         auth,
         apps,
         deploy,

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/sdk.py

@@ -29,6 +29,7 @@ _DEFAULT_SERIALIZATION_METHOD = "cloudpickle"
 FAL_SERVERLESS_DEFAULT_KEEP_ALIVE = 10
 FAL_SERVERLESS_DEFAULT_MAX_MULTIPLEXING = 1
 FAL_SERVERLESS_DEFAULT_MIN_CONCURRENCY = 0
+FAL_SERVERLESS_DEFAULT_CONCURRENCY_BUFFER = 0
 ALIAS_AUTH_MODES = ["public", "private", "shared"]
 
 logger = get_logger(__name__)
@@ -197,6 +198,7 @@ class ApplicationInfo:
     max_multiplexing: int
     active_runners: int
     min_concurrency: int
+    concurrency_buffer: int
     machine_types: list[str]
     request_timeout: int
     startup_timeout: int
@@ -213,6 +215,7 @@ class AliasInfo:
     max_multiplexing: int
     active_runners: int
     min_concurrency: int
+    concurrency_buffer: int
     machine_types: list[str]
     request_timeout: int
     startup_timeout: int
@@ -323,6 +326,7 @@ def _from_grpc_application_info(
         max_multiplexing=message.max_multiplexing,
         active_runners=message.active_runners,
         min_concurrency=message.min_concurrency,
+        concurrency_buffer=message.concurrency_buffer,
         machine_types=list(message.machine_types),
         request_timeout=message.request_timeout,
         startup_timeout=message.startup_timeout,
@@ -350,6 +354,7 @@ def _from_grpc_alias_info(message: isolate_proto.AliasInfo) -> AliasInfo:
         max_multiplexing=message.max_multiplexing,
         active_runners=message.active_runners,
         min_concurrency=message.min_concurrency,
+        concurrency_buffer=message.concurrency_buffer,
         machine_types=list(message.machine_types),
         request_timeout=message.request_timeout,
         startup_timeout=message.startup_timeout,
@@ -423,6 +428,7 @@ class MachineRequirements:
     max_concurrency: int | None = None
     max_multiplexing: int | None = None
     min_concurrency: int | None = None
+    concurrency_buffer: int | None = None
     request_timeout: int | None = None
     startup_timeout: int | None = None
 
@@ -540,6 +546,7 @@ class FalServerlessConnection:
                 ),
                 max_concurrency=machine_requirements.max_concurrency,
                 min_concurrency=machine_requirements.min_concurrency,
+                concurrency_buffer=machine_requirements.concurrency_buffer,
                 max_multiplexing=machine_requirements.max_multiplexing,
                 request_timeout=machine_requirements.request_timeout,
                 startup_timeout=machine_requirements.startup_timeout,
@@ -586,6 +593,7 @@ class FalServerlessConnection:
         max_multiplexing: int | None = None,
         max_concurrency: int | None = None,
         min_concurrency: int | None = None,
+        concurrency_buffer: int | None = None,
         request_timeout: int | None = None,
         startup_timeout: int | None = None,
         valid_regions: list[str] | None = None,
@@ -597,6 +605,7 @@ class FalServerlessConnection:
             max_multiplexing=max_multiplexing,
             max_concurrency=max_concurrency,
             min_concurrency=min_concurrency,
+            concurrency_buffer=concurrency_buffer,
             request_timeout=request_timeout,
             startup_timeout=startup_timeout,
             valid_regions=valid_regions,
@@ -645,6 +654,7 @@ class FalServerlessConnection:
                 max_concurrency=machine_requirements.max_concurrency,
                 max_multiplexing=machine_requirements.max_multiplexing,
                 min_concurrency=machine_requirements.min_concurrency,
+                concurrency_buffer=machine_requirements.concurrency_buffer,
                 request_timeout=machine_requirements.request_timeout,
                 startup_timeout=machine_requirements.startup_timeout,
             )

fal/toolkit/file/providers/fal.py

@@ -185,8 +185,236 @@ class FalFileRepositoryBase(FileRepository):
             )
 
 
+class MultipartUploadGCS:
+    MULTIPART_THRESHOLD = 100 * 1024 * 1024
+    MULTIPART_CHUNK_SIZE = 10 * 1024 * 1024
+    MULTIPART_MAX_CONCURRENCY = 10
+
+    def __init__(
+        self,
+        file_name: str,
+        chunk_size: int | None = None,
+        content_type: str | None = None,
+        max_concurrency: int | None = None,
+    ) -> None:
+        self.file_name = file_name
+        self.chunk_size = chunk_size or self.MULTIPART_CHUNK_SIZE
+        self.content_type = content_type or "application/octet-stream"
+        self.max_concurrency = max_concurrency or self.MULTIPART_MAX_CONCURRENCY
+
+        self._access_url: str | None = None
+        self._upload_url: str | None = None
+
+        self._parts: list[dict] = []
+
+    @property
+    def access_url(self) -> str:
+        if not self._access_url:
+            raise FileUploadException("Upload not initiated")
+        return self._access_url
+
+    @property
+    def upload_url(self) -> str:
+        if not self._upload_url:
+            raise FileUploadException("Upload not initiated")
+        return self._upload_url
+
+    @property
+    def auth_headers(self) -> dict[str, str]:
+        fal_key = key_credentials()
+        if not fal_key:
+            raise FileUploadException("FAL_KEY must be set")
+
+        key_id, key_secret = fal_key
+        return {
+            "Authorization": f"Key {key_id}:{key_secret}",
+        }
+
+    def create(self):
+        grpc_host = os.environ.get("FAL_HOST", "api.alpha.fal.ai")
+        rest_host = grpc_host.replace("api", "rest", 1)
+        url = f"https://{rest_host}/storage/upload/initiate-multipart?storage_type=gcs"
+
+        try:
+            req = Request(
+                url,
+                method="POST",
+                headers={
+                    **self.auth_headers,
+                    "Content-Type": "application/json",
+                    "Accept": "application/json",
+                },
+                data=json.dumps(
+                    {
+                        "file_name": self.file_name,
+                        "content_type": self.content_type,
+                    }
+                ).encode(),
+            )
+
+            with urlopen(req) as response:
+                result = json.load(response)
+                self._access_url = result["file_url"]
+                self._upload_url = result["upload_url"]
+
+        except HTTPError as exc:
+            raise FileUploadException(
+                f"Error initiating upload. Status {exc.status}: {exc.reason}"
+            )
+
+    @retry(max_retries=5, base_delay=1, backoff_type="exponential", jitter=True)
+    def upload_part(self, part_number: int, data: bytes) -> None:
+        initiate_upload_url = self.upload_url + f"/{part_number}"
+        req = Request(
+            initiate_upload_url,
+            method="POST",
+            headers=self.auth_headers,
+        )
+
+        try:
+            with urlopen(req) as response:
+                result = json.load(response)
+                upload_url = result["upload_url"]
+        except HTTPError as exc:
+            raise FileUploadException(
+                f"Error initiating part {part_number} to {initiate_upload_url}. "
+                f"Status {exc.status}: {exc.reason}"
+            )
+
+        req = Request(
+            upload_url,
+            method="PUT",
+            data=data,
+        )
+
+        try:
+            with urlopen(req) as resp:
+                self._parts.append(
+                    {
+                        "part_number": part_number,
+                        "etag": resp.headers["ETag"].strip('"'),
+                    }
+                )
+        except HTTPError as exc:
+            raise FileUploadException(
+                f"Error uploading part {part_number} to {upload_url}. "
+                f"Status {exc.status}: {exc.reason}"
+            )
+
+    def complete(self) -> str:
+        url = self.upload_url + "/complete"
+        try:
+            req = Request(
+                url,
+                method="POST",
+                headers={
+                    **self.auth_headers,
+                    "Accept": "application/json",
+                    "Content-Type": "application/json",
+                },
+                data=json.dumps(
+                    {
+                        "parts": self._parts,
+                    }
+                ).encode(),
+            )
+            with urlopen(req):
+                pass
+        except HTTPError as e:
+            raise FileUploadException(
+                f"Error completing upload {url}. Status {e.status}: {e.reason}"
+            )
+
+        return self.access_url
+
+    @classmethod
+    def save(
+        cls,
+        file: FileData,
+        chunk_size: int | None = None,
+        max_concurrency: int | None = None,
+    ):
+        import concurrent.futures
+
+        multipart = cls(
+            file.file_name,
+            chunk_size=chunk_size,
+            content_type=file.content_type,
+            max_concurrency=max_concurrency,
+        )
+        multipart.create()
+
+        parts = math.ceil(len(file.data) / multipart.chunk_size)
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=multipart.max_concurrency
+        ) as executor:
+            futures = []
+            for part_number in range(1, parts + 1):
+                start = (part_number - 1) * multipart.chunk_size
+                data = file.data[start : start + multipart.chunk_size]
+                futures.append(
+                    executor.submit(multipart.upload_part, part_number, data)
+                )
+
+            for future in concurrent.futures.as_completed(futures):
+                future.result()
+
+        return multipart.complete()
+
+    @classmethod
+    def save_file(
+        cls,
+        file_path: str | Path,
+        chunk_size: int | None = None,
+        content_type: str | None = None,
+        max_concurrency: int | None = None,
+    ) -> str:
+        import concurrent.futures
+
+        file_name = os.path.basename(file_path)
+        size = os.path.getsize(file_path)
+
+        multipart = cls(
+            file_name,
+            chunk_size=chunk_size,
+            content_type=content_type,
+            max_concurrency=max_concurrency,
+        )
+        multipart.create()
+
+        parts = math.ceil(size / multipart.chunk_size)
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=multipart.max_concurrency
+        ) as executor:
+            futures = []
+            for part_number in range(1, parts + 1):
+
+                def _upload_part(pn: int) -> None:
+                    with open(file_path, "rb") as f:
+                        start = (pn - 1) * multipart.chunk_size
+                        f.seek(start)
+                        data = f.read(multipart.chunk_size)
+                        multipart.upload_part(pn, data)
+
+                futures.append(executor.submit(_upload_part, part_number))
+
+            for future in concurrent.futures.as_completed(futures):
+                future.result()
+
+        return multipart.complete()
+
+
 @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)
+
+    @retry(max_retries=3, base_delay=1, backoff_type="exponential", jitter=True)
     def save(
         self,
         file: FileData,
@@ -196,12 +424,67 @@ class FalFileRepository(FalFileRepositoryBase):
         multipart_max_concurrency: int | None = None,
         object_lifecycle_preference: dict[str, str] | None = None,
     ) -> str:
+        if multipart is None:
+            threshold = multipart_threshold or MultipartUploadGCS.MULTIPART_THRESHOLD
+            multipart = len(file.data) > threshold
+
+        if multipart:
+            return MultipartUploadGCS.save(
+                file,
+                chunk_size=multipart_chunk_size,
+                max_concurrency=multipart_max_concurrency,
+            )
+
         headers = {}
         if object_lifecycle_preference:
             headers["X-Fal-Object-Lifecycle"] = json.dumps(object_lifecycle_preference)
 
         return self._save(file, "gcs", headers=headers)
 
+    @property
+    def auth_headers(self) -> dict[str, str]:
+        token = fal_v3_token_manager.get_token()
+        return {
+            "Authorization": f"{token.token_type} {token.token}",
+            "User-Agent": "fal/0.1.0",
+        }
+
+    def save_file(
+        self,
+        file_path: str | Path,
+        content_type: str,
+        multipart: bool | None = None,
+        multipart_threshold: int | None = None,
+        multipart_chunk_size: int | None = None,
+        multipart_max_concurrency: int | None = None,
+        object_lifecycle_preference: dict[str, str] | None = None,
+    ) -> tuple[str, FileData | None]:
+        if multipart is None:
+            threshold = multipart_threshold or MultipartUploadGCS.MULTIPART_THRESHOLD
+            multipart = os.path.getsize(file_path) > threshold
+
+        if multipart:
+            url = MultipartUploadGCS.save_file(
+                file_path,
+                chunk_size=multipart_chunk_size,
+                content_type=content_type,
+                max_concurrency=multipart_max_concurrency,
+            )
+            data = None
+        else:
+            with open(file_path, "rb") as f:
+                data = FileData(
+                    f.read(),
+                    content_type=content_type,
+                    file_name=os.path.basename(file_path),
+                )
+            url = self.save(
+                data,
+                object_lifecycle_preference=object_lifecycle_preference,
+            )
+
+        return url, data
+
 
 class MultipartUpload:
     MULTIPART_THRESHOLD = 100 * 1024 * 1024

{fal-1.9.4.dist-info → fal-1.11.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: fal
-Version: 1.9.4
+Version: 1.11.0
 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.17.0,>=0.16.1
-Requires-Dist: isolate-proto<0.7.0,>=0.6.7
+Requires-Dist: isolate-proto<0.8.0,>=0.7.0
 Requires-Dist: grpcio==1.64.0
 Requires-Dist: dill==0.3.7
 Requires-Dist: cloudpickle==3.0.0

{fal-1.9.4.dist-info → fal-1.11.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
 fal/__init__.py,sha256=wXs1G0gSc7ZK60-bHe-B2m0l_sA6TrFk4BxY0tMoLe8,784
 fal/__main__.py,sha256=4JMK66Wj4uLZTKbF-sT3LAxOsr6buig77PmOkJCRRxw,83
-fal/_fal_version.py,sha256=x_dqnWSuZ5m1DFc2qnANNI5KdLpU51P41kIYXxibols,511
+fal/_fal_version.py,sha256=NYxfUyIQwdONRcmiATXsc3iD0kuKImoMYD3H1Vdv9OM,513
 fal/_serialization.py,sha256=rD2YiSa8iuzCaZohZwN_MPEB-PpSKbWRDeaIDpTEjyY,7653
 fal/_version.py,sha256=EBGqrknaf1WygENX-H4fBefLvHryvJBBGtVJetaB0NY,266
-fal/api.py,sha256=i6HnL4sJtwv34N9T5uzXSgwetBLMVJye57CHmdq5m78,43998
+fal/api.py,sha256=jqmQfhRvZMYpWWvbTfARxjywP_72c314pnLPTb5dGwA,44755
 fal/app.py,sha256=3WhjRgJdJ2ajAeZ3IeFb20_Zm6EH19a_WIuDtanaMHE,23308
 fal/apps.py,sha256=RpmElElJnDYjsTRQOdNYiJwd74GEOGYA38L5O5GzNEg,11068
 fal/config.py,sha256=aVv0k2fxMZurlra4c7ZIKQQCNPI-Dm_Mns6PsYWdh-c,2264
-fal/container.py,sha256=9XslBET-NCG2V3-Wmof8c7eHrRoxCye88Ym7CskqCk0,1639
+fal/container.py,sha256=PM7e1RloTCexZ64uAv7sa2RSZxPI-X8KcxkdaZqEfjw,1914
 fal/files.py,sha256=QgfYfMKmNobMPufrAP_ga1FKcIAlSbw18Iar1-0qepo,2650
 fal/flags.py,sha256=oWN_eidSUOcE9wdPK_77si3A1fpgOC0UEERPsvNLIMc,842
 fal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fal/rest_client.py,sha256=kGBGmuyHfX1lR910EoKCYPjsyU8MdXawT_cW2q8Sajc,568
-fal/sdk.py,sha256=SRJ4zp0TAvHmfGPsMtYUoMPaw9yj-qKY1RkzqCcZxWo,23976
+fal/sdk.py,sha256=mMUIPB3F91TDssG_J5BFen2hWW6GFYWLh6dedpvZ9mU,24480
 fal/sync.py,sha256=ZuIJA2-hTPNANG9B_NNJZUsO68EIdTH0dc9MzeVE2VU,4340
 fal/utils.py,sha256=9q_QrQBlQN3nZYA1kEGRfhJWi4RjnO4H1uQswfaei9w,2146
 fal/workflows.py,sha256=Zl4f6Bs085hY40zmqScxDUyCu7zXkukDbW02iYOLTTI,14805
@@ -21,14 +21,16 @@ fal/auth/auth0.py,sha256=rSG1mgH-QGyKfzd7XyAaj1AYsWt-ho8Y_LZ-FUVWzh4,5421
 fal/auth/local.py,sha256=sndkM6vKpeVny6NHTacVlTbiIFqaksOmw0Viqs_RN1U,1790
 fal/cli/__init__.py,sha256=padK4o0BFqq61kxAA1qQ0jYr2SuhA2mf90B3AaRkmJA,37
 fal/cli/_utils.py,sha256=45G0LEz2bW-69MUQKPdatVE_CBC2644gC-V0qdNEsco,1252
-fal/cli/apps.py,sha256=KVi_sZQPvznrTtbOHnkbTGH9KUjYqp_b-uXLvFyjKgY,10358
+fal/cli/api.py,sha256=-rl50A00CxqVZtDh0iZmpCHMFY0jZySaumbPCe3MSoQ,2090
+fal/cli/apps.py,sha256=KhweXdLdd1wZquhAMVwgl38dZAyFns-j3ZdIZLOLGWg,11504
 fal/cli/auth.py,sha256=--MhfHGwxmtHbRkGioyn1prKn_U-pBzbz0G_QeZou-U,1352
+fal/cli/cli_nested_json.py,sha256=veSZU8_bYV3Iu1PAoxt-4BMBraNIqgH5nughbs2UKvE,13539
 fal/cli/create.py,sha256=a8WDq-nJLFTeoIXqpb5cr7GR7YR9ZZrQCawNm34KXXE,627
 fal/cli/debug.py,sha256=u_urnyFzSlNnrq93zz_GXE9FX4VyVxDoamJJyrZpFI0,1312
-fal/cli/deploy.py,sha256=Wu8wxR72od2GAp1OF-FYO6WSWt4umaHysL3HrO_bzEo,7764
+fal/cli/deploy.py,sha256=JX1jwyAFE0-u-PGGqU-pphKMCUpaPFbYMjRMhK0VmoQ,7783
 fal/cli/doctor.py,sha256=U4ne9LX5gQwNblsYQ27XdO8AYDgbYjTO39EtxhwexRM,983
 fal/cli/keys.py,sha256=trDpA3LJu9S27qE_K8Hr6fKLK4vwVzbxUHq8TFrV4pw,3157
-fal/cli/main.py,sha256=EPqG-Pp71RKkPUHv5QSb8_gWQ1DT8-OdUDNSN1h-TSk,2132
+fal/cli/main.py,sha256=oUY1bUcfEC8LIsNxUBBjT3O6HxWCd1cKEMrJBue47iw,2199
 fal/cli/parser.py,sha256=edCqFWYAQSOhrxeEK9BtFRlTEUAlG2JUDjS_vhZ_nHE,2868
 fal/cli/profile.py,sha256=OplQgs8UGQzBH7_BnG0GBMYNQ8jtPnzzX8Q1FM3Y-5s,3320
 fal/cli/run.py,sha256=nAC12Qss4Fg1XmV0qOS9RdGNLYcdoHeRgQMvbTN4P9I,1202
@@ -53,7 +55,7 @@ fal/toolkit/types.py,sha256=kkbOsDKj1qPGb1UARTBp7yuJ5JUuyy7XQurYUBCdti8,4064
 fal/toolkit/file/__init__.py,sha256=FbNl6wD-P0aSSTUwzHt4HujBXrbC3ABmaigPQA4hRfg,70
 fal/toolkit/file/file.py,sha256=Kb-mdR66OiSNTS2EGLLJYUqnAw-KN7diqhxvjS7EAZ0,9353
 fal/toolkit/file/types.py,sha256=MMAH_AyLOhowQPesOv1V25wB4qgbJ3vYNlnTPbdSv1M,2304
-fal/toolkit/file/providers/fal.py,sha256=j3g63b7ywUuTcesZD86WXSnn8Vuv-Lw5td3zSwHUmRw,37169
+fal/toolkit/file/providers/fal.py,sha256=NI9TX5gdFkyc6hHl-5FKNuYvGYhYFHD5FvXRf3d-oRU,46409
 fal/toolkit/file/providers/gcp.py,sha256=DKeZpm1MjwbvEsYvkdXUtuLIJDr_UNbqXj_Mfv3NTeo,2437
 fal/toolkit/file/providers/r2.py,sha256=YqnYkkAo_ZKIa-xoSuDnnidUFwJWHdziAR34PE6irdI,3061
 fal/toolkit/file/providers/s3.py,sha256=EI45T54Mox7lHZKROss_O8o0DIn3CHP9k1iaNYVrxvg,2714
@@ -131,8 +133,8 @@ openapi_fal_rest/models/workflow_node_type.py,sha256=-FzyeY2bxcNmizKbJI8joG7byRi
 openapi_fal_rest/models/workflow_schema.py,sha256=4K5gsv9u9pxx2ItkffoyHeNjBBYf6ur5bN4m_zePZNY,2019
 openapi_fal_rest/models/workflow_schema_input.py,sha256=2OkOXWHTNsCXHWS6EGDFzcJKkW5FIap-2gfO233EvZQ,1191
 openapi_fal_rest/models/workflow_schema_output.py,sha256=EblwSPAGfWfYVWw_WSSaBzQVju296is9o28rMBAd0mc,1196
-fal-1.9.4.dist-info/METADATA,sha256=YCKQIxk6JFhLAXYRTUqaWcGUDu4pqN1UIJ9n2liGjtE,4042
-fal-1.9.4.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-fal-1.9.4.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
-fal-1.9.4.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
-fal-1.9.4.dist-info/RECORD,,
+fal-1.11.0.dist-info/METADATA,sha256=gyk3rZlftiD1qXNBRHk5Z_g-CC65Qi9OTS_zuKfQGHE,4043
+fal-1.11.0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+fal-1.11.0.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
+fal-1.11.0.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
+fal-1.11.0.dist-info/RECORD,,

{fal-1.9.4.dist-info → fal-1.11.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (77.0.3)
 Root-Is-Purelib: true
 Tag: py3-none-any