prefect-client 2.19.3__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

prefect/client/orchestration.py

@@ -8,7 +8,6 @@ from typing import (
     Dict,
     Iterable,
     List,
-    NoReturn,
     Optional,
     Set,
     Tuple,
@@ -21,35 +20,20 @@ import certifi
 import httpcore
 import httpx
 import pendulum
-from typing_extensions import ParamSpec
-
-from prefect._internal.compatibility.deprecated import (
-    handle_deprecated_infra_overrides_parameter,
-)
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-from prefect.client.schemas import sorting
-from prefect.events import filters
-from prefect.settings import (
-    PREFECT_API_SERVICES_TRIGGERS_ENABLED,
-    PREFECT_EXPERIMENTAL_EVENTS,
-)
-
-if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
-else:
-    import pydantic
-
+import pydantic
 from asgi_lifespan import LifespanManager
-from prefect._vendor.starlette import status
+from starlette import status
+from typing_extensions import ParamSpec
 
 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
+from prefect.client.schemas import FlowRun, OrchestrationResult, TaskRun, sorting
 from prefect.client.schemas.actions import (
     ArtifactCreate,
+    ArtifactUpdate,
     BlockDocumentCreate,
     BlockDocumentUpdate,
     BlockSchemaCreate,
@@ -133,7 +117,7 @@ from prefect.client.schemas.sorting import (
     LogSort,
     TaskRunSort,
 )
-from prefect.deprecated.data_documents import DataDocument
+from prefect.events import filters
 from prefect.events.schemas.automations import Automation, AutomationCore
 from prefect.logging import get_logger
 from prefect.settings import (
@@ -171,12 +155,6 @@ class ServerType(AutoEnum):
     SERVER = AutoEnum.auto()
     CLOUD = AutoEnum.auto()
 
-    def supports_automations(self) -> bool:
-        if self == ServerType.CLOUD:
-            return True
-
-        return PREFECT_EXPERIMENTAL_EVENTS and PREFECT_API_SERVICES_TRIGGERS_ENABLED
-
 
 def get_client(
     httpx_settings: Optional[Dict[str, Any]] = None, sync_client: bool = False
@@ -198,14 +176,39 @@ def get_client(
         client.hello()
     ```
     """
-    ctx = prefect.context.get_settings_context()
+    import prefect.context
+
+    settings_ctx = prefect.context.get_settings_context()
+
+    # try to load clients from a client context, if possible
+    # only load clients that match the provided config / loop
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = None
+
+    if client_ctx := prefect.context.ClientContext.get():
+        if (
+            sync_client
+            and client_ctx.sync_client
+            and client_ctx._httpx_settings == httpx_settings
+        ):
+            return client_ctx.sync_client
+        elif (
+            not sync_client
+            and client_ctx.async_client
+            and client_ctx._httpx_settings == httpx_settings
+            and loop in (client_ctx.async_client._loop, None)
+        ):
+            return client_ctx.async_client
+
     api = PREFECT_API_URL.value()
 
     if not api:
         # create an ephemeral API if none was provided
         from prefect.server.api.server import create_app
 
-        api = create_app(ctx.settings, ephemeral=True)
+        api = create_app(settings_ctx.settings, ephemeral=True)
 
     if sync_client:
         return SyncPrefectClient(
@@ -273,6 +276,7 @@ class PrefectClient:
             httpx_settings["headers"].setdefault("Authorization", f"Bearer {api_key}")
 
         # Context management
+        self._context_stack: int = 0
         self._exit_stack = AsyncExitStack()
         self._ephemeral_app: Optional[ASGIApp] = None
         self.manage_lifespan = True
@@ -453,7 +457,7 @@ class PrefectClient:
         """
         flow_data = FlowCreate(name=flow_name)
         response = await self._client.post(
-            "/flows/", json=flow_data.dict(json_compatible=True)
+            "/flows/", json=flow_data.model_dump(mode="json")
         )
 
         flow_id = response.json().get("id")
@@ -474,7 +478,7 @@ class PrefectClient:
             a [Flow model][prefect.client.schemas.objects.Flow] representation of the flow
         """
         response = await self._client.get(f"/flows/{flow_id}")
-        return Flow.parse_obj(response.json())
+        return Flow.model_validate(response.json())
 
     async def read_flows(
         self,
@@ -508,29 +512,23 @@ class PrefectClient:
             a list of Flow model representations of the flows
         """
         body = {
-            "flows": flow_filter.dict(json_compatible=True) if flow_filter else None,
+            "flows": flow_filter.model_dump(mode="json") if flow_filter else None,
             "flow_runs": (
-                flow_run_filter.dict(json_compatible=True, exclude_unset=True)
+                flow_run_filter.model_dump(mode="json", exclude_unset=True)
                 if flow_run_filter
                 else None
             ),
             "task_runs": (
-                task_run_filter.dict(json_compatible=True) if task_run_filter else None
+                task_run_filter.model_dump(mode="json") if task_run_filter else None
             ),
             "deployments": (
-                deployment_filter.dict(json_compatible=True)
-                if deployment_filter
-                else None
+                deployment_filter.model_dump(mode="json") if deployment_filter else None
             ),
             "work_pools": (
-                work_pool_filter.dict(json_compatible=True)
-                if work_pool_filter
-                else None
+                work_pool_filter.model_dump(mode="json") if work_pool_filter else None
             ),
             "work_queues": (
-                work_queue_filter.dict(json_compatible=True)
-                if work_queue_filter
-                else None
+                work_queue_filter.model_dump(mode="json") if work_queue_filter else None
             ),
             "sort": sort,
             "limit": limit,
@@ -538,7 +536,7 @@ class PrefectClient:
         }
 
         response = await self._client.post("/flows/filter", json=body)
-        return pydantic.parse_obj_as(List[Flow], response.json())
+        return pydantic.TypeAdapter(List[Flow]).validate_python(response.json())
 
     async def read_flow_by_name(
         self,
@@ -554,7 +552,7 @@ class PrefectClient:
             a fully hydrated Flow model
         """
         response = await self._client.get(f"/flows/name/{flow_name}")
-        return Flow.parse_obj(response.json())
+        return Flow.model_validate(response.json())
 
     async def create_flow_run_from_deployment(
         self,
@@ -622,9 +620,9 @@ class PrefectClient:
 
         response = await self._client.post(
             f"/deployments/{deployment_id}/create_flow_run",
-            json=flow_run_create.dict(json_compatible=True, exclude_unset=True),
+            json=flow_run_create.model_dump(mode="json", exclude_unset=True),
         )
-        return FlowRun.parse_obj(response.json())
+        return FlowRun.model_validate(response.json())
 
     async def create_flow_run(
         self,
@@ -680,9 +678,9 @@ class PrefectClient:
             ),
         )
 
-        flow_run_create_json = flow_run_create.dict(json_compatible=True)
+        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.parse_obj(response.json())
+        flow_run = FlowRun.model_validate(response.json())
 
         # Restore the parameters to the local objects to retain expectations about
         # Python objects
@@ -740,7 +738,7 @@ class PrefectClient:
 
         return await self._client.patch(
             f"/flow_runs/{flow_run_id}",
-            json=flow_run_data.dict(json_compatible=True, exclude_unset=True),
+            json=flow_run_data.model_dump(mode="json", exclude_unset=True),
         )
 
     async def delete_flow_run(
@@ -790,7 +788,7 @@ class PrefectClient:
         )
         response = await self._client.post(
             "/concurrency_limits/",
-            json=concurrency_limit_create.dict(json_compatible=True),
+            json=concurrency_limit_create.model_dump(mode="json"),
         )
 
         concurrency_limit_id = response.json().get("id")
@@ -832,7 +830,7 @@ class PrefectClient:
         if not concurrency_limit_id:
             raise httpx.RequestError(f"Malformed response: {response}")
 
-        concurrency_limit = ConcurrencyLimit.parse_obj(response.json())
+        concurrency_limit = ConcurrencyLimit.model_validate(response.json())
         return concurrency_limit
 
     async def read_concurrency_limits(
@@ -857,7 +855,9 @@ class PrefectClient:
         }
 
         response = await self._client.post("/concurrency_limits/filter", json=body)
-        return pydantic.parse_obj_as(List[ConcurrencyLimit], response.json())
+        return pydantic.TypeAdapter(List[ConcurrencyLimit]).validate_python(
+            response.json()
+        )
 
     async def reset_concurrency_limit_by_tag(
         self,
@@ -969,7 +969,7 @@ class PrefectClient:
         if priority is not None:
             create_model.priority = priority
 
-        data = create_model.dict(json_compatible=True)
+        data = create_model.model_dump(mode="json")
         try:
             if work_pool_name is not None:
                 response = await self._client.post(
@@ -984,7 +984,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return WorkQueue.parse_obj(response.json())
+        return WorkQueue.model_validate(response.json())
 
     async def read_work_queue_by_name(
         self,
@@ -1019,7 +1019,7 @@ class PrefectClient:
             else:
                 raise
 
-        return WorkQueue.parse_obj(response.json())
+        return WorkQueue.model_validate(response.json())
 
     async def update_work_queue(self, id: UUID, **kwargs):
         """
@@ -1038,7 +1038,7 @@ class PrefectClient:
         if not kwargs:
             raise ValueError("No fields provided to update.")
 
-        data = WorkQueueUpdate(**kwargs).dict(json_compatible=True, exclude_unset=True)
+        data = WorkQueueUpdate(**kwargs).model_dump(mode="json", exclude_unset=True)
         try:
             await self._client.patch(f"/work_queues/{id}", json=data)
         except httpx.HTTPStatusError as e:
@@ -1085,7 +1085,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return pydantic.parse_obj_as(List[FlowRun], response.json())
+        return pydantic.TypeAdapter(List[FlowRun]).validate_python(response.json())
 
     async def read_work_queue(
         self,
@@ -1111,7 +1111,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return WorkQueue.parse_obj(response.json())
+        return WorkQueue.model_validate(response.json())
 
     async def read_work_queue_status(
         self,
@@ -1137,7 +1137,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return WorkQueueStatusDetail.parse_obj(response.json())
+        return WorkQueueStatusDetail.model_validate(response.json())
 
     async def match_work_queues(
         self,
@@ -1206,8 +1206,8 @@ class PrefectClient:
         try:
             response = await self._client.post(
                 "/block_types/",
-                json=block_type.dict(
-                    json_compatible=True, exclude_unset=True, exclude={"id"}
+                json=block_type.model_dump(
+                    mode="json", exclude_unset=True, exclude={"id"}
                 ),
             )
         except httpx.HTTPStatusError as e:
@@ -1215,7 +1215,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e
             else:
                 raise
-        return BlockType.parse_obj(response.json())
+        return BlockType.model_validate(response.json())
 
     async def create_block_schema(self, block_schema: BlockSchemaCreate) -> BlockSchema:
         """
@@ -1224,8 +1224,8 @@ class PrefectClient:
         try:
             response = await self._client.post(
                 "/block_schemas/",
-                json=block_schema.dict(
-                    json_compatible=True,
+                json=block_schema.model_dump(
+                    mode="json",
                     exclude_unset=True,
                     exclude={"id", "block_type", "checksum"},
                 ),
@@ -1235,7 +1235,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e
             else:
                 raise
-        return BlockSchema.parse_obj(response.json())
+        return BlockSchema.model_validate(response.json())
 
     async def create_block_document(
         self,
@@ -1252,24 +1252,14 @@ class PrefectClient:
                 `SecretBytes` fields. Note Blocks may not work as expected if
                 this is set to `False`.
         """
-        if isinstance(block_document, BlockDocument):
-            block_document = BlockDocumentCreate.parse_obj(
-                block_document.dict(
-                    json_compatible=True,
-                    include_secrets=include_secrets,
-                    exclude_unset=True,
-                    exclude={"id", "block_schema", "block_type"},
-                ),
-            )
-
         try:
             response = await self._client.post(
                 "/block_documents/",
-                json=block_document.dict(
-                    json_compatible=True,
-                    include_secrets=include_secrets,
+                json=block_document.model_dump(
+                    mode="json",
                     exclude_unset=True,
                     exclude={"id", "block_schema", "block_type"},
+                    context={"include_secrets": include_secrets},
                 ),
             )
         except httpx.HTTPStatusError as e:
@@ -1277,7 +1267,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e
             else:
                 raise
-        return BlockDocument.parse_obj(response.json())
+        return BlockDocument.model_validate(response.json())
 
     async def update_block_document(
         self,
@@ -1290,11 +1280,10 @@ class PrefectClient:
         try:
             await self._client.patch(
                 f"/block_documents/{block_document_id}",
-                json=block_document.dict(
-                    json_compatible=True,
+                json=block_document.model_dump(
+                    mode="json",
                     exclude_unset=True,
                     include={"data", "merge_existing_data", "block_schema_id"},
-                    include_secrets=True,
                 ),
             )
         except httpx.HTTPStatusError as e:
@@ -1326,7 +1315,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return BlockType.parse_obj(response.json())
+        return BlockType.model_validate(response.json())
 
     async def read_block_schema_by_checksum(
         self, checksum: str, version: Optional[str] = None
@@ -1344,7 +1333,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return BlockSchema.parse_obj(response.json())
+        return BlockSchema.model_validate(response.json())
 
     async def update_block_type(self, block_type_id: UUID, block_type: BlockTypeUpdate):
         """
@@ -1353,11 +1342,10 @@ class PrefectClient:
         try:
             await self._client.patch(
                 f"/block_types/{block_type_id}",
-                json=block_type.dict(
-                    json_compatible=True,
+                json=block_type.model_dump(
+                    mode="json",
                     exclude_unset=True,
                     include=BlockTypeUpdate.updatable_fields(),
-                    include_secrets=True,
                 ),
             )
         except httpx.HTTPStatusError as e:
@@ -1396,7 +1384,7 @@ class PrefectClient:
             List of BlockTypes.
         """
         response = await self._client.post("/block_types/filter", json={})
-        return pydantic.parse_obj_as(List[BlockType], response.json())
+        return pydantic.TypeAdapter(List[BlockType]).validate_python(response.json())
 
     async def read_block_schemas(self) -> List[BlockSchema]:
         """
@@ -1408,7 +1396,7 @@ class PrefectClient:
             A BlockSchema.
         """
         response = await self._client.post("/block_schemas/filter", json={})
-        return pydantic.parse_obj_as(List[BlockSchema], response.json())
+        return pydantic.TypeAdapter(List[BlockSchema]).validate_python(response.json())
 
     async def get_most_recent_block_schema_for_block_type(
         self,
@@ -1436,7 +1424,9 @@ class PrefectClient:
             )
         except httpx.HTTPStatusError:
             raise
-        return BlockSchema.parse_obj(response.json()[0]) if response.json() else None
+        return (
+            BlockSchema.model_validate(response.json()[0]) if response.json() else None
+        )
 
     async def read_block_document(
         self,
@@ -1474,7 +1464,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return BlockDocument.parse_obj(response.json())
+        return BlockDocument.model_validate(response.json())
 
     async def read_block_document_by_name(
         self,
@@ -1512,7 +1502,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return BlockDocument.parse_obj(response.json())
+        return BlockDocument.model_validate(response.json())
 
     async def read_block_documents(
         self,
@@ -1547,7 +1537,9 @@ class PrefectClient:
                 include_secrets=include_secrets,
             ),
         )
-        return pydantic.parse_obj_as(List[BlockDocument], response.json())
+        return pydantic.TypeAdapter(List[BlockDocument]).validate_python(
+            response.json()
+        )
 
     async def read_block_documents_by_type(
         self,
@@ -1576,26 +1568,27 @@ class PrefectClient:
             ),
         )
 
-        return pydantic.parse_obj_as(List[BlockDocument], response.json())
+        return pydantic.TypeAdapter(List[BlockDocument]).validate_python(
+            response.json()
+        )
 
     async def create_deployment(
         self,
         flow_id: UUID,
         name: str,
-        version: str = None,
-        schedule: SCHEDULE_TYPES = None,
-        schedules: List[DeploymentScheduleCreate] = None,
+        version: Optional[str] = None,
+        schedule: Optional[SCHEDULE_TYPES] = None,
+        schedules: Optional[List[DeploymentScheduleCreate]] = None,
         parameters: Optional[Dict[str, Any]] = None,
-        description: str = None,
-        work_queue_name: str = None,
-        work_pool_name: str = None,
-        tags: List[str] = None,
-        storage_document_id: UUID = None,
-        manifest_path: str = None,
-        path: str = None,
-        entrypoint: str = None,
-        infrastructure_document_id: UUID = None,
-        infra_overrides: Optional[Dict[str, Any]] = None,  # for backwards compat
+        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,
+        manifest_path: Optional[str] = None,
+        path: Optional[str] = None,
+        entrypoint: Optional[str] = None,
+        infrastructure_document_id: Optional[UUID] = None,
         parameter_openapi_schema: Optional[Dict[str, Any]] = None,
         is_schedule_active: Optional[bool] = None,
         paused: Optional[bool] = None,
@@ -1627,8 +1620,9 @@ class PrefectClient:
         Returns:
             the ID of the deployment in the backend
         """
-        jv = handle_deprecated_infra_overrides_parameter(job_variables, infra_overrides)
 
+        if parameter_openapi_schema is None:
+            parameter_openapi_schema = {}
         deployment_create = DeploymentCreate(
             flow_id=flow_id,
             name=name,
@@ -1642,7 +1636,7 @@ class PrefectClient:
             entrypoint=entrypoint,
             manifest_path=manifest_path,  # for backwards compat
             infrastructure_document_id=infrastructure_document_id,
-            job_variables=jv,
+            job_variables=dict(job_variables or {}),
             parameter_openapi_schema=parameter_openapi_schema,
             is_schedule_active=is_schedule_active,
             paused=paused,
@@ -1659,7 +1653,7 @@ class PrefectClient:
         exclude = {
             field
             for field in ["work_pool_name", "work_queue_name"]
-            if field not in deployment_create.__fields_set__
+            if field not in deployment_create.model_fields_set
         }
 
         if deployment_create.is_schedule_active is None:
@@ -1674,7 +1668,7 @@ class PrefectClient:
         if deployment_create.enforce_parameter_schema is None:
             exclude.add("enforce_parameter_schema")
 
-        json = deployment_create.dict(json_compatible=True, exclude=exclude)
+        json = deployment_create.model_dump(mode="json", exclude=exclude)
         response = await self._client.post(
             "/deployments/",
             json=json,
@@ -1732,7 +1726,7 @@ class PrefectClient:
 
         await self._client.patch(
             f"/deployments/{deployment.id}",
-            json=deployment_update.dict(json_compatible=True, exclude=exclude),
+            json=deployment_update.model_dump(mode="json", exclude=exclude),
         )
 
     async def _create_deployment_from_schema(self, schema: DeploymentCreate) -> UUID:
@@ -1742,7 +1736,7 @@ class PrefectClient:
         # 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.dict(json_compatible=True)
+            "/deployments/", json=schema.model_dump(mode="json")
         )
         deployment_id = response.json().get("id")
         if not deployment_id:
@@ -1770,7 +1764,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return DeploymentResponse.parse_obj(response.json())
+        return DeploymentResponse.model_validate(response.json())
 
     async def read_deployment_by_name(
         self,
@@ -1797,19 +1791,19 @@ class PrefectClient:
             else:
                 raise
 
-        return DeploymentResponse.parse_obj(response.json())
+        return DeploymentResponse.model_validate(response.json())
 
     async def read_deployments(
         self,
         *,
-        flow_filter: FlowFilter = None,
-        flow_run_filter: FlowRunFilter = None,
-        task_run_filter: TaskRunFilter = None,
-        deployment_filter: DeploymentFilter = None,
-        work_pool_filter: WorkPoolFilter = None,
-        work_queue_filter: WorkQueueFilter = None,
-        limit: int = None,
-        sort: DeploymentSort = None,
+        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]:
         """
@@ -1831,29 +1825,23 @@ class PrefectClient:
                 of the deployments
         """
         body = {
-            "flows": flow_filter.dict(json_compatible=True) if flow_filter else None,
+            "flows": flow_filter.model_dump(mode="json") if flow_filter else None,
             "flow_runs": (
-                flow_run_filter.dict(json_compatible=True, exclude_unset=True)
+                flow_run_filter.model_dump(mode="json", exclude_unset=True)
                 if flow_run_filter
                 else None
             ),
             "task_runs": (
-                task_run_filter.dict(json_compatible=True) if task_run_filter else None
+                task_run_filter.model_dump(mode="json") if task_run_filter else None
             ),
             "deployments": (
-                deployment_filter.dict(json_compatible=True)
-                if deployment_filter
-                else None
+                deployment_filter.model_dump(mode="json") if deployment_filter else None
             ),
             "work_pools": (
-                work_pool_filter.dict(json_compatible=True)
-                if work_pool_filter
-                else None
+                work_pool_filter.model_dump(mode="json") if work_pool_filter else None
             ),
             "work_pool_queues": (
-                work_queue_filter.dict(json_compatible=True)
-                if work_queue_filter
-                else None
+                work_queue_filter.model_dump(mode="json") if work_queue_filter else None
             ),
             "limit": limit,
             "offset": offset,
@@ -1861,7 +1849,9 @@ class PrefectClient:
         }
 
         response = await self._client.post("/deployments/filter", json=body)
-        return pydantic.parse_obj_as(List[DeploymentResponse], response.json())
+        return pydantic.TypeAdapter(List[DeploymentResponse]).validate_python(
+            response.json()
+        )
 
     async def delete_deployment(
         self,
@@ -1909,13 +1899,15 @@ class PrefectClient:
         ]
 
         json = [
-            deployment_schedule_create.dict(json_compatible=True)
+            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.parse_obj_as(List[DeploymentSchedule], response.json())
+        return pydantic.TypeAdapter(List[DeploymentSchedule]).validate_python(
+            response.json()
+        )
 
     async def read_deployment_schedules(
         self,
@@ -1937,7 +1929,9 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return pydantic.parse_obj_as(List[DeploymentSchedule], response.json())
+        return pydantic.TypeAdapter(List[DeploymentSchedule]).validate_python(
+            response.json()
+        )
 
     async def update_deployment_schedule(
         self,
@@ -1962,7 +1956,7 @@ class PrefectClient:
             kwargs["schedule"] = schedule
 
         deployment_schedule_update = DeploymentScheduleUpdate(**kwargs)
-        json = deployment_schedule_update.dict(json_compatible=True, exclude_unset=True)
+        json = deployment_schedule_update.model_dump(mode="json", exclude_unset=True)
 
         try:
             await self._client.patch(
@@ -2016,7 +2010,7 @@ class PrefectClient:
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return FlowRun.parse_obj(response.json())
+        return FlowRun.model_validate(response.json())
 
     async def resume_flow_run(
         self, flow_run_id: UUID, run_input: Optional[Dict] = None
@@ -2038,7 +2032,7 @@ class PrefectClient:
         except httpx.HTTPStatusError:
             raise
 
-        return OrchestrationResult.parse_obj(response.json())
+        return OrchestrationResult.model_validate(response.json())
 
     async def read_flow_runs(
         self,
@@ -2073,29 +2067,23 @@ class PrefectClient:
                 of the flow runs
         """
         body = {
-            "flows": flow_filter.dict(json_compatible=True) if flow_filter else None,
+            "flows": flow_filter.model_dump(mode="json") if flow_filter else None,
             "flow_runs": (
-                flow_run_filter.dict(json_compatible=True, exclude_unset=True)
+                flow_run_filter.model_dump(mode="json", exclude_unset=True)
                 if flow_run_filter
                 else None
             ),
             "task_runs": (
-                task_run_filter.dict(json_compatible=True) if task_run_filter else None
+                task_run_filter.model_dump(mode="json") if task_run_filter else None
             ),
             "deployments": (
-                deployment_filter.dict(json_compatible=True)
-                if deployment_filter
-                else None
+                deployment_filter.model_dump(mode="json") if deployment_filter else None
             ),
             "work_pools": (
-                work_pool_filter.dict(json_compatible=True)
-                if work_pool_filter
-                else None
+                work_pool_filter.model_dump(mode="json") if work_pool_filter else None
             ),
             "work_pool_queues": (
-                work_queue_filter.dict(json_compatible=True)
-                if work_queue_filter
-                else None
+                work_queue_filter.model_dump(mode="json") if work_queue_filter else None
             ),
             "sort": sort,
             "limit": limit,
@@ -2103,7 +2091,7 @@ class PrefectClient:
         }
 
         response = await self._client.post("/flow_runs/filter", json=body)
-        return pydantic.parse_obj_as(List[FlowRun], response.json())
+        return pydantic.TypeAdapter(List[FlowRun]).validate_python(response.json())
 
     async def set_flow_run_state(
         self,
@@ -2123,13 +2111,17 @@ class PrefectClient:
         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()
+        print(repr(state_create))
         try:
             response = await self._client.post(
                 f"/flow_runs/{flow_run_id}/set_state",
-                json=dict(state=state_create.dict(json_compatible=True), force=force),
+                json=dict(state=state_create.model_dump(mode="json"), force=force),
             )
         except httpx.HTTPStatusError as e:
             if e.response.status_code == status.HTTP_404_NOT_FOUND:
@@ -2137,7 +2129,7 @@ class PrefectClient:
             else:
                 raise
 
-        return OrchestrationResult.parse_obj(response.json())
+        return OrchestrationResult.model_validate(response.json())
 
     async def read_flow_run_states(
         self, flow_run_id: UUID
@@ -2155,13 +2147,15 @@ class PrefectClient:
         response = await self._client.get(
             "/flow_run_states/", params=dict(flow_run_id=str(flow_run_id))
         )
-        return pydantic.parse_obj_as(List[prefect.states.State], response.json())
+        return pydantic.TypeAdapter(List[prefect.states.State]).validate_python(
+            response.json()
+        )
 
     async def set_task_run_name(self, task_run_id: UUID, name: str):
         task_run_data = TaskRunUpdate(name=name)
         return await self._client.patch(
             f"/task_runs/{task_run_id}",
-            json=task_run_data.dict(json_compatible=True, exclude_unset=True),
+            json=task_run_data.model_dump(mode="json", exclude_unset=True),
         )
 
     async def create_task_run(
@@ -2169,6 +2163,7 @@ class PrefectClient:
         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,
@@ -2192,6 +2187,8 @@ class PrefectClient:
             task: The Task to run
             flow_run_id: The flow run id with which to associate the task run
             dynamic_key: A key unique to this particular run of a Task within the flow
+            id: An optional ID for the task run. If not provided, one will be generated
+                server-side.
             name: An optional name for the task run
             extra_tags: an optional list of extra tags to apply to the task run in
                 addition to `task.tags`
@@ -2208,10 +2205,11 @@ class PrefectClient:
             state = prefect.states.Pending()
 
         task_run_data = TaskRunCreate(
+            id=id,
             name=name,
             flow_run_id=flow_run_id,
             task_key=task.task_key,
-            dynamic_key=dynamic_key,
+            dynamic_key=str(dynamic_key),
             tags=list(tags),
             task_version=task.version,
             empirical_policy=TaskRunPolicy(
@@ -2222,11 +2220,10 @@ class PrefectClient:
             state=state.to_state_create(),
             task_inputs=task_inputs or {},
         )
+        content = task_run_data.model_dump_json(exclude={"id"} if id is None else None)
 
-        response = await self._client.post(
-            "/task_runs/", json=task_run_data.dict(json_compatible=True)
-        )
-        return TaskRun.parse_obj(response.json())
+        response = await self._client.post("/task_runs/", content=content)
+        return TaskRun.model_validate(response.json())
 
     async def read_task_run(self, task_run_id: UUID) -> TaskRun:
         """
@@ -2238,8 +2235,14 @@ class PrefectClient:
         Returns:
             a Task Run model representation of the task run
         """
-        response = await self._client.get(f"/task_runs/{task_run_id}")
-        return TaskRun.parse_obj(response.json())
+        try:
+            response = await self._client.get(f"/task_runs/{task_run_id}")
+            return TaskRun.model_validate(response.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 read_task_runs(
         self,
@@ -2270,26 +2273,24 @@ class PrefectClient:
                 of the task runs
         """
         body = {
-            "flows": flow_filter.dict(json_compatible=True) if flow_filter else None,
+            "flows": flow_filter.model_dump(mode="json") if flow_filter else None,
             "flow_runs": (
-                flow_run_filter.dict(json_compatible=True, exclude_unset=True)
+                flow_run_filter.model_dump(mode="json", exclude_unset=True)
                 if flow_run_filter
                 else None
             ),
             "task_runs": (
-                task_run_filter.dict(json_compatible=True) if task_run_filter else None
+                task_run_filter.model_dump(mode="json") if task_run_filter else None
             ),
             "deployments": (
-                deployment_filter.dict(json_compatible=True)
-                if deployment_filter
-                else None
+                deployment_filter.model_dump(mode="json") if deployment_filter else None
             ),
             "sort": sort,
             "limit": limit,
             "offset": offset,
         }
         response = await self._client.post("/task_runs/filter", json=body)
-        return pydantic.parse_obj_as(List[TaskRun], response.json())
+        return pydantic.TypeAdapter(List[TaskRun]).validate_python(response.json())
 
     async def delete_task_run(self, task_run_id: UUID) -> None:
         """
@@ -2331,9 +2332,9 @@ class PrefectClient:
         state_create.state_details.task_run_id = task_run_id
         response = await self._client.post(
             f"/task_runs/{task_run_id}/set_state",
-            json=dict(state=state_create.dict(json_compatible=True), force=force),
+            json=dict(state=state_create.model_dump(mode="json"), force=force),
         )
-        return OrchestrationResult.parse_obj(response.json())
+        return OrchestrationResult.model_validate(response.json())
 
     async def read_task_run_states(
         self, task_run_id: UUID
@@ -2350,7 +2351,9 @@ class PrefectClient:
         response = await self._client.get(
             "/task_run_states/", params=dict(task_run_id=str(task_run_id))
         )
-        return pydantic.parse_obj_as(List[prefect.states.State], response.json())
+        return pydantic.TypeAdapter(List[prefect.states.State]).validate_python(
+            response.json()
+        )
 
     async def create_logs(self, logs: Iterable[Union[LogCreate, dict]]) -> None:
         """
@@ -2360,7 +2363,7 @@ class PrefectClient:
             logs: An iterable of `LogCreate` objects or already json-compatible dicts
         """
         serialized_logs = [
-            log.dict(json_compatible=True) if isinstance(log, LogCreate) else log
+            log.model_dump(mode="json") if isinstance(log, LogCreate) else log
             for log in logs
         ]
         await self._client.post("/logs/", json=serialized_logs)
@@ -2397,7 +2400,7 @@ class PrefectClient:
         )
         response = await self._client.post(
             "/flow_run_notification_policies/",
-            json=policy.dict(json_compatible=True),
+            json=policy.model_dump(mode="json"),
         )
 
         policy_id = response.json().get("id")
@@ -2467,7 +2470,7 @@ class PrefectClient:
         try:
             await self._client.patch(
                 f"/flow_run_notification_policies/{id}",
-                json=policy.dict(json_compatible=True, exclude_unset=True),
+                json=policy.model_dump(mode="json", exclude_unset=True),
             )
         except httpx.HTTPStatusError as e:
             if e.response.status_code == status.HTTP_404_NOT_FOUND:
@@ -2496,7 +2499,7 @@ class PrefectClient:
         """
         body = {
             "flow_run_notification_policy_filter": (
-                flow_run_notification_policy_filter.dict(json_compatible=True)
+                flow_run_notification_policy_filter.model_dump(mode="json")
                 if flow_run_notification_policy_filter
                 else None
             ),
@@ -2506,7 +2509,9 @@ class PrefectClient:
         response = await self._client.post(
             "/flow_run_notification_policies/filter", json=body
         )
-        return pydantic.parse_obj_as(List[FlowRunNotificationPolicy], response.json())
+        return pydantic.TypeAdapter(List[FlowRunNotificationPolicy]).validate_python(
+            response.json()
+        )
 
     async def read_logs(
         self,
@@ -2519,45 +2524,14 @@ class PrefectClient:
         Read flow and task run logs.
         """
         body = {
-            "logs": log_filter.dict(json_compatible=True) if log_filter else None,
+            "logs": log_filter.model_dump(mode="json") if log_filter else None,
             "limit": limit,
             "offset": offset,
             "sort": sort,
         }
 
         response = await self._client.post("/logs/filter", json=body)
-        return pydantic.parse_obj_as(List[Log], response.json())
-
-    async def resolve_datadoc(self, datadoc: DataDocument) -> Any:
-        """
-        Recursively decode possibly nested data documents.
-
-        "server" encoded documents will be retrieved from the server.
-
-        Args:
-            datadoc: The data document to resolve
-
-        Returns:
-            a decoded object, the innermost data
-        """
-        if not isinstance(datadoc, DataDocument):
-            raise TypeError(
-                f"`resolve_datadoc` received invalid type {type(datadoc).__name__}"
-            )
-
-        async def resolve_inner(data):
-            if isinstance(data, bytes):
-                try:
-                    data = DataDocument.parse_raw(data)
-                except pydantic.ValidationError:
-                    return data
-
-            if isinstance(data, DataDocument):
-                return await resolve_inner(data.decode())
-
-            return data
-
-        return await resolve_inner(datadoc)
+        return pydantic.TypeAdapter(List[Log]).validate_python(response.json())
 
     async def send_worker_heartbeat(
         self,
@@ -2601,7 +2575,7 @@ class PrefectClient:
             f"/work_pools/{work_pool_name}/workers/filter",
             json={
                 "worker_filter": (
-                    worker_filter.dict(json_compatible=True, exclude_unset=True)
+                    worker_filter.model_dump(mode="json", exclude_unset=True)
                     if worker_filter
                     else None
                 ),
@@ -2610,7 +2584,7 @@ class PrefectClient:
             },
         )
 
-        return pydantic.parse_obj_as(List[Worker], response.json())
+        return pydantic.TypeAdapter(List[Worker]).validate_python(response.json())
 
     async def read_work_pool(self, work_pool_name: str) -> WorkPool:
         """
@@ -2625,7 +2599,7 @@ class PrefectClient:
         """
         try:
             response = await self._client.get(f"/work_pools/{work_pool_name}")
-            return pydantic.parse_obj_as(WorkPool, response.json())
+            return WorkPool.model_validate(response.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
@@ -2654,13 +2628,11 @@ class PrefectClient:
             "limit": limit,
             "offset": offset,
             "work_pools": (
-                work_pool_filter.dict(json_compatible=True)
-                if work_pool_filter
-                else None
+                work_pool_filter.model_dump(mode="json") if work_pool_filter else None
             ),
         }
         response = await self._client.post("/work_pools/filter", json=body)
-        return pydantic.parse_obj_as(List[WorkPool], response.json())
+        return pydantic.TypeAdapter(List[WorkPool]).validate_python(response.json())
 
     async def create_work_pool(
         self,
@@ -2678,7 +2650,7 @@ class PrefectClient:
         try:
             response = await self._client.post(
                 "/work_pools/",
-                json=work_pool.dict(json_compatible=True, exclude_unset=True),
+                json=work_pool.model_dump(mode="json", exclude_unset=True),
             )
         except httpx.HTTPStatusError as e:
             if e.response.status_code == status.HTTP_409_CONFLICT:
@@ -2686,7 +2658,7 @@ class PrefectClient:
             else:
                 raise
 
-        return pydantic.parse_obj_as(WorkPool, response.json())
+        return WorkPool.model_validate(response.json())
 
     async def update_work_pool(
         self,
@@ -2703,7 +2675,7 @@ class PrefectClient:
         try:
             await self._client.patch(
                 f"/work_pools/{work_pool_name}",
-                json=work_pool.dict(json_compatible=True, exclude_unset=True),
+                json=work_pool.model_dump(mode="json", exclude_unset=True),
             )
         except httpx.HTTPStatusError as e:
             if e.response.status_code == status.HTTP_404_NOT_FOUND:
@@ -2750,7 +2722,7 @@ class PrefectClient:
         """
         json = {
             "work_queues": (
-                work_queue_filter.dict(json_compatible=True, exclude_unset=True)
+                work_queue_filter.model_dump(mode="json", exclude_unset=True)
                 if work_queue_filter
                 else None
             ),
@@ -2772,14 +2744,14 @@ class PrefectClient:
         else:
             response = await self._client.post("/work_queues/filter", json=json)
 
-        return pydantic.parse_obj_as(List[WorkQueue], response.json())
+        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)
@@ -2791,7 +2763,9 @@ class PrefectClient:
             json=body,
         )
 
-        return pydantic.parse_obj_as(List[FlowRunResponse], response.json())
+        return pydantic.TypeAdapter(List[FlowRunResponse]).validate_python(
+            response.json()
+        )
 
     async def get_scheduled_flow_runs_for_work_pool(
         self,
@@ -2824,7 +2798,9 @@ class PrefectClient:
             f"/work_pools/{work_pool_name}/get_scheduled_flow_runs",
             json=body,
         )
-        return pydantic.parse_obj_as(List[WorkerFlowRunResponse], response.json())
+        return pydantic.TypeAdapter(List[WorkerFlowRunResponse]).validate_python(
+            response.json()
+        )
 
     async def create_artifact(
         self,
@@ -2841,10 +2817,29 @@ class PrefectClient:
 
         response = await self._client.post(
             "/artifacts/",
-            json=artifact.dict(json_compatible=True, exclude_unset=True),
+            json=artifact.model_dump(mode="json", exclude_unset=True),
         )
 
-        return pydantic.parse_obj_as(Artifact, response.json())
+        return Artifact.model_validate(response.json())
+
+    async def update_artifact(
+        self,
+        artifact_id: UUID,
+        artifact: ArtifactUpdate,
+    ) -> None:
+        """
+        Updates an artifact
+
+        Args:
+            artifact: Desired values for the updated artifact.
+        Returns:
+            Information about the updated artifact.
+        """
+
+        await self._client.patch(
+            f"/artifacts/{artifact_id}",
+            json=artifact.model_dump(mode="json", exclude_unset=True),
+        )
 
     async def read_artifacts(
         self,
@@ -2871,20 +2866,20 @@ class PrefectClient:
         """
         body = {
             "artifacts": (
-                artifact_filter.dict(json_compatible=True) if artifact_filter else None
+                artifact_filter.model_dump(mode="json") if artifact_filter else None
             ),
             "flow_runs": (
-                flow_run_filter.dict(json_compatible=True) if flow_run_filter else None
+                flow_run_filter.model_dump(mode="json") if flow_run_filter else None
             ),
             "task_runs": (
-                task_run_filter.dict(json_compatible=True) if task_run_filter else None
+                task_run_filter.model_dump(mode="json") if task_run_filter else None
             ),
             "sort": sort,
             "limit": limit,
             "offset": offset,
         }
         response = await self._client.post("/artifacts/filter", json=body)
-        return pydantic.parse_obj_as(List[Artifact], response.json())
+        return pydantic.TypeAdapter(List[Artifact]).validate_python(response.json())
 
     async def read_latest_artifacts(
         self,
@@ -2911,20 +2906,22 @@ class PrefectClient:
         """
         body = {
             "artifacts": (
-                artifact_filter.dict(json_compatible=True) if artifact_filter else None
+                artifact_filter.model_dump(mode="json") if artifact_filter else None
             ),
             "flow_runs": (
-                flow_run_filter.dict(json_compatible=True) if flow_run_filter else None
+                flow_run_filter.model_dump(mode="json") if flow_run_filter else None
             ),
             "task_runs": (
-                task_run_filter.dict(json_compatible=True) if task_run_filter else None
+                task_run_filter.model_dump(mode="json") if task_run_filter else None
             ),
             "sort": sort,
             "limit": limit,
             "offset": offset,
         }
         response = await self._client.post("/artifacts/latest/filter", json=body)
-        return pydantic.parse_obj_as(List[ArtifactCollection], response.json())
+        return pydantic.TypeAdapter(List[ArtifactCollection]).validate_python(
+            response.json()
+        )
 
     async def delete_artifact(self, artifact_id: UUID) -> None:
         """
@@ -2952,7 +2949,7 @@ class PrefectClient:
         """
         response = await self._client.post(
             "/variables/",
-            json=variable.dict(json_compatible=True, exclude_unset=True),
+            json=variable.model_dump(mode="json", exclude_unset=True),
         )
         return Variable(**response.json())
 
@@ -2967,7 +2964,7 @@ class PrefectClient:
         """
         await self._client.patch(
             f"/variables/name/{variable.name}",
-            json=variable.dict(json_compatible=True, exclude_unset=True),
+            json=variable.model_dump(mode="json", exclude_unset=True),
         )
 
     async def read_variable_by_name(self, name: str) -> Optional[Variable]:
@@ -2994,7 +2991,7 @@ class PrefectClient:
     async def read_variables(self, limit: int = None) -> List[Variable]:
         """Reads all variables."""
         response = await self._client.post("/variables/filter", json={"limit": limit})
-        return pydantic.parse_obj_as(List[Variable], response.json())
+        return pydantic.TypeAdapter(List[Variable]).validate_python(response.json())
 
     async def read_worker_metadata(self) -> Dict[str, Any]:
         """Reads worker metadata stored in Prefect collection registry."""
@@ -3027,7 +3024,7 @@ class PrefectClient:
     ) -> UUID:
         response = await self._client.post(
             "/v2/concurrency_limits/",
-            json=concurrency_limit.dict(json_compatible=True, exclude_unset=True),
+            json=concurrency_limit.model_dump(mode="json", exclude_unset=True),
         )
         return UUID(response.json()["id"])
 
@@ -3037,7 +3034,7 @@ class PrefectClient:
         try:
             response = await self._client.patch(
                 f"/v2/concurrency_limits/{name}",
-                json=concurrency_limit.dict(json_compatible=True, exclude_unset=True),
+                json=concurrency_limit.model_dump(mode="json", exclude_unset=True),
             )
             return response
         except httpx.HTTPStatusError as e:
@@ -3063,7 +3060,7 @@ class PrefectClient:
     ) -> GlobalConcurrencyLimitResponse:
         try:
             response = await self._client.get(f"/v2/concurrency_limits/{name}")
-            return GlobalConcurrencyLimitResponse.parse_obj(response.json())
+            return GlobalConcurrencyLimitResponse.model_validate(response.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
@@ -3080,9 +3077,9 @@ class PrefectClient:
                 "offset": offset,
             },
         )
-        return pydantic.parse_obj_as(
-            List[GlobalConcurrencyLimitResponse], response.json()
-        )
+        return pydantic.TypeAdapter(
+            List[GlobalConcurrencyLimitResponse]
+        ).validate_python(response.json())
 
     async def create_flow_run_input(
         self, flow_run_id: UUID, key: str, value: str, sender: Optional[str] = None
@@ -3118,7 +3115,7 @@ class PrefectClient:
             },
         )
         response.raise_for_status()
-        return pydantic.parse_obj_as(List[FlowRunInput], response.json())
+        return pydantic.TypeAdapter(List[FlowRunInput]).validate_python(response.json())
 
     async def read_flow_run_input(self, flow_run_id: UUID, key: str) -> str:
         """
@@ -3143,49 +3140,27 @@ class PrefectClient:
         response = await self._client.delete(f"/flow_runs/{flow_run_id}/input/{key}")
         response.raise_for_status()
 
-    def _raise_for_unsupported_automations(self) -> NoReturn:
-        if not PREFECT_EXPERIMENTAL_EVENTS:
-            raise RuntimeError(
-                "The current server and client configuration does not support "
-                "events.  Enable experimental events support with the "
-                "PREFECT_EXPERIMENTAL_EVENTS setting."
-            )
-        else:
-            raise RuntimeError(
-                "The current server and client configuration does not support "
-                "automations.  Enable experimental automations with the "
-                "PREFECT_API_SERVICES_TRIGGERS_ENABLED setting."
-            )
-
     async def create_automation(self, automation: AutomationCore) -> UUID:
         """Creates an automation in Prefect Cloud."""
-        if not self.server_type.supports_automations():
-            self._raise_for_unsupported_automations()
-
         response = await self._client.post(
             "/automations/",
-            json=automation.dict(json_compatible=True),
+            json=automation.model_dump(mode="json"),
         )
 
         return UUID(response.json()["id"])
 
     async def update_automation(self, automation_id: UUID, automation: AutomationCore):
         """Updates an automation in Prefect Cloud."""
-        if not self.server_type.supports_automations():
-            self._raise_for_unsupported_automations()
         response = await self._client.put(
             f"/automations/{automation_id}",
-            json=automation.dict(json_compatible=True, exclude_unset=True),
+            json=automation.model_dump(mode="json", exclude_unset=True),
         )
         response.raise_for_status
 
     async def read_automations(self) -> List[Automation]:
-        if not self.server_type.supports_automations():
-            self._raise_for_unsupported_automations()
-
         response = await self._client.post("/automations/filter")
         response.raise_for_status()
-        return pydantic.parse_obj_as(List[Automation], response.json())
+        return pydantic.TypeAdapter(List[Automation]).validate_python(response.json())
 
     async def find_automation(
         self, id_or_name: Union[str, UUID], exit_if_not_found: bool = True
@@ -3221,14 +3196,11 @@ class PrefectClient:
         return None
 
     async def read_automation(self, automation_id: UUID) -> Optional[Automation]:
-        if not self.server_type.supports_automations():
-            self._raise_for_unsupported_automations()
-
         response = await self._client.get(f"/automations/{automation_id}")
         if response.status_code == 404:
             return None
         response.raise_for_status()
-        return Automation.parse_obj(response.json())
+        return Automation.model_validate(response.json())
 
     async def read_automations_by_name(self, name: str) -> List[Automation]:
         """
@@ -3240,15 +3212,13 @@ class PrefectClient:
         Returns:
             a list of Automation model representations of the automations
         """
-        if not self.server_type.supports_automations():
-            self._raise_for_unsupported_automations()
         automation_filter = filters.AutomationFilter(name=dict(any_=[name]))
 
         response = await self._client.post(
             "/automations/filter",
             json={
                 "sort": sorting.AutomationSort.UPDATED_DESC,
-                "automations": automation_filter.dict(json_compatible=True)
+                "automations": automation_filter.model_dump(mode="json")
                 if automation_filter
                 else None,
             },
@@ -3256,30 +3226,21 @@ class PrefectClient:
 
         response.raise_for_status()
 
-        return pydantic.parse_obj_as(List[Automation], response.json())
+        return pydantic.TypeAdapter(List[Automation]).validate_python(response.json())
 
     async def pause_automation(self, automation_id: UUID):
-        if not self.server_type.supports_automations():
-            self._raise_for_unsupported_automations()
-
         response = await self._client.patch(
             f"/automations/{automation_id}", json={"enabled": False}
         )
         response.raise_for_status()
 
     async def resume_automation(self, automation_id: UUID):
-        if not self.server_type.supports_automations():
-            self._raise_for_unsupported_automations()
-
         response = await self._client.patch(
             f"/automations/{automation_id}", json={"enabled": True}
         )
         response.raise_for_status()
 
     async def delete_automation(self, automation_id: UUID):
-        if not self.server_type.supports_automations():
-            self._raise_for_unsupported_automations()
-
         response = await self._client.delete(f"/automations/{automation_id}")
         if response.status_code == 404:
             return
@@ -3289,17 +3250,11 @@ class PrefectClient:
     async def read_resource_related_automations(
         self, resource_id: str
     ) -> List[Automation]:
-        if not self.server_type.supports_automations():
-            self._raise_for_unsupported_automations()
-
         response = await self._client.get(f"/automations/related-to/{resource_id}")
         response.raise_for_status()
-        return pydantic.parse_obj_as(List[Automation], response.json())
+        return pydantic.TypeAdapter(List[Automation]).validate_python(response.json())
 
     async def delete_resource_owned_automations(self, resource_id: str):
-        if not self.server_type.supports_automations():
-            self._raise_for_unsupported_automations()
-
         await self._client.delete(f"/automations/owned-by/{resource_id}")
 
     async def __aenter__(self):
@@ -3318,9 +3273,11 @@ class PrefectClient:
                 "Retrieve a new client with `get_client()` instead."
             )
 
+        self._context_stack += 1
+
         if self._started:
-            # httpx.AsyncClient does not allow reentrancy so we will not either.
-            raise RuntimeError("The client cannot be started more than once.")
+            # allow reentrancy
+            return self
 
         self._loop = asyncio.get_running_loop()
         await self._exit_stack.__aenter__()
@@ -3351,6 +3308,10 @@ class PrefectClient:
         """
         Shutdown the client.
         """
+
+        self._context_stack -= 1
+        if self._context_stack > 0:
+            return
         self._closed = True
         return await self._exit_stack.__aexit__(*exc_info)
 
@@ -3416,6 +3377,7 @@ class SyncPrefectClient:
             httpx_settings["headers"].setdefault("Authorization", f"Bearer {api_key}")
 
         # Context management
+        self._context_stack: int = 0
         self._ephemeral_app: Optional[ASGIApp] = None
         self.manage_lifespan = True
         self.server_type: ServerType
@@ -3547,9 +3509,12 @@ class SyncPrefectClient:
                 "Retrieve a new client with `get_client()` instead."
             )
 
+        self._context_stack += 1
+
         if self._started:
-            # httpx.Client does not allow reentrancy so we will not either.
-            raise RuntimeError("The client cannot be started more than once.")
+            # allow reentrancy
+            return self
+
         self._client.__enter__()
         self._started = True
 
@@ -3559,6 +3524,9 @@ class SyncPrefectClient:
         """
         Shutdown the client.
         """
+        self._context_stack -= 1
+        if self._context_stack > 0:
+            return
         self._closed = True
         self._client.__exit__(*exc_info)
 
@@ -3612,9 +3580,7 @@ class SyncPrefectClient:
             the ID of the flow in the backend
         """
         flow_data = FlowCreate(name=flow_name)
-        response = self._client.post(
-            "/flows/", json=flow_data.dict(json_compatible=True)
-        )
+        response = self._client.post("/flows/", json=flow_data.model_dump(mode="json"))
 
         flow_id = response.json().get("id")
         if not flow_id:
@@ -3677,9 +3643,9 @@ class SyncPrefectClient:
             ),
         )
 
-        flow_run_create_json = flow_run_create.dict(json_compatible=True)
+        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.parse_obj(response.json())
+        flow_run = FlowRun.model_validate(response.json())
 
         # Restore the parameters to the local objects to retain expectations about
         # Python objects
@@ -3704,7 +3670,7 @@ class SyncPrefectClient:
                 raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
             else:
                 raise
-        return FlowRun.parse_obj(response.json())
+        return FlowRun.model_validate(response.json())
 
     def read_flow_runs(
         self,
@@ -3739,29 +3705,23 @@ class SyncPrefectClient:
                 of the flow runs
         """
         body = {
-            "flows": flow_filter.dict(json_compatible=True) if flow_filter else None,
+            "flows": flow_filter.model_dump(mode="json") if flow_filter else None,
             "flow_runs": (
-                flow_run_filter.dict(json_compatible=True, exclude_unset=True)
+                flow_run_filter.model_dump(mode="json", exclude_unset=True)
                 if flow_run_filter
                 else None
             ),
             "task_runs": (
-                task_run_filter.dict(json_compatible=True) if task_run_filter else None
+                task_run_filter.model_dump(mode="json") if task_run_filter else None
             ),
             "deployments": (
-                deployment_filter.dict(json_compatible=True)
-                if deployment_filter
-                else None
+                deployment_filter.model_dump(mode="json") if deployment_filter else None
             ),
             "work_pools": (
-                work_pool_filter.dict(json_compatible=True)
-                if work_pool_filter
-                else None
+                work_pool_filter.model_dump(mode="json") if work_pool_filter else None
             ),
             "work_pool_queues": (
-                work_queue_filter.dict(json_compatible=True)
-                if work_queue_filter
-                else None
+                work_queue_filter.model_dump(mode="json") if work_queue_filter else None
             ),
             "sort": sort,
             "limit": limit,
@@ -3769,7 +3729,7 @@ class SyncPrefectClient:
         }
 
         response = self._client.post("/flow_runs/filter", json=body)
-        return pydantic.parse_obj_as(List[FlowRun], response.json())
+        return pydantic.TypeAdapter(List[FlowRun]).validate_python(response.json())
 
     def set_flow_run_state(
         self,
@@ -3795,7 +3755,7 @@ class SyncPrefectClient:
         try:
             response = self._client.post(
                 f"/flow_runs/{flow_run_id}/set_state",
-                json=dict(state=state_create.dict(json_compatible=True), force=force),
+                json=dict(state=state_create.model_dump(mode="json"), force=force),
             )
         except httpx.HTTPStatusError as e:
             if e.response.status_code == status.HTTP_404_NOT_FOUND:
@@ -3803,13 +3763,28 @@ class SyncPrefectClient:
             else:
                 raise
 
-        return OrchestrationResult.parse_obj(response.json())
+        return OrchestrationResult.model_validate(response.json())
+
+    def set_flow_run_name(self, flow_run_id: UUID, name: str):
+        flow_run_data = TaskRunUpdate(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):
+        task_run_data = TaskRunUpdate(name=name)
+        return self._client.patch(
+            f"/task_runs/{task_run_id}",
+            json=task_run_data.model_dump(mode="json", exclude_unset=True),
+        )
 
     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,
@@ -3833,6 +3808,8 @@ class SyncPrefectClient:
             task: The Task to run
             flow_run_id: The flow run id with which to associate the task run
             dynamic_key: A key unique to this particular run of a Task within the flow
+            id: An optional ID for the task run. If not provided, one will be generated
+                server-side.
             name: An optional name for the task run
             extra_tags: an optional list of extra tags to apply to the task run in
                 addition to `task.tags`
@@ -3849,6 +3826,7 @@ class SyncPrefectClient:
             state = prefect.states.Pending()
 
         task_run_data = TaskRunCreate(
+            id=id,
             name=name,
             flow_run_id=flow_run_id,
             task_key=task.task_key,
@@ -3864,10 +3842,10 @@ class SyncPrefectClient:
             task_inputs=task_inputs or {},
         )
 
-        response = self._client.post(
-            "/task_runs/", json=task_run_data.dict(json_compatible=True)
-        )
-        return TaskRun.parse_obj(response.json())
+        content = task_run_data.model_dump_json(exclude={"id"} if id is None else None)
+
+        response = self._client.post("/task_runs/", content=content)
+        return TaskRun.model_validate(response.json())
 
     def read_task_run(self, task_run_id: UUID) -> TaskRun:
         """
@@ -3879,8 +3857,14 @@ class SyncPrefectClient:
         Returns:
             a Task Run model representation of the task run
         """
-        response = self._client.get(f"/task_runs/{task_run_id}")
-        return TaskRun.parse_obj(response.json())
+        try:
+            response = self._client.get(f"/task_runs/{task_run_id}")
+            return TaskRun.model_validate(response.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
 
     def read_task_runs(
         self,
@@ -3911,26 +3895,24 @@ class SyncPrefectClient:
                 of the task runs
         """
         body = {
-            "flows": flow_filter.dict(json_compatible=True) if flow_filter else None,
+            "flows": flow_filter.model_dump(mode="json") if flow_filter else None,
             "flow_runs": (
-                flow_run_filter.dict(json_compatible=True, exclude_unset=True)
+                flow_run_filter.model_dump(mode="json", exclude_unset=True)
                 if flow_run_filter
                 else None
             ),
             "task_runs": (
-                task_run_filter.dict(json_compatible=True) if task_run_filter else None
+                task_run_filter.model_dump(mode="json") if task_run_filter else None
             ),
             "deployments": (
-                deployment_filter.dict(json_compatible=True)
-                if deployment_filter
-                else None
+                deployment_filter.model_dump(mode="json") if deployment_filter else None
             ),
             "sort": sort,
             "limit": limit,
             "offset": offset,
         }
         response = self._client.post("/task_runs/filter", json=body)
-        return pydantic.parse_obj_as(List[TaskRun], response.json())
+        return pydantic.TypeAdapter(List[TaskRun]).validate_python(response.json())
 
     def set_task_run_state(
         self,
@@ -3954,9 +3936,9 @@ class SyncPrefectClient:
         state_create.state_details.task_run_id = task_run_id
         response = self._client.post(
             f"/task_runs/{task_run_id}/set_state",
-            json=dict(state=state_create.dict(json_compatible=True), force=force),
+            json=dict(state=state_create.model_dump(mode="json"), force=force),
         )
-        return OrchestrationResult.parse_obj(response.json())
+        return OrchestrationResult.model_validate(response.json())
 
     def read_task_run_states(self, task_run_id: UUID) -> List[prefect.states.State]:
         """
@@ -3971,4 +3953,28 @@ class SyncPrefectClient:
         response = self._client.get(
             "/task_run_states/", params=dict(task_run_id=str(task_run_id))
         )
-        return pydantic.parse_obj_as(List[prefect.states.State], response.json())
+        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())