prefect-client 2.16.7__py3-none-any.whl → 2.16.9__py3-none-any.whl

prefect/client/schemas/actions.py

@@ -1,29 +1,31 @@
-import warnings
-from copy import copy, deepcopy
+from copy import deepcopy
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, TypeVar, Union
-from uuid import UUID
+from uuid import UUID, uuid4
 
 import jsonschema
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 
 if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, root_validator, validator
+    from pydantic.v1 import Field, conint, root_validator, validator
 else:
-    from pydantic import Field, root_validator, validator
+    from pydantic import Field, conint, root_validator, validator
 
 import prefect.client.schemas.objects as objects
-from prefect._internal.compatibility.experimental import experimental_field
 from prefect._internal.schemas.bases import ActionBaseModel
 from prefect._internal.schemas.fields import DateTimeTZ
 from prefect._internal.schemas.serializers import orjson_dumps_extra_compatible
-from prefect._internal.schemas.transformations import FieldFrom, copy_model_fields
 from prefect._internal.schemas.validators import (
     raise_on_name_alphanumeric_dashes_only,
     raise_on_name_alphanumeric_underscores_only,
+    remove_old_deployment_fields,
+    return_none_schedule,
+    validate_message_template_variables,
+    validate_name_present_on_nonanonymous_blocks,
 )
 from prefect.client.schemas.objects import StateDetails, StateType
-from prefect.client.schemas.schedules import SCHEDULE_TYPES, NoSchedule
+from prefect.client.schemas.schedules import SCHEDULE_TYPES
+from prefect.utilities.collections import listrepr
 from prefect.utilities.pydantic import get_class_fields_only
 
 if TYPE_CHECKING:
@@ -67,79 +69,58 @@ class StateCreate(ActionBaseModel):
     )
 
 
-@copy_model_fields
 class FlowCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a flow."""
 
-    name: str = FieldFrom(objects.Flow)
-    tags: List[str] = FieldFrom(objects.Flow)
+    name: str = Field(
+        default=..., description="The name of the flow", example="my-flow"
+    )
+    tags: List[str] = Field(
+        default_factory=list,
+        description="A list of flow tags",
+        example=["tag-1", "tag-2"],
+    )
 
 
-@copy_model_fields
 class FlowUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a flow."""
 
-    tags: List[str] = FieldFrom(objects.Flow)
+    tags: List[str] = Field(
+        default_factory=list,
+        description="A list of flow tags",
+        example=["tag-1", "tag-2"],
+    )
 
 
-@copy_model_fields
 class DeploymentScheduleCreate(ActionBaseModel):
-    active: bool = FieldFrom(objects.DeploymentSchedule)
-    schedule: SCHEDULE_TYPES = FieldFrom(objects.DeploymentSchedule)
+    schedule: SCHEDULE_TYPES = Field(
+        default=..., description="The schedule for the deployment."
+    )
+    active: bool = Field(
+        default=True, description="Whether or not the schedule is active."
+    )
 
 
-@copy_model_fields
 class DeploymentScheduleUpdate(ActionBaseModel):
