prefect-client 3.1.11__py3-none-any.whl → 3.1.13__py3-none-any.whl

prefect/client/orchestration/__init__.py

@@ -7,7 +7,7 @@ from collections.abc import Iterable
 from contextlib import AsyncExitStack
 from logging import Logger
 from typing import TYPE_CHECKING, Any, Literal, NoReturn, Optional, Union, overload
-from uuid import UUID, uuid4
+from uuid import UUID
 
 import certifi
 import httpcore
@@ -40,31 +40,49 @@ from prefect.client.orchestration._variables.client import (
     VariableAsyncClient,
 )
 
+from prefect.client.orchestration._deployments.client import (
+    DeploymentClient,
+    DeploymentAsyncClient,
+)
+from prefect.client.orchestration._automations.client import (
+    AutomationClient,
+    AutomationAsyncClient,
+)
+from prefect._experimental.sla.client import SlaClient, SlaAsyncClient
+
+from prefect.client.orchestration._flows.client import (
+    FlowClient,
+    FlowAsyncClient,
+)
+from prefect.client.orchestration._flow_runs.client import (
+    FlowRunClient,
+    FlowRunAsyncClient,
+)
+
+from prefect.client.orchestration._blocks_documents.client import (
+    BlocksDocumentClient,
+    BlocksDocumentAsyncClient,
+)
+
+from prefect.client.orchestration._blocks_schemas.client import (
+    BlocksSchemaClient,
+    BlocksSchemaAsyncClient,
+)
+
+from prefect.client.orchestration._blocks_types.client import (
+    BlocksTypeClient,
+    BlocksTypeAsyncClient,
+)
+
 import prefect
 import prefect.exceptions
 import prefect.settings
 import prefect.states
 from prefect.client.constants import SERVER_API_VERSION
