prefect-client 2.19.4__py3-none-any.whl → 3.0.0rc2__py3-none-any.whl

prefect/blocks/fields.py

@@ -1,58 +1,3 @@
-from typing import TYPE_CHECKING, Any, Dict
+from prefect.types import SecretDict
 
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import SecretField
-    from pydantic.v1.utils import update_not_none
-    from pydantic.v1.validators import dict_validator
-
-    if TYPE_CHECKING:
-        from pydantic.v1.typing import CallableGenerator
-
-else:
-    from pydantic import SecretField
-    from pydantic.utils import update_not_none
-    from pydantic.validators import dict_validator
-
-    if TYPE_CHECKING:
-        from pydantic.typing import CallableGenerator
-
-
-class SecretDict(SecretField):
-    @classmethod
-    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
-        update_not_none(
-            field_schema,
-            type="object",
-        )
-
-    @classmethod
-    def __get_validators__(cls) -> "CallableGenerator":
-        yield cls.validate
-
-    @classmethod
-    def validate(cls, value: Any) -> "SecretDict":
-        if isinstance(value, cls):
-            return value
-        value = dict_validator(value)
-        return cls(value)
-
-    def __init__(self, value: Dict[str, Any]):
-        self._secret_value = value
-
-    def __str__(self) -> str:
-        return (
-            str({key: "**********" for key in self.get_secret_value().keys()})
-            if self.get_secret_value()
-            else ""
-        )
-
-    def __repr__(self) -> str:
-        return f"SecretDict('{self}')"
-
-    def get_secret_value(self) -> Dict[str, Any]:
-        return self._secret_value
-
-    def dict(self) -> Dict:
-        return {key: "**********" for key in self.get_secret_value().keys()}
+__all__ = ["SecretDict"]

prefect/blocks/kubernetes.py

@@ -1,19 +1,12 @@
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, Type
+from typing import TYPE_CHECKING, Dict, Optional, Type
 
 import yaml
+from pydantic import Field, field_validator
+from typing_extensions import Self
 
 from prefect._internal.compatibility.deprecated import deprecated_class
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect._internal.schemas.validators import validate_yaml
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, validator
-else:
-    from pydantic import Field, validator
-
-from typing_extensions import Self
-
 from prefect.blocks.core import Block
 from prefect.utilities.collections import listrepr
 from prefect.utilities.importtools import lazy_import
@@ -59,12 +52,15 @@ class KubernetesClusterConfig(Block):
         default=..., description="The name of the kubectl context to use."
     )
 
-    @validator("config", pre=True)
+    @field_validator("config", mode="before")
+    @classmethod
     def parse_yaml_config(cls, value):
         return validate_yaml(value)
 
     @classmethod
