prefect-client 3.8.9.dev5__tar.gz → 3.8.9.dev7__tar.gz

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prefect-client
-Version: 3.8.9.dev5
+Version: 3.8.9.dev7
 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.9.dev7/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.8.9.dev7"
+__build_date__ = "2026-10-20 08:19:07.991479+00:00"
+__git_commit__ = "817bc93b6e828459e6853fa8b51ddba52515ad16"
+__dirty__ = False

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/src/prefect/_internal/pydantic/v2_schema.py

@@ -85,6 +85,14 @@ def process_v2_params(
     # still ensure 'position' is always set
     extra.setdefault("position", position)
 
+    # `*args` and `**kwargs` accept any number of values, including none
+    if param.kind is inspect.Parameter.VAR_POSITIONAL:
+        type_ = list[type_]
+        default_value = []
+    elif param.kind is inspect.Parameter.VAR_KEYWORD:
+        type_ = dict[str, type_]
+        default_value = {}
+
     field = pydantic.Field(
         default=... if default_value is param.empty else default_value,
         title=param.name,

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/src/prefect/events/__init__.py

@@ -42,6 +42,7 @@ from .actions import (
     PauseAutomation,
     ResumeAutomation,
     DeclareIncident,
+    UnknownAction,
 )
 from .clients import get_events_client, get_events_subscriber
 from .subscribers import FlowRunSubscriber
@@ -90,6 +91,7 @@ __all__ = [
     "PauseAutomation",
     "ResumeAutomation",
     "DeclareIncident",
+    "UnknownAction",
     "emit_event",
     "get_events_client",
     "get_events_subscriber",

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/src/prefect/events/actions.py

@@ -1,9 +1,16 @@
 import abc
 from datetime import timedelta
-from typing import Any, Dict, Optional, Union
+from typing import Annotated, Any, ClassVar, Dict, Optional, Union, get_args
 from uuid import UUID
 
-from pydantic import Field, model_validator
+from pydantic import (
+    ConfigDict,
+    Discriminator,
+    Field,
+    Tag,
+    field_validator,
+    model_validator,
+)
 from typing_extensions import Literal, Self, TypeAlias
 
 from prefect._internal.schemas.bases import PrefectBaseModel
@@ -314,3 +321,56 @@ ActionTypes: TypeAlias = Union[
     # Prefect Cloud only
     DeclareIncident,
 ]
+
+_KNOWN_ACTION_TYPES: frozenset[str] = frozenset(
+    action.model_fields["type"].default for action in get_args(ActionTypes)
+)
+
+
+class UnknownAction(Action):
+    """An action whose type this version of Prefect does not recognize.
+
+    Prefect Cloud can add action types before a client release knows about
+    them. Reading an automation that uses one of these types returns this
+    model instead of failing. The model keeps every field of the action, so
+    updating the automation sends the action back unchanged.
+    """
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="allow")
+
+    type: str = Field(
+        json_schema_extra={"not": {"enum": sorted(_KNOWN_ACTION_TYPES)}},
+    )
+
+    @field_validator("type")
+    @classmethod
+    def _type_is_not_known(cls, value: str) -> str:
+        if value in _KNOWN_ACTION_TYPES:
+            raise ValueError(
+                f"{value!r} is a known action type and cannot be an UnknownAction"
+            )
+        return value
+
+
+def _action_discriminator(value: Any) -> str:
+    """Sends an action with an unrecognized `type` to `UnknownAction` and every
+    other action, including one with no `type`, to `ActionTypes`."""
+    if isinstance(value, UnknownAction):
+        return "unknown"
+    action_type = (
+        value.get("type") if isinstance(value, dict) else getattr(value, "type", None)
+    )
+    if isinstance(action_type, str) and action_type not in _KNOWN_ACTION_TYPES:
+        return "unknown"
+    return "known"
+
+
+ActionTypesOrUnknown: TypeAlias = Annotated[
+    Union[
+        Annotated[ActionTypes, Tag("known")],
+        Annotated[UnknownAction, Tag("unknown")],
+    ],
+    Discriminator(_action_discriminator),
+]
+"""The action types an automation read from the API may contain: any of
+`ActionTypes`, or an `UnknownAction` for a type this version does not know"""

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/src/prefect/events/schemas/automations.py

@@ -22,17 +22,21 @@ from pydantic import (
     Field,
     PrivateAttr,
     Tag,
+    TypeAdapter,
+    ValidationError,
     field_validator,
     model_validator,
 )
 from typing_extensions import Self, TypeAlias
 
 from prefect._internal.schemas.bases import PrefectBaseModel
-from prefect.events.actions import ActionTypes, RunDeployment
+from prefect.events.actions import ActionTypes, ActionTypesOrUnknown, RunDeployment
 from prefect.utilities.collections import AutoEnum
 
 from .events import ResourceSpecification
 
+_timedelta_adapter: TypeAdapter[timedelta] = TypeAdapter(timedelta)
+
 # Dict form accepted by ResourceSpecification via Pydantic coercion
 ResourceSpecificationDict: TypeAlias = Dict[str, Union[str, List[str]]]
 
@@ -96,7 +100,7 @@ class Trigger(PrefectBaseModel, abc.ABC, extra="ignore"):  # type: ignore[call-a
             description=getattr(self, "description", ""),
             enabled=getattr(self, "enabled", True),
             trigger=trigger,
-            actions=self.actions(),
+            actions=list(self.actions()),
             owner_resource=self.owner_resource(),
         )
 
@@ -220,8 +224,15 @@ class EventTrigger(ResourceTrigger):
         posture: Optional[Posture] = data.get("posture")
         within: Optional[timedelta] = data.get("within")
 
-        if isinstance(within, (int, float)):
-            within = timedelta(seconds=within)
+        if within is not None and not isinstance(within, timedelta):
+            # Parse the raw value the same way the field would, so that every
+            # form pydantic accepts for a timedelta reaches the comparisons
+            # below as a timedelta.
+            try:
+                within = _timedelta_adapter.validate_python(within)
+            except ValidationError:
+                # The field validation reports the unparsable value.
+                return data
 
         if posture == Posture.Proactive:
             if not within or within == timedelta(0):
@@ -486,17 +497,17 @@ class AutomationCore(PrefectBaseModel, extra="ignore"):  # type: ignore[call-arg
         ),
     )
 
