fal 1.42.0__py3-none-any.whl → 1.44.0__py3-none-any.whl

fal/_fal_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.42.0'
-__version_tuple__ = version_tuple = (1, 42, 0)
+__version__ = version = '1.44.0'
+__version_tuple__ = version_tuple = (1, 44, 0)
 
 __commit_id__ = commit_id = None

fal/app.py

@@ -311,10 +311,15 @@ class App(BaseServable):
         "resolver": "uv",
         "keep_alive": 60,
     }
-    app_name: ClassVar[str]
+    app_name: ClassVar[Optional[str]] = None
     app_auth: ClassVar[Optional[AuthModeLiteral]] = None
-    request_timeout: ClassVar[int | None] = None
-    startup_timeout: ClassVar[int | None] = None
+    request_timeout: ClassVar[Optional[int]] = None
+    startup_timeout: ClassVar[Optional[int]] = None
+    min_concurrency: ClassVar[Optional[int]] = None
+    max_concurrency: ClassVar[Optional[int]] = None
+    concurrency_buffer: ClassVar[Optional[int]] = None
+    concurrency_buffer_perc: ClassVar[Optional[int]] = None
+    max_multiplexing: ClassVar[Optional[int]] = None
 
     isolate_channel: async_grpc.Channel | None = None
 
@@ -329,6 +334,21 @@ class App(BaseServable):
         if cls.startup_timeout is not None:
             cls.host_kwargs["startup_timeout"] = cls.startup_timeout
 
+        if cls.min_concurrency is not None:
+            cls.host_kwargs["min_concurrency"] = cls.min_concurrency
+
+        if cls.max_concurrency is not None:
+            cls.host_kwargs["max_concurrency"] = cls.max_concurrency
+
+        if cls.concurrency_buffer is not None:
+            cls.host_kwargs["concurrency_buffer"] = cls.concurrency_buffer
+
+        if cls.concurrency_buffer_perc is not None:
+            cls.host_kwargs["concurrency_buffer_perc"] = cls.concurrency_buffer_perc
+
+        if cls.max_multiplexing is not None:
+            cls.host_kwargs["max_multiplexing"] = cls.max_multiplexing
+
         cls.app_name = getattr(cls, "app_name", app_name)
 
         if cls.__init__ is not App.__init__:

fal/cli/parser.py

@@ -86,6 +86,37 @@ class SinceAction(argparse.Action):
 
         super().__init__(*args, **kwargs)
 
+        # If a default is provided as a string like "1h ago", parse it into a datetime
+        # so callers can rely on receiving a datetime even when the flag isn't passed.
+        default_value = getattr(self, "default", None)
+        if default_value is not None and default_value is not argparse.SUPPRESS:
+            if isinstance(default_value, str):
+                dt = self._parse_since(default_value)
+                if not dt:
+                    raise ValueError(
+                        f"Invalid 'default' value for SinceAction: {default_value!r}"
+                    )
+                if (
+                    self._limit
+                    and self._limit_dt is not None
+                    and dt < self._limit_dt - self.LIMIT_LEEWAY
+                ):
+                    raise ValueError(
+                        "Default since value is older than the allowed limit "
+                        f"{self._limit}."
+                    )
+                self.default = dt
+            elif isinstance(default_value, datetime):
+                if (
+                    self._limit
+                    and self._limit_dt is not None
+                    and default_value < self._limit_dt - self.LIMIT_LEEWAY
+                ):
+                    raise ValueError(
+                        "Default since value is older than the allowed limit "
+                        f"{self._limit}."
+                    )
+
     def __call__(self, parser, args, values, option_string=None):  # noqa: ARG002
         if values is None:
             setattr(args, self.dest, None)
@@ -102,7 +133,7 @@ class SinceAction(argparse.Action):
                 ),
             )
 