-    def from_file(cls: Type[Self], path: Path = None, context_name: str = None) -> Self:
+    def from_file(
+        cls: Type[Self], path: Optional[Path] = None, context_name: Optional[str] = None
+    ) -> Self:
         """
         Create a cluster config from the a Kubernetes config file.
 

prefect/blocks/notifications.py

@@ -2,19 +2,12 @@ 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
-else:
-    from pydantic import AnyHttpUrl, Field, SecretStr
-
+from pydantic import AnyHttpUrl, Field, SecretStr
 from typing_extensions import Literal
 
 from prefect.blocks.abstract import NotificationBlock, NotificationError
-from prefect.blocks.fields import SecretDict
-from prefect.events.instrument import instrument_instance_method_call
+from prefect.logging import LogEavesdropper
+from prefect.types import SecretDict
 from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.templating import apply_values, find_placeholders
 
@@ -62,7 +55,6 @@ class AbstractAppriseNotificationBlock(NotificationBlock, ABC):
         self._start_apprise_client(self.url)
 
     @sync_compatible
-    @instrument_instance_method_call
     async def notify(
         self,
         body: str,
@@ -235,7 +227,12 @@ class PagerDutyWebHook(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
-        from apprise.plugins.pagerduty import NotifyPagerDuty
+        try:
+            # Try importing for apprise>=1.18.0
+            from apprise.plugins.pagerduty import NotifyPagerDuty
+        except ImportError:
+            # Fallback for versions apprise<1.18.0
+            from apprise.plugins.NotifyPagerDuty import NotifyPagerDuty
 
         url = SecretStr(
             NotifyPagerDuty(
@@ -303,8 +300,12 @@ class TwilioSMS(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
-        from apprise.plugins.twilio import NotifyTwilio
-
+        try:
+            # Try importing for apprise>=1.18.0
+            from apprise.plugins.twilio import NotifyTwilio
+        except ImportError:
+            # Fallback for versions apprise<1.18.0
+            from apprise.plugins.NotifyTwilio import NotifyTwilio
         url = SecretStr(
             NotifyTwilio(
                 account_sid=self.account_sid,
@@ -378,7 +379,7 @@ class OpsgenieWebhook(AbstractAppriseNotificationBlock):
         examples=['["tag1", "tag2"]'],
     )
 
-    priority: Optional[str] = Field(
+    priority: Optional[int] = Field(
         default=3,
         description=(
             "The priority to associate with the message. It is on a scale between 1"
@@ -401,7 +402,12 @@ class OpsgenieWebhook(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
-        from apprise.plugins.opsgenie import NotifyOpsgenie
+        try:
+            # Try importing for apprise>=1.18.0
+            from apprise.plugins.opsgenie import NotifyOpsgenie
+        except ImportError:
+            # Fallback for versions apprise<1.18.0
+            from apprise.plugins.NotifyOpsgenie import NotifyOpsgenie
 
         targets = []
         if self.target_user:
@@ -489,7 +495,12 @@ class MattermostWebhook(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
-        from apprise.plugins.mattermost import NotifyMattermost
+        try:
+            # Try importing for apprise>=1.18.0
+            from apprise.plugins.mattermost import NotifyMattermost
+        except ImportError:
+            # Fallback for versions apprise<1.18.0
+            from apprise.plugins.NotifyMattermost import NotifyMattermost
 
         url = SecretStr(
             NotifyMattermost(
@@ -582,7 +593,12 @@ class DiscordWebhook(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
-        from apprise.plugins.discord import NotifyDiscord
+        try:
+            # Try importing for apprise>=1.18.0
+            from apprise.plugins.discord import NotifyDiscord
+        except ImportError:
+            # Fallback for versions apprise<1.18.0
+            from apprise.plugins.NotifyDiscord import NotifyDiscord
 
         url = SecretStr(
             NotifyDiscord(
@@ -717,7 +733,6 @@ class CustomWebhookNotificationBlock(NotificationBlock):
                     raise KeyError(f"{name}/{placeholder}")
 
     @sync_compatible
-    @instrument_instance_method_call
     async def notify(self, body: str, subject: Optional[str] = None):
         import httpx
 
@@ -773,7 +788,12 @@ class SendgridEmail(AbstractAppriseNotificationBlock):
     )
 
     def block_initialization(self) -> None:
-        from apprise.plugins.sendgrid import NotifySendGrid
+        try:
+            # Try importing for apprise>=1.18.0
+            from apprise.plugins.sendgrid import NotifySendGrid
+        except ImportError:
+            # Fallback for versions apprise<1.18.0
+            from apprise.plugins.NotifySendGrid import NotifySendGrid
 
         url = SecretStr(
             NotifySendGrid(

prefect/blocks/redis.py

@@ -0,0 +1,168 @@
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import AsyncGenerator, Optional, Union
+
+try:
+    import redis.asyncio as redis
+except ImportError:
+    raise ImportError(
+        "`redis-py` must be installed to use the `RedisStorageContainer` block. "
+        "You can install it with `pip install redis>=5.0.1"
+    )
+
+from pydantic import Field
+from pydantic.types import SecretStr
+from typing_extensions import Self
+
+from prefect.filesystems import WritableFileSystem
+from prefect.utilities.asyncutils import sync_compatible
+
+
+class RedisStorageContainer(WritableFileSystem):
+    """
+    Block used to interact with Redis as a filesystem
+
+    Attributes:
+        host (str): The value to store.
+        port (int): The value to store.
+        db (int): The value to store.
+        username (str): The value to store.
+        password (str): The value to store.
+        connection_string (str): The value to store.
+
+    Example:
+        Create a new block from hostname, username and password:
+        ```python
+        from prefect.blocks.redis import RedisStorageContainer
+
+        block = RedisStorageContainer.from_host(
+            host="myredishost.com", username="redis", password="SuperSecret")
+        block.save("BLOCK_NAME")
+        ```
+
+        Create a new block from a connection string
+        ```python
+        from prefect.blocks.redis import RedisStorageContainer
+        block = RedisStorageContainer.from_url(""redis://redis:SuperSecret@myredishost.com:6379")
+        block.save("BLOCK_NAME")
+        ```
+    """
+
+    _logo_url = "https://stprododpcmscdnendpoint.azureedge.net/assets/icons/redis.png"
+
+    host: Optional[str] = Field(default=None, description="Redis hostname")
+    port: int = Field(default=6379, description="Redis port")
+    db: int = Field(default=0, description="Redis DB index")
+    username: Optional[SecretStr] = Field(default=None, description="Redis username")
+    password: Optional[SecretStr] = Field(default=None, description="Redis password")
+    connection_string: Optional[SecretStr] = Field(
+        default=None, description="Redis connection string"
+    )
+
+    def block_initialization(self) -> None:
+        if self.connection_string:
+            return
+        if not self.host:
+            raise ValueError("Initialization error: 'host' is required but missing.")
+        if self.username and not self.password:
+            raise ValueError(
+                "Initialization error: 'username' is provided, but 'password' is missing. Both are required."
+            )
+
+    @sync_compatible
+    async def read_path(self, path: Union[Path, str]):
+        """Read the redis content at `path`
+
+        Args:
+            path: Redis key to read from
+
+        Returns:
+            Contents at key as bytes
+        """
+        async with self._client() as client:
+            return await client.get(str(path))
+
+    @sync_compatible
+    async def write_path(self, path: Union[Path, str], content: bytes):
+        """Write `content` to the redis at `path`
+
+        Args:
+            path: Redis key to write to
+            content: Binary object to write
+        """
+
+        async with self._client() as client:
+            return await client.set(str(path), content)
+
+    @asynccontextmanager
+    async def _client(self) -> AsyncGenerator[redis.Redis, None]:
+        if self.connection_string:
+            client = redis.Redis.from_url(self.connection_string.get_secret_value())
+        else:
+            assert self.host
+            client = redis.Redis(
+                host=self.host,
+                port=self.port,
+                username=self.username.get_secret_value() if self.username else None,
+                password=self.password.get_secret_value() if self.password else None,
+                db=self.db,
+            )
+
+        try:
+            yield client
+        finally:
+            await client.aclose()
+
+    @classmethod
+    def from_host(
+        cls,
+        host: str,
+        port: int = 6379,
+        db: int = 0,
+        username: Union[None, str, SecretStr] = None,
+        password: Union[None, str, SecretStr] = None,
+    ) -> Self:
+        """Create block from hostname, username and password
+
+        Args:
+            host: Redis hostname
+            username: Redis username
+            password: Redis password
+            port: Redis port
+
+        Returns:
+            `RedisStorageContainer` instance
+        """
+
+        username = SecretStr(username) if isinstance(username, str) else username
+        password = SecretStr(password) if isinstance(password, str) else password
+
+        return cls(host=host, port=port, db=db, username=username, password=password)
+
+    @classmethod
+    def from_connection_string(cls, connection_string: Union[str, SecretStr]) -> Self:
+        """Create block from a Redis connection string
+
+        Supports the following URL schemes:
+        - `redis://` creates a TCP socket connection
+        - `rediss://` creates a SSL wrapped TCP socket connection
+        - `unix://` creates a Unix Domain Socket connection
+
+        See [Redis docs](https://redis.readthedocs.io/en/stable/examples
+        /connection_examples.html#Connecting-to-Redis-instances-by-specifying-a-URL
+        -scheme.) for more info.
+
+        Args:
+            connection_string: Redis connection string
+
+        Returns:
+            `RedisStorageContainer` instance
+        """
+
+        connection_string = (
+            SecretStr(connection_string)
+            if isinstance(connection_string, str)
+            else connection_string
+        )
+
+        return cls(connection_string=connection_string)

prefect/blocks/system.py

@@ -1,19 +1,20 @@
 from typing import Any
 
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
+from pydantic import Field, SecretStr
+from pydantic_extra_types.pendulum_dt import DateTime
 
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, SecretStr
-else:
-    from pydantic import Field, SecretStr
-
-from prefect._internal.schemas.fields import DateTimeTZ
+from prefect._internal.compatibility.deprecated import deprecated_class
 from prefect.blocks.core import Block
 
 
+@deprecated_class(
+    start_date="Jun 2024",
+    end_date="Jun 2025",
+    help="Use Variables to store json data instead.",
+)
 class JSON(Block):
     """
