prefect-client 2.20.4__py3-none-any.whl → 3.0.0__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/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,
@@ -137,11 +129,11 @@ class MicrosoftTeamsWebhook(AppriseNotificationBlock):
     _documentation_url = "https://docs.prefect.io/api-ref/prefect/blocks/notifications/#prefect.blocks.notifications.MicrosoftTeamsWebhook"
 
     url: SecretStr = Field(
-        ...,
+        default=...,
         title="Webhook URL",
         description="The Microsoft Power Automate (Workflows) URL used to send notifications to Teams.",
         examples=[
-            "https://prod-NO.LOCATION.logic.azure.com:443/workflows/WFID/triggers/manual/paths/invoke?sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=SIGNATURE"
+            "https://prod-NO.LOCATION.logic.azure.com:443/workflows/WFID/triggers/manual/paths/invoke?api-version=2016-06-01&sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=SIGNATURE"
         ],
     )
 
@@ -164,12 +156,7 @@ class MicrosoftTeamsWebhook(AppriseNotificationBlock):
         ):
             raise ValueError("Invalid Microsoft Teams Workflow URL provided.")
 
-        parsed_url.update(
-            {
-                "include_image": self.include_image,
-                "wrap": self.wrap,
-            }
-        )
+        parsed_url |= {"include_image": self.include_image, "wrap": self.wrap}
 
         self._start_apprise_client(SecretStr(NotifyWorkflows(**parsed_url).url()))
 
@@ -263,7 +250,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(
@@ -331,8 +323,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,
@@ -406,7 +402,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"
@@ -429,7 +425,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:
@@ -517,7 +518,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(
@@ -610,7 +616,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(
@@ -745,7 +756,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
 
@@ -801,7 +811,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,35 @@
-from typing import Any
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
+import json
+from typing import Annotated, Any, Generic, TypeVar, Union
+
+from pydantic import (
+    Field,
+    JsonValue,
+    SecretStr,
+    StrictStr,
+    field_validator,
+)
+from pydantic import Secret as PydanticSecret
+from pydantic_extra_types.pendulum_dt import DateTime as PydanticDateTime
+
+from prefect._internal.compatibility.deprecated import deprecated_class
+from prefect.blocks.core import Block
 
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, SecretStr
-else:
-    from pydantic import Field, SecretStr
+_SecretValueType = Union[
+    Annotated[StrictStr, Field(title="string")],
+    Annotated[JsonValue, Field(title="JSON")],
+]
 
-from prefect._internal.schemas.fields import DateTimeTZ
-from prefect.blocks.core import Block
+T = TypeVar("T", bound=_SecretValueType)
 
 
+@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 +49,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 +76,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,24 +101,26 @@ 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: PydanticDateTime = Field(
         default=...,
         description="An ISO 8601-compatible datetime value.",
     )
 
 
-class Secret(Block):
+class Secret(Block, Generic[T]):
     """
     A block that represents a secret value. The value stored in this block will be obfuscated when
-    this block is logged or shown in the UI.
+    this block is viewed or edited in the UI.
 
     Attributes:
-        value: A string value that should be kept secret.
+        value: A value that should be kept secret.
 
     Example:
         ```python
         from prefect.blocks.system import Secret
 
+        Secret(value="sk-1234567890").save("BLOCK_NAME", overwrite=True)
+
         secret_block = Secret.load("BLOCK_NAME")
 
         # Access the stored secret
@@ -103,9 +131,28 @@ class Secret(Block):
     _logo_url = "https://cdn.sanity.io/images/3ugk85nk/production/c6f20e556dd16effda9df16551feecfb5822092b-48x48.png"
     _documentation_url = "https://docs.prefect.io/api-ref/prefect/blocks/system/#prefect.blocks.system.Secret"
 
-    value: SecretStr = Field(
-        default=..., description="A string value that should be kept secret."
+    value: Union[SecretStr, PydanticSecret[T]] = Field(
+        default=...,
+        description="A value that should be kept secret.",
+        examples=["sk-1234567890", {"username": "johndoe", "password": "s3cr3t"}],
+        json_schema_extra={
+            "writeOnly": True,
+            "format": "password",
+        },
     )
 
-    def get(self):
-        return self.value.get_secret_value()
+    @field_validator("value", mode="before")
+    def validate_value(
+        cls, value: Union[T, SecretStr, PydanticSecret[T]]
+    ) -> Union[SecretStr, PydanticSecret[T]]:
+        if isinstance(value, (PydanticSecret, SecretStr)):
+            return value
+        else:
+            return PydanticSecret[type(value)](value)
+
+    def get(self) -> T:
+        try:
+            value = self.value.get_secret_value()
+            return json.loads(value)
+        except (TypeError, json.JSONDecodeError):
+            return 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