prefect-client 2.17.0__py3-none-any.whl → 2.18.0__py3-none-any.whl

prefect/_internal/compatibility/deprecated.py

@@ -344,6 +344,8 @@ class DeprecatedInfraOverridesField(BaseModel):
             exclude.add("job_variables")
         elif exclude_type is dict:
             exclude["job_variables"] = True
+        else:
+            exclude = {"job_variables"}
         kwargs["exclude"] = exclude
 
         return super().dict(**kwargs)

prefect/_internal/pydantic/_compat.py

@@ -2,6 +2,7 @@
 Functions within this module check for Pydantic V2 compatibility and provide mechanisms for copying,
  dumping, and validating models in a way that is agnostic to the underlying Pydantic version.
 """
+
 import typing
 
 from ._base_model import BaseModel as PydanticBaseModel

prefect/_internal/pydantic/utilities/field_validator.py

@@ -4,7 +4,7 @@ Conditional decorator for fields depending on Pydantic version.
 
 import functools
 from inspect import signature
-from typing import TYPE_CHECKING, Any, Callable, Dict, Literal, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Callable, Dict, Literal, TypeVar, Union
 
 from typing_extensions import TypeAlias
 
@@ -21,11 +21,8 @@ def field_validator(
     field: str,
     /,
     *fields: str,
-    mode: FieldValidatorModes = "after",  # v2 only
+    mode: FieldValidatorModes = "after",
     check_fields: Union[bool, None] = None,
-    pre: bool = False,  # v1 only
-    allow_reuse: Optional[bool] = None,
-    always: bool = False,  # v1 only
 ) -> Callable[[Any], Any]:
     """Usage docs: https://docs.pydantic.dev/2.7/concepts/validators/#field-validators
     Returns a decorator that conditionally applies Pydantic's `field_validator` or `validator`,
