prefect-client 2.18.2__py3-none-any.whl → 2.19.0__py3-none-any.whl

prefect/__init__.py

@@ -25,25 +25,12 @@ __ui_static_path__ = __module_path__ / "server" / "ui"
 
 del _version, pathlib
 
-if sys.version_info < (3, 8):
-    warnings.warn(
-        (
-            "Prefect dropped support for Python 3.7 when it reached end-of-life"
-            " . To use new versions of Prefect, you will need"
-            " to upgrade to Python 3.8+. See https://devguide.python.org/versions/ for "
-            " more details."
-        ),
-        FutureWarning,
-        stacklevel=2,
-    )
-
 
 # Import user-facing API
-from prefect.runner import Runner, serve
 from prefect.deployments import deploy
 from prefect.states import State
 from prefect.logging import get_run_logger
-from prefect.flows import flow, Flow
+from prefect.flows import flow, Flow, serve
 from prefect.tasks import task, Task
 from prefect.context import tags
 from prefect.manifests import Manifest
@@ -159,7 +146,6 @@ __all__ = [
     "task",
     "Task",
     "unmapped",
-    "Runner",
     "serve",
     "deploy",
     "pause_flow_run",

prefect/_internal/concurrency/cancellation.py

@@ -581,6 +581,8 @@ def _send_exception_to_thread(thread: threading.Thread, exc_type: Type[BaseExcep
 
     This will not interrupt long-running system calls like `sleep` or `wait`.
     """
+    if not thread.ident:
+        raise ValueError("Thread is not started.")
     ret = ctypes.pythonapi.PyThreadState_SetAsyncExc(
         ctypes.c_long(thread.ident), ctypes.py_object(exc_type)
     )

prefect/_internal/schemas/validators.py

@@ -112,6 +112,10 @@ def validate_values_conform_to_schema(
     """
     Validate that the provided values conform to the provided json schema.
 
+    TODO: This schema validation is outdated. The latest version is
+    prefect.utilities.schema_tools.validate, which handles fixes to Pydantic v1
+    schemas for null values and tuples.
+
     Args:
         values: The values to validate.
         schema: The schema to validate against.
@@ -322,6 +326,12 @@ def set_deployment_schedules(values: dict) -> dict:
     return values
 
 
+def validate_schedule_max_scheduled_runs(v: Optional[int], limit: int) -> Optional[int]:
+    if v is not None and v > limit:
+        raise ValueError(f"`max_scheduled_runs` must be less than or equal to {limit}.")
+    return v
+
+
 def remove_old_deployment_fields(values: dict) -> dict:
     # 2.7.7 removed worker_pool_queue_id in lieu of worker_pool_name and
     # worker_pool_queue_name. Those fields were later renamed to work_pool_name

prefect/_vendor/starlette/testclient.py

@@ -461,7 +461,7 @@ class TestClient(httpx.Client):
         ] = httpx._client.USE_CLIENT_DEFAULT,
         extensions: typing.Optional[typing.Dict[str, typing.Any]] = None,
     ) -> httpx.Response:
-        url = self.base_url.join(url)
+        url = self._merge_url(url)
         redirect = self._choose_redirect_arg(follow_redirects, allow_redirects)
         return super().request(
             method,

prefect/blocks/notifications.py

@@ -235,7 +235,7 @@ class PagerDutyWebHook(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
-        from apprise.plugins.NotifyPagerDuty import NotifyPagerDuty
+        from apprise.plugins.pagerduty import NotifyPagerDuty
 
         url = SecretStr(
             NotifyPagerDuty(
@@ -303,7 +303,7 @@ class TwilioSMS(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
-        from apprise.plugins.NotifyTwilio import NotifyTwilio
+        from apprise.plugins.twilio import NotifyTwilio
 
         url = SecretStr(
             NotifyTwilio(
@@ -401,7 +401,7 @@ class OpsgenieWebhook(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
-        from apprise.plugins.NotifyOpsgenie import NotifyOpsgenie
+        from apprise.plugins.opsgenie import NotifyOpsgenie
 
         targets = []
         if self.target_user:
@@ -489,7 +489,7 @@ class MattermostWebhook(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
-        from apprise.plugins.NotifyMattermost import NotifyMattermost
+        from apprise.plugins.mattermost import NotifyMattermost
 
         url = SecretStr(
             NotifyMattermost(
@@ -582,7 +582,7 @@ class DiscordWebhook(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
-        from apprise.plugins.NotifyDiscord import NotifyDiscord
+        from apprise.plugins.discord import NotifyDiscord
 
         url = SecretStr(
             NotifyDiscord(
@@ -773,7 +773,7 @@ class SendgridEmail(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
-        from apprise.plugins.NotifySendGrid import NotifySendGrid
+        from apprise.plugins.sendgrid import NotifySendGrid
 
         url = SecretStr(
             NotifySendGrid(

prefect/client/base.py

@@ -1,6 +1,7 @@
 import copy
 import sys
 import threading
+import time
 import uuid
 from collections import defaultdict
 from contextlib import asynccontextmanager
@@ -25,6 +26,7 @@ import httpx
 from asgi_lifespan import LifespanManager
 from httpx import HTTPStatusError, Request, Response
 from prefect._vendor.starlette import status
+from prefect._vendor.starlette.testclient import TestClient
 from typing_extensions import Self
 
 import prefect
@@ -182,7 +184,7 @@ class PrefectResponse(httpx.Response):
         return new_response
 
 
-class PrefectHttpxClient(httpx.AsyncClient):
+class PrefectHttpxAsyncClient(httpx.AsyncClient):
     """
     A Prefect wrapper for the async httpx client with support for retry-after headers
     for the provided status codes (typically 429, 502 and 503).
@@ -394,3 +396,244 @@ class PrefectHttpxClient(httpx.AsyncClient):
 
         request.headers["Prefect-Csrf-Token"] = self.csrf_token
         request.headers["Prefect-Csrf-Client"] = str(self.csrf_client_id)
+
+
+class PrefectHttpxSyncClient(httpx.Client):
+    """
+    A Prefect wrapper for the async httpx client with support for retry-after headers
+    for the provided status codes (typically 429, 502 and 503).
+
+    Additionally, this client will always call `raise_for_status` on responses.
+
+    For more details on rate limit headers, see:
+    [Configuring Cloudflare Rate Limiting](https://support.cloudflare.com/hc/en-us/articles/115001635128-Configuring-Rate-Limiting-from-UI)
+    """
+
+    def __init__(
+        self,
+        *args,
+        enable_csrf_support: bool = False,
+        raise_on_all_errors: bool = True,
+        **kwargs,
+    ):
+        self.enable_csrf_support: bool = enable_csrf_support
+        self.csrf_token: Optional[str] = None
+        self.csrf_token_expiration: Optional[datetime] = None
+        self.csrf_client_id: uuid.UUID = uuid.uuid4()
+        self.raise_on_all_errors: bool = raise_on_all_errors
+
+        super().__init__(*args, **kwargs)
+
+        user_agent = (
+            f"prefect/{prefect.__version__} (API {constants.SERVER_API_VERSION})"
+        )
+        self.headers["User-Agent"] = user_agent
+
+    def _send_with_retry(
+        self,
+        request: Request,
+        send: Callable[[Request], Response],
+        send_args: Tuple,
+        send_kwargs: Dict,
+        retry_codes: Set[int] = set(),
+        retry_exceptions: Tuple[Exception, ...] = tuple(),
+    ):
+        """
+        Send a request and retry it if it fails.
+
+        Sends the provided request and retries it up to PREFECT_CLIENT_MAX_RETRIES times
+        if the request either raises an exception listed in `retry_exceptions` or
+        receives a response with a status code listed in `retry_codes`.
+
+        Retries will be delayed based on either the retry header (preferred) or
+        exponential backoff if a retry header is not provided.
+        """
+        try_count = 0
+        response = None
+
+        is_change_request = request.method.lower() in {"post", "put", "patch", "delete"}
+
+        if self.enable_csrf_support and is_change_request:
+            self._add_csrf_headers(request=request)
+
+        while try_count <= PREFECT_CLIENT_MAX_RETRIES.value():
+            try_count += 1
+            retry_seconds = None
+            exc_info = None
+
+            try:
+                response = send(request, *send_args, **send_kwargs)
+            except retry_exceptions:  # type: ignore
+                if try_count > PREFECT_CLIENT_MAX_RETRIES.value():
+                    raise
+                # Otherwise, we will ignore this error but capture the info for logging
+                exc_info = sys.exc_info()
+            else:
+                # We got a response; check if it's a CSRF error, otherwise
+                # return immediately if it is not retryable
+                if (
+                    response.status_code == status.HTTP_403_FORBIDDEN
+                    and "Invalid CSRF token" in response.text
+                ):
+                    # We got a CSRF error, clear the token and try again
+                    self.csrf_token = None
+                    self._add_csrf_headers(request)
+                elif response.status_code not in retry_codes:
+                    return response
+
+                if "Retry-After" in response.headers:
+                    retry_seconds = float(response.headers["Retry-After"])
+
+            # Use an exponential back-off if not set in a header
+            if retry_seconds is None:
+                retry_seconds = 2**try_count
+
+            # Add jitter
+            jitter_factor = PREFECT_CLIENT_RETRY_JITTER_FACTOR.value()
+            if retry_seconds > 0 and jitter_factor > 0:
+                if response is not None and "Retry-After" in response.headers:
+                    # Always wait for _at least_ retry seconds if requested by the API
+                    retry_seconds = bounded_poisson_interval(
+                        retry_seconds, retry_seconds * (1 + jitter_factor)
+                    )
+                else:
+                    # Otherwise, use a symmetrical jitter
+                    retry_seconds = clamped_poisson_interval(
+                        retry_seconds, jitter_factor
+                    )
+
+            logger.debug(
+                (
+                    "Encountered retryable exception during request. "
+                    if exc_info
+                    else (
+                        "Received response with retryable status code"
+                        f" {response.status_code}. "
+                    )
+                )
+                + f"Another attempt will be made in {retry_seconds}s. "
+                "This is attempt"
+                f" {try_count}/{PREFECT_CLIENT_MAX_RETRIES.value() + 1}.",
+                exc_info=exc_info,
+            )
+            time.sleep(retry_seconds)
+
+        assert (
+            response is not None
+        ), "Retry handling ended without response or exception"
+
+        # We ran out of retries, return the failed response
+        return response
+
+    def send(self, request: Request, *args, **kwargs) -> Response:
+        """
+        Send a request with automatic retry behavior for the following status codes:
+
+        - 403 Forbidden, if the request failed due to CSRF protection
+        - 408 Request Timeout
+        - 429 CloudFlare-style rate limiting
+        - 502 Bad Gateway
+        - 503 Service unavailable
+        - Any additional status codes provided in `PREFECT_CLIENT_RETRY_EXTRA_CODES`
+        """
+
+        super_send = super().send
+        response = self._send_with_retry(
+            request=request,
+            send=super_send,
+            send_args=args,
+            send_kwargs=kwargs,
+            retry_codes={
+                status.HTTP_429_TOO_MANY_REQUESTS,
+                status.HTTP_503_SERVICE_UNAVAILABLE,
+                status.HTTP_502_BAD_GATEWAY,
+                status.HTTP_408_REQUEST_TIMEOUT,
+                *PREFECT_CLIENT_RETRY_EXTRA_CODES.value(),
+            },
+            retry_exceptions=(
+                httpx.ReadTimeout,
+                httpx.PoolTimeout,
+                httpx.ConnectTimeout,
+                # `ConnectionResetError` when reading socket raises as a `ReadError`
+                httpx.ReadError,
+                # Sockets can be closed during writes resulting in a `WriteError`
+                httpx.WriteError,
+                # Uvicorn bug, see https://github.com/PrefectHQ/prefect/issues/7512
+                httpx.RemoteProtocolError,
+                # HTTP2 bug, see https://github.com/PrefectHQ/prefect/issues/7442
+                httpx.LocalProtocolError,
+            ),
+        )
+
+        # Convert to a Prefect response to add nicer errors messages
+        response = PrefectResponse.from_httpx_response(response)
+
+        if self.raise_on_all_errors:
+            response.raise_for_status()
+
+        return response
+
+    def _add_csrf_headers(self, request: Request):
+        now = datetime.now(timezone.utc)
+
+        if not self.enable_csrf_support:
+            return
+
+        if not self.csrf_token or (
+            self.csrf_token_expiration and now > self.csrf_token_expiration
+        ):
+            token_request = self.build_request(
+                "GET", f"/csrf-token?client={self.csrf_client_id}"
+            )
+
+            try:
+                token_response = self.send(token_request)
+            except PrefectHTTPStatusError as exc:
+                old_server = exc.response.status_code == status.HTTP_404_NOT_FOUND
+                unconfigured_server = (
+                    exc.response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
+                    and "CSRF protection is disabled." in exc.response.text
+                )
+
+                if old_server or unconfigured_server:
+                    # The token endpoint is either unavailable, suggesting an
+                    # older server, or CSRF protection is disabled. In either
+                    # case we should disable CSRF support.
+                    self.enable_csrf_support = False
+                    return
+
+                raise
+
+            token: CsrfToken = CsrfToken.parse_obj(token_response.json())
+            self.csrf_token = token.token
+            self.csrf_token_expiration = token.expiration
+
+        request.headers["Prefect-Csrf-Token"] = self.csrf_token
+        request.headers["Prefect-Csrf-Client"] = str(self.csrf_client_id)
+
+
+class PrefectHttpxSyncEphemeralClient(TestClient, PrefectHttpxSyncClient):
+    """
+    This client is a synchronous httpx client that can be used to talk directly
+    to an ASGI app, such as an ephemeral Prefect API.
+
+    It is a subclass of both Starlette's `TestClient` and Prefect's
+    `PrefectHttpxSyncClient`, so it combines the synchronous testing
+    capabilities of `TestClient` with the Prefect-specific behaviors of
+    `PrefectHttpxSyncClient`.
+    """
+
+    def __init__(
+        self,
+        *args,
+        # override TestClient default
+        raise_server_exceptions=False,
+        **kwargs,
+    ):
+        super().__init__(
+            *args,
+            raise_server_exceptions=raise_server_exceptions,
+            **kwargs,
+        )
+
+    pass

prefect/client/cloud.py

@@ -15,7 +15,7 @@ from prefect._vendor.starlette import status
 
 import prefect.context
 import prefect.settings
-from prefect.client.base import PrefectHttpxClient
+from prefect.client.base import PrefectHttpxAsyncClient
 from prefect.client.schemas import Workspace
 from prefect.exceptions import PrefectException
 from prefect.settings import (
@@ -72,7 +72,9 @@ class CloudClient:
         httpx_settings.setdefault("base_url", host)
         if not PREFECT_UNIT_TEST_MODE.value():
             httpx_settings.setdefault("follow_redirects", True)
-        self._client = PrefectHttpxClient(**httpx_settings, enable_csrf_support=False)
+        self._client = PrefectHttpxAsyncClient(
+            **httpx_settings, enable_csrf_support=False
+        )
 
     async def api_healthcheck(self):
         """