prefect-client 3.8.6.dev2__tar.gz → 3.8.6.dev3__tar.gz

{prefect_client-3.8.6.dev2 → prefect_client-3.8.6.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prefect-client
-Version: 3.8.6.dev2
+Version: 3.8.6.dev3
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io

prefect_client-3.8.6.dev3/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.8.6.dev3"
+__build_date__ = "2026-09-10 08:20:04.292755+00:00"
+__git_commit__ = "9bb595651aa77701641630f4f56e99f1d7f91683"
+__dirty__ = False

prefect_client-3.8.6.dev3/src/prefect/server/api/run_history.py

@@ -0,0 +1,155 @@
+"""
+Utilities for querying flow and task run history.
+"""
+
+import datetime
+from collections import defaultdict
+from typing import TYPE_CHECKING, Any, List, Optional
+
+import pydantic
+import sqlalchemy as sa
+from typing_extensions import Literal
+
+import prefect.server.models as models
+import prefect.server.schemas as schemas
+from prefect.logging import get_logger
+from prefect.server.database import PrefectDBInterface, db_injector
+from prefect.types import DateTime
+
+if TYPE_CHECKING:
+    import logging
+
+logger: "logging.Logger" = get_logger("server.api")
+
+
+@db_injector
+async def run_history(
+    db: PrefectDBInterface,
+    session: sa.orm.Session,
+    run_type: Literal["flow_run", "task_run"],
+    history_start: DateTime,
+    history_end: DateTime,
+    history_interval: datetime.timedelta,
+    flows: Optional[schemas.filters.FlowFilter] = None,
+    flow_runs: Optional[schemas.filters.FlowRunFilter] = None,
+    task_runs: Optional[schemas.filters.TaskRunFilter] = None,
+    deployments: Optional[schemas.filters.DeploymentFilter] = None,
+    work_pools: Optional[schemas.filters.WorkPoolFilter] = None,
+    work_queues: Optional[schemas.filters.WorkQueueFilter] = None,
+) -> list[schemas.responses.HistoryResponse]:
+    """
+    Produce a history of runs aggregated by interval and state
+    """
+
+    # normalize to stdlib timedeltas; pendulum intervals, which the timestamp
+    # arguments produce when they are pendulum instances, do not support floor
+    # division by a timedelta
+    history_interval = datetime.timedelta(seconds=history_interval.total_seconds())
+
+    # SQLite has issues with very small intervals
+    # (by 0.001 seconds it stops incrementing the interval)
+    if history_interval < datetime.timedelta(seconds=1):
+        raise ValueError("History interval must not be less than 1 second.")
+
+    # prepare run-specific models
+    if run_type == "flow_run":
+        run_model = db.FlowRun
+        run_filter_function = models.flow_runs._apply_flow_run_filters
+    elif run_type == "task_run":
+        run_model = db.TaskRun
+        run_filter_function = models.task_runs._apply_task_run_filters
+    else:
+        raise ValueError(
+            f"Unknown run type {run_type!r}. Expected 'flow_run' or 'task_run'."
+        )
+
+    elapsed = datetime.timedelta(seconds=(history_end - history_start).total_seconds())
+    interval_count = (
+        min(-((-elapsed) // history_interval), 500)
+        if elapsed > datetime.timedelta(0)
+        else 0
+    )
+    if interval_count == 0:
+        return []
+
+    history_query_end = history_start + interval_count * history_interval
+
+    # apply filters to the flow runs (and related states)
+    runs = await run_filter_function(
+        db,
+        sa.select(
+            run_model.id,
+            run_model.expected_start_time,
+            run_model.estimated_run_time,
+            run_model.estimated_start_time_delta,
+            run_model.state_type,
+            run_model.state_name,
+            db.queries.make_timestamp_bucket_index(
+                run_model.expected_start_time,
+                history_start,
+                history_interval,
+            ).label("bucket_index"),
+        )
+        .select_from(run_model)
+        .where(
+            run_model.expected_start_time >= history_start,
+            run_model.expected_start_time < history_query_end,
+        ),
+        flow_filter=flows,
+        flow_run_filter=flow_runs,
+        task_run_filter=task_runs,
+        deployment_filter=deployments,
+        work_pool_filter=work_pools,
+        work_queue_filter=work_queues,
+    )
+    runs = runs.alias("runs")
+
+    counts = sa.select(
+        runs.c.bucket_index,
+        runs.c.state_type,
+        runs.c.state_name,
+        sa.func.count(runs.c.id).label("count_runs"),
+        # estimated run times only includes positive run times (to avoid any unexpected corner cases)
+        sa.func.sum(
+            sa.func.greatest(0, sa.extract("epoch", runs.c.estimated_run_time))
+        ).label("sum_estimated_run_time"),
+        # estimated lateness is the sum of any positive start time deltas
+        sa.func.sum(
+            sa.func.greatest(0, sa.extract("epoch", runs.c.estimated_start_time_delta))
+        ).label("sum_estimated_lateness"),
+    ).group_by(
+        runs.c.bucket_index,
+        runs.c.state_type,
+        runs.c.state_name,
+    )
+
+    # issue the query
+    result = await session.execute(counts)
+    states_by_bucket: dict[int, list[dict[str, Any]]] = defaultdict(list)
+    for record in result.mappings():
+        states_by_bucket[record["bucket_index"]].append(
+            {
+                "state_type": record["state_type"],
+                "state_name": record["state_name"],
+                "count_runs": record["count_runs"],
+                "sum_estimated_run_time": record["sum_estimated_run_time"],
+                "sum_estimated_lateness": record["sum_estimated_lateness"],
+            }
+        )
+
+    records = [
+        {
+            "interval_start": (history_start + i * history_interval).astimezone(
+                datetime.timezone.utc
+            ),
+            "interval_end": (history_start + (i + 1) * history_interval).astimezone(
+                datetime.timezone.utc
+            ),
+            "states": states_by_bucket[i],
+        }
+        for i in range(interval_count)
+    ]
+
+    return pydantic.TypeAdapter(
+        List[schemas.responses.HistoryResponse]
+    ).validate_python(records)

prefect_client-3.8.6.dev2/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.8.6.dev2"
-__build_date__ = "2026-09-09 08:20:10.582741+00:00"
-__git_commit__ = "5cbe701897870afcd48bb7002024250102ac9b69"
-__dirty__ = False

prefect_client-3.8.6.dev2/src/prefect/server/api/run_history.py

@@ -1,170 +0,0 @@
-"""
-Utilities for querying flow and task run history.
-"""
-
-import datetime
-import json
-from typing import TYPE_CHECKING, List, Optional
-
-import pydantic
-import sqlalchemy as sa
-from typing_extensions import Literal
-
-import prefect.server.models as models
-import prefect.server.schemas as schemas
-from prefect.logging import get_logger
-from prefect.server.database import PrefectDBInterface, db_injector
-from prefect.types import DateTime
-
-if TYPE_CHECKING:
-    import logging
-
-logger: "logging.Logger" = get_logger("server.api")
-
-
-@db_injector
-async def run_history(
-    db: PrefectDBInterface,
-    session: sa.orm.Session,
-    run_type: Literal["flow_run", "task_run"],
-    history_start: DateTime,
-    history_end: DateTime,
-    history_interval: datetime.timedelta,
-    flows: Optional[schemas.filters.FlowFilter] = None,
-    flow_runs: Optional[schemas.filters.FlowRunFilter] = None,
-    task_runs: Optional[schemas.filters.TaskRunFilter] = None,
-    deployments: Optional[schemas.filters.DeploymentFilter] = None,
-    work_pools: Optional[schemas.filters.WorkPoolFilter] = None,
-    work_queues: Optional[schemas.filters.WorkQueueFilter] = None,
-) -> list[schemas.responses.HistoryResponse]:
-    """
-    Produce a history of runs aggregated by interval and state
-    """
-
-    # SQLite has issues with very small intervals
-    # (by 0.001 seconds it stops incrementing the interval)
-    if history_interval < datetime.timedelta(seconds=1):
-        raise ValueError("History interval must not be less than 1 second.")
-
-    # prepare run-specific models
-    if run_type == "flow_run":
-        run_model = db.FlowRun
-        run_filter_function = models.flow_runs._apply_flow_run_filters
-    elif run_type == "task_run":
-        run_model = db.TaskRun
-        run_filter_function = models.task_runs._apply_task_run_filters
-    else:
-        raise ValueError(
-            f"Unknown run type {run_type!r}. Expected 'flow_run' or 'task_run'."
-        )
-
-    # create a CTE for timestamp intervals
-    intervals = db.queries.make_timestamp_intervals(
-        history_start,
-        history_end,
-        history_interval,
-    ).cte("intervals")
-
-    # apply filters to the flow runs (and related states)
-    runs = (
-        await run_filter_function(
-            db,
-            sa.select(
-                run_model.id,
-                run_model.expected_start_time,
-                run_model.estimated_run_time,
-                run_model.estimated_start_time_delta,
-                run_model.state_type,
-                run_model.state_name,
-            ).select_from(run_model),
-            flow_filter=flows,
-            flow_run_filter=flow_runs,
-            task_run_filter=task_runs,
-            deployment_filter=deployments,
-            work_pool_filter=work_pools,
-            work_queue_filter=work_queues,
-        )
-    ).alias("runs")
-    # outer join intervals to the filtered runs to create a dataset composed of
-    # every interval and the aggregate of all its runs. The runs aggregate is represented
-    # by a descriptive JSON object
-    counts = (
-        sa.select(
-            intervals.c.interval_start,
-            intervals.c.interval_end,
-            # build a JSON object, ignoring the case where the count of runs is 0
-            sa.case(
-                (sa.func.count(runs.c.id) == 0, None),
-                else_=db.queries.build_json_object(
-                    "state_type",
-                    runs.c.state_type,
-                    "state_name",
-                    runs.c.state_name,
-                    "count_runs",
-                    sa.func.count(runs.c.id),
-                    # estimated run times only includes positive run times (to avoid any unexpected corner cases)
-                    "sum_estimated_run_time",
-                    sa.func.sum(
-                        sa.func.greatest(
-                            0, sa.extract("epoch", runs.c.estimated_run_time)
-                        )
-                    ),
-                    # estimated lateness is the sum of any positive start time deltas
-                    "sum_estimated_lateness",
-                    sa.func.sum(
-                        sa.func.greatest(
-                            0, sa.extract("epoch", runs.c.estimated_start_time_delta)
-                        )
-                    ),
-                ),
-            ).label("state_agg"),
-        )
-        .select_from(intervals)
-        .join(
-            runs,
-            sa.and_(
-                runs.c.expected_start_time >= intervals.c.interval_start,
-                runs.c.expected_start_time < intervals.c.interval_end,
-            ),
-            isouter=True,
-        )
-        .group_by(
-            intervals.c.interval_start,
-            intervals.c.interval_end,
-            runs.c.state_type,
-            runs.c.state_name,
-        )
-    ).alias("counts")
-
-    # aggregate all state-aggregate objects into a single array for each interval,
-    # ensuring that intervals with no runs have an empty array
-    query = (
-        sa.select(
-            counts.c.interval_start,
-            counts.c.interval_end,
-            sa.func.coalesce(
-                db.queries.json_arr_agg(
-                    db.queries.cast_to_json(counts.c.state_agg)
-                ).filter(counts.c.state_agg.is_not(None)),
-                sa.literal("[]", literal_execute=True),
-            ).label("states"),
-        )
-        .group_by(counts.c.interval_start, counts.c.interval_end)
-        .order_by(counts.c.interval_start)
-        # return no more than 500 bars
-        .limit(500)
-    )
-
-    # issue the query
-    result = await session.execute(query)
-    records = result.mappings()
-
-    # load and parse the record if the database returns JSON as strings
-    if db.queries.uses_json_strings:
-        records = [dict(r) for r in records]
-        for r in records:
-            r["states"] = json.loads(r["states"])
-
-    return pydantic.TypeAdapter(
-        List[schemas.responses.HistoryResponse]
-    ).validate_python(records)