Fix: use MarkdownConsole in non-interactive contexts (#4306)

Author: treysp

docs/reference/configuration.md

@@ -248,32 +248,64 @@ For example, you might have a specific connection where your tests should run re
 
 ## Debug mode
 
-To enable debug mode set the `SQLMESH_DEBUG` environment variable to one of the following values: "1", "true", "t", "yes" or "y".
+Enable debug mode in one of two ways:
+
+- Pass the `--debug` flag between the CLI command and the subcommand. For example, `sqlmesh --debug plan`.
+- Set the `SQLMESH_DEBUG` environment variable to one of the following values: "1", "true", "t", "yes" or "y".
 
 Enabling this mode ensures that full backtraces are printed when using CLI. The default log level is set to `DEBUG` when this mode is enabled.
 
 Example enabling debug mode for the CLI command `sqlmesh plan`:
 
 === "Bash"
 
+    ```bash
+    $ sqlmesh --debug plan
+    ```
+
     ```bash
     $ SQLMESH_DEBUG=1 sqlmesh plan
     ```
 
 === "MS Powershell"
 
+    ```powershell
+    PS> sqlmesh --debug plan
+    ```
+
     ```powershell
     PS> $env:SQLMESH_DEBUG=1
     PS> sqlmesh plan
     ```
 
 === "MS CMD"
 
+    ```cmd
+    C:\> sqlmesh --debug plan
+    ```
+
     ```cmd
     C:\> set SQLMESH_DEBUG=1
     C:\> sqlmesh plan
     ```
 
+## Runtime Environment
+
+SQLMesh can run in different runtime environments. For example, you might run it in a regular command-line terminal, in a Jupyter notebook, or in Github's CI/CD platform.
+
+When it starts up, SQLMesh automatically detects the runtime environment and adjusts its behavior accordingly. For example, it registers `%magic` commands if in a Jupyter notebook and adjusts logging behavior if in a CI/CD environment.
+
+If necessary, you may force SQLMesh to use a specific runtime environment by setting the `SQLMESH_RUNTIME_ENVIRONMENT` environment variable.
+
+It accepts the following values, which will cause SQLMesh to behave as if it were in the runtime environment in parentheses:
+
+- `terminal` (CLI console)
+- `databricks` (Databricks notebook)
+- `google_colab` (Google Colab notebook)
+- `jupyter` (Jupyter notebook)
+- `debugger` (Debugging output)
+- `ci` (CI/CD or other non-interactive environment)
+
 ## Anonymized usage information
 
 We strive to make SQLMesh the best data transformation tool on the market. Part of accomplishing that is continually fixing bugs, adding features, and improving SQLMesh's performance.

sqlmesh/__init__.py

@@ -33,6 +33,7 @@
 from sqlmesh.utils import (
     debug_mode_enabled as debug_mode_enabled,
     enable_debug_mode as enable_debug_mode,
+    str_to_bool,
 )
 from sqlmesh.utils.date import DatetimeRanges as DatetimeRanges
 
@@ -54,6 +55,7 @@ class RuntimeEnv(str, Enum):
     GOOGLE_COLAB = "google_colab"  # Not currently officially supported
     JUPYTER = "jupyter"
     DEBUGGER = "debugger"
+    CI = "ci"  # CI or other envs that shouldn't use emojis
 
     @classmethod
     def get(cls) -> RuntimeEnv:
@@ -62,6 +64,16 @@ def get(cls) -> RuntimeEnv:
 
         Unlike the rich implementation we try to split out by notebook type instead of treating it all as Jupyter.
         """
+        runtime_env_var = os.getenv("SQLMESH_RUNTIME_ENVIRONMENT")
+        if runtime_env_var:
+            try:
+                return RuntimeEnv(runtime_env_var)
+            except ValueError:
+                valid_values = [f'"{member.value}"' for member in RuntimeEnv]
+                raise ValueError(
+                    f"Invalid SQLMESH_RUNTIME_ENVIRONMENT value: {runtime_env_var}. Must be one of {', '.join(valid_values)}."
+                )
+
         try:
             shell = get_ipython()  # type: ignore
             if os.getenv("DATABRICKS_RUNTIME_VERSION"):
@@ -75,6 +87,10 @@ def get(cls) -> RuntimeEnv:
 
         if debug_mode_enabled():
             return RuntimeEnv.DEBUGGER
+
+        if is_cicd_environment() or not is_interactive_environment():
+            return RuntimeEnv.CI
+
         return RuntimeEnv.TERMINAL
 
     @property
@@ -93,9 +109,24 @@ def is_jupyter(self) -> bool:
     def is_google_colab(self) -> bool:
         return self == RuntimeEnv.GOOGLE_COLAB
 
+    @property
+    def is_ci(self) -> bool:
+        return self == RuntimeEnv.CI
+
     @property
     def is_notebook(self) -> bool:
-        return not self.is_terminal
+        return not self.is_terminal and not self.is_ci
+
+
+def is_cicd_environment() -> bool:
+    for key in ("CI", "GITHUB_ACTIONS", "TRAVIS", "CIRCLECI", "GITLAB_CI", "BUILDKITE"):
+        if str_to_bool(os.environ.get(key, "false")):
+            return True
+    return False
+
+
+def is_interactive_environment() -> bool:
+    return sys.stdin.isatty() and sys.stdout.isatty()
 
 
 if RuntimeEnv.get().is_notebook:

sqlmesh/core/console.py

@@ -78,9 +78,6 @@
 
 PROGRESS_BAR_WIDTH = 40
 LINE_WRAP_WIDTH = 100
-CHECK_MARK = "\u2714"
-GREEN_CHECK_MARK = f"[green]{CHECK_MARK}[/green]"
-RED_X_MARK = "\u274c"
 
 
 class LinterConsole(abc.ABC):
@@ -770,6 +767,11 @@ class TerminalConsole(Console):
 
     TABLE_DIFF_SOURCE_BLUE = "#0248ff"
     TABLE_DIFF_TARGET_GREEN = "green"
+    AUDIT_PASS_MARK = "\u2714"
+    GREEN_AUDIT_PASS_MARK = f"[green]{AUDIT_PASS_MARK}[/green]"
+    AUDIT_FAIL_MARK = "\u274c"
+    AUDIT_PADDING = 0
+    CHECK_MARK = f"{AUDIT_PASS_MARK} "
 
     def __init__(
         self,
@@ -879,7 +881,9 @@ def start_evaluation_progress(
             progress_table.add_row(self.evaluation_total_progress)
             progress_table.add_row(self.evaluation_model_progress)
 
-            self.evaluation_progress_live = Live(progress_table, refresh_per_second=10)
+            self.evaluation_progress_live = Live(
+                progress_table, console=self.console, refresh_per_second=10
+            )
             self.evaluation_progress_live.start()
 
             batch_sizes = {
@@ -891,7 +895,7 @@ def start_evaluation_progress(
 
             # determine column widths
             self.evaluation_column_widths["annotation"] = (
-                _calculate_annotation_str_len(batched_intervals)
+                _calculate_annotation_str_len(batched_intervals, self.AUDIT_PADDING)
                 + 3  # brackets and opening escape backslash
             )
             self.evaluation_column_widths["name"] = max(
@@ -956,21 +960,24 @@ def update_snapshot_evaluation_progress(
                 )
                 audits_str = ""
                 if num_audits_passed:
-                    audits_str += f" {CHECK_MARK}{num_audits_passed}"
+                    audits_str += f" {self.AUDIT_PASS_MARK}{num_audits_passed}"
                 if num_audits_failed:
-                    audits_str += f" {RED_X_MARK}{num_audits_failed}"
+                    audits_str += f" {self.AUDIT_FAIL_MARK}{num_audits_failed}"
                 audits_str = f", audits{audits_str}" if audits_str else ""
                 annotation_len = self.evaluation_column_widths["annotation"]
+                # don't adjust the annotation_len if we're using AUDIT_PADDING
                 annotation = f"\\[{annotation + audits_str}]".ljust(
-                    annotation_len - 1 if num_audits_failed else annotation_len
+                    annotation_len - 1
+                    if num_audits_failed and self.AUDIT_PADDING == 0
+                    else annotation_len
                 )
 
                 duration = f"{(duration_ms / 1000.0):.2f}s".ljust(
                     self.evaluation_column_widths["duration"]
                 )
 
                 msg = f"{batch} {display_name}   {annotation}   {duration}".replace(
-                    CHECK_MARK, GREEN_CHECK_MARK
+                    self.AUDIT_PASS_MARK, self.GREEN_AUDIT_PASS_MARK
                 )
 
                 self.evaluation_progress_live.console.print(msg)
@@ -989,7 +996,7 @@ def stop_evaluation_progress(self, success: bool = True) -> None:
         if self.evaluation_progress_live:
             self.evaluation_progress_live.stop()
             if success:
-                self.log_success(f"{GREEN_CHECK_MARK} Model batches executed")
+                self.log_success(f"{self.CHECK_MARK}Model batches executed")
 
         self.evaluation_progress_live = None
         self.evaluation_total_progress = None
@@ -1053,7 +1060,7 @@ def stop_creation_progress(self, success: bool = True) -> None:
             self.creation_progress.stop()
             self.creation_progress = None
             if success:
-                self.log_success(f"\n{GREEN_CHECK_MARK} Physical layer updated")
+                self.log_success(f"\n{self.CHECK_MARK}Physical layer updated")
 
         self.environment_naming_info = EnvironmentNamingInfo()
         self.default_catalog = None
@@ -1154,7 +1161,7 @@ def stop_promotion_progress(self, success: bool = True) -> None:
             self.promotion_progress.stop()
             self.promotion_progress = None
             if success:
-                self.log_success(f"\n{GREEN_CHECK_MARK} Virtual layer updated")
+                self.log_success(f"\n{self.CHECK_MARK}Virtual layer updated")
 
         self.environment_naming_info = EnvironmentNamingInfo()
         self.default_catalog = None
@@ -2807,6 +2814,12 @@ class MarkdownConsole(CaptureTerminalConsole):
     where you want to display a plan or test results in markdown.
     """
 
+    CHECK_MARK = ""
+    AUDIT_PASS_MARK = "passed "
+    GREEN_AUDIT_PASS_MARK = AUDIT_PASS_MARK
+    AUDIT_FAIL_MARK = "failed "
+    AUDIT_PADDING = 7
+
     def __init__(self, **kwargs: t.Any) -> None:
         super().__init__(**{**kwargs, "console": RichConsole(no_color=True)})
 
@@ -2822,23 +2835,28 @@ def show_environment_difference_summary(
             no_diff: Hide the actual environment statements differences.
         """
         if context_diff.is_new_environment:
-            self._print(
-                f"**New environment `{context_diff.environment}` will be created from `{context_diff.create_from}`**\n"
+            msg = (
+                f"\n**`{context_diff.environment}` environment will be initialized**"
+                if not context_diff.create_from_env_exists
+                else f"\n**New environment `{context_diff.environment}` will be created from `{context_diff.create_from}`**"
             )
+            self._print(msg)
             if not context_diff.has_snapshot_changes:
                 return
 
         if not context_diff.has_changes:
-            self._print(f"**No differences when compared to `{context_diff.environment}`**\n")
+            self._print(
+                f"\n**No changes to plan: project files match the `{context_diff.environment}` environment**\n"
+            )
             return
 
-        self._print(f"**Summary of differences against `{context_diff.environment}`:**\n")
+        self._print(f"\n**Summary of differences from `{context_diff.environment}`:**")
 
         if context_diff.has_requirement_changes:
-            self._print(f"Requirements:\n{context_diff.requirements_diff()}")
+            self._print(f"\nRequirements:\n{context_diff.requirements_diff()}")
 
         if context_diff.has_environment_statements_changes and not no_diff:
-            self._print("[bold]Environment statements:\n")
+            self._print("\nEnvironment statements:\n")
             for _, diff in context_diff.environment_statements_diff(
                 include_python_env=not context_diff.is_new_environment
             ):
@@ -2984,7 +3002,7 @@ def _show_missing_dates(self, plan: Plan, default_catalog: t.Optional[str]) -> N
                 dialect=self.dialect,
             )
             snapshots.append(
-                f"* `{display_name}`: [{_format_missing_intervals(snapshot, missing)}]{preview_modifier}"
+                f"* `{display_name}`: \\[{_format_missing_intervals(snapshot, missing)}]{preview_modifier}"
             )
 
         length = len(snapshots)
@@ -3033,6 +3051,21 @@ def _show_categorized_snapshots(self, plan: Plan, default_catalog: t.Optional[st
             self._print(tree)
             self._print("\n```")
 
+    def stop_evaluation_progress(self, success: bool = True) -> None:
+        super().stop_evaluation_progress(success)
+        self._print("\n")
+
+    def stop_creation_progress(self, success: bool = True) -> None:
+        super().stop_creation_progress(success)
+        self._print("\n")
+
+    def stop_promotion_progress(self, success: bool = True) -> None:
+        super().stop_promotion_progress(success)
+        self._print("\n")
+
+    def log_success(self, message: str) -> None:
+        self._print(message)
+
     def log_test_results(
         self, result: unittest.result.TestResult, output: t.Optional[str], target_dialect: str
     ) -> None:
@@ -3082,6 +3115,12 @@ def log_warning(self, short_message: str, long_message: t.Optional[str] = None)
         logger.warning(long_message or short_message)
         self._print(f"```\n\\[WARNING] {short_message}```\n\n")
 
+    def _print(self, value: t.Any, **kwargs: t.Any) -> None:
+        self.console.print(value, **kwargs)
+        with self.console.capture() as capture:
+            self.console.print(value, **kwargs)
+        self._captured_outputs.append(capture.get())
+
 
 class DatabricksMagicConsole(CaptureTerminalConsole):
     """
@@ -3473,6 +3512,7 @@ def create_console(
         RuntimeEnv.TERMINAL: TerminalConsole,
         RuntimeEnv.GOOGLE_COLAB: NotebookMagicConsole,
         RuntimeEnv.DEBUGGER: DebuggerTerminalConsole,
+        RuntimeEnv.CI: MarkdownConsole,
     }
     rich_console_kwargs: t.Dict[str, t.Any] = {"theme": srich.theme}
     if runtime_env.is_jupyter or runtime_env.is_google_colab:
@@ -3598,7 +3638,7 @@ def _calculate_interval_str_len(snapshot: Snapshot, intervals: t.List[Interval])
     return interval_str_len
 
 
-def _calculate_audit_str_len(snapshot: Snapshot) -> int:
+def _calculate_audit_str_len(snapshot: Snapshot, audit_padding: int = 0) -> int:
     # The annotation includes audit results. We cannot build the audits result string
     # until after evaluation occurs, but we must determine the annotation column width here.
     # Therefore, we add enough padding for the longest possible audits result string.
@@ -3619,21 +3659,38 @@ def _calculate_audit_str_len(snapshot: Snapshot) -> int:
         )
         if num_audits == 1:
             # +1 for "1" audit count, +1 for red X
-            audit_len = audit_base_str_len + (2 if num_nonblocking_audits else 1)
+            # if audit_padding is > 0 we're using "failed" instead of red X
+            audit_len = (
+                audit_base_str_len
+                + (2 if num_nonblocking_audits else 1)
+                + (
+                    audit_padding - 1
+                    if num_nonblocking_audits and audit_padding > 0
+                    else audit_padding
+                )
+            )
         else:
-            audit_len = audit_base_str_len + len(str(num_audits))
+            audit_len = audit_base_str_len + len(str(num_audits)) + audit_padding
             if num_nonblocking_audits:
                 # +1 for space, +1 for red X
-                audit_len += len(str(num_nonblocking_audits)) + 2
+                # if audit_padding is > 0 we're using "failed" instead of red X
+                audit_len += (
+                    len(str(num_nonblocking_audits))
+                    + 2
+                    + (audit_padding - 1 if audit_padding > 0 else audit_padding)
+                )
         audit_str_len = max(audit_str_len, audit_len)
     return audit_str_len
 
 
-def _calculate_annotation_str_len(batched_intervals: t.Dict[Snapshot, t.List[Interval]]) -> int:
+def _calculate_annotation_str_len(
+    batched_intervals: t.Dict[Snapshot, t.List[Interval]], audit_padding: int = 0
+) -> int:
     annotation_str_len = 0
     for snapshot, intervals in batched_intervals.items():
         annotation_str_len = max(
             annotation_str_len,
-            _calculate_interval_str_len(snapshot, intervals) + _calculate_audit_str_len(snapshot),
+            _calculate_interval_str_len(snapshot, intervals)
+            + _calculate_audit_str_len(snapshot, audit_padding),
         )
     return annotation_str_len