-from prefect.client.schemas import FlowRun, OrchestrationResult, TaskRun, sorting
+from prefect.client.schemas import FlowRun, OrchestrationResult, TaskRun
 from prefect.client.schemas.actions import (
-    BlockDocumentCreate,
-    BlockDocumentUpdate,
-    BlockSchemaCreate,
-    BlockTypeCreate,
-    BlockTypeUpdate,
-    DeploymentCreate,
-    DeploymentFlowRunCreate,
-    DeploymentScheduleCreate,
-    DeploymentScheduleUpdate,
-    DeploymentUpdate,
-    FlowCreate,
-    FlowRunCreate,
     FlowRunNotificationPolicyCreate,
     FlowRunNotificationPolicyUpdate,
-    FlowRunUpdate,
-    LogCreate,
-    GlobalConcurrencyLimitCreate,
-    GlobalConcurrencyLimitUpdate,
     TaskRunCreate,
     TaskRunUpdate,
     WorkPoolCreate,
@@ -84,16 +102,8 @@ from prefect.client.schemas.filters import (
     WorkQueueFilterName,
 )
 from prefect.client.schemas.objects import (
-    BlockDocument,
-    BlockSchema,
-    BlockType,
-    ConcurrencyOptions,
     Constant,
-    DeploymentSchedule,
-    Flow,
-    FlowRunInput,
     FlowRunNotificationPolicy,
-    FlowRunPolicy,
     Parameter,
     TaskRunPolicy,
     TaskRunResult,
@@ -104,19 +114,11 @@ from prefect.client.schemas.objects import (
     WorkQueueStatusDetail,
 )
 from prefect.client.schemas.responses import (
-    DeploymentResponse,
-    FlowRunResponse,
     WorkerFlowRunResponse,
 )
-from prefect.client.schemas.schedules import SCHEDULE_TYPES
 from prefect.client.schemas.sorting import (
-    DeploymentSort,
-    FlowRunSort,
-    FlowSort,
     TaskRunSort,
 )
-from prefect.events import filters
-from prefect.events.schemas.automations import Automation, AutomationCore
 from prefect.logging import get_logger
 from prefect.settings import (
     PREFECT_API_AUTH_STRING,
@@ -133,10 +135,8 @@ from prefect.settings import (
     PREFECT_TESTING_UNIT_TEST_MODE,
     get_current_settings,
 )
-from prefect.types import KeyValueLabelsField
 
 if TYPE_CHECKING:
-    from prefect.flows import Flow as FlowObject
     from prefect.tasks import Task as TaskObject
 
 from prefect.client.base import (
@@ -255,6 +255,14 @@ class PrefectClient(
     LogAsyncClient,
     VariableAsyncClient,
     ConcurrencyLimitAsyncClient,
+    DeploymentAsyncClient,
+    AutomationAsyncClient,
+    SlaAsyncClient,
+    FlowRunAsyncClient,
+    FlowAsyncClient,
+    BlocksDocumentAsyncClient,
+    BlocksSchemaAsyncClient,
+    BlocksTypeAsyncClient,
 ):
     """
     An asynchronous client for interacting with the [Prefect REST API](/api-ref/rest-api/).
@@ -467,361 +475,6 @@ class PrefectClient(
         """
         return await self._client.get("/hello")
 
-    async def create_flow(self, flow: "FlowObject[Any, Any]") -> UUID:
-        """
-        Create a flow in the Prefect API.
-
-        Args:
-            flow: a [Flow][prefect.flows.Flow] object
-
-        Raises:
-            httpx.RequestError: if a flow was not created for any reason
-
-        Returns:
-            the ID of the flow in the backend
-        """
-        return await self.create_flow_from_name(flow.name)
-
-    async def create_flow_from_name(self, flow_name: str) -> UUID:
-        """
-        Create a flow in the Prefect API.
-
-        Args:
-            flow_name: the name of the new flow
-
-        Raises:
-            httpx.RequestError: if a flow was not created for any reason
-
-        Returns:
-            the ID of the flow in the backend
-        """
-        flow_data = FlowCreate(name=flow_name)
-        response = await self._client.post(
-            "/flows/", json=flow_data.model_dump(mode="json")
-        )
-
-        flow_id = response.json().get("id")
-        if not flow_id:
-            raise httpx.RequestError(f"Malformed response: {response}")
-
-        # Return the id of the created flow
-        return UUID(flow_id)
-
-    async def read_flow(self, flow_id: UUID) -> Flow:
-        """
-        Query the Prefect API for a flow by id.
-
-        Args:
-            flow_id: the flow ID of interest
-
-        Returns:
-            a [Flow model][prefect.client.schemas.objects.Flow] representation of the flow
-        """
-        response = await self._client.get(f"/flows/{flow_id}")
-        return Flow.model_validate(response.json())
-
-    async def delete_flow(self, flow_id: UUID) -> None:
-        """
-        Delete a flow by UUID.
-
-        Args:
-            flow_id: ID of the flow to be deleted
-        Raises:
-            prefect.exceptions.ObjectNotFound: If request returns 404
-            httpx.RequestError: If requests fail
-        """
-        try:
-            await self._client.delete(f"/flows/{flow_id}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-    async def read_flows(
-        self,
-        *,
-        flow_filter: Optional[FlowFilter] = None,
-        flow_run_filter: Optional[FlowRunFilter] = None,
-        task_run_filter: Optional[TaskRunFilter] = None,
-        deployment_filter: Optional[DeploymentFilter] = None,
-        work_pool_filter: Optional[WorkPoolFilter] = None,
-        work_queue_filter: Optional[WorkQueueFilter] = None,
-        sort: Optional[FlowSort] = None,
-        limit: Optional[int] = None,
-        offset: int = 0,
-    ) -> list[Flow]:
-        """
-        Query the Prefect API for flows. Only flows matching all criteria will
-        be returned.
-
-        Args:
-            flow_filter: filter criteria for flows
-            flow_run_filter: filter criteria for flow runs
-            task_run_filter: filter criteria for task runs
-            deployment_filter: filter criteria for deployments
-            work_pool_filter: filter criteria for work pools
-            work_queue_filter: filter criteria for work pool queues
-            sort: sort criteria for the flows
-            limit: limit for the flow query
-            offset: offset for the flow query
-
-        Returns:
-            a list of Flow model representations of the flows
-        """
-        body: dict[str, Any] = {
-            "flows": flow_filter.model_dump(mode="json") if flow_filter else None,
-            "flow_runs": (
-                flow_run_filter.model_dump(mode="json", exclude_unset=True)
-                if flow_run_filter
-                else None
-            ),
-            "task_runs": (
-                task_run_filter.model_dump(mode="json") if task_run_filter else None
-            ),
-            "deployments": (
-                deployment_filter.model_dump(mode="json") if deployment_filter else None
-            ),
-            "work_pools": (
-                work_pool_filter.model_dump(mode="json") if work_pool_filter else None
-            ),
-            "work_queues": (
-                work_queue_filter.model_dump(mode="json") if work_queue_filter else None
-            ),
-            "sort": sort,
-            "limit": limit,
-            "offset": offset,
-        }
-
-        response = await self._client.post("/flows/filter", json=body)
-        return pydantic.TypeAdapter(list[Flow]).validate_python(response.json())
-
-    async def read_flow_by_name(
-        self,
-        flow_name: str,
-    ) -> Flow:
-        """
-        Query the Prefect API for a flow by name.
-
-        Args:
-            flow_name: the name of a flow
-
-        Returns:
-            a fully hydrated Flow model
-        """
-        response = await self._client.get(f"/flows/name/{flow_name}")
-        return Flow.model_validate(response.json())
-
-    async def create_flow_run_from_deployment(
-        self,
-        deployment_id: UUID,
-        *,
-        parameters: Optional[dict[str, Any]] = None,
-        context: Optional[dict[str, Any]] = None,
-        state: Optional[prefect.states.State[Any]] = None,
-        name: Optional[str] = None,
-        tags: Optional[Iterable[str]] = None,
-        idempotency_key: Optional[str] = None,
-        parent_task_run_id: Optional[UUID] = None,
-        work_queue_name: Optional[str] = None,
-        job_variables: Optional[dict[str, Any]] = None,
-        labels: Optional[KeyValueLabelsField] = None,
-    ) -> FlowRun:
-        """
-        Create a flow run for a deployment.
-
-        Args:
-            deployment_id: The deployment ID to create the flow run from
-            parameters: Parameter overrides for this flow run. Merged with the
-                deployment defaults
-            context: Optional run context data
-            state: The initial state for the run. If not provided, defaults to
-                `Scheduled` for now. Should always be a `Scheduled` type.
-            name: An optional name for the flow run. If not provided, the server will
-                generate a name.
-            tags: An optional iterable of tags to apply to the flow run; these tags
-                are merged with the deployment's tags.
-            idempotency_key: Optional idempotency key for creation of the flow run.
-                If the key matches the key of an existing flow run, the existing run will
-                be returned instead of creating a new one.
-            parent_task_run_id: if a subflow run is being created, the placeholder task
-                run identifier in the parent flow
-            work_queue_name: An optional work queue name to add this run to. If not provided,
-                will default to the deployment's set work queue.  If one is provided that does not
-                exist, a new work queue will be created within the deployment's work pool.
-            job_variables: Optional variables that will be supplied to the flow run job.
-
-        Raises:
-            httpx.RequestError: if the Prefect API does not successfully create a run for any reason
-
-        Returns:
-            The flow run model
-        """
-        parameters = parameters or {}
-        context = context or {}
-        state = state or prefect.states.Scheduled()
-        tags = tags or []
-
-        flow_run_create = DeploymentFlowRunCreate(
-            parameters=parameters,
-            context=context,
-            state=state.to_state_create(),
-            tags=list(tags),
-            name=name,
-            idempotency_key=idempotency_key,
-            parent_task_run_id=parent_task_run_id,
-            job_variables=job_variables,
-            labels=labels,
-        )
-
-        # done separately to avoid including this field in payloads sent to older API versions
-        if work_queue_name:
-            flow_run_create.work_queue_name = work_queue_name
-
-        response = await self._client.post(
-            f"/deployments/{deployment_id}/create_flow_run",
-            json=flow_run_create.model_dump(mode="json", exclude_unset=True),
-        )
-        return FlowRun.model_validate(response.json())
-
-    async def create_flow_run(
-        self,
-        flow: "FlowObject[Any, R]",
-        name: Optional[str] = None,
-        parameters: Optional[dict[str, Any]] = None,
-        context: Optional[dict[str, Any]] = None,
-        tags: Optional[Iterable[str]] = None,
-        parent_task_run_id: Optional[UUID] = None,
-        state: Optional["prefect.states.State[R]"] = None,
-    ) -> FlowRun:
-        """
-        Create a flow run for a flow.
-
-        Args:
-            flow: The flow model to create the flow run for
-            name: An optional name for the flow run
-            parameters: Parameter overrides for this flow run.
-            context: Optional run context data
-            tags: a list of tags to apply to this flow run
-            parent_task_run_id: if a subflow run is being created, the placeholder task
-                run identifier in the parent flow
-            state: The initial state for the run. If not provided, defaults to
-                `Scheduled` for now. Should always be a `Scheduled` type.
-
-        Raises:
-            httpx.RequestError: if the Prefect API does not successfully create a run for any reason
-
-        Returns:
-            The flow run model
-        """
-        parameters = parameters or {}
-        context = context or {}
-
-        if state is None:
-            state = prefect.states.Pending()
-
-        # Retrieve the flow id
-        flow_id = await self.create_flow(flow)
-
-        flow_run_create = FlowRunCreate(
-            flow_id=flow_id,
-            flow_version=flow.version,
-            name=name,
-            parameters=parameters,
-            context=context,
-            tags=list(tags or []),
-            parent_task_run_id=parent_task_run_id,
-            state=state.to_state_create(),
-            empirical_policy=FlowRunPolicy(
-                retries=flow.retries,
-                retry_delay=int(flow.retry_delay_seconds or 0),
-            ),
-        )
-
-        flow_run_create_json = flow_run_create.model_dump(mode="json")
-        response = await self._client.post("/flow_runs/", json=flow_run_create_json)
-        flow_run = FlowRun.model_validate(response.json())
-
-        # Restore the parameters to the local objects to retain expectations about
-        # Python objects
-        flow_run.parameters = parameters
-
-        return flow_run
-
-    async def update_flow_run(
-        self,
-        flow_run_id: UUID,
-        flow_version: Optional[str] = None,
-        parameters: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
-        tags: Optional[Iterable[str]] = None,
-        empirical_policy: Optional[FlowRunPolicy] = None,
-        infrastructure_pid: Optional[str] = None,
-        job_variables: Optional[dict[str, Any]] = None,
-    ) -> httpx.Response:
-        """
-        Update a flow run's details.
-
-        Args:
-            flow_run_id: The identifier for the flow run to update.
-            flow_version: A new version string for the flow run.
-            parameters: A dictionary of parameter values for the flow run. This will not
-                be merged with any existing parameters.
-            name: A new name for the flow run.
-            empirical_policy: A new flow run orchestration policy. This will not be
-                merged with any existing policy.
-            tags: An iterable of new tags for the flow run. These will not be merged with
-                any existing tags.
-            infrastructure_pid: The id of flow run as returned by an
-                infrastructure block.
-
-        Returns:
-            an `httpx.Response` object from the PATCH request
-        """
-        params: dict[str, Any] = {}
-        if flow_version is not None:
-            params["flow_version"] = flow_version
-        if parameters is not None:
-            params["parameters"] = parameters
-        if name is not None:
-            params["name"] = name
-        if tags is not None:
-            params["tags"] = tags
-        if empirical_policy is not None:
-            params["empirical_policy"] = empirical_policy
-        if infrastructure_pid:
-            params["infrastructure_pid"] = infrastructure_pid
-        if job_variables is not None:
-            params["job_variables"] = job_variables
-
-        flow_run_data = FlowRunUpdate(**params)
-
-        return await self._client.patch(
-            f"/flow_runs/{flow_run_id}",
-            json=flow_run_data.model_dump(mode="json", exclude_unset=True),
-        )
-
-    async def delete_flow_run(
-        self,
-        flow_run_id: UUID,
-    ) -> None:
-        """
-        Delete a flow run by UUID.
-
-        Args:
-            flow_run_id: The flow run UUID of interest.
-        Raises:
-            prefect.exceptions.ObjectNotFound: If request returns 404
-            httpx.RequestError: If requests fails
-        """
-        try:
-            await self._client.delete(f"/flow_runs/{flow_run_id}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
     async def create_work_queue(
         self,
         name: str,
@@ -1089,1003 +742,37 @@ class PrefectClient(
             else:
                 raise
 
-    async def create_block_type(self, block_type: BlockTypeCreate) -> BlockType:
-        """
-        Create a block type in the Prefect API.
-        """
-        try:
-            response = await self._client.post(
-                "/block_types/",
-                json=block_type.model_dump(
-                    mode="json", exclude_unset=True, exclude={"id"}
-                ),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_409_CONFLICT:
-                raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e
-            else:
-                raise
-        return BlockType.model_validate(response.json())
-
-    async def create_block_schema(self, block_schema: BlockSchemaCreate) -> BlockSchema:
-        """
-        Create a block schema in the Prefect API.
-        """
-        try:
-            response = await self._client.post(
-                "/block_schemas/",
-                json=block_schema.model_dump(
-                    mode="json",
-                    exclude_unset=True,
-                    exclude={"id", "block_type", "checksum"},
-                ),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_409_CONFLICT:
-                raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e
-            else:
-                raise
-        return BlockSchema.model_validate(response.json())
+    async def set_task_run_name(self, task_run_id: UUID, name: str) -> httpx.Response:
+        task_run_data = TaskRunUpdate(name=name)
+        return await self._client.patch(
+            f"/task_runs/{task_run_id}",
+            json=task_run_data.model_dump(mode="json", exclude_unset=True),
+        )
 
-    async def create_block_document(
+    async def create_task_run(
         self,
-        block_document: Union[BlockDocument, BlockDocumentCreate],
-        include_secrets: bool = True,
-    ) -> BlockDocument:
+        task: "TaskObject[P, R]",
+        flow_run_id: Optional[UUID],
+        dynamic_key: str,
+        id: Optional[UUID] = None,
+        name: Optional[str] = None,
+        extra_tags: Optional[Iterable[str]] = None,
+        state: Optional[prefect.states.State[R]] = None,
+        task_inputs: Optional[
+            dict[
+                str,
+                list[
+                    Union[
+                        TaskRunResult,
+                        Parameter,
+                        Constant,
+                    ]
+                ],
+            ]
+        ] = None,
+    ) -> TaskRun:
         """
-        Create a block document in the Prefect API. This data is used to configure a
-        corresponding Block.
-
-        Args:
-            include_secrets (bool): whether to include secret values
-                on the stored Block, corresponding to Pydantic's `SecretStr` and
-                `SecretBytes` fields. Note Blocks may not work as expected if
-                this is set to `False`.
-        """
-        block_document_data = block_document.model_dump(
-            mode="json",
-            exclude_unset=True,
-            exclude={"id", "block_schema", "block_type"},
-            context={"include_secrets": include_secrets},
-            serialize_as_any=True,
-        )
-        try:
-            response = await self._client.post(
-                "/block_documents/",
-                json=block_document_data,
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_409_CONFLICT:
-                raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e
-            else:
-                raise
-        return BlockDocument.model_validate(response.json())
-
-    async def update_block_document(
-        self,
-        block_document_id: UUID,
-        block_document: BlockDocumentUpdate,
-    ) -> None:
-        """
-        Update a block document in the Prefect API.
-        """
-        try:
-            await self._client.patch(
-                f"/block_documents/{block_document_id}",
-                json=block_document.model_dump(
-                    mode="json",
-                    exclude_unset=True,
-                    include={"data", "merge_existing_data", "block_schema_id"},
-                ),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-    async def delete_block_document(self, block_document_id: UUID) -> None:
-        """
-        Delete a block document.
-        """
-        try:
-            await self._client.delete(f"/block_documents/{block_document_id}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == 404:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-    async def read_block_type_by_slug(self, slug: str) -> BlockType:
-        """
-        Read a block type by its slug.
-        """
-        try:
-            response = await self._client.get(f"/block_types/slug/{slug}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return BlockType.model_validate(response.json())
-
-    async def read_block_schema_by_checksum(
-        self, checksum: str, version: Optional[str] = None
-    ) -> BlockSchema:
-        """
-        Look up a block schema checksum
-        """
-        try:
-            url = f"/block_schemas/checksum/{checksum}"
-            if version is not None:
-                url = f"{url}?version={version}"
-            response = await self._client.get(url)
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return BlockSchema.model_validate(response.json())
-
-    async def update_block_type(
-        self, block_type_id: UUID, block_type: BlockTypeUpdate
-    ) -> None:
-        """
-        Update a block document in the Prefect API.
-        """
-        try:
-            await self._client.patch(
-                f"/block_types/{block_type_id}",
-                json=block_type.model_dump(
-                    mode="json",
-                    exclude_unset=True,
-                    include=BlockTypeUpdate.updatable_fields(),
-                ),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-    async def delete_block_type(self, block_type_id: UUID) -> None:
-        """
-        Delete a block type.
-        """
-        try:
-            await self._client.delete(f"/block_types/{block_type_id}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == 404:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            elif (
-                e.response.status_code == status.HTTP_403_FORBIDDEN
-                and e.response.json()["detail"]
-                == "protected block types cannot be deleted."
-            ):
-                raise prefect.exceptions.ProtectedBlockError(
-                    "Protected block types cannot be deleted."
-                ) from e
-            else:
-                raise
-
-    async def read_block_types(self) -> list[BlockType]:
-        """
-        Read all block types
-        Raises:
-            httpx.RequestError: if the block types were not found
-
-        Returns:
-            List of BlockTypes.
-        """
-        response = await self._client.post("/block_types/filter", json={})
-        return pydantic.TypeAdapter(list[BlockType]).validate_python(response.json())
-
-    async def read_block_schemas(self) -> list[BlockSchema]:
-        """
-        Read all block schemas
-        Raises:
-            httpx.RequestError: if a valid block schema was not found
-
-        Returns:
-            A BlockSchema.
-        """
-        response = await self._client.post("/block_schemas/filter", json={})
-        return pydantic.TypeAdapter(list[BlockSchema]).validate_python(response.json())
-
-    async def get_most_recent_block_schema_for_block_type(
-        self,
-        block_type_id: UUID,
-    ) -> Optional[BlockSchema]:
-        """
-        Fetches the most recent block schema for a specified block type ID.
-
-        Args:
-            block_type_id: The ID of the block type.
-
-        Raises:
-            httpx.RequestError: If the request fails for any reason.
-
-        Returns:
-            The most recent block schema or None.
-        """
-        try:
-            response = await self._client.post(
-                "/block_schemas/filter",
-                json={
-                    "block_schemas": {"block_type_id": {"any_": [str(block_type_id)]}},
-                    "limit": 1,
-                },
-            )
-        except httpx.HTTPStatusError:
-            raise
-        return (
-            BlockSchema.model_validate(response.json()[0]) if response.json() else None
-        )
-
-    async def read_block_document(
-        self,
-        block_document_id: UUID,
-        include_secrets: bool = True,
-    ) -> BlockDocument:
-        """
-        Read the block document with the specified ID.
-
-        Args:
-            block_document_id: the block document id
-            include_secrets (bool): whether to include secret values
-                on the Block, corresponding to Pydantic's `SecretStr` and
-                `SecretBytes` fields. These fields are automatically obfuscated
-                by Pydantic, but users can additionally choose not to receive
-                their values from the API. Note that any business logic on the
-                Block may not work if this is `False`.
-
-        Raises:
-            httpx.RequestError: if the block document was not found for any reason
-
-        Returns:
-            A block document or None.
-        """
-        assert (
-            block_document_id is not None
-        ), "Unexpected ID on block document. Was it persisted?"
-        try:
-            response = await self._client.get(
-                f"/block_documents/{block_document_id}",
-                params=dict(include_secrets=include_secrets),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return BlockDocument.model_validate(response.json())
-
-    async def read_block_document_by_name(
-        self,
-        name: str,
-        block_type_slug: str,
-        include_secrets: bool = True,
-    ) -> BlockDocument:
-        """
-        Read the block document with the specified name that corresponds to a
-        specific block type name.
-
-        Args:
-            name: The block document name.
-            block_type_slug: The block type slug.
-            include_secrets (bool): whether to include secret values
-                on the Block, corresponding to Pydantic's `SecretStr` and
-                `SecretBytes` fields. These fields are automatically obfuscated
-                by Pydantic, but users can additionally choose not to receive
-                their values from the API. Note that any business logic on the
-                Block may not work if this is `False`.
-
-        Raises:
-            httpx.RequestError: if the block document was not found for any reason
-
-        Returns:
-            A block document or None.
-        """
-        try:
-            response = await self._client.get(
-                f"/block_types/slug/{block_type_slug}/block_documents/name/{name}",
-                params=dict(include_secrets=include_secrets),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return BlockDocument.model_validate(response.json())
-
-    async def read_block_documents(
-        self,
-        block_schema_type: Optional[str] = None,
-        offset: Optional[int] = None,
-        limit: Optional[int] = None,
-        include_secrets: bool = True,
-    ) -> list[BlockDocument]:
-        """
-        Read block documents
-
-        Args:
-            block_schema_type: an optional block schema type
-            offset: an offset
-            limit: the number of blocks to return
-            include_secrets (bool): whether to include secret values
-                on the Block, corresponding to Pydantic's `SecretStr` and
-                `SecretBytes` fields. These fields are automatically obfuscated
-                by Pydantic, but users can additionally choose not to receive
-                their values from the API. Note that any business logic on the
-                Block may not work if this is `False`.
-
-        Returns:
-            A list of block documents
-        """
-        response = await self._client.post(
-            "/block_documents/filter",
-            json=dict(
-                block_schema_type=block_schema_type,
-                offset=offset,
-                limit=limit,
-                include_secrets=include_secrets,
-            ),
-        )
-        return pydantic.TypeAdapter(list[BlockDocument]).validate_python(
-            response.json()
-        )
-
-    async def read_block_documents_by_type(
-        self,
-        block_type_slug: str,
-        offset: Optional[int] = None,
-        limit: Optional[int] = None,
-        include_secrets: bool = True,
-    ) -> list[BlockDocument]:
-        """Retrieve block documents by block type slug.
-
-        Args:
-            block_type_slug: The block type slug.
-            offset: an offset
-            limit: the number of blocks to return
-            include_secrets: whether to include secret values
-
-        Returns:
-            A list of block documents
-        """
-        response = await self._client.get(
-            f"/block_types/slug/{block_type_slug}/block_documents",
-            params=dict(
-                offset=offset,
-                limit=limit,
-                include_secrets=include_secrets,
-            ),
-        )
-
-        return pydantic.TypeAdapter(list[BlockDocument]).validate_python(
-            response.json()
-        )
-
-    async def create_deployment(
-        self,
-        flow_id: UUID,
-        name: str,
-        version: Optional[str] = None,
-        schedules: Optional[list[DeploymentScheduleCreate]] = None,
-        concurrency_limit: Optional[int] = None,
-        concurrency_options: Optional[ConcurrencyOptions] = None,
-        parameters: Optional[dict[str, Any]] = None,
-        description: Optional[str] = None,
-        work_queue_name: Optional[str] = None,
-        work_pool_name: Optional[str] = None,
-        tags: Optional[list[str]] = None,
-        storage_document_id: Optional[UUID] = None,
-        path: Optional[str] = None,
-        entrypoint: Optional[str] = None,
-        infrastructure_document_id: Optional[UUID] = None,
-        parameter_openapi_schema: Optional[dict[str, Any]] = None,
-        paused: Optional[bool] = None,
-        pull_steps: Optional[list[dict[str, Any]]] = None,
-        enforce_parameter_schema: Optional[bool] = None,
-        job_variables: Optional[dict[str, Any]] = None,
-    ) -> UUID:
-        """
-        Create a deployment.
-
-        Args:
-            flow_id: the flow ID to create a deployment for
-            name: the name of the deployment
-            version: an optional version string for the deployment
-            tags: an optional list of tags to apply to the deployment
-            storage_document_id: an reference to the storage block document
-                used for the deployed flow
-            infrastructure_document_id: an reference to the infrastructure block document
-                to use for this deployment
-            job_variables: A dictionary of dot delimited infrastructure overrides that
-                will be applied at runtime; for example `env.CONFIG_KEY=config_value` or
-                `namespace='prefect'`. This argument was previously named `infra_overrides`.
-                Both arguments are supported for backwards compatibility.
-
-        Raises:
-            httpx.RequestError: if the deployment was not created for any reason
-
-        Returns:
-            the ID of the deployment in the backend
-        """
-
-        if parameter_openapi_schema is None:
-            parameter_openapi_schema = {}
-        deployment_create = DeploymentCreate(
-            flow_id=flow_id,
-            name=name,
-            version=version,
-            parameters=dict(parameters or {}),
-            tags=list(tags or []),
-            work_queue_name=work_queue_name,
-            description=description,
-            storage_document_id=storage_document_id,
-            path=path,
-            entrypoint=entrypoint,
-            infrastructure_document_id=infrastructure_document_id,
-            job_variables=dict(job_variables or {}),
-            parameter_openapi_schema=parameter_openapi_schema,
-            paused=paused,
-            schedules=schedules or [],
-            concurrency_limit=concurrency_limit,
-            concurrency_options=concurrency_options,
-            pull_steps=pull_steps,
-            enforce_parameter_schema=enforce_parameter_schema,
-        )
-
-        if work_pool_name is not None:
-            deployment_create.work_pool_name = work_pool_name
-
-        # Exclude newer fields that are not set to avoid compatibility issues
-        exclude = {
-            field
-            for field in ["work_pool_name", "work_queue_name"]
-            if field not in deployment_create.model_fields_set
-        }
-
-        if deployment_create.paused is None:
-            exclude.add("paused")
-
-        if deployment_create.pull_steps is None:
-            exclude.add("pull_steps")
-
-        if deployment_create.enforce_parameter_schema is None:
-            exclude.add("enforce_parameter_schema")
-
-        json = deployment_create.model_dump(mode="json", exclude=exclude)
-        response = await self._client.post(
-            "/deployments/",
-            json=json,
-        )
-        deployment_id = response.json().get("id")
-        if not deployment_id:
-            raise httpx.RequestError(f"Malformed response: {response}")
-
-        return UUID(deployment_id)
-
-    async def set_deployment_paused_state(
-        self, deployment_id: UUID, paused: bool
-    ) -> None:
-        await self._client.patch(
-            f"/deployments/{deployment_id}", json={"paused": paused}
-        )
-
-    async def update_deployment(
-        self,
-        deployment_id: UUID,
-        deployment: DeploymentUpdate,
-    ) -> None:
-        await self._client.patch(
-            f"/deployments/{deployment_id}",
-            json=deployment.model_dump(mode="json", exclude_unset=True),
-        )
-
-    async def _create_deployment_from_schema(self, schema: DeploymentCreate) -> UUID:
-        """
-        Create a deployment from a prepared `DeploymentCreate` schema.
-        """
-        # TODO: We are likely to remove this method once we have considered the
-        #       packaging interface for deployments further.
-        response = await self._client.post(
-            "/deployments/", json=schema.model_dump(mode="json")
-        )
-        deployment_id = response.json().get("id")
-        if not deployment_id:
-            raise httpx.RequestError(f"Malformed response: {response}")
-
-        return UUID(deployment_id)
-
-    async def read_deployment(
-        self,
-        deployment_id: Union[UUID, str],
-    ) -> DeploymentResponse:
-        """
-        Query the Prefect API for a deployment by id.
-
-        Args:
-            deployment_id: the deployment ID of interest
-
-        Returns:
-            a [Deployment model][prefect.client.schemas.objects.Deployment] representation of the deployment
-        """
-        if not isinstance(deployment_id, UUID):
-            try:
-                deployment_id = UUID(deployment_id)
-            except ValueError:
-                raise ValueError(f"Invalid deployment ID: {deployment_id}")
-
-        try:
-            response = await self._client.get(f"/deployments/{deployment_id}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return DeploymentResponse.model_validate(response.json())
-
-    async def read_deployment_by_name(
-        self,
-        name: str,
-    ) -> DeploymentResponse:
-        """
-        Query the Prefect API for a deployment by name.
-
-        Args:
-            name: A deployed flow's name: <FLOW_NAME>/<DEPLOYMENT_NAME>
-
-        Raises:
-            prefect.exceptions.ObjectNotFound: If request returns 404
-            httpx.RequestError: If request fails
-
-        Returns:
-            a Deployment model representation of the deployment
-        """
-        try:
-            response = await self._client.get(f"/deployments/name/{name}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                from prefect.utilities.text import fuzzy_match_string
-
-                deployments = await self.read_deployments()
-                flow_name_map = {
-                    flow.id: flow.name
-                    for flow in await asyncio.gather(
-                        *[
-                            self.read_flow(flow_id)
-                            for flow_id in {d.flow_id for d in deployments}
-                        ]
-                    )
-                }
-
-                raise prefect.exceptions.ObjectNotFound(
-                    http_exc=e,
-                    help_message=(
-                        f"Deployment {name!r} not found; did you mean {fuzzy_match!r}?"
-                        if (
-                            fuzzy_match := fuzzy_match_string(
-                                name,
-                                [
-                                    f"{flow_name_map[d.flow_id]}/{d.name}"
-                                    for d in deployments
-                                ],
-                            )
-                        )
-                        else f"Deployment {name!r} not found. Try `prefect deployment ls` to find available deployments."
-                    ),
-                ) from e
-            else:
-                raise
-
-        return DeploymentResponse.model_validate(response.json())
-
-    async def read_deployments(
-        self,
-        *,
-        flow_filter: Optional[FlowFilter] = None,
-        flow_run_filter: Optional[FlowRunFilter] = None,
-        task_run_filter: Optional[TaskRunFilter] = None,
-        deployment_filter: Optional[DeploymentFilter] = None,
-        work_pool_filter: Optional[WorkPoolFilter] = None,
-        work_queue_filter: Optional[WorkQueueFilter] = None,
-        limit: Optional[int] = None,
-        sort: Optional[DeploymentSort] = None,
-        offset: int = 0,
-    ) -> list[DeploymentResponse]:
-        """
-        Query the Prefect API for deployments. Only deployments matching all
-        the provided criteria will be returned.
-
-        Args:
-            flow_filter: filter criteria for flows
-            flow_run_filter: filter criteria for flow runs
-            task_run_filter: filter criteria for task runs
-            deployment_filter: filter criteria for deployments
-            work_pool_filter: filter criteria for work pools
-            work_queue_filter: filter criteria for work pool queues
-            limit: a limit for the deployment query
-            offset: an offset for the deployment query
-
-        Returns:
-            a list of Deployment model representations
-                of the deployments
-        """
-        body: dict[str, Any] = {
-            "flows": flow_filter.model_dump(mode="json") if flow_filter else None,
-            "flow_runs": (
-                flow_run_filter.model_dump(mode="json", exclude_unset=True)
-                if flow_run_filter
-                else None
-            ),
-            "task_runs": (
-                task_run_filter.model_dump(mode="json") if task_run_filter else None
-            ),
-            "deployments": (
-                deployment_filter.model_dump(mode="json") if deployment_filter else None
-            ),
-            "work_pools": (
-                work_pool_filter.model_dump(mode="json") if work_pool_filter else None
-            ),
-            "work_pool_queues": (
-                work_queue_filter.model_dump(mode="json") if work_queue_filter else None
-            ),
-            "limit": limit,
-            "offset": offset,
-            "sort": sort,
-        }
-
-        response = await self._client.post("/deployments/filter", json=body)
-        return pydantic.TypeAdapter(list[DeploymentResponse]).validate_python(
-            response.json()
-        )
-
-    async def delete_deployment(
-        self,
-        deployment_id: UUID,
-    ) -> None:
-        """
-        Delete deployment by id.
-
-        Args:
-            deployment_id: The deployment id of interest.
-        Raises:
-            prefect.exceptions.ObjectNotFound: If request returns 404
-            httpx.RequestError: If requests fails
-        """
-        try:
-            await self._client.delete(f"/deployments/{deployment_id}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == 404:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-    async def create_deployment_schedules(
-        self,
-        deployment_id: UUID,
-        schedules: list[tuple[SCHEDULE_TYPES, bool]],
-    ) -> list[DeploymentSchedule]:
-        """
-        Create deployment schedules.
-
-        Args:
-            deployment_id: the deployment ID
-            schedules: a list of tuples containing the schedule to create
-                       and whether or not it should be active.
-
-        Raises:
-            httpx.RequestError: if the schedules were not created for any reason
-
-        Returns:
-            the list of schedules created in the backend
-        """
-        deployment_schedule_create = [
-            DeploymentScheduleCreate(schedule=schedule[0], active=schedule[1])
-            for schedule in schedules
-        ]
-
-        json = [
-            deployment_schedule_create.model_dump(mode="json")
-            for deployment_schedule_create in deployment_schedule_create
-        ]
-        response = await self._client.post(
-            f"/deployments/{deployment_id}/schedules", json=json
-        )
-        return pydantic.TypeAdapter(list[DeploymentSchedule]).validate_python(
-            response.json()
-        )
-
-    async def read_deployment_schedules(
-        self,
-        deployment_id: UUID,
-    ) -> list[DeploymentSchedule]:
-        """
-        Query the Prefect API for a deployment's schedules.
-
-        Args:
-            deployment_id: the deployment ID
-
-        Returns:
-            a list of DeploymentSchedule model representations of the deployment schedules
-        """
-        try:
-            response = await self._client.get(f"/deployments/{deployment_id}/schedules")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return pydantic.TypeAdapter(list[DeploymentSchedule]).validate_python(
-            response.json()
-        )
-
-    async def update_deployment_schedule(
-        self,
-        deployment_id: UUID,
-        schedule_id: UUID,
-        active: Optional[bool] = None,
-        schedule: Optional[SCHEDULE_TYPES] = None,
-    ) -> None:
-        """
-        Update a deployment schedule by ID.
-
-        Args:
-            deployment_id: the deployment ID
-            schedule_id: the deployment schedule ID of interest
-            active: whether or not the schedule should be active
-            schedule: the cron, rrule, or interval schedule this deployment schedule should use
-        """
-        kwargs: dict[str, Any] = {}
-        if active is not None:
-            kwargs["active"] = active
-        if schedule is not None:
-            kwargs["schedule"] = schedule
-
-        deployment_schedule_update = DeploymentScheduleUpdate(**kwargs)
-        json = deployment_schedule_update.model_dump(mode="json", exclude_unset=True)
-
-        try:
-            await self._client.patch(
-                f"/deployments/{deployment_id}/schedules/{schedule_id}", json=json
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-    async def delete_deployment_schedule(
-        self,
-        deployment_id: UUID,
-        schedule_id: UUID,
-    ) -> None:
-        """
-        Delete a deployment schedule.
-
-        Args:
-            deployment_id: the deployment ID
-            schedule_id: the ID of the deployment schedule to delete.
-
-        Raises:
-            httpx.RequestError: if the schedules were not deleted for any reason
-        """
-        try:
-            await self._client.delete(
-                f"/deployments/{deployment_id}/schedules/{schedule_id}"
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == 404:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-    async def read_flow_run(self, flow_run_id: UUID) -> FlowRun:
-        """
-        Query the Prefect API for a flow run by id.
-
-        Args:
-            flow_run_id: the flow run ID of interest
-
-        Returns:
-            a Flow Run model representation of the flow run
-        """
-        try:
-            response = await self._client.get(f"/flow_runs/{flow_run_id}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == 404:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return FlowRun.model_validate(response.json())
-
-    async def resume_flow_run(
-        self, flow_run_id: UUID, run_input: Optional[dict[str, Any]] = None
-    ) -> OrchestrationResult[Any]:
-        """
-        Resumes a paused flow run.
-
-        Args:
-            flow_run_id: the flow run ID of interest
-            run_input: the input to resume the flow run with
-
-        Returns:
-            an OrchestrationResult model representation of state orchestration output
-        """
-        try:
-            response = await self._client.post(
-                f"/flow_runs/{flow_run_id}/resume", json={"run_input": run_input}
-            )
-        except httpx.HTTPStatusError:
-            raise
-
-        result: OrchestrationResult[Any] = OrchestrationResult.model_validate(
-            response.json()
-        )
-        return result
-
-    async def read_flow_runs(
-        self,
-        *,
-        flow_filter: Optional[FlowFilter] = None,
-        flow_run_filter: Optional[FlowRunFilter] = None,
-        task_run_filter: Optional[TaskRunFilter] = None,
-        deployment_filter: Optional[DeploymentFilter] = None,
-        work_pool_filter: Optional[WorkPoolFilter] = None,
-        work_queue_filter: Optional[WorkQueueFilter] = None,
-        sort: Optional[FlowRunSort] = None,
-        limit: Optional[int] = None,
-        offset: int = 0,
-    ) -> list[FlowRun]:
-        """
-        Query the Prefect API for flow runs. Only flow runs matching all criteria will
-        be returned.
-
-        Args:
-            flow_filter: filter criteria for flows
-            flow_run_filter: filter criteria for flow runs
-            task_run_filter: filter criteria for task runs
-            deployment_filter: filter criteria for deployments
-            work_pool_filter: filter criteria for work pools
-            work_queue_filter: filter criteria for work pool queues
-            sort: sort criteria for the flow runs
-            limit: limit for the flow run query
-            offset: offset for the flow run query
-
-        Returns:
-            a list of Flow Run model representations
-                of the flow runs
-        """
-        body: dict[str, Any] = {
-            "flows": flow_filter.model_dump(mode="json") if flow_filter else None,
-            "flow_runs": (
-                flow_run_filter.model_dump(mode="json", exclude_unset=True)
-                if flow_run_filter
-                else None
-            ),
-            "task_runs": (
-                task_run_filter.model_dump(mode="json") if task_run_filter else None
-            ),
-            "deployments": (
-                deployment_filter.model_dump(mode="json") if deployment_filter else None
-            ),
-            "work_pools": (
-                work_pool_filter.model_dump(mode="json") if work_pool_filter else None
-            ),
-            "work_pool_queues": (
-                work_queue_filter.model_dump(mode="json") if work_queue_filter else None
-            ),
-            "sort": sort,
-            "limit": limit,
-            "offset": offset,
-        }
-
-        response = await self._client.post("/flow_runs/filter", json=body)
-        return pydantic.TypeAdapter(list[FlowRun]).validate_python(response.json())
-
-    async def set_flow_run_state(
-        self,
-        flow_run_id: Union[UUID, str],
-        state: "prefect.states.State[T]",
-        force: bool = False,
-    ) -> OrchestrationResult[T]:
-        """
-        Set the state of a flow run.
-
-        Args:
-            flow_run_id: the id of the flow run
-            state: the state to set
-            force: if True, disregard orchestration logic when setting the state,
-                forcing the Prefect API to accept the state
-
-        Returns:
-            an OrchestrationResult model representation of state orchestration output
-        """
-        flow_run_id = (
-            flow_run_id if isinstance(flow_run_id, UUID) else UUID(flow_run_id)
-        )
-        state_create = state.to_state_create()
-        state_create.state_details.flow_run_id = flow_run_id
-        state_create.state_details.transition_id = uuid4()
-        try:
-            response = await self._client.post(
-                f"/flow_runs/{flow_run_id}/set_state",
-                json=dict(
-                    state=state_create.model_dump(mode="json", serialize_as_any=True),
-                    force=force,
-                ),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-        result: OrchestrationResult[T] = OrchestrationResult.model_validate(
-            response.json()
-        )
-        return result
-
-    async def read_flow_run_states(
-        self, flow_run_id: UUID
-    ) -> list[prefect.states.State]:
-        """
-        Query for the states of a flow run
-
-        Args:
-            flow_run_id: the id of the flow run
-
-        Returns:
-            a list of State model representations
-                of the flow run states
-        """
-        response = await self._client.get(
-            "/flow_run_states/", params=dict(flow_run_id=str(flow_run_id))
-        )
-        return pydantic.TypeAdapter(list[prefect.states.State]).validate_python(
-            response.json()
-        )
-
-    async def set_flow_run_name(self, flow_run_id: UUID, name: str) -> httpx.Response:
-        flow_run_data = FlowRunUpdate(name=name)
-        return await self._client.patch(
-            f"/flow_runs/{flow_run_id}",
-            json=flow_run_data.model_dump(mode="json", exclude_unset=True),
-        )
-
-    async def set_task_run_name(self, task_run_id: UUID, name: str) -> httpx.Response:
-        task_run_data = TaskRunUpdate(name=name)
-        return await self._client.patch(
-            f"/task_runs/{task_run_id}",
-            json=task_run_data.model_dump(mode="json", exclude_unset=True),
-        )
-
-    async def create_task_run(
-        self,
-        task: "TaskObject[P, R]",
-        flow_run_id: Optional[UUID],
-        dynamic_key: str,
-        id: Optional[UUID] = None,
-        name: Optional[str] = None,
-        extra_tags: Optional[Iterable[str]] = None,
-        state: Optional[prefect.states.State[R]] = None,
-        task_inputs: Optional[
-            dict[
-                str,
-                list[
-                    Union[
-                        TaskRunResult,
-                        Parameter,
-                        Constant,
-                    ]
-                ],
-            ]
-        ] = None,
-    ) -> TaskRun:
-        """
-        Create a task run
+        Create a task run
 
         Args:
             task: The Task to run
@@ -2666,251 +1353,46 @@ class PrefectClient(
 
         return pydantic.TypeAdapter(list[WorkQueue]).validate_python(response.json())
 
-    async def get_scheduled_flow_runs_for_deployments(
-        self,
-        deployment_ids: list[UUID],
-        scheduled_before: Optional[datetime.datetime] = None,
-        limit: Optional[int] = None,
-    ) -> list[FlowRunResponse]:
-        body: dict[str, Any] = dict(deployment_ids=[str(id) for id in deployment_ids])
-        if scheduled_before:
-            body["scheduled_before"] = str(scheduled_before)
-        if limit:
-            body["limit"] = limit
-
-        response = await self._client.post(
-            "/deployments/get_scheduled_flow_runs",
-            json=body,
-        )
-
-        return pydantic.TypeAdapter(list[FlowRunResponse]).validate_python(
-            response.json()
-        )
-
     async def get_scheduled_flow_runs_for_work_pool(
         self,
         work_pool_name: str,
         work_queue_names: Optional[list[str]] = None,
         scheduled_before: Optional[datetime.datetime] = None,
-    ) -> list[WorkerFlowRunResponse]:
-        """
-        Retrieves scheduled flow runs for the provided set of work pool queues.
-
-        Args:
-            work_pool_name: The name of the work pool that the work pool
-                queues are associated with.
-            work_queue_names: The names of the work pool queues from which
-                to get scheduled flow runs.
-            scheduled_before: Datetime used to filter returned flow runs. Flow runs
-                scheduled for after the given datetime string will not be returned.
-
-        Returns:
-            A list of worker flow run responses containing information about the
-            retrieved flow runs.
-        """
-        body: dict[str, Any] = {}
-        if work_queue_names is not None:
-            body["work_queue_names"] = list(work_queue_names)
-        if scheduled_before:
-            body["scheduled_before"] = str(scheduled_before)
-
-        response = await self._client.post(
-            f"/work_pools/{work_pool_name}/get_scheduled_flow_runs",
-            json=body,
-        )
-        return pydantic.TypeAdapter(list[WorkerFlowRunResponse]).validate_python(
-            response.json()
-        )
-
-    async def read_worker_metadata(self) -> dict[str, Any]:
-        """Reads worker metadata stored in Prefect collection registry."""
-        response = await self._client.get("collections/views/aggregate-worker-metadata")
-        response.raise_for_status()
-        return response.json()
-
-    async def create_flow_run_input(
-        self, flow_run_id: UUID, key: str, value: str, sender: Optional[str] = None
-    ) -> None:
-        """
-        Creates a flow run input.
-
-        Args:
-            flow_run_id: The flow run id.
-            key: The input key.
-            value: The input value.
-            sender: The sender of the input.
-        """
-
-        # Initialize the input to ensure that the key is valid.
-        FlowRunInput(flow_run_id=flow_run_id, key=key, value=value)
-
-        response = await self._client.post(
-            f"/flow_runs/{flow_run_id}/input",
-            json={"key": key, "value": value, "sender": sender},
-        )
-        response.raise_for_status()
-
-    async def filter_flow_run_input(
-        self, flow_run_id: UUID, key_prefix: str, limit: int, exclude_keys: set[str]
-    ) -> list[FlowRunInput]:
-        response = await self._client.post(
-            f"/flow_runs/{flow_run_id}/input/filter",
-            json={
-                "prefix": key_prefix,
-                "limit": limit,
-                "exclude_keys": list(exclude_keys),
-            },
-        )
-        response.raise_for_status()
-        return pydantic.TypeAdapter(list[FlowRunInput]).validate_python(response.json())
-
-    async def read_flow_run_input(self, flow_run_id: UUID, key: str) -> str:
-        """
-        Reads a flow run input.
-
-        Args:
-            flow_run_id: The flow run id.
-            key: The input key.
-        """
-        response = await self._client.get(f"/flow_runs/{flow_run_id}/input/{key}")
-        response.raise_for_status()
-        return response.content.decode()
-
-    async def delete_flow_run_input(self, flow_run_id: UUID, key: str) -> None:
-        """
-        Deletes a flow run input.
-
-        Args:
-            flow_run_id: The flow run id.
-            key: The input key.
-        """
-        response = await self._client.delete(f"/flow_runs/{flow_run_id}/input/{key}")
-        response.raise_for_status()
-
-    async def create_automation(self, automation: AutomationCore) -> UUID:
-        """Creates an automation in Prefect Cloud."""
-        response = await self._client.post(
-            "/automations/",
-            json=automation.model_dump(mode="json"),
-        )
-
-        return UUID(response.json()["id"])
-
-    async def update_automation(
-        self, automation_id: UUID, automation: AutomationCore
-    ) -> None:
-        """Updates an automation in Prefect Cloud."""
-        response = await self._client.put(
-            f"/automations/{automation_id}",
-            json=automation.model_dump(mode="json", exclude_unset=True),
-        )
-        response.raise_for_status
-
-    async def read_automations(self) -> list[Automation]:
-        response = await self._client.post("/automations/filter")
-        response.raise_for_status()
-        return pydantic.TypeAdapter(list[Automation]).validate_python(response.json())
-
-    async def find_automation(
-        self, id_or_name: Union[str, UUID]
-    ) -> Optional[Automation]:
-        if isinstance(id_or_name, str):
-            name = id_or_name
-            try:
-                id = UUID(id_or_name)
-            except ValueError:
-                id = None
-        else:
-            id = id_or_name
-            name = str(id)
-
-        if id:
-            try:
-                automation = await self.read_automation(id)
-                return automation
-            except prefect.exceptions.HTTPStatusError as e:
-                if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                    raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-
-        automations = await self.read_automations()
-
-        # Look for it by an exact name
-        for automation in automations:
-            if automation.name == name:
-                return automation
-
-        # Look for it by a case-insensitive name
-        for automation in automations:
-            if automation.name.lower() == name.lower():
-                return automation
-
-        return None
-
-    async def read_automation(
-        self, automation_id: Union[UUID, str]
-    ) -> Optional[Automation]:
-        response = await self._client.get(f"/automations/{automation_id}")
-        if response.status_code == 404:
-            return None
-        response.raise_for_status()
-        return Automation.model_validate(response.json())
-
-    async def read_automations_by_name(self, name: str) -> list[Automation]:
+    ) -> list[WorkerFlowRunResponse]:
         """
-        Query the Prefect API for an automation by name. Only automations matching the provided name will be returned.
+        Retrieves scheduled flow runs for the provided set of work pool queues.
 
         Args:
-            name: the name of the automation to query
+            work_pool_name: The name of the work pool that the work pool
+                queues are associated with.
+            work_queue_names: The names of the work pool queues from which
+                to get scheduled flow runs.
+            scheduled_before: Datetime used to filter returned flow runs. Flow runs
+                scheduled for after the given datetime string will not be returned.
 
         Returns:
-            a list of Automation model representations of the automations
+            A list of worker flow run responses containing information about the
+            retrieved flow runs.
         """
-        automation_filter = filters.AutomationFilter(
-            name=filters.AutomationFilterName(any_=[name])
-        )
+        body: dict[str, Any] = {}
+        if work_queue_names is not None:
+            body["work_queue_names"] = list(work_queue_names)
+        if scheduled_before:
+            body["scheduled_before"] = str(scheduled_before)
 
         response = await self._client.post(
-            "/automations/filter",
-            json={
-                "sort": sorting.AutomationSort.UPDATED_DESC,
-                "automations": automation_filter.model_dump(mode="json")
-                if automation_filter
-                else None,
-            },
-        )
-
-        response.raise_for_status()
-
-        return pydantic.TypeAdapter(list[Automation]).validate_python(response.json())
-
-    async def pause_automation(self, automation_id: UUID) -> None:
-        response = await self._client.patch(
-            f"/automations/{automation_id}", json={"enabled": False}
+            f"/work_pools/{work_pool_name}/get_scheduled_flow_runs",
+            json=body,
         )
-        response.raise_for_status()
-
-    async def resume_automation(self, automation_id: UUID) -> None:
-        response = await self._client.patch(
-            f"/automations/{automation_id}", json={"enabled": True}
+        return pydantic.TypeAdapter(list[WorkerFlowRunResponse]).validate_python(
+            response.json()
         )
-        response.raise_for_status()
-
-    async def delete_automation(self, automation_id: UUID) -> None:
-        response = await self._client.delete(f"/automations/{automation_id}")
-        if response.status_code == 404:
-            return
 
+    async def read_worker_metadata(self) -> dict[str, Any]:
+        """Reads worker metadata stored in Prefect collection registry."""
+        response = await self._client.get("collections/views/aggregate-worker-metadata")
         response.raise_for_status()
-
-    async def read_resource_related_automations(
-        self, resource_id: str
-    ) -> list[Automation]:
-        response = await self._client.get(f"/automations/related-to/{resource_id}")
-        response.raise_for_status()
-        return pydantic.TypeAdapter(list[Automation]).validate_python(response.json())
-
-    async def delete_resource_owned_automations(self, resource_id: str) -> None:
-        await self._client.delete(f"/automations/owned-by/{resource_id}")
+        return response.json()
 
     async def api_version(self) -> str:
         res = await self._client.get("/admin/version")
@@ -2940,18 +1422,6 @@ class PrefectClient(
                 f"Major versions must match."
             )
 
-    async def update_flow_run_labels(
-        self, flow_run_id: UUID, labels: KeyValueLabelsField
-    ) -> None:
-        """
-        Updates the labels of a flow run.
-        """
-
-        response = await self._client.patch(
-            f"/flow_runs/{flow_run_id}/labels", json=labels
-        )
-        response.raise_for_status()
-
     async def __aenter__(self) -> Self:
         """
         Start the client.
@@ -3026,6 +1496,14 @@ class SyncPrefectClient(
     LogClient,
     VariableClient,
     ConcurrencyLimitClient,
+    DeploymentClient,
+    AutomationClient,
+    SlaClient,
+    FlowRunClient,
+    FlowClient,
+    BlocksDocumentClient,
+    BlocksSchemaClient,
+    BlocksTypeClient,
 ):
     """
     A synchronous client for interacting with the [Prefect REST API](/api-ref/rest-api/).
@@ -3284,288 +1762,6 @@ class SyncPrefectClient(
                 f"Major versions must match."
             )
 
-    def create_flow(self, flow: "FlowObject[Any, Any]") -> UUID:
-        """
-        Create a flow in the Prefect API.
-
-        Args:
-            flow: a [Flow][prefect.flows.Flow] object
-
-        Raises:
-            httpx.RequestError: if a flow was not created for any reason
-
-        Returns:
-            the ID of the flow in the backend
-        """
-        return self.create_flow_from_name(flow.name)
-
-    def create_flow_from_name(self, flow_name: str) -> UUID:
-        """
-        Create a flow in the Prefect API.
-
-        Args:
-            flow_name: the name of the new flow
-
-        Raises:
-            httpx.RequestError: if a flow was not created for any reason
-
-        Returns:
-            the ID of the flow in the backend
-        """
-        flow_data = FlowCreate(name=flow_name)
-        response = self._client.post("/flows/", json=flow_data.model_dump(mode="json"))
-
-        flow_id = response.json().get("id")
-        if not flow_id:
-            raise httpx.RequestError(f"Malformed response: {response}")
-
-        # Return the id of the created flow
-        return UUID(flow_id)
-
-    def create_flow_run(
-        self,
-        flow: "FlowObject[Any, R]",
-        name: Optional[str] = None,
-        parameters: Optional[dict[str, Any]] = None,
-        context: Optional[dict[str, Any]] = None,
-        tags: Optional[Iterable[str]] = None,
-        parent_task_run_id: Optional[UUID] = None,
-        state: Optional["prefect.states.State[R]"] = None,
-    ) -> FlowRun:
-        """
-        Create a flow run for a flow.
-
-        Args:
-            flow: The flow model to create the flow run for
-            name: An optional name for the flow run
-            parameters: Parameter overrides for this flow run.
-            context: Optional run context data
-            tags: a list of tags to apply to this flow run
-            parent_task_run_id: if a subflow run is being created, the placeholder task
-                run identifier in the parent flow
-            state: The initial state for the run. If not provided, defaults to
-                `Scheduled` for now. Should always be a `Scheduled` type.
-
-        Raises:
-            httpx.RequestError: if the Prefect API does not successfully create a run for any reason
-
-        Returns:
-            The flow run model
-        """
-        parameters = parameters or {}
-        context = context or {}
-
-        if state is None:
-            state = prefect.states.Pending()
-
-        # Retrieve the flow id
-        flow_id = self.create_flow(flow)
-
-        flow_run_create = FlowRunCreate(
-            flow_id=flow_id,
-            flow_version=flow.version,
-            name=name,
-            parameters=parameters,
-            context=context,
-            tags=list(tags or []),
-            parent_task_run_id=parent_task_run_id,
-            state=state.to_state_create(),
-            empirical_policy=FlowRunPolicy(
-                retries=flow.retries,
-                retry_delay=int(flow.retry_delay_seconds or 0),
-            ),
-        )
-
-        flow_run_create_json = flow_run_create.model_dump(mode="json")
-        response = self._client.post("/flow_runs/", json=flow_run_create_json)
-        flow_run = FlowRun.model_validate(response.json())
-
-        # Restore the parameters to the local objects to retain expectations about
-        # Python objects
-        flow_run.parameters = parameters
-
-        return flow_run
-
-    def update_flow_run(
-        self,
-        flow_run_id: UUID,
-        flow_version: Optional[str] = None,
-        parameters: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
-        tags: Optional[Iterable[str]] = None,
-        empirical_policy: Optional[FlowRunPolicy] = None,
-        infrastructure_pid: Optional[str] = None,
-        job_variables: Optional[dict[str, Any]] = None,
-    ) -> httpx.Response:
-        """
-        Update a flow run's details.
-
-        Args:
-            flow_run_id: The identifier for the flow run to update.
-            flow_version: A new version string for the flow run.
-            parameters: A dictionary of parameter values for the flow run. This will not
-                be merged with any existing parameters.
-            name: A new name for the flow run.
-            empirical_policy: A new flow run orchestration policy. This will not be
-                merged with any existing policy.
-            tags: An iterable of new tags for the flow run. These will not be merged with
-                any existing tags.
-            infrastructure_pid: The id of flow run as returned by an
-                infrastructure block.
-
-        Returns:
-            an `httpx.Response` object from the PATCH request
-        """
-        params: dict[str, Any] = {}
-        if flow_version is not None:
-            params["flow_version"] = flow_version
-        if parameters is not None:
-            params["parameters"] = parameters
-        if name is not None:
-            params["name"] = name
-        if tags is not None:
-            params["tags"] = tags
-        if empirical_policy is not None:
-            params["empirical_policy"] = empirical_policy.model_dump(
-                mode="json", exclude_unset=True
-            )
-        if infrastructure_pid:
-            params["infrastructure_pid"] = infrastructure_pid
-        if job_variables is not None:
-            params["job_variables"] = job_variables
-
-        flow_run_data = FlowRunUpdate(**params)
-
-        return self._client.patch(
-            f"/flow_runs/{flow_run_id}",
-            json=flow_run_data.model_dump(mode="json", exclude_unset=True),
-        )
-
-    def read_flow_run(self, flow_run_id: UUID) -> FlowRun:
-        """
-        Query the Prefect API for a flow run by id.
-
-        Args:
-            flow_run_id: the flow run ID of interest
-
-        Returns:
-            a Flow Run model representation of the flow run
-        """
-        try:
-            response = self._client.get(f"/flow_runs/{flow_run_id}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == 404:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return FlowRun.model_validate(response.json())
-
-    def read_flow_runs(
-        self,
-        *,
-        flow_filter: Optional[FlowFilter] = None,
-        flow_run_filter: Optional[FlowRunFilter] = None,
-        task_run_filter: Optional[TaskRunFilter] = None,
-        deployment_filter: Optional[DeploymentFilter] = None,
-        work_pool_filter: Optional[WorkPoolFilter] = None,
-        work_queue_filter: Optional[WorkQueueFilter] = None,
-        sort: Optional[FlowRunSort] = None,
-        limit: Optional[int] = None,
-        offset: int = 0,
-    ) -> list[FlowRun]:
-        """
-        Query the Prefect API for flow runs. Only flow runs matching all criteria will
-        be returned.
-
-        Args:
-            flow_filter: filter criteria for flows
-            flow_run_filter: filter criteria for flow runs
-            task_run_filter: filter criteria for task runs
-            deployment_filter: filter criteria for deployments
-            work_pool_filter: filter criteria for work pools
-            work_queue_filter: filter criteria for work pool queues
-            sort: sort criteria for the flow runs
-            limit: limit for the flow run query
-            offset: offset for the flow run query
-
-        Returns:
-            a list of Flow Run model representations
-                of the flow runs
-        """
-        body: dict[str, Any] = {
-            "flows": flow_filter.model_dump(mode="json") if flow_filter else None,
-            "flow_runs": (
-                flow_run_filter.model_dump(mode="json", exclude_unset=True)
-                if flow_run_filter
-                else None
-            ),
-            "task_runs": (
-                task_run_filter.model_dump(mode="json") if task_run_filter else None
-            ),
-            "deployments": (
-                deployment_filter.model_dump(mode="json") if deployment_filter else None
-            ),
-            "work_pools": (
-                work_pool_filter.model_dump(mode="json") if work_pool_filter else None
-            ),
-            "work_pool_queues": (
-                work_queue_filter.model_dump(mode="json") if work_queue_filter else None
-            ),
-            "sort": sort,
-            "limit": limit,
-            "offset": offset,
-        }
-
-        response = self._client.post("/flow_runs/filter", json=body)
-        return pydantic.TypeAdapter(list[FlowRun]).validate_python(response.json())
-
-    def set_flow_run_state(
-        self,
-        flow_run_id: UUID,
-        state: "prefect.states.State[T]",
-        force: bool = False,
-    ) -> OrchestrationResult[T]:
-        """
-        Set the state of a flow run.
-
-        Args:
-            flow_run_id: the id of the flow run
-            state: the state to set
-            force: if True, disregard orchestration logic when setting the state,
-                forcing the Prefect API to accept the state
-
-        Returns:
-            an OrchestrationResult model representation of state orchestration output
-        """
-        state_create = state.to_state_create()
-        state_create.state_details.flow_run_id = flow_run_id
-        state_create.state_details.transition_id = uuid4()
-        try:
-            response = self._client.post(
-                f"/flow_runs/{flow_run_id}/set_state",
-                json=dict(
-                    state=state_create.model_dump(mode="json", serialize_as_any=True),
-                    force=force,
-                ),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-        result: OrchestrationResult[T] = OrchestrationResult.model_validate(
-            response.json()
-        )
-        return result
-
-    def set_flow_run_name(self, flow_run_id: UUID, name: str) -> httpx.Response:
-        flow_run_data = FlowRunUpdate(name=name)
-        return self._client.patch(
-            f"/flow_runs/{flow_run_id}",
-            json=flow_run_data.model_dump(mode="json", exclude_unset=True),
-        )
-
     def set_task_run_name(self, task_run_id: UUID, name: str) -> httpx.Response:
         task_run_data = TaskRunUpdate(name=name)
         return self._client.patch(
@@ -3759,102 +1955,3 @@ class SyncPrefectClient(
         return pydantic.TypeAdapter(list[prefect.states.State]).validate_python(
             response.json()
         )
-
-    def read_deployment(
-        self,
-        deployment_id: UUID,
-    ) -> DeploymentResponse:
-        """
-        Query the Prefect API for a deployment by id.
-
-        Args:
-            deployment_id: the deployment ID of interest
-
-        Returns:
-            a [Deployment model][prefect.client.schemas.objects.Deployment] representation of the deployment
-        """
-        try:
-            response = self._client.get(f"/deployments/{deployment_id}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return DeploymentResponse.model_validate(response.json())
-
-    def read_deployment_by_name(
-        self,
-        name: str,
-    ) -> DeploymentResponse:
-        """
-        Query the Prefect API for a deployment by name.
-
-        Args:
-            name: A deployed flow's name: <FLOW_NAME>/<DEPLOYMENT_NAME>
-
-        Raises:
-            prefect.exceptions.ObjectNotFound: If request returns 404
-            httpx.RequestError: If request fails
-
-        Returns:
-            a Deployment model representation of the deployment
-        """
-        try:
-            response = self._client.get(f"/deployments/name/{name}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-        return DeploymentResponse.model_validate(response.json())
-
-    def update_flow_run_labels(
-        self, flow_run_id: UUID, labels: KeyValueLabelsField
-    ) -> None:
-        """
-        Updates the labels of a flow run.
-        """
-        response = self._client.patch(
-            f"/flow_runs/{flow_run_id}/labels",
-            json=labels,
-        )
-        response.raise_for_status()
-
-    def read_block_document_by_name(
-        self,
-        name: str,
-        block_type_slug: str,
-        include_secrets: bool = True,
-    ) -> BlockDocument:
-        """
-        Read the block document with the specified name that corresponds to a
-        specific block type name.
-
-        Args:
-            name: The block document name.
-            block_type_slug: The block type slug.
-            include_secrets (bool): whether to include secret values
-                on the Block, corresponding to Pydantic's `SecretStr` and
-                `SecretBytes` fields. These fields are automatically obfuscated
-                by Pydantic, but users can additionally choose not to receive
-                their values from the API. Note that any business logic on the
-                Block may not work if this is `False`.
-
-        Raises:
-            httpx.RequestError: if the block document was not found for any reason
-
-        Returns:
-            A block document or None.
-        """
-        try:
-            response = self._client.get(
-                f"/block_types/slug/{block_type_slug}/block_documents/name/{name}",
-                params=dict(include_secrets=include_secrets),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return BlockDocument.model_validate(response.json())