prefect-client 2.20.2__py3-none-any.whl → 3.0.0__py3-none-any.whl

prefect/_vendor/starlette/types.py

@@ -1,30 +0,0 @@
-import typing
-
-if typing.TYPE_CHECKING:
-    from prefect._vendor.starlette.requests import Request
-    from prefect._vendor.starlette.responses import Response
-    from prefect._vendor.starlette.websockets import WebSocket
-
-AppType = typing.TypeVar("AppType")
-
-Scope = typing.MutableMapping[str, typing.Any]
-Message = typing.MutableMapping[str, typing.Any]
-
-Receive = typing.Callable[[], typing.Awaitable[Message]]
-Send = typing.Callable[[Message], typing.Awaitable[None]]
-
-ASGIApp = typing.Callable[[Scope, Receive, Send], typing.Awaitable[None]]
-
-StatelessLifespan = typing.Callable[[AppType], typing.AsyncContextManager[None]]
-StatefulLifespan = typing.Callable[
-    [AppType], typing.AsyncContextManager[typing.Mapping[str, typing.Any]]
-]
-Lifespan = typing.Union[StatelessLifespan[AppType], StatefulLifespan[AppType]]
-
-HTTPExceptionHandler = typing.Callable[
-    ["Request", Exception], typing.Union["Response", typing.Awaitable["Response"]]
-]
-WebSocketExceptionHandler = typing.Callable[
-    ["WebSocket", Exception], typing.Awaitable[None]
-]
-ExceptionHandler = typing.Union[HTTPExceptionHandler, WebSocketExceptionHandler]

prefect/_vendor/starlette/websockets.py

