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

prefect/client/orchestration.py

@@ -8,12 +8,13 @@ from typing import (
     Dict,
     Iterable,
     List,
-    NoReturn,
+    Literal,
     Optional,
     Set,
     Tuple,
     TypeVar,
     Union,
+    overload,
 )
 from uuid import UUID, uuid4
 
@@ -21,35 +22,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,
@@ -100,7 +86,6 @@ from prefect.client.schemas.objects import (
     BlockType,
     ConcurrencyLimit,
     Constant,
-    Deployment,
     DeploymentSchedule,
     Flow,
     FlowRunInput,
@@ -133,7 +118,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 (
@@ -146,9 +131,9 @@ from prefect.settings import (
     PREFECT_API_URL,
     PREFECT_CLIENT_CSRF_SUPPORT_ENABLED,
     PREFECT_CLOUD_API_URL,
+    PREFECT_SERVER_ALLOW_EPHEMERAL_MODE,
     PREFECT_UNIT_TEST_MODE,
 )
-from prefect.utilities.collections import AutoEnum
 
 if TYPE_CHECKING:
     from prefect.flows import Flow as FlowObject
@@ -158,7 +143,7 @@ from prefect.client.base import (
     ASGIApp,
     PrefectHttpxAsyncClient,
     PrefectHttpxSyncClient,
-    PrefectHttpxSyncEphemeralClient,
+    ServerType,
     app_lifespan_context,
 )
 
@@ -166,21 +151,23 @@ P = ParamSpec("P")
 R = TypeVar("R")
 
 
-class ServerType(AutoEnum):
-    EPHEMERAL = AutoEnum.auto()
-    SERVER = AutoEnum.auto()
-    CLOUD = AutoEnum.auto()
+@overload
+def get_client(
+    httpx_settings: Optional[Dict[str, Any]] = None, sync_client: Literal[False] = False
+) -> "PrefectClient":
+    ...
 
-    def supports_automations(self) -> bool:
-        if self == ServerType.CLOUD:
-            return True
 
-        return PREFECT_EXPERIMENTAL_EVENTS and PREFECT_API_SERVICES_TRIGGERS_ENABLED
+@overload
+def get_client(
+    httpx_settings: Optional[Dict[str, Any]] = None, sync_client: Literal[True] = True
+) -> "SyncPrefectClient":
+    ...
 
 
 def get_client(
     httpx_settings: Optional[Dict[str, Any]] = None, sync_client: bool = False
-) -> Union["PrefectClient", "SyncPrefectClient"]:
+):
     """
     Retrieve a HTTP client for communicating with the Prefect REST API.
 
@@ -198,26 +185,59 @@ def get_client(
         client.hello()
     ```
     """
-    ctx = prefect.context.get_settings_context()
+    import prefect.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 sync_client:
+        if client_ctx := prefect.context.SyncClientContext.get():
+            if client_ctx.client and client_ctx._httpx_settings == httpx_settings:
+                return client_ctx.client
+    else:
+        if client_ctx := prefect.context.AsyncClientContext.get():
+            if (
+                client_ctx.client
+                and client_ctx._httpx_settings == httpx_settings
+                and loop in (client_ctx.client._loop, None)
+            ):
+                return client_ctx.client
+
     api = PREFECT_API_URL.value()
+    server_type = None
 
-    if not api:
+    if not api and PREFECT_SERVER_ALLOW_EPHEMERAL_MODE:
         # create an ephemeral API if none was provided
-        from prefect.server.api.server import create_app
+        from prefect.server.api.server import SubprocessASGIServer
 
-        api = create_app(ctx.settings, ephemeral=True)
+        server = SubprocessASGIServer()
+        server.start()
+        assert server.server_process is not None, "Server process did not start"
+
+        api = server.api_url
+        server_type = ServerType.EPHEMERAL
+    elif not api and not PREFECT_SERVER_ALLOW_EPHEMERAL_MODE:
+        raise ValueError(
+            "No Prefect API URL provided. Please set PREFECT_API_URL to the address of a running Prefect server."
+        )
 
     if sync_client:
         return SyncPrefectClient(
             api,
             api_key=PREFECT_API_KEY.value(),
             httpx_settings=httpx_settings,
+            server_type=server_type,
         )
     else:
         return PrefectClient(
             api,
             api_key=PREFECT_API_KEY.value(),
             httpx_settings=httpx_settings,
+            server_type=server_type,
         )
 
 
@@ -251,9 +271,10 @@ class PrefectClient:
         self,
         api: Union[str, ASGIApp],
         *,
-        api_key: str = None,
-        api_version: str = None,
+        api_key: Optional[str] = None,
+        api_version: Optional[str] = None,
         httpx_settings: Optional[Dict[str, Any]] = None,
+        server_type: Optional[ServerType] = None,
     ) -> None:
         httpx_settings = httpx_settings.copy() if httpx_settings else {}
         httpx_settings.setdefault("headers", {})
