prefect-client 3.2.1__py3-none-any.whl → 3.2.3__py3-none-any.whl

prefect/runtime/flow_run.py

@@ -23,14 +23,14 @@ Available attributes:
 from __future__ import annotations
 
 import os
+from datetime import datetime
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
 
-import pendulum
-
 from prefect._internal.concurrency.api import create_call, from_sync
 from prefect.client.orchestration import get_client
 from prefect.context import FlowRunContext, TaskRunContext
 from prefect.settings import PREFECT_API_URL, PREFECT_UI_URL
+from prefect.types._datetime import DateTime, Timezone, now, parse_datetime
 
 if TYPE_CHECKING:
     from prefect.client.schemas.objects import Flow, FlowRun, TaskRun
@@ -53,28 +53,21 @@ __all__ = [
 ]
 
 
-def _pendulum_parse(dt: str) -> pendulum.DateTime:
-    """
-    Use pendulum to cast different format date strings to pendulum.DateTime --
-    tzinfo is ignored (UTC forced)
-    """
-    return pendulum.parse(dt, tz=None, strict=False).set(tz="UTC")
+def _parse_datetime_UTC(dt: str) -> DateTime:
+    pendulum_dt = parse_datetime(dt, tz=Timezone("UTC"), strict=False)
+    assert isinstance(pendulum_dt, datetime)
+    return DateTime.instance(pendulum_dt)
 
 
 type_cast: dict[
-    type[bool]
-    | type[int]
-    | type[float]
-    | type[str]
-    | type[None]
-    | type[pendulum.DateTime],
+    type[bool] | type[int] | type[float] | type[str] | type[None] | type[DateTime],
     Callable[[Any], Any],
 ] = {
     bool: lambda x: x.lower() == "true",
     int: int,
     float: float,
     str: str,
-    pendulum.DateTime: _pendulum_parse,
+    DateTime: _parse_datetime_UTC,
     # for optional defined attributes, when real value is NoneType, use str
     type(None): str,
 }
@@ -221,11 +214,11 @@ def get_flow_version() -> Optional[str]:
         return flow_run_ctx.flow.version
 
 
-def get_scheduled_start_time() -> pendulum.DateTime:
+def get_scheduled_start_time() -> DateTime:
     flow_run_ctx = FlowRunContext.get()
     run_id = get_id()
     if flow_run_ctx is None and run_id is None:
-        return pendulum.now("utc")
+        return now("UTC")
     elif flow_run_ctx is None:
         flow_run = from_sync.call_soon_in_loop_thread(
             create_call(_get_flow_run, run_id)

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"))
+            ),
+        )

prefect/server/api/block_capabilities.py

@@ -0,0 +1,25 @@
+"""
+Routes for interacting with block capabilities.
+"""
+
+from typing import List
+
+from fastapi import Depends
+
+from prefect.server import models
+from prefect.server.database import PrefectDBInterface, provide_database_interface
+from prefect.server.utilities.server import PrefectRouter
+
+router: PrefectRouter = PrefectRouter(
+    prefix="/block_capabilities", tags=["Block capabilities"]
+)
+
+
+@router.get("/")
+async def read_available_block_capabilities(
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> List[str]:
+    async with db.session_context() as session:
+        return await models.block_schemas.read_available_block_capabilities(
+            session=session
+        )