PR feedback

Author: erindru

sqlmesh/core/context.py

@@ -120,7 +120,14 @@
 from sqlmesh.utils import UniqueKeyDict, Verbosity
 from sqlmesh.utils.concurrency import concurrent_apply_to_values
 from sqlmesh.utils.dag import DAG
-from sqlmesh.utils.date import TimeLike, now_ds, to_timestamp, format_tz_datetime, now_timestamp
+from sqlmesh.utils.date import (
+    TimeLike,
+    now_ds,
+    to_timestamp,
+    format_tz_datetime,
+    now_timestamp,
+    now,
+)
 from sqlmesh.utils.errors import (
     CircuitBreakerError,
     ConfigError,
@@ -1517,7 +1524,7 @@ def plan_builder(
                 max_interval_end_per_model,
                 backfill_models,
                 modified_model_names,
-                execution_time,
+                execution_time or now(),
             )
 
             # Refresh snapshot intervals to ensure that they are up to date with values reflected in the max_interval_end_per_model.

sqlmesh/core/plan/builder.py

@@ -139,7 +139,7 @@ def __init__(
         self._include_unmodified = include_unmodified
         self._restate_models = set(restate_models) if restate_models is not None else None
         self._effective_from = effective_from
-        self._execution_time = execution_time
+        self._execution_time = execution_time or now()
         self._backfill_models = backfill_models
         self._end = end or default_end
         self._apply = apply
@@ -176,20 +176,16 @@ def is_start_and_end_allowed(self) -> bool:
 
     @property
     def start(self) -> t.Optional[TimeLike]:
-        if self._start and self._execution_time:
+        if self._start:
             return to_datetime(self._start, relative_base=to_datetime(self._execution_time))
         return self._start
 
     @property
     def end(self) -> t.Optional[TimeLike]:
-        if self._end and self._execution_time:
+        if self._end:
             return to_datetime(self._end, relative_base=to_datetime(self._execution_time))
         return self._end
 
-    @property
-    def execution_time(self) -> TimeLike:
-        return self._execution_time or now()
-
     def set_start(self, new_start: TimeLike) -> PlanBuilder:
         self._start = new_start
         self.override_start = True
@@ -274,7 +270,8 @@ def build(self) -> Plan:
         )
 
         restatements = self._build_restatements(
-            dag, earliest_interval_start(self._context_diff.snapshots.values(), self.execution_time)
+            dag,
+            earliest_interval_start(self._context_diff.snapshots.values(), self._execution_time),
         )
         models_to_backfill = self._build_models_to_backfill(dag, restatements)
 
@@ -307,7 +304,7 @@ def build(self) -> Plan:
             selected_models_to_backfill=self._backfill_models,
             models_to_backfill=models_to_backfill,
             effective_from=self._effective_from,
-            execution_time=self.execution_time,
+            execution_time=self._execution_time,
             end_bounded=self._end_bounded,
             ensure_finalized_snapshots=self._ensure_finalized_snapshots,
             user_provided_flags=self._user_provided_flags,
@@ -764,9 +761,9 @@ def _ensure_valid_date_range(self) -> None:
                 )
 
         if end := self.end:
-            if to_datetime(end) > to_datetime(self.execution_time):
+            if to_datetime(end) > to_datetime(self._execution_time):
                 raise PlanError(
-                    f"Plan end date: '{time_like_to_str(end)}' cannot be in the future (execution time: '{time_like_to_str(self.execution_time)}')"
+                    f"Plan end date: '{time_like_to_str(end)}' cannot be in the future (execution time: '{time_like_to_str(self._execution_time)}')"
                 )
 
     def _ensure_no_forward_only_revert(self) -> None:

sqlmesh/core/plan/definition.py

@@ -83,8 +83,9 @@ def start(self) -> TimeLike:
     def end(self) -> TimeLike:
         return self.provided_end or self.execution_time
 
-    @property
+    @cached_property
     def execution_time(self) -> TimeLike:
+        # note: property is cached so that it returns a consistent timestamp for now()
         return self.execution_time_ or now()
 
     @property