@@ -37,6 +34,26 @@ def field_validator(
 
     Decorate methods on the class indicating that they should be used to validate fields.
 
+    !!! note Replacing Pydantic V1 `pre=True` kwarg:
+    To replace a @validator that uses Pydantic V1's `pre` parameter, e.g. `@validator('a', pre=True)`,
+    you can use `mode='before'`, e.g. @field_validator('a', mode='before').
+
+    If a user has Pydantic V1 installed, `mode` will map to the `pre` parameter of `validator` if the value is `before`.
+
+    !!! note Replacing Pydantic V1 `always=True` kwarg:
+    To replace a @validator that uses Pydantic V1's `always` parameter, e.g. `@validator('a', always=True)`,
+    you can use the @model_validator (not the @field_validator) with the `mode='before'` parameter, (and also add a check that the field is not None, if necessary).
+
+    Read more discussion on that here: https://github.com/pydantic/pydantic/discussions/6337
+
+    !!! note Replacing Pydantic V1 `allow_reuse=True` kwarg:
+    To replace a @validator that uses Pydantic V1's `allow_reuse=True` parameter, e.g. `@validator('a', allow_reuse=True)`,
+    you can simply remove the `allow_reuse` parameter when replacing the decorator, e.g. `@field_validator('a')`. This is because
+    Pydantic V2 by default allows reuse of the decorated function, rendering the kwarg necessary), while Pydantic V1 required explicit
+    declaration of `allow_reuse=True`.
+
+    https://docs.pydantic.dev/2.0/migration/#the-allow_reuse-keyword-argument-is-no-longer-necessary
+
     Example usage:
     ```py
     from typing import Any
@@ -120,14 +137,12 @@ def field_validator(
 
             return validate_func(cls, v, **filtered_kwargs)
 
-        # In Pydantic V1, `allow_reuse` is by default False, while in Pydantic V2, it is by default True.
-        # We default to False in Pydantic V1 to maintain backward compatibility
-        # e.g. One uses @validator("a", pre=True, allow_reuse=True) in Pydantic V1
+        # Map Pydantic V2's `mode` to Pydantic V1's `pre` parameter for use in `@validator`
+        pre: bool = mode == "before"
+
         validator_kwargs: Dict[str, Any] = {
             "pre": pre,
-            "always": always,
             "check_fields": check_fields if check_fields is not None else True,
-            "allow_reuse": allow_reuse if allow_reuse is not None else False,
         }
 
         return validator(field, *fields, **validator_kwargs)(wrapper)  # type: ignore

prefect/_internal/pydantic/utilities/model_dump.py

@@ -47,7 +47,7 @@ def model_dump(  # type: ignore[no-redef]
     Returns:
         A dictionary representation of the model.
     """
-    if USE_V2_MODELS:
+    if USE_V2_MODELS and hasattr(model_instance, "model_dump"):
         return model_instance.model_dump(
             mode=mode,
             include=include,

prefect/_internal/pydantic/utilities/model_validate.py

@@ -39,7 +39,7 @@ def model_validate(
             context=context,
         )
     else:
-        return getattr(model_instance, "validate")(obj)
+        return getattr(model_instance, "parse_obj")(obj)
 
 
 class ModelValidateMixin(BaseModel):

prefect/_internal/pydantic/utilities/model_validator.py

@@ -13,8 +13,6 @@ def model_validator(
     _func: Optional[Callable] = None,
     *,
     mode: Literal["wrap", "before", "after"] = "before",  # v2 only
-    pre: bool = False,  # v1 only
-    skip_on_failure: bool = False,  # v1 only
 ) -> Any:
     """Usage docs: https://docs.pydantic.dev/2.6/concepts/validators/#model-validators
 
@@ -33,6 +31,15 @@ def model_validator(
     validation logic before, after, or wrapping the original method call, depending on the
     `mode` parameter.
 
+    !!! note Replacing Pydantic V1 `pre=True` kwarg:
+    To replace a @root_validator that uses Pydantic V1's `pre=True` parameter, e.g. `@root_validator('a', pre=True)`,
+    you can use the @model_validator with the `mode='before'` parameter, (and also add a check that the field is not None, if necessary).
+    This will map to the `pre` parameter of `root_validator` in Pydantic V1, if the value is `True`.
+
+    !!! note Replacing Pydantic V1 `skip_on_failure=True` kwarg:
+    To replace a @root_validator that uses Pydantic V1's `skip_on_failure=True` parameter, e.g. `@root_validator('a', skip_on_failure=True)`,
+    we'll simply remove it. Pydantic V2 does not have an equivalent parameter, and we use it in only 3 places in Prefect, none of which are critical.
+
     Args:
         _func: The function to be decorated. If None, the decorator is applied with parameters.
         mode: Specifies when the validation should occur. 'before' or 'after' are for v1 compatibility,
@@ -69,9 +76,10 @@ def model_validator(
         ) -> Any:
             return validate_func(cls, v)
 
+        pre: bool = mode == "before"
+
         return root_validator(
             pre=pre,
-            skip_on_failure=skip_on_failure,
         )(wrapper)  # type: ignore
 
     if _func is None:

prefect/_internal/schemas/validators.py

@@ -372,12 +372,6 @@ def reconcile_paused_deployment(values):
     return values
 
 
-def interval_schedule_must_be_positive(v: datetime.timedelta) -> datetime.timedelta:
-    if v.total_seconds() <= 0:
-        raise ValueError("The interval must be positive")
-    return v
-
-
 def default_anchor_date(v: DateTimeTZ) -> DateTimeTZ:
     if v is None:
         return pendulum.now("UTC")

prefect/_version.py

@@ -4,19 +4,22 @@
 # directories (produced by setup.py build) will contain a much shorter file
 # that just contains the computed version number.
 
-# This file is released into the public domain. Generated by
-# versioneer-0.20 (https://github.com/python-versioneer/python-versioneer)
+# This file is released into the public domain.
+# Generated by versioneer-0.29
+# https://github.com/python-versioneer/python-versioneer
 
 """Git implementation of _version.py."""
 
 import errno
+import functools
 import os
 import re
 import subprocess
 import sys
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
 
-def get_keywords():
+def get_keywords() -> Dict[str, str]:
     """Get the keywords needed to look up the version information."""
     # these strings will be replaced by git during git-archive.
     # setup.py/versioneer.py will grep for the variable names, so they must
@@ -29,11 +32,18 @@ def get_keywords():
     return keywords
 
 
-class VersioneerConfig:  # pylint: disable=too-few-public-methods
+class VersioneerConfig:
     """Container for Versioneer configuration parameters."""
 
+    VCS: str
+    style: str
+    tag_prefix: str
+    parentdir_prefix: str
+    versionfile_source: str
+    verbose: bool
 
-def get_config():
+
+def get_config() -> VersioneerConfig:
     """Create, populate and return the VersioneerConfig() object."""
     # these strings are filled in when 'setup.py versioneer' creates
     # _version.py
@@ -51,14 +61,14 @@ class NotThisMethod(Exception):
     """Exception raised if a method is not valid for the current scenario."""
 
 
-LONG_VERSION_PY = {}
-HANDLERS = {}
+LONG_VERSION_PY: Dict[str, str] = {}
+HANDLERS: Dict[str, Dict[str, Callable]] = {}
 
 
-def register_vcs_handler(vcs, method):  # decorator
+def register_vcs_handler(vcs: str, method: str) -> Callable:  # decorator
     """Create decorator to mark a method as the handler of a VCS."""
 
-    def decorate(f):
+    def decorate(f: Callable) -> Callable:
         """Store f in HANDLERS[vcs][method]."""
         if vcs not in HANDLERS:
             HANDLERS[vcs] = {}
@@ -68,11 +78,25 @@ def register_vcs_handler(vcs, method):  # decorator
     return decorate
 
 
-# pylint:disable=too-many-arguments,consider-using-with # noqa
-def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None):
+def run_command(
+    commands: List[str],
+    args: List[str],
+    cwd: Optional[str] = None,
+    verbose: bool = False,
+    hide_stderr: bool = False,
+    env: Optional[Dict[str, str]] = None,
+) -> Tuple[Optional[str], Optional[int]]:
     """Call the given command(s)."""
     assert isinstance(commands, list)
     process = None
+
+    popen_kwargs: Dict[str, Any] = {}
+    if sys.platform == "win32":
+        # This hides the console window if pythonw.exe is used
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        popen_kwargs["startupinfo"] = startupinfo
+
     for command in commands:
         try:
             dispcmd = str([command] + args)
@@ -83,10 +107,10 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=
                 env=env,
                 stdout=subprocess.PIPE,
                 stderr=(subprocess.PIPE if hide_stderr else None),
+                **popen_kwargs,
             )
             break
-        except EnvironmentError:
-            e = sys.exc_info()[1]
+        except OSError as e:
             if e.errno == errno.ENOENT:
                 continue
             if verbose:
@@ -106,7 +130,11 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=
     return stdout, process.returncode
 
 
-def versions_from_parentdir(parentdir_prefix, root, verbose):
+def versions_from_parentdir(
+    parentdir_prefix: str,
+    root: str,
+    verbose: bool,
+) -> Dict[str, Any]:
     """Try to determine the version from the parent directory name.
 
     Source tarballs conventionally unpack into a directory that includes both
@@ -137,13 +165,13 @@ def versions_from_parentdir(parentdir_prefix, root, verbose):
 
 
 @register_vcs_handler("git", "get_keywords")
-def git_get_keywords(versionfile_abs):
+def git_get_keywords(versionfile_abs: str) -> Dict[str, str]:
     """Extract version information from the given file."""
     # the code embedded in _version.py can just fetch the value of these
     # keywords. When used from setup.py, we don't want to import _version.py,
     # so we do it with a regexp instead. This function is not used from
     # _version.py.
-    keywords = {}
+    keywords: Dict[str, str] = {}
     try:
         with open(versionfile_abs, "r") as fobj:
             for line in fobj:
@@ -159,13 +187,17 @@ def git_get_keywords(versionfile_abs):
                     mo = re.search(r'=\s*"(.*)"', line)
                     if mo:
                         keywords["date"] = mo.group(1)
-    except EnvironmentError:
+    except OSError:
         pass
     return keywords
 
 
 @register_vcs_handler("git", "keywords")
-def git_versions_from_keywords(keywords, tag_prefix, verbose):
+def git_versions_from_keywords(
+    keywords: Dict[str, str],
+    tag_prefix: str,
+    verbose: bool,
+) -> Dict[str, Any]:
     """Get version information from git keywords."""
     if "refnames" not in keywords:
         raise NotThisMethod("Short version file found")
@@ -236,7 +268,9 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
 
 
 @register_vcs_handler("git", "pieces_from_vcs")
-def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
+def git_pieces_from_vcs(
+    tag_prefix: str, root: str, verbose: bool, runner: Callable = run_command
+) -> Dict[str, Any]:
     """Get version from 'git describe' in the root of the source tree.
 
     This only gets called if the git-archive 'subst' keywords were *not*
@@ -247,7 +281,14 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
     if sys.platform == "win32":
         GITS = ["git.cmd", "git.exe"]
 
-    _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True)
+    # GIT_DIR can interfere with correct operation of Versioneer.
+    # It may be intended to be passed to the Versioneer-versioned project,
+    # but that should not change where we get our version from.
+    env = os.environ.copy()
+    env.pop("GIT_DIR", None)
+    runner = functools.partial(runner, env=env)
+
+    _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=not verbose)
     if rc != 0:
         if verbose:
             print("Directory %s not under git control" % root)
@@ -264,7 +305,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
             "--always",
             "--long",
             "--match",
-            "%s*" % tag_prefix,
+            f"{tag_prefix}[[:digit:]]*",
         ],
         cwd=root,
     )
@@ -277,7 +318,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
         raise NotThisMethod("'git rev-parse' failed")
     full_out = full_out.strip()
 
-    pieces = {}
+    pieces: Dict[str, Any] = {}
     pieces["long"] = full_out
     pieces["short"] = full_out[:7]  # maybe improved later
     pieces["error"] = None
@@ -356,8 +397,8 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
     else:
         # HEX: no tags
         pieces["closest-tag"] = None
-        count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root)
-        pieces["distance"] = int(count_out)  # total number of commits
+        out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root)
+        pieces["distance"] = len(out.split())  # total number of commits
 
     # commit date: see ISO-8601 comment in git_versions_from_keywords()
     date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip()
@@ -369,14 +410,14 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
     return pieces
 
 
-def plus_or_dot(pieces):
+def plus_or_dot(pieces: Dict[str, Any]) -> str:
     """Return a + if we don't already have one, else return a ."""
     if "+" in pieces.get("closest-tag", ""):
         return "."
     return "+"
 
 
-def render_pep440(pieces):
+def render_pep440(pieces: Dict[str, Any]) -> str:
     """Build up version string, with post-release "local version identifier".
 
     Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
@@ -400,7 +441,7 @@ def render_pep440(pieces):
     return rendered
 
 
-def render_pep440_branch(pieces):
+def render_pep440_branch(pieces: Dict[str, Any]) -> str:
     """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] .
 
     The ".dev0" means not master branch. Note that .dev0 sorts backwards
@@ -429,23 +470,41 @@ def render_pep440_branch(pieces):
     return rendered
 
 
-def render_pep440_pre(pieces):
-    """TAG[.post0.devDISTANCE] -- No -dirty.
+def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]:
+    """Split pep440 version string at the post-release segment.
+
+    Returns the release segments before the post-release and the
+    post-release version number (or -1 if no post-release segment is present).
+    """
+    vc = str.split(ver, ".post")
+    return vc[0], int(vc[1] or 0) if len(vc) == 2 else None
+
+
+def render_pep440_pre(pieces: Dict[str, Any]) -> str:
+    """TAG[.postN.devDISTANCE] -- No -dirty.
 
     Exceptions:
     1: no tags. 0.post0.devDISTANCE
     """
     if pieces["closest-tag"]:
-        rendered = pieces["closest-tag"]
         if pieces["distance"]:
-            rendered += ".post0.dev%d" % pieces["distance"]
+            # update the post release segment
+            tag_version, post_version = pep440_split_post(pieces["closest-tag"])
+            rendered = tag_version
+            if post_version is not None:
+                rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"])
+            else:
+                rendered += ".post0.dev%d" % (pieces["distance"])
+        else:
+            # no commits, use the tag as the version
+            rendered = pieces["closest-tag"]
     else:
         # exception #1
         rendered = "0.post0.dev%d" % pieces["distance"]
     return rendered
 
 
-def render_pep440_post(pieces):
+def render_pep440_post(pieces: Dict[str, Any]) -> str:
     """TAG[.postDISTANCE[.dev0]+gHEX] .
 
     The ".dev0" means dirty. Note that .dev0 sorts backwards
@@ -472,7 +531,7 @@ def render_pep440_post(pieces):
     return rendered
 
 
-def render_pep440_post_branch(pieces):
+def render_pep440_post_branch(pieces: Dict[str, Any]) -> str:
     """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] .
 
     The ".dev0" means not master branch.
@@ -501,7 +560,7 @@ def render_pep440_post_branch(pieces):
     return rendered
 
 
-def render_pep440_old(pieces):
+def render_pep440_old(pieces: Dict[str, Any]) -> str:
     """TAG[.postDISTANCE[.dev0]] .
 
     The ".dev0" means dirty.
@@ -523,7 +582,7 @@ def render_pep440_old(pieces):
     return rendered
 
 
-def render_git_describe(pieces):
+def render_git_describe(pieces: Dict[str, Any]) -> str:
     """TAG[-DISTANCE-gHEX][-dirty].
 
     Like 'git describe --tags --dirty --always'.
@@ -543,7 +602,7 @@ def render_git_describe(pieces):
     return rendered
 
 
-def render_git_describe_long(pieces):
+def render_git_describe_long(pieces: Dict[str, Any]) -> str:
     """TAG-DISTANCE-gHEX[-dirty].
 
     Like 'git describe --tags --dirty --always -long'.
@@ -563,7 +622,7 @@ def render_git_describe_long(pieces):
     return rendered
 
 
-def render(pieces, style):
+def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]:
     """Render the given version pieces into the requested style."""
     if pieces["error"]:
         return {
@@ -605,7 +664,7 @@ def render(pieces, style):
     }
 
 
-def get_versions():
+def get_versions() -> Dict[str, Any]:
     """Get version information or return default if unable to do so."""
     # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
     # __file__, we can work backwards from there to the root. Some

prefect/blocks/abstract.py

@@ -1,7 +1,19 @@
 from abc import ABC, abstractmethod
+from contextlib import contextmanager
 from logging import Logger
 from pathlib import Path
-from typing import Any, BinaryIO, Dict, Generic, List, Optional, Tuple, TypeVar, Union
+from typing import (
+    Any,
+    BinaryIO,
+    Dict,
+    Generator,
+    Generic,
+    List,
+    Optional,
+    Tuple,
+    TypeVar,
+    Union,
+)
 
 from typing_extensions import Self
 
@@ -48,6 +60,13 @@ class CredentialsBlock(Block, ABC):
         """
 
 
+class NotificationError(Exception):
+    """Raised if a notification block fails to send a notification."""
+
+    def __init__(self, log: str) -> None:
+        self.log = log
+
+
 class NotificationBlock(Block, ABC):
     """
     Block that represents a resource in an external system that is able to send notifications.
@@ -82,6 +101,20 @@ class NotificationBlock(Block, ABC):
             subject: The subject of the notification.
         """
 
+    _raise_on_failure: bool = False
+
+    @contextmanager
+    def raise_on_failure(self) -> Generator[None, None, None]:
+        """
+        Context manager that, while active, causes the block to raise errors if it
+        encounters a failure sending notifications.
+        """
+        self._raise_on_failure = True
+        try:
+            yield
+        finally:
+            self._raise_on_failure = False
+
 
 class JobRun(ABC, Generic[T]):  # not a block
     """

prefect/blocks/notifications.py

@@ -1,7 +1,9 @@
+import logging
 from abc import ABC
 from typing import Dict, List, Optional
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
+from prefect.logging import LogEavesdropper
 
 if HAS_PYDANTIC_V2:
     from pydantic.v1 import AnyHttpUrl, Field, SecretStr
@@ -10,7 +12,7 @@ else:
 
 from typing_extensions import Literal
 
-from prefect.blocks.abstract import NotificationBlock
+from prefect.blocks.abstract import NotificationBlock, NotificationError
 from prefect.blocks.fields import SecretDict
 from prefect.events.instrument import instrument_instance_method_call
 from prefect.utilities.asyncutils import sync_compatible
@@ -61,10 +63,17 @@ class AbstractAppriseNotificationBlock(NotificationBlock, ABC):
 
     @sync_compatible
     @instrument_instance_method_call()
-    async def notify(self, body: str, subject: Optional[str] = None):
-        await self._apprise_client.async_notify(
-            body=body, title=subject, notify_type=self.notify_type
-        )
+    async def notify(
+        self,
+        body: str,
+        subject: Optional[str] = None,
+    ):
+        with LogEavesdropper("apprise", level=logging.DEBUG) as eavesdropper:
+            result = await self._apprise_client.async_notify(
+                body=body, title=subject, notify_type=self.notify_type
+            )
+        if not result and self._raise_on_failure:
+            raise NotificationError(log=eavesdropper.text())
 
 
 class AppriseNotificationBlock(AbstractAppriseNotificationBlock, ABC):

prefect/client/base.py

@@ -193,11 +193,18 @@ class PrefectHttpxClient(httpx.AsyncClient):
     [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, **kwargs):
+    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)
 
@@ -345,10 +352,8 @@ class PrefectHttpxClient(httpx.AsyncClient):
         # Convert to a Prefect response to add nicer errors messages
         response = PrefectResponse.from_httpx_response(response)
 
-        # Always raise bad responses
-        # NOTE: We may want to remove this and handle responses per route in the
-        #       `PrefectClient`
-        response.raise_for_status()
+        if self.raise_on_all_errors:
+            response.raise_for_status()
 
         return response