prefect 3.8.6.dev2__tar.gz → 3.8.6.dev4__tar.gz

{prefect-3.8.6.dev2 → prefect-3.8.6.dev4}/PKG-INFO

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

prefect-3.8.6.dev4/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.8.6.dev4"
+__build_date__ = "2026-09-11 08:20:41.198078+00:00"
+__git_commit__ = "d82220b5887fe65f6a469f4cb51124a01d02741f"
+__dirty__ = False

{prefect-3.8.6.dev2 → prefect-3.8.6.dev4}/src/prefect/blocks/core.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import collections.abc
 import hashlib
 import html
 import inspect
@@ -84,7 +85,27 @@ UnionTypes: tuple[object, ...] = (Union,)
 if hasattr(types, "UnionType"):
     # Python 3.10+ only
     UnionTypes = (*UnionTypes, types.UnionType)
-NestedTypes: tuple[type, ...] = (list, dict, tuple, *UnionTypes)
+
+
+def _nested_type_args(annotation: Any) -> tuple[Any, ...]:
+    """
+    Returns the type arguments of `annotation` that may contain nested types,
+    or an empty tuple if `annotation` is not a supported container or union
+    annotation (e.g. `Union[A, B]`, `A | B`, `list[A]`, `dict[str, A]`, or
+    `collections.abc.Sequence[A]`).
+
+    Only the yielded type is returned for `Generator` annotations; the send
+    and return types are not part of the field's data.
+    """
+    origin = get_origin(annotation)
+    if origin in UnionTypes:
+        return get_args(annotation)
+    if isinstance(origin, type) and issubclass(origin, collections.abc.Iterable):
+        args = get_args(annotation)
+        if issubclass(origin, collections.abc.Generator):
+            return args[:1]
+        return args
+    return ()
 
 
 def block_schema_to_key(schema: BlockSchema) -> str:
@@ -168,11 +189,11 @@ def _collect_secret_fields(
 ) -> None:
     """
     Recursively collects all secret fields from a given type and adds them to the
-    secrets list, supporting nested Union / Dict / Tuple / List / BaseModel fields.
+    secrets list, supporting nested Union / container / BaseModel fields.
     Also, note, this function mutates the input secrets list, thus does not return anything.
     """
-    if get_origin(type_) in NestedTypes:
-        for nested_type in get_args(type_):
+    if nested_types := _nested_type_args(type_):
+        for nested_type in nested_types:
             _collect_secret_fields(name, nested_type, secrets)
         return
     elif _is_subclass(type_, BaseModel):
@@ -302,9 +323,8 @@ def schema_extra(schema: dict[str, Any], model: type["Block"]) -> None:
             else:
                 refs[field_name] = annotation._to_block_schema_reference_dict()  # pyright: ignore[reportPrivateUsage]
 
-        if get_origin(annotation) in NestedTypes:
-            for type_ in get_args(annotation):
-                collect_block_schema_references(field_name, type_)
+        for type_ in _nested_type_args(annotation):
+            collect_block_schema_references(field_name, type_)
 
     for name, field in model.model_fields.items():
         if field.annotation is not None:
@@ -1469,10 +1489,9 @@ class Block(BaseModel, ABC):
         if Block.is_block_class(annotation):
             return True
 
-        if get_origin(annotation) in UnionTypes:
-            for annotation in get_args(annotation):
-                if Block.is_block_class(annotation):
-                    return True
+        for nested_annotation in _nested_type_args(annotation):
+            if Block.annotation_refers_to_block_class(nested_annotation):
+                return True
 
         return False
 
@@ -1510,8 +1529,8 @@ class Block(BaseModel, ABC):
                 if TYPE_CHECKING:
                     assert isinstance(coro, Coroutine)
                 await coro
-            elif get_origin(annotation) in NestedTypes:
-                for inner_annotation in get_args(annotation):
+            else:
+                for inner_annotation in _nested_type_args(annotation):
                     await register_blocks_in_annotation(inner_annotation)
 
         for field in cls.model_fields.values():
@@ -1606,8 +1625,8 @@ class Block(BaseModel, ABC):
             """Walk through the annotation and register any nested blocks."""
             if Block.is_block_class(annotation):
                 annotation.register_type_and_schema(_sync=True)
-            elif get_origin(annotation) in NestedTypes:
-                for inner_annotation in get_args(annotation):
+            else:
+                for inner_annotation in _nested_type_args(annotation):
                     register_blocks_in_annotation_sync(inner_annotation, sync_client)
 
         with get_client(sync_client=True) as sync_client:
@@ -2023,9 +2042,8 @@ class Block(BaseModel, ABC):
                 # recurse into the nested block's own fields
                 for nested in cls._collect_nested_block_types(annotation).items():
                     result.setdefault(nested[0], nested[1])
-        if get_origin(annotation) in NestedTypes:
-            for arg in get_args(annotation):
-                cls._walk_annotation_for_blocks(arg, result)
+        for arg in _nested_type_args(annotation):
+            cls._walk_annotation_for_blocks(arg, result)
 
     @classmethod
     def model_json_schema(

{prefect-3.8.6.dev2 → prefect-3.8.6.dev4}/src/prefect/server/AGENTS.md

@@ -49,6 +49,9 @@ alembic_revision("description")      # Create a new migration
 
 ## Orchestration Pitfalls
 
+- **Deployment concurrency has a TLA+ model.** Before changing its behavior,
+  review `formal/tla/deployment-concurrency/README.md` and its mapped regressions.
+
 - **Pydantic v2 treats null JSON fields as explicitly set.** When a worker sends a state update with `field: null`, Pydantic v2 sets that field to `None`, silently overwriting any existing value. To preserve `state_details` fields across transitions (e.g. `deployment_concurrency_lease_id`), add a `FlowRunUniversalTransform` to `CoreFlowPolicy` that copies the field forward when the proposed state has `None`. See `PreserveDeploymentConcurrencyLeaseId` in `orchestration/core_policy.py` as the canonical pattern. Any new field added to `state_details` that workers may omit faces this same risk.
 
 - **`update_deployment` uses `model_fields_set` to distinguish explicit `None` from "not provided" for `work_pool_name`.** In `models/deployments.py`, when `deployment.work_pool_name is None` AND `"work_pool_name" in deployment.model_fields_set`, the work queue association is cleared (`work_queue_id = None`). If `work_pool_name` is simply absent from `model_fields_set`, the existing work pool association is left intact. This is the intentional counterpart to the Pydantic v2 null-overwrite pitfall above — here the explicit `model_fields_set` entry signals *desired* clearing. `RunnerDeployment` factory methods omit `None`-valued work pool fields from constructor kwargs; `Runner.add_flow()` then post-assigns `None` to opt into clearing. Follow this same pattern for any future field that should distinguish "clear it" from "leave it alone."

prefect-3.8.6.dev4/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-3.8.6.dev2 → prefect-3.8.6.dev4}/src/prefect/server/database/query_components.py

@@ -32,7 +32,11 @@ from prefect.server.exceptions import FlowRunGraphTooLarge, ObjectNotFoundError
 from prefect.server.schemas.graph import Edge, Graph, GraphArtifact, GraphState, Node
 from prefect.server.schemas.states import StateType
 from prefect.server.utilities.database import UUID as UUIDTypeDecorator
-from prefect.server.utilities.database import Timestamp, bindparams_from_clause
+from prefect.server.utilities.database import (
+    Timestamp,
+    bindparams_from_clause,
+    date_diff_seconds,
+)
 from prefect.types._datetime import DateTime
 
 T = TypeVar("T", infer_variance=True)
@@ -94,12 +98,6 @@ class BaseQueryComponents(ABC):
     def cast_to_json(self, json_obj: sa.ColumnElement[T]) -> sa.ColumnElement[T]:
         """casts to JSON object if necessary"""
 
-    @abstractmethod
-    def build_json_object(
-        self, *args: Union[str, sa.ColumnElement[Any]]
-    ) -> sa.ColumnElement[Any]:
-        """builds a JSON object from sequential key-value pairs"""
-
     @abstractmethod
     def json_arr_agg(self, json_array: sa.ColumnElement[Any]) -> sa.ColumnElement[Any]:
         """aggregates a JSON array"""
@@ -107,12 +105,12 @@ class BaseQueryComponents(ABC):
     # --- dialect-optimized subqueries
 
     @abstractmethod