-    A block that represents JSON
+    A block that represents JSON. Deprecated, please use Variables to store JSON data instead.
 
     Attributes:
         value: A JSON-compatible value.
@@ -33,9 +34,14 @@ class JSON(Block):
     value: Any = Field(default=..., description="A JSON-compatible value.")
 
 
+@deprecated_class(
+    start_date="Jun 2024",
+    end_date="Jun 2025",
+    help="Use Variables to store string data instead.",
+)
 class String(Block):
     """
-    A block that represents a string
+    A block that represents a string. Deprecated, please use Variables to store string data instead.
 
     Attributes:
         value: A string value.
@@ -55,9 +61,14 @@ class String(Block):
     value: str = Field(default=..., description="A string value.")
 
 
+@deprecated_class(
+    start_date="Jun 2024",
+    end_date="Jun 2025",
+    help="Use Variables to store datetime data instead.",
+)
 class DateTime(Block):
     """
-    A block that represents a datetime
+    A block that represents a datetime. Deprecated, please use Variables to store datetime data instead.
 
     Attributes:
         value: An ISO 8601-compatible datetime value.
@@ -75,7 +86,7 @@ class DateTime(Block):
     _logo_url = "https://cdn.sanity.io/images/3ugk85nk/production/8b3da9a6621e92108b8e6a75b82e15374e170ff7-48x48.png"
     _documentation_url = "https://docs.prefect.io/api-ref/prefect/blocks/system/#prefect.blocks.system.DateTime"
 
