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

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

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

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.8.9.dev6"
+__build_date__ = "2026-10-18 08:17:13.281213+00:00"
+__git_commit__ = "87b5243845e733ed938b21cf7b9aeda6d6a4e194"
+__dirty__ = False

{prefect_client-3.8.9.dev5 → prefect_client-3.8.9.dev6}/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.dev6}/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.dev6}/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
@@ -289,12 +289,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 +482,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 +652,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 +712,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 +722,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 +748,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 +772,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/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