-    def make_timestamp_intervals(
+    def make_timestamp_bucket_index(
         self,
+        timestamp: sa.ColumnElement[Any] | orm.InstrumentedAttribute[Any],
         start_time: datetime.datetime,
-        end_time: datetime.datetime,
         interval: datetime.timedelta,
-    ) -> sa.Select[tuple[datetime.datetime, datetime.datetime]]: ...
+    ) -> sa.ColumnElement[int]: ...
 
     @abstractmethod
     def set_state_id_on_inserted_flow_runs_statement(
@@ -554,35 +552,23 @@ class AsyncPostgresQueryComponents(BaseQueryComponents):
     def cast_to_json(self, json_obj: sa.ColumnElement[T]) -> sa.ColumnElement[T]:
         return json_obj
 
-    def build_json_object(
-        self, *args: Union[str, sa.ColumnElement[Any]]
-    ) -> sa.ColumnElement[Any]:
-        return sa.func.jsonb_build_object(*args)
-
     def json_arr_agg(self, json_array: sa.ColumnElement[Any]) -> sa.ColumnElement[Any]:
         return sa.func.jsonb_agg(json_array)
 
     # --- Postgres-optimized subqueries
 
-    def make_timestamp_intervals(
+    def make_timestamp_bucket_index(
         self,
+        timestamp: sa.ColumnElement[Any] | orm.InstrumentedAttribute[Any],
         start_time: datetime.datetime,
-        end_time: datetime.datetime,
         interval: datetime.timedelta,
-    ) -> sa.Select[tuple[datetime.datetime, datetime.datetime]]:
-        dt = sa.func.generate_series(
-            start_time, end_time, interval, type_=Timestamp()
-        ).column_valued("dt")
-        return (
-            sa.select(
-                dt.label("interval_start"),
-                sa.type_coerce(
-                    dt + sa.bindparam("interval", interval, type_=sa.Interval()),
-                    type_=Timestamp(),
-                ).label("interval_end"),
-            )
-            .where(dt < end_time)
-            .limit(500)  # grab at most 500 intervals
+    ) -> sa.ColumnElement[int]:
+        start = sa.bindparam(None, start_time, type_=Timestamp(), unique=True)
+        return sa.cast(
+            sa.func.floor(
+                date_diff_seconds(timestamp, start) / interval.total_seconds()
+            ),
+            sa.Integer,
         )
 
     @db_injector
@@ -803,48 +789,25 @@ class AioSqliteQueryComponents(BaseQueryComponents):
     def cast_to_json(self, json_obj: sa.ColumnElement[T]) -> sa.ColumnElement[T]:
         return sa.func.json(json_obj)
 
-    def build_json_object(
-        self, *args: Union[str, sa.ColumnElement[Any]]
-    ) -> sa.ColumnElement[Any]:
-        return sa.func.json_object(*args)
-
     def json_arr_agg(self, json_array: sa.ColumnElement[Any]) -> sa.ColumnElement[Any]:
         return sa.func.json_group_array(json_array)
 
     # --- Sqlite-optimized subqueries
 
-    def make_timestamp_intervals(
+    def make_timestamp_bucket_index(
         self,
+        timestamp: sa.ColumnElement[Any] | orm.InstrumentedAttribute[Any],
         start_time: datetime.datetime,
-        end_time: datetime.datetime,
         interval: datetime.timedelta,
-    ) -> sa.Select[tuple[datetime.datetime, datetime.datetime]]:
-        start = sa.bindparam("start_time", start_time, Timestamp)
-        # subtract interval because recursive where clauses are effectively evaluated on a t-1 lag
-        stop = sa.bindparam("end_time", end_time - interval, Timestamp)
-        step = sa.bindparam("interval", interval, sa.Interval)
-
-        one = sa.literal(1, literal_execute=True)
-
-        # recursive CTE to mimic the behavior of `generate_series`, which is
-        # only available as a compiled extension
-        base_case = sa.select(
-            start.label("interval_start"),
-            sa.func.date_add(start, step).label("interval_end"),
-            one.label("counter"),
-        ).cte(recursive=True)
-        recursive_case = sa.select(
-            base_case.c.interval_end,
-            sa.func.date_add(base_case.c.interval_end, step),
-            base_case.c.counter + one,
-        ).where(
-            base_case.c.interval_start < stop,
-            # don't compute more than 500 intervals
-            base_case.c.counter < 500,
+    ) -> sa.ColumnElement[int]:
+        start = sa.bindparam(None, start_time, type_=Timestamp(), unique=True)
+        # SQLite's julianday arithmetic introduces small floating-point errors;
+        # rounding to its millisecond precision avoids mis-bucketing boundaries.
+        seconds = sa.func.round(date_diff_seconds(timestamp, start), 3)
+        return sa.cast(
+            sa.func.floor(seconds / interval.total_seconds()),
+            sa.Integer,
         )
-        cte = base_case.union_all(recursive_case)
-
-        return sa.select(cte.c.interval_start, cte.c.interval_end)
 
     @db_injector
     def set_state_id_on_inserted_flow_runs_statement(

prefect-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:21:19.997200+00:00"
-__git_commit__ = "5cbe701897870afcd48bb7002024250102ac9b69"
-__dirty__ = False

prefect-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)