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

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

prefect/deprecated/packaging/__init__.py

@@ -1,12 +0,0 @@
-"""
-DEPRECATION WARNING:
-This module is deprecated as of March 2024 and will not be available after September 2024.
- """
-from prefect.deprecated.packaging.docker import DockerPackager
-from prefect.deprecated.packaging.file import FilePackager
-from prefect.deprecated.packaging.orion import OrionPackager
-
-# isort: split
-
-# Register any packaging serializers
-import prefect.deprecated.packaging.serializers

prefect/deprecated/packaging/base.py

@@ -1,96 +0,0 @@
-"""
-DEPRECATION WARNING:
-This module is deprecated as of March 2024 and will not be available after September 2024.
-"""
-
-import abc
-from typing import Generic, Type, TypeVar
-
-from prefect._internal.compatibility.deprecated import deprecated_class
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import BaseModel
-else:
-    from pydantic import BaseModel
-
-from prefect.flows import Flow
-from prefect.utilities.callables import ParameterSchema, parameter_schema
-from prefect.utilities.dispatch import lookup_type
-from prefect.utilities.pydantic import add_type_dispatch
-
-D = TypeVar("D")
-
-
-@deprecated_class(start_date="Mar 2024")
-@add_type_dispatch
-class Serializer(BaseModel, Generic[D], abc.ABC):
-    """
-    DEPRECATION WARNING:
-
-    This class is deprecated as of version March 2024 and will not be available after September 2024.
-
-    A serializer that can encode objects of type 'D' into bytes.
-    """
-
-    type: str
-
-    def dumps(self, obj: D) -> bytes:
-        """Encode the object into a blob of bytes."""
-
-    def loads(self, blob: bytes) -> D:
-        """Decode the blob of bytes into an object."""
-
-
-@deprecated_class(start_date="Mar 2024")
-@add_type_dispatch
-class PackageManifest(BaseModel, abc.ABC):
-    """
-    DEPRECATION WARNING:
-
-    This class is deprecated as of version March 2024 and will not be available after September 2024.
-
-    Describes a package.
-    """
-
-    type: str
-    flow_name: str
-    flow_parameter_schema: ParameterSchema
-
-    @abc.abstractmethod
-    async def unpackage(self) -> Flow:
-        """
-        Retrieve a flow from the package.
-        """
-
-
-@deprecated_class(start_date="Mar 2024")
-@add_type_dispatch
-class Packager(BaseModel, abc.ABC):
-    """
-    DEPRECATION WARNING:
-
-    This class is deprecated as of version March 2024 and will not be available after September 2024.
-
-    Creates a package for a flow.
-
-    A package contains the flow and is typically stored outside of Prefect. To
-    facilitate interaction with the package, a manifest is returned that describes how
-    to access and use the package.
-    """
-
-    type: str
-
-    def base_manifest(self, flow: Flow) -> PackageManifest:
-        manifest_cls: Type[BaseModel] = lookup_type(PackageManifest, self.type)
-        return manifest_cls.construct(
-            type=self.type,
-            flow_name=flow.name,
-            flow_parameter_schema=parameter_schema(flow.fn),
-        )
-
-    @abc.abstractmethod
-    async def package(self, flow: Flow) -> "PackageManifest":
-        """
-        Package a flow and return a manifest describing the created package.
-        """

prefect/deprecated/packaging/docker.py

@@ -1,146 +0,0 @@
-"""
-DEPRECATION WARNING:
-This module is deprecated as of March 2024 and will not be available after September 2024.
-"""
-
-import json
-import sys
-from pathlib import Path
-from typing import Any, Mapping, Optional, Union
-
-from prefect._internal.compatibility.deprecated import deprecated_class
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-from prefect._internal.schemas.validators import (
-    assign_default_base_image,
-    base_image_xor_dockerfile,
-    set_default_python_environment,
-    validate_registry_url,
-)
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import AnyHttpUrl, root_validator, validator
-else:
-    from pydantic import AnyHttpUrl, root_validator, validator
-from typing_extensions import Literal
-
-from prefect.deprecated.packaging.base import PackageManifest, Packager
-from prefect.deprecated.packaging.serializers import SourceSerializer
-from prefect.flows import Flow, load_flow_from_script
-from prefect.software import CondaEnvironment, PythonEnvironment
-from prefect.utilities.asyncutils import run_sync_in_worker_thread
-from prefect.utilities.dockerutils import (
-    ImageBuilder,
-    build_image,
-    push_image,
-    to_run_command,
-)
-from prefect.utilities.slugify import slugify
-
-
-@deprecated_class(start_date="Mar 2024")
-class DockerPackageManifest(PackageManifest):
-    """
-    DEPRECATION WARNING:
-
-    This class is deprecated as of version March 2024 and will not be available after September 2024.
-
-    Represents a flow packaged in a Docker image
-    """
-
-    type: Literal["docker"] = "docker"
-
-    image: str
-    image_flow_location: str
-
-    async def unpackage(self) -> Flow:
-        return load_flow_from_script(self.image_flow_location, self.flow_name)
-
-
-@deprecated_class(start_date="Mar 2024")
-class DockerPackager(Packager):
-    """
-    DEPRECATION WARNING:
-
-    This class is deprecated as of version March 2024 and will not be available after September 2024.
-
-    This packager builds a Docker image containing the flow and the runtime environment
-    necessary to run the flow.  The resulting image is optionally pushed to a container
-    registry, given by `registry_url`.
-    """
-
-    type: str = "docker"
-
-    base_image: Optional[str] = None
-    python_environment: Optional[Union[PythonEnvironment, CondaEnvironment]] = None
-    dockerfile: Optional[Path] = None
-    platform: Optional[str] = (None,)
-    image_flow_location: str = "/flow.py"
-    registry_url: Optional[AnyHttpUrl] = None
-
-    @root_validator
-    def set_default_base_image(cls, values):
-        return assign_default_base_image(values)
-
-    @root_validator
-    def base_image_and_dockerfile_exclusive(cls, values: Mapping[str, Any]):
-        return base_image_xor_dockerfile(values)
-
-    @root_validator
-    def default_python_environment(cls, values: Mapping[str, Any]):
-        return set_default_python_environment(values)
-
-    @validator("registry_url", pre=True)
-    def ensure_registry_url_is_prefixed(cls, value):
-        validate_registry_url(value)
-
-    async def package(self, flow: Flow) -> DockerPackageManifest:
-        """
-        Package a flow as a Docker image and, optionally, push it to a registry
-        """
-        image_reference = await self._build_image(flow)
-
-        if self.registry_url:
-            image_name = f"{slugify(flow.name)}"
-            image_reference = await run_sync_in_worker_thread(
-                push_image, image_reference, self.registry_url, image_name
-            )
-
-        return DockerPackageManifest(
-            **{
-                **self.base_manifest(flow).dict(),
-                **{
-                    "image": image_reference,
-                    "image_flow_location": self.image_flow_location,
-                },
-            }
-        )
-
-    async def _build_image(self, flow: Flow) -> str:
-        if self.dockerfile:
-            return await self._build_from_dockerfile()
-        return await self._build_from_base_image(flow)
-
-    async def _build_from_dockerfile(self) -> str:
-        context = self.dockerfile.resolve().parent
-        dockerfile = self.dockerfile.relative_to(context)
-        return await run_sync_in_worker_thread(
-            build_image,
-            platform=self.platform,
-            context=context,
-            dockerfile=str(dockerfile),
-        )
-
-    async def _build_from_base_image(self, flow: Flow) -> str:
-        with ImageBuilder(
-            base_image=self.base_image, platform=self.platform
-        ) as builder:
-            for command in self.python_environment.install_commands():
-                builder.add_line(to_run_command(command))
-
-            source_info = json.loads(SourceSerializer().dumps(flow))
-
-            builder.write_text(source_info["source"], self.image_flow_location)
-
-            return await run_sync_in_worker_thread(
-                builder.build, stream_progress_to=sys.stdout
-            )

prefect/deprecated/packaging/file.py

@@ -1,92 +0,0 @@
-"""
-DEPRECATION WARNING:
-This module is deprecated as of March 2024 and will not be available after September 2024.
-"""
-
-from uuid import UUID
-
-from prefect._internal.compatibility.deprecated import deprecated_class
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field
-else:
-    from pydantic import Field
-
-from typing_extensions import Literal
-
-from prefect.blocks.core import Block
-from prefect.client.orchestration import PrefectClient
-from prefect.client.utilities import inject_client
-from prefect.deprecated.packaging.base import PackageManifest, Packager, Serializer
-from prefect.deprecated.packaging.serializers import SourceSerializer
-from prefect.filesystems import LocalFileSystem, ReadableFileSystem, WritableFileSystem
-from prefect.flows import Flow
-from prefect.settings import PREFECT_HOME
-from prefect.utilities.hashing import stable_hash
-
-
-@deprecated_class(start_date="Mar 2024")
-class FilePackageManifest(PackageManifest):
-    """
-    DEPRECATION WARNING:
-
-    This class is deprecated as of version March 2024 and will not be available after September 2024.
-    """
-
-    type: str = "file"
-    serializer: Serializer
-    key: str
-    filesystem_id: UUID
-
-    @inject_client
-    async def unpackage(self, client: PrefectClient) -> Flow:
-        block_document = await client.read_block_document(self.filesystem_id)
-        filesystem: ReadableFileSystem = Block._from_block_document(block_document)
-        content = await filesystem.read_path(self.key)
-        return self.serializer.loads(content)
-
-
-@deprecated_class(start_date="Mar 2024")
-class FilePackager(Packager):
-    """
-    DEPRECATION WARNING:
-
-    This class is deprecated as of version March 2024 and will not be available after September 2024.
-
-    This packager stores the flow as a single file.
-
-    By default, the file is the source code of the module the flow is defined in.
-    Alternative serialization modes are available in `prefect.deprecated.packaging.serializers`.
-    """
-
-    type: Literal["file"] = "file"
-    serializer: Serializer = Field(default_factory=SourceSerializer)
-    filesystem: WritableFileSystem = Field(
-        default_factory=lambda: LocalFileSystem(
-            basepath=PREFECT_HOME.value() / "storage"
-        )
-    )
-
-    @inject_client
-    async def package(self, flow: Flow, client: "PrefectClient") -> FilePackageManifest:
-        content = self.serializer.dumps(flow)
-        key = stable_hash(content)
-
-        await self.filesystem.write_path(key, content)
-
-        filesystem_id = (
-            self.filesystem._block_document_id
-            or await self.filesystem._save(is_anonymous=True)
-        )
-
-        return FilePackageManifest(
-            **{
-                **self.base_manifest(flow).dict(),
-                **{
-                    "serializer": self.serializer,
-                    "filesystem_id": filesystem_id,
-                    "key": key,
-                },
-            }
-        )