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

prefect/client/schemas/objects.py

@@ -29,8 +29,16 @@ from prefect._internal.schemas.fields import CreatedBy, DateTimeTZ, UpdatedBy
 from prefect._internal.schemas.validators import (
     get_or_create_run_name,
     get_or_create_state_name,
+    list_length_50_or_less,
     raise_on_name_alphanumeric_dashes_only,
     raise_on_name_with_banned_characters,
+    set_run_policy_deprecated_fields,
+    validate_default_queue_id_not_none,
+    validate_max_metadata_length,
+    validate_message_template_variables,
+    validate_name_present_on_nonanonymous_blocks,
+    validate_not_negative,
+    validate_parent_and_ref_diff,
 )
 from prefect.client.schemas.schedules import SCHEDULE_TYPES
 from prefect.settings import PREFECT_CLOUD_API_URL, PREFECT_CLOUD_UI_URL
@@ -296,7 +304,13 @@ class State(ObjectBaseModel, Generic[R]):
     def is_paused(self) -> bool:
         return self.type == StateType.PAUSED
 
-    def copy(self, *, update: dict = None, reset_fields: bool = False, **kwargs):
+    def copy(
+        self,
+        *,
+        update: Optional[Dict[str, Any]] = None,
+        reset_fields: bool = False,
+        **kwargs,
+    ):
         """
         Copying API models should return an object that could be inserted into the
         database again. The 'timestamp' is reset using the default factory.
@@ -387,18 +401,7 @@ class FlowRunPolicy(PrefectBaseModel):
 
     @root_validator
     def populate_deprecated_fields(cls, values):
-        """
-        If deprecated fields are provided, populate the corresponding new fields
-        to preserve orchestration behavior.
-        """
-        if not values.get("retries", None) and values.get("max_retries", 0) != 0:
-            values["retries"] = values["max_retries"]
-        if (
-            not values.get("retry_delay", None)
-            and values.get("retry_delay_seconds", 0) != 0
-        ):
-            values["retry_delay"] = values["retry_delay_seconds"]
-        return values
+        return set_run_policy_deprecated_fields(values)
 
 
 class FlowRun(ObjectBaseModel):
@@ -427,7 +430,7 @@ class FlowRun(ObjectBaseModel):
         description="The version of the flow executed in this flow run.",
         example="1.0",
     )
-    parameters: dict = Field(
+    parameters: Dict[str, Any] = Field(
         default_factory=dict, description="Parameters for the flow run."
     )
     idempotency_key: Optional[str] = Field(
@@ -437,7 +440,7 @@ class FlowRun(ObjectBaseModel):
             " run is not created multiple times."
         ),
     )
-    context: dict = Field(
+    context: Dict[str, Any] = Field(
         default_factory=dict,
         description="Additional context for the flow run.",
         example={"my_var": "my_val"},
@@ -526,6 +529,16 @@ class FlowRun(ObjectBaseModel):
         default=None, description="Job variables for the flow run."
     )
 
+    # These are server-side optimizations and should not be present on client models
+    # TODO: Deprecate these fields
+
+    state_type: Optional[StateType] = Field(
+        default=None, description="The type of the current flow run state."
+    )
+    state_name: Optional[str] = Field(
+        default=None, description="The name of the current flow run state."
+    )
+
     def __eq__(self, other: Any) -> bool:
         """
         Check for "equality" to another flow run schema
@@ -544,16 +557,6 @@ class FlowRun(ObjectBaseModel):
     def set_default_name(cls, name):
         return get_or_create_run_name(name)
 
-    # These are server-side optimizations and should not be present on client models
-    # TODO: Deprecate these fields
-
-    state_type: Optional[StateType] = Field(
-        default=None, description="The type of the current flow run state."
-    )
-    state_name: Optional[str] = Field(
-        default=None, description="The name of the current flow run state."
-    )
-
 
 class TaskRunPolicy(PrefectBaseModel):
     """Defines of how a task run should retry."""
@@ -585,32 +588,15 @@ class TaskRunPolicy(PrefectBaseModel):
 
     @root_validator
     def populate_deprecated_fields(cls, values):
