prefect-client 2.16.8__tar.gz → 2.16.9__tar.gz

{prefect-client-2.16.8 → prefect-client-2.16.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 2.16.8
+Version: 2.16.9
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.

{prefect-client-2.16.8 → prefect-client-2.16.9}/requirements-client.txt

@@ -7,7 +7,7 @@ croniter >= 1.0.12, < 3.0.0
 fsspec >= 2022.5.0
 graphviz >= 0.20.1
 griffe >= 0.20.0
-httpcore >=0.15.0, < 2.0.0
+httpcore >=1.0.5, < 2.0.0
 httpx[http2] >= 0.23, != 0.23.2
 importlib_metadata >= 4.4; python_version < '3.10'
 importlib-resources >= 6.1.3, < 6.2.0
@@ -21,6 +21,7 @@ pendulum < 3.0; python_version < '3.12'
 pendulum >= 3.0.0, <4; python_version >= '3.12'
 # the version constraints for pydantic are merged with those from fastapi 0.103.2
 pydantic[email]>=1.10.0,!=2.0.0,!=2.0.1,!=2.1.0,<3.0.0
+pydantic_core >= 2.10.0, < 3.0.0
 python_dateutil >= 2.8.2, < 3.0.0
 python-slugify >= 5.0, < 9.0
 pyyaml >= 5.4.1, < 7.0.0

{prefect-client-2.16.8 → prefect-client-2.16.9}/requirements.txt

@@ -15,4 +15,4 @@ kubernetes >= 24.2.0, < 30.0.0
 pytz >= 2021.1, < 2025
 readchar >= 4.0.0, < 5.0.0
 sqlalchemy[asyncio] >= 1.4.22, != 1.4.33, < 3.0.0
-typer >= 0.4.2
+typer >= 0.12.0, < 0.13.0

{prefect-client-2.16.8 → prefect-client-2.16.9}/setup.cfg

@@ -13,6 +13,7 @@ markers =
 	clear_db: marker to clear the database after test completion
 env = 
 	PREFECT_TEST_MODE = 1
+	PREFECT_LOGGING_SERVER_LEVEL = DEBUG
 asyncio_mode = auto
 timeout = 90
 filterwarnings = 

{prefect-client-2.16.8 → prefect-client-2.16.9}/src/prefect/_internal/compatibility/experimental.py

@@ -10,6 +10,7 @@ Warnings may also be disabled globally with the setting `PREFECT_EXPERIMENTAL_WA
 Some experimental features require opt-in to enable any usage. These require the setting
 `PREFECT_EXPERIMENTAL_ENABLE_<GROUP>` to be set or an error will be thrown on use.
 """
+
 import functools
 import warnings
 from typing import Any, Callable, Optional, Set, Type, TypeVar
@@ -24,7 +25,7 @@ else:
 from prefect.settings import PREFECT_EXPERIMENTAL_WARN, SETTING_VARIABLES, Setting
 from prefect.utilities.callables import get_call_parameters
 
-T = TypeVar("T", bound=Callable)
+T = TypeVar("T", bound=Callable[..., Any])
 M = TypeVar("M", bound=pydantic.BaseModel)
 
 
@@ -47,12 +48,6 @@ class ExperimentalWarning(Warning):
     """
 
 
-class ExperimentalError(Exception):
-    """
-    An exception related to experimental code.
-    """
-
-
 class ExperimentalFeature(ExperimentalWarning):
     """
     A warning displayed on use of an experimental feature.
@@ -61,6 +56,12 @@ class ExperimentalFeature(ExperimentalWarning):
     """
 
 
+class ExperimentalError(Exception):
+    """
+    An exception related to experimental code.
+    """
+
+
 class ExperimentalFeatureDisabled(ExperimentalError):
     """
     An error displayed on use of a disabled experimental feature that requires opt-in.
@@ -112,7 +113,7 @@ def experimental(
 
     group_warn = _warn_setting_for_group(group)
 
-    def decorator(fn: T):
+    def decorator(fn: T) -> T:
         @functools.wraps(fn)
         def wrapper(*args, **kwargs):
             if opt_in and not group_opt_in:

{prefect-client-2.16.8 → prefect-client-2.16.9}/src/prefect/_internal/concurrency/api.py

@@ -1,6 +1,7 @@
 """
 Primary developer-facing API for concurrency management.
 """
+
 import abc
 import asyncio
 import concurrent.futures
@@ -18,6 +19,7 @@ from typing import (
 
 from typing_extensions import ParamSpec
 
+from prefect._internal.concurrency.calls import get_current_call
 from prefect._internal.concurrency.threads import (
     WorkerThread,
     get_global_loop,
@@ -104,40 +106,6 @@ class _base(abc.ABC):
         runner.submit(call)
         return call
 
-    @staticmethod
-    def call_soon_in_waiting_thread(
-        __call: Union[Callable[[], T], Call[T]],
-        thread: threading.Thread,
-        timeout: Optional[float] = None,
-    ) -> Call[T]:
-        """
-        Schedule a call for execution in the thread that is waiting for the current
-        call.
-
-        Returns the submitted call.
-        """
-        call = _cast_to_call(__call)
-        waiter = get_waiter_for_thread(thread)
-        if waiter is None:
-            raise RuntimeError(f"No waiter found for thread {thread}.")
-
-        call.set_timeout(timeout)
-        waiter.submit(call)
-        return call
-
-    @staticmethod
-    def call_in_waiting_thread(
-        __call: Union[Callable[[], T], Call[T]],
-        thread: threading.Thread,
-        timeout: Optional[float] = None,
-    ) -> T:
-        """
-        Run a call in the thread that is waiting for the current call.
-
-        Returns the result of the call.
-        """
-        raise NotImplementedError()
-
     @staticmethod
     def call_in_new_thread(
         __call: Union[Callable[[], T], Call[T]], timeout: Optional[float] = None
@@ -196,13 +164,20 @@ class from_async(_base):
         return call.result()
 
     @staticmethod
-    def call_in_waiting_thread(
+    def call_soon_in_waiting_thread(
         __call: Union[Callable[[], T], Call[T]],
         thread: threading.Thread,
         timeout: Optional[float] = None,
-    ) -> Awaitable[T]:
-        call = _base.call_soon_in_waiting_thread(__call, thread, timeout=timeout)
-        return call.aresult()
+    ) -> Call[T]:
+        call = _cast_to_call(__call)
+        parent_call = get_current_call()
+        waiter = get_waiter_for_thread(thread, parent_call)
+        if waiter is None:
+            raise RuntimeError(f"No waiter found for thread {thread}.")
+
+        call.set_timeout(timeout)
+        waiter.submit(call)
+        return call
 
     @staticmethod
     def call_in_new_thread(
@@ -257,13 +232,19 @@ class from_sync(_base):
         return call.result()
 
     @staticmethod
-    def call_in_waiting_thread(
+    def call_soon_in_waiting_thread(
         __call: Union[Callable[[], T], Call[T]],
         thread: threading.Thread,
         timeout: Optional[float] = None,
-    ) -> T:
-        call = _base.call_soon_in_waiting_thread(__call, thread, timeout=timeout)
-        return call.result()
+    ) -> Call[T]:
+        call = _cast_to_call(__call)
+        waiter = get_waiter_for_thread(thread)
+        if waiter is None:
+            raise RuntimeError(f"No waiter found for thread {thread}.")
+
+        call.set_timeout(timeout)
+        waiter.submit(call)
+        return call
 
     @staticmethod
     def call_in_new_thread(

{prefect-client-2.16.8 → prefect-client-2.16.9}/src/prefect/_internal/concurrency/waiters.py

@@ -9,9 +9,9 @@ import contextlib
 import inspect
 import queue
 import threading
-import weakref
 from collections import deque
 from typing import Awaitable, Generic, List, Optional, TypeVar, Union
+from weakref import WeakKeyDictionary
 
 import anyio
 
@@ -24,34 +24,37 @@ T = TypeVar("T")
 
 
 # Waiters are stored in a stack for each thread
-_WAITERS_BY_THREAD: "weakref.WeakKeyDictionary[threading.Thread, deque[Waiter]]" = (
-    weakref.WeakKeyDictionary()
+_WAITERS_BY_THREAD: "WeakKeyDictionary[threading.Thread, deque[Waiter]]" = (
+    WeakKeyDictionary()
 )
 
 
-def get_waiter_for_thread(thread: threading.Thread) -> Optional["Waiter"]:
+def get_waiter_for_thread(
+    thread: threading.Thread, parent_call: Optional[Call] = None
+) -> Optional["Waiter"]:
     """
-    Get the current waiter for a thread.
+    Get the current waiter for a thread and an optional parent call.
 
-    Returns `None` if one does not exist.
+    To avoid assigning outer callbacks to inner waiters in the case of nested calls,
+    the parent call is used to determine which waiter to return. If a parent call is
+    not provided, we return the most recently created waiter (last in the stack).
+
+    see https://github.com/PrefectHQ/prefect/issues/12036
+
+    Returns `None` if no active waiter is found for the thread.
     """
-    waiters = _WAITERS_BY_THREAD.get(thread)
-
-    if waiters:
-        idx = -1
-        while abs(idx) <= len(waiters):
-            try:
-                waiter = waiters[idx]
-                if not waiter.call_is_done():
-                    return waiter
-                idx = idx - 1
-            # It is possible that items are being added or removed
-            # from the deque, so the index we're using may not always
-            # be valid.
-            except IndexError:
-                break
 
-    return None
+    waiters: "Optional[deque[Waiter]]" = _WAITERS_BY_THREAD.get(thread)
+
+    if waiters and (active_waiters := [w for w in waiters if not w.call_is_done()]):
+        if parent_call and (
+            matching_waiter := next(
+                (w for w in active_waiters if w._call == parent_call), None
+            )
+        ):  # if exists an active waiter responsible for the parent call, return it
+            return matching_waiter
+        else:  # otherwise, return the most recently created waiter
+            return active_waiters[-1]
 
 
 def add_waiter_for_thread(waiter: "Waiter", thread: threading.Thread):

{prefect-client-2.16.8 → prefect-client-2.16.9}/src/prefect/_internal/pydantic/__init__.py

@@ -6,21 +6,25 @@
 ### This is a tradeoff we're willing to make for now until pydantic v1 is
 ### no longer supported.
 
-from pydantic.version import VERSION as PYDANTIC_VERSION
 
-HAS_PYDANTIC_V2 = PYDANTIC_VERSION.startswith("2.")
+from ._flags import HAS_PYDANTIC_V2
 
 from ._compat import (
     model_dump,
     model_json_schema,
     model_validate,
-    IncEx,
     model_dump_json,
     model_copy,
     model_validate_json,
+    TypeAdapter,
     validate_python,
+    BaseModel,
+    Field,
+    FieldInfo,
 )
 
+from ._types import IncEx
+
 __all__ = [
     "model_dump",
     "model_json_schema",
@@ -29,5 +33,10 @@ __all__ = [
     "model_dump_json",
     "model_copy",
     "model_validate_json",
+    "TypeAdapter",
     "validate_python",
+    "BaseModel",
+    "HAS_PYDANTIC_V2",
+    "Field",
+    "FieldInfo",
 ]

prefect-client-2.16.9/src/prefect/_internal/pydantic/_base_model.py

@@ -0,0 +1,19 @@
+import typing
+
+from prefect._internal.pydantic._flags import (
+    HAS_PYDANTIC_V2,
+    USE_PYDANTIC_V2,
+)
+
+if typing.TYPE_CHECKING:
+    from pydantic import BaseModel, Field
+    from pydantic.fields import FieldInfo
+
+if HAS_PYDANTIC_V2 and not USE_PYDANTIC_V2:
+    from pydantic.v1 import BaseModel, Field
+    from pydantic.v1.fields import FieldInfo
+else:
+    from pydantic import BaseModel, Field
+    from pydantic.fields import FieldInfo
+
+__all__ = ["BaseModel", "Field", "FieldInfo"]

prefect-client-2.16.9/src/prefect/_internal/pydantic/_compat.py

@@ -0,0 +1,50 @@
+from ._base_model import BaseModel as PydanticBaseModel
+from ._base_model import Field, FieldInfo
+from ._flags import HAS_PYDANTIC_V2, USE_PYDANTIC_V2
+from .utilities.model_construct import ModelConstructMixin, model_construct
+from .utilities.model_copy import ModelCopyMixin, model_copy
+from .utilities.model_dump import ModelDumpMixin, model_dump
+from .utilities.model_dump_json import ModelDumpJsonMixin, model_dump_json
+from .utilities.model_fields import ModelFieldMixin
+from .utilities.model_json_schema import ModelJsonSchemaMixin, model_json_schema
+from .utilities.model_validate import ModelValidateMixin, model_validate
+from .utilities.model_validate_json import ModelValidateJsonMixin, model_validate_json
+from .utilities.type_adapter import TypeAdapter, validate_python
+
+if HAS_PYDANTIC_V2 and USE_PYDANTIC_V2:
+    # In this case, there's no functionality to add, so we just alias the Pydantic v2 BaseModel
+    class BaseModel(PydanticBaseModel):  # type: ignore
+        pass
+
+else:
+    # In this case, we're working with a Pydantic v1 model, so we need to add Pydantic v2 functionality
+    # TODO: Find a smarter way of attaching these methods so that they don't need to be redefined
+
+    class BaseModel(
+        ModelConstructMixin,
+        ModelCopyMixin,
+        ModelDumpMixin,
+        ModelDumpJsonMixin,
+        ModelJsonSchemaMixin,
+        ModelValidateMixin,
+        ModelValidateJsonMixin,
+        ModelFieldMixin,
+        PydanticBaseModel,
+    ):
+        pass
+
+
+__all__ = [
+    "model_construct",
+    "model_copy",
+    "model_dump",
+    "model_dump_json",
+    "model_json_schema",
+    "model_validate",
+    "model_validate_json",
+    "TypeAdapter",
+    "validate_python",
+    "BaseModel",
+    "Field",
+    "FieldInfo",
+]

{prefect-client-2.16.8 → prefect-client-2.16.9}/src/prefect/_internal/pydantic/_flags.py

@@ -11,5 +11,7 @@ USE_PYDANTIC_V2 = os.environ.get(
     "PREFECT_EXPERIMENTAL_ENABLE_PYDANTIC_V2_INTERNALS", False
 ) in {"1", "true", "True"}
 
+USE_V2_MODELS = HAS_PYDANTIC_V2 and USE_PYDANTIC_V2
+
 # Set to True if Pydantic v2 is present but not enabled, indicating deprecation warnings may occur.
 EXPECT_DEPRECATION_WARNINGS = HAS_PYDANTIC_V2 and not USE_PYDANTIC_V2

prefect-client-2.16.9/src/prefect/_internal/pydantic/_types.py

@@ -0,0 +1,8 @@
+from typing import Any, Dict, Literal, Set, Union
+
+from typing_extensions import TypeAlias
+
+IncEx: TypeAlias = "Union[Set[int], Set[str], Dict[int, Any], Dict[str, Any], None]"
+
+DEFAULT_REF_TEMPLATE = "#/$defs/{model}"
+JsonSchemaMode = Literal["validation", "serialization"]

prefect-client-2.16.9/src/prefect/_internal/pydantic/utilities/model_construct.py

@@ -0,0 +1,56 @@
+import typing
+
+from typing_extensions import Self
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+T = typing.TypeVar("T", bound="BaseModel")
+
+
+def model_construct(
+    model: typing.Type[T],
+    _fields_set: typing.Optional[typing.Set[str]] = None,
+    **values: typing.Any,
+) -> T:
+    """Creates a new instance of the `model` class with validated data.
+
+    Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data.
+    Default values are respected, but no other validation is performed.
+
+    Args:
+        _fields_set: The set of field names accepted for the Model instance.
+        values: Trusted or pre-validated data dictionary.
+
+    Returns:
+        A new instance of the `model` class with validated data.
+    """
+    if USE_V2_MODELS:
+        return model.model_construct(_fields_set=_fields_set, **values)
+    else:
+        return getattr(model, "construct")(**values)
+
+
+class ModelConstructMixin(BaseModel):
+    @classmethod
+    def model_construct(
+        cls: typing.Type["Self"],
+        _fields_set: typing.Optional[typing.Set[str]] = None,
+        **values: typing.Any,
+    ) -> "Self":
+        """Creates a new instance of the `model` class with validated data.
+
+        Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data.
+        Default values are respected, but no other validation is performed.
+
+        Args:
+            _fields_set: The set of field names accepted for the Model instance.
+            values: Trusted or pre-validated data dictionary.
+
+        Returns:
+            A new instance of the `model` class with validated data.
+        """
+        return model_construct(cls, _fields_set=_fields_set, **values)
+
+
+__all__ = ["model_construct", "ModelConstructMixin"]

prefect-client-2.16.9/src/prefect/_internal/pydantic/utilities/model_copy.py

@@ -0,0 +1,55 @@
+import typing
+
+from typing_extensions import Self
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+T = typing.TypeVar("T", bound="BaseModel")
+
+
+def model_copy(  # type: ignore[no-redef]
+    model_instance: T,
+    *,
+    update: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    deep: bool = False,
+) -> T:
+    """
+    Returns a copy of the model.
+
+    Args:
+        update: Values to change/add in the new model. Note: the data is not validated
+            before creating the new model. You should trust this data.
+        deep: Set to `True` to make a deep copy of the model.
+
+    Returns:
+        New model instance.
+    """
+    if USE_V2_MODELS:
+        return model_instance.model_copy(update=update, deep=deep)
+    else:
+        return getattr(model_instance, "copy")(update=update, deep=deep)
+
+
+class ModelCopyMixin(BaseModel):
+    def model_copy(
+        self: "Self",
+        *,
+        update: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        deep: bool = False,
+    ) -> "Self":
+        """
+        Returns a copy of the model.
+
+        Args:
+            update: Values to change/add in the new model. Note: the data is not validated
+                before creating the new model. You should trust this data.
+            deep: Set to `True` to make a deep copy of the model.
+
+        Returns:
+            New model instance.
+        """
+        return model_copy(self, update=update, deep=deep)
+
+
+__all__ = ["model_copy"]

prefect-client-2.16.9/src/prefect/_internal/pydantic/utilities/model_dump.py

@@ -0,0 +1,136 @@
+import typing
+import warnings as python_warnings
+
+from pydantic_core import from_json
+from typing_extensions import Self
+
+from prefect._internal.pydantic._base_model import BaseModel
+from prefect._internal.pydantic._flags import USE_V2_MODELS
+
+if typing.TYPE_CHECKING:
+    from prefect._internal.pydantic._types import IncEx
+
+T = typing.TypeVar("T", bound="BaseModel")
+
+
+def model_dump(  # type: ignore[no-redef]
+    model_instance: "BaseModel",
+    *,
+    mode: typing.Union[typing.Literal["json", "python"], str] = "python",
+    include: "IncEx" = None,
+    exclude: "IncEx" = None,
+    by_alias: bool = False,
+    exclude_unset: bool = False,
+    exclude_defaults: bool = False,
+    exclude_none: bool = False,
+    round_trip: bool = False,
+    warnings: bool = True,
+) -> typing.Dict[str, typing.Any]:
+    """
+    Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
+    Args:
+        mode: The mode in which `to_python` should run.
+            If mode is 'json', the output will only contain JSON serializable types.
+            If mode is 'python', the output may contain non-JSON-serializable Python objects.
+        include: A set of fields to include in the output.
+        exclude: A set of fields to exclude from the output.
+        context: Additional context to pass to the serializer.
+        by_alias: Whether to use the field's alias in the dictionary key if defined.
+        exclude_unset: Whether to exclude fields that have not been explicitly set.
+        exclude_defaults: Whether to exclude fields that are set to their default value.
+        exclude_none: Whether to exclude fields that have a value of `None`.
+        round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+        warnings: Whether to log warnings when invalid fields are encountered.
+        serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
+    Returns:
+        A dictionary representation of the model.
+    """
+    if USE_V2_MODELS:
+        return model_instance.model_dump(
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+        )
+    else:
+        if mode == "json":
+            with python_warnings.catch_warnings():
+                python_warnings.simplefilter("ignore")
+                return from_json(
+                    model_instance.json(
+                        include=include,
+                        exclude=exclude,
+                        by_alias=by_alias,
+                        exclude_unset=exclude_unset,
+                        exclude_defaults=exclude_defaults,
+                        exclude_none=exclude_none,
+                    )
+                )
+
+        return getattr(model_instance, "dict")(
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+
+
+class ModelDumpMixin(BaseModel):
+    def model_dump(
+        self: "Self",
+        *,
+        mode: typing.Union[typing.Literal["json", "python"], str] = "python",
+        include: "IncEx" = None,
+        exclude: "IncEx" = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        round_trip: bool = False,
+        warnings: bool = True,
+    ) -> typing.Dict[str, typing.Any]:
+        """
+        Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
+        Args:
+            mode: The mode in which `to_python` should run.
+                If mode is 'json', the output will only contain JSON serializable types.
+                If mode is 'python', the output may contain non-JSON-serializable Python objects.
+            include: A set of fields to include in the output.
+            exclude: A set of fields to exclude from the output.
+            context: Additional context to pass to the serializer.
+            by_alias: Whether to use the field's alias in the dictionary key if defined.
+            exclude_unset: Whether to exclude fields that have not been explicitly set.
+            exclude_defaults: Whether to exclude fields that are set to their default value.
+            exclude_none: Whether to exclude fields that have a value of `None`.
+            round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+            warnings: Whether to log warnings when invalid fields are encountered.
+            serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
+        Returns:
+            A dictionary representation of the model.
+        """
+        return model_dump(
+            self,
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+        )
+
+
+__all__ = ["model_dump", "ModelDumpMixin"]