prefect-client 2.20.4__py3-none-any.whl → 3.0.0__py3-none-any.whl

prefect/__init__.py

@@ -5,8 +5,7 @@
 from . import _version
 import importlib
 import pathlib
-import warnings
-import sys
+from typing import TYPE_CHECKING, Any
 
 __version_info__ = _version.get_versions()
 __version__ = __version_info__["version"]
@@ -25,113 +24,53 @@ __ui_static_path__ = __module_path__ / "server" / "ui"
 
 del _version, pathlib
 
-
-# Import user-facing API
-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.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.client.orchestration import get_client, PrefectClient
-from prefect.client.cloud import get_cloud_client, CloudClient
-import prefect.variables
-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
-
-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.plugins.load_extra_entrypoints()
-
-# Configure logging
-import prefect.logging.configuration
-
-prefect.logging.configuration.setup_logging()
-prefect.logging.get_logger("profiles").debug(
-    f"Using profile {prefect.context.get_settings_context().profile.name!r}"
-)
-
-# 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())
-
+if TYPE_CHECKING:
+    from .main import (
+        allow_failure,
+        flow,
+        Flow,
+        get_client,
+        get_run_logger,
+        State,
+        tags,
+        task,
+        Task,
+        Transaction,
+        unmapped,
+        serve,
+        deploy,
+        pause_flow_run,
+        resume_flow_run,
+        suspend_flow_run,
+    )
+
+_slots: dict[str, Any] = {
+    "__version_info__": __version_info__,
+    "__version__": __version__,
+    "__module_path__": __module_path__,
+    "__development_base_path__": __development_base_path__,
+    "__ui_static_subpath__": __ui_static_subpath__,
+    "__ui_static_path__": __ui_static_path__,
+}
+
+_public_api: dict[str, tuple[str, str]] = {
+    "allow_failure": (__spec__.parent, ".main"),
+    "flow": (__spec__.parent, ".main"),
+    "Flow": (__spec__.parent, ".main"),
+    "get_client": (__spec__.parent, ".main"),
+    "get_run_logger": (__spec__.parent, ".main"),
+    "State": (__spec__.parent, ".main"),
+    "tags": (__spec__.parent, ".main"),
+    "task": (__spec__.parent, ".main"),
+    "Task": (__spec__.parent, ".main"),
+    "Transaction": (__spec__.parent, ".main"),
+    "unmapped": (__spec__.parent, ".main"),
+    "serve": (__spec__.parent, ".main"),
+    "deploy": (__spec__.parent, ".main"),
+    "pause_flow_run": (__spec__.parent, ".main"),
+    "resume_flow_run": (__spec__.parent, ".main"),
+    "suspend_flow_run": (__spec__.parent, ".main"),
+}
 
 # Declare API for type-checkers
 __all__ = [
@@ -140,15 +79,40 @@ __all__ = [
     "Flow",
     "get_client",
     "get_run_logger",
-    "Manifest",
     "State",
     "tags",
     "task",
     "Task",
+    "Transaction",
     "unmapped",
     "serve",
     "deploy",
     "pause_flow_run",
     "resume_flow_run",
     "suspend_flow_run",
+    "__version_info__",
+    "__version__",
+    "__module_path__",
+    "__development_base_path__",
+    "__ui_static_subpath__",
+    "__ui_static_path__",
 ]
+
+
+def __getattr__(attr_name: str) -> object:
+    if attr_name in _slots:
+        return _slots[attr_name]
+
+    dynamic_attr = _public_api.get(attr_name)
+    if dynamic_attr is None:
+        return importlib.import_module(f".{attr_name}", package=__name__)
+
+    package, module_name = dynamic_attr
+
+    from importlib import import_module
+
+    if module_name == "__module__":
+        return import_module(f".{attr_name}", package=package)
+    else:
+        module = import_module(module_name, package=package)
+        return getattr(module, attr_name)

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/compatibility/migration.py

@@ -0,0 +1,166 @@
+"""
+This module provides a function to handle imports for moved or removed objects in Prefect 3.0 upgrade.
+
+The `getattr_migration` function is used to handle imports for moved or removed objects in Prefect 3.0 upgrade.
+It is used in the `__getattr__` attribute of modules that have moved or removed objects.
+
+Usage:
+
+Moved objects:
+1. Add the old and new path to the `MOVED_IN_V3` dictionary, e.g. `MOVED_IN_V3 = {"old_path": "new_path"}`
+2. In the module where the object was moved from, add the following lines:
+    ```python
+    # at top
+    from prefect._internal.compatibility.migration import getattr_migration
+
+    # at bottom
+    __getattr__ = getattr_migration(__name__)
+    ```
+
+    Example at src/prefect/engine.py
+
+Removed objects:
+1. Add the old path and error message to the `REMOVED_IN_V3` dictionary, e.g. `REMOVED_IN_V3 = {"old_path": "error_message"}`
+2. In the module where the object was removed, add the following lines:
+    ```python
+    # at top
+    from prefect._internal.compatibility.migration import getattr_migration
+
+    # at bottom
+    __getattr__ = getattr_migration(__name__)
+
+    ```
+    If the entire old module was removed, add a stub for the module with the following lines:
+    ```python
+    # at top
+    from prefect._internal.compatibility.migration import getattr_migration
+    
+    # at bottom
+    __getattr__ = getattr_migration(__name__)
+    ```
+
+    Example at src/prefect/infrastructure/base.py
+"""
+
+import sys
+from typing import Any, Callable, Dict
+
+from pydantic_core import PydanticCustomError
+
+from prefect.exceptions import PrefectImportError
+
+MOVED_IN_V3 = {
+    "prefect.deployments.deployments:load_flow_from_flow_run": "prefect.flows:load_flow_from_flow_run",
+    "prefect.deployments:load_flow_from_flow_run": "prefect.flows:load_flow_from_flow_run",
+    "prefect.variables:get": "prefect.variables:Variable.get",
+    "prefect.engine:pause_flow_run": "prefect.flow_runs:pause_flow_run",
+    "prefect.engine:resume_flow_run": "prefect.flow_runs:resume_flow_run",
+    "prefect.engine:suspend_flow_run": "prefect.flow_runs:suspend_flow_run",
+    "prefect.engine:_in_process_pause": "prefect.flow_runs:_in_process_pause",
+    "prefect.client:get_client": "prefect.client.orchestration:get_client",
+}
+
+upgrade_guide_msg = "Refer to the upgrade guide for more information: https://docs.prefect.io/latest/guides/upgrade-guide-agents-to-workers/."
+
+REMOVED_IN_V3 = {
+    "prefect.client.schemas.objects:MinimalDeploymentSchedule": "Use `prefect.client.schemas.actions.DeploymentScheduleCreate` instead.",
+    "prefect.context:PrefectObjectRegistry": upgrade_guide_msg,
+    "prefect.deployments.deployments:Deployment": "Use `flow.serve()`, `flow.deploy()`, or `prefect deploy` instead.",
+    "prefect.deployments:Deployment": "Use `flow.serve()`, `flow.deploy()`, or `prefect deploy` instead.",
+    "prefect.filesystems:GCS": "Use `prefect_gcp.GcsBucket` instead.",
+    "prefect.filesystems:Azure": "Use `prefect_azure.AzureBlobStorageContainer` instead.",
+    "prefect.filesystems:S3": "Use `prefect_aws.S3Bucket` instead.",
+    "prefect.filesystems:GitHub": "Use `prefect_github.GitHubRepository` instead.",
+    "prefect.engine:_out_of_process_pause": "Use `prefect.flow_runs.pause_flow_run` instead.",
+    "prefect.agent:PrefectAgent": "Use workers instead. " + upgrade_guide_msg,
+    "prefect.infrastructure:KubernetesJob": "Use workers instead. " + upgrade_guide_msg,
+    "prefect.infrastructure.base:Infrastructure": "Use the `BaseWorker` class to create custom infrastructure integrations instead. "
+    + upgrade_guide_msg,
+    "prefect.workers.block:BlockWorkerJobConfiguration": upgrade_guide_msg,
+    "prefect.workers.cloud:BlockWorker": upgrade_guide_msg,
+}
+
+# IMPORTANT FOR USAGE: When adding new modules to MOVED_IN_V3 or REMOVED_IN_V3, include the following lines at the bottom of that module:
+# from prefect._internal.compatibility.migration import getattr_migration
+# __getattr__ = getattr_migration(__name__)
+# See src/prefect/filesystems.py for an example
+
+
+def import_string_class_method(new_location: str) -> Callable:
+    """
+    Handle moved class methods.
+
+    `import_string` does not account for moved class methods. This function handles cases where a method has been
+    moved to a class. For example, if `new_location` is 'prefect.variables:Variable.get', `import_string(new_location)`
+    will raise an error because it does not handle class methods. This function will import the class and get the
+    method from the class.
+
+    Args:
+        new_location (str): The new location of the method.
+
+    Returns:
+        method: The resolved method from the class.
+
+    Raises:
+        PrefectImportError: If the method is not found in the class.
+    """
+    from pydantic._internal._validators import import_string
+
+    class_name, method_name = new_location.rsplit(".", 1)
+
+    cls = import_string(class_name)
+    method = getattr(cls, method_name, None)
+
+    if method is not None and callable(method):
+        return method
+
+    raise PrefectImportError(f"Unable to import {new_location!r}")
+
+
+def getattr_migration(module_name: str) -> Callable[[str], Any]:
+    """
+    Handle imports for moved or removed objects in Prefect 3.0 upgrade
+
+    Args:
+        module_name (str): The name of the module to handle imports for.
+    """
+
+    def wrapper(name: str) -> object:
+        """
+        Raise a PrefectImportError if the object is not found, moved, or removed.
+        """
+
+        if name == "__path__":
+            raise AttributeError(f"{module_name!r} object has no attribute {name!r}")
+        import warnings
+
+        from pydantic._internal._validators import import_string
+
+        import_path = f"{module_name}:{name}"
+
+        # Check if the attribute name corresponds to a moved or removed class or module
+        if import_path in MOVED_IN_V3.keys():
+            new_location = MOVED_IN_V3[import_path]
+            warnings.warn(
+                f"{import_path!r} has been moved to {new_location!r}. Importing from {new_location!r} instead. This warning will raise an error in a future release.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            try:
+                return import_string(new_location)
+            except PydanticCustomError:
+                return import_string_class_method(new_location)
+
+        if import_path in REMOVED_IN_V3.keys():
+            error_message = REMOVED_IN_V3[import_path]
+            raise PrefectImportError(
+                f"`{import_path}` has been removed. {error_message}"
+            )
+
+        globals: Dict[str, Any] = sys.modules[module_name].__dict__
+        if name in globals:
+            return globals[name]
+
+        raise AttributeError(f"module {module_name!r} has no attribute {name!r}")
+
+    return wrapper

prefect/_internal/concurrency/__init__.py

@@ -5,7 +5,7 @@ both asynchronous and synchronous calls.
 Much of the complexity managed here arises from ensuring that a thread of execution is
 not blocked.
 
-The main data structure is a `Call` which is created from a function call capturing 
+The main data structure is a `Call` which is created from a function call capturing
 local context variables. The call is then submitted to run somewhere via a `Portal`.
 The primary portal used is the `WorkerThread`, which executes work on a thread running
 concurrently to the one that created the call. A singleton `EventLoopThread` portal
@@ -13,7 +13,7 @@ is also used to schedule work on a dedicated event loop.
 
 The result of the call can be retrieved asynchronously using `Call.result()`. Behind
 the scenes, a `Future` is used to report the result of the call. Retrieving the result
-of a call is a blocking operation. 
+of a call is a blocking operation.
 
 Sometimes, it is important not to block the current thread while retrieving the result
 of a call. For this purpose, there is the `Waiter`. Waiters attach to a call and provide