prefect-client 2.19.3__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

prefect/__init__.py

@@ -5,8 +5,6 @@
 from . import _version
 import importlib
 import pathlib
-import warnings
-import sys
 
 __version_info__ = _version.get_versions()
 __version__ = __version_info__["version"]
@@ -31,12 +29,13 @@ from prefect.deployments import deploy
 from prefect.states import State
 from prefect.logging import get_run_logger
 from prefect.flows import flow, Flow, serve
+from prefect.transactions import Transaction
 from prefect.tasks import task, Task
 from prefect.context import tags
 from prefect.manifests import Manifest
 from prefect.utilities.annotations import unmapped, allow_failure
 from prefect.results import BaseResult
-from prefect.engine import pause_flow_run, resume_flow_run, suspend_flow_run
+from prefect.flow_runs import pause_flow_run, resume_flow_run, suspend_flow_run
 from prefect.client.orchestration import get_client, PrefectClient
 from prefect.client.cloud import get_cloud_client, CloudClient
 import prefect.variables
@@ -44,14 +43,9 @@ import prefect.runtime
 
 # Import modules that register types
 import prefect.serializers
-import prefect.deprecated.data_documents
-import prefect.deprecated.packaging
 import prefect.blocks.kubernetes
 import prefect.blocks.notifications
 import prefect.blocks.system
-import prefect.infrastructure.process
-import prefect.infrastructure.kubernetes
-import prefect.infrastructure.container
 
 # Initialize the process-wide profile and registry at import time
 import prefect.context
@@ -61,14 +55,11 @@ prefect.context.initialize_object_registry()
 # Perform any forward-ref updates needed for Pydantic models
 import prefect.client.schemas
 
-prefect.context.FlowRunContext.update_forward_refs(Flow=Flow)
-prefect.context.TaskRunContext.update_forward_refs(Task=Task)
-prefect.client.schemas.State.update_forward_refs(
-    BaseResult=BaseResult, DataDocument=prefect.deprecated.data_documents.DataDocument
-)
-prefect.client.schemas.StateCreate.update_forward_refs(
-    BaseResult=BaseResult, DataDocument=prefect.deprecated.data_documents.DataDocument
-)
+prefect.context.FlowRunContext.model_rebuild()
+prefect.context.TaskRunContext.model_rebuild()
+prefect.client.schemas.State.model_rebuild()
+prefect.client.schemas.StateCreate.model_rebuild()
+Transaction.model_rebuild()
 
 
 prefect.plugins.load_extra_entrypoints()
@@ -82,57 +73,17 @@ prefect.logging.get_logger("profiles").debug(
 )
 
 # Ensure moved names are accessible at old locations
-import prefect.client
-
 prefect.client.get_client = get_client
 prefect.client.PrefectClient = PrefectClient
 
 
 from prefect._internal.compatibility.deprecated import (
     inject_renamed_module_alias_finder,
-    register_renamed_module,
 )
 
-register_renamed_module(
-    "prefect.packaging", "prefect.deprecated.packaging", start_date="Mar 2024"
-)
 inject_renamed_module_alias_finder()
 
 
-# Attempt to warn users who are importing Prefect 1.x attributes that they may
-# have accidentally installed Prefect 2.x
-
-PREFECT_1_ATTRIBUTES = [
-    "prefect.Client",
-    "prefect.Parameter",
-    "prefect.api",
-    "prefect.apply_map",
-    "prefect.case",
-    "prefect.config",
-    "prefect.context",
-    "prefect.flatten",
-    "prefect.mapped",
-    "prefect.models",
-    "prefect.resource_manager",
-]
-
-
-class Prefect1ImportInterceptor(importlib.abc.Loader):
-    def find_spec(self, fullname, path, target=None):
-        if fullname in PREFECT_1_ATTRIBUTES:
-            warnings.warn(
-                f"Attempted import of {fullname!r}, which is part of Prefect 1.x, while"
-                f" Prefect {__version__} is installed. If you're upgrading you'll need"
-                " to update your code, see the Prefect 2.x migration guide:"
-                " `https://orion-docs.prefect.io/migration_guide/`. Otherwise ensure"
-                " that your code is pinned to the expected version."
-            )
-
-
-if not hasattr(sys, "frozen"):
-    sys.meta_path.insert(0, Prefect1ImportInterceptor())
-
-
 # Declare API for type-checkers
 __all__ = [
     "allow_failure",
@@ -145,6 +96,7 @@ __all__ = [
     "tags",
     "task",
     "Task",
+    "Transaction",
     "unmapped",
     "serve",
     "deploy",

prefect/_internal/compatibility/deprecated.py

@@ -9,21 +9,14 @@ Deprecated items require a start or end date. If a start date is given, the end
 will be calculated 6 months later. Start and end dates are always in the format MMM YYYY
 e.g. Jan 2023.
 """
+
 import functools
 import sys
 import warnings
-from typing import Any, Callable, Dict, List, Optional, Type, TypeVar, Union
+from typing import Any, Callable, List, Optional, Type, TypeVar
 
 import pendulum
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import BaseModel, Field, root_validator
-    from pydantic.v1.schema import default_ref_template
-else:
-    from pydantic import BaseModel, Field, root_validator
-    from pydantic.schema import default_ref_template
+from pydantic import BaseModel
 
 from prefect.utilities.callables import get_call_parameters
 from prefect.utilities.importtools import (
@@ -237,9 +230,10 @@ def deprecated_field(
 
             cls_init(__pydantic_self__, **data)
 
-            field = __pydantic_self__.__fields__.get(name)
+            field = __pydantic_self__.model_fields.get(name)
             if field is not None:
-                field.field_info.extra["deprecated"] = True
+                field.json_schema_extra = field.json_schema_extra or {}
+                field.json_schema_extra["deprecated"] = True
 
         # Patch the model's init method
         model_cls.__init__ = __init__
@@ -278,106 +272,3 @@ 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
-        else:
-            exclude = {"job_variables"}
-        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/_internal/compatibility/experimental.py

@@ -13,21 +13,11 @@ Some experimental features require opt-in to enable any usage. These require the
 
 import functools
 import warnings
-from typing import Any, Callable, Optional, Set, Type, TypeVar
+from typing import Any, Callable, Optional, Set, TypeVar
 
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
+import pydantic
 
-if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
-else:
-    import pydantic
-
-from prefect.settings import (
-    PREFECT_EXPERIMENTAL_WARN,
-    SETTING_VARIABLES,
-    Setting,
-    automation_settings_enabled,
-)
+from prefect.settings import PREFECT_EXPERIMENTAL_WARN, SETTING_VARIABLES, Setting
 from prefect.utilities.callables import get_call_parameters
 
 T = TypeVar("T", bound=Callable[..., Any])
@@ -194,77 +184,12 @@ def experimental_parameter(
     return decorator
 
 
-def experimental_field(
-    name: str,
-    *,
-    group: str,
-    help: str = "",
-    stacklevel: int = 2,
-    opt_in: bool = False,
-    when: Optional[Callable[[Any], bool]] = None,
-):
-    """
-    Mark a field in a Pydantic model as experimental.
-
-    Raises warning only if the field is specified during init.
-
-    Example:
-
-        ```python
-
-        @experimental_parameter("y", group="example", when=lambda y: y is not None)
-        def foo(x, y = None):
-            return x + 1 + (y or 0)
-        ```
-    """
-
-    when = when or (lambda _: True)
-
-    @experimental(
-        group=group,
-        feature=f"The field {name!r}",
-        help=help,
-        opt_in=opt_in,
-        stacklevel=stacklevel + 2,
-    )
-    def experimental_check():
-        """Utility function for performing a warning check for the specified group"""
-
-    # Replaces the model's __init__ method with one that performs an additional warning
-    # check
-    def decorator(model_cls: Type[M]) -> Type[M]:
-        cls_init = model_cls.__init__
-
-        @functools.wraps(model_cls.__init__)
-        def __init__(__pydantic_self__, **data: Any) -> None:
-            # Call the original init
-            cls_init(__pydantic_self__, **data)
-            # Perform warning check
-            if name in data.keys() and when(data[name]):
-                experimental_check()
-            field = __pydantic_self__.__fields__.get(name)
-            if field is not None:
-                field.field_info.extra["experimental"] = True
-                field.field_info.extra["experimental-group"] = group
-
-        # Patch the model's init method
-        model_cls.__init__ = __init__
-
-        return model_cls
-
-    return decorator
-
-
 def enabled_experiments() -> Set[str]:
     """
     Return the set of all enabled experiments.
     """
-    enabled_experimental_settings = {
+    return {
         name[len("PREFECT_EXPERIMENTAL_ENABLE_") :].lower()
         for name, setting in SETTING_VARIABLES.items()
         if name.startswith("PREFECT_EXPERIMENTAL_ENABLE_") and setting.value()
     }
-    if automation_settings_enabled():
-        enabled_experimental_settings.add("automations")
-
-    return enabled_experimental_settings

prefect/_internal/concurrency/api.py

@@ -6,7 +6,6 @@ import abc
 import asyncio
 import concurrent.futures
 import contextlib
-import threading
 from typing import (
     Awaitable,
     Callable,
@@ -19,7 +18,6 @@ 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,
@@ -29,7 +27,6 @@ from prefect._internal.concurrency.waiters import (
     AsyncWaiter,
     Call,
     SyncWaiter,
-    get_waiter_for_thread,
 )
 
 P = ParamSpec("P")
@@ -163,22 +160,6 @@ class from_async(_base):
         await waiter.wait()
         return call.result()
 
-    @staticmethod
-    def call_soon_in_waiting_thread(
-        __call: Union[Callable[[], T], Call[T]],
-        thread: threading.Thread,
-        timeout: Optional[float] = None,
-    ) -> 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(
         __call: Union[Callable[[], T], Call[T]], timeout: Optional[float] = None
@@ -231,21 +212,6 @@ class from_sync(_base):
         waiter.wait()
         return call.result()
 
-    @staticmethod
-    def call_soon_in_waiting_thread(
-        __call: Union[Callable[[], T], Call[T]],
-        thread: threading.Thread,
-        timeout: Optional[float] = None,
-    ) -> 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(
         __call: Union[Callable[[], T], Call[T]], timeout: Optional[float] = None

prefect/_internal/concurrency/calls.py

@@ -49,12 +49,6 @@ current_call: contextvars.ContextVar["weakref.ref[Call]"] = (  # novm
 _ASYNC_TASK_REFS = set()
 
 
-def get_current_call() -> Optional["Call"]:
-    call_ref = current_call.get(None)
-    if call_ref:
-        return call_ref()
-
-
 @contextlib.contextmanager
 def set_current_call(call: "Call"):
     token = current_call.set(weakref.ref(call))

prefect/_internal/concurrency/cancellation.py

@@ -76,9 +76,6 @@ class ThreadShield:
 
 
 class CancelledError(asyncio.CancelledError):
-    # In Python 3.7, `asyncio.CancelledError` is identical to `concurrent.futures.CancelledError`
-    # but in 3.8+ it is a separate class that inherits from `BaseException` instead
-    # See https://bugs.python.org/issue32528
     # We want our `CancelledError` to be treated as a `BaseException` and defining it
     # here simplifies downstream logic that needs to know "which" cancelled error to
     # handle.

prefect/_internal/concurrency/event_loop.py

@@ -25,26 +25,6 @@ def get_running_loop() -> Optional[asyncio.BaseEventLoop]:
         return None
 
 
-def call_in_loop(
-    __loop: asyncio.AbstractEventLoop,
-    __fn: Callable[P, T],
-    *args: P.args,
-    **kwargs: P.kwargs,
-) -> T:
-    """
-    Run a synchronous call in event loop's thread from another thread.
-
-    This function is blocking and not safe to call from an asynchronous context.
-
-    Returns the result of the call.
-    """
-    if __loop is get_running_loop():
-        return __fn(*args, **kwargs)
-    else:
-        future = call_soon_in_loop(__loop, __fn, *args, **kwargs)
-        return future.result()
-
-
 def call_soon_in_loop(
     __loop: asyncio.AbstractEventLoop,
     __fn: Callable[P, T],

prefect/_internal/concurrency/inspection.py

@@ -7,10 +7,10 @@ import linecache
 import sys
 import threading
 from types import FrameType
-from typing import List
+from typing import List, Optional
 
 """
-The following functions are derived from dask/distributed which is licensed under the 
+The following functions are derived from dask/distributed which is licensed under the
 BSD 3-Clause License.
 
 Copyright (c) 2015, Anaconda, Inc. and contributors
@@ -75,7 +75,7 @@ def repr_frame(frame: FrameType) -> str:
 def call_stack(frame: FrameType) -> List[str]:
     """Create a call text stack from a frame"""
     L = []
-    cur_frame: FrameType | None = frame
+    cur_frame: Optional[FrameType] = frame
     while cur_frame:
         L.append(repr_frame(cur_frame))
         cur_frame = cur_frame.f_back

prefect/_internal/concurrency/threads.py

@@ -1,6 +1,7 @@
 """
 Utilities for managing worker threads.
 """
+
 import asyncio
 import atexit
 import concurrent.futures
@@ -233,7 +234,10 @@ class EventLoopThread(Portal):
         self.shutdown()
 
 
+# the GLOBAL LOOP is used for background services, like logs
 GLOBAL_LOOP: Optional[EventLoopThread] = None
+# the RUN SYNC LOOP is used exclusively for running async functions in a sync context via asyncutils.run_sync
+RUN_SYNC_LOOP: Optional[EventLoopThread] = None
 
 
 def get_global_loop() -> EventLoopThread:
@@ -267,6 +271,37 @@ def in_global_loop() -> bool:
     return get_global_loop()._loop == get_running_loop()
 
 
+def get_run_sync_loop() -> EventLoopThread:
+    """
+    Get the run_sync loop thread.
+
+    Creates a new one if there is not one available.
+    """
+    global RUN_SYNC_LOOP
+
+    # Create a new worker on first call or if the existing worker is dead
+    if (
+        RUN_SYNC_LOOP is None
+        or not RUN_SYNC_LOOP.thread.is_alive()
+        or RUN_SYNC_LOOP._shutdown_event.is_set()
+    ):
+        RUN_SYNC_LOOP = EventLoopThread(daemon=True, name="RunSyncEventLoopThread")
+        RUN_SYNC_LOOP.start()
+
+    return RUN_SYNC_LOOP
+
+
+def in_run_sync_loop() -> bool:
+    """
+    Check if called from the global loop.
+    """
+    if RUN_SYNC_LOOP is None:
+        # Avoid creating a global loop if there isn't one
+        return False
+
+    return get_run_sync_loop()._loop == get_running_loop()
+
+
 def wait_for_global_loop_exit(timeout: Optional[float] = None) -> None:
     """
     Shutdown the global loop and wait for it to exit.

prefect/_internal/concurrency/waiters.py

@@ -29,34 +29,6 @@ _WAITERS_BY_THREAD: "WeakKeyDictionary[threading.Thread, deque[Waiter]]" = (
 )
 
 
-def get_waiter_for_thread(
-    thread: threading.Thread, parent_call: Optional[Call] = None
-) -> Optional["Waiter"]:
-    """
-    Get the current waiter for a thread and an optional parent call.
-
-    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: "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):
     """
     Add a waiter for a thread.

prefect/_internal/pydantic/__init__.py

@@ -1,46 +1 @@
-### A convenience module to allow for easy switching between pydantic versions.
 
-### Note this introduces a marginally worse import time, since
-### the import of any one of these symbols will import all of them.
-
-### This is a tradeoff we're willing to make for now until pydantic v1 is
-### no longer supported.
-
-
-from ._flags import HAS_PYDANTIC_V2
-
-from ._compat import (
-    model_dump,
-    model_json_schema,
-    model_validate,
-    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",
-    "model_validate",
-    "IncEx",
-    "model_dump_json",
-    "model_copy",
-    "model_validate_json",
-    "TypeAdapter",
-    "validate_python",
-    "BaseModel",
-    "HAS_PYDANTIC_V2",
-    "Field",
-    "FieldInfo",
-    "field_validator",
-    "model_validator",
-]