prefect-client 3.2.2__py3-none-any.whl → 3.2.4__py3-none-any.whl

prefect/__init__.py

@@ -3,7 +3,7 @@
 # Setup version and path constants
 
 import sys
-from . import _version
+from . import _build_info
 import importlib
 import pathlib
 from typing import TYPE_CHECKING, Any, Optional, TypedDict, cast
@@ -24,16 +24,14 @@ if TYPE_CHECKING:
         unmapped,
         serve,
         aserve,
-        deploy,
         pause_flow_run,
         resume_flow_run,
         suspend_flow_run,
     )
+    from prefect.deployments.runner import deploy
 
     __spec__: ModuleSpec
 
-    # Versioneer provides version information as dictionaries
-    # with these keys
     class VersionInfo(TypedDict("_FullRevisionId", {"full-revisionid": str})):
         version: str
         dirty: Optional[bool]
@@ -41,8 +39,17 @@ if TYPE_CHECKING:
         date: Optional[str]
 
 
-__version_info__: "VersionInfo" = cast("VersionInfo", _version.get_versions())
-__version__ = __version_info__["version"]
+__version__ = _build_info.__version__
+__version_info__: "VersionInfo" = cast(
+    "VersionInfo",
+    {
+        "version": __version__,
+        "date": _build_info.__build_date__,
+        "full-revisionid": _build_info.__git_commit__,
+        "error": None,
+        "dirty": _build_info.__dirty__,
+    },
+)
 
 # The absolute path to this module
 __module_path__: pathlib.Path = pathlib.Path(__file__).parent
@@ -56,12 +63,12 @@ __ui_static_subpath__: pathlib.Path = __module_path__ / "server" / "ui_build"
 # The absolute path to the built UI within the Python module
 __ui_static_path__: pathlib.Path = __module_path__ / "server" / "ui"
 