-        """
-        If deprecated fields are provided, populate the corresponding new fields
-        to preserve orchestration behavior.
-        """
-        if not values.get("retries", None) and values.get("max_retries", 0) != 0:
-            values["retries"] = values["max_retries"]
-
-        if (
-            not values.get("retry_delay", None)
-            and values.get("retry_delay_seconds", 0) != 0
-        ):
-            values["retry_delay"] = values["retry_delay_seconds"]
-
-        return values
+        return set_run_policy_deprecated_fields(values)
 
     @validator("retry_delay")
     def validate_configured_retry_delays(cls, v):
-        if isinstance(v, list) and (len(v) > 50):
-            raise ValueError("Can not configure more than 50 retry delays per task.")
-        return v
+        return list_length_50_or_less(v)
 
     @validator("retry_jitter_factor")
     def validate_jitter_factor(cls, v):
-        if v is not None and v < 0:
-            raise ValueError("`retry_jitter_factor` must be >= 0.")
-        return v
+        return validate_not_negative(v)
 
 
 class TaskRunInput(PrefectBaseModel):
@@ -834,7 +820,7 @@ class BlockSchema(ObjectBaseModel):
     """A representation of a block schema."""
 
     checksum: str = Field(default=..., description="The block schema's unique checksum")
-    fields: dict = Field(
+    fields: Dict[str, Any] = Field(
         default_factory=dict, description="The block schema's field schema"
     )
     block_type_id: Optional[UUID] = Field(default=..., description="A block type ID")
@@ -860,7 +846,9 @@ class BlockDocument(ObjectBaseModel):
             "The block document's name. Not required for anonymous block documents."
         ),
     )
-    data: dict = Field(default_factory=dict, description="The block document's data")
+    data: Dict[str, Any] = Field(
+        default_factory=dict, description="The block document's data"
+    )
     block_schema_id: UUID = Field(default=..., description="A block schema ID")
     block_schema: Optional[BlockSchema] = Field(
         default=None, description="The associated block schema"
@@ -889,11 +877,7 @@ class BlockDocument(ObjectBaseModel):
 
     @root_validator
     def validate_name_is_present_if_not_anonymous(cls, values):
-        # anonymous blocks may have no name prior to actually being
-        # stored in the database
-        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)
 
 
 class Flow(ObjectBaseModel):
@@ -913,34 +897,14 @@ class Flow(ObjectBaseModel):
         return raise_on_name_with_banned_characters(v)
 
 
-class FlowRunnerSettings(PrefectBaseModel):
-    """
-    An API schema for passing details about the flow runner.
-
-    This schema is agnostic to the types and configuration provided by clients
-    """
-
-    type: Optional[str] = Field(
-        default=None,
-        description=(
-            "The type of the flow runner which can be used by the client for"
-            " dispatching."
-        ),
+class MinimalDeploymentSchedule(PrefectBaseModel):
+    schedule: SCHEDULE_TYPES = Field(
+        default=..., description="The schedule for the deployment."
     )
-    config: Optional[dict] = Field(
-        default=None, description="The configuration for the given flow runner type."
+    active: bool = Field(
+        default=True, description="Whether or not the schedule is active."
     )
 
-    # The following is required for composite compatibility in the ORM
-
-    def __init__(self, type: str = None, config: dict = None, **kwargs) -> None:
-        # Pydantic does not support positional arguments so they must be converted to
-        # keyword arguments
-        super().__init__(type=type, config=config, **kwargs)
-
-    def __composite_values__(self):
-        return self.type, self.config
-
 
 class DeploymentSchedule(ObjectBaseModel):
     deployment_id: Optional[UUID] = Field(
@@ -955,15 +919,6 @@ class DeploymentSchedule(ObjectBaseModel):
     )
 
 
-class MinimalDeploymentSchedule(PrefectBaseModel):
-    schedule: SCHEDULE_TYPES = Field(
-        default=..., description="The schedule for the deployment."
-    )
-    active: bool = Field(
-        default=True, description="Whether or not the schedule is active."
-    )
-
-
 class Deployment(ObjectBaseModel):
     """An ORM representation of deployment data."""
 
@@ -1091,7 +1046,7 @@ class BlockSchema(ObjectBaseModel):
     """An ORM representation of a block schema."""
 
     checksum: str = Field(default=..., description="The block schema's unique checksum")
-    fields: dict = Field(
+    fields: Dict[str, Any] = Field(
         default_factory=dict, description="The block schema's field schema"
     )
     block_type_id: Optional[UUID] = Field(default=..., description="A block type ID")
@@ -1149,21 +1104,14 @@ class BlockDocumentReference(ObjectBaseModel):
 
     @root_validator
     def validate_parent_and_ref_are_different(cls, values):
-        parent_id = values.get("parent_block_document_id")
-        ref_id = values.get("reference_block_document_id")
-        if parent_id and ref_id and parent_id == ref_id:
-            raise ValueError(
-                "`parent_block_document_id` and `reference_block_document_id` cannot be"
-                " the same"
-            )
-        return values
+        return validate_parent_and_ref_diff(values)
 
 
 class Configuration(ObjectBaseModel):
     """An ORM representation of account info."""
 
     key: str = Field(default=..., description="Account info key")
-    value: dict = Field(default=..., description="Account info")
+    value: Dict[str, Any] = Field(default=..., description="Account info")
 
 
 class SavedSearchFilter(PrefectBaseModel):
@@ -1355,12 +1303,7 @@ class FlowRunNotificationPolicy(ObjectBaseModel):
 
     @validator("message_template")
     def validate_message_template_variables(cls, v):
-        if v is not None:
-            try:
-                v.format(**{k: "test" for k in FLOW_RUN_NOTIFICATION_TEMPLATE_KWARGS})
-            except KeyError as exc:
-                raise ValueError(f"Invalid template variable provided: '{exc.args[0]}'")
-        return v
+        return validate_message_template_variables(v)
 
 
 class Agent(ObjectBaseModel):
@@ -1425,23 +1368,7 @@ class WorkPool(ObjectBaseModel):
 
     @validator("default_queue_id", always=True)
     def helpful_error_for_missing_default_queue_id(cls, v):
-        """
-        Default queue ID is required because all pools must have a default queue
-        ID, but it represents a circular foreign key relationship to a
-        WorkQueue (which can't be created until the work pool exists).
-        Therefore, while this field can *technically* be null, it shouldn't be.
-        This should only be an issue when creating new pools, as reading
-        existing ones will always have this field populated. This custom error
-        message will help users understand that they should use the
-        `actions.WorkPoolCreate` model in that case.
-        """
-        if v is None:
-            raise ValueError(
-                "`default_queue_id` is a required field. If you are "
-                "creating a new WorkPool and don't have a queue "
-                "ID yet, use the `actions.WorkPoolCreate` model instead."
-            )
-        return v
+        return validate_default_queue_id_not_none(v)
 
 
 class Worker(ObjectBaseModel):
@@ -1508,13 +1435,7 @@ class Artifact(ObjectBaseModel):
 
     @validator("metadata_")
     def validate_metadata_length(cls, v):
-        max_metadata_length = 500
-        if not isinstance(v, dict):
-            return v
-        for key in v.keys():
-            if len(str(v[key])) > max_metadata_length:
-                v[key] = str(v[key])[:max_metadata_length] + "..."
-        return v
+        return validate_max_metadata_length(v)
 
 
 class ArtifactCollection(ObjectBaseModel):

prefect/client/schemas/responses.py

@@ -14,9 +14,9 @@ from typing_extensions import Literal
 import prefect.client.schemas.objects as objects
 from prefect._internal.schemas.bases import ObjectBaseModel, PrefectBaseModel
 from prefect._internal.schemas.fields import CreatedBy, DateTimeTZ, UpdatedBy
-from prefect._internal.schemas.transformations import FieldFrom, copy_model_fields
 from prefect.client.schemas.schedules import SCHEDULE_TYPES
 from prefect.utilities.collections import AutoEnum
+from prefect.utilities.names import generate_slug
 
 R = TypeVar("R")
 
@@ -154,43 +154,140 @@ class WorkerFlowRunResponse(PrefectBaseModel):
     flow_run: objects.FlowRun
 
 
-@copy_model_fields
 class FlowRunResponse(ObjectBaseModel):
-    name: str = FieldFrom(objects.FlowRun)
-    flow_id: UUID = FieldFrom(objects.FlowRun)
-    state_id: Optional[UUID] = FieldFrom(objects.FlowRun)
-    deployment_id: Optional[UUID] = FieldFrom(objects.FlowRun)
-    work_queue_id: Optional[UUID] = FieldFrom(objects.FlowRun)
-    work_queue_name: Optional[str] = FieldFrom(objects.FlowRun)
-    flow_version: Optional[str] = FieldFrom(objects.FlowRun)
-    parameters: dict = FieldFrom(objects.FlowRun)
-    idempotency_key: Optional[str] = FieldFrom(objects.FlowRun)
-    context: dict = FieldFrom(objects.FlowRun)
-    empirical_policy: objects.FlowRunPolicy = FieldFrom(objects.FlowRun)
-    tags: List[str] = FieldFrom(objects.FlowRun)
-    parent_task_run_id: Optional[UUID] = FieldFrom(objects.FlowRun)
-    state_type: Optional[objects.StateType] = FieldFrom(objects.FlowRun)
-    state_name: Optional[str] = FieldFrom(objects.FlowRun)
-    run_count: int = FieldFrom(objects.FlowRun)
-    expected_start_time: Optional[DateTimeTZ] = FieldFrom(objects.FlowRun)
-    next_scheduled_start_time: Optional[DateTimeTZ] = FieldFrom(objects.FlowRun)
-    start_time: Optional[DateTimeTZ] = FieldFrom(objects.FlowRun)
-    end_time: Optional[DateTimeTZ] = FieldFrom(objects.FlowRun)
-    total_run_time: datetime.timedelta = FieldFrom(objects.FlowRun)
-    estimated_run_time: datetime.timedelta = FieldFrom(objects.FlowRun)
-    estimated_start_time_delta: datetime.timedelta = FieldFrom(objects.FlowRun)
-    auto_scheduled: bool = FieldFrom(objects.FlowRun)
-    infrastructure_document_id: Optional[UUID] = FieldFrom(objects.FlowRun)
-    infrastructure_pid: Optional[str] = FieldFrom(objects.FlowRun)
-    created_by: Optional[CreatedBy] = FieldFrom(objects.FlowRun)
-    work_pool_id: Optional[UUID] = FieldFrom(objects.FlowRun)
+    name: str = Field(
+        default_factory=lambda: generate_slug(2),
+        description=(
+            "The name of the flow run. Defaults to a random slug if not specified."
+        ),
+        example="my-flow-run",
+    )
+    flow_id: UUID = Field(default=..., description="The id of the flow being run.")
+    state_id: Optional[UUID] = Field(
+        default=None, description="The id of the flow run's current state."
+    )
+    deployment_id: Optional[UUID] = Field(
+        default=None,
+        description=(
+            "The id of the deployment associated with this flow run, if available."
+        ),
+    )
+    work_queue_name: Optional[str] = Field(
+        default=None, description="The work queue that handled this flow run."
+    )
+    flow_version: Optional[str] = Field(
+        default=None,
+        description="The version of the flow executed in this flow run.",
+        example="1.0",
+    )
+    parameters: Dict[str, Any] = Field(
+        default_factory=dict, description="Parameters for the flow run."
+    )
+    idempotency_key: Optional[str] = Field(
+        default=None,
+        description=(
+            "An optional idempotency key for the flow run. Used to ensure the same flow"
+            " run is not created multiple times."
+        ),
+    )
+    context: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Additional context for the flow run.",
+        example={"my_var": "my_val"},
+    )
+    empirical_policy: objects.FlowRunPolicy = Field(
+        default_factory=objects.FlowRunPolicy,
+    )
+    tags: List[str] = Field(
+        default_factory=list,
+        description="A list of tags on the flow run",
+        example=["tag-1", "tag-2"],
+    )
+    parent_task_run_id: Optional[UUID] = Field(
+        default=None,
+        description=(
+            "If the flow run is a subflow, the id of the 'dummy' task in the parent"
+            " flow used to track subflow state."
+        ),
+    )
+    run_count: int = Field(
+        default=0, description="The number of times the flow run was executed."
+    )
+    expected_start_time: Optional[DateTimeTZ] = Field(
+        default=None,
+        description="The flow run's expected start time.",
+    )
+    next_scheduled_start_time: Optional[DateTimeTZ] = Field(
+        default=None,
+        description="The next time the flow run is scheduled to start.",
+    )
+    start_time: Optional[DateTimeTZ] = Field(
+        default=None, description="The actual start time."
+    )
+    end_time: Optional[DateTimeTZ] = Field(
+        default=None, description="The actual end time."
+    )
+    total_run_time: datetime.timedelta = Field(
+        default=datetime.timedelta(0),
+        description=(
+            "Total run time. If the flow run was executed multiple times, the time of"
+            " each run will be summed."
+        ),
+    )
+    estimated_run_time: datetime.timedelta = Field(
+        default=datetime.timedelta(0),
+        description="A real-time estimate of the total run time.",
+    )
+    estimated_start_time_delta: datetime.timedelta = Field(
+        default=datetime.timedelta(0),
+        description="The difference between actual and expected start time.",
+    )
+    auto_scheduled: bool = Field(
+        default=False,
+        description="Whether or not the flow run was automatically scheduled.",
+    )
+    infrastructure_document_id: Optional[UUID] = Field(
+        default=None,
+        description="The block document defining infrastructure to use this flow run.",
+    )
+    infrastructure_pid: Optional[str] = Field(
+        default=None,
+        description="The id of the flow run as returned by an infrastructure block.",
+    )
+    created_by: Optional[CreatedBy] = Field(
+        default=None,
+        description="Optional information about the creator of this flow run.",
+    )
+    work_queue_id: Optional[UUID] = Field(
+        default=None, description="The id of the run's work pool queue."
+    )
+
+    work_pool_id: Optional[UUID] = Field(
+        description="The work pool with which the queue is associated."
+    )
     work_pool_name: Optional[str] = Field(
         default=None,
         description="The name of the flow run's work pool.",
         example="my-work-pool",
     )
-    state: Optional[objects.State] = FieldFrom(objects.FlowRun)
-    job_variables: Optional[dict] = FieldFrom(objects.FlowRun)
+    state: Optional[objects.State] = Field(
+        default=None,
+        description="The state of the flow run.",
+        example=objects.State(type=objects.StateType.COMPLETED),
+    )
+    job_variables: Optional[dict] = Field(
+        default=None, description="Job variables for the flow run."
+    )
+
+    # These are server-side optimizations and should not be present on client models
+    # TODO: Deprecate these fields
+
+    state_type: Optional[objects.StateType] = Field(
+        default=None, description="The type of the current flow run state."
+    )
+    state_name: Optional[str] = Field(
+        default=None, description="The name of the current flow run state."
+    )
 
     def __eq__(self, other: Any) -> bool:
         """
@@ -199,7 +296,7 @@ class FlowRunResponse(ObjectBaseModel):
         Estimates times are rolling and will always change with repeated queries for
         a flow run so we ignore them during equality checks.
         """
-        if isinstance(other, FlowRunResponse):
+        if isinstance(other, objects.FlowRun):
             exclude_fields = {"estimated_run_time", "estimated_start_time_delta"}
             return self.dict(exclude=exclude_fields) == other.dict(
                 exclude=exclude_fields
@@ -207,30 +304,108 @@ class FlowRunResponse(ObjectBaseModel):
         return super().__eq__(other)
 
 
-@copy_model_fields
 class DeploymentResponse(ObjectBaseModel):
-    name: str = FieldFrom(objects.Deployment)
-    version: Optional[str] = FieldFrom(objects.Deployment)
-    description: Optional[str] = FieldFrom(objects.Deployment)
-    flow_id: UUID = FieldFrom(objects.Deployment)
-    schedule: Optional[SCHEDULE_TYPES] = FieldFrom(objects.Deployment)
-    is_schedule_active: bool = FieldFrom(objects.Deployment)
-    paused: bool = FieldFrom(objects.Deployment)
-    schedules: List[objects.DeploymentSchedule] = FieldFrom(objects.Deployment)
-    infra_overrides: Dict[str, Any] = FieldFrom(objects.Deployment)
-    parameters: Dict[str, Any] = FieldFrom(objects.Deployment)
-    tags: List[str] = FieldFrom(objects.Deployment)
-    work_queue_name: Optional[str] = FieldFrom(objects.Deployment)
-    last_polled: Optional[DateTimeTZ] = FieldFrom(objects.Deployment)
-    parameter_openapi_schema: Optional[Dict[str, Any]] = FieldFrom(objects.Deployment)
-    path: Optional[str] = FieldFrom(objects.Deployment)
-    pull_steps: Optional[List[dict]] = 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)
-    created_by: Optional[CreatedBy] = FieldFrom(objects.Deployment)
-    updated_by: Optional[UpdatedBy] = FieldFrom(objects.Deployment)
+    name: str = Field(default=..., description="The name of the deployment.")
+    version: Optional[str] = Field(
+        default=None, description="An optional version for the deployment."
+    )
+    description: Optional[str] = Field(
+        default=None, description="A description for the deployment."
+    )
+    flow_id: UUID = Field(
+        default=..., description="The flow id associated with the deployment."
+    )
+    schedule: Optional[SCHEDULE_TYPES] = Field(
+        default=None, description="A schedule for the deployment."
+    )
+    is_schedule_active: bool = Field(
+        default=True, description="Whether or not the deployment schedule is active."
+    )
+    paused: bool = Field(
+        default=False, description="Whether or not the deployment is paused."
+    )
+    schedules: List[objects.DeploymentSchedule] = Field(
+        default_factory=list, description="A list of schedules for the deployment."
+    )
+    infra_overrides: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Overrides to apply to the base infrastructure block at runtime.",
+    )
+    parameters: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Parameters for flow runs scheduled by the deployment.",
+    )
+    pull_steps: Optional[List[dict]] = Field(
+        default=None,
+        description="Pull steps for cloning and running this deployment.",
+    )
+    tags: List[str] = Field(
+        default_factory=list,
+        description="A list of tags for the deployment",
+        example=["tag-1", "tag-2"],
+    )
+    work_queue_name: Optional[str] = Field(
+        default=None,
+        description=(
+            "The work queue for the deployment. If no work queue is set, work will not"
+            " be scheduled."
+        ),
+    )
+    last_polled: Optional[DateTimeTZ] = Field(
+        default=None,
+        description="The last time the deployment was polled for status updates.",
+    )
+    parameter_openapi_schema: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="The parameter schema of the flow, including defaults.",
+    )
+    path: Optional[str] = Field(
+        default=None,
+        description=(
+            "The path to the working directory for the workflow, relative to remote"
+            " storage or an absolute path."
+        ),
+    )
+    entrypoint: Optional[str] = Field(
+        default=None,
+        description=(
+            "The path to the entrypoint for the workflow, relative to the `path`."
+        ),
+    )
+    manifest_path: Optional[str] = Field(
+        default=None,
+        description=(
+            "The path to the flow's manifest file, relative to the chosen storage."
+        ),
+    )
+    storage_document_id: Optional[UUID] = Field(
+        default=None,
+        description="The block document defining storage used for this flow.",
+    )
+    infrastructure_document_id: Optional[UUID] = Field(
+        default=None,
+        description="The block document defining infrastructure to use for flow runs.",
+    )
+    created_by: Optional[CreatedBy] = Field(
+        default=None,
+        description="Optional information about the creator of this deployment.",
+    )
+    updated_by: Optional[UpdatedBy] = Field(
+        default=None,
+        description="Optional information about the updater of this deployment.",
+    )
+    work_queue_id: UUID = Field(
+        default=None,
+        description=(
+            "The id of the work pool queue to which this deployment is assigned."
+        ),
+    )
+    enforce_parameter_schema: bool = Field(
+        default=False,
+        description=(
+            "Whether or not the deployment should enforce the parameter schema."
+        ),
+    )
     work_pool_name: Optional[str] = Field(
         default=None,
         description="The name of the deployment's work pool.",
@@ -239,7 +414,6 @@ class DeploymentResponse(ObjectBaseModel):
         default=None,
         description="Current status of the deployment.",
     )
-    enforce_parameter_schema: bool = FieldFrom(objects.Deployment)
 
 
 class MinimalConcurrencyLimitResponse(PrefectBaseModel):

prefect/concurrency/events.py

@@ -20,8 +20,8 @@ def _emit_concurrency_event(
     }
 
     related = [
-        RelatedResource(
-            __root__={
+        RelatedResource.parse_obj(
+            {
                 "prefect.resource.id": f"prefect.concurrency-limit.{limit.id}",
                 "prefect.resource.role": "concurrency-limit",
             }

prefect/context.py

@@ -5,6 +5,7 @@ These contexts should never be directly mutated by the user.
 
 For more user-accessible information about the current run, see [`prefect.runtime`](../runtime/flow_run).
 """
+
 import os
 import sys
 import warnings
@@ -75,7 +76,7 @@ class ContextModel(BaseModel):
     _token: Token = PrivateAttr(None)
 
     class Config:
-        allow_mutation = False
+        # allow_mutation = False
         arbitrary_types_allowed = True
         extra = "forbid"