prefect-client 3.1.8__py3-none-any.whl → 3.1.9__py3-none-any.whl

prefect/results.py

@@ -233,6 +233,29 @@ def _format_user_supplied_storage_key(key: str) -> str:
     return key.format(**runtime_vars, parameters=prefect.runtime.task_run.parameters)
 
 
+async def _call_explicitly_async_block_method(
+    block: Union[WritableFileSystem, NullFileSystem],
+    method: str,
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+) -> Any:
+    """
+    TODO: remove this once we have explicit async methods on all storage blocks
+
+    see https://github.com/PrefectHQ/prefect/issues/15008
+    """
+    if hasattr(block, f"a{method}"):  # explicit async method
+        return await getattr(block.__class__.__name__, f"a{method}")(*args, **kwargs)
+    elif hasattr(getattr(block, method, None), "aio"):  # sync_compatible
+        return await getattr(block, method).aio(block, *args, **kwargs)
+    else:  # should not happen in prefect, but users can override impls
+        maybe_coro = getattr(block, method)(*args, **kwargs)
+        if inspect.isawaitable(maybe_coro):
+            return await maybe_coro
+        else:
+            return maybe_coro
+
+
 T = TypeVar("T")
 
 
@@ -405,7 +428,9 @@ class ResultStore(BaseModel):
             # TODO: Add an `exists` method to commonly used storage blocks
             # so the entire payload doesn't need to be read
             try:
-                metadata_content = await self.metadata_storage.read_path(key)
+                metadata_content = await _call_explicitly_async_block_method(
+                    self.metadata_storage, "read_path", (key,), {}
+                )
                 if metadata_content is None:
                     return False
                 metadata = ResultRecordMetadata.load_bytes(metadata_content)
@@ -414,7 +439,9 @@ class ResultStore(BaseModel):
                 return False
         else:
             try:
-                content = await self.result_storage.read_path(key)
+                content = await _call_explicitly_async_block_method(
+                    self.result_storage, "read_path", (key,), {}
+                )
                 if content is None:
                     return False
                 record = ResultRecord.deserialize(content)
@@ -491,12 +518,22 @@ class ResultStore(BaseModel):
             self.result_storage = await get_default_result_storage()
 
         if self.metadata_storage is not None:
-            metadata_content = await self.metadata_storage.read_path(key)
+            metadata_content = await _call_explicitly_async_block_method(
+                self.metadata_storage,
+                "read_path",
+                (key,),
+                {},
+            )
             metadata = ResultRecordMetadata.load_bytes(metadata_content)
             assert (
                 metadata.storage_key is not None
             ), "Did not find storage key in metadata"
-            result_content = await self.result_storage.read_path(metadata.storage_key)
+            result_content = await _call_explicitly_async_block_method(
+                self.result_storage,
+                "read_path",
+                (metadata.storage_key,),
+                {},
+            )
             result_record: ResultRecord[
                 Any
             ] = ResultRecord.deserialize_from_result_and_metadata(
@@ -504,7 +541,12 @@ class ResultStore(BaseModel):
             )
             await emit_result_read_event(self, resolved_key_path)
         else:
-            content = await self.result_storage.read_path(key)
+            content = await _call_explicitly_async_block_method(
+                self.result_storage,
+                "read_path",
+                (key,),
+                {},
+            )
             result_record: ResultRecord[Any] = ResultRecord.deserialize(
                 content, backup_serializer=self.serializer
             )
@@ -555,7 +597,7 @@ class ResultStore(BaseModel):
         obj: Any,
         key: Optional[str] = None,
         expiration: Optional[DateTime] = None,
