sqlmesh 0.182.1.dev11__py3-none-any.whl → 0.183.1.dev1__py3-none-any.whl

sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.182.1.dev11'
-__version_tuple__ = version_tuple = (0, 182, 1, 'dev11')
+__version__ = version = '0.183.1.dev1'
+__version_tuple__ = version_tuple = (0, 183, 1, 'dev1')

sqlmesh/core/console.py

@@ -350,11 +350,14 @@ class Console(
         batched_intervals: t.Dict[Snapshot, Intervals],
         environment_naming_info: EnvironmentNamingInfo,
         default_catalog: t.Optional[str],
+        audit_only: bool = False,
     ) -> None:
-        """Indicates that a new snapshot evaluation progress has begun."""
+        """Indicates that a new snapshot evaluation/auditing progress has begun."""
 
     @abc.abstractmethod
-    def start_snapshot_evaluation_progress(self, snapshot: Snapshot) -> None:
+    def start_snapshot_evaluation_progress(
+        self, snapshot: Snapshot, audit_only: bool = False
+    ) -> None:
         """Starts the snapshot evaluation progress."""
 
     @abc.abstractmethod
@@ -366,6 +369,7 @@ class Console(
         duration_ms: t.Optional[int],
         num_audits_passed: int,
         num_audits_failed: int,
+        audit_only: bool = False,
     ) -> None:
         """Updates the snapshot evaluation progress."""
 
@@ -507,10 +511,13 @@ class NoopConsole(Console):
         batched_intervals: t.Dict[Snapshot, Intervals],
         environment_naming_info: EnvironmentNamingInfo,
         default_catalog: t.Optional[str],
+        audit_only: bool = False,
     ) -> None:
         pass
 
-    def start_snapshot_evaluation_progress(self, snapshot: Snapshot) -> None:
+    def start_snapshot_evaluation_progress(
+        self, snapshot: Snapshot, audit_only: bool = False
+    ) -> None:
         pass
 
     def update_snapshot_evaluation_progress(
@@ -521,6 +528,7 @@ class NoopConsole(Console):
         duration_ms: t.Optional[int],
         num_audits_passed: int,
         num_audits_failed: int,
+        audit_only: bool = False,
     ) -> None:
         pass
 
@@ -891,11 +899,12 @@ class TerminalConsole(Console):
         batched_intervals: t.Dict[Snapshot, Intervals],
         environment_naming_info: EnvironmentNamingInfo,
         default_catalog: t.Optional[str],
+        audit_only: bool = False,
     ) -> None:
-        """Indicates that a new snapshot evaluation progress has begun."""
+        """Indicates that a new snapshot evaluation/auditing progress has begun."""
         if not self.evaluation_progress_live:
             self.evaluation_total_progress = make_progress_bar(
-                "Executing model batches", self.console
+                "Executing model batches" if not audit_only else "Auditing models", self.console
             )
 
             self.evaluation_model_progress = Progress(
@@ -916,8 +925,9 @@ class TerminalConsole(Console):
             batch_sizes = {
                 snapshot: len(intervals) for snapshot, intervals in batched_intervals.items()
             }
+            message = "Executing" if not audit_only else "Auditing"
             self.evaluation_total_task = self.evaluation_total_progress.add_task(
-                "Executing models...", total=sum(batch_sizes.values())
+                f"{message} models...", total=sum(batch_sizes.values())
             )
 
             # determine column widths
@@ -943,7 +953,9 @@ class TerminalConsole(Console):
             self.environment_naming_info = environment_naming_info
             self.default_catalog = default_catalog
 
-    def start_snapshot_evaluation_progress(self, snapshot: Snapshot) -> None:
+    def start_snapshot_evaluation_progress(
+        self, snapshot: Snapshot, audit_only: bool = False
+    ) -> None:
         if self.evaluation_model_progress and snapshot.name not in self.evaluation_model_tasks:
             display_name = snapshot.display_name(
                 self.environment_naming_info,
@@ -951,7 +963,7 @@ class TerminalConsole(Console):
                 dialect=self.dialect,
             )
             self.evaluation_model_tasks[snapshot.name] = self.evaluation_model_progress.add_task(
-                f"Evaluating {display_name}...",
+                f"{'Evaluating' if not audit_only else 'Auditing'} {display_name}...",
                 view_name=display_name,
                 total=self.evaluation_model_batch_sizes[snapshot],
             )
@@ -964,6 +976,7 @@ class TerminalConsole(Console):
         duration_ms: t.Optional[int],
         num_audits_passed: int,
         num_audits_failed: int,
+        audit_only: bool = False,
     ) -> None:
         """Update the snapshot evaluation progress."""
         if (
@@ -1003,7 +1016,7 @@ class TerminalConsole(Console):
                     self.evaluation_column_widths["duration"]
                 )
 