@@ -273,6 +294,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
@@ -315,11 +337,14 @@ class PrefectClient:
             # client will use a standard HTTP/1.1 connection instead.
             httpx_settings.setdefault("http2", PREFECT_API_ENABLE_HTTP2.value())
 
-            self.server_type = (
-                ServerType.CLOUD
-                if api.startswith(PREFECT_CLOUD_API_URL.value())
-                else ServerType.SERVER
-            )
+            if server_type:
+                self.server_type = server_type
+            else:
+                self.server_type = (
+                    ServerType.CLOUD
+                    if api.startswith(PREFECT_CLOUD_API_URL.value())
+                    else ServerType.SERVER
+                )
 
         # Connect to an in-process application
         elif isinstance(api, ASGIApp):
@@ -453,7 +478,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 +499,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,
@@ -486,7 +511,7 @@ class PrefectClient:
         work_pool_filter: WorkPoolFilter = None,
         work_queue_filter: WorkQueueFilter = None,
         sort: FlowSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[Flow]:
         """
@@ -508,29 +533,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 +557,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 +573,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,
@@ -562,12 +581,12 @@ class PrefectClient:
         *,
         parameters: Optional[Dict[str, Any]] = None,
         context: Optional[Dict[str, Any]] = None,
-        state: prefect.states.State = None,
-        name: str = None,
-        tags: Iterable[str] = None,
-        idempotency_key: str = None,
-        parent_task_run_id: UUID = None,
-        work_queue_name: str = None,
+        state: Optional[prefect.states.State] = 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,
     ) -> FlowRun:
         """
@@ -622,9 +641,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 +699,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 +759,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 +809,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 +851,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 +876,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,
@@ -918,6 +939,57 @@ class PrefectClient:
             else:
                 raise
 
+    async def increment_v1_concurrency_slots(
+        self,
+        names: List[str],
+        task_run_id: UUID,
+    ) -> httpx.Response:
+        """
+        Increment concurrency limit slots for the specified limits.
+
+        Args:
+            names (List[str]): A list of limit names for which to increment limits.
+            task_run_id (UUID): The task run ID incrementing the limits.
+        """
+        data = {
+            "names": names,
+            "task_run_id": str(task_run_id),
+        }
+
+        return await self._client.post(
+            "/concurrency_limits/increment",
+            json=data,
+        )
+
+    async def decrement_v1_concurrency_slots(
+        self,
+        names: List[str],
+        task_run_id: UUID,
+        occupancy_seconds: float,
+    ) -> httpx.Response:
+        """
+        Decrement concurrency limit slots for the specified limits.
+
+        Args:
+            names (List[str]): A list of limit names to decrement.
+            task_run_id (UUID): The task run ID that incremented the limits.
+            occupancy_seconds (float): The duration in seconds that the limits
+                were held.
+
+        Returns:
+            httpx.Response: The HTTP response from the server.
+        """
+        data = {
+            "names": names,
+            "task_run_id": str(task_run_id),
+            "occupancy_seconds": occupancy_seconds,
+        }
+
+        return await self._client.post(
+            "/concurrency_limits/decrement",
+            json=data,
+        )
+
     async def create_work_queue(
         self,
         name: str,
@@ -969,7 +1041,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 +1056,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 +1091,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 +1110,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 +1157,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 +1183,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 +1209,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 +1278,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 +1287,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 +1296,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 +1307,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,32 +1324,24 @@ 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"},
-                ),
-            )
-
+        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.dict(
-                    json_compatible=True,
-                    include_secrets=include_secrets,
-                    exclude_unset=True,
-                    exclude={"id", "block_schema", "block_type"},
-                ),
+                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.parse_obj(response.json())
+        return BlockDocument.model_validate(response.json())
 
     async def update_block_document(
         self,
@@ -1290,11 +1354,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 +1389,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 +1407,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 +1416,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 +1458,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 +1470,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 +1498,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 +1538,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 +1576,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 +1611,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,28 +1642,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,
+        schedules: Optional[List[DeploymentScheduleCreate]] = None,
+        concurrency_limit: Optional[int] = 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,
+        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,
         pull_steps: Optional[List[dict]] = None,
         enforce_parameter_schema: Optional[bool] = None,
@@ -1610,7 +1675,6 @@ class PrefectClient:
             flow_id: the flow ID to create a deployment for
             name: the name of the deployment
             version: an optional version string for the deployment
-            schedule: an optional schedule to apply to 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
@@ -1627,8 +1691,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,
@@ -1640,14 +1705,12 @@ class PrefectClient:
             storage_document_id=storage_document_id,
             path=path,
             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,
-            schedule=schedule,
             schedules=schedules or [],
+            concurrency_limit=concurrency_limit,
             pull_steps=pull_steps,
             enforce_parameter_schema=enforce_parameter_schema,
         )