@@ -1,193 +0,0 @@
-import enum
-import json
-import typing
-
-from prefect._vendor.starlette.requests import HTTPConnection
-from prefect._vendor.starlette.types import Message, Receive, Scope, Send
-
-
-class WebSocketState(enum.Enum):
-    CONNECTING = 0
-    CONNECTED = 1
-    DISCONNECTED = 2
-
-
-class WebSocketDisconnect(Exception):
-    def __init__(self, code: int = 1000, reason: typing.Optional[str] = None) -> None:
-        self.code = code
-        self.reason = reason or ""
-
-
-class WebSocket(HTTPConnection):
-    def __init__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        super().__init__(scope)
-        assert scope["type"] == "websocket"
-        self._receive = receive
-        self._send = send
-        self.client_state = WebSocketState.CONNECTING
-        self.application_state = WebSocketState.CONNECTING
-
-    async def receive(self) -> Message:
-        """
-        Receive ASGI websocket messages, ensuring valid state transitions.
-        """
-        if self.client_state == WebSocketState.CONNECTING:
-            message = await self._receive()
-            message_type = message["type"]
-            if message_type != "websocket.connect":
-                raise RuntimeError(
-                    'Expected ASGI message "websocket.connect", '
-                    f"but got {message_type!r}"
-                )
-            self.client_state = WebSocketState.CONNECTED
-            return message
-        elif self.client_state == WebSocketState.CONNECTED:
-            message = await self._receive()
-            message_type = message["type"]
-            if message_type not in {"websocket.receive", "websocket.disconnect"}:
-                raise RuntimeError(
-                    'Expected ASGI message "websocket.receive" or '
-                    f'"websocket.disconnect", but got {message_type!r}'
-                )
-            if message_type == "websocket.disconnect":
-                self.client_state = WebSocketState.DISCONNECTED
-            return message
-        else:
-            raise RuntimeError(
-                'Cannot call "receive" once a disconnect message has been received.'
-            )
-
-    async def send(self, message: Message) -> None:
-        """
-        Send ASGI websocket messages, ensuring valid state transitions.
-        """
-        if self.application_state == WebSocketState.CONNECTING:
-            message_type = message["type"]
-            if message_type not in {"websocket.accept", "websocket.close"}:
-                raise RuntimeError(
-                    'Expected ASGI message "websocket.accept" or '
-                    f'"websocket.close", but got {message_type!r}'
-                )
-            if message_type == "websocket.close":
-                self.application_state = WebSocketState.DISCONNECTED
-            else:
-                self.application_state = WebSocketState.CONNECTED
-            await self._send(message)
-        elif self.application_state == WebSocketState.CONNECTED:
-            message_type = message["type"]
-            if message_type not in {"websocket.send", "websocket.close"}:
-                raise RuntimeError(
-                    'Expected ASGI message "websocket.send" or "websocket.close", '
-                    f"but got {message_type!r}"
-                )
-            if message_type == "websocket.close":
-                self.application_state = WebSocketState.DISCONNECTED
-            await self._send(message)
-        else:
-            raise RuntimeError('Cannot call "send" once a close message has been sent.')
-
-    async def accept(
-        self,
-        subprotocol: typing.Optional[str] = None,
-        headers: typing.Optional[typing.Iterable[typing.Tuple[bytes, bytes]]] = None,
-    ) -> None:
-        headers = headers or []
-
-        if self.client_state == WebSocketState.CONNECTING:
-            # If we haven't yet seen the 'connect' message, then wait for it first.
-            await self.receive()
-        await self.send(
-            {"type": "websocket.accept", "subprotocol": subprotocol, "headers": headers}
-        )
-
-    def _raise_on_disconnect(self, message: Message) -> None:
-        if message["type"] == "websocket.disconnect":
-            raise WebSocketDisconnect(message["code"], message.get("reason"))
-
-    async def receive_text(self) -> str:
-        if self.application_state != WebSocketState.CONNECTED:
-            raise RuntimeError(
-                'WebSocket is not connected. Need to call "accept" first.'
-            )
-        message = await self.receive()
-        self._raise_on_disconnect(message)
-        return typing.cast(str, message["text"])
-
-    async def receive_bytes(self) -> bytes:
-        if self.application_state != WebSocketState.CONNECTED:
-            raise RuntimeError(
-                'WebSocket is not connected. Need to call "accept" first.'
-            )
-        message = await self.receive()
-        self._raise_on_disconnect(message)
-        return typing.cast(bytes, message["bytes"])
-
-    async def receive_json(self, mode: str = "text") -> typing.Any:
-        if mode not in {"text", "binary"}:
-            raise RuntimeError('The "mode" argument should be "text" or "binary".')
-        if self.application_state != WebSocketState.CONNECTED:
-            raise RuntimeError(
-                'WebSocket is not connected. Need to call "accept" first.'
-            )
-        message = await self.receive()
-        self._raise_on_disconnect(message)
-
-        if mode == "text":
-            text = message["text"]
-        else:
-            text = message["bytes"].decode("utf-8")
-        return json.loads(text)
-
-    async def iter_text(self) -> typing.AsyncIterator[str]:
-        try:
-            while True:
-                yield await self.receive_text()
-        except WebSocketDisconnect:
-            pass
-
-    async def iter_bytes(self) -> typing.AsyncIterator[bytes]:
-        try:
-            while True:
-                yield await self.receive_bytes()
-        except WebSocketDisconnect:
-            pass
-
-    async def iter_json(self) -> typing.AsyncIterator[typing.Any]:
-        try:
-            while True:
-                yield await self.receive_json()
-        except WebSocketDisconnect:
-            pass
-
-    async def send_text(self, data: str) -> None:
-        await self.send({"type": "websocket.send", "text": data})
-
-    async def send_bytes(self, data: bytes) -> None:
-        await self.send({"type": "websocket.send", "bytes": data})
-
-    async def send_json(self, data: typing.Any, mode: str = "text") -> None:
-        if mode not in {"text", "binary"}:
-            raise RuntimeError('The "mode" argument should be "text" or "binary".')
-        text = json.dumps(data, separators=(",", ":"), ensure_ascii=False)
-        if mode == "text":
-            await self.send({"type": "websocket.send", "text": text})
-        else:
-            await self.send({"type": "websocket.send", "bytes": text.encode("utf-8")})
-
-    async def close(
-        self, code: int = 1000, reason: typing.Optional[str] = None
-    ) -> None:
-        await self.send(
-            {"type": "websocket.close", "code": code, "reason": reason or ""}
-        )
-
-
-class WebSocketClose:
-    def __init__(self, code: int = 1000, reason: typing.Optional[str] = None) -> None:
-        self.code = code
-        self.reason = reason or ""
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        await send(
-            {"type": "websocket.close", "code": self.code, "reason": self.reason}
-        )

prefect/blocks/kubernetes.py