-    actions: List[ActionTypes] = Field(
+    actions: List[ActionTypesOrUnknown] = Field(
         default=...,
         description="The actions to perform when this Automation triggers",
     )
 
-    actions_on_trigger: List[ActionTypes] = Field(
+    actions_on_trigger: List[ActionTypesOrUnknown] = Field(
         default_factory=list,
         description="The actions to perform when an Automation goes into a triggered state",
     )
 
-    actions_on_resolve: List[ActionTypes] = Field(
+    actions_on_resolve: List[ActionTypesOrUnknown] = Field(
         default_factory=list,
         description="The actions to perform when an Automation goes into a resolving state",
     )

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/src/prefect/flow_runs.py

@@ -273,7 +273,7 @@ async def apause_flow_run(
             if wait_for_input:
                 # The flow run wanted input, so we need to load it and return it
                 # to the user.
-                await wait_for_input.aload(run_input_keyset)
+                return await wait_for_input.aload(run_input_keyset)
 
             return
 

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/src/prefect/flows.py

@@ -578,11 +578,11 @@ class Flow(Generic[P, R]):
                 else self.cache_result_in_memory
             ),
             log_prints=log_prints if log_prints is not NotSet else self.log_prints,
-            on_completion=on_completion or self.on_completion_hooks,
-            on_failure=on_failure or self.on_failure_hooks,
-            on_cancellation=on_cancellation or self.on_cancellation_hooks,
-            on_crashed=on_crashed or self.on_crashed_hooks,
-            on_running=on_running or self.on_running_hooks,
+            on_completion=on_completion or copy(self.on_completion_hooks),
+            on_failure=on_failure or copy(self.on_failure_hooks),
+            on_cancellation=on_cancellation or copy(self.on_cancellation_hooks),
+            on_crashed=on_crashed or copy(self.on_crashed_hooks),
+            on_running=on_running or copy(self.on_running_hooks),
         )
         new_flow._storage = self._storage
         new_flow._entrypoint = self._entrypoint

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/src/prefect/futures.py

@@ -584,7 +584,7 @@ class PrefectFutureList(list[PrefectFuture[R]], Iterator[PrefectFuture[R]]):
         timeout_message = (
             f"Timed out waiting for all futures to complete within {timeout} seconds"
         )
-        deadline = time.monotonic() + timeout if timeout is not None else None
+        deadline = time.monotonic() + timeout if timeout else None
 
         try:
             # `as_completed` de-duplicates internally; each unique future is
@@ -638,7 +638,7 @@ def as_completed(
     pending = unique_futures
     deadline: float | None = None
     try:
-        with timeout_context(timeout, timeout_exc_type=_WaitTimeoutError):
+        with timeout_context(timeout or None, timeout_exc_type=_WaitTimeoutError):
             done = {f for f in unique_futures if f._final_state}  # type: ignore[privateUsage]
             pending = unique_futures - done
             yield from done

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/src/prefect/task_engine.py

@@ -16,6 +16,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     AsyncGenerator,
+    Awaitable,
     Callable,
     Coroutine,
     Generator,
@@ -459,12 +460,14 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                     message=f"Task run encountered unexpected exception: {repr(exc_or_state)}",
                 )
             )
-            if inspect.iscoroutinefunction(retry_condition):
-                should_retry = run_coro_as_sync(
-                    retry_condition(self.task, self.task_run, state)
-                )
-            elif inspect.isfunction(retry_condition):
+            if callable(retry_condition):
                 should_retry = retry_condition(self.task, self.task_run, state)
+                if inspect.isawaitable(should_retry):
+
+                    async def await_retry_condition(result: Awaitable[bool]) -> bool:
+                        return await result
+
+                    should_retry = run_coro_as_sync(await_retry_condition(should_retry))
             else:
                 should_retry = not retry_condition
             return should_retry
@@ -1077,10 +1080,10 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                     message=f"Task run encountered unexpected exception: {repr(exc_or_state)}",
                 )
             )
