prefect-client 2.16.8__py3-none-any.whl → 2.17.0__py3-none-any.whl

prefect/client/schemas/responses.py

@@ -2,6 +2,7 @@ import datetime
 from typing import Any, Dict, List, Optional, TypeVar, Union
 from uuid import UUID
 
+from prefect._internal.compatibility.deprecated import DeprecatedInfraOverridesField
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 
 if HAS_PYDANTIC_V2:
@@ -14,9 +15,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 +155,145 @@ 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."
+        ),
+        examples=["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."
+        ),
+    )
+    deployment_version: Optional[str] = Field(
+        default=None,
+        description="The version of the deployment associated with this flow run.",
+        examples=["1.0"],
+    )
+    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.",
+        examples=["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.",
+        examples=[{"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",
+        examples=[["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",
+        examples=["my-work-pool"],
+    )
+    state: Optional[objects.State] = Field(
+        default=None,
+        description="The state of the flow run.",
+        examples=[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."
     )
-    state: Optional[objects.State] = FieldFrom(objects.FlowRun)
-    job_variables: Optional[dict] = FieldFrom(objects.FlowRun)
 
     def __eq__(self, other: Any) -> bool:
         """
@@ -199,7 +302,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 +310,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)
+class DeploymentResponse(DeprecatedInfraOverridesField, ObjectBaseModel):
+    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."
+    )
+    job_variables: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Overrides to apply to flow run infrastructure 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",
+        examples=[["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,12 +420,11 @@ class DeploymentResponse(ObjectBaseModel):
         default=None,
         description="Current status of the deployment.",
     )
-    enforce_parameter_schema: bool = FieldFrom(objects.Deployment)
 
 
 class MinimalConcurrencyLimitResponse(PrefectBaseModel):
     class Config:
-        extra = "ignore"
+        extra = "ignore"  # 2024/4/1
 
     id: UUID
     name: str

prefect/client/schemas/schedules.py

@@ -10,6 +10,8 @@ import dateutil.rrule
 import pendulum
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
+from prefect._internal.schemas.bases import PrefectBaseModel
+from prefect._internal.schemas.fields import DateTimeTZ
 from prefect._internal.schemas.validators import (
     default_anchor_date,
     default_timezone,
@@ -24,10 +26,6 @@ if HAS_PYDANTIC_V2:
 else:
     from pydantic import Field, validator
 
-
-from prefect._internal.schemas.bases import PrefectBaseModel
-from prefect._internal.schemas.fields import DateTimeTZ
-
 MAX_ITERATIONS = 1000
 # approx. 1 years worth of RDATEs + buffer
 MAX_RRULE_LENGTH = 6500
@@ -68,7 +66,7 @@ class IntervalSchedule(PrefectBaseModel):
 
     interval: datetime.timedelta
     anchor_date: DateTimeTZ = None
-    timezone: Optional[str] = Field(default=None, example="America/New_York")
+    timezone: Optional[str] = Field(default=None, examples=["America/New_York"])
 
     @validator("interval")
     def validate_interval_schedule(cls, v):
@@ -111,8 +109,8 @@ class CronSchedule(PrefectBaseModel):
     class Config:
         extra = "forbid"
 
-    cron: str = Field(default=..., example="0 0 * * *")
-    timezone: Optional[str] = Field(default=None, example="America/New_York")
+    cron: str = Field(default=..., examples=["0 0 * * *"])
+    timezone: Optional[str] = Field(default=None, examples=["America/New_York"])
     day_or: bool = Field(
         default=True,
         description=(
@@ -156,7 +154,7 @@ class RRuleSchedule(PrefectBaseModel):
         extra = "forbid"
 
     rrule: str
-    timezone: Optional[str] = Field(default=None, example="America/New_York")
+    timezone: Optional[str] = Field(default=None, examples=["America/New_York"])
 
     @validator("rrule")
     def validate_rrule_str(cls, v):

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
@@ -18,6 +19,7 @@ from typing import (
     Any,
     ContextManager,
     Dict,
+    Generator,
     List,
     Optional,
     Set,
@@ -75,7 +77,7 @@ class ContextModel(BaseModel):
     _token: Token = PrivateAttr(None)
 
     class Config:
-        allow_mutation = False
+        # allow_mutation = False
         arbitrary_types_allowed = True
         extra = "forbid"
 
@@ -394,7 +396,7 @@ def get_settings_context() -> SettingsContext:
 
 
 @contextmanager
-def tags(*new_tags: str) -> Set[str]:
+def tags(*new_tags: str) -> Generator[Set[str], None, None]:
     """
     Context manager to add tags to flow and task run calls.
 

prefect/deployments/base.py

@@ -4,6 +4,7 @@ build system for managing flows and deployments.
 
 To get started, follow along with [the deloyments tutorial](/tutorials/deployments/).
 """
+
 import ast
 import asyncio
 import json
@@ -13,18 +14,10 @@ import subprocess
 import sys
 from copy import deepcopy
 from pathlib import Path
-from typing import Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 
 import anyio
 import yaml
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import BaseModel
-else:
-    from pydantic import BaseModel
-
 from ruamel.yaml import YAML
 
 from prefect.client.schemas.objects import MinimalDeploymentSchedule
@@ -74,7 +67,7 @@ def set_prefect_hidden_dir(path: str = None) -> bool:
 
 
 def create_default_prefect_yaml(
-    path: str, name: str = None, contents: dict = None
+    path: str, name: str = None, contents: Optional[Dict[str, Any]] = None
 ) -> bool:
     """
     Creates default `prefect.yaml` file in the provided path if one does not already exist;
@@ -221,7 +214,7 @@ def _get_git_branch() -> Optional[str]:
 
 
 def initialize_project(
-    name: str = None, recipe: str = None, inputs: dict = None
+    name: str = None, recipe: str = None, inputs: Optional[Dict[str, Any]] = None
 ) -> List[str]:
     """
     Initializes a basic project structure with base files.  If no name is provided, the name
@@ -408,7 +401,7 @@ def _format_deployment_for_saving_to_prefect_file(
     if deployment.get("schedule"):
         if isinstance(deployment["schedule"], IntervalSchedule):
             deployment["schedule"] = _interval_schedule_to_dict(deployment["schedule"])
-        elif isinstance(deployment["schedule"], BaseModel):
+        else:  # all valid SCHEDULE_TYPES are subclasses of BaseModel
             deployment["schedule"] = deployment["schedule"].dict()
 
         if "is_schedule_active" in deployment:
@@ -423,7 +416,7 @@ def _format_deployment_for_saving_to_prefect_file(
                 schedule_config = _interval_schedule_to_dict(
                     deployment_schedule.schedule
                 )
-            elif isinstance(deployment_schedule.schedule, BaseModel):
+            else:  # all valid SCHEDULE_TYPES are subclasses of BaseModel
                 schedule_config = deployment_schedule.schedule.dict()
 
             schedule_config["active"] = deployment_schedule.active

prefect/deployments/deployments.py

@@ -17,8 +17,11 @@ import pendulum
 import yaml
 
 from prefect._internal.compatibility.deprecated import (
+    DeprecatedInfraOverridesField,
     deprecated_callable,
     deprecated_class,
+    deprecated_parameter,
+    handle_deprecated_infra_overrides_parameter,
 )
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect._internal.schemas.validators import (
@@ -71,6 +74,11 @@ logger = get_logger("deployments")
 
 
 @sync_compatible
+@deprecated_parameter(
+    "infra_overrides",
+    start_date="Apr 2024",
+    help="Use `job_variables` instead.",
+)
 @inject_client
 async def run_deployment(
     name: Union[str, UUID],
@@ -84,6 +92,7 @@ async def run_deployment(
     idempotency_key: Optional[str] = None,
     work_queue_name: Optional[str] = None,
     as_subflow: Optional[bool] = True,
+    infra_overrides: Optional[dict] = None,
     job_variables: Optional[dict] = None,
 ) -> FlowRun:
     """
@@ -103,7 +112,7 @@ async def run_deployment(
 
     Args:
         name: The deployment id or deployment name in the form:
-            `<slugified-flow-name>/<slugified-deployment-name>`
+            `"flow name/deployment name"`
         parameters: Parameter overrides for this flow run. Merged with the deployment
             defaults.
         scheduled_time: The time to schedule the flow run for, defaults to scheduling
@@ -122,6 +131,9 @@ async def run_deployment(
             the default work queue for the deployment.
         as_subflow: Whether to link the flow run as a subflow of the current
             flow or task run.
+        job_variables: A dictionary of dot delimited infrastructure overrides that
+            will be applied at runtime; for example `env.CONFIG_KEY=config_value` or
+            `namespace='prefect'`
     """
     if timeout is not None and timeout < 0:
         raise ValueError("`timeout` cannot be negative")
@@ -129,6 +141,8 @@ async def run_deployment(
     if scheduled_time is None:
         scheduled_time = pendulum.now("UTC")
 
+    jv = handle_deprecated_infra_overrides_parameter(job_variables, infra_overrides)
+
     parameters = parameters or {}
 
     deployment_id = None
@@ -204,7 +218,7 @@ async def run_deployment(
         idempotency_key=idempotency_key,
         parent_task_run_id=parent_task_run_id,
         work_queue_name=work_queue_name,
-        job_variables=job_variables,
+        job_variables=jv,
     )
 
     flow_run_id = flow_run.id
@@ -334,7 +348,7 @@ def load_deployments_from_yaml(
     " Refer to the upgrade guide for more information:"
     " https://docs.prefect.io/latest/guides/upgrade-guide-agents-to-workers/.",
 )
-class Deployment(BaseModel):
+class Deployment(DeprecatedInfraOverridesField, BaseModel):
     """
     DEPRECATION WARNING:
 
@@ -363,7 +377,7 @@ class Deployment(BaseModel):
         infrastructure: An optional infrastructure block used to configure
             infrastructure for runs; if not provided, will default to running this
             deployment in Agent subprocesses
-        infra_overrides: A dictionary of dot delimited infrastructure overrides that
+        job_variables: A dictionary of dot delimited infrastructure overrides that
             will be applied at runtime; for example `env.CONFIG_KEY=config_value` or
             `namespace='prefect'`
         storage: An optional remote storage block used to store and retrieve this
@@ -405,7 +419,7 @@ class Deployment(BaseModel):
         ...     version="2",
         ...     tags=["aws"],
         ...     storage=storage,
-        ...     infra_overrides=dict("env.PREFECT_LOGGING_LEVEL"="DEBUG"),
+        ...     job_variables=dict("env.PREFECT_LOGGING_LEVEL"="DEBUG"),
         >>> )
         >>> deployment.apply()
 
@@ -429,6 +443,11 @@ class Deployment(BaseModel):
             "schedule",
             "schedules",
             "is_schedule_active",
+            # The `infra_overrides` field has been renamed to `job_variables`.
+            # We will continue writing it in the YAML file as `infra_overrides`
+            # instead of `job_variables` for better backwards compat, but we'll
+            # accept either `job_variables` or `infra_overrides` when we read
+            # the file.
             "infra_overrides",
         ]
 
@@ -478,10 +497,16 @@ class Deployment(BaseModel):
                 # write the field
                 yaml.dump({field: yaml_dict[field]}, f, sort_keys=False)
 
-            # write non-editable fields
+            # write non-editable fields, excluding `job_variables` because we'll
+            # continue writing it as `infra_overrides` for better backwards compat
+            # with the existing file format.
             f.write("\n###\n### DO NOT EDIT BELOW THIS LINE\n###\n")
             yaml.dump(
-                {k: v for k, v in yaml_dict.items() if k not in self._editable_fields},
+                {
+                    k: v
+                    for k, v in yaml_dict.items()
+                    if k not in self._editable_fields and k != "job_variables"
+                },
                 f,
                 sort_keys=False,
             )
@@ -558,7 +583,7 @@ class Deployment(BaseModel):
         ),
     )
     infrastructure: Infrastructure = Field(default_factory=Process)
-    infra_overrides: Dict[str, Any] = Field(
+    job_variables: Dict[str, Any] = Field(
         default_factory=dict,
         description="Overrides to apply to the base infrastructure block at runtime.",
     )
@@ -869,7 +894,7 @@ class Deployment(BaseModel):
                 manifest_path=self.manifest_path,  # allows for backwards YAML compat
                 path=self.path,
                 entrypoint=self.entrypoint,
-                infra_overrides=self.infra_overrides,
+                job_variables=self.job_variables,
                 storage_document_id=storage_document_id,
                 infrastructure_document_id=infrastructure_document_id,
                 parameter_openapi_schema=self.parameter_openapi_schema.dict(),