prefect-client 3.8.5.dev6__tar.gz → 3.8.6__tar.gz

{prefect_client-3.8.5.dev6 → prefect_client-3.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prefect-client
-Version: 3.8.5.dev6
+Version: 3.8.6
 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/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.8.6"
+__build_date__ = "2026-09-14 14:19:34.965420+00:00"
+__git_commit__ = "33de4078a0f1d5efb6e4170ccb8fcc482e073155"
+__dirty__ = False

{prefect_client-3.8.5.dev6 → prefect_client-3.8.6}/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_client-3.8.5.dev6 → prefect_client-3.8.6}/src/prefect/client/attribution.py

@@ -67,4 +67,10 @@ def get_attribution_headers() -> dict[str, str]:
         if deployment_name := os.environ.get("PREFECT__DEPLOYMENT_NAME"):
             headers["X-Prefect-Deployment-Name"] = deployment_name
 
-    return headers
+    # HTTP header values cannot start or end with spaces or tabs. Normalize only
+    # the attribution values, leaving the actual flow/deployment/worker names intact.
+    return {
+        name: stripped
+        for name, value in headers.items()
+        if (stripped := value.strip(" \t"))
+    }

{prefect_client-3.8.5.dev6 → prefect_client-3.8.6}/src/prefect/flow_engine.py

@@ -1213,9 +1213,10 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
                         intent = _termination_intent()
                         if intent == "cancel":
                             self.handle_cancellation(exc)
-                        elif intent is None:
-                            self.handle_crash(exc)
-                        elif intent not in _SUPERVISOR_OWNED_INTENTS:
+                            raise
+                        if intent in _SUPERVISOR_OWNED_INTENTS:
+                            raise
+                        if intent is not None:
                             # Defensive: an unknown intent means the control
                             # listener was extended (e.g. "suspend" in a
                             # follow-up PR) without extending this dispatch.
@@ -1227,6 +1228,15 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
                                 " dispatch branch.",
                                 intent,
                             )
+                        if self.flow_run.state and self.flow_run.state.is_final():
+                            # A termination signal that lands during teardown
+                            # must not overwrite an already-reported final state
+                            self.logger.debug(
+                                "Termination signal was received after the flow"
+                                " run reached a final state",
+                                exc_info=exc,
+                            )
+                        else:
                             self.handle_crash(exc)
                         raise
                     except Exception:
@@ -1913,9 +1923,10 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
                         intent = _termination_intent()
                         if intent == "cancel":
                             await self.handle_cancellation(exc)
-                        elif intent is None:
-                            await self.handle_crash(exc)
-                        elif intent not in _SUPERVISOR_OWNED_INTENTS:
+                            raise
+                        if intent in _SUPERVISOR_OWNED_INTENTS:
+                            raise
+                        if intent is not None:
                             # Defensive: see sync engine's dispatch for why.
                             self.logger.error(
                                 "Unhandled termination intent %r; treating as"
@@ -1923,6 +1934,15 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
                                 " dispatch branch.",
                                 intent,
                             )
+                        if self.flow_run.state and self.flow_run.state.is_final():
+                            # A termination signal that lands during teardown
+                            # must not overwrite an already-reported final state
+                            self.logger.debug(
+                                "Termination signal was received after the flow"
+                                " run reached a final state",
+                                exc_info=exc,
+                            )
+                        else:
                             await self.handle_crash(exc)
                         raise
                     except Exception:

{prefect_client-3.8.5.dev6 → prefect_client-3.8.6}/src/prefect/infrastructure/provisioners/container_instance.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 import json
 import random
 import shlex
+import shutil
 import string
 import subprocess
 import time
@@ -86,7 +87,12 @@ class AzureCLI:
             json.JSONDecodeError: If output cannot be decoded as JSON when return_json is True.
         """
         try:
-            result = await run_process(shlex.split(command), check=False)
+            args = shlex.split(command)
+            # On Windows the Azure CLI launcher is `az.cmd`; resolve the executable
+            # through PATH so subprocess can find it without a shell.
+            if args:
+                args[0] = shutil.which(args[0]) or args[0]
+            result = await run_process(args, check=False)
             output = result.stdout.decode("utf-8").strip()
 
             if result.returncode != 0:

{prefect_client-3.8.5.dev6 → prefect_client-3.8.6}/src/prefect/locking/_filelock.py

@@ -28,13 +28,15 @@ def _is_pid_alive(pid: int) -> bool:
         import ctypes
 
         _PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
-        handle = ctypes.windll.kernel32.OpenProcess(  # type: ignore[attr-defined]
-            _PROCESS_QUERY_LIMITED_INFORMATION, False, pid
-        )
+        _ERROR_ACCESS_DENIED = 5
+        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)  # type: ignore[attr-defined]
+        handle = kernel32.OpenProcess(_PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
         if handle:
-            ctypes.windll.kernel32.CloseHandle(handle)  # type: ignore[attr-defined]
+            kernel32.CloseHandle(handle)
             return True
-        return False
+        # ERROR_ACCESS_DENIED means the process exists but we can't open it
+        # (another user, higher integrity, or a protected process).
+        return ctypes.get_last_error() == _ERROR_ACCESS_DENIED
 
     try:
         os.kill(pid, 0)

prefect_client-3.8.6/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.5.dev6 → prefect_client-3.8.6}/src/prefect/settings/models/root.py

@@ -279,6 +279,19 @@ class Settings(PrefectBaseSettings):
         to use default_factory. The remaining items here require access to the full Settings instance
         or have complex interdependencies that will be migrated in future PRs.
         """
+        if "profiles_path" not in self.model_fields_set:
+            self.profiles_path = self.home / "profiles.toml"
+            self.__pydantic_fields_set__.remove("profiles_path")
+        if "local_storage_path" not in self.results.model_fields_set:
+            self.results.local_storage_path = self.home / "storage"
+            self.results.__pydantic_fields_set__.remove("local_storage_path")
+        if "config_path" not in self.logging.model_fields_set:
+            self.logging.config_path = self.home / "logging.yml"
+            self.logging.__pydantic_fields_set__.remove("config_path")
+        if "memo_store_path" not in self.server.model_fields_set:
+            self.server.memo_store_path = self.home / "memo_store.toml"
+            self.server.__pydantic_fields_set__.remove("memo_store_path")
+
         if self.ui_url is None:
             self.ui_url = default_ui_url(self)
             self.__pydantic_fields_set__.remove("ui_url")

prefect_client-3.8.5.dev6/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.8.5.dev6"
-__build_date__ = "2026-09-03 08:20:42.058224+00:00"
-__git_commit__ = "d63a95a49f48f869523781116d8adf2eb4118f32"
-__dirty__ = False

prefect_client-3.8.5.dev6/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)