-    active: bool = FieldFrom(objects.DeploymentSchedule)
-    schedule: SCHEDULE_TYPES = FieldFrom(objects.DeploymentSchedule)
+    schedule: Optional[SCHEDULE_TYPES] = Field(
+        default=None, description="The schedule for the deployment."
+    )
+    active: bool = Field(
+        default=True, description="Whether or not the schedule is active."
+    )
 
 
-@experimental_field(
-    "work_pool_name",
-    group="work_pools",
-    when=lambda x: x is not None,
-)
-@copy_model_fields
 class DeploymentCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a deployment."""
 
     @root_validator(pre=True)
     def remove_old_fields(cls, values):
-        # 2.7.7 removed worker_pool_queue_id in lieu of worker_pool_name and
-        # worker_pool_queue_name. Those fields were later renamed to work_pool_name
-        # and work_queue_name. This validator removes old fields provided
-        # by older clients to avoid 422 errors.
-        values_copy = copy(values)
-        worker_pool_queue_id = values_copy.pop("worker_pool_queue_id", None)
-        worker_pool_name = values_copy.pop("worker_pool_name", None)
-        worker_pool_queue_name = values_copy.pop("worker_pool_queue_name", None)
-        work_pool_queue_name = values_copy.pop("work_pool_queue_name", None)
-        if worker_pool_queue_id:
-            warnings.warn(
-                (
-                    "`worker_pool_queue_id` is no longer supported for creating "
-                    "deployments. Please use `work_pool_name` and "
-                    "`work_queue_name` instead."
-                ),
-                UserWarning,
-            )
-        if worker_pool_name or worker_pool_queue_name or work_pool_queue_name:
-            warnings.warn(
-                (
-                    "`worker_pool_name`, `worker_pool_queue_name`, and "
-                    "`work_pool_name` are"
-                    "no longer supported for creating "
-                    "deployments. Please use `work_pool_name` and "
-                    "`work_queue_name` instead."
-                ),
-                UserWarning,
-            )
-        return values_copy
-
-    name: str = FieldFrom(objects.Deployment)
-    flow_id: UUID = FieldFrom(objects.Deployment)
-    is_schedule_active: Optional[bool] = FieldFrom(objects.Deployment)
-    paused: Optional[bool] = FieldFrom(objects.Deployment)
+        return remove_old_deployment_fields(values)
+
+    name: str = Field(..., description="The name of the deployment.")
+    flow_id: UUID = Field(..., description="The ID of the flow to deploy.")
+    is_schedule_active: Optional[bool] = Field(None)
+    paused: Optional[bool] = Field(None)
     schedules: List[DeploymentScheduleCreate] = Field(
         default_factory=list,
         description="A list of schedules for the deployment.",
@@ -150,26 +131,29 @@ class DeploymentCreate(ActionBaseModel):
             "Whether or not the deployment should enforce the parameter schema."
         ),
     )
-    parameter_openapi_schema: Optional[Dict[str, Any]] = FieldFrom(objects.Deployment)
-    parameters: Dict[str, Any] = FieldFrom(objects.Deployment)
-    tags: List[str] = FieldFrom(objects.Deployment)
-    pull_steps: Optional[List[dict]] = FieldFrom(objects.Deployment)
+    parameter_openapi_schema: Optional[Dict[str, Any]] = Field(None)
+    parameters: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Parameters for flow runs scheduled by the deployment.",
+    )
+    tags: List[str] = Field(default_factory=list)
+    pull_steps: Optional[List[dict]] = Field(None)
 
-    manifest_path: Optional[str] = FieldFrom(objects.Deployment)
-    work_queue_name: Optional[str] = FieldFrom(objects.Deployment)
+    manifest_path: Optional[str] = Field(None)
+    work_queue_name: Optional[str] = Field(None)
     work_pool_name: Optional[str] = Field(
         default=None,
         description="The name of the deployment's work pool.",
         example="my-work-pool",
     )
-    storage_document_id: Optional[UUID] = FieldFrom(objects.Deployment)
-    infrastructure_document_id: Optional[UUID] = FieldFrom(objects.Deployment)
-    schedule: Optional[SCHEDULE_TYPES] = FieldFrom(objects.Deployment)
-    description: Optional[str] = FieldFrom(objects.Deployment)
-    path: Optional[str] = FieldFrom(objects.Deployment)
-    version: Optional[str] = FieldFrom(objects.Deployment)
-    entrypoint: Optional[str] = FieldFrom(objects.Deployment)
-    infra_overrides: Optional[Dict[str, Any]] = FieldFrom(objects.Deployment)
+    storage_document_id: Optional[UUID] = Field(None)
+    infrastructure_document_id: Optional[UUID] = Field(None)
+    schedule: Optional[SCHEDULE_TYPES] = Field(None)
+    description: Optional[str] = Field(None)
+    path: Optional[str] = Field(None)
+    version: Optional[str] = Field(None)
+    entrypoint: Optional[str] = Field(None)
+    infra_overrides: Optional[Dict[str, Any]] = Field(None)
 
     def check_valid_configuration(self, base_job_template: dict):
         """Check that the combination of base_job_template defaults
@@ -191,75 +175,38 @@ class DeploymentCreate(ActionBaseModel):
             jsonschema.validate(self.infra_overrides, variables_schema)
 
 