@@ -1659,12 +1722,9 @@ 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:
-            exclude.add("is_schedule_active")
-
         if deployment_create.paused is None:
             exclude.add("paused")
 
@@ -1674,7 +1734,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,
@@ -1685,12 +1745,6 @@ class PrefectClient:
 
         return UUID(deployment_id)
 
-    async def update_schedule(self, deployment_id: UUID, active: bool = True):
-        path = "set_schedule_active" if active else "set_schedule_inactive"
-        await self._client.post(
-            f"/deployments/{deployment_id}/{path}",
-        )
-
     async def set_deployment_paused_state(self, deployment_id: UUID, paused: bool):
         await self._client.patch(
             f"/deployments/{deployment_id}", json={"paused": paused}
@@ -1698,41 +1752,12 @@ class PrefectClient:
 
     async def update_deployment(
         self,
-        deployment: Deployment,
-        schedule: SCHEDULE_TYPES = None,
-        is_schedule_active: bool = None,
+        deployment_id: UUID,
+        deployment: DeploymentUpdate,
     ):
-        deployment_update = DeploymentUpdate(
-            version=deployment.version,
-            schedule=schedule if schedule is not None else deployment.schedule,
-            is_schedule_active=(
-                is_schedule_active
-                if is_schedule_active is not None
-                else deployment.is_schedule_active
-            ),
-            description=deployment.description,
-            work_queue_name=deployment.work_queue_name,
-            tags=deployment.tags,
-            manifest_path=deployment.manifest_path,
-            path=deployment.path,
-            entrypoint=deployment.entrypoint,
-            parameters=deployment.parameters,
-            storage_document_id=deployment.storage_document_id,
-            infrastructure_document_id=deployment.infrastructure_document_id,
-            job_variables=deployment.job_variables,
-            enforce_parameter_schema=deployment.enforce_parameter_schema,
-        )
-
-        if getattr(deployment, "work_pool_name", None) is not None:
-            deployment_update.work_pool_name = deployment.work_pool_name
-
-        exclude = set()
-        if deployment.enforce_parameter_schema is None:
-            exclude.add("enforce_parameter_schema")
-
         await self._client.patch(
-            f"/deployments/{deployment.id}",
-            json=deployment_update.dict(json_compatible=True, exclude=exclude),
+            f"/deployments/{deployment_id}",
+            json=deployment.model_dump(mode="json", exclude_unset=True),
         )
 
     async def _create_deployment_from_schema(self, schema: DeploymentCreate) -> UUID:
@@ -1742,7 +1767,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:
@@ -1763,6 +1788,12 @@ class PrefectClient:
         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:
@@ -1770,7 +1801,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 +1828,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 +1862,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 +1886,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 +1936,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 +1966,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 +1993,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 +2047,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 +2069,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,
@@ -2050,7 +2081,7 @@ class PrefectClient:
         work_pool_filter: WorkPoolFilter = None,
         work_queue_filter: WorkQueueFilter = None,
         sort: FlowRunSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[FlowRun]:
         """
@@ -2073,29 +2104,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 +2128,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 +2148,16 @@ 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()
         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 +2165,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 +2183,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 +2199,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 +2223,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 +2241,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 +2256,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 +2271,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,
@@ -2249,7 +2288,7 @@ class PrefectClient:
         task_run_filter: TaskRunFilter = None,
         deployment_filter: DeploymentFilter = None,
         sort: TaskRunSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[TaskRun]:
         """
@@ -2270,26 +2309,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 +2368,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 +2387,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 +2399,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 +2436,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 +2506,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 +2535,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,58 +2545,29 @@ 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,
         log_filter: LogFilter = None,
-        limit: int = None,
-        offset: int = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
         sort: LogSort = LogSort.TIMESTAMP_ASC,
     ) -> List[Log]:
         """
         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 +2611,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 +2620,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 +2635,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,17 +2664,16 @@ 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,
         work_pool: WorkPoolCreate,
+        overwrite: bool = False,
     ) -> WorkPool:
         """
         Creates a work pool with the provided configuration.
