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

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

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

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

@@ -7,12 +7,12 @@ 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
 jsonpatch >= 1.32, < 2.0
-jsonschema >= 3.2.0, < 5.0.0
+jsonschema >= 4.0.0, < 5.0.0
 orjson >= 3.7, < 4.0
 packaging >= 21.3, < 24.3
 pathspec >= 0.8.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.12.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.17.0}/requirements.txt

@@ -11,8 +11,10 @@ docker >= 4.0, < 7.0
 graphviz >= 0.20.1
 griffe >= 0.20.0
 jinja2 >= 3.0.0, < 4.0.0
+jinja2-humanize-extension >= 0.4.0
+humanize >= 4.9.0
 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.12.2, < 0.13.0

{prefect-client-2.16.8 → prefect-client-2.17.0}/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.17.0}/src/prefect/__init__.py

@@ -106,24 +106,6 @@ from prefect._internal.compatibility.deprecated import (
     register_renamed_module,
 )
 
-register_renamed_module(
-    "prefect.client.orchestration",
-    "prefect.client.orchestration",
-    start_date="Feb 2023",
-)
-register_renamed_module(
-    "prefect.docker",
-    "prefect.utilities.dockerutils",
-    start_date="Mar 2023",
-)
-register_renamed_module(
-    "prefect.infrastructure.docker",
-    "prefect.infrastructure.container",
-    start_date="Mar 2023",
-)
-register_renamed_module(
-    "prefect.projects", "prefect.deployments", start_date="Jun 2023"
-)
 register_renamed_module(
     "prefect.packaging", "prefect.deprecated.packaging", start_date="Mar 2024"
 )

{prefect-client-2.16.8 → prefect-client-2.17.0}/src/prefect/_internal/compatibility/deprecated.py

@@ -12,16 +12,18 @@ e.g. Jan 2023.
 import functools
 import sys
 import warnings
-from typing import Any, Callable, List, Optional, Type, TypeVar
+from typing import Any, Callable, Dict, List, Optional, Type, TypeVar, Union
 
 import pendulum
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 
 if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
+    from pydantic.v1 import BaseModel, Field, root_validator
+    from pydantic.v1.schema import default_ref_template
 else:
-    import pydantic
+    from pydantic import BaseModel, Field, root_validator
+    from pydantic.schema import default_ref_template
 
 from prefect.utilities.callables import get_call_parameters
 from prefect.utilities.importtools import (
@@ -31,7 +33,7 @@ from prefect.utilities.importtools import (
 )
 
 T = TypeVar("T", bound=Callable)
-M = TypeVar("M", bound=pydantic.BaseModel)
+M = TypeVar("M", bound=BaseModel)
 
 
 DEPRECATED_WARNING = (
@@ -207,7 +209,7 @@ def deprecated_field(
         ```python
 
         @deprecated_field("x", when=lambda x: x is not None)
-        class Model(pydantic.BaseModel)
+        class Model(BaseModel)
             x: Optional[int] = None
             y: str
         ```
@@ -276,3 +278,104 @@ def register_renamed_module(old_name: str, new_name: str, start_date: str):
     DEPRECATED_MODULE_ALIASES.append(
         AliasedModuleDefinition(old_name, new_name, callback)
     )
+
+
+class DeprecatedInfraOverridesField(BaseModel):
+    """
+    A model mixin that handles the deprecated `infra_overrides` field.
+
+    The `infra_overrides` field has been renamed to `job_variables`. This mixin maintains
+    backwards compatibility with users of the `infra_overrides` field while presenting
+    `job_variables` as the user-facing field.
+
+    When we remove support for `infra_overrides`, we can remove this class as a parent of
+    all schemas that use it, leaving them with only the `job_variables` field.
+    """
+
+    infra_overrides: Optional[Dict[str, Any]] = Field(
+        default_factory=dict,
+        description="Deprecated field. Use `job_variables` instead.",
+    )
+
+    @root_validator(pre=True)
+    def _job_variables_from_infra_overrides(
+        cls, values: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Validate that only one of `infra_overrides` or `job_variables` is used
+        and keep them in sync during init.
+        """
+        job_variables = values.get("job_variables")
+        infra_overrides = values.get("infra_overrides")
+
+        if job_variables is not None and infra_overrides is not None:
+            if job_variables != infra_overrides:
+                raise ValueError(
+                    "The `infra_overrides` field has been renamed to `job_variables`."
+                    "Use one of these fields, but not both."
+                )
+            return values
+        elif job_variables is not None and infra_overrides is None:
+            values["infra_overrides"] = job_variables
+        elif job_variables is None and infra_overrides is not None:
+            values["job_variables"] = infra_overrides
+        return values
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        """
+        Override the default __setattr__ to ensure that setting `infra_overrides` or
+        `job_variables` will update both fields.
+        """
+        if key == "infra_overrides" or key == "job_variables":
+            updates = {"infra_overrides": value, "job_variables": value}
+            self.__dict__.update(updates)
+            return
+        super().__setattr__(key, value)
+
+    def dict(self, **kwargs) -> Dict[str, Any]:
+        """
+        Override the default dict method to ensure only `infra_overrides` is serialized.
+        This preserves backwards compatibility for newer clients talking to older servers.
+        """
+        exclude: Union[set, Dict[str, Any]] = kwargs.pop("exclude", set())
+        exclude_type = type(exclude)
+
+        if exclude_type is set:
+            exclude.add("job_variables")
+        elif exclude_type is dict:
+            exclude["job_variables"] = True
+        kwargs["exclude"] = exclude
+
+        return super().dict(**kwargs)
+
+    @classmethod
+    def schema(
+        cls, by_alias: bool = True, ref_template: str = default_ref_template
+    ) -> Dict[str, Any]:
+        """
+        Don't use the mixin docstring as the description if this class is missing a
+        docstring.
+        """
+        schema = super().schema(by_alias=by_alias, ref_template=ref_template)
+
+        if not cls.__doc__:
+            schema.pop("description", None)
+
+        return schema
+
+
+def handle_deprecated_infra_overrides_parameter(
+    job_variables: Dict[str, Any], infra_overrides: Dict[str, Any]
+) -> Optional[Dict[str, Any]]:
+    if infra_overrides is not None and job_variables is not None:
+        raise RuntimeError(
+            "The `infra_overrides` argument has been renamed to `job_variables`."
+            "Use one or the other, but not both."
+        )
+    elif infra_overrides is not None and job_variables is None:
+        jv = infra_overrides
+    elif job_variables is not None and infra_overrides is None:
+        jv = job_variables
+    else:
+        jv = None
+    return jv

{prefect-client-2.16.8 → prefect-client-2.17.0}/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.17.0}/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.17.0}/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.17.0}/src/prefect/_internal/pydantic/__init__.py

@@ -6,21 +6,27 @@
 ### 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,
+    field_validator,
+    model_validator,
 )
 
+from ._types import IncEx
+
 __all__ = [
     "model_dump",
     "model_json_schema",
@@ -29,5 +35,12 @@ __all__ = [
     "model_dump_json",
     "model_copy",
     "model_validate_json",
+    "TypeAdapter",
     "validate_python",
+    "BaseModel",
+    "HAS_PYDANTIC_V2",
+    "Field",
+    "FieldInfo",
+    "field_validator",
+    "model_validator",
 ]

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

@@ -0,0 +1,51 @@
+"""
+This file introduces a conditional import of `BaseModel` from Pydantic, depending on the Pydantic version available. If Pydantic V2 is not used, it falls back to importing `BaseModel` from Pydantic V1. This is to ensure compatibility with different versions of Pydantic.
+"""
+import typing
+
+from prefect._internal.pydantic._flags import (
+    HAS_PYDANTIC_V2,
+    USE_PYDANTIC_V2,
+)
+
+if typing.TYPE_CHECKING:
+    from pydantic import (
+        BaseModel,
+        ConfigDict,
+        Field,
+        PrivateAttr,
+        SecretStr,
+        ValidationError,
+    )
+    from pydantic.fields import FieldInfo
+
+if HAS_PYDANTIC_V2 and not USE_PYDANTIC_V2:
+    from pydantic.v1 import (
+        BaseModel,
+        ConfigDict,
+        Field,
+        PrivateAttr,
+        SecretStr,
+        ValidationError,
+    )
+    from pydantic.v1.fields import FieldInfo
+else:
+    from pydantic import (
+        BaseModel,
+        ConfigDict,
+        Field,
+        PrivateAttr,
+        SecretStr,
+        ValidationError,
+    )
+    from pydantic.fields import FieldInfo
+
+__all__ = [
+    "BaseModel",
+    "Field",
+    "FieldInfo",
+    "PrivateAttr",
+    "SecretStr",
+    "ConfigDict",
+    "ValidationError",
+]

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

@@ -0,0 +1,81 @@
+"""
+Functions within this module check for Pydantic V2 compatibility and provide mechanisms for copying,
+ dumping, and validating models in a way that is agnostic to the underlying Pydantic version.
+"""
+import typing
+
+from ._base_model import BaseModel as PydanticBaseModel
+from ._base_model import (
+    ConfigDict,
+    Field,
+    FieldInfo,
+    PrivateAttr,
+    SecretStr,
+    ValidationError,
+)
+from ._flags import HAS_PYDANTIC_V2, USE_PYDANTIC_V2
+from .utilities.config_dict import ConfigMixin
+from .utilities.field_validator import field_validator
+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_fields_set import ModelFieldsSetMixin, model_fields_set
+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.model_validator import model_validator
+from .utilities.type_adapter import TypeAdapter, validate_python
+
+if typing.TYPE_CHECKING:
+
+    class BaseModel(PydanticBaseModel):  # type: ignore
+        pass
+
+elif 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,
+        ConfigMixin,
+        ModelFieldsSetMixin,
+        PydanticBaseModel,
+    ):
+        pass
+
+
+__all__ = [
+    "model_construct",
+    "model_copy",
+    "model_dump",
+    "model_dump_json",
+    "model_json_schema",
+    "model_validate",
+    "model_validate_json",
+    "model_fields_set",
+    "TypeAdapter",
+    "validate_python",
+    "BaseModel",
+    "Field",
+    "FieldInfo",
+    "field_validator",
+    "model_validator",
+    "PrivateAttr",
+    "SecretStr",
+    "ConfigDict",
+    "ValidationError",
+]

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

@@ -1,3 +1,6 @@
+"""
+This file defines flags that determine whether Pydantic V2 is available and whether its features should be used.
+"""
 import os
 
 # Retrieve current version of Pydantic installed in environment
@@ -11,5 +14,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.17.0/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"]