-        if self._limit_dt is not None:
+        if self._limit and self._limit_dt is not None:
             if dt < self._limit_dt - self.LIMIT_LEEWAY:
                 raise argparse.ArgumentError(
                     self,

fal/cli/runners.py

@@ -1,9 +1,18 @@
 from __future__ import annotations
 
 import json
-from datetime import timedelta
-from typing import List
-
+from collections import deque
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from http import HTTPStatus
+from typing import Iterator, List
+
+import httpx
+from httpx_sse import connect_sse
+from rich.console import Console
+from structlog.typing import EventDict
+
+from fal.rest_client import REST_CLIENT
 from fal.sdk import RunnerInfo, RunnerState
 
 from ._utils import get_client
@@ -198,6 +207,347 @@ def _add_list_parser(subparsers, parents):
     parser.set_defaults(func=_list)
 
 
+def _to_iso_naive(dt: datetime) -> str:
+    return dt.astimezone(timezone.utc).isoformat()
+
+
+def _parse_ts(ts: str) -> datetime:
+    # Support both 'Z' and offset formats
+    ts_norm = ts.replace("Z", "+00:00")
+    return datetime.fromisoformat(ts_norm)
+
+
+def _to_aware_utc(dt: datetime) -> datetime:
+    # Treat naive datetimes as UTC
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc)
+
+
+def _post_history(
+    client: httpx.Client,
+    base_params: dict[str, str],
+    since: datetime | None,
+    until: datetime | None,
+    page_size: int,
+) -> tuple[list, str | None]:
+    params: dict[str, str] = dict(base_params)
+    if since is not None:
+        params["since"] = _to_iso_naive(since)
+    if until is not None:
+        params["until"] = _to_iso_naive(until)
+    params["page_size"] = str(page_size)
+    resp = client.post("/logs/history", params=params)
+    if resp.status_code != HTTPStatus.OK:
+        try:
+            detail = resp.json().get("detail", resp.text)
+        except Exception:
+            detail = resp.text
+        raise RuntimeError(f"Failed to fetch logs history: {detail}")
+    data = resp.json()
+    items = data.get("items", []) if isinstance(data, dict) else []
+    next_until = data.get("next_until") if isinstance(data, dict) else None
+    if not isinstance(items, list):
+        raise RuntimeError("Unexpected logs history response format")
+    return items, next_until
+
+
+@dataclass
+class RestRunnerInfo:
+    started_at: datetime | None
+    ended_at: datetime | None
+
+
+def _get_runner_info(runner_id: str) -> RestRunnerInfo:
+    headers = REST_CLIENT.get_headers()
+    with httpx.Client(
+        base_url=REST_CLIENT.base_url, headers=headers, timeout=30
+    ) as client:
+        resp = client.get(f"/runners/{runner_id}")
+        if resp.status_code == HTTPStatus.NOT_FOUND:
+            raise RuntimeError(f"Runner {runner_id} not found")
+        if resp.status_code != HTTPStatus.OK:
+            raise RuntimeError(
+                f"Failed to fetch runner info: {resp.status_code} {resp.text}"
+            )
+        data = resp.json()
+        if not isinstance(data, dict):
+            raise RuntimeError(f"Unexpected runner info response format: {resp.text}")
+
+        start: datetime | None = None
+        end: datetime | None = None
+
+        started_at = data.get("started_at")
+        if started_at is not None:
+            try:
+                start = _to_aware_utc(_parse_ts(started_at))
+            except Exception:
+                start = None
+
+        ended_at = data.get("ended_at")
+        if ended_at is not None:
+            try:
+                end = _to_aware_utc(_parse_ts(ended_at))
+            except Exception:
+                end = None
+
+        return RestRunnerInfo(started_at=start, ended_at=end)
+
+
+def _stream_logs(
+    base_params: dict[str, str], since: datetime | None, until: datetime | None
+) -> Iterator[dict]:
+    headers = REST_CLIENT.get_headers()
+    params: dict[str, str] = base_params.copy()
+    if since is not None:
+        params["since"] = _to_iso_naive(since)
+    if until is not None:
+        params["until"] = _to_iso_naive(until)
+    with httpx.Client(
+        base_url=REST_CLIENT.base_url,
+        headers=headers,
+        timeout=None,
+        follow_redirects=True,
+    ) as client:
+        with connect_sse(
+            client,
+            method="POST",
+            url="/logs/stream",
+            params=params,
+            headers={"Accept": "text/event-stream"},
+        ) as event_source:
+            for sse in event_source.iter_sse():
+                if not sse.data:
+                    continue
+                if sse.event == "error":
+                    raise RuntimeError(f"Error streaming logs: {sse.data}")
+                try:
+                    yield json.loads(sse.data)
+                except Exception:
+                    continue
+
+
+DEFAULT_PAGE_SIZE = 1000
+
+
+def _iter_logs(
+    base_params: dict[str, str], start: datetime | None, end: datetime | None
+) -> Iterator[dict]:
+    headers = REST_CLIENT.get_headers()
+    with httpx.Client(
+        base_url=REST_CLIENT.base_url,
+        headers=headers,
+        timeout=300,
+        follow_redirects=True,
+    ) as client:
+        cursor_until = end
+        while True:
+            items, next_until = _post_history(
+                client, base_params, start, cursor_until, DEFAULT_PAGE_SIZE
+            )
+
+            yield from items
+
+            if not next_until:
+                break
+
+            new_until_dt = _to_aware_utc(_parse_ts(next_until))
+            if start is not None and new_until_dt <= start:
+                break
+            cursor_until = new_until_dt
+
+
+def _get_logs(
+    params: dict[str, str],
+    since: datetime | None,
+    until: datetime | None,
+    lines_count: int | None,
+    *,
+    oldest: bool = False,
+) -> Iterator[dict]:
+    if lines_count is None:
+        yield from _iter_logs(params, since, until)
+        return
+
+    if oldest:
+        produced = 0
+        for log in _iter_logs(params, since, until):
+            if produced >= lines_count:
+                break
+            produced += 1
+            yield log
+        return
+
+    # newest tail: collect into a fixed-size deque, then yield
+    tail: deque[dict] = deque(maxlen=lines_count)
+    for log in _iter_logs(params, since, until):
+        tail.append(log)
+    for log in tail:
+        yield log
+
+
+class LogPrinter:
+    def __init__(self, console: Console) -> None:
+        from structlog.dev import ConsoleRenderer
+
+        from fal.logging.style import LEVEL_STYLES
+
+        self._console = console
+        self._renderer = ConsoleRenderer(level_styles=LEVEL_STYLES)
+
+    def _render_log(self, log: dict) -> str:
+        ts_str: str = log["timestamp"]
+        timestamp = _to_aware_utc(_parse_ts(ts_str))
+        local_ts = timestamp.astimezone()
+        tz_offset = local_ts.strftime("%z")
+        # Insert ':' into offset for readability, e.g. +0300 -> +03:00
+        if tz_offset and len(tz_offset) == 5:
+            tz_offset = tz_offset[:3] + ":" + tz_offset[3:]
+
+        event: EventDict = {
+            "event": log.get("message", ""),
+            "level": str(log.get("level", "")).upper(),
+            "timestamp": f"{local_ts.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}{tz_offset}",
+        }
+        return self._renderer(logger={}, name=event["level"], event_dict=event)
+
+    def print(self, log: dict) -> None:
+        self._console.print(self._render_log(log), highlight=False)
+
+
+DEFAULT_STREAM_SINCE = timedelta(minutes=1)
+
+
+def _logs(args):
+    params: dict[str, str] = {"job_id": args.id}
+    if getattr(args, "search", None) is not None:
+        params["search"] = args.search
+
+    runner_info = _get_runner_info(args.id)
+    follow: bool = getattr(args, "follow", False)
+    since = getattr(args, "since", None)
+    if follow:
+        since = since or (datetime.now(timezone.utc) - DEFAULT_STREAM_SINCE)
+    else:
+        since = since or runner_info.started_at
+    until = getattr(args, "until", None) or runner_info.ended_at
+
+    # Normalize to aware UTC for comparisons
+    if since is not None:
+        since = _to_aware_utc(since)
+    if until is not None:
+        until = _to_aware_utc(until)
+
+    # Sanity limiters: clamp within runner lifetime when known
+    if runner_info.started_at is not None:
+        if since is not None and since < runner_info.started_at:
+            since = runner_info.started_at
+        if until is not None and until < runner_info.started_at:
+            until = runner_info.started_at
+    if runner_info.ended_at is not None:
+        if since is not None and since > runner_info.ended_at:
+            since = runner_info.ended_at
+        if until is not None and until > runner_info.ended_at:
+            until = runner_info.ended_at
+
+    # Ensure ordering if both are present
+    if since is not None and until is not None and until < since:
+        since, until = until, since
+
+    lines_arg = getattr(args, "lines", None)
+    lines_count: int | None = None
+    lines_oldest = False
+    if lines_arg is not None:
+        if lines_arg.startswith("+"):
+            lines_str = lines_arg[1:]
+            lines_oldest = True
+        else:
+            lines_str = lines_arg
+        try:
+            lines_count = int(lines_str)
+        except ValueError:
+            args.parser.error("Invalid -n|--lines value. Use an integer or +integer.")
+
+    if follow:
+        logs_gen = _stream_logs(params, since, until)
+    else:
+        logs_gen = _get_logs(params, since, until, lines_count, oldest=lines_oldest)
+
+    printer = LogPrinter(args.console)
+
+    if follow:
+        for log in logs_gen:
+            if args.output == "json":
+                args.console.print(json.dumps(log))
+            else:
+                printer.print(log)
+        return
+
+    if args.output == "json":
+        args.console.print(json.dumps({"logs": list(logs_gen)}))
+    else:
+        for log in reversed(list(logs_gen)):
+            printer.print(log)
+
+
+def _add_logs_parser(subparsers, parents):
+    logs_help = "Show logs for a runner."
+    parser = subparsers.add_parser(
+        "logs",
+        aliases=["log"],
+        description=logs_help,
+        help=logs_help,
+        parents=[*parents, get_output_parser()],
+    )
+    parser.add_argument(
+        "id",
+        help="Runner ID.",
+    )
+    parser.add_argument(
+        "--search",
+        default=None,
+        help="Search for string in logs.",
+    )
+    parser.add_argument(
+        "--since",
+        default=None,
+        action=SinceAction,
+        help=(
+            "Show logs since the given time. "
+            "Accepts 'now', relative like '30m', '1h', or an ISO timestamp. "
+            "Defaults to runner start time or to '1m ago' in --follow mode."
+        ),
+    )
+    parser.add_argument(
+        "--until",
+        default=None,
+        action=SinceAction,
+        help=(
+            "Show logs until the given time. "
+            "Accepts 'now', relative like '30m', '1h', or an ISO timestamp. "
+            "Defaults to runner finish time or 'now' if it is still running."
+        ),
+    )
+    parser.add_argument(
+        "--follow",
+        "-f",
+        action="store_true",
+        help="Follow logs live. If --since is not specified, implies '--since 1m ago'.",
+    )
+    parser.add_argument(
+        "--lines",
+        "-n",
+        default=None,
+        type=str,
+        help=(
+            "Only show latest N log lines. "
+            "If '+' prefix is used, show oldest N log lines. "
+            "Ignored if --follow is used."
+        ),
+    )
+    parser.set_defaults(func=_logs)
+
+
 def add_parser(main_subparsers, parents):
     runners_help = "Manage fal runners."
     parser = main_subparsers.add_parser(
@@ -217,3 +567,4 @@ def add_parser(main_subparsers, parents):
 
     _add_kill_parser(subparsers, parents)
     _add_list_parser(subparsers, parents)
+    _add_logs_parser(subparsers, parents)

{fal-1.42.0.dist-info → fal-1.44.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fal
-Version: 1.42.0
+Version: 1.44.0
 Summary: fal is an easy-to-use Serverless Python Framework
 Author: Features & Labels <support@fal.ai>
 Requires-Python: >=3.8
@@ -25,6 +25,7 @@ Requires-Dist: pydantic!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.*,!=2.4.*,<2.11
 Requires-Dist: fastapi<1,>=0.99.1
 Requires-Dist: starlette-exporter>=0.21.0
 Requires-Dist: httpx>=0.15.4
+Requires-Dist: httpx-sse
 Requires-Dist: attrs>=21.3.0
 Requires-Dist: python-dateutil<3,>=2.8.0
 Requires-Dist: types-python-dateutil<3,>=2.8.0

{fal-1.42.0.dist-info → fal-1.44.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 fal/__init__.py,sha256=wXs1G0gSc7ZK60-bHe-B2m0l_sA6TrFk4BxY0tMoLe8,784
 fal/__main__.py,sha256=4JMK66Wj4uLZTKbF-sT3LAxOsr6buig77PmOkJCRRxw,83
-fal/_fal_version.py,sha256=ePOiaVd_k5uDeARQ7499FXrIrIEk2EdfO8TlWOOZUEo,706
+fal/_fal_version.py,sha256=ukbfyss0nlFEpMfoBksf6TuiHSAA5lYg-Uh3oNJKvXI,706
 fal/_serialization.py,sha256=npXNsFJ5G7jzBeBIyVMH01Ww34mGY4XWhHpRbSrTtnQ,7598
 fal/_version.py,sha256=1BbTFnucNC_6ldKJ_ZoC722_UkW4S9aDBSW9L0fkKAw,2315
 fal/api.py,sha256=6LkGbbqGUC4tcMBlTL-l7DBkl7t9FpZFSZY1doIdI5o,50284
-fal/app.py,sha256=4CGoHBxHQkpjpSlfYi-CCjVQ2A6BDX3qaH2JYv_zaoc,26008
+fal/app.py,sha256=dZm2PW4zLH7JBeueN-s3vvpWty66M-ujCSgN33ipXQY,26909
 fal/apps.py,sha256=pzCd2mrKl5J_4oVc40_pggvPtFahXBCdrZXWpnaEJVs,12130
 fal/config.py,sha256=1HRaOJFOAjB7fbQoEPCSH85gMvEEMIMPeupVWgrHVgU,3572
 fal/container.py,sha256=FTsa5hOW4ars-yV1lUoc0BNeIIvAZcpw7Ftyt3A4m_w,2000
@@ -33,11 +33,11 @@ fal/cli/doctor.py,sha256=8SZrYG9Ku0F6LLUHtFdKopdIgZfFkw5E3Mwrxa9KOSk,1613
 fal/cli/files.py,sha256=-j0q4g53A7CWSczGLdfeUCTSd4zXoV3pfZFdman7JOw,3450
 fal/cli/keys.py,sha256=iQVMr3WT8CUqSQT3qeCCiy6rRwoux9F-UEaC4bCwMWo,3754
 fal/cli/main.py,sha256=LDy3gze9TRsvGa4uSNc8NMFmWMLpsyoC-msteICNiso,3371
-fal/cli/parser.py,sha256=PZi5MWS4Z-3YSPe6np_F87ay4kF6gaYxlP0avByPr-0,5222
+fal/cli/parser.py,sha256=siSY1kxqczZIs3l_jLwug_BpVzY_ZqHpewON3am83Ow,6658
 fal/cli/profile.py,sha256=PAY_ffifCT71VJ8VxfDVaXPT0U1oN8drvWZDFRXwvek,6678
 fal/cli/queue.py,sha256=9Kid3zR6VOFfAdDgnqi2TNN4ocIv5Vs61ASEZnwMa9o,2713
 fal/cli/run.py,sha256=nAC12Qss4Fg1XmV0qOS9RdGNLYcdoHeRgQMvbTN4P9I,1202
-fal/cli/runners.py,sha256=AXUB2pq9Ot0VU2cOeJydSgmgTlUm4i6iNgJOClO7ZZw,6533
+fal/cli/runners.py,sha256=OWSsvk01IkwQhibewZQgC-iWMOXl43tWJSi9F81x8n4,17481
 fal/cli/secrets.py,sha256=HfIeO2IZpCEiBC6Cs5Kpi3zckfDnc7GsLwLdgj3NnPU,3085
 fal/cli/teams.py,sha256=_JcNcf659ZoLBFOxKnVP5A6Pyk1jY1vh4_xzMweYIDo,1285
 fal/console/__init__.py,sha256=lGPUuTqIM9IKTa1cyyA-MA2iZJKVHp2YydsITZVlb6g,148
@@ -143,8 +143,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.42.0.dist-info/METADATA,sha256=0SLh5bSuT_NfkPefO5SaJz0xkOu2rwg1wCpovvgk7FA,4132
-fal-1.42.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fal-1.42.0.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
-fal-1.42.0.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
-fal-1.42.0.dist-info/RECORD,,
+fal-1.44.0.dist-info/METADATA,sha256=M6TovVUSGD1FCSOEd5VoU96qC4l09iOuHiMW-ZwONJA,4157
+fal-1.44.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fal-1.44.0.dist-info/entry_points.txt,sha256=32zwTUC1U1E7nSTIGCoANQOQ3I7-qHG5wI6gsVz5pNU,37
+fal-1.44.0.dist-info/top_level.txt,sha256=r257X1L57oJL8_lM0tRrfGuXFwm66i1huwQygbpLmHw,21
+fal-1.44.0.dist-info/RECORD,,