@@ -1,119 +0,0 @@
-from pathlib import Path
-from typing import TYPE_CHECKING, Dict, Type
-
-import yaml
-
-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
-
-if TYPE_CHECKING:
-    import kubernetes
-    from kubernetes.client.api_client import ApiClient
-else:
-    kubernetes = lazy_import("kubernetes")
-
-
-@deprecated_class(
-    start_date="Mar 2024",
-    help="Use the KubernetesClusterConfig block from prefect-kubernetes instead.",
-)
-class KubernetesClusterConfig(Block):
-    """
-    Stores configuration for interaction with Kubernetes clusters.
-
-    See `from_file` for creation.
-
-    Attributes:
-        config: The entire loaded YAML contents of a kubectl config file
-        context_name: The name of the kubectl context to use
-
-    Example:
-        Load a saved Kubernetes cluster config:
-        ```python
-        from prefect.blocks.kubernetes import KubernetesClusterConfig
-
-        cluster_config_block = KubernetesClusterConfig.load("BLOCK_NAME")
-        ```
-    """
-
-    _block_type_name = "Kubernetes Cluster Config"
-    _logo_url = "https://cdn.sanity.io/images/3ugk85nk/production/2d0b896006ad463b49c28aaac14f31e00e32cfab-250x250.png"
-    _documentation_url = "https://docs.prefect.io/api-ref/prefect/blocks/kubernetes/#prefect.blocks.kubernetes.KubernetesClusterConfig"
-
-    config: Dict = Field(
-        default=..., description="The entire contents of a kubectl config file."
-    )
-    context_name: str = Field(
-        default=..., description="The name of the kubectl context to use."
-    )
-
-    @validator("config", pre=True)
-    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:
-        """
-        Create a cluster config from the a Kubernetes config file.
-
-        By default, the current context in the default Kubernetes config file will be
-        used.
-
-        An alternative file or context may be specified.
-
-        The entire config file will be loaded and stored.
-        """
-        kube_config = kubernetes.config.kube_config
-
-        path = Path(path or kube_config.KUBE_CONFIG_DEFAULT_LOCATION)
-        path = path.expanduser().resolve()
-
-        # Determine the context
-        existing_contexts, current_context = kube_config.list_kube_config_contexts(
-            config_file=str(path)
-        )
-        context_names = {ctx["name"] for ctx in existing_contexts}
-        if context_name:
-            if context_name not in context_names:
-                raise ValueError(
-                    f"Context {context_name!r} not found. "
-                    f"Specify one of: {listrepr(context_names, sep=', ')}."
-                )
-        else:
-            context_name = current_context["name"]
-
-        # Load the entire config file
-        config_file_contents = path.read_text()
-        config_dict = yaml.safe_load(config_file_contents)
-
-        return cls(config=config_dict, context_name=context_name)
-
-    def get_api_client(self) -> "ApiClient":
-        """
-        Returns a Kubernetes API client for this cluster config.
-        """
-        return kubernetes.config.kube_config.new_client_from_config_dict(
-            config_dict=self.config, context=self.context_name
-        )
-
-    def configure_client(self) -> None:
-        """
-        Activates this cluster configuration by loading the configuration into the
-        Kubernetes Python client. After calling this, Kubernetes API clients can use
-        this config's context.
-        """
-        kubernetes.config.kube_config.load_kube_config_from_dict(
-            config_dict=self.config, context=self.context_name
-        )

prefect/deprecated/data_documents.py

@@ -1,350 +0,0 @@
-import base64
-import json
-import uuid
-import warnings
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    Generic,
-    Iterable,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
-
-import cloudpickle
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
-else:
-    import pydantic
-
-from typing_extensions import Protocol
-
-from prefect._internal.compatibility.deprecated import (
-    deprecated_callable,
-    generate_deprecation_message,
-)
-from prefect._internal.schemas.bases import PrefectBaseModel
-
-if TYPE_CHECKING:
-    from prefect.deprecated.packaging.base import PackageManifest
-
-T = TypeVar("T", bound="DataDocument")  # Generic for DataDocument class types
-D = TypeVar("D", bound=Any)  # Generic for DataDocument data types
-
-
-_SERIALIZERS: Dict[str, "Serializer"] = {}
-
-
-class Serializer(Protocol[D]):
-    """
-    Define a serializer that can encode data of type 'D' into bytes
-    """
-
-    @staticmethod
-    def dumps(data: D, **kwargs: Any) -> bytes:
-        raise NotImplementedError
-
-    @staticmethod
-    def loads(blob: bytes) -> D:
-        raise NotImplementedError
-
-
-def register_serializer(
-    encoding: Union[str, Tuple[str, ...]], serializer: Serializer = None
-):
-    """Register dispatch of `func` on arguments of encoding `encoding`"""
-
-    def wrapper(serializer):
-        if isinstance(encoding, tuple):
-            for e in encoding:
-                register_serializer(e, serializer)
-        else:
-            _SERIALIZERS[encoding] = serializer
-        return serializer
-
-    return wrapper(serializer) if serializer is not None else wrapper
-
-
-def lookup_serializer(encoding: str) -> Serializer:
-    """Return the serializer implementation for the given ``encoding``"""
-    try:
-        return _SERIALIZERS[encoding]
-    except KeyError:
-        raise ValueError(f"Unregistered encoding {encoding!r}")
-
-
-class DataDocument(PrefectBaseModel, Generic[D]):
-    """
-    A data document includes an encoding string and a blob of encoded data
-
-    Subclasses can define the expected type for the blob's underlying type using the
-    generic variable `D`.
-
-    For example `DataDocument[str]` indicates that a string should be passed when
-    creating the document and a string will be returned when it is decoded.
-    """
-
-    encoding: str
-    blob: bytes
-
-    # A cache for the decoded data, see `DataDocument.decode`
-    _data: D
-    __slots__ = ["_data"]
-
-    @classmethod
-    @deprecated_callable(
-        start_date="Sep 2022",
-        help="Data documents should not be created. Use result persistence instead.",
-    )
-    def encode(
-        cls: Type["DataDocument"], encoding: str, data: D, **kwargs: Any
-    ) -> "DataDocument[D]":
-        """
-        Create a new data document
-
-        A serializer must be registered for the given `encoding`
-        """
-        # Dispatch encoding
-        blob = lookup_serializer(encoding).dumps(data, **kwargs)
-
-        inst = cls(blob=blob, encoding=encoding)
-        inst._cache_data(data)
-        return inst
-
-    def decode(self) -> D:
-        """
-        Get the data from a data document
-
-        A serializer must be registered for the document's encoding
-        """
-        if self.has_cached_data():
-            return self._data
-
-        # Dispatch decoding
-        data = lookup_serializer(self.encoding).loads(self.blob)
-
-        self._cache_data(data)
-        return data
-
-    def _cache_data(self, data) -> None:
-        # Use object's setattr to avoid a pydantic 'field does not exist' error
-        # See https://github.com/samuelcolvin/pydantic/issues/655
-        object.__setattr__(self, "_data", data)
-
-    def has_cached_data(self):
-        return hasattr(self, "_data")
-
-    def __str__(self) -> str:
-        if self.has_cached_data():
-            return repr(self._data)
-        else:
-            return repr(self)
-
-    def __repr__(self) -> str:
-        return f"{type(self).__name__}(encoding={self.encoding!r})"
-
-
-@register_serializer("json")
-class DocumentJSONSerializer:
-    """
-    Serializes data to JSON.
-
-    Input types must be compatible with the stdlib json library.
-
-    Wraps the `json` library to serialize to UTF-8 bytes instead of string types.
-    """
-
-    @staticmethod
-    @deprecated_callable(
-        start_date="Sep 2022",
-        help=(
-            "Data document serializers should not be used. Use result serializers"
-            " instead."
-        ),
-    )
-    def dumps(data: Any) -> bytes:
-        return json.dumps(data).encode()
-
-    @staticmethod
-    def loads(blob: bytes) -> Any:
-        return json.loads(blob.decode())
-
-
-@register_serializer("text")
-class TextSerializer:
-    @staticmethod
-    @deprecated_callable(
-        start_date="Sep 2022",
-        help=(
-            "Data document serializers should not be used. Use result serializers"
-            " instead."
-        ),
-    )
-    def dumps(data: str) -> bytes:
-        return data.encode()
-
-    @staticmethod
-    def loads(blob: bytes) -> str:
-        return blob.decode()
-
-
-@register_serializer("cloudpickle")
-class DocumentPickleSerializer:
-    """
-    Serializes arbitrary objects using the pickle protocol.
-
-    Wraps `cloudpickle` to encode bytes in base64 for safe transmission.
-    """
-
-    @staticmethod
-    @deprecated_callable(
-        start_date="Sep 2022",
-        help=(
-            "Data document serializers should not be used. Use result serializers"
-            " instead."
-        ),
-    )
-    def dumps(data: Any) -> bytes:
-        data_bytes = cloudpickle.dumps(data)
-
-        return base64.encodebytes(data_bytes)
-
-    @staticmethod
-    def loads(blob: bytes) -> Any:
-        return cloudpickle.loads(base64.decodebytes(blob))
-        # TODO: Consider adding python version data to pickle payloads to raise
-        #       more helpful errors for users.
-        #       A TypeError("expected bytes-like object, not int") will be raised if
-        #       a document is deserialized by Python 3.7 and serialized by 3.8+
-
-
-@register_serializer("package-manifest")
-class PackageManifestSerializer:
-    """
-    Serializes a package manifest.
-    """
-
-    @staticmethod
-    @deprecated_callable(
-        start_date="Sep 2022",
-        help=(
-            "Data document serializers should not be used. Use result serializers"
-            " instead."
-        ),
-    )
-    def dumps(data: "PackageManifest") -> bytes:
-        return data.json().encode()
-
-    @staticmethod
-    def loads(blob: bytes) -> "PackageManifest":
-        from prefect.deprecated.packaging.base import PackageManifest
-
-        return PackageManifest.parse_raw(blob)
-
-
-@register_serializer("result")
-class ResultSerializer:
-    """
-    Serializes a result object
-    """
-
-    @staticmethod
-    @deprecated_callable(
-        start_date="Sep 2022",
-        help=(
-            "Data document serializers should not be used. Use result serializers"
-            " instead."
-        ),
-    )
-    def dumps(data: "_Result") -> bytes:
-        return data.json().encode()
-
-    @staticmethod
-    def loads(blob: bytes) -> "_Result":
-        return _Result.parse_raw(blob)
-
-
-def result_from_state_with_data_document(state, raise_on_failure: bool) -> Any:
-    # Complain about usage
-    warnings.warn(
-        generate_deprecation_message(
-            "Retrieving results from states with data documents", start_date="Sep 2022"
-        ),
-        DeprecationWarning,
-        stacklevel=3,
-    )
-
-    data = None
-
-    if state.data:
-        data = state.data.decode()
-
-    from prefect.states import State
-
-    if (
-        state.is_failed() or state.is_crashed() or state.is_cancelled()
-    ) and raise_on_failure:
-        if isinstance(data, Exception):
-            raise data
-        elif isinstance(data, BaseException):
-            warnings.warn(
-                f"State result is a {type(data).__name__!r} type and is not safe "
-                "to re-raise, it will be returned instead."
-            )
-            return data
-        elif isinstance(data, State):
-            data.result(fetch=False)
-        elif isinstance(data, Iterable) and all([isinstance(o, State) for o in data]):
-            # raise the first failure we find
-            for state in data:
-                state.result(fetch=False)
-
-        # we don't make this an else in case any of the above conditionals doesn't raise
-        raise TypeError(
-            f"Unexpected result for failure state: {data!r} —— "
-            f"{type(data).__name__} cannot be resolved into an exception"
-        )
-
-    return data
-
-
-async def _persist_serialized_result(
-    content: bytes,
-    filesystem,
-) -> DataDocument:
-    key = uuid.uuid4().hex
-    await filesystem.write_path(key, content)
-    result = _Result(key=key, filesystem_document_id=filesystem._block_document_id)
-    return DataDocument.encode("result", result)
-
-
-async def _retrieve_serialized_result(document: DataDocument, client) -> bytes:
-    from prefect.blocks.core import Block
-
-    if document.encoding != "result":
-        raise TypeError(
-            f"Got unsupported data document encoding of {document.encoding!r}. "
-            "Expected 'result'."
-        )
-    result = document.decode()
-    filesystem_document = await client.read_block_document(
-        result.filesystem_document_id
-    )
-    filesystem = Block._from_block_document(filesystem_document)
-    return await filesystem.read_path(result.key)
-
-
-async def _retrieve_result(state, client):
-    serialized_result = await _retrieve_serialized_result(state.data, client)
-    return DataDocument.parse_raw(serialized_result).decode()
-
-
-class _Result(pydantic.BaseModel):
-    key: str
-    filesystem_document_id: uuid.UUID