prefect-client 2.16.8__py3-none-any.whl → 2.17.0__py3-none-any.whl

prefect/logging/configuration.py

@@ -6,7 +6,7 @@ import string
 import warnings
 from functools import partial
 from pathlib import Path
-from typing import Optional
+from typing import Any, Dict, Optional
 
 import yaml
 
@@ -21,7 +21,7 @@ from prefect.utilities.collections import dict_to_flatdict, flatdict_to_dict
 DEFAULT_LOGGING_SETTINGS_PATH = Path(__file__).parent / "logging.yml"
 
 # Stores the configuration used to setup logging in this Python process
-PROCESS_LOGGING_CONFIG: dict = None
+PROCESS_LOGGING_CONFIG: Optional[Dict[str, Any]] = None
 
 # Regex call to replace non-alphanumeric characters to '_' to create a valid env var
 to_envvar = partial(re.sub, re.compile(r"[^0-9a-zA-Z]+"), "_")

prefect/manifests.py

@@ -4,14 +4,7 @@ Manifests are portable descriptions of one or more workflows within a given dire
 They are the foundational building blocks for defining Flow Deployments.
 """
 
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import BaseModel, Field
-else:
-    from pydantic import BaseModel, Field
-
+from prefect.pydantic import BaseModel, Field
 from prefect.utilities.callables import ParameterSchema
 
 

prefect/profiles.toml

@@ -1,3 +1,3 @@
 active = "default"
 
-[profiles.default]
+[profiles.default]

prefect/pydantic/__init__.py

@@ -1,4 +1,76 @@
-from .main import BaseModel, PrefectBaseModel
+"""
+This initialization file makes the `BaseModel` and `PrefectBaseModel` classes available for import from the pydantic module within Prefect. This setup allows other parts of the Prefect codebase to use these models without needing to understand the underlying compatibility layer.
+"""
+import typing
+from prefect._internal.pydantic._flags import HAS_PYDANTIC_V2, USE_PYDANTIC_V2
 
+if typing.TYPE_CHECKING:
+    # import of virtually everything is supported via `__getattr__` below,
+    # but we need them here for type checking and IDE support
+    from pydantic import validator, root_validator
+    from .main import (
+        BaseModel,
+        PrefectBaseModel,
+        FieldInfo,
+        Field,
+        PrivateAttr,
+        SecretStr,
+        field_validator,
+        model_validator,
+        ConfigDict,
+        ValidationError,
+    )
 
-__all__ = ["BaseModel", "PrefectBaseModel"]
+__all__ = [
+    "BaseModel",
+    "PrefectBaseModel",
+    "Field",
+    "FieldInfo",
+    "PrivateAttr",
+    "SecretStr",
+    "validator",
+    "root_validator",
+    "field_validator",
+    "model_validator",
+    "ConfigDict",
+    "ValidationError",
+]
+
+_dynamic_imports: "typing.Dict[str, typing.Tuple[str, str]]" = {
+    "BaseModel": ("prefect.pydantic", ".main"),
+    "PrefectBaseModel": ("prefect.pydantic", ".main"),
+    "Field": ("prefect.pydantic", ".main"),
+    "FieldInfo": ("prefect.pydantic", ".main"),
+    "PrivateAttr": ("prefect.pydantic", ".main"),
+    "SecretStr": ("prefect.pydantic", ".main"),
+    "field_validator": ("prefect.pydantic", ".main"),
+    "model_validator": ("prefect.pydantic", ".main"),
+    "ConfigDict": ("prefect.pydantic", ".main"),
+    "ValidationError": ("prefect.pydantic", ".main"),
+}
+
+
+def __getattr__(attr_name: str) -> object:
+    from importlib import import_module
+
+    if attr_name in _dynamic_imports:
+        # If the attribute is in the dynamic imports, import it from the specified module
+        package, module_name = _dynamic_imports[attr_name]
+
+        # Prevent recursive import
+        if module_name == "__module__":
+            return import_module(f".{attr_name}", package=package)
+
+        # Import the module and return the attribute
+        else:
+            module = import_module(module_name, package=package)
+            return getattr(module, attr_name)
+
+    elif HAS_PYDANTIC_V2 and not USE_PYDANTIC_V2:
+        # In this case, we are using Pydantic v2 but it is not enabled, so we should import from pydantic.v1
+        module = import_module("pydantic.v1")
+        return getattr(module, attr_name)
+    else:
+        # In this case, we are using either Pydantic v1 or Pydantic v2 is enabled, so we should import from pydantic
+        module = import_module("pydantic")
+        return getattr(module, attr_name)

prefect/pydantic/main.py

@@ -1,6 +1,19 @@
+"""
+This file defines a `PrefectBaseModel` class that extends the `BaseModel` (imported from the internal compatibility layer).
+"""
 import typing
 
-from prefect._internal.pydantic._compat import BaseModel
+from prefect._internal.pydantic._compat import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    FieldInfo,
+    PrivateAttr,
+    SecretStr,
+    ValidationError,
+    field_validator,
+    model_validator,
+)
 
 
 class PrefectBaseModel(BaseModel):
@@ -12,4 +25,15 @@ class PrefectBaseModel(BaseModel):
         return set()
 
 
-__all__ = ["BaseModel", "PrefectBaseModel"]
+__all__ = [
+    "BaseModel",
+    "PrefectBaseModel",
+    "Field",
+    "FieldInfo",
+    "PrivateAttr",
+    "SecretStr",
+    "field_validator",
+    "model_validator",
+    "ConfigDict",
+    "ValidationError",
+]

prefect/serializers.py

@@ -10,10 +10,10 @@ the instance so the same settings can be used to load saved objects.
 All serializers must implement `dumps` and `loads` which convert objects to bytes and
 bytes to an object respectively.
 """
+
 import abc
 import base64
-import warnings
-from typing import Any, Generic, Optional, TypeVar
+from typing import Any, Dict, Generic, Optional, TypeVar
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect._internal.schemas.validators import (
@@ -22,6 +22,7 @@ from prefect._internal.schemas.validators import (
     validate_dump_kwargs,
     validate_load_kwargs,
     validate_picklelib,
+    validate_picklelib_version,
 )
 
 if HAS_PYDANTIC_V2:
@@ -112,33 +113,7 @@ class PickleSerializer(Serializer):
 
     @pydantic.root_validator
     def check_picklelib_version(cls, values):
-        """
-        Infers a default value for `picklelib_version` if null or ensures it matches
-        the version retrieved from the `pickelib`.
-        """
-        picklelib = values.get("picklelib")
-        picklelib_version = values.get("picklelib_version")
-
-        if not picklelib:
-            raise ValueError("Unable to check version of unrecognized picklelib module")
-
-        pickler = from_qualified_name(picklelib)
-        pickler_version = getattr(pickler, "__version__", None)
-
-        if not picklelib_version:
-            values["picklelib_version"] = pickler_version
-        elif picklelib_version != pickler_version:
-            warnings.warn(
-                (
-                    f"Mismatched {picklelib!r} versions. Found {pickler_version} in the"
-                    f" environment but {picklelib_version} was requested. This may"
-                    " cause the serializer to fail."
-                ),
-                RuntimeWarning,
-                stacklevel=3,
-            )
-
-        return values
+        return validate_picklelib_version(values)
 
     def dumps(self, obj: Any) -> bytes:
         pickler = from_qualified_name(self.picklelib)
@@ -178,8 +153,8 @@ class JSONSerializer(Serializer):
             "by our default `object_encoder`."
         ),
     )
-    dumps_kwargs: dict = pydantic.Field(default_factory=dict)
-    loads_kwargs: dict = pydantic.Field(default_factory=dict)
+    dumps_kwargs: Dict[str, Any] = pydantic.Field(default_factory=dict)
+    loads_kwargs: Dict[str, Any] = pydantic.Field(default_factory=dict)
 
     @pydantic.validator("dumps_kwargs")
     def dumps_kwargs_cannot_contain_default(cls, value):

prefect/settings.py

@@ -68,6 +68,7 @@ from urllib.parse import urlparse
 import toml
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
+from prefect._internal.schemas.validators import validate_settings
 
 if HAS_PYDANTIC_V2:
     from pydantic.v1 import (
@@ -106,6 +107,8 @@ DEFAULT_PROFILES_PATH = Path(__file__).parent.joinpath("profiles.toml")
 REMOVED_EXPERIMENTAL_FLAGS = {
     "PREFECT_EXPERIMENTAL_ENABLE_ENHANCED_SCHEDULING_UI",
     "PREFECT_EXPERIMENTAL_ENABLE_ENHANCED_DEPLOYMENT_PARAMETERS",
+    "PREFECT_EXPERIMENTAL_ENABLE_EVENTS_CLIENT",
+    "PREFECT_EXPERIMENTAL_WARN_EVENTS_CLIENT",
 }
 
 
@@ -577,6 +580,14 @@ PREFECT_UNIT_TEST_MODE = Setting(
 This variable only exists to facilitate unit testing. If `True`,
 code is executing in a unit test context. Defaults to `False`.
 """
+PREFECT_UNIT_TEST_LOOP_DEBUG = Setting(
+    bool,
+    default=True,
+)
+"""
+If `True` turns on debug mode for the unit testing event loop.
+Defaults to `False`.
+"""
 
 PREFECT_TEST_SETTING = Setting(
     Any,
@@ -1358,16 +1369,6 @@ PREFECT_EXPERIMENTAL_ENABLE_STATES_ON_FLOW_RUN_GRAPH = Setting(bool, default=Tru
 Whether or not to enable flow run states on the flow run graph.
 """
 
-PREFECT_EXPERIMENTAL_ENABLE_EVENTS_CLIENT = Setting(bool, default=True)
-"""
-Whether or not to enable experimental Prefect work pools.
-"""
-
-PREFECT_EXPERIMENTAL_WARN_EVENTS_CLIENT = Setting(bool, default=False)
-"""
-Whether or not to warn when experimental Prefect work pools are used.
-"""
-
 PREFECT_EXPERIMENTAL_ENABLE_WORK_POOLS = Setting(bool, default=True)
 """
 Whether or not to enable experimental Prefect work pools.
@@ -1629,8 +1630,26 @@ The directory to serve static files from. This should be used when running into
 when attempting to serve the UI from the default directory (for example when running in a Docker container)
 """
 
+# Messaging system settings
+
+PREFECT_MESSAGING_BROKER = Setting(
+    str, default="prefect.server.utilities.messaging.memory"
+)
+"""
+Which message broker implementation to use for the messaging system, should point to a
+module that exports a Publisher and Consumer class.
+"""
+
+PREFECT_MESSAGING_CACHE = Setting(
+    str, default="prefect.server.utilities.messaging.memory"
+)
+"""
+Which cache implementation to use for the events system.  Should point to a module that
+exports a Cache class.
+"""
 
-# Events settings ------------------------------------------------------------------
+
+# Events settings
 
 PREFECT_EVENTS_MAXIMUM_LABELS_PER_RESOURCE = Setting(int, default=500)
 """
@@ -1642,13 +1661,53 @@ PREFECT_EVENTS_MAXIMUM_RELATED_RESOURCES = Setting(int, default=500)
 The maximum number of related resources an Event may have.
 """
 
+PREFECT_EVENTS_MAXIMUM_SIZE_BYTES = Setting(int, default=1_500_000)
+"""
+The maximum size of an Event when serialized to JSON
+"""
+
+PREFECT_API_SERVICES_EVENT_LOGGER_ENABLED = Setting(bool, default=True)
+"""
+Whether or not to start the event debug logger service in the server application.
+"""
+
+PREFECT_API_SERVICES_TRIGGERS_ENABLED = Setting(bool, default=True)
+"""
+Whether or not to start the triggers service in the server application.
+"""
+
+PREFECT_EVENTS_EXPIRED_BUCKET_BUFFER = Setting(timedelta, default=timedelta(seconds=60))
+"""
+The amount of time to retain expired automation buckets
+"""
+
+PREFECT_EVENTS_PROACTIVE_GRANULARITY = Setting(timedelta, default=timedelta(seconds=5))
+"""
+How frequently proactive automations are evaluated
+"""
+
+PREFECT_API_SERVICES_EVENT_PERSISTER_ENABLED = Setting(bool, default=True)
+"""
+Whether or not to start the event persister service in the server application.
+"""
+
+PREFECT_API_SERVICES_EVENT_PERSISTER_BATCH_SIZE = Setting(int, default=20, gt=0)
+"""
+The number of events the event persister will attempt to insert in one batch.
+"""
+
+PREFECT_API_SERVICES_EVENT_PERSISTER_FLUSH_INTERVAL = Setting(float, default=5, gt=0.0)
+"""
+The maximum number of seconds between flushes of the event persister.
+"""
+
 
 # Deprecated settings ------------------------------------------------------------------
 
 
 # Collect all defined settings ---------------------------------------------------------
 
-SETTING_VARIABLES = {
+SETTING_VARIABLES: Dict[str, Any] = {
     name: val for name, val in tuple(globals().items()) if isinstance(val, Setting)
 }
 
@@ -1947,20 +2006,7 @@ class Profile(BaseModel):
 
     @validator("settings", pre=True)
     def map_names_to_settings(cls, value):
-        if value is None:
-            return value
-
-        # Cast string setting names to variables
-        validated = {}
-        for setting, val in value.items():
-            if isinstance(setting, str) and setting in SETTING_VARIABLES:
-                validated[SETTING_VARIABLES[setting]] = val
-            elif isinstance(setting, Setting):
-                validated[setting] = val
-            else:
-                raise ValueError(f"Unknown setting {setting!r}.")
-
-        return validated
+        return validate_settings(value)
 
     def validate_settings(self) -> None:
         """

prefect/software/python.py

@@ -1,8 +1,8 @@
-import sys
 from pathlib import Path
 from typing import List, Type
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
+from prefect._internal.schemas.validators import infer_python_version
 
 if HAS_PYDANTIC_V2:
     from pydantic.v1 import BaseModel, Field, validate_arguments, validator
@@ -23,10 +23,8 @@ class PythonEnvironment(BaseModel):
     pip_requirements: List[PipRequirement] = Field(default_factory=list)
 
     @validator("python_version", pre=True, always=True)
-    def infer_python_version(cls, value):
-        if value is None:
-            return f"{sys.version_info.major}.{sys.version_info.minor}"
-        return value
+    def validate_python_version(cls, value):
+        return infer_python_version(value)
 
     @classmethod
     def from_environment(cls: Type[Self], exclude_nested: bool = False) -> Self:

prefect/task_server.py

@@ -53,8 +53,8 @@ def should_try_to_read_parameters(task: Task, task_run: TaskRun) -> bool:
 
 
 class TaskServer:
-    """This class is responsible for serving tasks that may be executed autonomously by a
-    task runner in the engine.
+    """This class is responsible for serving tasks that may be executed in the background
+    by a task runner via the traditional engine machinery.
 
     When `start()` is called, the task server will open a websocket connection to a
     server-side queue of scheduled task runs. When a scheduled task run is found, the

prefect/utilities/callables.py

@@ -225,7 +225,7 @@ class ParameterSchema(pydantic.BaseModel):
     type: Literal["object"] = "object"
     properties: Dict[str, Any] = pydantic.Field(default_factory=dict)
     required: List[str] = None
-    definitions: Dict[str, Any] = None
+    definitions: Optional[Dict[str, Any]] = None
 
     def dict(self, *args, **kwargs):
         """Exclude `None` fields by default to comply with

prefect/utilities/collections.py

@@ -1,6 +1,7 @@
 """
 Utilities for extensions of and operations on Python collections.
 """
+
 import io
 import itertools
 from collections import OrderedDict, defaultdict
@@ -158,7 +159,7 @@ def ensure_iterable(obj: Union[T, Iterable[T]]) -> Iterable[T]:
     return [obj]
 
 
-def listrepr(objs: Iterable, sep=" ") -> str:
+def listrepr(objs: Iterable[Any], sep: str = " ") -> str:
     return sep.join(repr(obj) for obj in objs)
 
 

prefect/utilities/dispatch.py

@@ -19,6 +19,7 @@ key = get_dispatch_key(Foo)  # 'foo'
 lookup_type(Base, key) # Foo
 ```
 """
+
 import abc
 import inspect
 import warnings