@@ -2678,15 +2687,32 @@ 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:
-                raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e
+                if overwrite:
+                    existing_work_pool = await self.read_work_pool(
+                        work_pool_name=work_pool.name
+                    )
+                    if existing_work_pool.type != work_pool.type:
+                        warnings.warn(
+                            "Overwriting work pool type is not supported. Ignoring provided type.",
+                            category=UserWarning,
+                        )
+                    await self.update_work_pool(
+                        work_pool_name=work_pool.name,
+                        work_pool=WorkPoolUpdate.model_validate(
+                            work_pool.model_dump(exclude={"name", "type"})
+                        ),
+                    )
+                    response = await self._client.get(f"/work_pools/{work_pool.name}")
+                else:
+                    raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e
             else:
                 raise
 
-        return pydantic.parse_obj_as(WorkPool, response.json())
+        return WorkPool.model_validate(response.json())
 
     async def update_work_pool(
         self,
@@ -2703,7 +2729,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 +2776,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 +2798,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 +2817,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 +2852,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 +2871,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,
@@ -2853,7 +2902,7 @@ class PrefectClient:
         flow_run_filter: FlowRunFilter = None,
         task_run_filter: TaskRunFilter = None,
         sort: ArtifactSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[Artifact]:
         """
@@ -2871,20 +2920,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,
@@ -2893,7 +2942,7 @@ class PrefectClient:
         flow_run_filter: FlowRunFilter = None,
         task_run_filter: TaskRunFilter = None,
         sort: ArtifactCollectionSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[ArtifactCollection]:
         """
@@ -2911,20 +2960,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 +3003,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 +3018,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]:
@@ -2991,10 +3042,10 @@ class PrefectClient:
             else:
                 raise
 
