prefect-client 3.1.11__py3-none-any.whl → 3.1.13__py3-none-any.whl

prefect/tasks.py

@@ -30,7 +30,7 @@ from uuid import UUID, uuid4
 from typing_extensions import Literal, ParamSpec, Self, TypeAlias, TypeIs
 
 import prefect.states
-from prefect.cache_policies import DEFAULT, NONE, CachePolicy
+from prefect.cache_policies import DEFAULT, NO_CACHE, CachePolicy
 from prefect.client.orchestration import get_client
 from prefect.client.schemas import TaskRun
 from prefect.client.schemas.objects import (
@@ -53,10 +53,7 @@ from prefect.results import (
     ResultStore,
     get_or_create_default_task_scheduling_storage,
 )
-from prefect.settings import (
-    PREFECT_TASK_DEFAULT_RETRIES,
-    PREFECT_TASK_DEFAULT_RETRY_DELAY_SECONDS,
-)
+from prefect.settings.context import get_current_settings
 from prefect.states import Pending, Scheduled, State
 from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import run_coro_as_sync, sync_compatible
@@ -70,6 +67,8 @@ from prefect.utilities.importtools import to_qualified_name
 from prefect.utilities.urls import url_for
 
 if TYPE_CHECKING:
+    import logging
+
     from prefect.client.orchestration import PrefectClient
     from prefect.context import TaskRunContext
     from prefect.transactions import Transaction
@@ -80,7 +79,7 @@ P = ParamSpec("P")  # The parameters of the task
 
 NUM_CHARS_DYNAMIC_KEY = 8
 
-logger = get_logger("tasks")
+logger: "logging.Logger" = get_logger("tasks")
 
 FutureOrResult: TypeAlias = Union[PrefectFuture[T], T]
 OneOrManyFutureOrResult: TypeAlias = Union[
@@ -383,19 +382,19 @@ class Task(Generic[P, R]):
         if not callable(fn):
             raise TypeError("'fn' must be callable")
 
-        self.description = description or inspect.getdoc(fn)
+        self.description: str | None = description or inspect.getdoc(fn)
         update_wrapper(self, fn)
         self.fn = fn
 
         # the task is considered async if its function is async or an async
         # generator
-        self.isasync = asyncio.iscoroutinefunction(
+        self.isasync: bool = asyncio.iscoroutinefunction(
             self.fn
         ) or inspect.isasyncgenfunction(self.fn)
 
         # the task is considered a generator if its function is a generator or
         # an async generator
-        self.isgenerator = inspect.isgeneratorfunction(
+        self.isgenerator: bool = inspect.isgeneratorfunction(
             self.fn
         ) or inspect.isasyncgenfunction(self.fn)
 
@@ -405,7 +404,7 @@ class Task(Generic[P, R]):
             else:
                 self.name = self.fn.__name__
         else:
-            self.name = name
+            self.name: str = name
 
         if task_run_name is not None:
             if not isinstance(task_run_name, str) and not callable(task_run_name):
@@ -420,9 +419,9 @@ class Task(Generic[P, R]):
 
         raise_for_reserved_arguments(self.fn, ["return_state", "wait_for"])
 
-        self.tags = set(tags if tags else [])
+        self.tags: set[str] = set(tags if tags else [])
 
-        self.task_key = _generate_task_key(self.fn)
+        self.task_key: str = _generate_task_key(self.fn)
 
         if cache_policy is not NotSet and cache_key_fn is not None:
             logger.warning(
@@ -441,7 +440,9 @@ class Task(Generic[P, R]):
         if persist_result is None:
             if any(
                 [
-                    cache_policy and cache_policy != NONE and cache_policy != NotSet,
+                    cache_policy
+                    and cache_policy != NO_CACHE
+                    and cache_policy != NotSet,
                     cache_key_fn is not None,
                     result_storage_key is not None,
                     result_storage is not None,
@@ -451,8 +452,8 @@ class Task(Generic[P, R]):
                 persist_result = True
 
         if persist_result is False:
-            self.cache_policy = None if cache_policy is None else NONE
-            if cache_policy and cache_policy is not NotSet and cache_policy != NONE:
+            self.cache_policy = None if cache_policy is None else NO_CACHE
+            if cache_policy and cache_policy is not NotSet and cache_policy != NO_CACHE:
                 logger.warning(
                     "Ignoring `cache_policy` because `persist_result` is False"
                 )
@@ -462,26 +463,29 @@ class Task(Generic[P, R]):
             # TODO: handle this situation with double storage
             self.cache_policy = None
         else:
-            self.cache_policy = cache_policy
+            self.cache_policy: Union[CachePolicy, type[NotSet], None] = cache_policy
 
         # TaskRunPolicy settings
         # TODO: We can instantiate a `TaskRunPolicy` and add Pydantic bound checks to
         #       validate that the user passes positive numbers here
 
-        self.retries = (
-            retries if retries is not None else PREFECT_TASK_DEFAULT_RETRIES.value()
+        settings = get_current_settings()
+        self.retries: int = (
+            retries if retries is not None else settings.tasks.default_retries
         )
         if retry_delay_seconds is None:
-            retry_delay_seconds = PREFECT_TASK_DEFAULT_RETRY_DELAY_SECONDS.value()
+            retry_delay_seconds = settings.tasks.default_retry_delay_seconds
 
         if callable(retry_delay_seconds):
-            self.retry_delay_seconds = retry_delay_seconds(retries)
+            self.retry_delay_seconds = retry_delay_seconds(self.retries)
         elif not isinstance(retry_delay_seconds, (list, int, float, type(None))):
             raise TypeError(
                 f"Invalid `retry_delay_seconds` provided; must be an int, float, list or callable. Received type {type(retry_delay_seconds)}"
             )
         else:
-            self.retry_delay_seconds = retry_delay_seconds
+            self.retry_delay_seconds: Union[
+                float, int, list[float], None
+            ] = retry_delay_seconds
 
         if isinstance(self.retry_delay_seconds, list) and (
             len(self.retry_delay_seconds) > 50
@@ -505,11 +509,15 @@ class Task(Generic[P, R]):
         self.result_serializer = result_serializer
         self.result_storage_key = result_storage_key
         self.cache_result_in_memory = cache_result_in_memory
-        self.timeout_seconds = float(timeout_seconds) if timeout_seconds else None
-        self.on_rollback_hooks = on_rollback or []
-        self.on_commit_hooks = on_commit or []
-        self.on_completion_hooks = on_completion or []
-        self.on_failure_hooks = on_failure or []
+        self.timeout_seconds: Union[float, None] = (
+            float(timeout_seconds) if timeout_seconds else None
+        )
+        self.on_rollback_hooks: list[Callable[["Transaction"], None]] = (
+            on_rollback or []
+        )
+        self.on_commit_hooks: list[Callable[["Transaction"], None]] = on_commit or []
+        self.on_completion_hooks: list[StateHookCallable] = on_completion or []
+        self.on_failure_hooks: list[StateHookCallable] = on_failure or []
 
         # retry_condition_fn must be a callable or None. If it is neither, raise a TypeError
         if retry_condition_fn is not None and not (callable(retry_condition_fn)):
@@ -525,7 +533,7 @@ class Task(Generic[P, R]):
     def ismethod(self) -> bool:
         return hasattr(self.fn, "__prefect_self__")
 
-    def __get__(self, instance: Any, owner: Any):
+    def __get__(self, instance: Any, owner: Any) -> "Task[P, R]":
         """
         Implement the descriptor protocol so that the task can be used as an instance method.
         When an instance method is loaded, this method is called with the "self" instance as
@@ -580,7 +588,7 @@ class Task(Generic[P, R]):
             Callable[["Task[..., Any]", TaskRun, State], bool]
         ] = None,
         viz_return_value: Optional[Any] = None,
-    ):
+    ) -> "Task[P, R]":
         """
         Create a new task from the current object, updating provided options.
 

prefect/telemetry/bootstrap.py

@@ -2,6 +2,12 @@ from typing import TYPE_CHECKING, Union
 
 import prefect.settings
 from prefect.client.base import ServerType, determine_server_type
+from prefect.logging.loggers import get_logger
+
+if TYPE_CHECKING:
+    import logging
+
+logger: "logging.Logger" = get_logger(__name__)
 
 if TYPE_CHECKING:
     from opentelemetry.sdk._logs import LoggerProvider
@@ -16,30 +22,28 @@ def setup_telemetry() -> (
     ]
 ):
     settings = prefect.settings.get_current_settings()
-    if not settings.experiments.telemetry_enabled:
-        return None, None, None
 
     server_type = determine_server_type()
     if server_type != ServerType.CLOUD:
         return None, None, None
 
+    if not settings.cloud.enable_orchestration_telemetry:
+        return None, None, None
+
     if not settings.api.key:
-        raise ValueError(
+        logger.warning(
             "A Prefect Cloud API key is required to enable telemetry. Please set "
             "the `PREFECT_API_KEY` environment variable or authenticate with "
             "Prefect Cloud via the `prefect cloud login` command."
         )
+        return None, None, None
 
     assert settings.api.url
 
     # This import is here to defer importing of the `opentelemetry` packages.
     try:
         from .instrumentation import setup_exporters
-    except ImportError as exc:
-        raise ValueError(
-            "Unable to import OpenTelemetry instrumentation libraries. Please "
-            "ensure you have installed the `otel` extra when installing Prefect: "
-            "`pip install 'prefect[otel]'`"
-        ) from exc
+    except ImportError:
+        return None, None, None
 
     return setup_exporters(settings.api.url, settings.api.key.get_secret_value())

prefect/telemetry/run_telemetry.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 import time
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Union
 
 from opentelemetry import propagate, trace
 from opentelemetry.context import Context
@@ -47,14 +49,14 @@ class RunTelemetry:
     _tracer: "Tracer" = field(
         default_factory=lambda: get_tracer("prefect", prefect.__version__)
     )
-    span: Optional[Span] = None
+    span: Span | None = None
 
     async def async_start_span(
         self,
         run: FlowOrTaskRun,
         client: PrefectClient,
-        parameters: Optional[dict[str, Any]] = None,
-    ):
+        parameters: dict[str, Any] | None = None,
+    ) -> Span:
         traceparent, span = self._start_span(run, parameters)
 
         if self._run_type(run) == "flow" and traceparent:
@@ -70,8 +72,8 @@ class RunTelemetry:
         self,
         run: FlowOrTaskRun,
         client: SyncPrefectClient,
-        parameters: Optional[dict[str, Any]] = None,
-    ):
+        parameters: dict[str, Any] | None = None,
+    ) -> Span:
         traceparent, span = self._start_span(run, parameters)
 
         if self._run_type(run) == "flow" and traceparent:
@@ -84,8 +86,8 @@ class RunTelemetry:
     def _start_span(
         self,
         run: FlowOrTaskRun,
-        parameters: Optional[dict[str, Any]] = None,
-    ) -> tuple[Optional[str], Span]:
+        parameters: dict[str, Any] | None = None,
+    ) -> tuple[str | None, Span]:
         """
         Start a span for a run.
         """
@@ -139,8 +141,8 @@ class RunTelemetry:
         return "task" if isinstance(run, TaskRun) else "flow"
 
     def _trace_context_from_labels(
-        self, labels: Optional[KeyValueLabels]
-    ) -> Optional[Context]:
+        self, labels: KeyValueLabels | None
+    ) -> Context | None:
         """Get trace context from run labels if it exists."""
         if not labels or LABELS_TRACEPARENT_KEY not in labels:
             return None
@@ -148,7 +150,7 @@ class RunTelemetry:
         carrier = {TRACEPARENT_KEY: traceparent}
         return propagate.extract(carrier)
 
-    def _traceparent_from_span(self, span: Span) -> Optional[str]:
+    def _traceparent_from_span(self, span: Span) -> str | None:
         carrier: dict[str, Any] = {}
         propagate.inject(carrier, context=trace.set_span_in_context(span))
         return carrier.get(TRACEPARENT_KEY)
@@ -162,7 +164,7 @@ class RunTelemetry:
             self.span.end(time.time_ns())
             self.span = None
 
-    def end_span_on_failure(self, terminal_message: Optional[str] = None) -> None:
+    def end_span_on_failure(self, terminal_message: str | None = None) -> None:
         """
         End a span for a run on failure.
         """
@@ -203,7 +205,7 @@ class RunTelemetry:
             self.span.update_name(name=name)
             self.span.set_attribute("prefect.run.name", name)
 
-    def _parent_run(self) -> Union[FlowOrTaskRun, None]:
+    def _parent_run(self) -> FlowOrTaskRun | None:
         """
         Identify the "parent run" for the current execution context.
 

prefect/telemetry/services.py

@@ -53,6 +53,8 @@ class QueueingSpanExporter(BaseQueueingExporter[ReadableSpan], SpanExporter):
 
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         for item in spans:
+            if self._stopped:
+                break
             self.send(item)
         return SpanExportResult.SUCCESS
 
@@ -65,4 +67,6 @@ class QueueingLogExporter(BaseQueueingExporter[LogData], LogExporter):
 
     def export(self, batch: Sequence[LogData]) -> None:
         for item in batch:
+            if self._stopped:
+                break
             self.send(item)

prefect/transactions.py

@@ -173,7 +173,7 @@ class Transaction(ContextModel):
     def is_active(self) -> bool:
         return self.state == TransactionState.ACTIVE
 
-    def __enter__(self):
+    def __enter__(self) -> Self:
         if self._token is not None:
             raise RuntimeError(
                 "Context already entered. Context enter calls cannot be nested."
@@ -206,7 +206,7 @@ class Transaction(ContextModel):
         self._token = self.__var__.set(self)
         return self
 
-    def __exit__(self, *exc_info: Any):
+    def __exit__(self, *exc_info: Any) -> None:
         exc_type, exc_val, _ = exc_info
         if not self._token:
             raise RuntimeError(
@@ -235,7 +235,7 @@ class Transaction(ContextModel):
 
         self.reset()
 
-    def begin(self):
+    def begin(self) -> None:
         if (
             self.store
             and self.key

prefect/types/__init__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from functools import partial
 from typing import Annotated, Any, Dict, List, Optional, Set, TypeVar, Union
 from typing_extensions import Literal, TypeAlias
@@ -114,7 +116,7 @@ class SecretDict(pydantic.Secret[Dict[str, Any]]):
 
 
 def validate_set_T_from_delim_string(
-    value: Union[str, T, Set[T], None], type_, delim=None
+    value: Union[str, T, Set[T], None], type_: type[T], delim: str | None = None
 ) -> Set[T]:
     """
     "no-info" before validator useful in scooping env vars

prefect/utilities/_deprecated.py

@@ -0,0 +1,38 @@
+from typing import Any
+
+from jsonpatch import (  # type: ignore  # no typing stubs available, see https://github.com/stefankoegl/python-json-patch/issues/158
+    JsonPatch as JsonPatchBase,
+)
+from pydantic import GetJsonSchemaHandler
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import core_schema
+
+
+class JsonPatch(JsonPatchBase):
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetJsonSchemaHandler
+    ) -> core_schema.CoreSchema:
+        return core_schema.typed_dict_schema(
+            {"patch": core_schema.typed_dict_field(core_schema.dict_schema())}
+        )
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls, core_schema: core_schema.CoreSchema, handler: GetJsonSchemaHandler
+    ) -> JsonSchemaValue:
+        json_schema = handler(core_schema)
+        json_schema = handler.resolve_ref_schema(json_schema)
+        json_schema.pop("required", None)
+        json_schema.pop("properties", None)
+        json_schema.update(
+            {
+                "type": "array",
+                "format": "rfc6902",
+                "items": {
+                    "type": "object",
+                    "additionalProperties": {"type": "string"},
+                },
+            }
+        )
+        return json_schema

prefect/utilities/engine.py

@@ -757,12 +757,19 @@ def resolve_to_final_result(expr: Any, context: dict[str, Any]) -> Any:
         parameter_context = propagate.extract(
             {"traceparent": state.state_details.traceparent}
         )
-        trace.get_current_span().add_link(
-            context=trace.get_current_span(parameter_context).get_span_context(),
-            attributes={
+        attributes = {}
+
+        # If this future is being used as a parameter (as opposed to just a wait_for),
+        # add attributes to the span to indicate the parameter name and type
+        if "parameter_name" in context:
+            attributes = {
                 "prefect.input.name": context["parameter_name"],
                 "prefect.input.type": type(result).__name__,
-            },
+            }
+
+        trace.get_current_span().add_link(
+            context=trace.get_current_span(parameter_context).get_span_context(),
+            attributes=attributes,
         )
 
     return result

prefect/utilities/filesystem.py

@@ -8,7 +8,7 @@ import threading
 from collections.abc import Iterable
 from contextlib import contextmanager
 from pathlib import Path, PureWindowsPath
-from typing import AnyStr, Optional, Union, cast
+from typing import Any, AnyStr, Optional, Union, cast
 
 # fsspec has no stubs, see https://github.com/fsspec/filesystem_spec/issues/625
 import fsspec  # type: ignore
@@ -114,7 +114,7 @@ def filename(path: str) -> str:
     return path.split(sep)[-1]
 
 
-def is_local_path(path: Union[str, pathlib.Path, OpenFile]) -> bool:
+def is_local_path(path: Union[str, pathlib.Path, Any]) -> bool:
     """Check if the given path points to a local or remote file system"""
     if isinstance(path, str):
         try:

prefect/utilities/generics.py

@@ -5,7 +5,7 @@ from pydantic_core import SchemaValidator, core_schema
 
 T = TypeVar("T", bound=BaseModel)
 
-ListValidator = SchemaValidator(
+ListValidator: SchemaValidator = SchemaValidator(
     schema=core_schema.list_schema(
         items_schema=core_schema.dict_schema(
             keys_schema=core_schema.str_schema(), values_schema=core_schema.any_schema()

prefect/utilities/pydantic.py

@@ -1,3 +1,4 @@
+import warnings
 from typing import (
     Any,
     Callable,
@@ -10,18 +11,13 @@ from typing import (
     overload,
 )
 
-from jsonpatch import (  # type: ignore  # no typing stubs available, see https://github.com/stefankoegl/python-json-patch/issues/158
-    JsonPatch as JsonPatchBase,
-)
 from pydantic import (
     BaseModel,
-    GetJsonSchemaHandler,
     Secret,
     TypeAdapter,
     ValidationError,
 )
-from pydantic.json_schema import JsonSchemaValue
-from pydantic_core import core_schema, to_jsonable_python
+from pydantic_core import to_jsonable_python
 from typing_extensions import Literal
 
 from prefect.utilities.dispatch import get_dispatch_key, lookup_type, register_base_type
@@ -262,36 +258,6 @@ class PartialModel(Generic[M]):
         return f"PartialModel(cls={self.model_cls.__name__}, {dsp_fields})"
 
 
-class JsonPatch(JsonPatchBase):
-    @classmethod
-    def __get_pydantic_core_schema__(
-        cls, source_type: Any, handler: GetJsonSchemaHandler
-    ) -> core_schema.CoreSchema:
-        return core_schema.typed_dict_schema(
-            {"patch": core_schema.typed_dict_field(core_schema.dict_schema())}
-        )
-
-    @classmethod
-    def __get_pydantic_json_schema__(
-        cls, core_schema: core_schema.CoreSchema, handler: GetJsonSchemaHandler
-    ) -> JsonSchemaValue:
-        json_schema = handler(core_schema)
-        json_schema = handler.resolve_ref_schema(json_schema)
-        json_schema.pop("required", None)
-        json_schema.pop("properties", None)
-        json_schema.update(
-            {
-                "type": "array",
-                "format": "rfc6902",
-                "items": {
-                    "type": "object",
-                    "additionalProperties": {"type": "string"},
-                },
-            }
-        )
-        return json_schema
-
-
 def custom_pydantic_encoder(
     type_encoders: dict[Any, Callable[[type[Any]], Any]], obj: Any
 ) -> Any:
@@ -382,3 +348,22 @@ def handle_secret_render(value: object, context: dict[str, Any]) -> object:
     elif isinstance(value, BaseModel):
         return value.model_dump(context=context)
     return value
+
+
+def __getattr__(name: str) -> Any:
+    """
+    Handles imports from this module that are deprecated.
+    """
+
+    if name == "JsonPatch":
+        warnings.warn(
+            "JsonPatch is deprecated and will be removed after March 2025. "
+            "Please use `JsonPatch` from the `jsonpatch` package instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        from ._deprecated import JsonPatch
+
+        return JsonPatch
+    else:
+        raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

prefect/utilities/templating.py

@@ -1,7 +1,17 @@
 import enum
 import os
 import re
-from typing import TYPE_CHECKING, Any, NamedTuple, Optional, TypeVar, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    NamedTuple,
+    Optional,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
 
 from prefect.client.utilities import inject_client
 from prefect.utilities.annotations import NotSet
@@ -79,6 +89,20 @@ def find_placeholders(template: T) -> set[Placeholder]:
         raise ValueError(f"Unexpected type: {type(template)}")
 
 
+@overload
+def apply_values(
+    template: T, values: dict[str, Any], remove_notset: Literal[True] = True
+) -> T:
+    ...
+
+
+@overload
+def apply_values(
+    template: T, values: dict[str, Any], remove_notset: Literal[False] = False
+) -> Union[T, type[NotSet]]:
+    ...
+
+
 def apply_values(
     template: T, values: dict[str, Any], remove_notset: bool = True
 ) -> Union[T, type[NotSet]]: