sqlmesh 0.199.1.dev1__py3-none-any.whl → 0.199.1.dev2__py3-none-any.whl

sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.199.1.dev1'
-__version_tuple__ = version_tuple = (0, 199, 1, 'dev1')
+__version__ = version = '0.199.1.dev2'
+__version_tuple__ = version_tuple = (0, 199, 1, 'dev2')

sqlmesh/core/console.py

@@ -3224,8 +3224,9 @@ class MarkdownConsole(CaptureTerminalConsole):
             )
         else:
             for snapshot_table_info in models:
+                category_str = SNAPSHOT_CHANGE_CATEGORY_STR[snapshot_table_info.change_category]
                 self._print(
-                    f"- `{snapshot_table_info.display_name(environment_naming_info, default_catalog if self.verbosity < Verbosity.VERY_VERBOSE else None, dialect=self.dialect)}`"
+                    f"- `{snapshot_table_info.display_name(environment_naming_info, default_catalog if self.verbosity < Verbosity.VERY_VERBOSE else None, dialect=self.dialect)}` ({category_str})"
                 )
 
     def _print_modified_models(
@@ -3237,7 +3238,7 @@ class MarkdownConsole(CaptureTerminalConsole):
         no_diff: bool = True,
     ) -> None:
         directly_modified = []
-        indirectly_modified = []
+        indirectly_modified: t.List[Snapshot] = []
         metadata_modified = []
         for snapshot in modified_snapshots:
             if context_diff.directly_modified(snapshot.name):
@@ -3249,11 +3250,40 @@ class MarkdownConsole(CaptureTerminalConsole):
         if directly_modified:
             self._print("\n**Directly Modified:**")
             for snapshot in sorted(directly_modified):
+                category_str = SNAPSHOT_CHANGE_CATEGORY_STR[snapshot.change_category]
                 self._print(
-                    f"- `{snapshot.display_name(environment_naming_info, default_catalog if self.verbosity < Verbosity.VERY_VERBOSE else None, dialect=self.dialect)}`"
+                    f"* `{snapshot.display_name(environment_naming_info, default_catalog if self.verbosity < Verbosity.VERY_VERBOSE else None, dialect=self.dialect)}` ({category_str})"
+                )
+
+                indirectly_modified_children = sorted(
+                    [s for s in indirectly_modified if snapshot.snapshot_id in s.parents]
                 )
+
                 if not no_diff:
-                    self._print(f"```diff\n{context_diff.text_diff(snapshot.name)}\n```")
+                    diff_text = context_diff.text_diff(snapshot.name)
+                    # sometimes there is no text_diff, like on a seed model where the data has been updated
+                    if diff_text:
+                        diff_text = f"\n```diff\n{diff_text}\n```"
+                        # these are part of a Markdown list, so indent them by 2 spaces to relate them to the current list item
+                        diff_text_indented = "\n".join(
+                            [f"  {line}" for line in diff_text.splitlines()]
+                        )
+                        self._print(diff_text_indented)
+                    else:
+                        if indirectly_modified_children:
+                            self._print("\n")
+
+                if indirectly_modified_children:
+                    self._print("  Indirectly Modified Children:")
+                    for child_snapshot in indirectly_modified_children:
+                        child_category_str = SNAPSHOT_CHANGE_CATEGORY_STR[
+                            child_snapshot.change_category
+                        ]
+                        self._print(
+                            f"    - `{child_snapshot.display_name(environment_naming_info, default_catalog if self.verbosity < Verbosity.VERY_VERBOSE else None, dialect=self.dialect)}` ({child_category_str})"
+                        )
+                    self._print("\n")
+
         if indirectly_modified:
             self._print("\n**Indirectly Modified:**")
             self._print_models_with_threshold(

sqlmesh/integrations/github/cicd/command.py

@@ -115,8 +115,12 @@ def _update_pr_environment(controller: GithubController) -> bool:
         conclusion = controller.update_pr_environment_check(status=GithubCheckStatus.COMPLETED)
         return conclusion is not None and conclusion.is_success
     except Exception as e:
+        logger.exception("Error occurred when updating PR environment")
         conclusion = controller.update_pr_environment_check(
-            status=GithubCheckStatus.COMPLETED, exception=e, plan=controller.pr_plan_or_none
+            status=GithubCheckStatus.COMPLETED,
+            exception=e,
+            plan=controller.pr_plan_or_none,
+            plan_flags=controller.pr_plan_flags,
         )
         return (
             conclusion is not None
@@ -147,6 +151,7 @@ def _gen_prod_plan(controller: GithubController) -> bool:
         )
         return bool(plan_summary)
     except Exception as e:
+        logger.exception("Error occurred generating prod plan")
         controller.update_prod_plan_preview_check(
             status=GithubCheckStatus.COMPLETED,
             conclusion=GithubCheckConclusion.FAILURE,
@@ -211,6 +216,8 @@ def deploy_production(ctx: click.Context) -> None:
 
 
 def _run_all(controller: GithubController) -> None:
+    click.echo(f"SQLMesh Version: {controller.version_info}")
+
     has_required_approval = False
     is_auto_deploying_prod = (
         controller.deploy_command_enabled or controller.do_required_approval_check

sqlmesh/integrations/github/cicd/controller.py

@@ -9,11 +9,11 @@ import re
 import traceback
 import typing as t
 from enum import Enum
-from typing import List
 from pathlib import Path
+from dataclasses import dataclass
+from functools import cached_property
 
 import requests
-from hyperscript import Element, h
 from sqlglot.helper import seq_get
 
 from sqlmesh.core import constants as c
@@ -21,13 +21,13 @@ from sqlmesh.core.console import SNAPSHOT_CHANGE_CATEGORY_STR, get_console, Mark
 from sqlmesh.core.context import Context
 from sqlmesh.core.test.result import ModelTextTestResult
 from sqlmesh.core.environment import Environment
-from sqlmesh.core.plan import Plan, PlanBuilder
+from sqlmesh.core.plan import Plan, PlanBuilder, SnapshotIntervals
+from sqlmesh.core.plan.definition import UserProvidedFlags
 from sqlmesh.core.snapshot.definition import (
     Snapshot,
     SnapshotChangeCategory,
     SnapshotId,
     SnapshotTableInfo,
-    format_intervals,
 )
 from sqlglot.errors import SqlglotError
 from sqlmesh.core.user import User
@@ -415,6 +415,14 @@ class GithubController:
         except:
             return None
 
+    @property
+    def pr_plan_flags(self) -> t.Optional[t.Dict[str, UserProvidedFlags]]:
+        if pr_plan := self.pr_plan_or_none:
+            return pr_plan.user_provided_flags
+        if pr_plan_builder := self._pr_plan_builder:
+            return pr_plan_builder._user_provided_flags
+        return None
+
     @property
     def prod_plan(self) -> Plan:
         if not self._prod_plan_builder:
@@ -434,7 +442,9 @@ class GithubController:
         if not self._prod_plan_with_gaps_builder:
             self._prod_plan_with_gaps_builder = self._context.plan_builder(
                 c.PROD,
+                # this is required to highlight any data gaps between this PR environment and prod (since PR environments may only contain a subset of data)
                 no_gaps=False,
+                # this works because the snapshots were already categorized when applying self.pr_plan so there are no uncategorized local snapshots to trigger a plan error
                 no_auto_categorization=True,
                 skip_tests=True,
                 skip_linter=True,
@@ -495,9 +505,17 @@ class GithubController:
             difference_summary = self._console.consume_captured_output()
             self._console._show_missing_dates(plan, self._context.default_catalog)
             missing_dates = self._console.consume_captured_output()
+
+            plan_flags_section = (
+                f"\n\n{self._generate_plan_flags_section(plan.user_provided_flags)}"
+                if plan.user_provided_flags
+                else ""
+            )
+
             if not difference_summary and not missing_dates:
-                return "No changes to apply."
-            return f"{difference_summary}\n{missing_dates}"
+                return f"No changes to apply.{plan_flags_section}"
+
+            return f"{difference_summary}\n{missing_dates}{plan_flags_section}"
         except PlanError as e:
             return f"Plan failed to generate. Check for pending or unresolved changes. Error: {e}"
 
@@ -831,6 +849,9 @@ class GithubController:
         status: GithubCheckStatus,
         exception: t.Optional[Exception] = None,
         plan: t.Optional[Plan] = None,
+        plan_flags: t.Optional[
+            t.Dict[str, UserProvidedFlags]
+        ] = None,  # note: the plan flags are passed separately in case the plan fails to build
     ) -> t.Optional[GithubCheckConclusion]:
         """
         Updates the status of the merge commit for the PR environment.
@@ -852,58 +873,16 @@ class GithubController:
             conclusion: GithubCheckConclusion, exception: t.Optional[Exception]
         ) -> t.Tuple[GithubCheckConclusion, str, t.Optional[str]]:
             if conclusion.is_success:
-                if not self.modified_snapshots:
+                prod_plan = self.prod_plan_with_gaps
+
+                if not prod_plan.has_changes:
                     summary = "No models were modified in this PR.\n"
                 else:
-                    header_rows = [
-                        h("th", {"colspan": "3"}, "PR Environment Summary"),
-                        [
-                            h("th", "Model"),
-                            h("th", "Change Type"),
-                            h("th", "Dates Loaded"),
-                        ],
-                    ]
-                    body_rows: List[Element | List[Element]] = []
-                    for modified_snapshot in self.modified_snapshots.values():
-                        # We don't want to display indirect non-breaking since to users these are effectively no-op changes
-                        if modified_snapshot.is_indirect_non_breaking:
-                            continue
-                        if modified_snapshot.snapshot_id in self.removed_snapshots:
-                            # This will be an FQN since we don't have access to node name from a snapshot table info
-                            # which is what a removed snapshot is
-                            model_name = modified_snapshot.name
-                            change_category = SNAPSHOT_CHANGE_CATEGORY_STR[
-                                SnapshotChangeCategory.BREAKING
-                            ]
-                            interval_output = "REMOVED"
-                        else:
-                            assert isinstance(modified_snapshot, Snapshot)
-                            model_name = modified_snapshot.node.name
-                            change_category = (
-                                "Uncategorized"
-                                if not modified_snapshot.change_category
-                                else SNAPSHOT_CHANGE_CATEGORY_STR[modified_snapshot.change_category]
-                            )
-                            intervals = (
-                                modified_snapshot.dev_intervals
-                                if modified_snapshot.is_forward_only
-                                else modified_snapshot.intervals
-                            )
-                            interval_output = (
-                                format_intervals(intervals, modified_snapshot.node.interval_unit)
-                                if intervals
-                                else "N/A"
-                            )
-                        body_rows.append(
-                            [
-                                h("td", model_name, autoescape=False),
-                                h("td", change_category),
-                                h("td", interval_output),
-                            ]
-                        )
-                    table_header = h("thead", [h("tr", row) for row in header_rows])
-                    table_body = h("tbody", [h("tr", row) for row in body_rows])
-                    summary = str(h("table", [table_header, table_body]))
+                    intro = self._generate_pr_environment_summary_intro()
+                    summary = intro + self._generate_pr_environment_summary_list(prod_plan)
+                    if prod_plan.user_provided_flags:
+                        summary += self._generate_plan_flags_section(prod_plan.user_provided_flags)
+
                 vde_title = (
                     "- :eyes: To **review** this PR's changes, use virtual data environment:"
                 )
@@ -943,7 +922,11 @@ class GithubController:
                         "If you would like the bot to automatically categorize changes, check the [documentation](https://sqlmesh.readthedocs.io/en/stable/integrations/github/) for more information."
                     )
                 elif isinstance(exception, PlanError):
-                    failure_msg = f"Plan application failed.\n\n{self._console.captured_output}"
+                    failure_msg = f"Plan application failed.\n"
+                    if exception.args and (msg := exception.args[0]) and isinstance(msg, str):
+                        failure_msg += f"\n{msg}\n"
+                    if self._console.captured_output:
+                        failure_msg += f"\n{self._console.captured_output}"
                 elif isinstance(exception, (SQLMeshError, SqlglotError, ValueError)):
                     # this logic is taken from the global error handler attached to the CLI, which uses `click.echo()` to output the message
                     # so cant be re-used here because it bypasses the Console
@@ -959,13 +942,17 @@ class GithubController:
 
                 conclusion_to_summary = {
                     GithubCheckConclusion.SKIPPED: f":next_track_button: Skipped creating or updating PR Environment `{self.pr_environment_name}`. {skip_reason}",
-                    GithubCheckConclusion.FAILURE: f":x: Failed to create or update PR Environment `{self.pr_environment_name}`.\n\n{failure_msg}",
+                    GithubCheckConclusion.FAILURE: f":x: Failed to create or update PR Environment `{self.pr_environment_name}` :x:\n\n{failure_msg}",
                     GithubCheckConclusion.CANCELLED: f":stop_sign: Cancelled creating or updating PR Environment `{self.pr_environment_name}`",
                     GithubCheckConclusion.ACTION_REQUIRED: f":warning: Action Required to create or update PR Environment `{self.pr_environment_name}` :warning:\n\n{failure_msg}",
                 }
                 summary = conclusion_to_summary.get(
                     conclusion, f":interrobang: Got an unexpected conclusion: {conclusion.value}"
                 )
+                if plan_flags:
+                    plan_flags_section = self._generate_plan_flags_section(plan_flags)
+                    summary += f"\n\n{plan_flags_section}"
+
             self._append_output("pr_environment_name", self.pr_environment_name)
             return conclusion, check_title, summary
 
@@ -1006,6 +993,12 @@ class GithubController:
             title = conclusion_to_title.get(
                 conclusion, f"Got an unexpected conclusion: {conclusion.value}"
             )
+            if conclusion == GithubCheckConclusion.SUCCESS and summary:
+                summary = (
+                    f"This is a preview that shows the differences between this PR environment `{self.pr_environment_name}` and `prod`.\n\n"
+                    "These are the changes that would be deployed.\n\n"
+                ) + summary
+
             return conclusion, title, summary
 
         self._update_check_handler(
@@ -1115,3 +1108,232 @@ class GithubController:
     @property
     def running_in_github_actions(self) -> bool:
         return os.environ.get("GITHUB_ACTIONS", None) == "true"
+
+    @property
+    def version_info(self) -> str:
+        from sqlmesh.cli.main import _sqlmesh_version
+
+        return _sqlmesh_version()
+
+    def _generate_plan_flags_section(
+        self, user_provided_flags: t.Dict[str, UserProvidedFlags]
+    ) -> str:
+        # collapsed section syntax:
+        # https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/organizing-information-with-collapsed-sections#creating-a-collapsed-section
+        section = "<details>\n\n<summary>Plan flags</summary>\n\n"
+        for flag_name, flag_value in user_provided_flags.items():
+            section += f"- `{flag_name}` = `{flag_value}`\n"
+        section += "\n</details>"
+
+        return section
+
+    def _generate_pr_environment_summary_intro(self) -> str:
+        note = ""
+        subset_reasons = []
+
+        if self.bot_config.skip_pr_backfill:
+            subset_reasons.append("`skip_pr_backfill` is enabled")
+
+        if default_pr_start := self.bot_config.default_pr_start:
+            subset_reasons.append(f"`default_pr_start` is set to `{default_pr_start}`")
+
+        if subset_reasons:
+            note = (
+                "> [!IMPORTANT]\n"
+                f"> This PR environment may only contain a subset of data because:\n"
+                + "\n".join(f"> - {r}" for r in subset_reasons)
+                + "\n"
+                "> \n"
+                "> This means that deploying to `prod` may not be a simple virtual update if there is still some data to load.\n"
+                "> See `Dates not loaded in PR` below or the `Prod Plan Preview` check for more information.\n\n"
+            )
+
+        return (
+            f"Here is a summary of data that has been loaded into the PR environment `{self.pr_environment_name}` and could be deployed to `prod`.\n\n"
+            + note
+        )
+
+    def _generate_pr_environment_summary_list(self, plan: Plan) -> str:
+        added_snapshot_ids = set(plan.context_diff.added)
+        modified_snapshot_ids = set(
+            s.snapshot_id for s, _ in plan.context_diff.modified_snapshots.values()
+        )
+        removed_snapshot_ids = set(plan.context_diff.removed_snapshots.keys())
+
+        # note: we sort these to get a deterministic order for the output tests
+        table_records = sorted(
+            [
+                SnapshotSummaryRecord(snapshot_id=snapshot_id, plan=plan)
+                for snapshot_id in (
+                    added_snapshot_ids | modified_snapshot_ids | removed_snapshot_ids
+                )
+            ],
+            key=lambda r: r.display_name,
+        )
+
+        sections = [
+            ("### Added", [r for r in table_records if r.is_added]),
+            ("### Removed", [r for r in table_records if r.is_removed]),
+            ("### Directly Modified", [r for r in table_records if r.is_directly_modified]),
+            ("### Indirectly Modified", [r for r in table_records if r.is_indirectly_modified]),
+            (
+                "### Metadata Updated",
+                [r for r in table_records if r.is_metadata_updated and not r.is_modified],
+            ),
+        ]
+
+        summary = ""
+        for title, records in sections:
+            if records:
+                summary += f"\n{title}\n"
+
+            for record in records:
+                summary += f"{record.as_markdown_list_item}\n"
+
+        return summary
+
+
+@dataclass
+class SnapshotSummaryRecord:
+    snapshot_id: SnapshotId
+    plan: Plan
+
+    @property
+    def snapshot(self) -> Snapshot:
+        if self.is_removed:
+            raise ValueError("Removed snapshots only have SnapshotTableInfo available")
+        return self.plan.snapshots[self.snapshot_id]
+
+    @cached_property
+    def snapshot_table_info(self) -> SnapshotTableInfo:
+        if self.is_removed:
+            return self.plan.modified_snapshots[self.snapshot_id].table_info
+        return self.plan.snapshots[self.snapshot_id].table_info
+
+    @property
+    def display_name(self) -> str:
+        dialect = None if self.is_removed else self.snapshot.node.dialect
+        return self.snapshot_table_info.display_name(
+            self.plan.environment_naming_info, default_catalog=None, dialect=dialect
+        )
+
+    @property
+    def change_category(self) -> str:
+        if self.is_removed:
+            return SNAPSHOT_CHANGE_CATEGORY_STR[SnapshotChangeCategory.BREAKING]
+
+        if change_category := self.snapshot.change_category:
+            return SNAPSHOT_CHANGE_CATEGORY_STR[change_category]
+
+        return "Uncategorized"
+
+    @property
+    def is_added(self) -> bool:
+        return self.snapshot_id in self.plan.context_diff.added
+
+    @property
+    def is_removed(self) -> bool:
+        return self.snapshot_id in self.plan.context_diff.removed_snapshots
+
+    @property
+    def is_dev_preview(self) -> bool:
+        return not self.plan.deployability_index.is_deployable(self.snapshot_id)
+
+    @property
+    def is_directly_modified(self) -> bool:
+        return self.plan.context_diff.directly_modified(self.snapshot_table_info.name)
+
+    @property
+    def is_indirectly_modified(self) -> bool:
+        return self.plan.context_diff.indirectly_modified(self.snapshot_table_info.name)
+
+    @property
+    def is_modified(self) -> bool:
+        return self.is_directly_modified or self.is_indirectly_modified
+
+    @property
+    def is_metadata_updated(self) -> bool:
+        return self.plan.context_diff.metadata_updated(self.snapshot_table_info.name)
+
+    @property
+    def is_incremental(self) -> bool:
+        return self.snapshot_table_info.is_incremental
+
+    @property
+    def modification_type(self) -> str:
+        if self.is_directly_modified:
+            return "Directly modified"
+        if self.is_indirectly_modified:
+            return "Indirectly modified"
+        if self.is_metadata_updated:
+            return "Metadata updated"
+
+        return "Unknown"
+
+    @property
+    def loaded_intervals(self) -> SnapshotIntervals:
+        if self.is_removed:
+            raise ValueError("Removed snapshots dont have loaded intervals available")
+
+        return SnapshotIntervals(
+            snapshot_id=self.snapshot_id,
+            intervals=(
+                self.snapshot.dev_intervals
+                if self.snapshot.is_forward_only
+                else self.snapshot.intervals
+            ),
+        )
+
+    @property
+    def loaded_intervals_rendered(self) -> str:
+        if self.is_removed:
+            return "REMOVED"
+
+        return self._format_intervals(self.loaded_intervals)
+
+    @property
+    def missing_intervals(self) -> t.Optional[SnapshotIntervals]:
+        return next(
+            (si for si in self.plan.missing_intervals if si.snapshot_id == self.snapshot_id),
+            None,
+        )
+
+    @property
+    def missing_intervals_formatted(self) -> str:
+        if not self.is_removed and (intervals := self.missing_intervals):
+            return self._format_intervals(intervals)
+
+        return "N/A"
+
+    @property
+    def as_markdown_list_item(self) -> str:
+        if self.is_removed:
+            return f"- `{self.display_name}` ({self.change_category})"
+
+        how_applied = ""
+
+        if not self.is_incremental:
+            from sqlmesh.core.console import _format_missing_intervals
+
+            # note: this is to re-use the '[recreate view]' and '[full refresh]' text and keep it in sync with updates to the CLI
+            # it doesnt actually use the passed intervals, those are handled differently
+            how_applied = _format_missing_intervals(self.snapshot, self.loaded_intervals)
+
+        how_applied_str = f" [{how_applied}]" if how_applied else ""
+
+        item = f"- `{self.display_name}` ({self.change_category})\n"
+
+        if self.snapshot_table_info.model_kind_name:
+            item += f"  **Kind:** {self.snapshot_table_info.model_kind_name}{how_applied_str}\n"
+
+        if self.is_incremental:
+            # in-depth interval info is only relevant for incremental models
+            item += f"  **Dates loaded in PR:** [{self.loaded_intervals_rendered}]\n"
+            if self.missing_intervals:
+                item += f"  **Dates *not* loaded in PR:** [{self.missing_intervals_formatted}]\n"
+
+        return item
+
+    def _format_intervals(self, intervals: SnapshotIntervals) -> str:
+        preview_modifier = " (**preview**)" if self.is_dev_preview else ""
+        return f"{intervals.format_intervals(self.snapshot.node.interval_unit)}{preview_modifier}"

{sqlmesh-0.199.1.dev1.dist-info → sqlmesh-0.199.1.dev2.dist-info}/METADATA

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

{sqlmesh-0.199.1.dev1.dist-info → sqlmesh-0.199.1.dev2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 sqlmesh/__init__.py,sha256=QjwaamJIdW7voXoS880yAx7tHm-Im4_mqGA-XJgafos,7631
-sqlmesh/_version.py,sha256=zOqzr9tB5Ig4Cqi2rqDvOF1BHWDDqZBx5ng9PsPP81o,528
+sqlmesh/_version.py,sha256=xr44hQ2o7jmOZ347ejlZNhnmweEDkJf_mQ6dquBDsDM,528
 sqlmesh/magics.py,sha256=R9U0Mp9ZQhDYe751nxAQDLaMv3zLAR4HcTdIflKTmEE,41709
 sqlmesh/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/cicd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -11,7 +11,7 @@ sqlmesh/cli/options.py,sha256=-4ZclMIeIg8tghLowtmQNmpEFlm0QtOVEh40NqRdFHA,2499
 sqlmesh/cli/project_init.py,sha256=5JmDmUK0WJs39hM-p76uzHYdo1Hnx6fKuJg_pR3Hn5A,16419
 sqlmesh/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/core/_typing.py,sha256=e1f7xO2aZCy38M_3VoDy-XI3shyd99-IFctgIFSgXWM,497
-sqlmesh/core/console.py,sha256=HInr6MOcxgn8Z-B9fAoghoDXbBEZqkB5ClyZF-fRP58,159032
+sqlmesh/core/console.py,sha256=ieSXS0G--HpVgziwAqgcJvE4zUn60xRswljpc1GO6pU,160753
 sqlmesh/core/constants.py,sha256=gUABXWYgH_XOSbaZAJsR5o1dmA61JDCvBDyxqqXX3LM,2630
 sqlmesh/core/context.py,sha256=K9bQqk5ATZ0cl7v7qaiOQq-b7hYfPIgdo9G9v51Y6y8,119111
 sqlmesh/core/context_diff.py,sha256=CeUmMBJzN__98YohrtAiIYPIZI9mrGBk6bVADWBLUw8,21692
@@ -162,9 +162,9 @@ sqlmesh/integrations/llm.py,sha256=URgp3JKr06HYv6hGlJ7DQ9m3QCc41xRWK23HzmGpbDI,1
 sqlmesh/integrations/slack.py,sha256=nxLxu5WztGbZH3JdqnzyPqmJUMfRdJ_49LQ7zR-u39Q,6801
 sqlmesh/integrations/github/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/integrations/github/cicd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlmesh/integrations/github/cicd/command.py,sha256=1tsLOrGibDwoKKgFWf03H8OKOoAW3TWLesXuBRYTtBY,11824
+sqlmesh/integrations/github/cicd/command.py,sha256=neBs7BfuywRR_AnB8pXHMlEmgFe2-WPJka_KsE9YzkY,12097
 sqlmesh/integrations/github/cicd/config.py,sha256=tRhMZaLf1p6AWXvi67n85Q-lptJNGt1Wk_Jr61ytpiM,2104
-sqlmesh/integrations/github/cicd/controller.py,sha256=QCs51Ag52Eu-2C5B2ivJ3Jgh7yThKj0eBqILGCHqizk,44436
+sqlmesh/integrations/github/cicd/controller.py,sha256=I8jnpS2hvYwa-dpki0Cly246eeBM9-9Qy9loxw4bMpI,52284
 sqlmesh/lsp/api.py,sha256=_lA_buSPZFIoLJuINbS53LbNOOaHp3orb0uFTE3aCqI,2328
 sqlmesh/lsp/completions.py,sha256=Nt1XpFL_-QAIRM8BBBC6Ia6YG0hMZriiNJra7nGfD4Q,6676
 sqlmesh/lsp/context.py,sha256=2aD_lH-GqAwCjTFHfCavH2fZz2T4IXQZVS7LDMAa2X4,12815
@@ -284,7 +284,7 @@ sqlmesh/utils/pydantic.py,sha256=o_NsXbIpDqNpUA1Uc5xF0ZzoXQYYB0DfHwdRxBwXPNk,120
 sqlmesh/utils/rich.py,sha256=BpB47G0-JcU41LkGkeGKroexj4NOV5fox4-GOIXPgIc,3545
 sqlmesh/utils/windows.py,sha256=r7Yin4WEwbvH7sKA3hOJtRsclmscNuBeCklCfVPvtQs,611
 sqlmesh/utils/yaml.py,sha256=hvo5lmybYLcIx4p6CQwufS8X4MbwS60lEBnCmYJCXmU,2336
-sqlmesh-0.199.1.dev1.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
+sqlmesh-0.199.1.dev2.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
 web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web/client/dist/index.html,sha256=kNpFjWxt34Pf-P-cROtPWi3GNSVk6zqA3eoN9tlZXI0,5472
 web/client/dist/assets/Audits-DKgXravk.js,sha256=SaVQhNlislD_yQc_KivO7SPi1JH0ts1GnDPD5Zssutw,1041
@@ -402,8 +402,8 @@ web/server/api/endpoints/models.py,sha256=ud-lRwriyI_OYg9tZchrBgeiXELiRTLNEodraf
 web/server/api/endpoints/modules.py,sha256=8hqqgonGay_mJmpCw0IdbjsPhWlQH2VLdKAqha-myac,468
 web/server/api/endpoints/plan.py,sha256=bbbY50W_2MsZSTxOHWMKz0tbIm75nsRSlPy8GI2fg9Q,9306
 web/server/api/endpoints/table_diff.py,sha256=SCy3-pr5x6bEEiOaZGCDbiHQhpgxwmnz3Acqa2Ie6jI,2090
-sqlmesh-0.199.1.dev1.dist-info/METADATA,sha256=J9wTKr23lqz22qxIQ2oQZga5pQJ7auPT1rBlGN0qFxY,26658
-sqlmesh-0.199.1.dev1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlmesh-0.199.1.dev1.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
-sqlmesh-0.199.1.dev1.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
-sqlmesh-0.199.1.dev1.dist-info/RECORD,,
+sqlmesh-0.199.1.dev2.dist-info/METADATA,sha256=EC4u5rjn5cBDWonMr78Q0TCJHLbRJ4vZUx3Ay9ui6lo,26658
+sqlmesh-0.199.1.dev2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlmesh-0.199.1.dev2.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
+sqlmesh-0.199.1.dev2.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
+sqlmesh-0.199.1.dev2.dist-info/RECORD,,