-            if inspect.iscoroutinefunction(retry_condition):
-                should_retry = await retry_condition(self.task, self.task_run, state)
-            elif inspect.isfunction(retry_condition):
+            if callable(retry_condition):
                 should_retry = retry_condition(self.task, self.task_run, state)
+                if inspect.isawaitable(should_retry):
+                    should_retry = await should_retry
             else:
                 should_retry = not retry_condition
             return should_retry

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/src/prefect/tasks.py

@@ -791,7 +791,7 @@ class Task(Generic[P, R]):
             fn=self.fn,
             name=name or self.name,
             description=description or self.description,
-            tags=tags or copy(self.tags),
+            tags=tags if tags is not None else copy(self.tags),
             version=self.version,
             cache_policy=cache_policy
             if cache_policy is not NotSet
@@ -842,9 +842,9 @@ class Task(Generic[P, R]):
             refresh_cache=(
                 refresh_cache if refresh_cache is not NotSet else self.refresh_cache
             ),
-            on_completion=on_completion or self.on_completion_hooks,
-            on_failure=on_failure or self.on_failure_hooks,
-            on_running=on_running or self.on_running_hooks,
+            on_completion=on_completion or copy(self.on_completion_hooks),
+            on_failure=on_failure or copy(self.on_failure_hooks),
+            on_running=on_running or copy(self.on_running_hooks),
             on_rollback=copy(self.on_rollback_hooks),
             on_commit=copy(self.on_commit_hooks),
             retry_condition_fn=retry_condition_fn or self.retry_condition_fn,
@@ -2258,9 +2258,10 @@ class MaterializingTask(Task[P, R]):
                 continue
 
             attr_name = param_to_attr.get(param_name, param_name)
-            init_kwargs[param_name] = task_kwargs.get(
-                param_name, getattr(self, attr_name)
-            )
+            value = getattr(self, attr_name)
+            if attr_name.endswith("_hooks"):
+                value = copy(value)
+            init_kwargs[param_name] = task_kwargs.get(param_name, value)
 
         return MaterializingTask(
             fn=self.fn,

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/src/prefect/utilities/callables/AGENTS.md

@@ -17,6 +17,7 @@ Inspects user-written flow/task functions to produce:
 ## Pitfalls
 
 - **`parameters_to_args_kwargs` adjusts the positional/keyword split based on the wrapper's signature, not the wrapped function's.** For `@functools.wraps`-decorated callables, it inspects the *wrapper* (via `follow_wrapped=False`) to count how many positional slots are actually available and routes excess parameters to `**kwargs`. This means `args` and `kwargs` from this function are shaped for the *wrapper* call, not the inner function — callers must not assume all POSITIONAL_OR_KEYWORD parameters end up in `args`.
-- **`parameters_to_args_kwargs` skips the positional-to-keyword rewrite entirely when the function signature contains `*args`.** Inserting KEYWORD_ONLY parameters before a VAR_POSITIONAL parameter is invalid in Python, so the original signature is used as-is in that case.
+- **`parameters_to_args_kwargs` skips the positional-to-keyword rewrite entirely when the function signature contains `*args`.** Inserting KEYWORD_ONLY parameters before a VAR_POSITIONAL parameter is invalid in Python, so the original signature is used as-is in that case. When `*args` values are given but earlier defaulted positional parameters are omitted, those parameters are filled with their defaults so the values bind positionally (an empty `*args` is dropped instead). Any non-string, non-mapping iterable counts as `*args` values and is converted to a tuple; other values (`None`, scalars, strings, mappings) are passed through untouched so validation rejects them.
 - **Passing the same key in both an explicit parameter and a `**kwargs` dict raises `TypeError`.** `parameters_to_args_kwargs` detects when a VAR_KEYWORD (`**kwargs`) dict contains a key that also appears as an explicit parameter and raises rather than silently letting the variadic entry win. Exception: POSITIONAL_ONLY parameters are exempt because `fn(1, **{'a': 2})` is legal when `a` is positional-only.
 - **`generate_parameter_schema` silently downgrades unsupported parameter types to `Any`.** When a parameter's type raises `ValueError`, `TypeError`, or `PydanticInvalidForJsonSchema` during JSON schema generation (e.g., `Callable`, custom types Pydantic can't serialize), the type is replaced with `Any` in the output schema without warning. If a flow parameter shows up as `Any` in the schema, the declared type is not JSON-schema-compatible.
+- **Variadic parameters are optional collections in the schema.** `*args: T` is an `array` of `T` defaulting to `[]` and `**kwargs: T` an `object` with `T` values defaulting to `{}`. The explicit defaults keep schema preprocessing from making them nullable, since `None` can't be unpacked. `process_v1_params` and `process_v2_params` must stay in sync.

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/src/prefect/utilities/callables/__init__.py

@@ -7,7 +7,7 @@ import importlib.util
 import inspect
 import warnings
 from collections import OrderedDict
-from collections.abc import Iterable
+from collections.abc import Iterable, Mapping
 from functools import partial
 from logging import Logger
 from pathlib import Path