-@experimental_field(
-    "work_pool_name",
-    group="work_pools",
-    when=lambda x: x is not None,
-)
-@copy_model_fields
 class DeploymentUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a deployment."""
 
     @root_validator(pre=True)
     def remove_old_fields(cls, values):
-        # 2.7.7 removed worker_pool_queue_id in lieu of worker_pool_name and
-        # worker_pool_queue_name. Those fields were later renamed to work_pool_name
-        # and work_queue_name. This validator removes old fields provided
-        # by older clients to avoid 422 errors.
-        values_copy = copy(values)
-        worker_pool_queue_id = values_copy.pop("worker_pool_queue_id", None)
-        worker_pool_name = values_copy.pop("worker_pool_name", None)
-        worker_pool_queue_name = values_copy.pop("worker_pool_queue_name", None)
-        work_pool_queue_name = values_copy.pop("work_pool_queue_name", None)
-        if worker_pool_queue_id:
-            warnings.warn(
-                (
-                    "`worker_pool_queue_id` is no longer supported for updating "
-                    "deployments. Please use `work_pool_name` and "
-                    "`work_queue_name` instead."
-                ),
-                UserWarning,
-            )
-        if worker_pool_name or worker_pool_queue_name or work_pool_queue_name:
-            warnings.warn(
-                (
-                    "`worker_pool_name`, `worker_pool_queue_name`, and "
-                    "`work_pool_name` are"
-                    "no longer supported for creating "
-                    "deployments. Please use `work_pool_name` and "
-                    "`work_queue_name` instead."
-                ),
-                UserWarning,
-            )
-        return values_copy
+        return remove_old_deployment_fields(values)
 
     @validator("schedule")
-    def return_none_schedule(cls, v):
-        if isinstance(v, NoSchedule):
-            return None
-        return v
-
-    version: Optional[str] = FieldFrom(objects.Deployment)
-    schedule: Optional[SCHEDULE_TYPES] = FieldFrom(objects.Deployment)
-    description: Optional[str] = FieldFrom(objects.Deployment)
-    is_schedule_active: bool = FieldFrom(objects.Deployment)
+    def validate_none_schedule(cls, v):
+        return return_none_schedule(v)
+
+    version: Optional[str] = Field(None)
+    schedule: Optional[SCHEDULE_TYPES] = Field(None)
+    description: Optional[str] = Field(None)
+    is_schedule_active: bool = Field(None)
     parameters: Optional[Dict[str, Any]] = Field(
         default=None,
         description="Parameters for flow runs scheduled by the deployment.",
     )
-    tags: List[str] = FieldFrom(objects.Deployment)
-    work_queue_name: Optional[str] = FieldFrom(objects.Deployment)
+    tags: List[str] = Field(default_factory=list)
+    work_queue_name: Optional[str] = Field(None)
     work_pool_name: Optional[str] = Field(
         default=None,
         description="The name of the deployment's work pool.",
         example="my-work-pool",
     )
-    path: Optional[str] = FieldFrom(objects.Deployment)
-    infra_overrides: Optional[Dict[str, Any]] = FieldFrom(objects.Deployment)
-    entrypoint: Optional[str] = FieldFrom(objects.Deployment)
-    manifest_path: Optional[str] = FieldFrom(objects.Deployment)
-    storage_document_id: Optional[UUID] = FieldFrom(objects.Deployment)
-    infrastructure_document_id: Optional[UUID] = FieldFrom(objects.Deployment)
+    path: Optional[str] = Field(None)
+    infra_overrides: Optional[Dict[str, Any]] = Field(None)
+    entrypoint: Optional[str] = Field(None)
+    manifest_path: Optional[str] = Field(None)
+    storage_document_id: Optional[UUID] = Field(None)
+    infrastructure_document_id: Optional[UUID] = Field(None)
     enforce_parameter_schema: Optional[bool] = Field(
         default=None,
         description=(
@@ -288,20 +235,20 @@ class DeploymentUpdate(ActionBaseModel):
             jsonschema.validate(self.infra_overrides, variables_schema)
 
 
-@copy_model_fields
 class FlowRunUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a flow run."""
 
-    name: Optional[str] = FieldFrom(objects.FlowRun)
-    flow_version: Optional[str] = FieldFrom(objects.FlowRun)
-    parameters: dict = FieldFrom(objects.FlowRun)
-    empirical_policy: objects.FlowRunPolicy = FieldFrom(objects.FlowRun)
-    tags: List[str] = FieldFrom(objects.FlowRun)
-    infrastructure_pid: Optional[str] = FieldFrom(objects.FlowRun)
-    job_variables: Optional[dict] = FieldFrom(objects.FlowRun)
+    name: Optional[str] = Field(None)
+    flow_version: Optional[str] = Field(None)
+    parameters: Optional[Dict[str, Any]] = Field(None)
+    empirical_policy: objects.FlowRunPolicy = Field(
+        default_factory=objects.FlowRunPolicy
+    )
+    tags: List[str] = Field(default_factory=list)
+    infrastructure_pid: Optional[str] = Field(None)
+    job_variables: Optional[Dict[str, Any]] = Field(None)
 
 
-@copy_model_fields
 class TaskRunCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a task run"""
 
@@ -310,15 +257,28 @@ class TaskRunCreate(ActionBaseModel):
         default=None, description="The state of the task run to create"
     )
 
-    name: str = FieldFrom(objects.TaskRun)
-    flow_run_id: Optional[UUID] = FieldFrom(objects.TaskRun)
-    task_key: str = FieldFrom(objects.TaskRun)
-    dynamic_key: str = FieldFrom(objects.TaskRun)
-    cache_key: Optional[str] = FieldFrom(objects.TaskRun)
-    cache_expiration: Optional[objects.DateTimeTZ] = FieldFrom(objects.TaskRun)
-    task_version: Optional[str] = FieldFrom(objects.TaskRun)
-    empirical_policy: objects.TaskRunPolicy = FieldFrom(objects.TaskRun)
-    tags: List[str] = FieldFrom(objects.TaskRun)
+    name: Optional[str] = Field(
+        default=None,
+        description="The name of the task run",
+    )
+    flow_run_id: Optional[UUID] = Field(None)
+    task_key: str = Field(
+        default=..., description="A unique identifier for the task being run."
+    )
+    dynamic_key: str = Field(
+        default=...,
+        description=(
+            "A dynamic key used to differentiate between multiple runs of the same task"
+            " within the same flow run."
+        ),
+    )
+    cache_key: Optional[str] = Field(None)
+    cache_expiration: Optional[objects.DateTimeTZ] = Field(None)
+    task_version: Optional[str] = Field(None)
+    empirical_policy: objects.TaskRunPolicy = Field(
+        default_factory=objects.TaskRunPolicy,
+    )
+    tags: List[str] = Field(default_factory=list)
     task_inputs: Dict[
         str,
         List[
@@ -328,17 +288,15 @@ class TaskRunCreate(ActionBaseModel):
                 objects.Constant,
             ]
         ],
-    ] = FieldFrom(objects.TaskRun)
+    ] = Field(default_factory=dict)
 
 
-@copy_model_fields
 class TaskRunUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a task run"""
 
-    name: str = FieldFrom(objects.TaskRun)
+    name: Optional[str] = Field(None)
 
 
-@copy_model_fields
 class FlowRunCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a flow run."""
 
@@ -347,23 +305,28 @@ class FlowRunCreate(ActionBaseModel):
         default=None, description="The state of the flow run to create"
     )
 
-    name: str = FieldFrom(objects.FlowRun)
-    flow_id: UUID = FieldFrom(objects.FlowRun)
-    deployment_id: Optional[UUID] = FieldFrom(objects.FlowRun)
-    flow_version: Optional[str] = FieldFrom(objects.FlowRun)
-    parameters: dict = FieldFrom(objects.FlowRun)
-    context: dict = FieldFrom(objects.FlowRun)
-    parent_task_run_id: Optional[UUID] = FieldFrom(objects.FlowRun)
-    infrastructure_document_id: Optional[UUID] = FieldFrom(objects.FlowRun)
-    empirical_policy: objects.FlowRunPolicy = FieldFrom(objects.FlowRun)
-    tags: List[str] = FieldFrom(objects.FlowRun)
-    idempotency_key: Optional[str] = FieldFrom(objects.FlowRun)
+    name: Optional[str] = Field(default=None, description="The name of the flow run.")
+    flow_id: UUID = Field(default=..., description="The id of the flow being run.")
+    deployment_id: Optional[UUID] = Field(None)
+    flow_version: Optional[str] = Field(None)
+    parameters: Dict[str, Any] = Field(
+        default_factory=dict, description="The parameters for the flow run."
+    )
+    context: Dict[str, Any] = Field(
+        default_factory=dict, description="The context for the flow run."
+    )
+    parent_task_run_id: Optional[UUID] = Field(None)
+    infrastructure_document_id: Optional[UUID] = Field(None)
+    empirical_policy: objects.FlowRunPolicy = Field(
+        default_factory=objects.FlowRunPolicy
+    )
+    tags: List[str] = Field(default_factory=list)
+    idempotency_key: Optional[str] = Field(None)
 
     class Config(ActionBaseModel.Config):
         json_dumps = orjson_dumps_extra_compatible
 
 
-@copy_model_fields
 class DeploymentFlowRunCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a flow run from a deployment."""
 
@@ -372,44 +335,61 @@ class DeploymentFlowRunCreate(ActionBaseModel):
         default=None, description="The state of the flow run to create"
     )
 
-    name: Optional[str] = FieldFrom(objects.FlowRun)
-    parameters: dict = FieldFrom(objects.FlowRun)
-    context: dict = FieldFrom(objects.FlowRun)
-    infrastructure_document_id: Optional[UUID] = FieldFrom(objects.FlowRun)
-    empirical_policy: objects.FlowRunPolicy = FieldFrom(objects.FlowRun)
-    tags: List[str] = FieldFrom(objects.FlowRun)
-    idempotency_key: Optional[str] = FieldFrom(objects.FlowRun)
-    parent_task_run_id: Optional[UUID] = FieldFrom(objects.FlowRun)
-    work_queue_name: Optional[str] = FieldFrom(objects.FlowRun)
-    job_variables: Optional[dict] = FieldFrom(objects.FlowRun)
+    name: Optional[str] = Field(default=None, description="The name of the flow run.")
+    parameters: Dict[str, Any] = Field(
+        default_factory=dict, description="The parameters for the flow run."
+    )
+    context: Dict[str, Any] = Field(
+        default_factory=dict, description="The context for the flow run."
+    )
+    infrastructure_document_id: Optional[UUID] = Field(None)
+    empirical_policy: objects.FlowRunPolicy = Field(
+        default_factory=objects.FlowRunPolicy
+    )
+    tags: List[str] = Field(default_factory=list)
+    idempotency_key: Optional[str] = Field(None)
+    parent_task_run_id: Optional[UUID] = Field(None)
+    work_queue_name: Optional[str] = Field(None)
+    job_variables: Optional[dict] = Field(None)
 
 
-@copy_model_fields
 class SavedSearchCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a saved search."""
 
-    name: str = FieldFrom(objects.SavedSearch)
-    filters: List[objects.SavedSearchFilter] = FieldFrom(objects.SavedSearch)
+    name: str = Field(default=..., description="The name of the saved search.")
+    filters: List[objects.SavedSearchFilter] = Field(
+        default_factory=list, description="The filter set for the saved search."
+    )
 
 
-@copy_model_fields
 class ConcurrencyLimitCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a concurrency limit."""
 
-    tag: str = FieldFrom(objects.ConcurrencyLimit)
-    concurrency_limit: int = FieldFrom(objects.ConcurrencyLimit)
+    tag: str = Field(
+        default=..., description="A tag the concurrency limit is applied to."
+    )
+    concurrency_limit: int = Field(default=..., description="The concurrency limit.")
 
 
-@copy_model_fields
 class BlockTypeCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a block type."""
 
-    name: str = FieldFrom(objects.BlockType)
-    slug: str = FieldFrom(objects.BlockType)
-    logo_url: Optional[objects.HttpUrl] = FieldFrom(objects.BlockType)
-    documentation_url: Optional[objects.HttpUrl] = FieldFrom(objects.BlockType)
-    description: Optional[str] = FieldFrom(objects.BlockType)
-    code_example: Optional[str] = FieldFrom(objects.BlockType)
+    name: str = Field(default=..., description="A block type's name")
+    slug: str = Field(default=..., description="A block type's slug")
+    logo_url: Optional[objects.HttpUrl] = Field(
+        default=None, description="Web URL for the block type's logo"
+    )
+    documentation_url: Optional[objects.HttpUrl] = Field(
+        default=None, description="Web URL for the block type's documentation"
+    )
+    description: Optional[str] = Field(
+        default=None,
+        description="A short blurb about the corresponding block's intended use",
+    )
+    code_example: Optional[str] = Field(
+        default=None,
+        description="A code snippet demonstrating use of the corresponding block",
+    )
 
     # validators
     _validate_slug_format = validator("slug", allow_reuse=True)(
@@ -417,39 +397,58 @@ class BlockTypeCreate(ActionBaseModel):
     )
 
 
-@copy_model_fields
 class BlockTypeUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a block type."""
 
-    logo_url: Optional[objects.HttpUrl] = FieldFrom(objects.BlockType)
-    documentation_url: Optional[objects.HttpUrl] = FieldFrom(objects.BlockType)
-    description: Optional[str] = FieldFrom(objects.BlockType)
-    code_example: Optional[str] = FieldFrom(objects.BlockType)
+    logo_url: Optional[objects.HttpUrl] = Field(None)
+    documentation_url: Optional[objects.HttpUrl] = Field(None)
+    description: Optional[str] = Field(None)
+    code_example: Optional[str] = Field(None)
 
     @classmethod
     def updatable_fields(cls) -> set:
         return get_class_fields_only(cls)
 
 
-@copy_model_fields
 class BlockSchemaCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a block schema."""
 
-    fields: dict = FieldFrom(objects.BlockSchema)
-    block_type_id: Optional[UUID] = FieldFrom(objects.BlockSchema)
-    capabilities: List[str] = FieldFrom(objects.BlockSchema)
-    version: str = FieldFrom(objects.BlockSchema)
+    fields: Dict[str, Any] = Field(
+        default_factory=dict, description="The block schema's field schema"
+    )
+    block_type_id: Optional[UUID] = Field(None)
+    capabilities: List[str] = Field(
+        default_factory=list,
+        description="A list of Block capabilities",
+    )
+    version: str = Field(
+        default=objects.DEFAULT_BLOCK_SCHEMA_VERSION,
+        description="Human readable identifier for the block schema",
+    )
 
 
-@copy_model_fields
 class BlockDocumentCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a block document."""
 
-    name: Optional[str] = FieldFrom(objects.BlockDocument)
-    data: dict = FieldFrom(objects.BlockDocument)
-    block_schema_id: UUID = FieldFrom(objects.BlockDocument)
-    block_type_id: UUID = FieldFrom(objects.BlockDocument)
-    is_anonymous: bool = FieldFrom(objects.BlockDocument)
+    name: Optional[str] = Field(
+        default=None, description="The name of the block document"
+    )
+    data: Dict[str, Any] = Field(
+        default_factory=dict, description="The block document's data"
+    )
+    block_schema_id: UUID = Field(
+        default=..., description="The block schema ID for the block document"
+    )
+    block_type_id: UUID = Field(
+        default=..., description="The block type ID for the block document"
+    )
+    is_anonymous: bool = Field(
+        default=False,
+        description=(
+            "Whether the block is anonymous (anonymous blocks are usually created by"
+            " Prefect automatically)"
+        ),
+    )
 
     _validate_name_format = validator("name", allow_reuse=True)(
         validate_block_document_name
@@ -457,75 +456,95 @@ class BlockDocumentCreate(ActionBaseModel):
 
     @root_validator
     def validate_name_is_present_if_not_anonymous(cls, values):
-        # TODO: We should find an elegant way to reuse this logic from the origin model
-        if not values.get("is_anonymous") and not values.get("name"):
-            raise ValueError("Names must be provided for block documents.")
-        return values
+        return validate_name_present_on_nonanonymous_blocks(values)
 
 
-@copy_model_fields
 class BlockDocumentUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a block document."""
 
     block_schema_id: Optional[UUID] = Field(
         default=None, description="A block schema ID"
     )
-    data: dict = FieldFrom(objects.BlockDocument)
-    merge_existing_data: bool = True
+    data: Dict[str, Any] = Field(
+        default_factory=dict, description="The block document's data"
+    )
+    merge_existing_data: bool = Field(
+        default=True,
+        description="Whether to merge the existing data with the new data or replace it",
+    )
 
 
-@copy_model_fields
 class BlockDocumentReferenceCreate(ActionBaseModel):
     """Data used to create block document reference."""
 
-    id: UUID = FieldFrom(objects.BlockDocumentReference)
-    parent_block_document_id: UUID = FieldFrom(objects.BlockDocumentReference)
-    reference_block_document_id: UUID = FieldFrom(objects.BlockDocumentReference)
-    name: str = FieldFrom(objects.BlockDocumentReference)
+    id: UUID = Field(default_factory=uuid4)
+    parent_block_document_id: UUID = Field(
+        default=..., description="ID of block document the reference is nested within"
+    )
+    reference_block_document_id: UUID = Field(
+        default=..., description="ID of the nested block document"
+    )
+    name: str = Field(
+        default=..., description="The name that the reference is nested under"
+    )
 
 
-@copy_model_fields
 class LogCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a log."""
 
-    name: str = FieldFrom(objects.Log)
-    level: int = FieldFrom(objects.Log)
-    message: str = FieldFrom(objects.Log)
-    timestamp: objects.DateTimeTZ = FieldFrom(objects.Log)
-    flow_run_id: Optional[UUID] = FieldFrom(objects.Log)
-    task_run_id: Optional[UUID] = FieldFrom(objects.Log)
+    name: str = Field(default=..., description="The logger name.")
+    level: int = Field(default=..., description="The log level.")
+    message: str = Field(default=..., description="The log message.")
+    timestamp: DateTimeTZ = Field(default=..., description="The log timestamp.")
+    flow_run_id: Optional[UUID] = Field(None)
+    task_run_id: Optional[UUID] = Field(None)
 
 
-@copy_model_fields
 class WorkPoolCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a work pool."""
 
-    name: str = FieldFrom(objects.WorkPool)
-    description: Optional[str] = FieldFrom(objects.WorkPool)
-    type: str = Field(description="The work pool type.", default="prefect-agent")
-    base_job_template: Dict[str, Any] = FieldFrom(objects.WorkPool)
-    is_paused: bool = FieldFrom(objects.WorkPool)
-    concurrency_limit: Optional[int] = FieldFrom(objects.WorkPool)
+    name: str = Field(
+        description="The name of the work pool.",
+    )
+    description: Optional[str] = Field(None)
+    type: str = Field(
+        description="The work pool type.", default="prefect-agent"
+    )  # TODO: change default
+    base_job_template: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="The base job template for the work pool.",
+    )
+    is_paused: bool = Field(
+        default=False,
+        description="Whether the work pool is paused.",
+    )
+    concurrency_limit: Optional[conint(ge=0)] = Field(
+        default=None, description="A concurrency limit for the work pool."
+    )
 
 
-@copy_model_fields
 class WorkPoolUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a work pool."""
 
-    description: Optional[str] = FieldFrom(objects.WorkPool)
-    is_paused: Optional[bool] = FieldFrom(objects.WorkPool)
-    base_job_template: Optional[Dict[str, Any]] = FieldFrom(objects.WorkPool)
-    concurrency_limit: Optional[int] = FieldFrom(objects.WorkPool)
+    description: Optional[str] = Field(None)
+    is_paused: Optional[bool] = Field(None)
+    base_job_template: Optional[Dict[str, Any]] = Field(None)
+    concurrency_limit: Optional[int] = Field(None)
 
 
-@copy_model_fields
 class WorkQueueCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a work queue."""
 
-    name: str = FieldFrom(objects.WorkQueue)
-    description: Optional[str] = FieldFrom(objects.WorkQueue)
-    is_paused: bool = FieldFrom(objects.WorkQueue)
-    concurrency_limit: Optional[int] = FieldFrom(objects.WorkQueue)
+    name: str = Field(default=..., description="The name of the work queue.")
+    description: Optional[str] = Field(None)
+    is_paused: bool = Field(
+        default=False,
+        description="Whether the work queue is paused.",
+    )
+    concurrency_limit: Optional[int] = Field(
+        default=None,
+        description="A concurrency limit for the work queue.",
+    )
     priority: Optional[int] = Field(
         default=None,
         description=(
@@ -542,16 +561,17 @@ class WorkQueueCreate(ActionBaseModel):
     )
 
 
-@copy_model_fields
 class WorkQueueUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a work queue."""
 
-    name: str = FieldFrom(objects.WorkQueue)
-    description: Optional[str] = FieldFrom(objects.WorkQueue)
-    is_paused: bool = FieldFrom(objects.WorkQueue)
-    concurrency_limit: Optional[int] = FieldFrom(objects.WorkQueue)
-    priority: Optional[int] = FieldFrom(objects.WorkQueue)
-    last_polled: Optional[DateTimeTZ] = FieldFrom(objects.WorkQueue)
+    name: Optional[str] = Field(None)
+    description: Optional[str] = Field(None)
+    is_paused: bool = Field(
+        default=False, description="Whether or not the work queue is paused."
+    )
+    concurrency_limit: Optional[int] = Field(None)
+    priority: Optional[int] = Field(None)
+    last_polled: Optional[DateTimeTZ] = Field(None)
 
     # DEPRECATED
 
@@ -562,67 +582,95 @@ class WorkQueueUpdate(ActionBaseModel):
     )
 
 
-@copy_model_fields
 class FlowRunNotificationPolicyCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a flow run notification policy."""
 
-    is_active: bool = FieldFrom(objects.FlowRunNotificationPolicy)
-    state_names: List[str] = FieldFrom(objects.FlowRunNotificationPolicy)
-    tags: List[str] = FieldFrom(objects.FlowRunNotificationPolicy)
-    block_document_id: UUID = FieldFrom(objects.FlowRunNotificationPolicy)
-    message_template: Optional[str] = FieldFrom(objects.FlowRunNotificationPolicy)
+    is_active: bool = Field(
+        default=True, description="Whether the policy is currently active"
+    )
+    state_names: List[str] = Field(
+        default=..., description="The flow run states that trigger notifications"
+    )
+    tags: List[str] = Field(
+        default=...,
+        description="The flow run tags that trigger notifications (set [] to disable)",
+    )
+    block_document_id: UUID = Field(
+        default=..., description="The block document ID used for sending notifications"
+    )
+    message_template: Optional[str] = Field(
+        default=None,
+        description=(
+            "A templatable notification message. Use {braces} to add variables."
+            " Valid variables include:"
+            f" {listrepr(sorted(objects.FLOW_RUN_NOTIFICATION_TEMPLATE_KWARGS), sep=', ')}"
+        ),
+        example=(
+            "Flow run {flow_run_name} with id {flow_run_id} entered state"
+            " {flow_run_state_name}."
+        ),
+    )
+
+    @validator("message_template")
+    def validate_message_template_variables(cls, v):
+        return validate_message_template_variables(v)
 
 
-@copy_model_fields
 class FlowRunNotificationPolicyUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a flow run notification policy."""
 
-    is_active: Optional[bool] = FieldFrom(objects.FlowRunNotificationPolicy)
-    state_names: Optional[List[str]] = FieldFrom(objects.FlowRunNotificationPolicy)
-    tags: Optional[List[str]] = FieldFrom(objects.FlowRunNotificationPolicy)
-    block_document_id: Optional[UUID] = FieldFrom(objects.FlowRunNotificationPolicy)
-    message_template: Optional[str] = FieldFrom(objects.FlowRunNotificationPolicy)
+    is_active: Optional[bool] = Field(None)
+    state_names: Optional[List[str]] = Field(None)
+    tags: Optional[List[str]] = Field(None)
+    block_document_id: Optional[UUID] = Field(None)
+    message_template: Optional[str] = Field(None)
 
 
-@copy_model_fields
 class ArtifactCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create an artifact."""
 
-    key: Optional[str] = FieldFrom(objects.Artifact)
-    type: Optional[str] = FieldFrom(objects.Artifact)
-    description: Optional[str] = FieldFrom(objects.Artifact)
-    data: Optional[Union[Dict[str, Any], Any]] = FieldFrom(objects.Artifact)
-    metadata_: Optional[Dict[str, str]] = FieldFrom(objects.Artifact)
-    flow_run_id: Optional[UUID] = FieldFrom(objects.Artifact)
-    task_run_id: Optional[UUID] = FieldFrom(objects.Artifact)
+    key: Optional[str] = Field(None)
+    type: Optional[str] = Field(None)
+    description: Optional[str] = Field(None)
+    data: Optional[Union[Dict[str, Any], Any]] = Field(None)
+    metadata_: Optional[Dict[str, str]] = Field(None)
+    flow_run_id: Optional[UUID] = Field(None)
+    task_run_id: Optional[UUID] = Field(None)
 
     _validate_artifact_format = validator("key", allow_reuse=True)(
         validate_artifact_key
     )
 
 
-@copy_model_fields
 class ArtifactUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update an artifact."""
 
-    data: Optional[Union[Dict[str, Any], Any]] = FieldFrom(objects.Artifact)
-    description: Optional[str] = FieldFrom(objects.Artifact)
-    metadata_: Optional[Dict[str, str]] = FieldFrom(objects.Artifact)
+    data: Optional[Union[Dict[str, Any], Any]] = Field(None)
+    description: Optional[str] = Field(None)
+    metadata_: Optional[Dict[str, str]] = Field(None)
 
 
-@copy_model_fields
 class VariableCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a Variable."""
 
-    name: str = FieldFrom(objects.Variable)
-    value: str = FieldFrom(objects.Variable)
-    tags: Optional[List[str]] = FieldFrom(objects.Variable)
+    name: str = Field(
+        default=...,
+        description="The name of the variable",
+        example="my_variable",
+        max_length=objects.MAX_VARIABLE_NAME_LENGTH,
+    )
+    value: str = Field(
+        default=...,
+        description="The value of the variable",
+        example="my-value",
+        max_length=objects.MAX_VARIABLE_VALUE_LENGTH,
+    )
+    tags: Optional[List[str]] = Field(default=None)
 
     # validators
     _validate_name_format = validator("name", allow_reuse=True)(validate_variable_name)
 
 
-@copy_model_fields
 class VariableUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a Variable."""
 
@@ -638,29 +686,44 @@ class VariableUpdate(ActionBaseModel):
         example="my-value",
         max_length=objects.MAX_VARIABLE_NAME_LENGTH,
     )
-    tags: Optional[List[str]] = FieldFrom(objects.Variable)
+    tags: Optional[List[str]] = Field(default=None)
 
     # validators
     _validate_name_format = validator("name", allow_reuse=True)(validate_variable_name)
 
 
-@copy_model_fields
 class GlobalConcurrencyLimitCreate(ActionBaseModel):
     """Data used by the Prefect REST API to create a global concurrency limit."""
 
-    name: str = FieldFrom(objects.GlobalConcurrencyLimit)
-    limit: int = FieldFrom(objects.GlobalConcurrencyLimit)
-    active: Optional[bool] = FieldFrom(objects.GlobalConcurrencyLimit)
-    active_slots: Optional[int] = FieldFrom(objects.GlobalConcurrencyLimit)
-    slot_decay_per_second: Optional[float] = FieldFrom(objects.GlobalConcurrencyLimit)
+    name: str = Field(description="The name of the global concurrency limit.")
+    limit: int = Field(
+        description=(
+            "The maximum number of slots that can be occupied on this concurrency"
+            " limit."
+        )
+    )
+    active: Optional[bool] = Field(
+        default=True,
+        description="Whether or not the concurrency limit is in an active state.",
+    )
+    active_slots: Optional[int] = Field(
+        default=0,
+        description="Number of tasks currently using a concurrency slot.",
+    )
+    slot_decay_per_second: Optional[float] = Field(
+        default=0.0,
+        description=(
+            "Controls the rate at which slots are released when the concurrency limit"
+            " is used as a rate limit."
+        ),
+    )
 
 
-@copy_model_fields
 class GlobalConcurrencyLimitUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a global concurrency limit."""
 
-    name: Optional[str] = FieldFrom(objects.GlobalConcurrencyLimit)
-    limit: Optional[int] = FieldFrom(objects.GlobalConcurrencyLimit)
-    active: Optional[bool] = FieldFrom(objects.GlobalConcurrencyLimit)
-    active_slots: Optional[int] = FieldFrom(objects.GlobalConcurrencyLimit)
-    slot_decay_per_second: Optional[float] = FieldFrom(objects.GlobalConcurrencyLimit)
+    name: Optional[str] = Field(None)
+    limit: Optional[int] = Field(None)
+    active: Optional[bool] = Field(None)
+    active_slots: Optional[int] = Field(None)
+    slot_decay_per_second: Optional[float] = Field(None)