-    ) -> "ResultRecord":
+    ) -> "ResultRecord[Any]":
         """
         Create a result record.
 
@@ -671,19 +713,26 @@ class ResultStore(BaseModel):
 
         # If metadata storage is configured, write result and metadata separately
         if self.metadata_storage is not None:
-            await self.result_storage.write_path(
-                result_record.metadata.storage_key,
-                content=result_record.serialize_result(),
+            await _call_explicitly_async_block_method(
+                self.result_storage,
+                "write_path",
+                (result_record.metadata.storage_key,),
+                {"content": result_record.serialize_result()},
             )
-            await self.metadata_storage.write_path(
-                base_key,
-                content=result_record.serialize_metadata(),
+            await _call_explicitly_async_block_method(
+                self.metadata_storage,
+                "write_path",
+                (base_key,),
+                {"content": result_record.serialize_metadata()},
             )
             await emit_result_write_event(self, result_record.metadata.storage_key)
         # Otherwise, write the result metadata and result together
         else:
-            await self.result_storage.write_path(
-                result_record.metadata.storage_key, content=result_record.serialize()
+            await _call_explicitly_async_block_method(
+                self.result_storage,
+                "write_path",
+                (result_record.metadata.storage_key,),
+                {"content": result_record.serialize()},
             )
             await emit_result_write_event(self, result_record.metadata.storage_key)
         if self.cache_result_in_memory:
@@ -910,8 +959,11 @@ class ResultStore(BaseModel):
                 serializer=self.serializer, storage_key=str(identifier)
             ),
         )
-        await self.result_storage.write_path(
-            f"parameters/{identifier}", content=record.serialize()
+        await _call_explicitly_async_block_method(
+            self.result_storage,
+            "write_path",
+            (f"parameters/{identifier}",),
+            {"content": record.serialize()},
         )
 
     @sync_compatible
@@ -921,7 +973,12 @@ class ResultStore(BaseModel):
                 "Result store is not configured - must have a result storage block to read parameters"
             )
         record = ResultRecord.deserialize(
-            await self.result_storage.read_path(f"parameters/{identifier}")
+            await _call_explicitly_async_block_method(
+                self.result_storage,
+                "read_path",
+                (f"parameters/{identifier}",),
+                {},
+            )
         )
         return record.result
 
@@ -976,7 +1033,7 @@ class ResultRecordMetadata(BaseModel):
         """
         return cls.model_validate_json(data)
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if not isinstance(other, ResultRecordMetadata):
             return False
         return (
@@ -1050,7 +1107,7 @@ class ResultRecord(BaseModel, Generic[R]):
 
     @model_validator(mode="before")
     @classmethod
-    def coerce_old_format(cls, value: Any):
+    def coerce_old_format(cls, value: Any) -> Any:
         if isinstance(value, dict):
             if "data" in value:
                 value["result"] = value.pop("data")

prefect/runner/runner.py

@@ -1209,9 +1209,8 @@ class Runner:
                 )
                 # Mark the task as started to prevent agent crash
                 task_status.started(exc)