-                msg = f"{batch} {display_name}   {annotation}   {duration}".replace(
+                msg = f"{f'{batch} ' if not audit_only else ''}{display_name}   {annotation}   {duration}".replace(
                     self.AUDIT_PASS_MARK, self.GREEN_AUDIT_PASS_MARK
                 )
 
@@ -1015,7 +1028,10 @@ class TerminalConsole(Console):
 
             model_task_id = self.evaluation_model_tasks[snapshot.name]
             self.evaluation_model_progress.update(model_task_id, refresh=True, advance=1)
-            if self.evaluation_model_progress._tasks[model_task_id].completed >= total_batches:
+            if (
+                self.evaluation_model_progress._tasks[model_task_id].completed >= total_batches
+                or audit_only
+            ):
                 self.evaluation_model_progress.remove_task(model_task_id)
 
     def stop_evaluation_progress(self, success: bool = True) -> None:
@@ -3208,6 +3224,7 @@ class DatabricksMagicConsole(CaptureTerminalConsole):
         batched_intervals: t.Dict[Snapshot, Intervals],
         environment_naming_info: EnvironmentNamingInfo,
         default_catalog: t.Optional[str],
+        audit_only: bool = False,
     ) -> None:
         self.evaluation_model_batch_sizes = {
             snapshot: len(intervals) for snapshot, intervals in batched_intervals.items()
@@ -3215,7 +3232,9 @@ class DatabricksMagicConsole(CaptureTerminalConsole):
         self.evaluation_environment_naming_info = environment_naming_info
         self.default_catalog = default_catalog
 
-    def start_snapshot_evaluation_progress(self, snapshot: Snapshot) -> None:
+    def start_snapshot_evaluation_progress(
+        self, snapshot: Snapshot, audit_only: bool = False
+    ) -> None:
         if not self.evaluation_batch_progress.get(snapshot.snapshot_id):
             display_name = snapshot.display_name(
                 self.evaluation_environment_naming_info,
@@ -3235,8 +3254,14 @@ class DatabricksMagicConsole(CaptureTerminalConsole):
         duration_ms: t.Optional[int],
         num_audits_passed: int,
         num_audits_failed: int,
+        audit_only: bool = False,
     ) -> None:
         view_name, loaded_batches = self.evaluation_batch_progress[snapshot.snapshot_id]
+
+        if audit_only:
+            print(f"Completed Auditing {view_name}")
+            return
+
         total_batches = self.evaluation_model_batch_sizes[snapshot]
 
         loaded_batches += 1
@@ -3378,13 +3403,17 @@ class DebuggerTerminalConsole(TerminalConsole):
         batched_intervals: t.Dict[Snapshot, Intervals],
         environment_naming_info: EnvironmentNamingInfo,
         default_catalog: t.Optional[str],
+        audit_only: bool = False,
     ) -> None:
+        message = "evaluation" if not audit_only else "auditing"
         self._write(
-            f"Starting evaluation for {sum(len(intervals) for intervals in batched_intervals.values())} snapshots"
+            f"Starting {message} for {sum(len(intervals) for intervals in batched_intervals.values())} snapshots"
         )
 
-    def start_snapshot_evaluation_progress(self, snapshot: Snapshot) -> None:
-        self._write(f"Evaluating {snapshot.name}")
+    def start_snapshot_evaluation_progress(
+        self, snapshot: Snapshot, audit_only: bool = False
+    ) -> None:
+        self._write(f"{'Evaluating' if not audit_only else 'Auditing'} {snapshot.name}")
 
     def update_snapshot_evaluation_progress(
         self,
@@ -3394,10 +3423,14 @@ class DebuggerTerminalConsole(TerminalConsole):
         duration_ms: t.Optional[int],
         num_audits_passed: int,
         num_audits_failed: int,
+        audit_only: bool = False,
     ) -> None:
-        self._write(
-            f"Evaluating {snapshot.name} | batch={batch_idx} | duration={duration_ms}ms | num_audits_passed={num_audits_passed} | num_audits_failed={num_audits_failed}"
-        )
+        message = f"Evaluating {snapshot.name} | batch={batch_idx} | duration={duration_ms}ms | num_audits_passed={num_audits_passed} | num_audits_failed={num_audits_failed}"
+
+        if audit_only:
+            message = f"Auditing {snapshot.name} duration={duration_ms}ms | num_audits_passed={num_audits_passed} | num_audits_failed={num_audits_failed}"
+
+        self._write(message)
 
     def stop_evaluation_progress(self, success: bool = True) -> None:
         self._write(f"Stopping evaluation with success={success}")

sqlmesh/core/model/definition.py

@@ -1069,6 +1069,37 @@ class _Model(ModelMeta, frozen=True):
 
         return data  # type: ignore
 
+    def _audit_metadata_hash_values(self) -> t.List[str]:
+        from sqlmesh.core.audit.builtin import BUILT_IN_AUDITS
+
+        metadata = []
+
+        for audit_name, audit_args in sorted(self.audits, key=lambda a: a[0]):
+            metadata.append(audit_name)
+            if audit_name in BUILT_IN_AUDITS:
+                for arg_name, arg_value in audit_args.items():
+                    metadata.append(arg_name)
+                    metadata.append(gen(arg_value))
+            else:
+                audit = self.audit_definitions[audit_name]
+                query = (
+                    self.render_audit_query(audit, **t.cast(t.Dict[str, t.Any], audit_args))
+                    or audit.query
+                )
+                metadata.extend(
+                    [
+                        gen(query),
+                        audit.dialect,
+                        str(audit.skip),
+                        str(audit.blocking),
+                    ]
+                )
+
+        return metadata
+
+    def audit_metadata_hash(self) -> str:
+        return hash_data(self._audit_metadata_hash_values())
+
     @property
     def metadata_hash(self) -> str:
         """
@@ -1078,8 +1109,6 @@ class _Model(ModelMeta, frozen=True):
             The metadata hash for the node.
         """
         if self._metadata_hash is None:
-            from sqlmesh.core.audit.builtin import BUILT_IN_AUDITS
-
             metadata = [
                 self.dialect,
                 self.owner,
@@ -1100,29 +1129,9 @@ class _Model(ModelMeta, frozen=True):
                 str(self.allow_partials),
                 gen(self.session_properties_) if self.session_properties_ else None,
                 *[gen(g) for g in self.grains],
+                *self._audit_metadata_hash_values(),
             ]
 
