prefect-client 3.1.2__tar.gz → 3.1.3__tar.gz

{prefect-client-3.1.2/src/prefect_client.egg-info → prefect-client-3.1.3}/PKG-INFO

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

{prefect-client-3.1.2 → prefect-client-3.1.3}/requirements-client.txt

@@ -3,7 +3,7 @@ asgi-lifespan >= 1.0, < 3.0
 cachetools >= 5.3, < 6.0
 cloudpickle >= 2.0, < 4.0
 coolname >= 1.0.4, < 3.0.0
-croniter >= 1.0.12, < 5.0.0
+croniter >= 1.0.12, < 6.0.0
 exceptiongroup >= 1.0.0
 fastapi >= 0.111.0, < 1.0.0
 fsspec >= 2022.5.0
@@ -14,6 +14,7 @@ httpx[http2] >= 0.23, != 0.23.2
 importlib_metadata >= 4.4; python_version < '3.10'
 jsonpatch >= 1.32, < 2.0
 jsonschema >= 4.0.0, < 5.0.0
+opentelemetry-api >= 1.27.0, < 2.0.0
 orjson >= 3.7, < 4.0
 packaging >= 21.3, < 24.3
 pathspec >= 0.8.0

{prefect-client-3.1.2 → prefect-client-3.1.3}/requirements.txt

@@ -12,7 +12,6 @@ graphviz >= 0.20.1
 jinja2 >= 3.0.0, < 4.0.0
 jinja2-humanize-extension >= 0.4.0
 humanize >= 4.9.0, < 5.0.0
-opentelemetry-api >= 1.27.0, < 2.0.0
 pytz >= 2021.1, < 2025
 readchar >= 4.0.0, < 5.0.0
 sqlalchemy[asyncio] >= 2.0, < 3.0.0

prefect-client-3.1.3/src/prefect/_internal/compatibility/async_dispatch.py

@@ -0,0 +1,63 @@
+import asyncio
+import inspect
+from functools import wraps
+from typing import Any, Callable, Coroutine, Optional, TypeVar, Union
+
+from typing_extensions import ParamSpec
+
+from prefect.tasks import Task
+
+R = TypeVar("R")
+P = ParamSpec("P")
+
+
+def is_in_async_context() -> bool:
+    """
+    Returns True if called from within an async context (coroutine or running event loop)
+    """
+    try:
+        asyncio.get_running_loop()
+        return True
+    except RuntimeError:
+        return False
+
+
+def _is_acceptable_callable(obj: Union[Callable, Task]) -> bool:
+    if inspect.iscoroutinefunction(obj):
+        return True
+    if isinstance(obj, Task) and inspect.iscoroutinefunction(obj.fn):
+        return True
+    return False
+
+
+def async_dispatch(
+    async_impl: Callable[P, Coroutine[Any, Any, R]],
+) -> Callable[[Callable[P, R]], Callable[P, Union[R, Coroutine[Any, Any, R]]]]:
+    """
+    Decorator that dispatches to either sync or async implementation based on context.
+
+    Args:
+        async_impl: The async implementation to dispatch to when in async context
+    """
+
+    def decorator(
+        sync_fn: Callable[P, R],
+    ) -> Callable[P, Union[R, Coroutine[Any, Any, R]]]:
+        if not _is_acceptable_callable(async_impl):
+            raise TypeError("async_impl must be an async function")
+
+        @wraps(sync_fn)
+        def wrapper(
+            *args: P.args,
+            _sync: Optional[bool] = None,  # type: ignore
+            **kwargs: P.kwargs,
+        ) -> Union[R, Coroutine[Any, Any, R]]:
+            should_run_sync = _sync if _sync is not None else not is_in_async_context()
+
+            if should_run_sync:
+                return sync_fn(*args, **kwargs)
+            return async_impl(*args, **kwargs)
+
+        return wrapper  # type: ignore
+
+    return decorator

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-11-12T13:38:45-0800",
+ "date": "2024-11-19T15:25:34-0600",
  "dirty": true,
  "error": null,