-    async def read_variables(self, limit: int = None) -> List[Variable]:
+    async def read_variables(self, limit: Optional[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."""
@@ -3003,16 +3054,34 @@ class PrefectClient:
         return response.json()
 
     async def increment_concurrency_slots(
-        self, names: List[str], slots: int, mode: str
+        self, names: List[str], slots: int, mode: str, create_if_missing: Optional[bool]
     ) -> httpx.Response:
         return await self._client.post(
             "/v2/concurrency_limits/increment",
-            json={"names": names, "slots": slots, "mode": mode},
+            json={
+                "names": names,
+                "slots": slots,
+                "mode": mode,
+                "create_if_missing": create_if_missing,
+            },
         )
 
     async def release_concurrency_slots(
         self, names: List[str], slots: int, occupancy_seconds: float
     ) -> httpx.Response:
+        """
+        Release concurrency slots for the specified limits.
+
+        Args:
+            names (List[str]): A list of limit names for which to release slots.
+            slots (int): The number of concurrency slots to release.
+            occupancy_seconds (float): The duration in seconds that the slots
+                were occupied.
+
+        Returns:
+            httpx.Response: The HTTP response from the server.
+        """
+
         return await self._client.post(
             "/v2/concurrency_limits/decrement",
             json={
@@ -3027,7 +3096,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 +3106,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 +3132,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 +3149,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 +3187,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,52 +3212,30 @@ 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
+        self, id_or_name: Union[str, UUID]
     ) -> Optional[Automation]:
         if isinstance(id_or_name, str):
             try:
@@ -3221,14 +3268,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 +3284,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 +3298,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 +3322,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 +3345,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 +3380,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)
 
@@ -3394,9 +3427,10 @@ class SyncPrefectClient:
         self,
         api: Union[str, ASGIApp],
         *,
-        api_key: str = None,
-        api_version: str = None,
+        api_key: Optional[str] = None,
+        api_version: Optional[str] = None,
         httpx_settings: Optional[Dict[str, Any]] = None,
+        server_type: Optional[ServerType] = None,
     ) -> None:
         httpx_settings = httpx_settings.copy() if httpx_settings else {}
         httpx_settings.setdefault("headers", {})
@@ -3416,6 +3450,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
@@ -3454,11 +3489,14 @@ class SyncPrefectClient:
             # client will use a standard HTTP/1.1 connection instead.
             httpx_settings.setdefault("http2", PREFECT_API_ENABLE_HTTP2.value())
 
-            self.server_type = (
-                ServerType.CLOUD
-                if api.startswith(PREFECT_CLOUD_API_URL.value())
-                else ServerType.SERVER
-            )
+            if server_type:
+                self.server_type = server_type
+            else:
+                self.server_type = (
+                    ServerType.CLOUD
+                    if api.startswith(PREFECT_CLOUD_API_URL.value())
+                    else ServerType.SERVER
+                )
 
         # Connect to an in-process application
         elif isinstance(api, ASGIApp):
@@ -3490,14 +3528,9 @@ class SyncPrefectClient:
             and PREFECT_CLIENT_CSRF_SUPPORT_ENABLED.value()
         )
 
-        if self.server_type == ServerType.EPHEMERAL:
-            self._client = PrefectHttpxSyncEphemeralClient(
-                api, base_url="http://ephemeral-prefect/api"
-            )
-        else:
-            self._client = PrefectHttpxSyncClient(
-                **httpx_settings, enable_csrf_support=enable_csrf_support
-            )
+        self._client = PrefectHttpxSyncClient(
+            **httpx_settings, enable_csrf_support=enable_csrf_support
+        )
 
         # See https://www.python-httpx.org/advanced/#custom-transports
         #
@@ -3547,9 +3580,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 +3595,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 +3651,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 +3714,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
@@ -3687,6 +3724,61 @@ class SyncPrefectClient:
 
         return flow_run
 
+    def update_flow_run(
+        self,
+        flow_run_id: UUID,
+        flow_version: Optional[str] = None,
+        parameters: Optional[dict] = None,
+        name: Optional[str] = None,
+        tags: Optional[Iterable[str]] = None,
+        empirical_policy: Optional[FlowRunPolicy] = None,
+        infrastructure_pid: Optional[str] = None,
+        job_variables: Optional[dict] = 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 = {}
+        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.
@@ -3704,7 +3796,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,
@@ -3716,7 +3808,7 @@ class SyncPrefectClient:
         work_pool_filter: WorkPoolFilter = None,
         work_queue_filter: WorkQueueFilter = None,
         sort: FlowRunSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[FlowRun]:
         """
@@ -3739,29 +3831,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 +3855,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 +3881,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 +3889,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 +3934,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 +3952,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 +3968,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 +3983,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,
@@ -3890,7 +4000,7 @@ class SyncPrefectClient:
         task_run_filter: TaskRunFilter = None,
         deployment_filter: DeploymentFilter = None,
         sort: TaskRunSort = None,
-        limit: int = None,
+        limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[TaskRun]:
         """
@@ -3911,26 +4021,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 +4062,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 +4079,123 @@ 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())
+
+    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 create_artifact(
+        self,
+        artifact: ArtifactCreate,
+    ) -> Artifact:
+        """
+        Creates an artifact with the provided configuration.
+
+        Args:
+            artifact: Desired configuration for the new artifact.
+        Returns:
+            Information about the newly created artifact.
+        """
+
+        response = self._client.post(
+            "/artifacts/",
+            json=artifact.model_dump(mode="json", exclude_unset=True),
+        )
+
+        return Artifact.model_validate(response.json())
+
+    def release_concurrency_slots(
+        self, names: List[str], slots: int, occupancy_seconds: float
+    ) -> httpx.Response:
+        """
+        Release concurrency slots for the specified limits.
+
+        Args:
+            names (List[str]): A list of limit names for which to release slots.
+            slots (int): The number of concurrency slots to release.
+            occupancy_seconds (float): The duration in seconds that the slots
+                were occupied.
+
+        Returns:
+            httpx.Response: The HTTP response from the server.
+        """
+        return self._client.post(
+            "/v2/concurrency_limits/decrement",
+            json={
+                "names": names,
+                "slots": slots,
+                "occupancy_seconds": occupancy_seconds,
+            },
+        )
+
+    def decrement_v1_concurrency_slots(
+        self, names: List[str], occupancy_seconds: float, task_run_id: UUID
+    ) -> httpx.Response:
+        """
+        Release the specified concurrency limits.
+
+        Args:
+            names (List[str]): A list of limit names to decrement.
+            occupancy_seconds (float): The duration in seconds that the slots
+                were held.
+            task_run_id (UUID): The task run ID that incremented the limits.
+
+        Returns:
+            httpx.Response: The HTTP response from the server.
+        """
+        return self._client.post(
+            "/concurrency_limits/decrement",
+            json={
+                "names": names,
+                "occupancy_seconds": occupancy_seconds,
+                "task_run_id": str(task_run_id),
+            },
+        )