prefect 3.3.6.dev3__tar.gz → 3.3.7.dev1__tar.gz

{prefect-3.3.6.dev3 → prefect-3.3.7.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect
-Version: 3.3.6.dev3
+Version: 3.3.7.dev1
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io

prefect-3.3.7.dev1/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.3.7.dev1"
+__build_date__ = "2025-04-26 08:07:53.022993+00:00"
+__git_commit__ = "cd10dc7dbb1bf043aeec4d2b21cd3e68742f474a"
+__dirty__ = False

prefect-3.3.6.dev3/src/prefect/_experimental/bundles.py → prefect-3.3.7.dev1/src/prefect/_experimental/bundles/__init__.py

@@ -11,7 +11,7 @@ import sys
 from pathlib import Path
 from typing import Any, TypedDict
 
-import cloudpickle
+import cloudpickle  # pyright: ignore[reportMissingTypeStubs]
 
 from prefect.client.schemas.objects import FlowRun
 from prefect.context import SettingsContext, get_settings_context, serialize_context
@@ -22,12 +22,18 @@ from prefect.settings.context import get_current_settings
 from prefect.settings.models.root import Settings
 from prefect.utilities.slugify import slugify
 
-try:
-    import uv
+from .execute import execute_bundle_from_file
 
-    uv_path = uv.find_uv_bin()
-except (ImportError, ModuleNotFoundError):
-    uv_path = "uv"
+
+def _get_uv_path() -> str:
+    try:
+        import uv
+
+        uv_path = uv.find_uv_bin()
+    except (ImportError, ModuleNotFoundError):
+        uv_path = "uv"
+
+    return uv_path
 
 
 class SerializedBundle(TypedDict):
@@ -46,7 +52,7 @@ def _serialize_bundle_object(obj: Any) -> str:
     """
     Serializes an object to a string.
     """
-    return base64.b64encode(gzip.compress(cloudpickle.dumps(obj))).decode()
+    return base64.b64encode(gzip.compress(cloudpickle.dumps(obj))).decode()  # pyright: ignore[reportUnknownMemberType]
 
 
 def _deserialize_bundle_object(serialized_obj: str) -> Any:
@@ -80,7 +86,7 @@ def create_bundle_for_flow_run(
         "flow_run": flow_run.model_dump(mode="json"),
         "dependencies": subprocess.check_output(
             [
-                uv_path,
+                _get_uv_path(),
                 "pip",
                 "freeze",
                 # Exclude editable installs because we won't be able to install them in the execution environment
@@ -164,7 +170,7 @@ def execute_bundle_in_subprocess(
     # Install dependencies if necessary
     if dependencies := bundle.get("dependencies"):
         subprocess.check_call(
-            [uv_path, "pip", "install", *dependencies.split("\n")],
+            [_get_uv_path(), "pip", "install", *dependencies.split("\n")],
             # Copy the current environment to ensure we install into the correct venv
             env=os.environ,
         )
@@ -238,3 +244,13 @@ def convert_step_to_command(
     command.extend(["--key", key])
 
     return command
+
+
+__all__ = [
+    "execute_bundle_from_file",
+    "convert_step_to_command",
+    "create_bundle_for_flow_run",
+    "extract_flow_from_bundle",
+    "execute_bundle_in_subprocess",
+    "SerializedBundle",
+]

prefect-3.3.7.dev1/src/prefect/_experimental/bundles/execute.py

@@ -0,0 +1,34 @@
+import json
+
+import typer
+
+from prefect.utilities.asyncutils import run_coro_as_sync
+
+
+def execute_bundle_from_file(key: str):
+    """
+    Loads a bundle from a file and executes it.
+
+    Args:
+        key: The key of the bundle to execute.
+    """
+    with open(key, "r") as f:
+        bundle = json.load(f)
+
+    from prefect.runner.runner import Runner
+
+    run_coro_as_sync(Runner().execute_bundle(bundle))
+
+
+def _execute_bundle_from_file(key: str = typer.Option(...)):
+    """
+    Loads a bundle from a file and executes it.
+
+    Args:
+        key: The key of the bundle to execute.
+    """
+    execute_bundle_from_file(key)
+
+
+if __name__ == "__main__":
+    typer.run(_execute_bundle_from_file)

{prefect-3.3.6.dev3 → prefect-3.3.7.dev1}/src/prefect/_versioning.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 from enum import Enum
 from typing import Any, Callable, Coroutine, Dict, Literal, Optional
+from urllib.parse import urlparse
 
 from anyio import run_process
 from pydantic import Field, model_validator
@@ -49,7 +50,7 @@ async def get_github_version_info(
 
     Args:
         version: The commit SHA, falls back to GITHUB_SHA env var
-        branch: The git branch, falls back to GITHUB_REF env var
+        branch: The git branch, falls back to GITHUB_REF_NAME env var
         repository: The repository name, falls back to GITHUB_REPOSITORY env var
         url: The repository URL, constructed from GITHUB_SERVER_URL/GITHUB_REPOSITORY if not provided
 
@@ -60,14 +61,16 @@ async def get_github_version_info(
         ValueError: If any required fields cannot be determined
     """
     version = version or os.getenv("GITHUB_SHA")
-    branch = branch or os.getenv("GITHUB_REF")
+    branch = branch or os.getenv("GITHUB_REF_NAME")
     repository = repository or os.getenv("GITHUB_REPOSITORY")
     url = url or f"{os.getenv('GITHUB_SERVER_URL')}/{repository}"
 
     if not version:
         raise ValueError("version is required - must be provided or set in GITHUB_SHA")
     if not branch:
-        raise ValueError("branch is required - must be provided or set in GITHUB_REF")
+        raise ValueError(
+            "branch is required - must be provided or set in GITHUB_REF_NAME"
+        )
     if not repository:
         raise ValueError(
             "repository is required - must be provided or set in GITHUB_REPOSITORY"
@@ -104,8 +107,10 @@ async def get_git_version_info(
             remote_url = result.stdout.decode().strip()
 
             # Extract just the repository name (last part of the path)
-            repo_name = os.path.basename(remote_url.split(":")[1].rstrip(".git"))
-            repository = repo_name
+            repo_url = urlparse(remote_url)
+            repository = repo_url.path.strip("/")
+            if repository.endswith(".git"):
+                repository = repository[:-4]
 
         if not url and repository:
             # Use the full remote URL as the URL

{prefect-3.3.6.dev3 → prefect-3.3.7.dev1}/src/prefect/cli/deploy.py

@@ -769,7 +769,6 @@ async def _run_single_deploy(
 
     version_info = await _version_info_from_options(options, deploy_config)
 
-    app.console.print(f"Version info: {version_info}")
     apply_coro = deployment.apply(version_info=version_info)
     if TYPE_CHECKING:
         assert inspect.isawaitable(apply_coro)
@@ -866,15 +865,13 @@ async def _run_single_deploy(
 async def _version_info_from_options(
     options: dict[str, Any], deploy_config: dict[str, Any]
 ) -> VersionInfo | None:
-    if version_type := (
-        options.get("version_type") or deploy_config.get("version_type")
-    ):
-        app.console.print(f"Inferring version info for {version_type}...")
-        return await get_inferred_version_info(version_type)
-
     if version := options.get("version"):
         return VersionInfo(type="prefect:simple", version=version)
 
+    version_type = options.get("version_type") or deploy_config.get("version_type")
+    if version_info := await get_inferred_version_info(version_type):
+        return version_info
+
     return None
 
 

{prefect-3.3.6.dev3 → prefect-3.3.7.dev1}/src/prefect/cli/task_run.py

@@ -3,20 +3,27 @@ Command line interface for working with task runs
 """
 
 import logging
-from typing import List
+from datetime import datetime
+from typing import List, cast
 from uuid import UUID
 
-import httpx
 import typer
 from rich.pretty import Pretty
 from rich.table import Table
-from starlette import status
 
 from prefect.cli._types import PrefectTyper
 from prefect.cli._utilities import exit_with_error
 from prefect.cli.root import app
 from prefect.client.orchestration import get_client
-from prefect.client.schemas.filters import LogFilter, TaskRunFilter
+from prefect.client.schemas.filters import (
+    LogFilter,
+    LogFilterTaskRunId,
+    TaskRunFilter,
+    TaskRunFilterName,
+    TaskRunFilterState,
+    TaskRunFilterStateName,
+    TaskRunFilterStateType,
+)
 from prefect.client.schemas.objects import StateType
 from prefect.client.schemas.sorting import LogSort, TaskRunSort
 from prefect.exceptions import ObjectNotFound
@@ -42,11 +49,8 @@ async def inspect(id: UUID):
     async with get_client() as client:
         try:
             task_run = await client.read_task_run(id)
-        except httpx.HTTPStatusError as exc:
-            if exc.response.status_code == status.HTTP_404_NOT_FOUND:
-                exit_with_error(f"Task run {id!r} not found!")
-            else:
-                raise
+        except ObjectNotFound:
+            exit_with_error(f"Task run '{id}' not found!")
 
     app.console.print(Pretty(task_run))
 
@@ -64,22 +68,30 @@ async def ls(
     View recent task runs
     """
 
-    state_filter = {}
-    if state:
-        state_filter["name"] = {"any_": [s.capitalize() for s in state]}
-    if state_type:
-        state_filter["type"] = {"any_": state_type}
+    if state or state_type:
+        state_filter = TaskRunFilterState(
+            name=TaskRunFilterStateName(any_=[s.capitalize() for s in state])
+            if state
+            else None,
+            type=TaskRunFilterStateType(any_=state_type) if state_type else None,
+        )
+    else:
+        state_filter = None
 
     async with get_client() as client:
         task_runs = await client.read_task_runs(
             task_run_filter=TaskRunFilter(
-                name={"any_": task_run_name} if task_run_name else None,
-                state=state_filter if state_filter else None,
+                name=TaskRunFilterName(any_=task_run_name) if task_run_name else None,
+                state=state_filter,
             ),
             limit=limit,
             sort=TaskRunSort.EXPECTED_START_TIME_DESC,
         )
 
+    if not task_runs:
+        app.console.print("No task runs found.")
+        return
+
     table = Table(title="Task Runs")
     table.add_column("ID", justify="right", style="cyan", no_wrap=True)
     table.add_column("Task", style="blue", no_wrap=True)
@@ -87,18 +99,24 @@ async def ls(
     table.add_column("State", no_wrap=True)
     table.add_column("When", style="bold", no_wrap=True)
 
-    for task_run in sorted(task_runs, key=lambda d: d.created, reverse=True):
+    for task_run in sorted(
+        task_runs, key=lambda d: cast(datetime, d.created), reverse=True
+    ):
         task = task_run
-        timestamp = (
-            task_run.state.state_details.scheduled_time
-            if task_run.state.is_scheduled()
-            else task_run.state.timestamp
-        )
+        if task_run.state:
+            timestamp = (
+                task_run.state.state_details.scheduled_time
+                if task_run.state.is_scheduled()
+                else task_run.state.timestamp
+            )
+        else:
+            timestamp = task_run.created
+
         table.add_row(
             str(task_run.id),
             str(task.name),
             str(task_run.name),
-            str(task_run.state.type.value),
+            str(task_run.state.type.value) if task_run.state else "Unknown",
             human_friendly_diff(timestamp),
         )
 
@@ -118,7 +136,7 @@ async def logs(
         ),
     ),
     num_logs: int = typer.Option(
-        None,
+        LOGS_WITH_LIMIT_FLAG_DEFAULT_NUM_LOGS,
         "--num-logs",
         "-n",
         help=(
@@ -155,17 +173,11 @@ async def logs(
     if head and tail:
         exit_with_error("Please provide either a `head` or `tail` option but not both.")
 
-    user_specified_num_logs = (
-        num_logs or LOGS_WITH_LIMIT_FLAG_DEFAULT_NUM_LOGS
-        if head or tail or num_logs
-        else None
-    )
-
     # if using tail update offset according to LOGS_DEFAULT_PAGE_SIZE
     if tail:
-        offset = max(0, user_specified_num_logs - LOGS_DEFAULT_PAGE_SIZE)
+        offset = max(0, num_logs - LOGS_DEFAULT_PAGE_SIZE)
 
-    log_filter = LogFilter(task_run_id={"any_": [id]})
+    log_filter = LogFilter(task_run_id=LogFilterTaskRunId(any_=[id]))
 
     async with get_client() as client:
         # Get the task run
@@ -175,12 +187,8 @@ async def logs(
             exit_with_error(f"task run {str(id)!r} not found!")
 
         while more_logs:
-            num_logs_to_return_from_page = (
-                LOGS_DEFAULT_PAGE_SIZE
-                if user_specified_num_logs is None
-                else min(
-                    LOGS_DEFAULT_PAGE_SIZE, user_specified_num_logs - num_logs_returned
-                )
+            num_logs_to_return_from_page = min(
+                LOGS_DEFAULT_PAGE_SIZE, num_logs - num_logs_returned
             )
 
             # Get the next page of logs

{prefect-3.3.6.dev3 → prefect-3.3.7.dev1}/src/prefect/flows.py

@@ -65,7 +65,7 @@ from prefect.exceptions import (
     UnspecifiedFlowError,
 )
 from prefect.filesystems import LocalFileSystem, ReadableDeploymentStorage
-from prefect.futures import PrefectFuture
+from prefect.futures import PrefectFlowRunFuture, PrefectFuture
 from prefect.logging import get_logger
 from prefect.logging.loggers import flow_run_logger
 from prefect.results import ResultSerializer, ResultStorage
@@ -2104,6 +2104,106 @@ class InfrastructureBoundFlow(Flow[P, R]):
                 )
             )
 
+    def submit(self, *args: P.args, **kwargs: P.kwargs) -> PrefectFlowRunFuture[R]:
+        """
+        EXPERIMENTAL: This method is experimental and may be removed or changed in future
+            releases.
+
+        Submit the flow to run on remote infrastructure.
+
+        Args:
+            *args: Positional arguments to pass to the flow.
+            **kwargs: Keyword arguments to pass to the flow.
+
+        Returns:
+            A `PrefectFlowRunFuture` that can be used to retrieve the result of the flow run.
+
+        Examples:
+            Submit a flow to run on Kubernetes:
+
+            ```python
+            from prefect import flow
+            from prefect_kubernetes.experimental import kubernetes
+
+            @kubernetes(work_pool="my-kubernetes-work-pool")
+            @flow
+            def my_flow(x: int, y: int):
+                return x + y
+
+            future = my_flow.submit(x=1, y=2)
+            result = future.result()
+            print(result)
+            ```
+        """
+
+        async def submit_func():
+            async with self.worker_cls(work_pool_name=self.work_pool) as worker:
+                parameters = get_call_parameters(self, args, kwargs)
+                return await worker.submit(
+                    flow=self,
+                    parameters=parameters,
+                    job_variables=self.job_variables,
+                )
+
+        return run_coro_as_sync(submit_func())
+
+    def with_options(
+        self,
+        *,
+        name: Optional[str] = None,
+        version: Optional[str] = None,
+        retries: Optional[int] = None,
+        retry_delay_seconds: Optional[Union[int, float]] = None,
+        description: Optional[str] = None,
+        flow_run_name: Optional[Union[Callable[[], str], str]] = None,
+        task_runner: Union[
+            Type[TaskRunner[PrefectFuture[Any]]], TaskRunner[PrefectFuture[Any]], None
+        ] = None,
+        timeout_seconds: Union[int, float, None] = None,
+        validate_parameters: Optional[bool] = None,
+        persist_result: Optional[bool] = NotSet,  # type: ignore
+        result_storage: Optional[ResultStorage] = NotSet,  # type: ignore
+        result_serializer: Optional[ResultSerializer] = NotSet,  # type: ignore
+        cache_result_in_memory: Optional[bool] = None,
+        log_prints: Optional[bool] = NotSet,  # type: ignore
+        on_completion: Optional[list[FlowStateHook[P, R]]] = None,
+        on_failure: Optional[list[FlowStateHook[P, R]]] = None,
+        on_cancellation: Optional[list[FlowStateHook[P, R]]] = None,
+        on_crashed: Optional[list[FlowStateHook[P, R]]] = None,
+        on_running: Optional[list[FlowStateHook[P, R]]] = None,
+        job_variables: Optional[dict[str, Any]] = None,
+    ) -> "InfrastructureBoundFlow[P, R]":
+        new_flow = super().with_options(
+            name=name,
+            version=version,
+            retries=retries,
+            retry_delay_seconds=retry_delay_seconds,
+            description=description,
+            flow_run_name=flow_run_name,
+            task_runner=task_runner,
+            timeout_seconds=timeout_seconds,
+            validate_parameters=validate_parameters,
+            persist_result=persist_result,
+            result_storage=result_storage,
+            result_serializer=result_serializer,
+            cache_result_in_memory=cache_result_in_memory,
+            log_prints=log_prints,
+            on_completion=on_completion,
+            on_failure=on_failure,
+            on_cancellation=on_cancellation,
+            on_crashed=on_crashed,
+            on_running=on_running,
+        )
+        new_infrastructure_bound_flow = bind_flow_to_infrastructure(
+            new_flow,
+            self.work_pool,
+            self.worker_cls,
+            job_variables=job_variables
+            if job_variables is not None
+            else self.job_variables,
+        )
+        return new_infrastructure_bound_flow
+
 
 def bind_flow_to_infrastructure(
     flow: Flow[P, R],

{prefect-3.3.6.dev3 → prefect-3.3.7.dev1}/src/prefect/server/api/deployments.py

@@ -98,9 +98,31 @@ async def create_deployment(
             )
 
         # hydrate the input model into a full model
-        deployment_dict = deployment.model_dump(
-            exclude={"work_pool_name"}, exclude_unset=True
+        deployment_dict: dict = deployment.model_dump(
+            exclude={"work_pool_name"},
+            exclude_unset=True,
         )
+
+        requested_concurrency_limit = deployment_dict.pop(
+            "global_concurrency_limit_id", "unset"
+        )
+        if requested_concurrency_limit != "unset":
+            if requested_concurrency_limit:
+                concurrency_limit = (
+                    await models.concurrency_limits_v2.read_concurrency_limit(
+                        session=session,
+                        concurrency_limit_id=requested_concurrency_limit,
+                    )
+                )
+
+                if not concurrency_limit:
+                    raise HTTPException(
+                        status_code=status.HTTP_404_NOT_FOUND,
+                        detail="Concurrency limit not found",
+                    )
+
+            deployment_dict["concurrency_limit_id"] = requested_concurrency_limit
+
         if deployment.work_pool_name and deployment.work_queue_name:
             # If a specific pool name/queue name combination was provided, get the
             # ID for that work pool queue.
@@ -300,8 +322,24 @@ async def update_deployment(
                     detail="Invalid schema: Unable to validate schema with circular references.",
                 )
 
+        if deployment.global_concurrency_limit_id:
+            concurrency_limit = (
+                await models.concurrency_limits_v2.read_concurrency_limit(
+                    session=session,
+                    concurrency_limit_id=deployment.global_concurrency_limit_id,
+                )
+            )
+
+            if not concurrency_limit:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="Concurrency limit not found",
+                )
+
         result = await models.deployments.update_deployment(
-            session=session, deployment_id=deployment_id, deployment=deployment
+            session=session,
+            deployment_id=deployment_id,
+            deployment=deployment,
         )
 
         for schedule in schedules_to_patch:

{prefect-3.3.6.dev3 → prefect-3.3.7.dev1}/src/prefect/server/models/deployments.py

@@ -80,7 +80,7 @@ async def _delete_scheduled_runs(
 async def create_deployment(
     db: PrefectDBInterface,
     session: AsyncSession,
-    deployment: schemas.core.Deployment,
+    deployment: schemas.core.Deployment | schemas.actions.DeploymentCreate,
 ) -> Optional[orm_models.Deployment]:
     """Upserts a deployment.
 
@@ -102,7 +102,7 @@ async def create_deployment(
 
     schedules = deployment.schedules
     insert_values = deployment.model_dump_for_orm(
-        exclude_unset=True, exclude={"schedules"}
+        exclude_unset=True, exclude={"schedules", "version_info"}
     )
 
     requested_concurrency_limit = insert_values.pop("concurrency_limit", "unset")
@@ -122,6 +122,7 @@ async def create_deployment(
             "schedules",
             "job_variables",
             "concurrency_limit",
+            "version_info",
         },
     )
     if job_variables:
@@ -225,11 +226,17 @@ async def update_deployment(
     # the user, ignoring any defaults on the model
     update_data = deployment.model_dump_for_orm(
         exclude_unset=True,
-        exclude={"work_pool_name"},
+        exclude={"work_pool_name", "version_info"},
     )
 
+    requested_global_concurrency_limit_update = update_data.pop(
+        "global_concurrency_limit_id", "unset"
+    )
     requested_concurrency_limit_update = update_data.pop("concurrency_limit", "unset")
 
+    if requested_global_concurrency_limit_update != "unset":
+        update_data["concurrency_limit_id"] = requested_global_concurrency_limit_update
+
     # The job_variables field in client and server schemas is named
     # infra_overrides in the database.
     job_variables = update_data.pop("job_variables", None)

{prefect-3.3.6.dev3 → prefect-3.3.7.dev1}/src/prefect/server/schemas/actions.py

@@ -183,6 +183,10 @@ class DeploymentCreate(ActionBaseModel):
     concurrency_options: Optional[schemas.core.ConcurrencyOptions] = Field(
         default=None, description="The deployment's concurrency options."
     )
+    global_concurrency_limit_id: Optional[UUID] = Field(
+        default=None,
+        description="The ID of the global concurrency limit to apply to the deployment.",
+    )
     enforce_parameter_schema: bool = Field(
         default=True,
         description=(
@@ -274,6 +278,17 @@ class DeploymentCreate(ActionBaseModel):
         )
         return values
 
+    @model_validator(mode="before")
+    def _validate_concurrency_limits(cls, values: dict[str, Any]) -> dict[str, Any]:
+        """Validate that a deployment does not have both a concurrency limit and global concurrency limit."""
+        if values.get("concurrency_limit") and values.get(
+            "global_concurrency_limit_id"
+        ):
+            raise ValueError(
+                "A deployment cannot have both a concurrency limit and a global concurrency limit."
+            )
+        return values
+
 
 class DeploymentUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a deployment."""
@@ -298,6 +313,10 @@ class DeploymentUpdate(ActionBaseModel):
     concurrency_options: Optional[schemas.core.ConcurrencyOptions] = Field(
         default=None, description="The deployment's concurrency options."
     )
+    global_concurrency_limit_id: Optional[UUID] = Field(
+        default=None,
+        description="The ID of the global concurrency limit to apply to the deployment.",
+    )
     parameters: Optional[Dict[str, Any]] = Field(
         default=None,
         description="Parameters for flow runs scheduled by the deployment.",
@@ -334,6 +353,10 @@ class DeploymentUpdate(ActionBaseModel):
     )
     model_config: ClassVar[ConfigDict] = ConfigDict(populate_by_name=True)
 
+    version_info: Optional[schemas.core.VersionInfo] = Field(
+        default=None, description="A description of this version of the deployment."
+    )
+
     def check_valid_configuration(self, base_job_template: dict[str, Any]) -> None:
         """
         Check that the combination of base_job_template defaults and job_variables
@@ -361,6 +384,17 @@ class DeploymentUpdate(ActionBaseModel):
                 for error in errors:
                     raise error
 
+    @model_validator(mode="before")
+    def _validate_concurrency_limits(cls, values: dict[str, Any]) -> dict[str, Any]:
+        """Validate that a deployment does not have both a concurrency limit and global concurrency limit."""
+        if values.get("concurrency_limit") and values.get(
+            "global_concurrency_limit_id"
+        ):
+            raise ValueError(
+                "A deployment cannot have both a concurrency limit and a global concurrency limit."
+            )
+        return values
+
 
 class FlowRunUpdate(ActionBaseModel):
     """Data used by the Prefect REST API to update a flow run."""

{prefect-3.3.6.dev3 → prefect-3.3.7.dev1}/src/prefect/server/schemas/core.py

@@ -602,6 +602,10 @@ class Deployment(ORMBaseModel):
     concurrency_limit: Optional[NonNegativeInteger] = Field(
         default=None, description="The concurrency limit for the deployment."
     )
+    concurrency_limit_id: Optional[UUID] = Field(
+        default=None,
+        description="The concurrency limit id associated with the deployment.",
+    )
     concurrency_options: Optional[ConcurrencyOptions] = Field(
         default=None, description="The concurrency options for the deployment."
     )

{prefect-3.3.6.dev3 → prefect-3.3.7.dev1}/src/prefect/server/schemas/states.py

@@ -147,7 +147,7 @@ class State(StateBaseModel):
         field.
         """
 
-        field_keys = cls.model_json_schema()["properties"].keys()
+        field_keys = cls.model_fields.keys()
         state_data: dict[str, Any] = {
             field: getattr(orm_state, field, None)
             for field in field_keys

prefect-3.3.7.dev1/src/prefect/server/ui/assets/404-DAQLWYVo.js

@@ -0,0 +1,2 @@
+import{d as e,c as o,o as a,n as t,dB as n}from"./index-DHPxdPUs.js";import{u as r}from"./usePageTitle-N_Vwn3MG.js";const m=e({__name:"404",setup(s){return r("Page Not Found"),(c,p)=>(a(),o(t(n)))}});export{m as default};
+//# sourceMappingURL=404-DAQLWYVo.js.map