-            for audit_name, audit_args in sorted(self.audits, key=lambda a: a[0]):
-                metadata.append(audit_name)
-                if audit_name in BUILT_IN_AUDITS:
-                    for arg_name, arg_value in audit_args.items():
-                        metadata.append(arg_name)
-                        metadata.append(gen(arg_value))
-                else:
-                    audit = self.audit_definitions[audit_name]
-                    query = (
-                        self.render_audit_query(audit, **t.cast(t.Dict[str, t.Any], audit_args))
-                        or audit.query
-                    )
-                    metadata.extend(
-                        [
-                            gen(query),
-                            audit.dialect,
-                            str(audit.skip),
-                            str(audit.blocking),
-                        ]
-                    )
-
             for key, value in (self.virtual_properties or {}).items():
                 metadata.append(key)
                 metadata.append(gen(value))

sqlmesh/core/plan/evaluator.py

@@ -128,6 +128,8 @@ class BuiltInPlanEvaluator(PlanEvaluator):
                 execution_time=plan.execution_time,
             )
 
+            self._run_audits_for_metadata_snapshots(plan, new_snapshots)
+
             push_completion_status = self._push(plan, snapshots, deployability_index_for_creation)
             if push_completion_status.is_nothing_to_do:
                 self.console.log_status_update(
@@ -545,6 +547,54 @@ class BuiltInPlanEvaluator(PlanEvaluator):
 
         return set(snapshots_to_restate.values())
 
+    def _run_audits_for_metadata_snapshots(
+        self,
+        plan: EvaluatablePlan,
+        new_snapshots: t.Dict[SnapshotId, Snapshot],
+    ) -> None:
+        # Filter out snapshots that are not categorized as metadata changes on models
+        metadata_snapshots = []
+        for snapshot in new_snapshots.values():
+            if not snapshot.is_metadata or not snapshot.is_model or not snapshot.evaluatable:
+                continue
+
+            metadata_snapshots.append(snapshot)
+
+        # Bulk load all the previous snapshots
+        previous_snapshots = self.state_sync.get_snapshots(
+            [
+                s.previous_version.snapshot_id(s.name)
+                for s in metadata_snapshots
+                if s.previous_version
+            ]
+        ).values()
+
+        # Check if any of the snapshots have modifications to the audits field by comparing the hashes
+        audit_snapshots = {}
+        for snapshot, previous_snapshot in zip(metadata_snapshots, previous_snapshots):
+            new_audits_hash = snapshot.model.audit_metadata_hash()
+            previous_audit_hash = previous_snapshot.model.audit_metadata_hash()
+
+            if snapshot.model.audits and previous_audit_hash != new_audits_hash:
+                audit_snapshots[snapshot.snapshot_id] = snapshot
+
+        if not audit_snapshots:
+            return
+
+        # If there are any snapshots to be audited, we'll reuse the scheduler's internals to audit them
+        scheduler = self.create_scheduler(audit_snapshots.values())
+        completion_status = scheduler.audit(
+            plan.environment,
+            plan.start,
+            plan.end,
+            execution_time=plan.execution_time,
+            end_bounded=plan.end_bounded,
+            interval_end_per_model=plan.interval_end_per_model,
+        )
+
+        if completion_status.is_failure:
+            raise PlanError("Plan application failed.")
+
 
 def update_intervals_for_new_snapshots(
     snapshots: t.Collection[Snapshot], state_sync: StateSync

sqlmesh/core/scheduler.py

@@ -149,8 +149,9 @@ class Scheduler:
         execution_time: TimeLike,
         deployability_index: DeployabilityIndex,
         batch_index: int,
+        environment_naming_info: t.Optional[EnvironmentNamingInfo] = None,
         **kwargs: t.Any,
-    ) -> t.Tuple[t.List[AuditResult], t.List[AuditError]]:
+    ) -> t.List[AuditResult]:
         """Evaluate a snapshot and add the processed interval to the state sync.
 
         Args:
@@ -182,8 +183,9 @@ class Scheduler:
             batch_index=batch_index,
             **kwargs,
         )
-        audit_results = self.snapshot_evaluator.audit(
+        audit_results = self._audit_snapshot(
             snapshot=snapshot,
+            environment_naming_info=environment_naming_info,
             start=start,
             end=end,
             execution_time=execution_time,
@@ -193,32 +195,8 @@ class Scheduler:
             **kwargs,
         )
 
-        audit_errors_to_raise: t.List[AuditError] = []
-        audit_errors_to_warn: t.List[AuditError] = []
-        for audit_result in (result for result in audit_results if result.count):
-            error = AuditError(
-                audit_name=audit_result.audit.name,
-                audit_args=audit_result.audit_args,
-                model=snapshot.model_or_none,
-                count=t.cast(int, audit_result.count),
-                query=t.cast(exp.Query, audit_result.query),
-                adapter_dialect=self.snapshot_evaluator.adapter.dialect,
-            )
-            self.notification_target_manager.notify(NotificationEvent.AUDIT_FAILURE, error)
-            if is_deployable and snapshot.node.owner:
-                self.notification_target_manager.notify_user(
-                    NotificationEvent.AUDIT_FAILURE, snapshot.node.owner, error
-                )
-            if audit_result.blocking:
-                audit_errors_to_raise.append(error)
-            else:
-                audit_errors_to_warn.append(error)
-
-        if audit_errors_to_raise:
-            raise NodeAuditsErrors(audit_errors_to_raise)
-
         self.state_sync.add_interval(snapshot, start, end, is_dev=not is_deployable)
-        return audit_results, audit_errors_to_warn
+        return audit_results
 
     def run(
         self,
@@ -236,101 +214,61 @@ class Scheduler:
         auto_restatement_enabled: bool = False,
         run_environment_statements: bool = False,
     ) -> CompletionStatus:
-        """Concurrently runs all snapshots in topological order.
-
-        Args:
-            environment: The environment naming info the user is targeting when applying their change.
-                Can just be the environment name if the user is targeting a remote environment and wants to get the remote
-                naming info
-            start: The start of the run. Defaults to the min node start date.
-            end: The end of the run. Defaults to now.
-            execution_time: The date/time time reference to use for execution time. Defaults to now.
-            restatements: A dict of snapshots to restate and their intervals.
-            interval_end_per_model: The mapping from model FQNs to target end dates.
-            ignore_cron: Whether to ignore the node's cron schedule.
-            end_bounded: If set to true, the evaluated intervals will be bounded by the target end date, disregarding lookback,
-                allow_partials, and other attributes that could cause the intervals to exceed the target end date.
-            selected_snapshots: A set of snapshot names to run. If not provided, all snapshots will be run.
-            circuit_breaker: An optional handler which checks if the run should be aborted.
-            deployability_index: Determines snapshots that are deployable in the context of this render.
-            auto_restatement_enabled: Whether to enable auto restatements.
-
-        Returns:
-            True if the execution was successful and False otherwise.
-        """
-        restatements = restatements or {}
-        validate_date_range(start, end)
-        if isinstance(environment, str):
-            env = self.state_sync.get_environment(environment)
-            if not env:
-                raise SQLMeshError(
-                    "Was not provided an environment suffix target and the environment doesn't exist."
-                    "Are you running for the first time and need to run plan/apply first?"
-                )
-            environment_naming_info = env.naming_info
-        else:
-            environment_naming_info = environment
-
-        deployability_index = deployability_index or (
-            DeployabilityIndex.create(self.snapshots.values(), start=start)
-            if environment_naming_info.name != c.PROD
-            else DeployabilityIndex.all_deployable()
-        )
-        execution_time = execution_time or now_timestamp()
-
-        self.state_sync.refresh_snapshot_intervals(self.snapshots.values())
-        for s_id, interval in (restatements or {}).items():
-            self.snapshots[s_id].remove_interval(interval)
-
-        if auto_restatement_enabled:
-            auto_restated_intervals = apply_auto_restatements(self.snapshots, execution_time)
-            self.state_sync.add_snapshots_intervals(auto_restated_intervals)
-            self.state_sync.update_auto_restatements(
-                {s.name_version: s.next_auto_restatement_ts for s in self.snapshots.values()}
-            )
-
-        merged_intervals = self.merged_missing_intervals(
-            start,
-            end,
-            execution_time,
-            deployability_index=deployability_index,
-            restatements=restatements,
+        return self._run_or_audit(
+            environment=environment,
+            start=start,
+            end=end,
+            execution_time=execution_time,
+            remove_intervals=restatements,
             interval_end_per_model=interval_end_per_model,
             ignore_cron=ignore_cron,
             end_bounded=end_bounded,
             selected_snapshots=selected_snapshots,
+            circuit_breaker=circuit_breaker,
+            deployability_index=deployability_index,
+            auto_restatement_enabled=auto_restatement_enabled,
+            run_environment_statements=run_environment_statements,
         )
 
-        if not merged_intervals:
-            return CompletionStatus.NOTHING_TO_DO
+    def audit(
+        self,
+        environment: str | EnvironmentNamingInfo,
+        start: TimeLike,
+        end: TimeLike,
+        execution_time: t.Optional[TimeLike] = None,
+        interval_end_per_model: t.Optional[t.Dict[str, int]] = None,
+        ignore_cron: bool = False,
+        end_bounded: bool = False,
+        selected_snapshots: t.Optional[t.Set[str]] = None,
+        circuit_breaker: t.Optional[t.Callable[[], bool]] = None,
+        deployability_index: t.Optional[DeployabilityIndex] = None,
+        run_environment_statements: bool = False,
+    ) -> CompletionStatus:
+        # Remove the intervals from the snapshots that will be audited so that they can be recomputed
+        # by _run_or_audit as "missing intervals" to reuse the rest of it's logic
+        remove_intervals = {}
+        for snapshot in self.snapshots.values():
+            removal_intervals = snapshot.get_removal_interval(
+                start, end, execution_time, is_preview=True
+            )
+            remove_intervals[snapshot.snapshot_id] = removal_intervals
 
-        errors, skipped_intervals = self.run_merged_intervals(
-            merged_intervals=merged_intervals,
-            deployability_index=deployability_index,
-            environment_naming_info=environment_naming_info,
-            execution_time=execution_time,
-            circuit_breaker=circuit_breaker,
+        return self._run_or_audit(
+            environment=environment,
             start=start,
             end=end,
+            execution_time=execution_time,
+            remove_intervals=remove_intervals,
+            interval_end_per_model=interval_end_per_model,
+            ignore_cron=ignore_cron,
+            end_bounded=end_bounded,
+            selected_snapshots=selected_snapshots,
+            circuit_breaker=circuit_breaker,
+            deployability_index=deployability_index,
             run_environment_statements=run_environment_statements,
+            audit_only=True,
         )
 
-        self.console.stop_evaluation_progress(success=not errors)
-
-        skipped_snapshots = {i[0] for i in skipped_intervals}
-        self.console.log_skipped_models(skipped_snapshots)
-        for skipped in skipped_snapshots:
-            logger.info(f"SKIPPED snapshot {skipped}\n")
-
-        for error in errors:
-            if isinstance(error.__cause__, CircuitBreakerError):
-                raise error.__cause__
-            logger.info(str(error), exc_info=error)
-
-        self.console.log_failed_models(errors)
-
-        return CompletionStatus.FAILURE if errors else CompletionStatus.SUCCESS
-
     def batch_intervals(
         self,
         merged_intervals: SnapshotToIntervals,
@@ -407,6 +345,7 @@ class Scheduler:
         start: t.Optional[TimeLike] = None,
         end: t.Optional[TimeLike] = None,
         run_environment_statements: bool = False,
+        audit_only: bool = False,
     ) -> t.Tuple[t.List[NodeExecutionFailedError[SchedulingUnit]], t.List[SchedulingUnit]]:
         """Runs precomputed batches of missing intervals.
 