-del _version, pathlib
+del _build_info, pathlib
 
 _public_api: dict[str, tuple[Optional[str], str]] = {
     "allow_failure": (__spec__.parent, ".main"),
     "aserve": (__spec__.parent, ".main"),
-    "deploy": (__spec__.parent, ".main"),
+    "deploy": (__spec__.parent, ".deployments.runner"),
     "flow": (__spec__.parent, ".main"),
     "Flow": (__spec__.parent, ".main"),
     "get_client": (__spec__.parent, ".main"),

prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.2.4"
+__build_date__ = "2025-02-18 21:30:33.140267+00:00"
+__git_commit__ = "701e7f4891ec22af2cc202c9747be8763a5153f1"
+__dirty__ = False

prefect/client/orchestration/__init__.py

@@ -149,19 +149,30 @@ T = TypeVar("T")
 
 
 @overload
-def get_client(  # type: ignore # TODO
-    *,
-    httpx_settings: Optional[dict[str, Any]] = ...,
-    sync_client: Literal[False] = False,
+def get_client(
+    httpx_settings: Optional[dict[str, Any]],
+    sync_client: Literal[False],
 ) -> "PrefectClient": ...
 
 
+@overload
+def get_client(*, httpx_settings: Optional[dict[str, Any]]) -> "PrefectClient": ...
+
+
+@overload
+def get_client(*, sync_client: Literal[False] = False) -> "PrefectClient": ...
+
+
 @overload
 def get_client(
-    *, httpx_settings: Optional[dict[str, Any]] = ..., sync_client: Literal[True] = ...
+    httpx_settings: Optional[dict[str, Any]], sync_client: Literal[True]
 ) -> "SyncPrefectClient": ...
 
 
+@overload
+def get_client(*, sync_client: Literal[True]) -> "SyncPrefectClient": ...
+
+
 def get_client(
     httpx_settings: Optional[dict[str, Any]] = None, sync_client: bool = False
 ) -> Union["SyncPrefectClient", "PrefectClient"]:

prefect/main.py

@@ -1,6 +1,5 @@
 # Import user-facing API
 from typing import Any
-from prefect.deployments import deploy
 from prefect.states import State
 from prefect.logging import get_run_logger
 from prefect.flows import FlowDecorator, flow, Flow, serve, aserve
@@ -77,7 +76,6 @@ __all__ = [
     "unmapped",
     "serve",
     "aserve",
-    "deploy",
     "pause_flow_run",
     "resume_flow_run",
     "suspend_flow_run",

prefect/server/api/__init__.py

@@ -0,0 +1,34 @@
+from . import (
+    artifacts,
+    admin,
+    automations,
+    block_capabilities,
+    block_documents,
+    block_schemas,
+    block_types,
+    collections,
+    concurrency_limits,
+    concurrency_limits_v2,
+    csrf_token,
+    dependencies,
+    deployments,
+    events,
+    flow_run_notification_policies,
+    flow_run_states,
+    flow_runs,
+    flows,
+    logs,
+    middleware,
+    root,
+    run_history,
+    saved_searches,
+    task_run_states,
+    task_runs,
+    task_workers,
+    templates,
+    ui,
+    variables,
+    work_queues,
+    workers,
+)
+from . import server  # Server relies on all of the above routes

prefect/server/api/admin.py

@@ -0,0 +1,85 @@
+"""
+Routes for admin-level interactions with the Prefect REST API.
+"""
+
+from fastapi import Body, Depends, Response, status
+
+import prefect
+import prefect.settings
+from prefect.server.database import PrefectDBInterface, provide_database_interface
+from prefect.server.utilities.server import PrefectRouter
+
+router: PrefectRouter = PrefectRouter(prefix="/admin", tags=["Admin"])
+
+
+@router.get("/settings")
+async def read_settings() -> prefect.settings.Settings:
+    """
+    Get the current Prefect REST API settings.
+
+    Secret setting values will be obfuscated.
+    """
+    return prefect.settings.get_current_settings()
+
+
+@router.get("/version")
+async def read_version() -> str:
+    """Returns the Prefect version number"""
+    return prefect.__version__
+
+
+@router.post("/database/clear", status_code=status.HTTP_204_NO_CONTENT)
+async def clear_database(
+    db: PrefectDBInterface = Depends(provide_database_interface),
+    confirm: bool = Body(
+        False,
+        embed=True,
+        description="Pass confirm=True to confirm you want to modify the database.",
+    ),
+    response: Response = None,  # type: ignore
+) -> None:
+    """Clear all database tables without dropping them."""
+    if not confirm:
+        response.status_code = status.HTTP_400_BAD_REQUEST
+        return
+    async with db.session_context(begin_transaction=True) as session:
+        # work pool has a circular dependency on pool queue; delete it first
+        await session.execute(db.WorkPool.__table__.delete())
+        for table in reversed(db.Base.metadata.sorted_tables):
+            await session.execute(table.delete())
+
+
+@router.post("/database/drop", status_code=status.HTTP_204_NO_CONTENT)
+async def drop_database(
+    db: PrefectDBInterface = Depends(provide_database_interface),
+    confirm: bool = Body(
+        False,
+        embed=True,
+        description="Pass confirm=True to confirm you want to modify the database.",
+    ),
+    response: Response = None,
+) -> None:
+    """Drop all database objects."""
+    if not confirm:
+        response.status_code = status.HTTP_400_BAD_REQUEST
+        return
+
+    await db.drop_db()
+
+
+@router.post("/database/create", status_code=status.HTTP_204_NO_CONTENT)
+async def create_database(
+    db: PrefectDBInterface = Depends(provide_database_interface),
+    confirm: bool = Body(
+        False,
+        embed=True,
+        description="Pass confirm=True to confirm you want to modify the database.",
+    ),
+    response: Response = None,
+) -> None:
+    """Create all database objects."""
+    if not confirm:
+        response.status_code = status.HTTP_400_BAD_REQUEST
+        return
+
+    await db.create_db()

prefect/server/api/artifacts.py

@@ -0,0 +1,224 @@
+"""
+Routes for interacting with artifact objects.
+"""
+
+from typing import List
+from uuid import UUID
+
+from fastapi import Body, Depends, HTTPException, Path, Response, status
+
+import prefect.server.api.dependencies as dependencies
+from prefect.server import models
+from prefect.server.database import PrefectDBInterface, provide_database_interface
+from prefect.server.schemas import actions, core, filters, sorting
+from prefect.server.utilities.server import PrefectRouter
+from prefect.types._datetime import now
+
+router: PrefectRouter = PrefectRouter(
+    prefix="/artifacts",
+    tags=["Artifacts"],
+)
+
+
+@router.post("/")
+async def create_artifact(
+    artifact: actions.ArtifactCreate,
+    response: Response,
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> core.Artifact:
+    artifact = core.Artifact(**artifact.model_dump())
+
+    right_now = now("UTC")
+
+    async with db.session_context(begin_transaction=True) as session:
+        model = await models.artifacts.create_artifact(
+            session=session,
+            artifact=artifact,
+        )
+
+    if model.created >= right_now:
+        response.status_code = status.HTTP_201_CREATED
+    return model
+
+
+@router.get("/{id}")
+async def read_artifact(
+    artifact_id: UUID = Path(
+        ..., description="The ID of the artifact to retrieve.", alias="id"
+    ),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> core.Artifact:
+    """
+    Retrieve an artifact from the database.
+    """
+    async with db.session_context() as session:
+        artifact = await models.artifacts.read_artifact(
+            session=session, artifact_id=artifact_id
+        )
+
+    if artifact is None:
+        raise HTTPException(status_code=404, detail="Artifact not found.")
+    return artifact
+
+
+@router.get("/{key}/latest")
+async def read_latest_artifact(
+    key: str = Path(
+        ...,
+        description="The key of the artifact to retrieve.",
+    ),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> core.Artifact:
+    """
+    Retrieve the latest artifact from the artifact table.
+    """
+    async with db.session_context() as session:
+        artifact = await models.artifacts.read_latest_artifact(session=session, key=key)
+
+    if artifact is None:
+        raise HTTPException(status_code=404, detail="Artifact not found.")
+    return artifact
+
+
+@router.post("/filter")
+async def read_artifacts(
+    sort: sorting.ArtifactSort = Body(sorting.ArtifactSort.ID_DESC),
+    limit: int = dependencies.LimitBody(),
+    offset: int = Body(0, ge=0),
+    artifacts: filters.ArtifactFilter = None,
+    flow_runs: filters.FlowRunFilter = None,
+    task_runs: filters.TaskRunFilter = None,
+    flows: filters.FlowFilter = None,
+    deployments: filters.DeploymentFilter = None,
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> List[core.Artifact]:
+    """
+    Retrieve artifacts from the database.
+    """
+    async with db.session_context() as session:
+        return await models.artifacts.read_artifacts(
+            session=session,
+            artifact_filter=artifacts,
+            flow_run_filter=flow_runs,
+            task_run_filter=task_runs,
+            flow_filter=flows,
+            deployment_filter=deployments,
+            offset=offset,
+            limit=limit,
+            sort=sort,
+        )
+
+
+@router.post("/latest/filter")
+async def read_latest_artifacts(
+    sort: sorting.ArtifactCollectionSort = Body(sorting.ArtifactCollectionSort.ID_DESC),
+    limit: int = dependencies.LimitBody(),
+    offset: int = Body(0, ge=0),
+    artifacts: filters.ArtifactCollectionFilter = None,
+    flow_runs: filters.FlowRunFilter = None,
+    task_runs: filters.TaskRunFilter = None,
+    flows: filters.FlowFilter = None,
+    deployments: filters.DeploymentFilter = None,
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> List[core.ArtifactCollection]:
+    """
+    Retrieve artifacts from the database.
+    """
+    async with db.session_context() as session:
+        return await models.artifacts.read_latest_artifacts(
+            session=session,
+            artifact_filter=artifacts,
+            flow_run_filter=flow_runs,
+            task_run_filter=task_runs,
+            flow_filter=flows,
+            deployment_filter=deployments,
+            offset=offset,
+            limit=limit,
+            sort=sort,
+        )
+
+
+@router.post("/count")
+async def count_artifacts(
+    artifacts: filters.ArtifactFilter = None,
+    flow_runs: filters.FlowRunFilter = None,
+    task_runs: filters.TaskRunFilter = None,
+    flows: filters.FlowFilter = None,
+    deployments: filters.DeploymentFilter = None,
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> int:
+    """
+    Count artifacts from the database.
+    """
+    async with db.session_context() as session:
+        return await models.artifacts.count_artifacts(
+            session=session,
+            artifact_filter=artifacts,
+            flow_run_filter=flow_runs,
+            task_run_filter=task_runs,
+            flow_filter=flows,
+            deployment_filter=deployments,
+        )
+
+
+@router.post("/latest/count")
+async def count_latest_artifacts(
+    artifacts: filters.ArtifactCollectionFilter = None,
+    flow_runs: filters.FlowRunFilter = None,
+    task_runs: filters.TaskRunFilter = None,
+    flows: filters.FlowFilter = None,
+    deployments: filters.DeploymentFilter = None,
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> int:
+    """
+    Count artifacts from the database.
+    """
+    async with db.session_context() as session:
+        return await models.artifacts.count_latest_artifacts(
+            session=session,
+            artifact_filter=artifacts,
+            flow_run_filter=flow_runs,
+            task_run_filter=task_runs,
+            flow_filter=flows,
+            deployment_filter=deployments,
+        )
+
+
+@router.patch("/{id}", status_code=204)
+async def update_artifact(
+    artifact: actions.ArtifactUpdate,
+    artifact_id: UUID = Path(
+        ..., description="The ID of the artifact to update.", alias="id"
+    ),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> None:
+    """
+    Update an artifact in the database.
+    """
+    async with db.session_context(begin_transaction=True) as session:
+        result = await models.artifacts.update_artifact(
+            session=session,
+            artifact_id=artifact_id,
+            artifact=artifact,
+        )
+    if not result:
+        raise HTTPException(status_code=404, detail="Artifact not found.")
+
+
+@router.delete("/{id}", status_code=204)
+async def delete_artifact(
+    artifact_id: UUID = Path(
+        ..., description="The ID of the artifact to delete.", alias="id"
+    ),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> None:
+    """
+    Delete an artifact from the database.
+    """
+    async with db.session_context(begin_transaction=True) as session:
+        result = await models.artifacts.delete_artifact(
+            session=session,
+            artifact_id=artifact_id,
+        )
+    if not result:
+        raise HTTPException(status_code=404, detail="Artifact not found.")

prefect/server/api/automations.py

@@ -0,0 +1,239 @@
+from typing import Optional, Sequence
+from uuid import UUID
+
+from fastapi import Body, Depends, HTTPException, Path, status
+from fastapi.exceptions import RequestValidationError
+from pydantic import ValidationError
+
+from prefect.server.api.dependencies import LimitBody
+from prefect.server.api.validation import (
+    validate_job_variables_for_run_deployment_action,
+)
+from prefect.server.database import PrefectDBInterface, provide_database_interface
+from prefect.server.events import actions
+from prefect.server.events.filters import AutomationFilter, AutomationFilterCreated
+from prefect.server.events.models import automations as automations_models
+from prefect.server.events.schemas.automations import (
+    Automation,
+    AutomationCreate,
+    AutomationPartialUpdate,
+    AutomationSort,
+    AutomationUpdate,
+)
+from prefect.server.exceptions import ObjectNotFoundError
+from prefect.server.utilities.server import PrefectRouter
+from prefect.types._datetime import now
+from prefect.utilities.schema_tools.validation import (
+    ValidationError as JSONSchemaValidationError,
+)
+
+router: PrefectRouter = PrefectRouter(
+    prefix="/automations",
+    tags=["Automations"],
+    dependencies=[],
+)
+
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
+async def create_automation(
+    automation: AutomationCreate,
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> Automation:
+    # reset any client-provided IDs on the provided triggers
+    automation.trigger.reset_ids()
+
+    errors = []
+    for action in automation.actions:
+        if (
+            isinstance(action, actions.RunDeployment)
+            and action.deployment_id is not None
+            and action.job_variables is not None
+            and action.job_variables != {}
+        ):
+            async with db.session_context() as session:
+                try:
+                    await validate_job_variables_for_run_deployment_action(
+                        session, action
+                    )
+                except JSONSchemaValidationError as exc:
+                    errors.append(str(exc))
+
+    if errors:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Error creating automation: {' '.join(errors)}",
+        )
+
+    automation_dict = automation.model_dump()
+    owner_resource = automation_dict.pop("owner_resource", None)
+
+    async with db.session_context(begin_transaction=True) as session:
+        created_automation = await automations_models.create_automation(
+            session=session,
+            automation=Automation(
+                **automation_dict,
+            ),
+        )
+
+        if owner_resource:
+            await automations_models.relate_automation_to_resource(
+                session,
+                automation_id=created_automation.id,
+                resource_id=owner_resource,
+                owned_by_resource=True,
+            )
+
+    return created_automation
+
+
+@router.put("/{id:uuid}", status_code=status.HTTP_204_NO_CONTENT)
+async def update_automation(
+    automation: AutomationUpdate,
+    automation_id: UUID = Path(..., alias="id"),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> None:
+    # reset any client-provided IDs on the provided triggers
+    automation.trigger.reset_ids()
+
+    errors = []
+    for action in automation.actions:
+        if (
+            isinstance(action, actions.RunDeployment)
+            and action.deployment_id is not None
+            and action.job_variables is not None
+        ):
+            async with db.session_context() as session:
+                try:
+                    await validate_job_variables_for_run_deployment_action(
+                        session, action
+                    )
+                except JSONSchemaValidationError as exc:
+                    errors.append(str(exc))
+    if errors:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Error creating automation: {' '.join(errors)}",
+        )
+
+    async with db.session_context(begin_transaction=True) as session:
+        updated = await automations_models.update_automation(
+            session=session,
+            automation_update=automation,
+            automation_id=automation_id,
+        )
+
+    if not updated:
+        raise ObjectNotFoundError("Automation not found")
+
+
+@router.patch(
+    "/{id:uuid}",
+    status_code=status.HTTP_204_NO_CONTENT,
+)
+async def patch_automation(
+    automation: AutomationPartialUpdate,
+    automation_id: UUID = Path(..., alias="id"),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> None:
+    try:
+        async with db.session_context(begin_transaction=True) as session:
+            updated = await automations_models.update_automation(
+                session=session,
+                automation_update=automation,
+                automation_id=automation_id,
+            )
+    except ValidationError as e:
+        raise RequestValidationError(
+            errors=e.errors(),
+            body=automation.model_dump(mode="json"),
+        )
+
+    if not updated:
+        raise ObjectNotFoundError("Automation not found")
+
+
+@router.delete(
+    "/{id:uuid}",
+    status_code=status.HTTP_204_NO_CONTENT,
+)
+async def delete_automation(
+    automation_id: UUID = Path(..., alias="id"),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> None:
+    async with db.session_context(begin_transaction=True) as session:
+        deleted = await automations_models.delete_automation(
+            session=session,
+            automation_id=automation_id,
+        )
+
+    if not deleted:
+        raise ObjectNotFoundError("Automation not found")
+
+
+@router.post("/filter")
+async def read_automations(
+    sort: AutomationSort = Body(AutomationSort.NAME_ASC),
+    limit: int = LimitBody(),
+    offset: int = Body(0, ge=0),
+    automations: Optional[AutomationFilter] = None,
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> Sequence[Automation]:
+    async with db.session_context() as session:
+        return await automations_models.read_automations_for_workspace(
+            session=session,
+            sort=sort,
+            limit=limit,
+            offset=offset,
+            automation_filter=automations,
+        )
+
+
+@router.post("/count")
+async def count_automations(
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> int:
+    async with db.session_context() as session:
+        return await automations_models.count_automations_for_workspace(session=session)
+
+
+@router.get("/{id:uuid}")
+async def read_automation(
+    automation_id: UUID = Path(..., alias="id"),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> Automation:
+    async with db.session_context() as session:
+        automation = await automations_models.read_automation(
+            session=session,
+            automation_id=automation_id,
+        )
+
+    if not automation:
+        raise ObjectNotFoundError("Automation not found")
+    return automation
+
+
+@router.get("/related-to/{resource_id:str}")
+async def read_automations_related_to_resource(
+    resource_id: str = Path(..., alias="resource_id"),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> Sequence[Automation]:
+    async with db.session_context() as session:
+        return await automations_models.read_automations_related_to_resource(
+            session=session,
+            resource_id=resource_id,
+        )
+
+
+@router.delete("/owned-by/{resource_id:str}", status_code=status.HTTP_202_ACCEPTED)
+async def delete_automations_owned_by_resource(
+    resource_id: str = Path(..., alias="resource_id"),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> None:
+    async with db.session_context(begin_transaction=True) as session:
+        await automations_models.delete_automations_owned_by_resource(
+            session,
+            resource_id=resource_id,
+            automation_filter=AutomationFilter(
+                created=AutomationFilterCreated(before_=now("UTC"))
+            ),
+        )