@@ -83,12 +83,21 @@ def get_call_parameters(
     # a FieldInfo object when the user writes `param: T = Field(default=..., ...)`.
     # Unwrap those to their actual default values.
     for key, value in arguments.items():
-        if isinstance(value, pydantic.fields.FieldInfo):
-            arguments[key] = value.default
+        arguments[key] = _resolve_field_info_default(value)
 
     return arguments
 
 
+def _resolve_field_info_default(value: Any) -> Any:
+    """
+    Resolve a `pydantic.Field(...)` used as a signature default to its actual
+    default value. Other values are returned unchanged.
+    """
+    if isinstance(value, pydantic.fields.FieldInfo):
+        return value.default
+    return value
+
+
 def get_parameter_defaults(
     fn: Callable[..., Any],
 ) -> dict[str, Any]:
@@ -101,7 +110,7 @@ def get_parameter_defaults(
 
     for name, param in signature.parameters.items():
         if param.default is not signature.empty:
-            parameter_defaults[name] = param.default
+            parameter_defaults[name] = _resolve_field_info_default(param.default)
 
     return parameter_defaults
 
@@ -289,12 +298,51 @@ def parameters_to_args_kwargs(
     # Skip the rewrite entirely when the exposed signature contains a
     # VAR_POSITIONAL (*args) parameter because inserting KEYWORD_ONLY params
     # before *args would produce an invalid parameter ordering.
-    has_var_positional = any(
-        p.kind == inspect.Parameter.VAR_POSITIONAL for p in sig.parameters.values()
+    var_positional = next(
+        (
+            p
+            for p in sig.parameters.values()
+            if p.kind == inspect.Parameter.VAR_POSITIONAL
+        ),
+        None,
     )
 
-    if has_var_positional:
+    if var_positional is not None:
         modified_sig = sig
+        # Values for `*args` can only be passed positionally, so every positional
+        # parameter before it must be bound too, otherwise `*args` is passed as a
+        # keyword. Drop an empty `*args` and fill omitted parameters with their
+        # defaults otherwise. Other values, such as `None`, strings, or mappings,
+        # are left for validation to reject.
+        var_positional_value = parameters.get(var_positional.name)
+        if isiterable(var_positional_value) and not isinstance(
+            var_positional_value, Mapping
+        ):
+            var_positional_values = tuple(cast(Iterable[Any], var_positional_value))
+            if not var_positional_values:
+                parameters = {
+                    k: v for k, v in parameters.items() if k != var_positional.name
+                }
+            else:
+                parameters = (
+                    {
+                        p.name: (
+                            p.default.get_default(call_default_factory=True)
+                            if isinstance(p.default, pydantic.fields.FieldInfo)
+                            else p.default
+                        )
+                        for p in sig.parameters.values()
+                        if p.kind
+                        in (
+                            inspect.Parameter.POSITIONAL_ONLY,
+                            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                        )
+                        and p.default is not p.empty
+                        and p.name not in parameters
+                    }
+                    | parameters
+                    | {var_positional.name: var_positional_values}
+                )
     elif hasattr(fn, "__wrapped__") or (
         isinstance(fn, partial) and hasattr(fn.func, "__wrapped__")
     ):
@@ -443,11 +491,20 @@ def process_v1_params(
 
     type_ = Any if param.annotation is inspect.Parameter.empty else param.annotation
 
+    default = ... if param.default is param.empty else param.default
+    # `*args` and `**kwargs` accept any number of values, including none
+    if param.kind is inspect.Parameter.VAR_POSITIONAL:
+        type_ = list[type_]
+        default = []
+    elif param.kind is inspect.Parameter.VAR_KEYWORD:
+        type_ = dict[str, type_]
+        default = {}
+
     with warnings.catch_warnings():
         # Note: pydantic.v1 doesn't have the warnings module, so we can't suppress them
         warnings.filterwarnings("ignore", category=DeprecationWarning)
         field: Any = pydantic_v1.Field(
-            default=... if param.default is param.empty else param.default,
+            default=default,
             title=param.name,
             description=docstrings.get(param.name, None),
             alias=aliases.get(name),
@@ -604,6 +661,23 @@ def raise_for_reserved_arguments(
             )
 
 
+def _evaluate_annotation(arg: ast.arg, namespace: dict[str, Any]) -> Any:
+    """
+    Evaluate the annotation of a function argument parsed from source code.
+
+    Returns `inspect.Parameter.empty`, equivalent to no annotation, if the argument
+    is not annotated or the annotation can't be evaluated.
+    """
+    if arg.annotation is None:
+        return inspect.Parameter.empty
+    try:
+        ann_code = compile(ast.Expression(arg.annotation), "<string>", "eval")
+        return eval(ann_code, namespace)
+    except Exception as e:
+        logger.debug("Failed to evaluate annotation for %s: %s", arg.arg, e)
+        return inspect.Parameter.empty
+
+
 def _generate_signature_from_source(
     source_code: str, func_name: str, filepath: Optional[str] = None
 ) -> inspect.Signature:
@@ -647,16 +721,7 @@ def _generate_signature_from_source(
     # Handle annotations for positional only args e.g. def func(a, /, b, c)
     for arg in func_def.args.posonlyargs:
         name = arg.arg
-        annotation = arg.annotation
-        if annotation is not None:
-            try:
-                ann_code = compile(ast.Expression(annotation), "<string>", "eval")
-                annotation = eval(ann_code, namespace)
-            except Exception as e:
-                logger.debug("Failed to evaluate annotation for %s: %s", name, e)
-                annotation = inspect.Parameter.empty
-        else:
-            annotation = inspect.Parameter.empty
+        annotation = _evaluate_annotation(arg, namespace)
 
         param = inspect.Parameter(
             name, inspect.Parameter.POSITIONAL_ONLY, annotation=annotation
@@ -666,20 +731,7 @@ def _generate_signature_from_source(
     # Determine the annotations for args e.g. def func(a: int, b: str, c: float)
     for arg in func_def.args.args:
         name = arg.arg
-        annotation = arg.annotation
-        if annotation is not None:
-            try:
-                # Compile and evaluate the annotation
-                ann_code = compile(ast.Expression(annotation), "<string>", "eval")
-                annotation = eval(ann_code, namespace)
-            except Exception as e:
-                # Don't raise an error if the annotation evaluation fails. Set the
-                # annotation to `inspect.Parameter.empty` instead which is equivalent to
-                # not having an annotation.
-                logger.debug("Failed to evaluate annotation for %s: %s", name, e)
-                annotation = inspect.Parameter.empty
-        else:
-            annotation = inspect.Parameter.empty
+        annotation = _evaluate_annotation(arg, namespace)
 
         param = inspect.Parameter(
             name, inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=annotation
@@ -705,16 +757,7 @@ def _generate_signature_from_source(
     # Handle annotations for keyword only args e.g. def func(*, a: int, b: str)
     for kwarg in func_def.args.kwonlyargs:
         name = kwarg.arg
-        annotation = kwarg.annotation
-        if annotation is not None:
-            try:
-                ann_code = compile(ast.Expression(annotation), "<string>", "eval")
-                annotation = eval(ann_code, namespace)
-            except Exception as e:
-                logger.debug("Failed to evaluate annotation for %s: %s", name, e)
-                annotation = inspect.Parameter.empty
-        else:
-            annotation = inspect.Parameter.empty
+        annotation = _evaluate_annotation(kwarg, namespace)
 
         param = inspect.Parameter(
             name, inspect.Parameter.KEYWORD_ONLY, annotation=annotation
@@ -738,15 +781,21 @@ def _generate_signature_from_source(
             parameters[parameters.index(param)] = param.replace(default=default)
 
     # Handle annotations for varargs and kwargs e.g. def func(*args: int, **kwargs: str)
-    if func_def.args.vararg:
+    if vararg := func_def.args.vararg:
         parameters.append(
             inspect.Parameter(
-                func_def.args.vararg.arg, inspect.Parameter.VAR_POSITIONAL
+                vararg.arg,
+                inspect.Parameter.VAR_POSITIONAL,
+                annotation=_evaluate_annotation(vararg, namespace),
             )
         )
-    if func_def.args.kwarg:
+    if varkw := func_def.args.kwarg:
         parameters.append(
-            inspect.Parameter(func_def.args.kwarg.arg, inspect.Parameter.VAR_KEYWORD)
+            inspect.Parameter(
+                varkw.arg,
+                inspect.Parameter.VAR_KEYWORD,
+                annotation=_evaluate_annotation(varkw, namespace),
+            )
         )
 
     # Handle return annotation e.g. def func() -> int

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev7}/src/prefect/utilities/collections.py

@@ -208,7 +208,7 @@ def extract_instances(
 
     if len(types_collection) == 1:
         [type_] = types_collection
-        return ret[type_]
+        return ret.get(type_, [])
 
     return ret
 

prefect_client-3.8.9.dev5/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.8.9.dev5"
-__build_date__ = "2026-10-17 08:16:48.982485+00:00"
-__git_commit__ = "e29ee8a50c54aa3b41c1566827f6223997e7153c"
-__dirty__ = False