prefect-client 3.4.25.dev5__tar.gz → 3.4.26.dev2__tar.gz

{prefect_client-3.4.25.dev5 → prefect_client-3.4.26.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.4.25.dev5
+Version: 3.4.26.dev2
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io
@@ -19,8 +19,9 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries
-Requires-Python: <3.14,>=3.9
+Requires-Python: <3.15,>=3.9
 Requires-Dist: anyio<5.0.0,>=4.4.0
 Requires-Dist: asgi-lifespan<3.0,>=1.0
 Requires-Dist: cachetools<7.0,>=5.3

{prefect_client-3.4.25.dev5 → prefect_client-3.4.26.dev2}/pyproject.toml

@@ -7,7 +7,7 @@ name = "prefect-client"
 dynamic = ["version"]
 description = "Workflow orchestration and management."
 readme = "README.md"
-requires-python = ">=3.9,<3.14"
+requires-python = ">=3.9,<3.15"
 license = { text = "Apache-2.0" }
 authors = [{ name = "Prefect Technologies, Inc.", email = "help@prefect.io" }]
 classifiers = [
@@ -21,6 +21,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Software Development :: Libraries",
 ]
 dependencies = [

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

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.4.26.dev2"
+__build_date__ = "2025-10-25 08:07:49.047020+00:00"
+__git_commit__ = "7fcfb7e8c133807fdc174214560a3badb40f0839"
+__dirty__ = False

{prefect_client-3.4.25.dev5 → prefect_client-3.4.26.dev2}/src/prefect/_internal/pydantic/v1_schema.py

@@ -1,9 +1,9 @@
 import inspect
+import sys
 import typing
 import warnings
 
 import pydantic
-from pydantic.v1 import BaseModel as V1BaseModel
 
 
 def is_v1_model(v: typing.Any) -> bool:
@@ -12,6 +12,11 @@ def is_v1_model(v: typing.Any) -> bool:
             "ignore", category=pydantic.warnings.PydanticDeprecatedSince20
         )
 
+        if sys.version_info >= (3, 14):  # Pydantic v1 is not supported in Python 3.14+
+            return False
+
+        from pydantic.v1 import BaseModel as V1BaseModel
+
         if isinstance(v, V1BaseModel):
             return True
         try:

prefect_client-3.4.26.dev2/src/prefect/_internal/pydantic/validated_func.py

@@ -0,0 +1,339 @@
+"""
+Pure Pydantic v2 implementation of function argument validation.
+
+This module provides validation of function arguments without calling the function,
+compatible with Python 3.14+ (no Pydantic v1 dependency).
+"""
+
+from __future__ import annotations
+
+import inspect
+from typing import Any, Callable, ClassVar, Optional
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    ValidationError,
+    create_model,
+    field_validator,
+)
+
+# Special field names for validation
+# These match pydantic.v1.decorator constants for compatibility
+V_ARGS_NAME = "v__args"
+V_KWARGS_NAME = "v__kwargs"
+V_POSITIONAL_ONLY_NAME = "v__positional_only"
+V_DUPLICATE_KWARGS = "v__duplicate_kwargs"
+
+
+class ValidatedFunction:
+    """
+    Validates function arguments using Pydantic v2 without calling the function.
+
+    This class inspects a function's signature and creates a Pydantic model
+    that can validate arguments passed to the function, including handling
+    of *args, **kwargs, positional-only parameters, and duplicate arguments.
+
+    Example:
+        ```python
+        def greet(name: str, age: int = 0):
+            return f"Hello {name}, you are {age} years old"
+
+        vf = ValidatedFunction(greet)
+
+        # Validate arguments
+        values = vf.validate_call_args(("Alice",), {"age": 30})
+        # Returns: {"name": "Alice", "age": 30}
+
+        # Invalid arguments will raise ValidationError
+        vf.validate_call_args(("Bob",), {"age": "not a number"})
+        # Raises: ValidationError
+        ```
+    """
+
+    def __init__(
+        self,
+        function: Callable[..., Any],
+        config: ConfigDict | None = None,
+    ):
+        """
+        Initialize the validated function.
+
+        Args:
+            function: The function to validate arguments for
+            config: Optional Pydantic ConfigDict or dict configuration
+
+        Raises:
+            ValueError: If function parameters conflict with internal field names
+        """
+        self.raw_function = function
+        self.signature = inspect.signature(function)
+        self.arg_mapping: dict[int, str] = {}
+        self.positional_only_args: set[str] = set()
+        self.v_args_name = V_ARGS_NAME
+        self.v_kwargs_name = V_KWARGS_NAME
+
+        # Check for conflicts with internal field names
+        reserved_names = {
+            V_ARGS_NAME,
+            V_KWARGS_NAME,
+            V_POSITIONAL_ONLY_NAME,
+            V_DUPLICATE_KWARGS,
+        }
+        param_names = set(self.signature.parameters.keys())
+        conflicts = reserved_names & param_names
+        if conflicts:
+            raise ValueError(
+                f"Function parameters conflict with internal field names: {conflicts}. "
+                f"These names are reserved: {reserved_names}"
+            )
+
+        # Build the validation model
+        fields, takes_args, takes_kwargs = self._build_fields()
+        self._create_model(fields, takes_args, takes_kwargs, config)
+
+    def _build_fields(self) -> tuple[dict[str, Any], bool, bool]:
+        """
+        Build field definitions from function signature.
+
+        Returns:
+            Tuple of (fields_dict, takes_args, takes_kwargs)
+        """
+        fields: dict[str, Any] = {}
+        takes_args = False
+        takes_kwargs = False
+        position = 0
+
+        for param_name, param in self.signature.parameters.items():
+            if param.kind == inspect.Parameter.VAR_POSITIONAL:
+                takes_args = True
+                continue
+
+            if param.kind == inspect.Parameter.VAR_KEYWORD:
+                takes_kwargs = True
+                continue
+
+            # Track positional-only parameters
+            if param.kind == inspect.Parameter.POSITIONAL_ONLY:
+                self.positional_only_args.add(param_name)
+
+            # Map position to parameter name
+            if param.kind in (
+                inspect.Parameter.POSITIONAL_ONLY,
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            ):
+                self.arg_mapping[position] = param_name
+                position += 1
+
+            # Determine type and default
+            annotation = (
+                param.annotation if param.annotation != inspect.Parameter.empty else Any
+            )
+
+            if param.default == inspect.Parameter.empty:
+                # Required parameter
+                fields[param_name] = (annotation, Field(...))
+            else:
+                # Optional parameter with default
+                fields[param_name] = (annotation, Field(default=param.default))
+
+        # Always add args/kwargs fields for validation, even if function doesn't accept them
+        fields[self.v_args_name] = (Optional[list[Any]], Field(default=None))
+        fields[self.v_kwargs_name] = (Optional[dict[str, Any]], Field(default=None))
+
+        # Add special validation fields
+        fields[V_POSITIONAL_ONLY_NAME] = (Optional[list[str]], Field(default=None))
+        fields[V_DUPLICATE_KWARGS] = (Optional[list[str]], Field(default=None))
+
+        return fields, takes_args, takes_kwargs
+
+    def _create_model(
+        self,
+        fields: dict[str, Any],
+        takes_args: bool,
+        takes_kwargs: bool,
+        config: ConfigDict | None,
+    ) -> None:
+        """Create the Pydantic validation model."""
+        pos_args = len(self.arg_mapping)
+
+        # Process config
+        # Note: ConfigDict is a TypedDict, so we can't use isinstance() in Python 3.14
+        # Instead, check if it's a dict-like object and merge with defaults
+        if config is None:
+            config_dict = ConfigDict(extra="forbid")
+        else:
+            config_dict = config.copy()
+            if "extra" not in config_dict:
+                config_dict["extra"] = "forbid"
+
+        # Create base model with validators
+        class DecoratorBaseModel(BaseModel):
+            model_config: ClassVar[ConfigDict] = config_dict
+
+            @field_validator(V_ARGS_NAME, check_fields=False)
+            @classmethod
+            def check_args(cls, v: Optional[list[Any]]) -> Optional[list[Any]]:
+                if takes_args or v is None:
+                    return v
+
+                raise TypeError(
+                    f"{pos_args} positional argument{'s' if pos_args != 1 else ''} "
+                    f"expected but {pos_args + len(v)} given"
+                )
+
+            @field_validator(V_KWARGS_NAME, check_fields=False)
+            @classmethod
+            def check_kwargs(
+                cls, v: Optional[dict[str, Any]]
+            ) -> Optional[dict[str, Any]]:
+                if takes_kwargs or v is None:
+                    return v
+
+                plural = "" if len(v) == 1 else "s"
+                keys = ", ".join(map(repr, v.keys()))
+                raise TypeError(f"unexpected keyword argument{plural}: {keys}")
+
+            @field_validator(V_POSITIONAL_ONLY_NAME, check_fields=False)
+            @classmethod
+            def check_positional_only(cls, v: Optional[list[str]]) -> None:
+                if v is None:
+                    return
+
+                plural = "" if len(v) == 1 else "s"
+                keys = ", ".join(map(repr, v))
+                raise TypeError(
+                    f"positional-only argument{plural} passed as keyword "
+                    f"argument{plural}: {keys}"
+                )
+
+            @field_validator(V_DUPLICATE_KWARGS, check_fields=False)
+            @classmethod
+            def check_duplicate_kwargs(cls, v: Optional[list[str]]) -> None:
+                if v is None:
+                    return
+
+                plural = "" if len(v) == 1 else "s"
+                keys = ", ".join(map(repr, v))
+                raise TypeError(f"multiple values for argument{plural}: {keys}")
+
+        # Create the model dynamically
+        model_name = f"{self.raw_function.__name__.title()}Model"
+        self.model = create_model(
+            model_name,
+            __base__=DecoratorBaseModel,
+            **fields,
+        )
+
+    def validate_call_args(
+        self, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> dict[str, Any]:
+        """
+        Validate function arguments and return normalized parameters.
+
+        Args:
+            args: Positional arguments
+            kwargs: Keyword arguments
+
+        Returns:
+            Dictionary mapping parameter names to values
+
+        Raises:
+            ValidationError: If arguments don't match the function signature
+        """
+        # Build the values dict for validation
+        values: dict[str, Any] = {}
+        var_args: list[Any] = []
+        var_kwargs: dict[str, Any] = {}
+        positional_only_passed_as_kw: list[str] = []
+        duplicate_kwargs: list[str] = []
+
+        # Process positional arguments
+        for i, arg in enumerate(args):
+            if i in self.arg_mapping:
+                param_name = self.arg_mapping[i]
+                if param_name in kwargs:
+                    # Duplicate: both positional and keyword
+                    duplicate_kwargs.append(param_name)
+                values[param_name] = arg
+            else:
+                # Extra positional args go into *args
+                var_args.append(arg)
+
+        # Process keyword arguments
+        for key, value in kwargs.items():
+            if key in values:
+                # Already set by positional arg
+                continue
+
+            # Check if this is a positional-only param passed as keyword
+            if key in self.positional_only_args:
+                positional_only_passed_as_kw.append(key)
+                continue
+
+            # Check if this is a known parameter
+            if key in self.signature.parameters:
+                values[key] = value
+            else:
+                # Unknown parameter goes into **kwargs
+                var_kwargs[key] = value
+
+        # Add special fields
+        if var_args:
+            values[self.v_args_name] = var_args
+        if var_kwargs:
+            values[self.v_kwargs_name] = var_kwargs
+        if positional_only_passed_as_kw:
+            values[V_POSITIONAL_ONLY_NAME] = positional_only_passed_as_kw
+        if duplicate_kwargs:
+            values[V_DUPLICATE_KWARGS] = duplicate_kwargs
+
+        # Validate using the model
+        try:
+            validated = self.model.model_validate(values)
+        except ValidationError as e:
+            # Convert ValidationError to TypeError for certain cases to match Python's behavior
+            # Check if the error is about extra kwargs
+            for error in e.errors():
+                if error.get("type") == "extra_forbidden" and error.get("loc") == (
+                    "kwargs",
+                ):
+                    # This is an extra keyword argument error
+                    extra_keys = error.get("input", {})
+                    if isinstance(extra_keys, dict):
+                        plural = "" if len(extra_keys) == 1 else "s"
+                        keys = ", ".join(map(repr, extra_keys.keys()))
+                        raise TypeError(f"unexpected keyword argument{plural}: {keys}")
+            # For other validation errors, re-raise as-is
+            raise
+
+        # Extract only the actual function parameters
+        result: dict[str, Any] = {}
+        for param_name in self.signature.parameters.keys():
+            param = self.signature.parameters[param_name]
+
+            if param.kind == inspect.Parameter.VAR_POSITIONAL:
+                result[param_name] = getattr(validated, self.v_args_name) or []
+            elif param.kind == inspect.Parameter.VAR_KEYWORD:
+                result[param_name] = getattr(validated, self.v_kwargs_name) or {}
+            else:
+                # Regular parameter
+                value = getattr(validated, param_name)
+                result[param_name] = value
+
+        return result
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """
+        Validate arguments and call the function.
+
+        Args:
+            *args: Positional arguments
+            **kwargs: Keyword arguments
+
+        Returns:
+            The result of calling the function with validated arguments
+        """
+        validated_params = self.validate_call_args(args, kwargs)
+        return self.raw_function(**validated_params)

{prefect_client-3.4.25.dev5 → prefect_client-3.4.26.dev2}/src/prefect/concurrency/_asyncio.py

@@ -1,8 +1,12 @@
+from __future__ import annotations
+
 import asyncio
 import logging
-from typing import TYPE_CHECKING, Literal, Optional
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, AsyncGenerator, Literal, Optional
 from uuid import UUID
 
+import anyio
 import httpx
 
 from prefect.client.orchestration import get_client
@@ -10,6 +14,12 @@ from prefect.client.schemas.responses import (
     ConcurrencyLimitWithLeaseResponse,
     MinimalConcurrencyLimitResponse,
 )
+from prefect.concurrency._events import (
+    emit_concurrency_acquisition_events,
+    emit_concurrency_release_events,
+)
+from prefect.concurrency._leases import amaintain_concurrency_lease
+from prefect.concurrency.context import ConcurrencyContext
 from prefect.logging import get_logger
 from prefect.logging.loggers import get_run_logger
 from prefect.utilities.timeout import timeout_async
@@ -80,6 +90,7 @@ async def aacquire_concurrency_slots_with_lease(
     lease_duration: float = 300,
     strict: bool = False,
     holder: "Optional[ConcurrencyLeaseHolder]" = None,
+    suppress_warnings: bool = False,
 ) -> ConcurrencyLimitWithLeaseResponse:
     try:
         # Use a run logger if available
@@ -108,8 +119,14 @@ async def aacquire_concurrency_slots_with_lease(
                                     f"Concurrency limits {names!r} must be created before acquiring slots"
                                 )
                             else:
-                                logger.warning(
-                                    f"Concurrency limits {names!r} do not exist - skipping acquisition."
+                                log_level = (
+                                    logging.DEBUG
+                                    if suppress_warnings
+                                    else logging.WARNING
+                                )
+                                logger.log(
+                                    log_level,
+                                    f"Concurrency limits {names!r} do not exist - skipping acquisition.",
                                 )
 
                         return retval
@@ -159,3 +176,87 @@ def _response_to_minimal_concurrency_limit_response(
     return [
         MinimalConcurrencyLimitResponse.model_validate(obj_) for obj_ in response.json()
     ]
+
+
+@asynccontextmanager
+async def concurrency(
+    names: str | list[str],
+    occupy: int = 1,
+    timeout_seconds: Optional[float] = None,
+    max_retries: Optional[int] = None,
+    lease_duration: float = 300,
+    strict: bool = False,
+    holder: "Optional[ConcurrencyLeaseHolder]" = None,
+    suppress_warnings: bool = False,
+) -> AsyncGenerator[None, None]:
+    """
+    Internal version of the `concurrency` context manager. The public version is located in `prefect.concurrency.asyncio`.
+
+    Args:
+        names: The names of the concurrency limits to acquire slots from.
+        occupy: The number of slots to acquire and hold from each limit.
+        timeout_seconds: The number of seconds to wait for the slots to be acquired before
+            raising a `TimeoutError`. A timeout of `None` will wait indefinitely.
+        max_retries: The maximum number of retries to acquire the concurrency slots.
+        lease_duration: The duration of the lease for the acquired slots in seconds.
+        strict: A boolean specifying whether to raise an error if the concurrency limit does not exist.
+            Defaults to `False`.
+        holder: A dictionary containing information about the holder of the concurrency slots.
+            Typically includes 'type' and 'id' keys.
+
+    Raises:
+        TimeoutError: If the slots are not acquired within the given timeout.
+        ConcurrencySlotAcquisitionError: If the concurrency limit does not exist and `strict` is `True`.
+
+    Example:
+    A simple example of using the async `concurrency` context manager:
+    ```python
+    from prefect.concurrency.asyncio import concurrency
+
+    async def resource_heavy():
+        async with concurrency("test", occupy=1):
+            print("Resource heavy task")
+
+    async def main():
+        await resource_heavy()
+    ```
+    """
+    if not names:
+        yield
+        return
+
+    names = names if isinstance(names, list) else [names]
+
+    response = await aacquire_concurrency_slots_with_lease(
+        names=names,
+        slots=occupy,
+        timeout_seconds=timeout_seconds,
+        max_retries=max_retries,
+        lease_duration=lease_duration,
+        strict=strict,
+        holder=holder,
+        suppress_warnings=suppress_warnings,
+    )
+    emitted_events = emit_concurrency_acquisition_events(response.limits, occupy)
+
+    try:
+        async with amaintain_concurrency_lease(
+            response.lease_id,
+            lease_duration,
+            raise_on_lease_renewal_failure=strict,
+            suppress_warnings=suppress_warnings,
+        ):
+            yield
+    finally:
+        try:
+            await arelease_concurrency_slots_with_lease(
+                lease_id=response.lease_id,
+            )
+        except anyio.get_cancelled_exc_class():
+            # The task was cancelled before it could release the lease. Add the
+            # lease ID to the cleanup list so it can be released when the
+            # concurrency context is exited.
+            if ctx := ConcurrencyContext.get():
+                ctx.cleanup_lease_ids.append(response.lease_id)
+
+        emit_concurrency_release_events(response.limits, occupy, emitted_events)

{prefect_client-3.4.25.dev5 → prefect_client-3.4.26.dev2}/src/prefect/concurrency/_leases.py

@@ -40,6 +40,7 @@ def maintain_concurrency_lease(
     lease_id: UUID,
     lease_duration: float,
     raise_on_lease_renewal_failure: bool = False,
+    suppress_warnings: bool = False,
 ) -> Generator[None, None, None]:
     """
     Maintain a concurrency lease for the given lease ID.
@@ -76,9 +77,14 @@ def maintain_concurrency_lease(
                     )
                     assert cancel_scope.cancel()
                 else:
-                    logger.warning(
-                        "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
-                    )
+                    if suppress_warnings:
+                        logger.debug(
+                            "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
+                        )
+                    else:
+                        logger.warning(
+                            "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
+                        )
 
         lease_renewal_call.future.add_done_callback(handle_lease_renewal_failure)
 
@@ -94,6 +100,7 @@ async def amaintain_concurrency_lease(
     lease_id: UUID,
     lease_duration: float,
     raise_on_lease_renewal_failure: bool = False,
+    suppress_warnings: bool = False,
 ) -> AsyncGenerator[None, None]:
     """
     Maintain a concurrency lease for the given lease ID.
@@ -125,9 +132,14 @@ async def amaintain_concurrency_lease(
                     )
                     cancel_scope.cancel()
                 else:
-                    logger.warning(
-                        "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
-                    )
+                    if suppress_warnings:
+                        logger.debug(
+                            "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
+                        )
+                    else:
+                        logger.warning(
+                            "Concurrency lease renewal failed - slots are no longer reserved. Execution will continue, but concurrency limits may be exceeded."
+                        )
 
         # Add a callback to stop execution if the lease renewal fails and strict is True
         lease_renewal_task.add_done_callback(handle_lease_renewal_failure)