prefect-client 3.2.15.dev9__py3-none-any.whl → 3.3.0__py3-none-any.whl

prefect/context.py

@@ -20,6 +20,7 @@ from typing_extensions import Self
 import prefect.logging
 import prefect.logging.configuration
 import prefect.settings
+import prefect.types._datetime
 from prefect._internal.compatibility.migration import getattr_migration
 from prefect.client.orchestration import PrefectClient, SyncPrefectClient, get_client
 from prefect.client.schemas import FlowRun, TaskRun
@@ -315,7 +316,9 @@ class RunContext(ContextModel):
 
         start_client_metrics_server()
 
-    start_time: DateTime = Field(default_factory=lambda: DateTime.now("UTC"))
+    start_time: DateTime = Field(
+        default_factory=lambda: prefect.types._datetime.now("UTC")
+    )
     input_keyset: Optional[dict[str, dict[str, str]]] = None
     client: Union[PrefectClient, SyncPrefectClient]
 

prefect/events/clients.py

@@ -35,6 +35,7 @@ from websockets.exceptions import (
     ConnectionClosedOK,
 )
 
+import prefect.types._datetime
 from prefect.events import Event
 from prefect.logging import get_logger
 from prefect.settings import (
@@ -46,7 +47,6 @@ from prefect.settings import (
     PREFECT_DEBUG_MODE,
     PREFECT_SERVER_ALLOW_EPHEMERAL_MODE,
 )
-from prefect.types._datetime import add_years, now
 
 if TYPE_CHECKING:
     from prefect.events.filters import EventFilter
@@ -665,8 +665,8 @@ class PrefectEventSubscriber:
         from prefect.events.filters import EventOccurredFilter
 
         self._filter.occurred = EventOccurredFilter(
-            since=now("UTC") - timedelta(minutes=1),
-            until=add_years(now("UTC"), 1),
+            since=prefect.types._datetime.now("UTC") - timedelta(minutes=1),
+            until=prefect.types._datetime.now("UTC") + timedelta(days=365),
         )
 
         logger.debug("  filtering events since %s...", self._filter.occurred.since)

prefect/events/filters.py

@@ -1,8 +1,10 @@
+import datetime
 from typing import Optional
 from uuid import UUID
 
 from pydantic import Field
 
+import prefect.types._datetime
 from prefect._internal.schemas.bases import PrefectBaseModel
 from prefect.types import DateTime
 from prefect.utilities.collections import AutoEnum
@@ -59,11 +61,14 @@ class EventDataFilter(PrefectBaseModel, extra="forbid"):  # type: ignore[call-ar
 
 class EventOccurredFilter(EventDataFilter):
     since: DateTime = Field(
-        default_factory=lambda: DateTime.now("UTC").start_of("day").subtract(days=180),
+        default_factory=lambda: prefect.types._datetime.start_of_day(
+            prefect.types._datetime.now("UTC")
+        )
+        - datetime.timedelta(days=180),
         description="Only include events after this time (inclusive)",
     )
     until: DateTime = Field(
-        default_factory=lambda: DateTime.now("UTC"),
+        default_factory=lambda: prefect.types._datetime.now("UTC"),
         description="Only include events prior to this time (inclusive)",
     )
 

prefect/events/related.py

@@ -14,7 +14,7 @@ from typing import (
 )
 from uuid import UUID
 
-from prefect.types._datetime import DateTime, now
+import prefect.types._datetime
 
 from .schemas.events import RelatedResource
 
@@ -23,7 +23,9 @@ if TYPE_CHECKING:
     from prefect.client.orchestration import PrefectClient
 
 ResourceCacheEntry = Dict[str, Union[str, "ObjectBaseModel", None]]
-RelatedResourceCache = Dict[str, Tuple[ResourceCacheEntry, DateTime]]
+RelatedResourceCache = Dict[
+    str, Tuple[ResourceCacheEntry, prefect.types._datetime.DateTime]
+]
 
 MAX_CACHE_SIZE = 100
 RESOURCE_CACHE: RelatedResourceCache = {}
@@ -205,7 +207,7 @@ async def _get_and_cache_related_object(
             "object": obj_,
         }
 
-    cache[cache_key] = (entry, now("UTC"))
+    cache[cache_key] = (entry, prefect.types._datetime.now("UTC"))
 
     # In the case of a worker or agent this cache could be long-lived. To keep
     # from running out of memory only keep `MAX_CACHE_SIZE` entries in the

prefect/events/schemas/events.py

@@ -24,12 +24,12 @@ from pydantic import (
 )
 from typing_extensions import Annotated, Self
 
+import prefect.types._datetime
 from prefect._internal.schemas.bases import PrefectBaseModel
 from prefect.logging import get_logger
 from prefect.settings import (
     PREFECT_EVENTS_MAXIMUM_LABELS_PER_RESOURCE,
 )
-from prefect.types import DateTime
 
 from .labelling import Labelled
 
@@ -115,8 +115,8 @@ class Event(PrefectBaseModel):
 
     model_config: ClassVar[ConfigDict] = ConfigDict(extra="ignore")
 
-    occurred: DateTime = Field(
-        default_factory=lambda: DateTime.now("UTC"),
+    occurred: prefect.types._datetime.DateTime = Field(
+        default_factory=lambda: prefect.types._datetime.now("UTC"),
         description="When the event happened from the sender's perspective",
     )
     event: str = Field(description="The name of the event that happened")
@@ -184,7 +184,7 @@ class ReceivedEvent(Event):
 
     model_config: ClassVar[ConfigDict] = ConfigDict(from_attributes=True)
 
-    received: DateTime = Field(
+    received: prefect.types._datetime.DateTime = Field(
         ...,
         description="When the event was received by Prefect Cloud",
     )

prefect/events/utilities.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
+import datetime
 from datetime import timedelta
-from typing import Any
+from typing import TYPE_CHECKING, Any
 from uuid import UUID
 
-from prefect.types import DateTime
+import prefect.types._datetime
+from prefect.logging.loggers import get_logger
 
 from .clients import (
     AssertingEventsClient,
@@ -15,13 +17,18 @@ from .clients import (
 from .schemas.events import Event, RelatedResource
 from .worker import EventsWorker, should_emit_events
 
+if TYPE_CHECKING:
+    import logging
+
 TIGHT_TIMING = timedelta(minutes=5)
 
+logger: "logging.Logger" = get_logger(__name__)
+
 
 def emit_event(
     event: str,
     resource: dict[str, str],
-    occurred: DateTime | None = None,
+    occurred: datetime.datetime | None = None,
     related: list[dict[str, str]] | list[RelatedResource] | None = None,
     payload: dict[str, Any] | None = None,
     id: UUID | None = None,
@@ -51,41 +58,45 @@ def emit_event(
     if not should_emit_events():
         return None
 
-    operational_clients = [
-        AssertingPassthroughEventsClient,
-        AssertingEventsClient,
-        PrefectCloudEventsClient,
-        PrefectEventsClient,
-    ]
-    worker_instance = EventsWorker.instance()
+    try:
+        operational_clients = [
+            AssertingPassthroughEventsClient,
+            AssertingEventsClient,
+            PrefectCloudEventsClient,
+            PrefectEventsClient,
+        ]
+        worker_instance = EventsWorker.instance()
 
-    if worker_instance.client_type not in operational_clients:
-        return None
+        if worker_instance.client_type not in operational_clients:
+            return None
 
-    event_kwargs: dict[str, Any] = {
-        "event": event,
-        "resource": resource,
-        **kwargs,
-    }
+        event_kwargs: dict[str, Any] = {
+            "event": event,
+            "resource": resource,
+            **kwargs,
+        }
 
-    if occurred is None:
-        occurred = DateTime.now("UTC")
-    event_kwargs["occurred"] = occurred
+        if occurred is None:
+            occurred = prefect.types._datetime.now("UTC")
+        event_kwargs["occurred"] = occurred
 
-    if related is not None:
-        event_kwargs["related"] = related
+        if related is not None:
+            event_kwargs["related"] = related
 
-    if payload is not None:
-        event_kwargs["payload"] = payload
+        if payload is not None:
+            event_kwargs["payload"] = payload
 
-    if id is not None:
-        event_kwargs["id"] = id
+        if id is not None:
+            event_kwargs["id"] = id
 
-    if follows is not None:
-        if -TIGHT_TIMING < (occurred - follows.occurred) < TIGHT_TIMING:
-            event_kwargs["follows"] = follows.id
+        if follows is not None:
+            if -TIGHT_TIMING < (occurred - follows.occurred) < TIGHT_TIMING:
+                event_kwargs["follows"] = follows.id
 
-    event_obj = Event(**event_kwargs)
-    worker_instance.send(event_obj)
+        event_obj = Event(**event_kwargs)
+        worker_instance.send(event_obj)
 
-    return event_obj
+        return event_obj
+    except Exception:
+        logger.exception(f"Error emitting event: {event}")
+        return None

prefect/exceptions.py

@@ -8,7 +8,7 @@ from collections.abc import Iterable
 from types import ModuleType, TracebackType
 from typing import TYPE_CHECKING, Any, Callable, Optional
 
-from httpx._exceptions import HTTPStatusError
+from httpx import HTTPStatusError
 from pydantic import ValidationError
 from typing_extensions import Self
 

prefect/flow_engine.py

@@ -355,11 +355,7 @@ class FlowRunEngine(BaseFlowRunEngine[P, R]):
         # the State was Prefect-created.
         # TODO: Remove the need to get the result from a State except in cases where the return value
         # is a State object.
-        _result = self.state.result(raise_on_failure=raise_on_failure, fetch=True)  # type: ignore
-        # state.result is a `sync_compatible` function that may or may not return an awaitable
-        # depending on whether the parent frame is sync or not
-        if asyncio.iscoroutine(_result):
-            _result = run_coro_as_sync(_result)
+        _result = self.state.result(raise_on_failure=raise_on_failure, _sync=True)  # type: ignore
         return _result
 
     def handle_success(self, result: R) -> R:
@@ -924,12 +920,7 @@ class AsyncFlowRunEngine(BaseFlowRunEngine[P, R]):
         # the State was Prefect-created.
         # TODO: Remove the need to get the result from a State except in cases where the return value
         # is a State object.
-        _result = self.state.result(raise_on_failure=raise_on_failure, fetch=True)  # type: ignore
-        # state.result is a `sync_compatible` function that may or may not return an awaitable
-        # depending on whether the parent frame is sync or not
-        if asyncio.iscoroutine(_result):
-            _result = await _result
-        return _result
+        return await self.state.aresult(raise_on_failure=raise_on_failure)  # type: ignore
 
     async def handle_success(self, result: R) -> R:
         result_store = getattr(FlowRunContext.get(), "result_store", None)

prefect/futures.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import abc
-import asyncio
 import concurrent.futures
 import threading
 import uuid
@@ -221,12 +220,8 @@ class PrefectConcurrentFuture(PrefectWrappedFuture[R, concurrent.futures.Future[
                 return future_result
 
         _result = self._final_state.result(
-            raise_on_failure=raise_on_failure, fetch=True
+            raise_on_failure=raise_on_failure, _sync=True
         )
-        # state.result is a `sync_compatible` function that may or may not return an awaitable
-        # depending on whether the parent frame is sync or not
-        if asyncio.iscoroutine(_result):
-            _result = run_coro_as_sync(_result)
         return _result
 
     def __del__(self) -> None:
@@ -316,9 +311,7 @@ class PrefectDistributedFuture(PrefectTaskRunFuture[R]):
                     f"Task run {self.task_run_id} did not complete within {timeout} seconds"
                 )
 
-        return await self._final_state.result(
-            raise_on_failure=raise_on_failure, fetch=True
-        )
+        return await self._final_state.aresult(raise_on_failure=raise_on_failure)
 
     def add_done_callback(self, fn: Callable[[PrefectFuture[R]], None]) -> None:
         if self._final_state:
@@ -433,9 +426,7 @@ class PrefectFlowRunFuture(PrefectFuture[R]):
                     f"Task run {self.task_run_id} did not complete within {timeout} seconds"
                 )
 
-        return await self._final_state.result(
-            raise_on_failure=raise_on_failure, fetch=True
-        )
+        return await self._final_state.aresult(raise_on_failure=raise_on_failure)
 
     def add_done_callback(self, fn: Callable[[PrefectFuture[R]], None]) -> None:
         if self._final_state:

prefect/locking/filesystem.py

@@ -1,3 +1,4 @@
+import datetime
 import time
 from datetime import timedelta
 from logging import Logger
@@ -9,7 +10,7 @@ import pydantic_core
 from typing_extensions import TypedDict
 
 from prefect.logging.loggers import get_logger
-from prefect.types._datetime import DateTime, now, parse_datetime
+from prefect.types._datetime import now, parse_datetime
 
 from .protocol import LockManager
 
@@ -27,7 +28,7 @@ class _LockInfo(TypedDict):
     """
 
     holder: str
-    expiration: Optional[DateTime]
+    expiration: Optional[datetime.datetime]
     path: Path
 
 

prefect/logging/formatters.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import logging.handlers
+import logging
 import sys
 import traceback
 from types import TracebackType

prefect/logging/handlers.py

@@ -236,7 +236,7 @@ class APILogHandler(logging.Handler):
             worker_id=worker_id,
             name=record.name,
             level=record.levelno,
-            timestamp=from_timestamp(getattr(record, "created", None) or time.time()),
+            timestamp=from_timestamp(getattr(record, "created", None) or time.time()),  # pyright: ignore[reportArgumentType] DateTime is split into two types depending on Python version
             message=self.format(record),
         ).model_dump(mode="json")
 
@@ -277,7 +277,7 @@ class WorkerAPILogHandler(APILogHandler):
             worker_id=worker_id,
             name=record.name,
             level=record.levelno,
-            timestamp=from_timestamp(getattr(record, "created", None) or time.time()),
+            timestamp=from_timestamp(getattr(record, "created", None) or time.time()),  # pyright: ignore[reportArgumentType] DateTime is split into two types depending on Python version
             message=self.format(record),
         ).model_dump(mode="json")
 

prefect/main.py

@@ -11,13 +11,13 @@ from prefect._result_records import ResultRecordMetadata
 from prefect.flow_runs import pause_flow_run, resume_flow_run, suspend_flow_run
 from prefect.client.orchestration import get_client
 from prefect.client.cloud import get_cloud_client
-import prefect.variables
-import prefect.runtime
+import prefect.variables  # pyright: ignore[reportUnusedImport] # TODO: Does this need to be imported here?
+import prefect.runtime  # pyright: ignore[reportUnusedImport] # TODO: Does this need to be imported here?
 
 # Import modules that register types
-import prefect.serializers
-import prefect.blocks.notifications
-import prefect.blocks.system
+import prefect.serializers  # pyright: ignore[reportUnusedImport]
+import prefect.blocks.notifications  # pyright: ignore[reportUnusedImport]
+import prefect.blocks.system  # pyright: ignore[reportUnusedImport]
 
 # Initialize the process-wide profile and registry at import time
 import prefect.context

prefect/results.py

@@ -31,6 +31,7 @@ from pydantic import (
 from typing_extensions import ParamSpec, Self
 
 import prefect
+import prefect.types._datetime
 from prefect._internal.compatibility.async_dispatch import async_dispatch
 from prefect._result_records import R, ResultRecord, ResultRecordMetadata
 from prefect.blocks.core import Block
@@ -519,7 +520,7 @@ class ResultStore(BaseModel):
         if metadata.expiration:
             # if the result has an expiration,
             # check if it is still in the future
-            exists = metadata.expiration > DateTime.now("utc")
+            exists = metadata.expiration > prefect.types._datetime.now("UTC")
         else:
             exists = True
         return exists

prefect/runner/runner.py

@@ -113,7 +113,7 @@ from prefect.states import (
     Pending,
     exception_to_failed_state,
 )
-from prefect.types._datetime import DateTime
+from prefect.types._datetime import now
 from prefect.types.entrypoint import EntrypointType
 from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import (
@@ -992,7 +992,7 @@ class Runner:
         if self.stopping:
             return
         runs_response = await self._get_scheduled_flow_runs()
-        self.last_polled: DateTime = DateTime.now("UTC")
+        self.last_polled: datetime.datetime = now("UTC")
         return await self._submit_scheduled_flow_runs(flow_run_response=runs_response)
 
     async def _check_for_cancelled_flow_runs(
@@ -1258,7 +1258,9 @@ class Runner:
         """
         Retrieve scheduled flow runs for this runner.
         """
-        scheduled_before = DateTime.now("utc").add(seconds=int(self._prefetch_seconds))
+        scheduled_before = now("UTC") + datetime.timedelta(
+            seconds=int(self._prefetch_seconds)
+        )
         self._logger.debug(
             f"Querying for flow runs scheduled before {scheduled_before}"
         )

prefect/runner/server.py

@@ -23,7 +23,7 @@ from prefect.settings import (
     PREFECT_RUNNER_SERVER_MISSED_POLLS_TOLERANCE,
     PREFECT_RUNNER_SERVER_PORT,
 )
-from prefect.types._datetime import DateTime
+from prefect.types._datetime import now as now_fn
 from prefect.utilities.asyncutils import run_coro_as_sync
 from prefect.utilities.importtools import load_script_as_module
 
@@ -56,7 +56,7 @@ def perform_health_check(
         )
 
     def _health_check():
-        now = DateTime.now("utc")
+        now = now_fn("UTC")
         poll_delay = (now - runner.last_polled).total_seconds()
 
         if TYPE_CHECKING:

prefect/runtime/flow_run.py

@@ -25,12 +25,13 @@ from __future__ import annotations
 import os
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
+from zoneinfo import ZoneInfo
 
 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
+from prefect.types._datetime import DateTime, now, parse_datetime
 
 if TYPE_CHECKING:
     from prefect.client.schemas.objects import Flow, FlowRun, TaskRun
@@ -53,10 +54,14 @@ __all__ = [
 ]
 
 
-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)
+def _parse_datetime_UTC(dt: str) -> datetime:
+    parsed_dt = parse_datetime(dt)
+    if parsed_dt.tzinfo is None:
+        # if the datetime is naive, assume it is UTCff
+        return parsed_dt.replace(tzinfo=ZoneInfo("UTC"))
+    else:
+        # if the datetime is timezone-aware, convert to UTC
+        return parsed_dt.astimezone(ZoneInfo("UTC"))
 
 
 type_cast: dict[
@@ -67,7 +72,7 @@ type_cast: dict[
     int: int,
     float: float,
     str: str,
-    DateTime: _parse_datetime_UTC,
+    datetime: _parse_datetime_UTC,
     # for optional defined attributes, when real value is NoneType, use str
     type(None): str,
 }

prefect/server/api/concurrency_limits_v2.py

@@ -156,15 +156,18 @@ async def bulk_increment_active_slots(
     slots: int = Body(..., gt=0),
     names: List[str] = Body(..., min_items=1),
     mode: Literal["concurrency", "rate_limit"] = Body("concurrency"),
-    create_if_missing: Optional[bool] = Body(None),
+    create_if_missing: Optional[bool] = Body(
+        None,
+        deprecated="Limits must be explicitly created before acquiring concurrency slots.",
+    ),
     db: PrefectDBInterface = Depends(provide_database_interface),
 ) -> List[MinimalConcurrencyLimitResponse]:
     async with db.session_context(begin_transaction=True) as session:
         limits = [
             schemas.core.ConcurrencyLimitV2.model_validate(limit)
             for limit in (
-                await models.concurrency_limits_v2.bulk_read_or_create_concurrency_limits(
-                    session=session, names=names, create_if_missing=create_if_missing
+                await models.concurrency_limits_v2.bulk_read_concurrency_limits(
+                    session=session, names=names
                 )
             )
         ]
@@ -246,14 +249,15 @@ async def bulk_decrement_active_slots(
     slots: int = Body(..., gt=0),
     names: List[str] = Body(..., min_items=1),
     occupancy_seconds: Optional[float] = Body(None, gt=0.0),
-    create_if_missing: bool = Body(True),
+    create_if_missing: bool = Body(
+        None,
+        deprecated="Limits must be explicitly created before decrementing active slots.",
+    ),
     db: PrefectDBInterface = Depends(provide_database_interface),
 ) -> List[MinimalConcurrencyLimitResponse]:
     async with db.session_context(begin_transaction=True) as session:
-        limits = (
-            await models.concurrency_limits_v2.bulk_read_or_create_concurrency_limits(
-                session=session, names=names, create_if_missing=create_if_missing
-            )
+        limits = await models.concurrency_limits_v2.bulk_read_concurrency_limits(
+            session=session, names=names
         )
 
         if not limits:

prefect/server/api/deployments.py

@@ -568,8 +568,10 @@ async def delete_deployment(
 @router.post("/{id}/schedule")
 async def schedule_deployment(
     deployment_id: UUID = Path(..., description="The deployment id", alias="id"),
-    start_time: DateTime = Body(None, description="The earliest date to schedule"),
-    end_time: DateTime = Body(None, description="The latest date to schedule"),
+    start_time: datetime.datetime = Body(
+        None, description="The earliest date to schedule"
+    ),
+    end_time: datetime.datetime = Body(None, description="The latest date to schedule"),
     # Workaround for the fact that FastAPI does not let us configure ser_json_timedelta
     # to represent timedeltas as floats in JSON.
     min_time: float = Body(

prefect/server/api/server.py

@@ -253,11 +253,11 @@ def copy_directory(directory: str, path: str) -> None:
             # ensure copied files are writeable
             for root, dirs, files in os.walk(destination):
                 for f in files:
-                    os.chmod(os.path.join(root, f), 0o600)
+                    os.chmod(os.path.join(root, f), 0o700)
         else:
             shutil.copy2(source, destination)
             # Ensure copied file is writeable
-            os.chmod(destination, 0o600)
+            os.chmod(destination, 0o700)
 
 
 async def custom_internal_exception_handler(

prefect/server/api/ui/flows.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from datetime import datetime
 from typing import TYPE_CHECKING, Dict, List, Optional
 from uuid import UUID
+from zoneinfo import ZoneInfo
 
 import sqlalchemy as sa
 from fastapi import Body, Depends
@@ -15,7 +16,7 @@ from prefect.server.utilities.database import UUID as UUIDTypeDecorator
 from prefect.server.utilities.schemas import PrefectBaseModel
 from prefect.server.utilities.server import PrefectRouter
 from prefect.types import DateTime
-from prefect.types._datetime import create_datetime_instance
+from prefect.types._datetime import create_datetime_instance, parse_datetime
 
 if TYPE_CHECKING:
     import logging
@@ -162,7 +163,11 @@ async def next_runs_by_flow(
                 name=result.name,
                 state_name=result.state_name,
                 state_type=result.state_type,
-                next_scheduled_start_time=result.next_scheduled_start_time,
+                next_scheduled_start_time=parse_datetime(
+                    result.next_scheduled_start_time
+                ).replace(tzinfo=ZoneInfo("UTC"))
+                if isinstance(result.next_scheduled_start_time, str)
+                else result.next_scheduled_start_time,
             )
             for result in results.all()
         }

prefect/server/api/ui/task_runs.py

@@ -62,14 +62,14 @@ async def read_dashboard_task_run_counts(
     )
 
     bucket_count = 20
-    start_time = task_runs.start_time.after_.start_of("minute")
+    start_time = task_runs.start_time.after_.replace(microsecond=0, second=0)
     end_time = (
         end_of_period(task_runs.start_time.before_, "minute")
         if task_runs.start_time.before_
         else end_of_period(now("UTC"), "minute")
     )
     window = end_time - start_time
-    delta = window.as_timedelta() / bucket_count
+    delta = window / bucket_count
 
     async with db.session_context(begin_transaction=False) as session:
         # Gather the raw counts. The counts are divided into buckets of time
@@ -85,7 +85,7 @@ async def read_dashboard_task_run_counts(
             start_time.minute,
             start_time.second,
             start_time.microsecond,
-            start_time.timezone,
+            start_time.tzinfo,
         )
         bucket_expression = sa.func.floor(
             sa.func.date_diff_seconds(db.TaskRun.start_time, start_datetime)