@@ -430,6 +369,7 @@ class Scheduler:
             batched_intervals,
             environment_naming_info,
             self.default_catalog,
+            audit_only=audit_only,
         )
 
         dag = self._dag(batched_intervals)
@@ -465,28 +405,29 @@ class Scheduler:
             evaluation_duration_ms: t.Optional[int] = None
 
             audit_results: t.List[AuditResult] = []
-            audit_errors_to_warn: t.List[AuditError] = []
             try:
                 assert execution_time  # mypy
                 assert deployability_index  # mypy
-                audit_results, audit_errors_to_warn = self.evaluate(
-                    snapshot=snapshot,
-                    start=start,
-                    end=end,
-                    execution_time=execution_time,
-                    deployability_index=deployability_index,
-                    batch_index=batch_idx,
-                )
 
-                for audit_error in audit_errors_to_warn:
-                    display_name = snapshot.display_name(
-                        environment_naming_info,
-                        self.default_catalog,
-                        self.snapshot_evaluator.adapter.dialect,
+                if audit_only:
+                    audit_results = self._audit_snapshot(
+                        snapshot=snapshot,
+                        environment_naming_info=environment_naming_info,
+                        deployability_index=deployability_index,
+                        snapshots=self.snapshots_by_name,
+                        start=start,
+                        end=end,
+                        execution_time=execution_time,
                     )
-                    self.console.log_warning(
-                        f"\n{display_name}: {audit_error}.",
-                        f"{audit_error}. Audit query:\n{audit_error.query.sql(audit_error.adapter_dialect)}",
+                else:
+                    audit_results = self.evaluate(
+                        snapshot=snapshot,
+                        environment_naming_info=environment_naming_info,
+                        start=start,
+                        end=end,
+                        execution_time=execution_time,
+                        deployability_index=deployability_index,
+                        batch_index=batch_idx,
                     )
 
                 evaluation_duration_ms = now_timestamp() - execution_start_ts
@@ -583,6 +524,181 @@ class Scheduler:
                     )
         return dag
 
+    def _run_or_audit(
+        self,
+        environment: str | EnvironmentNamingInfo,
+        start: t.Optional[TimeLike] = None,
+        end: t.Optional[TimeLike] = None,
+        execution_time: t.Optional[TimeLike] = None,
+        remove_intervals: t.Optional[t.Dict[SnapshotId, Interval]] = None,
+        interval_end_per_model: t.Optional[t.Dict[str, int]] = None,
+        ignore_cron: bool = False,
+        end_bounded: bool = False,
+        selected_snapshots: t.Optional[t.Set[str]] = None,
+        circuit_breaker: t.Optional[t.Callable[[], bool]] = None,
+        deployability_index: t.Optional[DeployabilityIndex] = None,
+        auto_restatement_enabled: bool = False,
+        run_environment_statements: bool = False,
+        audit_only: bool = False,
+    ) -> CompletionStatus:
+        """Concurrently runs or audits all snapshots in topological order.
+
+        Args:
+            environment: The environment naming info the user is targeting when applying their change.
+                Can just be the environment name if the user is targeting a remote environment and wants to get the remote
+                naming info
+            start: The start of the run. Defaults to the min node start date.
+            end: The end of the run. Defaults to now.
+            execution_time: The date/time time reference to use for execution time. Defaults to now.
+            remove_intervals: A dict of snapshots to their intervals. For evaluation, these are the intervals that will be restated. For audits,
+                              these are the intervals that will be reaudited
+            interval_end_per_model: The mapping from model FQNs to target end dates.
+            ignore_cron: Whether to ignore the node's cron schedule.
+            end_bounded: If set to true, the evaluated intervals will be bounded by the target end date, disregarding lookback,
+                allow_partials, and other attributes that could cause the intervals to exceed the target end date.
+            selected_snapshots: A set of snapshot names to run. If not provided, all snapshots will be run.
+            circuit_breaker: An optional handler which checks if the run should be aborted.
+            deployability_index: Determines snapshots that are deployable in the context of this render.
+            auto_restatement_enabled: Whether to enable auto restatements.
+
+        Returns:
+            True if the execution was successful and False otherwise.
+        """
+        validate_date_range(start, end)
+        if isinstance(environment, str):
+            env = self.state_sync.get_environment(environment)
+            if not env:
+                raise SQLMeshError(
+                    "Was not provided an environment suffix target and the environment doesn't exist."
+                    "Are you running for the first time and need to run plan/apply first?"
+                )
+            environment_naming_info = env.naming_info
+        else:
+            environment_naming_info = environment
+
+        deployability_index = deployability_index or (
+            DeployabilityIndex.create(self.snapshots.values(), start=start)
+            if environment_naming_info.name != c.PROD
+            else DeployabilityIndex.all_deployable()
+        )
+        execution_time = execution_time or now_timestamp()
+
+        self.state_sync.refresh_snapshot_intervals(self.snapshots.values())
+        for s_id, interval in (remove_intervals or {}).items():
+            self.snapshots[s_id].remove_interval(interval)
+
+        if auto_restatement_enabled:
+            auto_restated_intervals = apply_auto_restatements(self.snapshots, execution_time)
+            self.state_sync.add_snapshots_intervals(auto_restated_intervals)
+            self.state_sync.update_auto_restatements(
+                {s.name_version: s.next_auto_restatement_ts for s in self.snapshots.values()}
+            )
+
+        merged_intervals = self.merged_missing_intervals(
+            start,
+            end,
+            execution_time,
+            deployability_index=deployability_index,
+            restatements=remove_intervals,
+            interval_end_per_model=interval_end_per_model,
+            ignore_cron=ignore_cron,
+            end_bounded=end_bounded,
+            selected_snapshots=selected_snapshots,
+        )
+        if not merged_intervals:
+            return CompletionStatus.NOTHING_TO_DO
+
+        errors, skipped_intervals = self.run_merged_intervals(
+            merged_intervals=merged_intervals,
+            deployability_index=deployability_index,
+            environment_naming_info=environment_naming_info,
+            execution_time=execution_time,
+            circuit_breaker=circuit_breaker,
+            start=start,
+            end=end,
+            run_environment_statements=run_environment_statements,
+            audit_only=audit_only,
+        )
+
+        self.console.stop_evaluation_progress(success=not errors)
+
+        skipped_snapshots = {i[0] for i in skipped_intervals}
+        self.console.log_skipped_models(skipped_snapshots)
+        for skipped in skipped_snapshots:
+            logger.info(f"SKIPPED snapshot {skipped}\n")
+
+        for error in errors:
+            if isinstance(error.__cause__, CircuitBreakerError):
+                raise error.__cause__
+            logger.info(str(error), exc_info=error)
+
+        self.console.log_failed_models(errors)
+
+        return CompletionStatus.FAILURE if errors else CompletionStatus.SUCCESS
+
+    def _audit_snapshot(
+        self,
+        snapshot: Snapshot,
+        deployability_index: DeployabilityIndex,
+        snapshots: t.Dict[str, Snapshot],
+        start: t.Optional[TimeLike] = None,
+        end: t.Optional[TimeLike] = None,
+        execution_time: t.Optional[TimeLike] = None,
+        wap_id: t.Optional[str] = None,
+        environment_naming_info: t.Optional[EnvironmentNamingInfo] = None,
+        **kwargs: t.Any,
+    ) -> t.List[AuditResult]:
+        is_deployable = deployability_index.is_deployable(snapshot)
+
+        audit_results = self.snapshot_evaluator.audit(
+            snapshot=snapshot,
+            start=start,
+            end=end,
+            execution_time=execution_time,
+            snapshots=snapshots,
+            deployability_index=deployability_index,
+            wap_id=wap_id,
+            **kwargs,
+        )
+
+        audit_errors_to_raise: t.List[AuditError] = []
+        audit_errors_to_warn: t.List[AuditError] = []
+        for audit_result in (result for result in audit_results if result.count):
+            error = AuditError(
+                audit_name=audit_result.audit.name,
+                audit_args=audit_result.audit_args,
+                model=snapshot.model_or_none,
+                count=t.cast(int, audit_result.count),
+                query=t.cast(exp.Query, audit_result.query),
+                adapter_dialect=self.snapshot_evaluator.adapter.dialect,
+            )
+            self.notification_target_manager.notify(NotificationEvent.AUDIT_FAILURE, error)
+            if is_deployable and snapshot.node.owner:
+                self.notification_target_manager.notify_user(
+                    NotificationEvent.AUDIT_FAILURE, snapshot.node.owner, error
+                )
+            if audit_result.blocking:
+                audit_errors_to_raise.append(error)
+            else:
+                audit_errors_to_warn.append(error)
+
+        if audit_errors_to_raise:
+            raise NodeAuditsErrors(audit_errors_to_raise)
+
+        if environment_naming_info:
+            for audit_error in audit_errors_to_warn:
+                display_name = snapshot.display_name(
+                    environment_naming_info,
+                    self.default_catalog,
+                    self.snapshot_evaluator.adapter.dialect,
+                )
+                self.console.log_warning(
+                    f"\n{display_name}: {audit_error}.",
+                    f"{audit_error}. Audit query:\n{audit_error.query.sql(audit_error.adapter_dialect)}",
+                )
+
+        return audit_results
+
 
 def compute_interval_params(
     snapshots: t.Collection[Snapshot],

{sqlmesh-0.182.1.dev11.dist-info → sqlmesh-0.183.1.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.182.1.dev11
+Version: 0.183.1.dev1
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.182.1.dev11.dist-info → sqlmesh-0.183.1.dev1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 sqlmesh/__init__.py,sha256=DRovDXI-9D9xeYDP7t8Fq7mI31S2btlN-LHPOK3y7PA,7240
-sqlmesh/_version.py,sha256=xq4uYUyMW-tE8c0UOE-8IEknqvQyZ6agAaTeVjZRLh8,530
+sqlmesh/_version.py,sha256=CdSt2H82Fsaq1-jnoVcfx_AmtltmEprat3aS3RpPnrY,528
 sqlmesh/magics.py,sha256=9oY1Uz8uwsuTtPRg9HTYDxnGiJ7-OVRCpmCgAhbKHUU,39431
 sqlmesh/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/cicd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -11,7 +11,7 @@ sqlmesh/cli/main.py,sha256=z1Af0bwqtnYHzkY0_9REpaJe-onxvXN4rLw6upyxKec,31979
 sqlmesh/cli/options.py,sha256=aC_L5WnMScKzMU55BD1Y-8R-QzqCkPSYrlCI-payHRA,1333
 sqlmesh/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/core/_typing.py,sha256=e1f7xO2aZCy38M_3VoDy-XI3shyd99-IFctgIFSgXWM,497
-sqlmesh/core/console.py,sha256=-FGOalIrfCN5ZyDIYW8Emx3GIF9qeaNfNW00lUogoFg,149608
+sqlmesh/core/console.py,sha256=o5TSVb9rN0ygerS-CeWaZTIblaa7u-OZotucwTBu4ik,150790
 sqlmesh/core/constants.py,sha256=oqt6zjepUhQoWlgapKn_HpG7Pu9mrFwepdX5caNfJUI,2499
 sqlmesh/core/context.py,sha256=kLKXwOLc_5Orv-SxvI0zbpL9ZJ0XkB9HZgd9R6uh-9Y,114691
 sqlmesh/core/context_diff.py,sha256=s9toP17d4tJfOpFH91LcjGK2CM64PVuB0MPkeFgF4hQ,20415
@@ -24,7 +24,7 @@ sqlmesh/core/node.py,sha256=r4_1MRTPcU0MAlwZ5KzrykLT58B7dkKvHzPCsJmEKD8,14497
 sqlmesh/core/notification_target.py,sha256=PPGoDrgbRKxr27vJEu03XqNTQLYTw0ZF_b0yAapxGeI,16158
 sqlmesh/core/reference.py,sha256=k7OSkLqTjPR8WJjNeFj0xAJ297nZUMgb_iTVwKRRKjc,4875
 sqlmesh/core/renderer.py,sha256=n2WEGENL-1Z53sBTI6RVH_yRVneDtNK0GxNElFaQKcE,26597
-sqlmesh/core/scheduler.py,sha256=r0WOHKarut-ywKLsAF5vn5WeA5Q5h7jGVk8nHR0cz_0,29414
+sqlmesh/core/scheduler.py,sha256=TB03rSvPyaPMRANOJq_O_cNXvu0fc5rVaDVC9olE5kg,34196
 sqlmesh/core/schema_diff.py,sha256=mE28W51JUQz6q8inSOw2Cds84VPIqPxI6C2ed6xLmrg,29812
 sqlmesh/core/schema_loader.py,sha256=lvrI9k7hr1P4X4E6t3U-KrcuvdQuw0UdNlN90P2s52w,3563
 sqlmesh/core/selector.py,sha256=9riBQ6gPySg546x0JaXXITw2eZgGe9iVKcynAUJ1mmw,12137
@@ -87,7 +87,7 @@ sqlmesh/core/model/__init__.py,sha256=C8GRZ53xuXEA9hQv3BQS9pNNyd9rZ06R_B96UYGhDu
 sqlmesh/core/model/cache.py,sha256=hzpGPXxp2LFMEp6gm-8DULJKCBDGf-1kTQcfNt0xrRM,7028
 sqlmesh/core/model/common.py,sha256=Lr2o0KCMt3HPqlc_4uiNz5BhYSUdm5bzvjCaIz58H7A,15724
 sqlmesh/core/model/decorator.py,sha256=v_sVudNROGrtj5cZ3vgcOFnwPdzwoUGY6REAkQpIMQc,8927
-sqlmesh/core/model/definition.py,sha256=qwj9smoaeVZglkTON6HTTlGzOvPwhmjgcaQ160Pjo6E,108953
+sqlmesh/core/model/definition.py,sha256=Uc0sWFosZ7V_VcFB0iVwKQotuxxrHxMqtiYJH_A2_lg,109132
 sqlmesh/core/model/kind.py,sha256=em6wq0W4pDnxl9sBgNweosnZH1on3h349t0Pn76wwBM,35867
 sqlmesh/core/model/meta.py,sha256=v-g1lnGPoeZ2SjV2CbVjvlec9buydiOFKkZWUm2dQPs,19071
 sqlmesh/core/model/schema.py,sha256=QzM1cOfukuK3L-cEE9MtxKeYec3x5JvutdZAnczJSiQ,3858
@@ -95,7 +95,7 @@ sqlmesh/core/model/seed.py,sha256=ctUHH6CmeEnBVJyIAZznx0xJBm09W7VIZ-76Cfwfq28,50
 sqlmesh/core/plan/__init__.py,sha256=ctpnu9mK3uTujs0It8qRMqcj9GdObXDnvSgn4rD2zqc,450
 sqlmesh/core/plan/builder.py,sha256=ltoUlUr13uoEftYqGzjbnOa_n7-Q1CUiE9R_LgHY9Mc,38471
 sqlmesh/core/plan/definition.py,sha256=SI3zi2poPkKJKTZogYv60Q7eIOhksaAcFUcu-J2-XqI,13218
-sqlmesh/core/plan/evaluator.py,sha256=Ocb4vxWUFRI1hD5tpkVvdJicWSa9rUfL8Qm1C3DMVts,23760
+sqlmesh/core/plan/evaluator.py,sha256=D_DegArxUsmxgVwxzQPv-RKGGcihDQeg1bdsqcpmu6s,25741
 sqlmesh/core/snapshot/__init__.py,sha256=Z5HTetNCZGoKF1WAKXk4LWL9dc8EC8lwS2O4TtoBmt4,1317
 sqlmesh/core/snapshot/cache.py,sha256=MRYi_koDvp2yeQ5NDGoNFzhuJTw7Vh7mI0oJyeVbqio,4022
 sqlmesh/core/snapshot/categorizer.py,sha256=qGG5870mu1jR2whKisSBH_GFbsyh96RnzJDgkN7DV9g,2482
@@ -266,7 +266,7 @@ sqlmesh/utils/pandas.py,sha256=j_tYhuPcWpzuPceZZ6IhdTVbmxYyGJW7l4FHr4bQqjM,1824
 sqlmesh/utils/pydantic.py,sha256=ioaAzYF42PutEJRyAS11-AHguiCG3yWI6VRcTVa2G-g,10470
 sqlmesh/utils/rich.py,sha256=xNZyPCqEc4TAlJlsEthg-5eYUWpaizz0QjBzO7a1Yv4,1509
 sqlmesh/utils/yaml.py,sha256=np-WVcwmwsKghCgAj1OBBMsK1SXSRn4wR-H37cGiFr8,2282
-sqlmesh-0.182.1.dev11.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
+sqlmesh-0.183.1.dev1.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
 web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web/client/dist/index.html,sha256=nPqIDCJmonOaEAp4hhwrwgPdwt_F-5zzw-WW1kJqq3I,5472
 web/client/dist/assets/Audits-DiRd7NXk.js,sha256=Q5dIFqsHps-vVYD8037NpTPW_1juQgn_Ov45smEm7Y8,1041
@@ -363,7 +363,7 @@ web/client/dist/fonts/Sohne/sohne-mono-kraftig.woff2,sha256=DGsWMljiFHztzyb0Gg_T
 web/client/src/workers/sqlglot/sqlglot.py,sha256=XAMrvqcRBa7vy8bHVayYbZNyWsf1lNSjVk_odtif-YY,1566
 web/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web/server/app.py,sha256=b6qEJ4btjaSm2kWwQUGV--S3VE8QW0Um7f4rBdaoB_M,59
-web/server/console.py,sha256=h1NrP01ax1TtSYc-r1W3lmuaNGzC-iBH-Wc83uEi-VA,14292
+web/server/console.py,sha256=K2fJpiZbibWaQa2OvN7YbeI9sxkXtkXwA8lJKsXfq-k,14529
 web/server/exceptions.py,sha256=I2PPpChwhDWawQENr5kHg6DjyRGeiJ6OWZsCzEZhVzs,1533
 web/server/main.py,sha256=9PaDa8sigo1z0AxtI3sQ3fHmDqs6uXwP-_IvoMwkznw,3199
 web/server/models.py,sha256=SUztvOYmlHDMVOt7C36-C3tKBwm7UNRkkYeid9bc5n8,15527
@@ -384,8 +384,8 @@ web/server/api/endpoints/models.py,sha256=SzS5bshzdXyM6hb948sZ_3k-xhpGCHkxkb7pHz
 web/server/api/endpoints/modules.py,sha256=8hqqgonGay_mJmpCw0IdbjsPhWlQH2VLdKAqha-myac,468
 web/server/api/endpoints/plan.py,sha256=OYuQ_4dgbhG9ibTcX1a8mvYgH3ANxw9Fhbb4wg6QWqc,9222
 web/server/api/endpoints/table_diff.py,sha256=Wd5YxeKbZB7AkrDvqFgvV9ZQlnKYOF1n5W_w2EHE_Zw,2085
-sqlmesh-0.182.1.dev11.dist-info/METADATA,sha256=h6wPxjDx8uRDrom1lsCleuWuZ2X8m-qfOz11LFYMT4o,25253
-sqlmesh-0.182.1.dev11.dist-info/WHEEL,sha256=QZxptf4Y1BKFRCEDxD4h2V0mBFQOVFLFEpvxHmIs52A,91
-sqlmesh-0.182.1.dev11.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
-sqlmesh-0.182.1.dev11.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
-sqlmesh-0.182.1.dev11.dist-info/RECORD,,
+sqlmesh-0.183.1.dev1.dist-info/METADATA,sha256=p0n7HFlYBHg7tUa0czVN0J2_oOKW7HL5tGZx8izIHIc,25252
+sqlmesh-0.183.1.dev1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+sqlmesh-0.183.1.dev1.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
+sqlmesh-0.183.1.dev1.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
+sqlmesh-0.183.1.dev1.dist-info/RECORD,,

{sqlmesh-0.182.1.dev11.dist-info → sqlmesh-0.183.1.dev1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.6.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

web/server/console.py

@@ -93,7 +93,11 @@ class ApiConsole(TerminalConsole):
         batched_intervals: t.Dict[Snapshot, Intervals],
         environment_naming_info: EnvironmentNamingInfo,
         default_catalog: t.Optional[str],
+        audit_only: bool = False,
     ) -> None:
+        if audit_only:
+            return
+
         if self.plan_apply_stage_tracker:
             batch_sizes = {
                 snapshot: len(intervals) for snapshot, intervals in batched_intervals.items()
@@ -118,7 +122,12 @@ class ApiConsole(TerminalConsole):
 
         self.log_event_plan_apply()
 
-    def start_snapshot_evaluation_progress(self, snapshot: Snapshot) -> None:
+    def start_snapshot_evaluation_progress(
+        self, snapshot: Snapshot, audit_only: bool = False
+    ) -> None:
+        if audit_only:
+            return
+
         if self.plan_apply_stage_tracker and self.plan_apply_stage_tracker.backfill:
             self.plan_apply_stage_tracker.backfill.queue.add(snapshot.name)
 
@@ -132,7 +141,11 @@ class ApiConsole(TerminalConsole):
         duration_ms: t.Optional[int],
         num_audits_passed: int,
         num_audits_failed: int,
+        audit_only: bool = False,
     ) -> None:
+        if audit_only:
+            return
+
         if self.plan_apply_stage_tracker and self.plan_apply_stage_tracker.backfill:
             task = self.plan_apply_stage_tracker.backfill.tasks[snapshot.name]
             task.completed += 1