-    value: DateTimeTZ = Field(
+    value: DateTime = Field(
         default=...,
         description="An ISO 8601-compatible datetime value.",
     )

prefect/blocks/webhook.py

@@ -1,18 +1,11 @@
 from typing import Optional
 
 from httpx import AsyncClient, AsyncHTTPTransport, Response
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, SecretStr
-else:
-    from pydantic import Field, SecretStr
-
+from pydantic import Field, SecretStr
 from typing_extensions import Literal
 
 from prefect.blocks.core import Block
-from prefect.blocks.fields import SecretDict
+from prefect.types import SecretDict
 
 # Use a global HTTP transport to maintain a process-wide connection pool for
 # interservice requests

prefect/client/base.py

@@ -25,8 +25,8 @@ import anyio
 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 starlette import status
+from starlette.testclient import TestClient
 from typing_extensions import Self
 
 import prefect
@@ -390,7 +390,7 @@ class PrefectHttpxAsyncClient(httpx.AsyncClient):
 
                 raise
 
-            token: CsrfToken = CsrfToken.parse_obj(token_response.json())
+            token: CsrfToken = CsrfToken.model_validate(token_response.json())
             self.csrf_token = token.token
             self.csrf_token_expiration = token.expiration
 
@@ -604,7 +604,7 @@ class PrefectHttpxSyncClient(httpx.Client):
 
                 raise
 
-            token: CsrfToken = CsrfToken.parse_obj(token_response.json())
+            token: CsrfToken = CsrfToken.model_validate(token_response.json())
             self.csrf_token = token.token
             self.csrf_token_expiration = token.expiration
 

prefect/client/cloud.py

@@ -3,21 +3,14 @@ from typing import Any, Dict, List, Optional
 
 import anyio
 import httpx
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
-else:
-    import pydantic
-
-from prefect._vendor.starlette import status
+import pydantic
+from starlette import status
 
 import prefect.context
 import prefect.settings
 from prefect.client.base import PrefectHttpxAsyncClient
 from prefect.client.schemas import Workspace
-from prefect.exceptions import PrefectException
+from prefect.exceptions import ObjectNotFound, PrefectException
 from prefect.settings import (
     PREFECT_API_KEY,
     PREFECT_CLOUD_API_URL,
@@ -87,8 +80,8 @@ class CloudClient:
             await self.read_workspaces()
 
     async def read_workspaces(self) -> List[Workspace]:
-        workspaces = pydantic.parse_obj_as(
-            List[Workspace], await self.get("/me/workspaces")
+        workspaces = pydantic.TypeAdapter(List[Workspace]).validate_python(
+            await self.get("/me/workspaces")
         )
         return workspaces
 
@@ -128,8 +121,10 @@ class CloudClient:
                 status.HTTP_403_FORBIDDEN,
             ):
                 raise CloudUnauthorizedError
+            elif exc.response.status_code == status.HTTP_404_NOT_FOUND:
+                raise ObjectNotFound(http_exc=exc) from exc
             else:
-                raise exc
+                raise
 
         if res.status_code == status.HTTP_204_NO_CONTENT:
             return