-                await self._propose_crashed_state(
-                    flow_run, "Flow run process could not be started"
-                )
+                message = f"Flow run process could not be started:\n{exc!r}"
+                await self._propose_crashed_state(flow_run, message)
             else:
                 run_logger.exception(
                     f"An error occurred while monitoring flow run '{flow_run.id}'. "

prefect/states.py

@@ -11,6 +11,7 @@ from typing import Any, Dict, Iterable, Optional, Type
 import anyio
 import httpx
 import pendulum
+from opentelemetry import propagate
 from typing_extensions import TypeGuard
 
 from prefect._internal.compatibility import deprecated
@@ -588,6 +589,16 @@ class StateGroup:
         return f"StateGroup<{self.counts_message()}>"
 
 
+def _traced(cls: Type[State[R]], **kwargs: Any) -> State[R]:
+    state_details = StateDetails.model_validate(kwargs.pop("state_details", {}))
+
+    carrier = {}
+    propagate.inject(carrier)
+    state_details.traceparent = carrier.get("traceparent")
+
+    return cls(**kwargs, state_details=state_details)
+
+
 def Scheduled(
     cls: Type[State[R]] = State,
     scheduled_time: Optional[datetime.datetime] = None,
@@ -605,7 +616,7 @@ def Scheduled(
         raise ValueError("An extra scheduled_time was provided in state_details")
     state_details.scheduled_time = scheduled_time
 
-    return cls(type=StateType.SCHEDULED, state_details=state_details, **kwargs)
+    return _traced(cls, type=StateType.SCHEDULED, state_details=state_details, **kwargs)
 
 
 def Completed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
@@ -614,7 +625,8 @@ def Completed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     Returns:
         State: a Completed state
     """
-    return cls(type=StateType.COMPLETED, **kwargs)
+
+    return _traced(cls, type=StateType.COMPLETED, **kwargs)
 
 
 def Running(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
@@ -623,7 +635,7 @@ def Running(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     Returns:
         State: a Running state
     """
-    return cls(type=StateType.RUNNING, **kwargs)
+    return _traced(cls, type=StateType.RUNNING, **kwargs)
 
 
 def Failed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
@@ -632,7 +644,7 @@ def Failed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     Returns:
         State: a Failed state
     """
-    return cls(type=StateType.FAILED, **kwargs)
+    return _traced(cls, type=StateType.FAILED, **kwargs)
 
 
 def Crashed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
@@ -641,7 +653,7 @@ def Crashed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     Returns:
         State: a Crashed state
     """
-    return cls(type=StateType.CRASHED, **kwargs)
+    return _traced(cls, type=StateType.CRASHED, **kwargs)
 
 
 def Cancelling(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
@@ -650,7 +662,7 @@ def Cancelling(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     Returns:
         State: a Cancelling state
     """
-    return cls(type=StateType.CANCELLING, **kwargs)
+    return _traced(cls, type=StateType.CANCELLING, **kwargs)
 
 
 def Cancelled(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
@@ -659,7 +671,7 @@ def Cancelled(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     Returns:
         State: a Cancelled state
     """
-    return cls(type=StateType.CANCELLED, **kwargs)
+    return _traced(cls, type=StateType.CANCELLED, **kwargs)
 
 
 def Pending(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
@@ -668,7 +680,7 @@ def Pending(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     Returns:
         State: a Pending state
     """
-    return cls(type=StateType.PENDING, **kwargs)
+    return _traced(cls, type=StateType.PENDING, **kwargs)
 
 
 def Paused(
@@ -704,7 +716,7 @@ def Paused(
     state_details.pause_reschedule = reschedule
     state_details.pause_key = pause_key
 
-    return cls(type=StateType.PAUSED, state_details=state_details, **kwargs)
+    return _traced(cls, type=StateType.PAUSED, state_details=state_details, **kwargs)
 
 
 def Suspended(
@@ -766,7 +778,7 @@ def Retrying(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     Returns:
         State: a Retrying state
     """
-    return cls(type=StateType.RUNNING, name="Retrying", **kwargs)
+    return _traced(cls, type=StateType.RUNNING, name="Retrying", **kwargs)
 
 
 def Late(

prefect/task_engine.py

@@ -182,7 +182,7 @@ class BaseTaskRunEngine(Generic[P, R]):
                     return_data=True,
                     max_depth=-1,
                     remove_annotations=True,
-                    context={},
+                    context={"parameter_name": parameter},
                 )
             except UpstreamTaskError:
                 raise

prefect/telemetry/instrumentation.py

@@ -7,9 +7,7 @@ from uuid import UUID
 
 from opentelemetry import metrics, trace
 from opentelemetry._logs import set_logger_provider
-from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
 from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
 from opentelemetry.sdk._logs.export import SimpleLogRecordProcessor
 from opentelemetry.sdk.metrics import MeterProvider
@@ -19,6 +17,7 @@ from opentelemetry.sdk.trace import TracerProvider
 
 from .logging import set_log_handler
 from .processors import InFlightSpanProcessor
+from .services import QueueingLogExporter, QueueingSpanExporter
 
 if TYPE_CHECKING:
     from opentelemetry.sdk._logs import LoggerProvider
@@ -83,11 +82,10 @@ def _setup_trace_provider(
     resource: Resource, headers: dict[str, str], telemetry_url: str
 ) -> TracerProvider:
     trace_provider = TracerProvider(resource=resource)
-    otlp_span_exporter = OTLPSpanExporter(
-        endpoint=_url_join(telemetry_url, "v1/traces"),
-        headers=headers,
+    queueing_span_exporter = QueueingSpanExporter.instance(
+        _url_join(telemetry_url, "v1/traces"), tuple(headers.items())
     )
-    trace_provider.add_span_processor(InFlightSpanProcessor(otlp_span_exporter))
+    trace_provider.add_span_processor(InFlightSpanProcessor(queueing_span_exporter))
     trace.set_tracer_provider(trace_provider)
 
     return trace_provider
@@ -112,11 +110,12 @@ def _setup_logger_provider(
     resource: Resource, headers: dict[str, str], telemetry_url: str
 ) -> LoggerProvider:
     logger_provider = LoggerProvider(resource=resource)
-    otlp_exporter = OTLPLogExporter(
-        endpoint=_url_join(telemetry_url, "v1/logs"),
-        headers=headers,
+    queueing_log_exporter = QueueingLogExporter.instance(
+        _url_join(telemetry_url, "v1/logs"), tuple(headers.items())
+    )
+    logger_provider.add_log_record_processor(
+        SimpleLogRecordProcessor(queueing_log_exporter)
     )
-    logger_provider.add_log_record_processor(SimpleLogRecordProcessor(otlp_exporter))
     set_logger_provider(logger_provider)
     log_handler = LoggingHandler(level=logging.NOTSET, logger_provider=logger_provider)
 

prefect/telemetry/services.py

@@ -0,0 +1,67 @@
+from abc import abstractmethod
+from typing import Union
+
+from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk._logs import LogData
+from opentelemetry.sdk._logs.export import LogExporter
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExporter
+
+from prefect._internal.concurrency.services import BatchedQueueService
+
+
+class BaseQueueingExporter(BatchedQueueService):
+    _max_batch_size = 512
+    _min_interval = 2.0
+    _otlp_exporter: Union[SpanExporter, LogExporter]
+
+    def export(self, batch: list[Union[ReadableSpan, LogData]]) -> None:
+        for item in batch:
+            self.send(item)
+
+    @abstractmethod
+    def _export_batch(self, items: list[Union[ReadableSpan, LogData]]) -> None:
+        pass
+
+    async def _handle_batch(self, items: list[Union[ReadableSpan, LogData]]) -> None:
+        try:
+            self._export_batch(items)
+        except Exception as e:
+            self._logger.exception(f"Failed to export batch: {e}")
+            raise
+
+    def shutdown(self) -> None:
+        if self._stopped:
+            return
+
+        self.drain()
+        self._otlp_exporter.shutdown()
+
+
+class QueueingSpanExporter(BaseQueueingExporter, SpanExporter):
+    _otlp_exporter: OTLPSpanExporter
+
+    def __init__(self, endpoint: str, headers: tuple[tuple[str, str]]):
+        super().__init__()
+        self._otlp_exporter = OTLPSpanExporter(
+            endpoint=endpoint,
+            headers=dict(headers),
+        )
+
+    def _export_batch(self, items: list[ReadableSpan]) -> None:
+        self._otlp_exporter.export(items)
+
+
+class QueueingLogExporter(BaseQueueingExporter, LogExporter):
+    _otlp_exporter: OTLPLogExporter
+
+    def __init__(self, endpoint: str, headers: tuple[tuple[str, str]]):
+        super().__init__()
+        self._otlp_exporter = OTLPLogExporter(
+            endpoint=endpoint,
+            headers=dict(headers),
+        )
+
+    def _export_batch(self, items: list[LogData]) -> None:
+        self._otlp_exporter.export(items)

prefect/utilities/engine.py

@@ -18,6 +18,7 @@ from typing import (
 from uuid import UUID
 
 import anyio
+from opentelemetry import propagate, trace
 from typing_extensions import TypeIs
 
 import prefect
@@ -767,6 +768,19 @@ def resolve_to_final_result(expr: Any, context: dict[str, Any]) -> Any:
     result = state.result(raise_on_failure=False, fetch=True)
     if asyncio.iscoroutine(result):
         result = run_coro_as_sync(result)
+
+    if state.state_details.traceparent:
+        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={
+                "prefect.input.name": context["parameter_name"],
+                "prefect.input.type": type(result).__name__,
+            },
+        )
+
     return result
 
 
@@ -796,7 +810,7 @@ def resolve_inputs_sync(
                 return_data=return_data,
                 max_depth=max_depth,
                 remove_annotations=True,
-                context={},
+                context={"parameter_name": parameter},
             )
         except UpstreamTaskError:
             raise

prefect/utilities/importtools.py

@@ -4,6 +4,7 @@ import importlib.util
 import os
 import runpy
 import sys
+import threading
 import warnings
 from collections.abc import Iterable, Sequence
 from importlib.abc import Loader, MetaPathFinder
@@ -23,6 +24,16 @@ from prefect.utilities.filesystem import filename, is_local_path, tmpchdir
 
 logger: Logger = get_logger(__name__)
 
+_sys_path_lock: Optional[threading.Lock] = None
+
+
+def _get_sys_path_lock() -> threading.Lock:
+    """Get the global sys.path lock, initializing it if necessary."""
+    global _sys_path_lock
+    if _sys_path_lock is None:
+        _sys_path_lock = threading.Lock()
+    return _sys_path_lock
+
 
 def to_qualified_name(obj: Any) -> str:
     """
@@ -135,32 +146,26 @@ def objects_from_script(
 
 
 def load_script_as_module(path: str) -> ModuleType:
-    """
-    Execute a script at the given path.
+    """Execute a script at the given path.
 
-    Sets the module name to `__prefect_loader__`.
+    Sets the module name to a unique identifier to ensure thread safety.
+    Uses a lock to safely modify sys.path for relative imports.
 
     If an exception occurs during execution of the script, a
     `prefect.exceptions.ScriptError` is created to wrap the exception and raised.
-
-    During the duration of this function call, `sys` is modified to support loading.
-    These changes are reverted after completion, but this function is not thread safe
-    and use of it in threaded contexts may result in undesirable behavior.
-
-    See https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
     """
-    # We will add the parent directory to search locations to support relative imports
-    # during execution of the script
     if not path.endswith(".py"):
         raise ValueError(f"The provided path does not point to a python file: {path!r}")
 
     parent_path = str(Path(path).resolve().parent)
     working_directory = os.getcwd()
 
+    # Generate unique module name for thread safety
+    module_name = f"__prefect_loader_{id(path)}__"
+
     spec = importlib.util.spec_from_file_location(
-        "__prefect_loader__",
+        module_name,
         path,
-        # Support explicit relative imports i.e. `from .foo import bar`
         submodule_search_locations=[parent_path, working_directory],
     )
     if TYPE_CHECKING:
@@ -168,19 +173,21 @@ def load_script_as_module(path: str) -> ModuleType:
         assert spec.loader is not None
 
     module = importlib.util.module_from_spec(spec)
-    sys.modules["__prefect_loader__"] = module
+    sys.modules[module_name] = module
 
-    # Support implicit relative imports i.e. `from foo import bar`
-    sys.path.insert(0, working_directory)
-    sys.path.insert(0, parent_path)
     try:
-        spec.loader.exec_module(module)
+        with _get_sys_path_lock():
+            sys.path.insert(0, working_directory)
+            sys.path.insert(0, parent_path)
+            try:
+                spec.loader.exec_module(module)
+            finally:
+                sys.path.remove(parent_path)
+                sys.path.remove(working_directory)
     except Exception as exc:
         raise ScriptError(user_exc=exc, path=path) from exc
     finally:
-        sys.modules.pop("__prefect_loader__")
-        sys.path.remove(parent_path)
-        sys.path.remove(working_directory)
+        sys.modules.pop(module_name)
 
     return module
 

prefect/variables.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Any, Callable, Optional
 
 from pydantic import BaseModel, Field
 
@@ -256,4 +256,4 @@ class Variable(BaseModel):
                 return False
 
 
-__getattr__ = getattr_migration(__name__)
+__getattr__: Callable[[str], Any] = getattr_migration(__name__)

prefect/workers/base.py

@@ -18,7 +18,6 @@ from typing_extensions import Literal
 import prefect
 from prefect._internal.schemas.validators import return_v_or_none
 from prefect.client.base import ServerType
-from prefect.client.cloud import CloudClient, get_cloud_client
 from prefect.client.orchestration import PrefectClient, get_client
 from prefect.client.schemas.actions import WorkPoolCreate, WorkPoolUpdate
 from prefect.client.schemas.objects import (
@@ -441,7 +440,6 @@ class BaseWorker(abc.ABC):
         self._exit_stack: AsyncExitStack = AsyncExitStack()
         self._runs_task_group: Optional[anyio.abc.TaskGroup] = None
         self._client: Optional[PrefectClient] = None
-        self._cloud_client: Optional[CloudClient] = None
         self._last_polled_time: pendulum.DateTime = pendulum.now("utc")
         self._limit = limit
         self._limiter: Optional[anyio.CapacityLimiter] = None
@@ -637,11 +635,6 @@ class BaseWorker(abc.ABC):
         await self._exit_stack.enter_async_context(self._client)
         await self._exit_stack.enter_async_context(self._runs_task_group)
 
-        if self._client.server_type == ServerType.CLOUD:
-            self._cloud_client = await self._exit_stack.enter_async_context(
-                get_cloud_client()
-            )
-
         self.is_setup = True
 
     async def teardown(self, *exc_info):
@@ -989,6 +982,8 @@ class BaseWorker(abc.ABC):
         try:
             configuration = await self._get_configuration(flow_run)
             submitted_event = self._emit_flow_run_submitted_event(configuration)
+            await self._give_worker_labels_to_flow_run(flow_run.id)
+
             result = await self.run(
                 flow_run=flow_run,
                 task_status=task_status,
@@ -1002,9 +997,8 @@ class BaseWorker(abc.ABC):
                 )
                 # Mark the task as started to prevent agent crash
                 task_status.started(exc)
-                await self._propose_crashed_state(
-                    flow_run, "Flow run could not be submitted to infrastructure"
-                )
+                message = f"Flow run could not be submitted to infrastructure:\n{exc!r}"
+                await self._propose_crashed_state(flow_run, message)
             else:
                 run_logger.exception(
                     f"An error occurred while monitoring flow run '{flow_run.id}'. "
@@ -1221,7 +1215,7 @@ class BaseWorker(abc.ABC):
         """
         Give this worker's identifying labels to the specified flow run.
         """
-        if self._cloud_client:
+        if self._client:
             labels: KeyValueLabels = {
                 "prefect.worker.name": self.name,
                 "prefect.worker.type": self.type,
@@ -1235,7 +1229,7 @@ class BaseWorker(abc.ABC):
                     }
                 )
 
-            await self._cloud_client.update_flow_run_labels(flow_run_id, labels)
+            await self._client.update_flow_run_labels(flow_run_id, labels)
 
     async def __aenter__(self):
         self._logger.debug("Entering worker context...")

prefect/workers/block.py

@@ -1,6 +1,8 @@
 """
 2024-06-27: This surfaces an actionable error message for moved or removed objects in Prefect 3.0 upgrade.
 """
+from typing import Any, Callable
+
 from prefect._internal.compatibility.migration import getattr_migration
 
-__getattr__ = getattr_migration(__name__)
+__getattr__: Callable[[str], Any] = getattr_migration(__name__)

prefect/workers/cloud.py

@@ -1,6 +1,8 @@
 """
 2024-06-27: This surfaces an actionable error message for moved or removed objects in Prefect 3.0 upgrade.
 """
+from typing import Any, Callable
+
 from prefect._internal.compatibility.migration import getattr_migration
 
-__getattr__ = getattr_migration(__name__)
+__getattr__: Callable[[str], Any] = getattr_migration(__name__)

{prefect_client-3.1.8.dist-info → prefect_client-3.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 3.1.8
+Version: 3.1.9
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.