prefect-client 3.1.10__py3-none-any.whl → 3.1.12__py3-none-any.whl

prefect/settings/models/server/services.py

@@ -1,6 +1,7 @@
 from datetime import timedelta
+from typing import ClassVar
 
-from pydantic import AliasChoices, AliasPath, Field
+from pydantic import AliasChoices, AliasPath, ConfigDict, Field
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
 
@@ -10,7 +11,7 @@ class ServerServicesCancellationCleanupSettings(PrefectBaseSettings):
     Settings for controlling the cancellation cleanup service
     """
 
-    model_config = _build_settings_config(
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
         ("server", "services", "cancellation_cleanup")
     )
 
@@ -40,7 +41,9 @@ class ServerServicesEventPersisterSettings(PrefectBaseSettings):
     Settings for controlling the event persister service
     """
 
-    model_config = _build_settings_config(("server", "services", "event_persister"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "event_persister")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -80,7 +83,7 @@ class ServerServicesFlowRunNotificationsSettings(PrefectBaseSettings):
     Settings for controlling the flow run notifications service
     """
 
-    model_config = _build_settings_config(
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
         ("server", "services", "flow_run_notifications")
     )
 
@@ -100,7 +103,9 @@ class ServerServicesForemanSettings(PrefectBaseSettings):
     Settings for controlling the foreman service
     """
 
-    model_config = _build_settings_config(("server", "services", "foreman"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "foreman")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -179,7 +184,9 @@ class ServerServicesLateRunsSettings(PrefectBaseSettings):
     Settings for controlling the late runs service
     """
 
-    model_config = _build_settings_config(("server", "services", "late_runs"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "late_runs")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -221,7 +228,9 @@ class ServerServicesSchedulerSettings(PrefectBaseSettings):
     Settings for controlling the scheduler service
     """
 
-    model_config = _build_settings_config(("server", "services", "scheduler"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "scheduler")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -344,7 +353,9 @@ class ServerServicesPauseExpirationsSettings(PrefectBaseSettings):
     Settings for controlling the pause expiration service
     """
 
-    model_config = _build_settings_config(("server", "services", "pause_expirations"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "pause_expirations")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -378,7 +389,9 @@ class ServerServicesTaskRunRecorderSettings(PrefectBaseSettings):
     Settings for controlling the task run recorder service
     """
 
-    model_config = _build_settings_config(("server", "services", "task_run_recorder"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "task_run_recorder")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -396,7 +409,9 @@ class ServerServicesTriggersSettings(PrefectBaseSettings):
     Settings for controlling the triggers service
     """
 
-    model_config = _build_settings_config(("server", "services", "triggers"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "services", "triggers")
+    )
 
     enabled: bool = Field(
         default=True,
@@ -414,7 +429,7 @@ class ServerServicesSettings(PrefectBaseSettings):
     Settings for controlling server services
     """
 
-    model_config = _build_settings_config(("server", "services"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("server", "services"))
 
     cancellation_cleanup: ServerServicesCancellationCleanupSettings = Field(
         default_factory=ServerServicesCancellationCleanupSettings,

prefect/settings/models/server/tasks.py

@@ -1,6 +1,7 @@
 from datetime import timedelta
+from typing import ClassVar
 
-from pydantic import AliasChoices, AliasPath, Field
+from pydantic import AliasChoices, AliasPath, ConfigDict, Field
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
 
@@ -10,7 +11,9 @@ class ServerTasksSchedulingSettings(PrefectBaseSettings):
     Settings for controlling server-side behavior related to task scheduling
     """
 
-    model_config = _build_settings_config(("server", "tasks", "scheduling"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(
+        ("server", "tasks", "scheduling")
+    )
 
     max_scheduled_queue_size: int = Field(
         default=1000,
@@ -48,7 +51,7 @@ class ServerTasksSettings(PrefectBaseSettings):
     Settings for controlling server-side behavior related to tasks
     """
 
-    model_config = _build_settings_config(("server", "tasks"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("server", "tasks"))
 
     tag_concurrency_slot_wait_seconds: float = Field(
         default=30,

prefect/settings/models/server/ui.py

@@ -1,12 +1,12 @@
-from typing import Optional
+from typing import ClassVar, Optional
 
-from pydantic import AliasChoices, AliasPath, Field
+from pydantic import AliasChoices, AliasPath, ConfigDict, Field
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
 
 
 class ServerUISettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("server", "ui"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("server", "ui"))
 
     enabled: bool = Field(
         default=True,

prefect/settings/models/tasks.py

@@ -1,12 +1,12 @@
-from typing import Optional, Union
+from typing import ClassVar, Optional, Union
 
-from pydantic import AliasChoices, AliasPath, Field
+from pydantic import AliasChoices, AliasPath, ConfigDict, Field
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
 
 
 class TasksRunnerSettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("tasks", "runner"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("tasks", "runner"))
 
     thread_pool_max_workers: Optional[int] = Field(
         default=None,
@@ -21,7 +21,7 @@ class TasksRunnerSettings(PrefectBaseSettings):
 
 
 class TasksSchedulingSettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("tasks", "scheduling"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("tasks", "scheduling"))
 
     default_storage_block: Optional[str] = Field(
         default=None,
@@ -45,7 +45,7 @@ class TasksSchedulingSettings(PrefectBaseSettings):
 
 
 class TasksSettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("tasks",))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("tasks",))
 
     refresh_cache: bool = Field(
         default=False,

prefect/settings/models/testing.py

@@ -1,12 +1,12 @@
-from typing import Any, Optional
+from typing import Any, ClassVar, Optional
 
-from pydantic import AliasChoices, AliasPath, Field
+from pydantic import AliasChoices, AliasPath, ConfigDict, Field
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
 
 
 class TestingSettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("testing",))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("testing",))
 
     test_mode: bool = Field(
         default=False,

prefect/settings/models/worker.py

@@ -1,10 +1,12 @@
-from pydantic import Field
+from typing import ClassVar
+
+from pydantic import ConfigDict, Field
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
 
 
 class WorkerWebserverSettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("worker", "webserver"))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("worker", "webserver"))
 
     host: str = Field(
         default="0.0.0.0",
@@ -18,7 +20,7 @@ class WorkerWebserverSettings(PrefectBaseSettings):
 
 
 class WorkerSettings(PrefectBaseSettings):
-    model_config = _build_settings_config(("worker",))
+    model_config: ClassVar[ConfigDict] = _build_settings_config(("worker",))
 
     heartbeat_seconds: float = Field(
         default=30,

prefect/settings/profiles.py

@@ -1,7 +1,18 @@
 import inspect
 import warnings
 from pathlib import Path
-from typing import Annotated, Any, Dict, Iterable, List, Optional, Set, Tuple, Union
+from typing import (
+    Annotated,
+    Any,
+    ClassVar,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
 
 import toml
 from pydantic import (
@@ -48,7 +59,9 @@ def _cast_settings(
 class Profile(BaseModel):
     """A user profile containing settings."""
 
-    model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True)
+    model_config: ClassVar[ConfigDict] = ConfigDict(
+        extra="ignore", arbitrary_types_allowed=True
+    )
 
     name: str
     settings: Annotated[Dict[Setting, Any], BeforeValidator(_cast_settings)] = Field(

prefect/states.py

@@ -6,7 +6,7 @@ import uuid
 import warnings
 from collections import Counter
 from types import GeneratorType, TracebackType
-from typing import Any, Dict, Iterable, Optional, Type
+from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Type
 
 import anyio
 import httpx
@@ -28,17 +28,16 @@ from prefect.exceptions import (
     UnfinishedRun,
 )
 from prefect.logging.loggers import get_logger, get_run_logger
-from prefect.results import (
-    BaseResult,
-    R,
-    ResultRecord,
-    ResultRecordMetadata,
-    ResultStore,
-)
 from prefect.utilities.annotations import BaseAnnotation
 from prefect.utilities.asyncutils import in_async_main_thread, sync_compatible
 from prefect.utilities.collections import ensure_iterable
 
+if TYPE_CHECKING:
+    from prefect.results import (
+        R,
+        ResultStore,
+    )
+
 logger = get_logger("states")
 
 
@@ -50,11 +49,11 @@ logger = get_logger("states")
     help="Please ensure you are awaiting the call to `result()` when calling in an async context.",
 )
 def get_state_result(
-    state: State[R],
+    state: "State[R]",
     raise_on_failure: bool = True,
     fetch: bool = True,
     retry_result_failure: bool = True,
-) -> R:
+) -> "R":
     """
     Get the result from a state.
 
@@ -87,13 +86,18 @@ RESULT_READ_RETRY_DELAY = 0.25
 
 
 async def _get_state_result_data_with_retries(
-    state: State[R], retry_result_failure: bool = True
-) -> R:
+    state: "State[R]", retry_result_failure: bool = True
+) -> "R":
     # Results may be written asynchronously, possibly after their corresponding
     # state has been written and events have been emitted, so we should give some
     # grace here about missing results.  The exception below could come in the form
     # of a missing file, a short read, or other types of errors depending on the
     # result storage backend.
+    from prefect.results import (
+        ResultRecord,
+        ResultRecordMetadata,
+    )
+
     if retry_result_failure is False:
         max_attempts = 1
     else:
@@ -121,11 +125,16 @@ async def _get_state_result_data_with_retries(
 
 @sync_compatible
 async def _get_state_result(
-    state: State[R], raise_on_failure: bool, retry_result_failure: bool = True
-) -> R:
+    state: "State[R]", raise_on_failure: bool, retry_result_failure: bool = True
+) -> "R":
     """
     Internal implementation for `get_state_result` without async backwards compatibility
     """
+    from prefect.results import (
+        ResultRecord,
+        ResultRecordMetadata,
+    )
+
     if state.is_paused():
         # Paused states are not truly terminal and do not have results associated with them
         raise PausedRun("Run is paused, its result is not available.", state=state)
@@ -140,7 +149,7 @@ async def _get_state_result(
     ):
         raise await get_state_exception(state)
 
-    if isinstance(state.data, (BaseResult, ResultRecordMetadata)):
+    if isinstance(state.data, ResultRecordMetadata):
         result = await _get_state_result_data_with_retries(
             state, retry_result_failure=retry_result_failure
         )
@@ -182,7 +191,7 @@ def format_exception(exc: BaseException, tb: TracebackType = None) -> str:
 
 async def exception_to_crashed_state(
     exc: BaseException,
-    result_store: Optional[ResultStore] = None,
+    result_store: Optional["ResultStore"] = None,
 ) -> State:
     """
     Takes an exception that occurs _outside_ of user code and converts it to a
@@ -234,7 +243,7 @@ async def exception_to_crashed_state(
 
 async def exception_to_failed_state(
     exc: Optional[BaseException] = None,
-    result_store: Optional[ResultStore] = None,
+    result_store: Optional["ResultStore"] = None,
     write_result: bool = False,
     **kwargs,
 ) -> State:
@@ -286,12 +295,12 @@ async def exception_to_failed_state(
 
 
 async def return_value_to_state(
-    retval: R,
-    result_store: ResultStore,
+    retval: "R",
+    result_store: "ResultStore",
     key: Optional[str] = None,
     expiration: Optional[datetime.datetime] = None,
     write_result: bool = False,
-) -> State[R]:
+) -> "State[R]":
     """
     Given a return value from a user's function, create a `State` the run should
     be placed in.
@@ -312,6 +321,11 @@ async def return_value_to_state(
     Callers should resolve all futures into states before passing return values to this
     function.
     """
+    from prefect.results import (
+        ResultRecord,
+        ResultRecordMetadata,
+    )
+
     try:
         local_logger = get_run_logger()
     except MissingContextError:
@@ -326,7 +340,7 @@ async def return_value_to_state(
         state = retval
         # Unless the user has already constructed a result explicitly, use the store
         # to update the data to the correct type
-        if not isinstance(state.data, (BaseResult, ResultRecord, ResultRecordMetadata)):
+        if not isinstance(state.data, (ResultRecord, ResultRecordMetadata)):
             result_record = result_store.create_result_record(
                 state.data,
                 key=key,
@@ -402,7 +416,7 @@ async def return_value_to_state(
         data = retval
 
     # Otherwise, they just gave data and this is a completed retval
-    if isinstance(data, (BaseResult, ResultRecord)):
+    if isinstance(data, ResultRecord):
         return Completed(data=data)
     else:
         result_record = result_store.create_result_record(
@@ -444,6 +458,10 @@ async def get_state_exception(state: State) -> BaseException:
         - `CrashedRun` if the state type is CRASHED.
         - `CancelledRun` if the state type is CANCELLED.
     """
+    from prefect.results import (
+        ResultRecord,
+        ResultRecordMetadata,
+    )
 
     if state.is_failed():
         wrapper = FailedRun
@@ -457,9 +475,7 @@ async def get_state_exception(state: State) -> BaseException:
     else:
         raise ValueError(f"Expected failed or crashed state got {state!r}.")
 
-    if isinstance(state.data, BaseResult):
-        result = await _get_state_result_data_with_retries(state)
-    elif isinstance(state.data, ResultRecord):
+    if isinstance(state.data, ResultRecord):
         result = state.data.result
     elif isinstance(state.data, ResultRecordMetadata):
         record = await ResultRecord._from_metadata(state.data)
@@ -589,7 +605,7 @@ class StateGroup:
         return f"StateGroup<{self.counts_message()}>"
 
 
-def _traced(cls: Type[State[R]], **kwargs: Any) -> State[R]:
+def _traced(cls: Type["State[R]"], **kwargs: Any) -> "State[R]":
     state_details = StateDetails.model_validate(kwargs.pop("state_details", {}))
 
     carrier = {}
@@ -600,10 +616,10 @@ def _traced(cls: Type[State[R]], **kwargs: Any) -> State[R]:
 
 
 def Scheduled(
-    cls: Type[State[R]] = State,
+    cls: Type["State[R]"] = State,
     scheduled_time: Optional[datetime.datetime] = None,
     **kwargs: Any,
-) -> State[R]:
+) -> "State[R]":
     """Convenience function for creating `Scheduled` states.
 
     Returns:
@@ -619,7 +635,7 @@ def Scheduled(
     return _traced(cls, type=StateType.SCHEDULED, state_details=state_details, **kwargs)
 
 
-def Completed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Completed(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Completed` states.
 
     Returns:
@@ -629,7 +645,7 @@ def Completed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     return _traced(cls, type=StateType.COMPLETED, **kwargs)
 
 
-def Running(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Running(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Running` states.
 
     Returns:
@@ -638,7 +654,7 @@ def Running(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     return _traced(cls, type=StateType.RUNNING, **kwargs)
 
 
-def Failed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Failed(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Failed` states.
 
     Returns:
@@ -647,7 +663,7 @@ def Failed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     return _traced(cls, type=StateType.FAILED, **kwargs)
 
 
-def Crashed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Crashed(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Crashed` states.
 
     Returns:
@@ -656,7 +672,7 @@ def Crashed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     return _traced(cls, type=StateType.CRASHED, **kwargs)
 
 
-def Cancelling(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Cancelling(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Cancelling` states.
 
     Returns:
@@ -665,7 +681,7 @@ def Cancelling(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     return _traced(cls, type=StateType.CANCELLING, **kwargs)
 
 
-def Cancelled(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Cancelled(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Cancelled` states.
 
     Returns:
@@ -674,7 +690,7 @@ def Cancelled(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     return _traced(cls, type=StateType.CANCELLED, **kwargs)
 
 
-def Pending(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Pending(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Pending` states.
 
     Returns:
@@ -684,13 +700,13 @@ def Pending(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
 
 
 def Paused(
-    cls: Type[State[R]] = State,
+    cls: Type["State[R]"] = State,
     timeout_seconds: Optional[int] = None,
     pause_expiration_time: Optional[datetime.datetime] = None,
     reschedule: bool = False,
     pause_key: Optional[str] = None,
     **kwargs: Any,
-) -> State[R]:
+) -> "State[R]":
     """Convenience function for creating `Paused` states.
 
     Returns:
@@ -720,7 +736,7 @@ def Paused(
 
 
 def Suspended(
-    cls: Type[State[R]] = State,
+    cls: Type["State[R]"] = State,
     timeout_seconds: Optional[int] = None,
     pause_expiration_time: Optional[datetime.datetime] = None,
     pause_key: Optional[str] = None,
@@ -743,10 +759,10 @@ def Suspended(
 
 
 def AwaitingRetry(
-    cls: Type[State[R]] = State,
+    cls: Type["State[R]"] = State,
     scheduled_time: Optional[datetime.datetime] = None,
     **kwargs: Any,
-) -> State[R]:
+) -> "State[R]":
     """Convenience function for creating `AwaitingRetry` states.
 
     Returns:
@@ -758,10 +774,10 @@ def AwaitingRetry(
 
 
 def AwaitingConcurrencySlot(
-    cls: Type[State[R]] = State,
+    cls: Type["State[R]"] = State,
     scheduled_time: Optional[datetime.datetime] = None,
     **kwargs: Any,
-) -> State[R]:
+) -> "State[R]":
     """Convenience function for creating `AwaitingConcurrencySlot` states.
 
     Returns:
@@ -772,7 +788,7 @@ def AwaitingConcurrencySlot(
     )
 
 
-def Retrying(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Retrying(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Retrying` states.
 
     Returns:
@@ -782,10 +798,10 @@ def Retrying(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
 
 
 def Late(
-    cls: Type[State[R]] = State,
+    cls: Type["State[R]"] = State,
     scheduled_time: Optional[datetime.datetime] = None,
     **kwargs: Any,
-) -> State[R]:
+) -> "State[R]":
     """Convenience function for creating `Late` states.
 
     Returns: