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

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,
-                },
-            }
-        )

prefect/deprecated/packaging/orion.py

@@ -1,80 +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.system import JSON
-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.flows import Flow
-
-
-@deprecated_class(start_date="Mar 2024")
-class OrionPackageManifest(PackageManifest):
-    """
-    DEPRECATION WARNING:
-
-    This class is deprecated as of version March 2024 and will not be available after September 2024.
-    """
-
-    type: str = "orion"
-    serializer: Serializer
-    block_document_id: UUID
-
-    @inject_client
-    async def unpackage(self, client: PrefectClient) -> Flow:
-        document = await client.read_block_document(self.block_document_id)
-        block = JSON._from_block_document(document)
-        serialized_flow: str = block.value["flow"]
-        # Cast to bytes before deserialization
-        return self.serializer.loads(serialized_flow.encode())
-
-
-@deprecated_class(start_date="Mar 2024")
-class OrionPackager(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 an anonymous JSON block in the Prefect database.
-    The content of the block are encrypted at rest.
-
-    By default, the content is the source code of the module the flow is defined in.
-    Alternative serialization modes are available in `prefect.deprecated.packaging.serializers`.
-    """
-
-    type: Literal["orion"] = "orion"
-    serializer: Serializer = Field(default_factory=SourceSerializer)
-
-    async def package(self, flow: Flow) -> OrionPackageManifest:
-        """
-        Package a flow in the Prefect database as an anonymous block.
-        """
-        block_document_id = await JSON(
-            value={"flow": self.serializer.dumps(flow)}
-        )._save(is_anonymous=True)
-
-        return OrionPackageManifest(
-            **{
-                **self.base_manifest(flow).dict(),
-                **{
-                    "serializer": self.serializer,
-                    "block_document_id": block_document_id,
-                },
-            }
-        )

prefect/deprecated/packaging/serializers.py

@@ -1,171 +0,0 @@
-"""
-DEPRECATION WARNING:
-This module is deprecated as of March 2024 and will not be available after September 2024.
-"""
-
-import base64
-import inspect
-import json
-import os.path
-from pathlib import Path
-from tempfile import TemporaryDirectory
-from typing import Any, List
-
-from prefect._internal.compatibility.deprecated import deprecated_class
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-from prefect._internal.schemas.validators import (
-    validate_picklelib,
-    validate_picklelib_and_modules,
-    validate_picklelib_version,
-)
-
-if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
-else:
-    import pydantic
-
-from typing_extensions import Literal
-
-from prefect.deprecated.packaging.base import Serializer
-from prefect.utilities.importtools import (
-    from_qualified_name,
-    load_script_as_module,
-    to_qualified_name,
-)
-
-
-@deprecated_class(start_date="Mar 2024")
-class PickleSerializer(Serializer):
-    """
-    DEPRECATION WARNING:
-
-    This class is deprecated as of version March 2024 and will not be available after September 2024.
-
-    Serializes objects using the pickle protocol.
-
-    If using cloudpickle, you may specify a list of 'pickle_modules'. These modules will
-    be serialized by value instead of by reference, which means they do not have to be
-    installed in the runtime location. This is especially useful for serializing objects
-    that rely on local packages.
-
-    Wraps pickles in base64 for safe transmission.
-    """
-
-    type: Literal["pickle"] = "pickle"
-
-    picklelib: str = "cloudpickle"
-    picklelib_version: str = None
-
-    pickle_modules: List[str] = pydantic.Field(default_factory=list)
-
-    @pydantic.validator("picklelib")
-    def check_picklelib(cls, value):
-        return validate_picklelib(value)
-
-    @pydantic.root_validator
-    def check_picklelib_and_modules(cls, values):
-        return validate_picklelib_and_modules(values)
-
-    @pydantic.root_validator
-    def check_picklelib_version(cls, values):
-        return validate_picklelib_version(values)
-
-    def dumps(self, obj: Any) -> bytes:
-        pickler = from_qualified_name(self.picklelib)
-
-        for module in self.pickle_modules:
-            pickler.register_pickle_by_value(from_qualified_name(module))
-
-        blob = pickler.dumps(obj)
-
-        for module in self.pickle_modules:
-            # Restore the pickler settings
-            pickler.unregister_pickle_by_value(from_qualified_name(module))
-
-        return base64.encodebytes(blob)
-
-    def loads(self, blob: bytes) -> Any:
-        pickler = from_qualified_name(self.picklelib)
-        return pickler.loads(base64.decodebytes(blob))
-
-
-@deprecated_class(start_date="Mar 2024")
-class SourceSerializer(Serializer):
-    """
-    DEPRECATION WARNING:
-
-    This class is deprecated as of version March 2024 and will not be available after September 2024.
-
-    Serializes objects by retrieving the source code of the module they are defined in.
-
-    Creates a JSON blob with keys:
-        source: The source code
-        file_name: The name of the file the source was in
-        symbol_name: The name of the object to extract from the source code
-
-    Deserialization requires the code to run with `exec`.
-    """
-
-    type: Literal["source"] = "source"
-
-    def dumps(self, obj: Any) -> bytes:
-        module = inspect.getmodule(obj)
-
-        if module is None:
-            raise ValueError(f"Cannot determine source module for object: {obj!r}.")
-
-        if not getattr(module, "__file__", None):
-            raise ValueError(
-                f"Found module {module!r} without source code file while serializing "
-                f"object: {obj!r}."
-            )
-
-        source = inspect.getsource(module)
-
-        return json.dumps(
-            {
-                "source": source,
-                "file_name": os.path.basename(module.__file__),
-                "symbol_name": obj.__name__,
-            }
-        ).encode()
-
-    def loads(self, blob: bytes) -> Any:
-        document = json.loads(blob)
-        if not isinstance(document, dict) or set(document.keys()) != {
-            "source",
-            "file_name",
-            "symbol_name",
-        }:
-            raise ValueError(
-                "Invalid serialized data. "
-                "Expected dictionary with keys 'source', 'file_name', and "
-                "'symbol_name'. "
-                f"Got: {document}"
-            )
-
-        with TemporaryDirectory() as tmpdir:
-            temp_script = Path(tmpdir) / document["file_name"]
-            temp_script.write_text(document["source"])
-            module = load_script_as_module(str(temp_script))
-
-        return getattr(module, document["symbol_name"])
-
-
-@deprecated_class(start_date="Mar 2024")
-class ImportSerializer(Serializer):
-    """
-    DEPRECATION WARNING:
-
-    This class is deprecated as of version March 2024 and will not be available after September 2024.
-
-    Serializes objects by storing their importable path.
-    """
-
-    type: Literal["import"] = "import"
-
-    def dumps(self, obj: Any) -> bytes:
-        return to_qualified_name(obj).encode()
-
-    def loads(self, blob: bytes) -> Any:
-        return from_qualified_name(blob.decode())