- "full-revisionid": "02b99f0a756f0395e4292952dcb2d963fc839750",
- "version": "3.1.2"
+ "full-revisionid": "39b6028cea9f2b0437546ba13cc08bb3bf6d94a4",
+ "version": "3.1.3"
 }
 '''  # END VERSION_JSON
 

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/blocks/notifications.py

@@ -494,6 +494,7 @@ class OpsgenieWebhook(AbstractAppriseNotificationBlock):
                 entity=self.entity,
                 batch=self.batch,
                 tags=self.tags,
+                action="new",
             ).url()
         )
         self._start_apprise_client(url)

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/cache_policies.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, Any, Callable, Dict, List, Literal, Optional,
 from typing_extensions import Self
 
 from prefect.context import TaskRunContext
+from prefect.exceptions import HashError
 from prefect.utilities.hashing import hash_objects
 
 if TYPE_CHECKING:
@@ -223,7 +224,6 @@ class TaskSource(CachePolicy):
                 lines = task_ctx.task.fn.__code__.co_code
             else:
                 raise
-
         return hash_objects(lines, raise_on_failure=True)
 
 
@@ -293,7 +293,18 @@ class Inputs(CachePolicy):
             if key not in exclude:
                 hashed_inputs[key] = val
 
-        return hash_objects(hashed_inputs, raise_on_failure=True)
+        try:
+            return hash_objects(hashed_inputs, raise_on_failure=True)
+        except HashError as exc:
+            msg = (
+                f"{exc}\n\n"
+                "This often occurs when task inputs contain objects that cannot be cached "
+                "like locks, file handles, or other system resources.\n\n"
+                "To resolve this, you can:\n"
+                "  1. Exclude these arguments by defining a custom `cache_key_fn`\n"
+                "  2. Disable caching by passing `cache_policy=NONE`\n"
+            )
+            raise ValueError(msg) from exc
 
     def __sub__(self, other: str) -> "CachePolicy":
         if not isinstance(other, str):

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/client/schemas/objects.py

@@ -497,6 +497,9 @@ class FlowRunPolicy(PrefectBaseModel):
     resuming: Optional[bool] = Field(
         default=False, description="Indicates if this run is resuming from a pause."
     )
+    retry_type: Optional[Literal["in_process", "reschedule"]] = Field(
+        default=None, description="The type of retry this run is undergoing."
+    )
 
     @model_validator(mode="before")
     @classmethod
@@ -560,6 +563,11 @@ class FlowRun(ObjectBaseModel):
         description="A list of tags on the flow run",
         examples=[["tag-1", "tag-2"]],
     )
+    labels: KeyValueLabels = Field(
+        default_factory=dict,
+        description="Prefect Cloud: A dictionary of key-value labels. Values can be strings, numbers, or booleans.",
+        examples=[{"key": "value1", "key2": 42}],
+    )
     parent_task_run_id: Optional[UUID] = Field(
         default=None,
         description=(

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/events/filters.py

@@ -83,17 +83,18 @@ class EventOccurredFilter(EventDataFilter):
 
 class EventNameFilter(EventDataFilter):
     prefix: Optional[List[str]] = Field(
-        None, description="Only include events matching one of these prefixes"
+        default=None, description="Only include events matching one of these prefixes"
     )
     exclude_prefix: Optional[List[str]] = Field(
-        None, description="Exclude events matching one of these prefixes"
+        default=None, description="Exclude events matching one of these prefixes"
     )
 
     name: Optional[List[str]] = Field(
-        None, description="Only include events matching one of these names exactly"
+        default=None,
+        description="Only include events matching one of these names exactly",
     )
     exclude_name: Optional[List[str]] = Field(
-        None, description="Exclude events matching one of these names exactly"
+        default=None, description="Exclude events matching one of these names exactly"
     )
 
     def includes(self, event: Event) -> bool:
@@ -230,17 +231,20 @@ class EventFilter(EventDataFilter):
         description="Filter criteria for when the events occurred",
     )
     event: Optional[EventNameFilter] = Field(
-        None,
+        default=None,
         description="Filter criteria for the event name",
     )
     any_resource: Optional[EventAnyResourceFilter] = Field(
-        None, description="Filter criteria for any resource involved in the event"
+        default=None,
+        description="Filter criteria for any resource involved in the event",
     )
     resource: Optional[EventResourceFilter] = Field(
-        None, description="Filter criteria for the resource of the event"
+        default=None,
+        description="Filter criteria for the resource of the event",
     )
     related: Optional[EventRelatedFilter] = Field(
-        None, description="Filter criteria for the related resources of the event"
+        default=None,
+        description="Filter criteria for the related resources of the event",
     )
     id: EventIDFilter = Field(
         default_factory=lambda: EventIDFilter(id=[]),
@@ -248,6 +252,6 @@ class EventFilter(EventDataFilter):
     )
 
     order: EventOrder = Field(
-        EventOrder.DESC,
+        default=EventOrder.DESC,
         description="The order to return filtered events",
     )

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/exceptions.py

@@ -443,3 +443,7 @@ class ProfileSettingsValidationError(PrefectException):
 
     def __init__(self, errors: List[Tuple[Any, ValidationError]]) -> None:
         self.errors = errors
+
+
+class HashError(PrefectException):
+    """Raised when hashing objects fails"""

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/flow_engine.py

@@ -22,8 +22,11 @@ from typing import (
 )
 from uuid import UUID
 
+from opentelemetry import trace
+from opentelemetry.trace import Tracer, get_tracer
 from typing_extensions import ParamSpec
 
+import prefect
 from prefect import Task
 from prefect.client.orchestration import SyncPrefectClient, get_client
 from prefect.client.schemas import FlowRun, TaskRun
@@ -124,6 +127,10 @@ class FlowRunEngine(Generic[P, R]):
     _client: Optional[SyncPrefectClient] = None
     short_circuit: bool = False
     _flow_run_name_set: bool = False
+    _tracer: Tracer = field(
+        default_factory=lambda: get_tracer("prefect", prefect.__version__)
+    )
+    _span: Optional[trace.Span] = None
 
     def __post_init__(self):
         if self.flow is None and self.flow_run_id is None:
@@ -233,6 +240,17 @@ class FlowRunEngine(Generic[P, R]):
         self.flow_run.state = state  # type: ignore
         self.flow_run.state_name = state.name  # type: ignore
         self.flow_run.state_type = state.type  # type: ignore
+
+        if self._span:
+            self._span.add_event(
+                state.name,
+                {
+                    "prefect.state.message": state.message or "",
+                    "prefect.state.type": state.type,
+                    "prefect.state.name": state.name or state.type,
+                    "prefect.state.id": str(state.id),
+                },
+            )
         return state
 
     def result(self, raise_on_failure: bool = True) -> "Union[R, State, None]":
@@ -281,6 +299,9 @@ class FlowRunEngine(Generic[P, R]):
         )
         self.set_state(terminal_state)
         self._return_value = resolved_result
+
+        self._end_span_on_success()
+
         return result
 
     def handle_exception(
@@ -311,6 +332,9 @@ class FlowRunEngine(Generic[P, R]):
             )
             state = self.set_state(Running())
         self._raised = exc
+
+        self._end_span_on_error(exc, state.message)
+
         return state
 
     def handle_timeout(self, exc: TimeoutError) -> None:
@@ -329,6 +353,8 @@ class FlowRunEngine(Generic[P, R]):
         self.set_state(state)
         self._raised = exc
 
+        self._end_span_on_error(exc, message)
+
     def handle_crash(self, exc: BaseException) -> None:
         state = run_coro_as_sync(exception_to_crashed_state(exc))
         self.logger.error(f"Crash detected! {state.message}")
@@ -336,6 +362,23 @@ class FlowRunEngine(Generic[P, R]):
         self.set_state(state, force=True)
         self._raised = exc
 
+        self._end_span_on_error(exc, state.message)
+
+    def _end_span_on_success(self):
+        if not self._span:
+            return
+        self._span.set_status(trace.Status(trace.StatusCode.OK))
+        self._span.end(time.time_ns())
+        self._span = None
+
+    def _end_span_on_error(self, exc: BaseException, description: Optional[str]):
+        if not self._span:
+            return
+        self._span.record_exception(exc)
+        self._span.set_status(trace.Status(trace.StatusCode.ERROR, description))
+        self._span.end(time.time_ns())
+        self._span = None
+
     def load_subflow_run(
         self,
         parent_task_run: TaskRun,
@@ -578,6 +621,18 @@ class FlowRunEngine(Generic[P, R]):
                     flow_version=self.flow.version,
                     empirical_policy=self.flow_run.empirical_policy,
                 )
+
+            self._span = self._tracer.start_span(
+                name=self.flow_run.name,
+                attributes={
+                    **self.flow_run.labels,
+                    "prefect.run.type": "flow",
+                    "prefect.run.id": str(self.flow_run.id),
+                    "prefect.tags": self.flow_run.tags,
+                    "prefect.flow.name": self.flow.name,
+                },
+            )
+
             try:
                 yield self
 
@@ -632,7 +687,7 @@ class FlowRunEngine(Generic[P, R]):
 
     @contextmanager
     def start(self) -> Generator[None, None, None]:
-        with self.initialize_run():
+        with self.initialize_run(), trace.use_span(self._span):
             self.begin_run()
 
             if self.state.is_running():

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/logging/handlers.py

@@ -32,7 +32,6 @@ from prefect.settings import (
     PREFECT_LOGGING_TO_API_BATCH_SIZE,
     PREFECT_LOGGING_TO_API_MAX_LOG_SIZE,
     PREFECT_LOGGING_TO_API_WHEN_MISSING_FLOW,
-    get_current_settings,
 )
 
 
@@ -241,10 +240,12 @@ class APILogHandler(logging.Handler):
 
 class WorkerAPILogHandler(APILogHandler):
     def emit(self, record: logging.LogRecord):
-        if get_current_settings().experiments.worker_logging_to_api_enabled:
-            super().emit(record)
-        else:
+        # Open-source API servers do not currently support worker logs, and
+        # worker logs only have an associated worker ID when connected to Cloud,
+        # so we won't send worker logs to the API unless they have a worker ID.
+        if not getattr(record, "worker_id", None):
             return
+        super().emit(record)
 
     def prepare(self, record: logging.LogRecord) -> Dict[str, Any]:
         """

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/settings/models/experiments.py

@@ -18,11 +18,6 @@ class ExperimentsSettings(PrefectBaseSettings):
         ),
     )
 
-    worker_logging_to_api_enabled: bool = Field(
-        default=False,
-        description="Enables the logging of worker logs to Prefect Cloud.",
-    )
-
     telemetry_enabled: bool = Field(
         default=False,
         description="Enables sending telemetry to Prefect Cloud.",

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/telemetry/processors.py

@@ -1,6 +1,6 @@
 import time
 from threading import Event, Lock, Thread
-from typing import Optional
+from typing import Dict, Optional
 
 from opentelemetry.context import Context
 from opentelemetry.sdk.trace import ReadableSpan, Span, SpanProcessor
@@ -10,7 +10,7 @@ from opentelemetry.sdk.trace.export import SpanExporter
 class InFlightSpanProcessor(SpanProcessor):
     def __init__(self, span_exporter: SpanExporter):
         self.span_exporter = span_exporter
-        self._in_flight = {}
+        self._in_flight: Dict[int, Span] = {}
         self._lock = Lock()
         self._stop_event = Event()
         self._export_thread = Thread(target=self._export_periodically, daemon=True)

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/utilities/filesystem.py

@@ -7,7 +7,7 @@ import pathlib
 import threading
 from contextlib import contextmanager
 from pathlib import Path, PureWindowsPath
-from typing import Optional, Union
+from typing import Optional, Union, cast
 
 import fsspec
 import pathspec
@@ -22,8 +22,8 @@ def create_default_ignore_file(path: str) -> bool:
     Creates default ignore file in the provided path if one does not already exist; returns boolean specifying
     whether a file was created.
     """
-    path = pathlib.Path(path)
-    ignore_file = path / ".prefectignore"
+    _path = pathlib.Path(path)
+    ignore_file = _path / ".prefectignore"
     if ignore_file.exists():
         return False
     default_file = pathlib.Path(prefect.__module_path__) / ".prefectignore"
@@ -54,12 +54,34 @@ def filter_files(
 chdir_lock = threading.Lock()
 
 
+def _normalize_path(path: Union[str, Path]) -> str:
+    """
+    Normalize a path, handling UNC paths on Windows specially.
+    """
+    path = Path(path)
+
+    # Handle UNC paths on Windows differently
+    if os.name == "nt" and str(path).startswith("\\\\"):
+        # For UNC paths, use absolute() instead of resolve()
+        # to avoid the Windows path resolution issues
+        return str(path.absolute())
+    else:
+        try:
+            # For non-UNC paths, try resolve() first
+            return str(path.resolve())
+        except OSError:
+            # Fallback to absolute() if resolve() fails
+            return str(path.absolute())
+
+
 @contextmanager
 def tmpchdir(path: str):
     """
-    Change current-working directories for the duration of the context
+    Change current-working directories for the duration of the context,
+    with special handling for UNC paths on Windows.
     """
-    path = os.path.abspath(path)
+    path = _normalize_path(path)
+
     if os.path.isfile(path) or (not os.path.exists(path) and not path.endswith("/")):
         path = os.path.dirname(path)
 
@@ -67,7 +89,12 @@ def tmpchdir(path: str):
 
     with chdir_lock:
         try:
-            os.chdir(path)
+            # On Windows with UNC paths, we need to handle the directory change carefully
+            if os.name == "nt" and path.startswith("\\\\"):
+                # Use os.path.abspath to handle UNC paths
+                os.chdir(os.path.abspath(path))
+            else:
+                os.chdir(path)
             yield path
         finally:
             os.chdir(owd)
@@ -76,7 +103,7 @@ def tmpchdir(path: str):
 def filename(path: str) -> str:
     """Extract the file name from a path with remote file system support"""
     try:
-        of: OpenFile = fsspec.open(path)
+        of: OpenFile = cast(OpenFile, fsspec.open(path))
         sep = of.fs.sep
     except (ImportError, AttributeError):
         sep = "\\" if "\\" in path else "/"
@@ -98,7 +125,7 @@ def is_local_path(path: Union[str, pathlib.Path, OpenFile]):
     else:
         raise TypeError(f"Invalid path of type {type(path).__name__!r}")
 
-    return type(of.fs) == LocalFileSystem
+    return isinstance(of.fs, LocalFileSystem)
 
 
 def to_display_path(

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/utilities/hashing.py

@@ -6,6 +6,7 @@ from typing import Optional, Union
 
 import cloudpickle
 
+from prefect.exceptions import HashError
 from prefect.serializers import JSONSerializer
 
 if sys.version_info[:2] >= (3, 9):
@@ -53,19 +54,39 @@ def hash_objects(
 ) -> Optional[str]:
     """
     Attempt to hash objects by dumping to JSON or serializing with cloudpickle.
-    On failure of both, `None` will be returned; to raise on failure, set
-    `raise_on_failure=True`.
+
+    Args:
+        *args: Positional arguments to hash
+        hash_algo: Hash algorithm to use
+        raise_on_failure: If True, raise exceptions instead of returning None
+        **kwargs: Keyword arguments to hash
+
+    Returns:
+        A hash string or None if hashing failed
+
+    Raises:
+        HashError: If objects cannot be hashed and raise_on_failure is True
     """
+    json_error = None
+    pickle_error = None
+
     try:
         serializer = JSONSerializer(dumps_kwargs={"sort_keys": True})
         return stable_hash(serializer.dumps((args, kwargs)), hash_algo=hash_algo)
-    except Exception:
-        pass
+    except Exception as e:
+        json_error = str(e)
 
     try:
         return stable_hash(cloudpickle.dumps((args, kwargs)), hash_algo=hash_algo)
-    except Exception:
-        if raise_on_failure:
-            raise
+    except Exception as e:
+        pickle_error = str(e)
+
+    if raise_on_failure:
+        msg = (
+            "Unable to create hash - objects could not be serialized.\n"
+            f"  JSON error: {json_error}\n"
+            f"  Pickle error: {pickle_error}"
+        )
+        raise HashError(msg)
 
     return None

{prefect-client-3.1.2 → prefect-client-3.1.3}/src/prefect/utilities/urls.py

@@ -3,7 +3,7 @@ import ipaddress
 import socket
 import urllib.parse
 from string import Formatter
-from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Union
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 from urllib.parse import urlparse
 from uuid import UUID
 
@@ -135,7 +135,7 @@ def url_for(
     obj_id: Optional[Union[str, UUID]] = None,
     url_type: URLType = "ui",
     default_base_url: Optional[str] = None,
-    **additional_format_kwargs: Optional[Dict[str, Any]],
+    **additional_format_kwargs: Any,
 ) -> Optional[str]:
     """
     Returns the URL for a Prefect object.