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

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())

prefect/events/instrument.py

@@ -1,135 +0,0 @@
-import functools
-import inspect
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Generator,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    cast,
-)
-
-from prefect.events import emit_event
-
-ResourceTuple = Tuple[Dict[str, Any], List[Dict[str, Any]]]
-
-
-def emit_instance_method_called_event(
-    instance: Any,
-    method_name: str,
-    successful: bool,
-    payload: Optional[Dict[str, Any]] = None,
-):
-    kind = instance._event_kind()
-    resources: Optional[ResourceTuple] = instance._event_method_called_resources()
-
-    if not resources:
-        return
-
-    resource, related = resources
-    result = "called" if successful else "failed"
-
-    emit_event(
-        event=f"{kind}.{method_name}.{result}",
-        resource=resource,
-        related=related,
-        payload=payload,
-    )
-
-
-F = TypeVar("F", bound=Callable)
-
-
-def instrument_instance_method_call(function: F) -> F:
-    if is_instrumented(function):
-        return function
-
-    if inspect.iscoroutinefunction(function):
-
-        @functools.wraps(function)
-        async def inner(self, *args, **kwargs):
-            success = True
-            try:
-                return await function(self, *args, **kwargs)
-            except Exception as exc:
-                success = False
-                raise exc
-            finally:
-                emit_instance_method_called_event(
-                    instance=self, method_name=function.__name__, successful=success
-                )
-
-    else:
-
-        @functools.wraps(function)
-        def inner(self, *args, **kwargs):
-            success = True
-            try:
-                return function(self, *args, **kwargs)
-            except Exception as exc:
-                success = False
-                raise exc
-            finally:
-                emit_instance_method_called_event(
-                    instance=self, method_name=function.__name__, successful=success
-                )
-
-    setattr(inner, "__events_instrumented__", True)
-    return cast(F, inner)
-
-
-def is_instrumented(function: Callable) -> bool:
-    """Indicates whether the given function is already instrumented"""
-    return getattr(function, "__events_instrumented__", False)
-
-
-def instrumentable_methods(
-    cls: Type,
-    exclude_methods: Union[List[str], Set[str], None] = None,
-) -> Generator[Tuple[str, Callable], None, None]:
-    """Returns all of the public methods on a class."""
-
-    for name, kind, _, method in inspect.classify_class_attrs(cls):
-        if kind == "method" and callable(method):
-            if exclude_methods and name in exclude_methods:
-                continue
-            if name.startswith("_"):
-                continue
-
-            yield name, method
-
-
-def instrument_method_calls_on_class_instances(cls: Type) -> Type:
-    """Given a Python class, instruments all "public" methods that are
-    defined directly on the class to emit events when called.
-
-    Examples:
-
-        @instrument_class
-        class MyClass(MyBase):
-            def my_method(self):
-                ... this method will be instrumented ...
-
-            def _my_method(self):
-                ... this method will not ...
-    """
-
-    required_events_methods = ["_event_kind", "_event_method_called_resources"]
-    for method_name in required_events_methods:
-        if not hasattr(cls, method_name):
-            raise RuntimeError(
-                f"Unable to instrument class {cls}. Class must define {method_name!r}."
-            )
-
-    for method_name, method in instrumentable_methods(
-        cls,
-        exclude_methods=getattr(cls, "_events_excluded_methods", []),
-    ):
-        setattr(cls, method_name, instrument_instance_method_call(method))
-    return cls

prefect/infrastructure/base.py

@@ -1,323 +0,0 @@
-"""
-DEPRECATION WARNING:
-
-This module is deprecated as of March 2024 and will not be available after September 2024.
-Infrastructure blocks have been replaced by workers, which offer enhanced functionality and better performance.
-
-For upgrade instructions, see https://docs.prefect.io/latest/guides/upgrade-guide-agents-to-workers/.
-"""
-import abc
-import shlex
-import warnings
-from typing import TYPE_CHECKING, Dict, List, Optional
-
-import anyio.abc
-
-from prefect._internal.compatibility.deprecated import deprecated_class
-from prefect._internal.compatibility.experimental import (
-    EXPERIMENTAL_WARNING,
-    ExperimentalFeature,
-    experiment_enabled,
-)
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-from prefect.client.schemas.actions import WorkPoolCreate
-from prefect.exceptions import ObjectAlreadyExists
-
-if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
-else:
-    import pydantic
-
-from rich.console import Console
-from typing_extensions import Self
-
-import prefect
-from prefect.blocks.core import Block, BlockNotSavedError
-from prefect.logging import get_logger
-from prefect.settings import (
-    PREFECT_EXPERIMENTAL_WARN,
-    PREFECT_EXPERIMENTAL_WARN_ENHANCED_CANCELLATION,
-    PREFECT_UI_URL,
-    get_current_settings,
-)
-from prefect.utilities.asyncutils import sync_compatible
-
-MIN_COMPAT_PREFECT_VERSION = "2.0b12"
-
-
-if TYPE_CHECKING:
-    from prefect.client.schemas.objects import Deployment, Flow, FlowRun
-
-
-class InfrastructureResult(pydantic.BaseModel, abc.ABC):
-    identifier: str
-    status_code: int
-
-    def __bool__(self):
-        return self.status_code == 0
-
-
-@deprecated_class(
-    start_date="Mar 2024",
-    help="Use the `BaseWorker` class to create custom infrastructure integrations instead."
-    " Refer to the upgrade guide for more information:"
-    " https://docs.prefect.io/latest/guides/upgrade-guide-agents-to-workers/.",
-)
-class Infrastructure(Block, abc.ABC):
-    _block_schema_capabilities = ["run-infrastructure"]
-
-    type: str
-
-    env: Dict[str, Optional[str]] = pydantic.Field(
-        default_factory=dict,
-        title="Environment",
-        description="Environment variables to set in the configured infrastructure.",
-    )
-    labels: Dict[str, str] = pydantic.Field(
-        default_factory=dict,
-        description="Labels applied to the infrastructure for metadata purposes.",
-    )
-    name: Optional[str] = pydantic.Field(
-        default=None,
-        description="Name applied to the infrastructure for identification.",
-    )
-    command: Optional[List[str]] = pydantic.Field(
-        default=None,
-        description="The command to run in the infrastructure.",
-    )
-
-    async def generate_work_pool_base_job_template(self):
-        if self._block_document_id is None:
-            raise BlockNotSavedError(
-                "Cannot publish as work pool, block has not been saved. Please call"
-                " `.save()` on your block before publishing."
-            )
-
-        block_schema = self.__class__.schema()
-        return {
-            "job_configuration": {"block": "{{ block }}"},
-            "variables": {
-                "type": "object",
-                "properties": {
-                    "block": {
-                        "title": "Block",
-                        "description": (
-                            "The infrastructure block to use for job creation."
-                        ),
-                        "allOf": [{"$ref": f"#/definitions/{self.__class__.__name__}"}],
-                        "default": {
-                            "$ref": {"block_document_id": str(self._block_document_id)}
-                        },
-                    }
-                },
-                "required": ["block"],
-                "definitions": {self.__class__.__name__: block_schema},
-            },
-        }
-
-    def get_corresponding_worker_type(self):
-        return "block"
-
-    @sync_compatible
-    async def publish_as_work_pool(self, work_pool_name: Optional[str] = None):
-        """
-        Creates a work pool configured to use the given block as the job creator.
-
-        Used to migrate from a agents setup to a worker setup.
-
-        Args:
-            work_pool_name: The name to give to the created work pool. If not provided, the name of the current
-                block will be used.
-        """
-
-        base_job_template = await self.generate_work_pool_base_job_template()
-        work_pool_name = work_pool_name or self._block_document_name
-
-        if work_pool_name is None:
-            raise ValueError(
-                "`work_pool_name` must be provided if the block has not been saved."
-            )
-
-        console = Console()
-
-        try:
-            async with prefect.get_client() as client:
-                work_pool = await client.create_work_pool(
-                    work_pool=WorkPoolCreate(
-                        name=work_pool_name,
-                        type=self.get_corresponding_worker_type(),
-                        base_job_template=base_job_template,
-                    )
-                )
-        except ObjectAlreadyExists:
-            console.print(
-                (
-                    f"Work pool with name {work_pool_name!r} already exists, please use"
-                    " a different name."
-                ),
-                style="red",
-            )
-            return
-
-        console.print(
-            f"Work pool {work_pool.name} created!",
-            style="green",
-        )
-        if PREFECT_UI_URL:
-            console.print(
-                "You see your new work pool in the UI at"
-                f" {PREFECT_UI_URL.value()}/work-pools/work-pool/{work_pool.name}"
-            )
-
-        deploy_script = (
-            "my_flow.deploy(work_pool_name='{work_pool.name}', image='my_image:tag')"
-        )
-        if not hasattr(self, "image"):
-            deploy_script = (
-                "my_flow.from_source(source='https://github.com/org/repo.git',"
-                f" entrypoint='flow.py:my_flow').deploy(work_pool_name='{work_pool.name}')"
-            )
-        console.print(
-            "\nYou can deploy a flow to this work pool by calling"
-            f" [blue].deploy[/]:\n\n\t{deploy_script}\n"
-        )
-        console.print(
-            "\nTo start a worker to execute flow runs in this work pool run:\n"
-        )
-        console.print(f"\t[blue]prefect worker start --pool {work_pool.name}[/]\n")
-
-    @abc.abstractmethod
-    async def run(
-        self,
-        task_status: anyio.abc.TaskStatus = None,
-    ) -> InfrastructureResult:
-        """
-        Run the infrastructure.
-
-        If provided a `task_status`, the status will be reported as started when the
-        infrastructure is successfully created. The status return value will be an
-        identifier for the infrastructure.
-
-        The call will then monitor the created infrastructure, returning a result at
-        the end containing a status code indicating if the infrastructure exited cleanly
-        or encountered an error.
-        """
-        # Note: implementations should include `sync_compatible`
-
-    @abc.abstractmethod
-    def preview(self) -> str:
-        """
-        View a preview of the infrastructure that would be run.
-        """
-
-    @property
-    def logger(self):
-        return get_logger(f"prefect.infrastructure.{self.type}")
-
-    @property
-    def is_using_a_runner(self):
-        return self.command is not None and "prefect flow-run execute" in shlex.join(
-            self.command
-        )
-
-    @classmethod
-    def _base_environment(cls) -> Dict[str, str]:
-        """
-        Environment variables that should be passed to all created infrastructure.
-
-        These values should be overridable with the `env` field.
-        """
-        return get_current_settings().to_environment_variables(exclude_unset=True)
-
-    def prepare_for_flow_run(
-        self: Self,
-        flow_run: "FlowRun",
-        deployment: Optional["Deployment"] = None,
-        flow: Optional["Flow"] = None,
-    ) -> Self:
-        """
-        Return an infrastructure block that is prepared to execute a flow run.
-        """
-        if deployment is not None:
-            deployment_labels = self._base_deployment_labels(deployment)
-        else:
-            deployment_labels = {}
-
-        if flow is not None:
-            flow_labels = self._base_flow_labels(flow)
-        else:
-            flow_labels = {}
-
-        return self.copy(
-            update={
-                "env": {**self._base_flow_run_environment(flow_run), **self.env},
-                "labels": {
-                    **self._base_flow_run_labels(flow_run),
-                    **deployment_labels,
-                    **flow_labels,
-                    **self.labels,
-                },
-                "name": self.name or flow_run.name,
-                "command": self.command or self._base_flow_run_command(),
-            }
-        )
-
-    @staticmethod
-    def _base_flow_run_command() -> List[str]:
-        """
-        Generate a command for a flow run job.
-        """
-        if experiment_enabled("enhanced_cancellation"):
-            if (
-                PREFECT_EXPERIMENTAL_WARN
-                and PREFECT_EXPERIMENTAL_WARN_ENHANCED_CANCELLATION
-            ):
-                warnings.warn(
-                    EXPERIMENTAL_WARNING.format(
-                        feature="Enhanced flow run cancellation",
-                        group="enhanced_cancellation",
-                        help="",
-                    ),
-                    ExperimentalFeature,
-                    stacklevel=3,
-                )
-            return ["prefect", "flow-run", "execute"]
-
-        return ["python", "-m", "prefect.engine"]
-
-    @staticmethod
-    def _base_flow_run_labels(flow_run: "FlowRun") -> Dict[str, str]:
-        """
-        Generate a dictionary of labels for a flow run job.
-        """
-        return {
-            "prefect.io/flow-run-id": str(flow_run.id),
-            "prefect.io/flow-run-name": flow_run.name,
-            "prefect.io/version": prefect.__version__,
-        }
-
-    @staticmethod
-    def _base_flow_run_environment(flow_run: "FlowRun") -> Dict[str, str]:
-        """
-        Generate a dictionary of environment variables for a flow run job.
-        """
-        environment = {}
-        environment["PREFECT__FLOW_RUN_ID"] = str(flow_run.id)
-        return environment
-
-    @staticmethod
-    def _base_deployment_labels(deployment: "Deployment") -> Dict[str, str]:
-        labels = {
-            "prefect.io/deployment-name": deployment.name,
-        }
-        if deployment.updated is not None:
-            labels["prefect.io/deployment-updated"] = deployment.updated.in_timezone(
-                "utc"
-            ).to_iso8601_string()
-        return labels
-
-    @staticmethod
-    def _base_flow_labels(flow: "Flow") -> Dict[str, str]:
-        return {
-            "prefect.io/flow-name": flow.name,
-        }