sqlmesh 0.195.1.dev4__py3-none-any.whl → 0.195.1.dev6__py3-none-any.whl

sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.195.1.dev4'
-__version_tuple__ = version_tuple = (0, 195, 1, 'dev4')
+__version__ = version = '0.195.1.dev6'
+__version_tuple__ = version_tuple = (0, 195, 1, 'dev6')

sqlmesh/cli/main.py

@@ -6,11 +6,15 @@ import sys
 import typing as t
 
 import click
-
 from sqlmesh import configure_logging, remove_excess_logs
 from sqlmesh.cli import error_handler
 from sqlmesh.cli import options as opt
-from sqlmesh.cli.example_project import ProjectTemplate, init_example_project
+from sqlmesh.cli.project_init import (
+    ProjectTemplate,
+    init_example_project,
+    InitCliMode,
+    interactive_init,
+)
 from sqlmesh.core.analytics import cli_analytics
 from sqlmesh.core.console import configure_console, get_console
 from sqlmesh.utils import Verbosity
@@ -22,6 +26,7 @@ from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
+
 SKIP_LOAD_COMMANDS = (
     "clean",
     "create_external_models",
@@ -138,7 +143,7 @@ def cli(
 
 
 @cli.command("init")
-@click.argument("sql_dialect", required=False)
+@click.argument("engine", required=False)
 @click.option(
     "-t",
     "--template",
@@ -160,24 +165,83 @@ def cli(
 @cli_analytics
 def init(
     ctx: click.Context,
-    sql_dialect: t.Optional[str] = None,
+    engine: t.Optional[str] = None,
     template: t.Optional[str] = None,
     dlt_pipeline: t.Optional[str] = None,
     dlt_path: t.Optional[str] = None,
 ) -> None:
     """Create a new SQLMesh repository."""
-    try:
-        project_template = ProjectTemplate(template.lower() if template else "default")
-    except ValueError:
-        raise click.ClickException(f"Invalid project template '{template}'")
-    init_example_project(
-        ctx.obj,
-        dialect=sql_dialect,
+    project_template = None
+    if template:
+        try:
+            project_template = ProjectTemplate(template.lower())
+        except ValueError:
+            template_strings = "', '".join([template.value for template in ProjectTemplate])
+            raise click.ClickException(
+                f"Invalid project template '{template}'. Please specify one of '{template_strings}'."
+            )
+
+    if engine or project_template == ProjectTemplate.DBT:
+        init_example_project(
+            path=ctx.obj,
+            template=project_template or ProjectTemplate.DEFAULT,
+            engine_type=engine,
+            pipeline=dlt_pipeline,
+            dlt_path=dlt_path,
+        )
+        return
+
+    import sqlmesh.utils.rich as srich
+
+    console = srich.console
+
+    project_template, engine_type, cli_mode = interactive_init(ctx.obj, console, project_template)
+
+    config_path = init_example_project(
+        path=ctx.obj,
         template=project_template,
+        engine_type=engine_type,
+        cli_mode=cli_mode or InitCliMode.DEFAULT,
         pipeline=dlt_pipeline,
         dlt_path=dlt_path,
     )
 
+    engine_install_text = ""
+    if engine_type and engine_type not in ("duckdb", "motherduck"):
+        install_text = (
+            "pyspark" if engine_type == "spark" else f"sqlmesh\\[{engine_type.replace('_', '')}]"
+        )
+        engine_install_text = f'• Run command in CLI to install your SQL engine\'s Python dependencies: pip install "{install_text}"\n'
+    # interactive init does not support DLT template
+    next_step_text = {
+        ProjectTemplate.DEFAULT: f"{engine_install_text}• Update your gateway connection settings (e.g., username/password) in the project configuration file:\n    {config_path}",
+        ProjectTemplate.DBT: "",
+    }
+    next_step_text[ProjectTemplate.EMPTY] = next_step_text[ProjectTemplate.DEFAULT]
+
+    quickstart_text = {
+        ProjectTemplate.DEFAULT: "Quickstart guide:\nhttps://sqlmesh.readthedocs.io/en/stable/quickstart/cli/",
+        ProjectTemplate.DBT: "dbt guide:\nhttps://sqlmesh.readthedocs.io/en/stable/integrations/dbt/",
+    }
+    quickstart_text[ProjectTemplate.EMPTY] = quickstart_text[ProjectTemplate.DEFAULT]
+
+    console.print(f"""──────────────────────────────
+
+Your SQLMesh project is ready!
+
+Next steps:
+{next_step_text[project_template]}
+• Run command in CLI: sqlmesh plan
+• (Optional) Explain a plan: sqlmesh plan --explain
+
+{quickstart_text[project_template]}
+
+Need help?
+• Docs:   https://sqlmesh.readthedocs.io
+• Slack:  https://www.tobikodata.com/slack
+• GitHub: https://github.com/TobikoData/sqlmesh/issues
+""")
+
 
 @cli.command("render")
 @click.argument("model")

sqlmesh/cli/project_init.py

@@ -0,0 +1,497 @@
+import typing as t
+from enum import Enum
+from pathlib import Path
+from dataclasses import dataclass
+from rich.prompt import Prompt
+from rich.console import Console
+from sqlmesh.integrations.dlt import generate_dlt_models_and_settings
+from sqlmesh.utils.date import yesterday_ds
+from sqlmesh.utils.errors import SQLMeshError
+
+from sqlmesh.core.config.connection import (
+    CONNECTION_CONFIG_TO_TYPE,
+    DIALECT_TO_TYPE,
+    INIT_DISPLAY_INFO_TO_TYPE,
+)
+
+
+PRIMITIVES = (str, int, bool, float)
+
+
+class ProjectTemplate(Enum):
+    DEFAULT = "default"
+    DBT = "dbt"
+    EMPTY = "empty"
+    DLT = "dlt"
+
+
+class InitCliMode(Enum):
+    DEFAULT = "default"
+    FLOW = "flow"
+
+
+def _gen_config(
+    engine_type: t.Optional[str],
+    settings: t.Optional[str],
+    start: t.Optional[str],
+    template: ProjectTemplate,
+    cli_mode: InitCliMode,
+    dialect: t.Optional[str] = None,
+) -> str:
+    project_dialect = dialect or DIALECT_TO_TYPE.get(engine_type)
+
+    connection_settings = (
+        settings
+        or """      type: duckdb
+      database: db.db"""
+    )
+
+    if not settings and template != ProjectTemplate.DBT:
+        doc_link = "https://sqlmesh.readthedocs.io/en/stable/integrations/engines{engine_link}"
+        engine_link = ""
+
+        if engine_type in CONNECTION_CONFIG_TO_TYPE:
+            required_fields = []
+            non_required_fields = []
+
+            for name, field in CONNECTION_CONFIG_TO_TYPE[engine_type].model_fields.items():
+                field_name = field.alias or name
+
+                default_value = field.get_default()
+
+                if isinstance(default_value, Enum):
+                    default_value = default_value.value
+                elif not isinstance(default_value, PRIMITIVES):
+                    default_value = ""
+
+                required = field.is_required() or field_name == "type"
+                option_str = f"      {'# ' if not required else ''}{field_name}: {default_value}\n"
+
+                # specify the DuckDB database field so quickstart runs out of the box
+                if engine_type == "duckdb" and field_name == "database":
+                    option_str = "      database: db.db\n"
+                    required = True
+
+                if required:
+                    required_fields.append(option_str)
+                else:
+                    non_required_fields.append(option_str)
+
+            connection_settings = "".join(required_fields + non_required_fields)
+
+            engine_link = f"/{engine_type}/#connection-options"
+
+        connection_settings = (
+            "      # For more information on configuring the connection to your execution engine, visit:\n"
+            "      # https://sqlmesh.readthedocs.io/en/stable/reference/configuration/#connection\n"
+            f"      # {doc_link.format(engine_link=engine_link)}\n{connection_settings}"
+        )
+
+    default_configs = {
+        ProjectTemplate.DEFAULT: f"""# --- Gateway Connection ---
+gateways:
+  {engine_type}:
+    connection:
+{connection_settings}
+default_gateway: {engine_type}
+
+# --- Model Defaults ---
+# https://sqlmesh.readthedocs.io/en/stable/reference/model_configuration/#model-defaults
+
+model_defaults:
+  dialect: {project_dialect}
+  start: {start or yesterday_ds()} # Start date for backfill history
+  cron: '@daily'    # Run models daily at 12am UTC (can override per model)
+
+# --- Linting Rules ---
+# Enforce standards for your team
+# https://sqlmesh.readthedocs.io/en/stable/guides/linter/
+
+linter:
+  enabled: true
+  rules:
+    - ambiguousorinvalidcolumn
+    - invalidselectstarexpansion
+""",
+        ProjectTemplate.DBT: """from pathlib import Path
+
+from sqlmesh.dbt.loader import sqlmesh_config
+
+config = sqlmesh_config(Path(__file__).parent)
+""",
+    }
+
+    default_configs[ProjectTemplate.EMPTY] = default_configs[ProjectTemplate.DEFAULT]
+    default_configs[ProjectTemplate.DLT] = default_configs[ProjectTemplate.DEFAULT]
+
+    flow_cli_mode = """
+# FLOW: Minimal prompts, automatic changes, summary output
+# https://sqlmesh.readthedocs.io/en/stable/reference/configuration/#plan
+
+plan:
+  no_diff: true             # Hide detailed text differences for changed models
+  no_prompts: true          # No interactive prompts
+  auto_apply: true          # Apply changes automatically
+
+# --- Optional: Set a default target environment ---
+# This is intended for local development to prevent users from accidentally applying plans to the prod environment.
+# It is a development only config and should NOT be committed to your git repo.
+# https://sqlmesh.readthedocs.io/en/stable/guides/configuration/#default-target-environment
+
+# Uncomment the following line to use a default target environment derived from the logged in user's name.
+# default_target_environment: dev_{{ user() }}
+
+# Example usage:
+# sqlmesh plan            # Automatically resolves to: sqlmesh plan dev_yourname
+# sqlmesh plan prod       # Specify `prod` to apply changes to production
+"""
+
+    return default_configs[template] + (flow_cli_mode if cli_mode == InitCliMode.FLOW else "")
+
+
+@dataclass
+class ExampleObjects:
+    sql_models: t.Dict[str, str]
+    python_models: t.Dict[str, str]
+    seeds: t.Dict[str, str]
+    audits: t.Dict[str, str]
+    tests: t.Dict[str, str]
+    sql_macros: t.Dict[str, str]
+    python_macros: t.Dict[str, str]
+
+
+def _gen_example_objects(schema_name: str) -> ExampleObjects:
+    sql_models: t.Dict[str, str] = {}
+    python_models: t.Dict[str, str] = {}
+    seeds: t.Dict[str, str] = {}
+    audits: t.Dict[str, str] = {}
+    tests: t.Dict[str, str] = {}
+    sql_macros: t.Dict[str, str] = {}
+    python_macros: t.Dict[str, str] = {"__init__": ""}
+
+    full_model_name = f"{schema_name}.full_model"
+    incremental_model_name = f"{schema_name}.incremental_model"
+    seed_model_name = f"{schema_name}.seed_model"
+
+    sql_models[full_model_name] = f"""MODEL (
+  name {full_model_name},
+  kind FULL,
+  cron '@daily',
+  grain item_id,
+  audits (assert_positive_order_ids),
+);
+
+SELECT
+  item_id,
+  COUNT(DISTINCT id) AS num_orders,
+FROM
+  {incremental_model_name}
+GROUP BY item_id
+  """
+
+    sql_models[incremental_model_name] = f"""MODEL (
+  name {incremental_model_name},
+  kind INCREMENTAL_BY_TIME_RANGE (
+    time_column event_date
+  ),
+  start '2020-01-01',
+  cron '@daily',
+  grain (id, event_date)
+);
+
+SELECT
+  id,
+  item_id,
+  event_date,
+FROM
+  {seed_model_name}
+WHERE
+  event_date BETWEEN @start_date AND @end_date
+  """
+
+    sql_models[seed_model_name] = f"""MODEL (
+  name {seed_model_name},
+  kind SEED (
+    path '../seeds/seed_data.csv'
+  ),
+  columns (
+    id INTEGER,
+    item_id INTEGER,
+    event_date DATE
+  ),
+  grain (id, event_date)
+);
+  """
+
+    seeds["seed_data"] = """id,item_id,event_date
+1,2,2020-01-01
+2,1,2020-01-01
+3,3,2020-01-03
+4,1,2020-01-04
+5,1,2020-01-05
+6,1,2020-01-06
+7,1,2020-01-07
+"""
+
+    audits["assert_positive_order_ids"] = """AUDIT (
+  name assert_positive_order_ids,
+);
+
+SELECT *
+FROM @this_model
+WHERE
+  item_id < 0
+  """
+
+    tests["test_full_model"] = f"""test_example_full_model:
+  model: {full_model_name}
+  inputs:
+    {incremental_model_name}:
+      rows:
+      - id: 1
+        item_id: 1
+      - id: 2
+        item_id: 1
+      - id: 3
+        item_id: 2
+  outputs:
+    query:
+      rows:
+      - item_id: 1
+        num_orders: 2
+      - item_id: 2
+        num_orders: 1
+  """
+
+    return ExampleObjects(
+        sql_models=sql_models,
+        python_models=python_models,
+        seeds=seeds,
+        audits=audits,
+        tests=tests,
+        python_macros=python_macros,
+        sql_macros=sql_macros,
+    )
+
+
+def init_example_project(
+    path: t.Union[str, Path],
+    engine_type: t.Optional[str],
+    dialect: t.Optional[str] = None,
+    template: ProjectTemplate = ProjectTemplate.DEFAULT,
+    pipeline: t.Optional[str] = None,
+    dlt_path: t.Optional[str] = None,
+    schema_name: str = "sqlmesh_example",
+    cli_mode: InitCliMode = InitCliMode.DEFAULT,
+) -> Path:
+    root_path = Path(path)
+    config_extension = "py" if template == ProjectTemplate.DBT else "yaml"
+    config_path = root_path / f"config.{config_extension}"
+    audits_path = root_path / "audits"
+    macros_path = root_path / "macros"
+    models_path = root_path / "models"
+    seeds_path = root_path / "seeds"
+    tests_path = root_path / "tests"
+
+    if config_path.exists():
+        raise SQLMeshError(
+            f"Found an existing config file '{config_path}'.\n\nPlease change to another directory or remove the existing file."
+        )
+
+    if template == ProjectTemplate.DBT and not Path(root_path, "dbt_project.yml").exists():
+        raise SQLMeshError(
+            "Required dbt project file 'dbt_project.yml' not found in the current directory.\n\nPlease add it or change directories before running `sqlmesh init` to set up your project."
+        )
+
+    engine_types = "', '".join(CONNECTION_CONFIG_TO_TYPE)
+    if engine_type is None and template != ProjectTemplate.DBT:
+        raise SQLMeshError(
+            f"Missing `engine` argument to `sqlmesh init` - please specify a SQL engine for your project. Options: '{engine_types}'."
+        )
+
+    if engine_type and engine_type not in CONNECTION_CONFIG_TO_TYPE:
+        raise SQLMeshError(
+            f"Invalid engine '{engine_type}'. Please specify one of '{engine_types}'."
+        )
+
+    models: t.Set[t.Tuple[str, str]] = set()
+    settings = None
+    start = None
+    if engine_type and template == ProjectTemplate.DLT:
+        project_dialect = dialect or DIALECT_TO_TYPE.get(engine_type)
+        if pipeline and project_dialect:
+            dlt_models, settings, start = generate_dlt_models_and_settings(
+                pipeline_name=pipeline, dialect=project_dialect, dlt_path=dlt_path
+            )
+        else:
+            raise SQLMeshError(
+                "Please provide a DLT pipeline with the `--dlt-pipeline` flag to generate a SQLMesh project from DLT."
+            )
+
+    _create_config(config_path, engine_type, dialect, settings, start, template, cli_mode)
+    if template == ProjectTemplate.DBT:
+        return config_path
+
+    _create_folders([audits_path, macros_path, models_path, seeds_path, tests_path])
+
+    if template == ProjectTemplate.DLT:
+        _create_object_files(
+            models_path, {model[0].split(".")[-1]: model[1] for model in dlt_models}, "sql"
+        )
+        return config_path
+
+    example_objects = _gen_example_objects(schema_name=schema_name)
+
+    if template != ProjectTemplate.EMPTY:
+        _create_object_files(models_path, example_objects.sql_models, "sql")
+        _create_object_files(models_path, example_objects.python_models, "py")
+        _create_object_files(seeds_path, example_objects.seeds, "csv")
+        _create_object_files(audits_path, example_objects.audits, "sql")
+        _create_object_files(tests_path, example_objects.tests, "yaml")
+        _create_object_files(macros_path, example_objects.python_macros, "py")
+        _create_object_files(macros_path, example_objects.sql_macros, "sql")
+
+    return config_path
+
+
+def _create_folders(target_folders: t.Sequence[Path]) -> None:
+    for folder_path in target_folders:
+        folder_path.mkdir(exist_ok=True)
+        (folder_path / ".gitkeep").touch()
+
+
+def _create_config(
+    config_path: Path,
+    engine_type: t.Optional[str],
+    dialect: t.Optional[str],
+    settings: t.Optional[str],
+    start: t.Optional[str],
+    template: ProjectTemplate,
+    cli_mode: InitCliMode,
+) -> None:
+    project_config = _gen_config(engine_type, settings, start, template, cli_mode, dialect)
+
+    _write_file(
+        config_path,
+        project_config,
+    )
+
+
+def _create_object_files(path: Path, object_dict: t.Dict[str, str], file_extension: str) -> None:
+    for object_name, object_def in object_dict.items():
+        # file name is table component of catalog.schema.table
+        _write_file(path / f"{object_name.split('.')[-1]}.{file_extension}", object_def)
+
+
+def _write_file(path: Path, payload: str) -> None:
+    with open(path, "w", encoding="utf-8") as fd:
+        fd.write(payload)
+
+
+def interactive_init(
+    path: Path,
+    console: Console,
+    project_template: t.Optional[ProjectTemplate] = None,
+) -> t.Tuple[ProjectTemplate, t.Optional[str], t.Optional[InitCliMode]]:
+    console.print("──────────────────────────────")
+    console.print("Welcome to SQLMesh!")
+
+    project_template = _init_template_prompt(console) if not project_template else project_template
+
+    if project_template == ProjectTemplate.DBT:
+        return (project_template, None, None)
+
+    engine_type = _init_engine_prompt(console)
+    cli_mode = _init_cli_mode_prompt(console)
+
+    return (project_template, engine_type, cli_mode)
+
+
+def _init_integer_prompt(
+    console: Console, err_msg_entity: str, num_options: int, retry_func: t.Callable[[t.Any], t.Any]
+) -> int:
+    err_msg = "\nERROR: '{option_str}' is not a valid {err_msg_entity} number - please enter a number between 1 and {num_options} or exit with control+c\n"
+    while True:
+        option_str = Prompt.ask("Enter a number", console=console)
+
+        value_error = False
+        try:
+            option_num = int(option_str)
+        except ValueError:
+            value_error = True
+
+        if value_error or option_num < 1 or option_num > num_options:
+            console.print(
+                err_msg.format(
+                    option_str=option_str, err_msg_entity=err_msg_entity, num_options=num_options
+                ),
+                style="red",
+            )
+            continue
+        console.print("")
+        return option_num
+
+
+def _init_display_choices(values_dict: t.Dict[str, str], console: Console) -> t.Dict[int, str]:
+    display_num_to_value = {}
+    for i, value_str in enumerate(values_dict.keys()):
+        console.print(f"    \[{i + 1}] {' ' if i < 9 else ''}{value_str} {values_dict[value_str]}")
+        display_num_to_value[i + 1] = value_str
+    console.print("")
+    return display_num_to_value
+
+
+def _init_template_prompt(console: Console) -> ProjectTemplate:
+    console.print("──────────────────────────────\n")
+    console.print("What type of project do you want to set up?\n")
+
+    # These are ordered for user display - do not reorder
+    template_descriptions = {
+        ProjectTemplate.DEFAULT.name: "- Create SQLMesh example project models and files",
+        ProjectTemplate.DBT.value: "    - You have an existing dbt project and want to run it with SQLMesh",
+        ProjectTemplate.EMPTY.name: "  - Create a SQLMesh configuration file and project directories only",
+    }
+
+    display_num_to_template = _init_display_choices(template_descriptions, console)
+
+    template_num = _init_integer_prompt(
+        console, "project type", len(template_descriptions), _init_template_prompt
+    )
+
+    return ProjectTemplate(display_num_to_template[template_num].lower())
+
+
+def _init_engine_prompt(console: Console) -> str:
+    console.print("──────────────────────────────\n")
+    console.print("Choose your SQL engine:\n")
+
+    # INIT_DISPLAY_INFO_TO_TYPE is a dict of {engine_type: (display_order, display_name)}
+    DISPLAY_NAME_TO_TYPE = {v[1]: k for k, v in INIT_DISPLAY_INFO_TO_TYPE.items()}
+    ordered_engine_display_names = {
+        info[1]: "" for info in sorted(INIT_DISPLAY_INFO_TO_TYPE.values(), key=lambda x: x[0])
+    }
+    display_num_to_display_name = _init_display_choices(ordered_engine_display_names, console)
+
+    engine_num = _init_integer_prompt(
+        console, "engine", len(ordered_engine_display_names), _init_engine_prompt
+    )
+
+    return DISPLAY_NAME_TO_TYPE[display_num_to_display_name[engine_num]]
+
+
+def _init_cli_mode_prompt(console: Console) -> InitCliMode:
+    console.print("──────────────────────────────\n")
+    console.print("Choose your SQLMesh CLI experience:\n")
+
+    cli_mode_descriptions = {
+        InitCliMode.DEFAULT.name: "- See and control every detail",
+        InitCliMode.FLOW.name: "   - Automatically run changes and show summary output",
+    }
+
+    display_num_to_cli_mode = _init_display_choices(cli_mode_descriptions, console)
+
+    cli_mode_num = _init_integer_prompt(
+        console, "config", len(cli_mode_descriptions), _init_cli_mode_prompt
+    )
+
+    return InitCliMode(display_num_to_cli_mode[cli_mode_num].lower())

sqlmesh/core/config/connection.py

@@ -87,6 +87,9 @@ def _get_engine_import_validator(
 
 class ConnectionConfig(abc.ABC, BaseConfig):
     type_: str
+    DIALECT: t.ClassVar[str]
+    DISPLAY_NAME: t.ClassVar[str]
+    DISPLAY_ORDER: t.ClassVar[int]
     concurrent_tasks: int
     register_comments: bool
     pre_ping: bool
@@ -463,6 +466,9 @@ class MotherDuckConnectionConfig(BaseDuckDBConnectionConfig):
     """Configuration for the MotherDuck connection."""
 
     type_: t.Literal["motherduck"] = Field(alias="type", default="motherduck")
+    DIALECT: t.ClassVar[t.Literal["duckdb"]] = "duckdb"
+    DISPLAY_NAME: t.ClassVar[t.Literal["MotherDuck"]] = "MotherDuck"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[5]] = 5
 
     @property
     def _connection_kwargs_keys(self) -> t.Set[str]:
@@ -487,6 +493,9 @@ class DuckDBConnectionConfig(BaseDuckDBConnectionConfig):
     """Configuration for the DuckDB connection."""
 
     type_: t.Literal["duckdb"] = Field(alias="type", default="duckdb")
+    DIALECT: t.ClassVar[t.Literal["duckdb"]] = "duckdb"
+    DISPLAY_NAME: t.ClassVar[t.Literal["DuckDB"]] = "DuckDB"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[1]] = 1
 
 
 class SnowflakeConnectionConfig(ConnectionConfig):
@@ -537,6 +546,9 @@ class SnowflakeConnectionConfig(ConnectionConfig):
     session_parameters: t.Optional[dict] = None
 
     type_: t.Literal["snowflake"] = Field(alias="type", default="snowflake")
+    DIALECT: t.ClassVar[t.Literal["snowflake"]] = "snowflake"
+    DISPLAY_NAME: t.ClassVar[t.Literal["Snowflake"]] = "Snowflake"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[2]] = 2
 
     _concurrent_tasks_validator = concurrent_tasks_validator
 
@@ -733,6 +745,9 @@ class DatabricksConnectionConfig(ConnectionConfig):
     pre_ping: t.Literal[False] = False
 
     type_: t.Literal["databricks"] = Field(alias="type", default="databricks")
+    DIALECT: t.ClassVar[t.Literal["databricks"]] = "databricks"
+    DISPLAY_NAME: t.ClassVar[t.Literal["Databricks"]] = "Databricks"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[3]] = 3
 
     _concurrent_tasks_validator = concurrent_tasks_validator
     _http_headers_validator = http_headers_validator
@@ -989,6 +1004,9 @@ class BigQueryConnectionConfig(ConnectionConfig):
     pre_ping: t.Literal[False] = False
 
     type_: t.Literal["bigquery"] = Field(alias="type", default="bigquery")
+    DIALECT: t.ClassVar[t.Literal["bigquery"]] = "bigquery"
+    DISPLAY_NAME: t.ClassVar[t.Literal["BigQuery"]] = "BigQuery"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[4]] = 4
 
     _engine_import_validator = _get_engine_import_validator("google.cloud.bigquery", "bigquery")
 
@@ -1129,7 +1147,12 @@ class GCPPostgresConnectionConfig(ConnectionConfig):
     timeout: t.Optional[int] = None
     scopes: t.Tuple[str, ...] = ("https://www.googleapis.com/auth/sqlservice.admin",)
     driver: str = "pg8000"
+
     type_: t.Literal["gcp_postgres"] = Field(alias="type", default="gcp_postgres")
+    DIALECT: t.ClassVar[t.Literal["postgres"]] = "postgres"
+    DISPLAY_NAME: t.ClassVar[t.Literal["GCP Postgres"]] = "GCP Postgres"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[13]] = 13
+
     concurrent_tasks: int = 4
     register_comments: bool = True
     pre_ping: bool = True
@@ -1264,6 +1287,9 @@ class RedshiftConnectionConfig(ConnectionConfig):
     pre_ping: bool = False
 
     type_: t.Literal["redshift"] = Field(alias="type", default="redshift")
+    DIALECT: t.ClassVar[t.Literal["redshift"]] = "redshift"
+    DISPLAY_NAME: t.ClassVar[t.Literal["Redshift"]] = "Redshift"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[7]] = 7
 
     _engine_import_validator = _get_engine_import_validator("redshift_connector", "redshift")
 
@@ -1325,6 +1351,9 @@ class PostgresConnectionConfig(ConnectionConfig):
     pre_ping: bool = True
 
     type_: t.Literal["postgres"] = Field(alias="type", default="postgres")
+    DIALECT: t.ClassVar[t.Literal["postgres"]] = "postgres"
+    DISPLAY_NAME: t.ClassVar[t.Literal["Postgres"]] = "Postgres"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[12]] = 12
 
     _engine_import_validator = _get_engine_import_validator("psycopg2", "postgres")
 
@@ -1378,6 +1407,9 @@ class MySQLConnectionConfig(ConnectionConfig):
     pre_ping: bool = True
 
     type_: t.Literal["mysql"] = Field(alias="type", default="mysql")
+    DIALECT: t.ClassVar[t.Literal["mysql"]] = "mysql"
+    DISPLAY_NAME: t.ClassVar[t.Literal["MySQL"]] = "MySQL"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[14]] = 14
 
     _engine_import_validator = _get_engine_import_validator("pymysql", "mysql")
 
@@ -1440,6 +1472,9 @@ class MSSQLConnectionConfig(ConnectionConfig):
     pre_ping: bool = True
 
     type_: t.Literal["mssql"] = Field(alias="type", default="mssql")
+    DIALECT: t.ClassVar[t.Literal["tsql"]] = "tsql"
+    DISPLAY_NAME: t.ClassVar[t.Literal["MSSQL"]] = "MSSQL"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[11]] = 11
 
     @model_validator(mode="before")
     @classmethod
@@ -1581,6 +1616,8 @@ class MSSQLConnectionConfig(ConnectionConfig):
 
 class AzureSQLConnectionConfig(MSSQLConnectionConfig):
     type_: t.Literal["azuresql"] = Field(alias="type", default="azuresql")  # type: ignore
+    DISPLAY_NAME: t.ClassVar[t.Literal["Azure SQL"]] = "Azure SQL"  # type: ignore
+    DISPLAY_ORDER: t.ClassVar[t.Literal[10]] = 10  # type: ignore
 
     @property
     def _extra_engine_config(self) -> t.Dict[str, t.Any]:
@@ -1601,6 +1638,9 @@ class SparkConnectionConfig(ConnectionConfig):
     pre_ping: t.Literal[False] = False
 
     type_: t.Literal["spark"] = Field(alias="type", default="spark")
+    DIALECT: t.ClassVar[t.Literal["spark"]] = "spark"
+    DISPLAY_NAME: t.ClassVar[t.Literal["Spark"]] = "Spark"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[8]] = 8
 
     _engine_import_validator = _get_engine_import_validator("pyspark", "spark")
 
@@ -1719,6 +1759,9 @@ class TrinoConnectionConfig(ConnectionConfig):
     pre_ping: t.Literal[False] = False
 
     type_: t.Literal["trino"] = Field(alias="type", default="trino")
+    DIALECT: t.ClassVar[t.Literal["trino"]] = "trino"
+    DISPLAY_NAME: t.ClassVar[t.Literal["Trino"]] = "Trino"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[9]] = 9
 
     _engine_import_validator = _get_engine_import_validator("trino", "trino")
 
@@ -1879,6 +1922,9 @@ class ClickhouseConnectionConfig(ConnectionConfig):
     connection_pool_options: t.Optional[t.Dict[str, t.Any]] = None
 
     type_: t.Literal["clickhouse"] = Field(alias="type", default="clickhouse")
+    DIALECT: t.ClassVar[t.Literal["clickhouse"]] = "clickhouse"
+    DISPLAY_NAME: t.ClassVar[t.Literal["ClickHouse"]] = "ClickHouse"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[6]] = 6
 
     _engine_import_validator = _get_engine_import_validator("clickhouse_connect", "clickhouse")
 
@@ -2003,6 +2049,9 @@ class AthenaConnectionConfig(ConnectionConfig):
     pre_ping: t.Literal[False] = False
 
     type_: t.Literal["athena"] = Field(alias="type", default="athena")
+    DIALECT: t.ClassVar[t.Literal["athena"]] = "athena"
+    DISPLAY_NAME: t.ClassVar[t.Literal["Athena"]] = "Athena"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[15]] = 15
 
     _engine_import_validator = _get_engine_import_validator("pyathena", "athena")
 
@@ -2071,6 +2120,9 @@ class RisingwaveConnectionConfig(ConnectionConfig):
     pre_ping: bool = True
 
     type_: t.Literal["risingwave"] = Field(alias="type", default="risingwave")
+    DIALECT: t.ClassVar[t.Literal["risingwave"]] = "risingwave"
+    DISPLAY_NAME: t.ClassVar[t.Literal["RisingWave"]] = "RisingWave"
+    DISPLAY_ORDER: t.ClassVar[t.Literal[16]] = 16
 
     _engine_import_validator = _get_engine_import_validator("psycopg2", "risingwave")
 
@@ -2115,6 +2167,27 @@ CONNECTION_CONFIG_TO_TYPE = {
     )
 }
 
+DIALECT_TO_TYPE = {
+    tpe.all_field_infos()["type_"].default: tpe.DIALECT
+    for tpe in subclasses(
+        __name__,
+        ConnectionConfig,
+        exclude=(ConnectionConfig, BaseDuckDBConnectionConfig),
+    )
+}
+
+INIT_DISPLAY_INFO_TO_TYPE = {
+    tpe.all_field_infos()["type_"].default: (
+        tpe.DISPLAY_ORDER,
+        tpe.DISPLAY_NAME,
+    )
+    for tpe in subclasses(
+        __name__,
+        ConnectionConfig,
+        exclude=(ConnectionConfig, BaseDuckDBConnectionConfig),
+    )
+}
+
 
 def parse_connection_config(v: t.Dict[str, t.Any]) -> ConnectionConfig:
     if "type" not in v:

sqlmesh/core/plan/builder.py

@@ -835,6 +835,7 @@ class PlanBuilder:
             and not self._include_unmodified
             and self._context_diff.is_new_environment
             and not self._context_diff.has_snapshot_changes
+            and not self._context_diff.has_environment_statements_changes
             and not self._backfill_models
         ):
             raise NoChangesPlanError(

sqlmesh/integrations/dlt.py

@@ -138,7 +138,7 @@ def generate_dlt_models(
     force: bool,
     dlt_path: t.Optional[str] = None,
 ) -> t.List[str]:
-    from sqlmesh.cli.example_project import _create_models
+    from sqlmesh.cli.project_init import _create_object_files
 
     sqlmesh_models, _, _ = generate_dlt_models_and_settings(
         pipeline_name=pipeline_name,
@@ -152,7 +152,11 @@ def generate_dlt_models(
         sqlmesh_models = {model for model in sqlmesh_models if model[0] not in existing_models}
 
     if sqlmesh_models:
-        _create_models(models_path=context.path / "models", models=sqlmesh_models)
+        _create_object_files(
+            context.path / "models",
+            {model[0].split(".")[-1]: model[1] for model in sqlmesh_models},
+            "sql",
+        )
         return [model[0] for model in sqlmesh_models]
     return []
 

sqlmesh/magics.py

@@ -26,15 +26,16 @@ from IPython.core.magic import (
 from IPython.core.magic_arguments import argument, magic_arguments, parse_argstring
 from IPython.utils.process import arg_split
 from rich.jupyter import JupyterRenderable
-from sqlmesh.cli.example_project import ProjectTemplate, init_example_project
+from sqlmesh.cli.project_init import ProjectTemplate, init_example_project
 from sqlmesh.core import analytics
 from sqlmesh.core.config import load_configs
+from sqlmesh.core.config.connection import INIT_DISPLAY_INFO_TO_TYPE
 from sqlmesh.core.console import create_console, set_console, configure_console
 from sqlmesh.core.context import Context
 from sqlmesh.core.dialect import format_model_expressions, parse
 from sqlmesh.core.model import load_sql_based_model
 from sqlmesh.core.test import ModelTestMetadata
-from sqlmesh.utils import sqlglot_dialects, yaml, Verbosity, optional_import
+from sqlmesh.utils import yaml, Verbosity, optional_import
 from sqlmesh.utils.errors import MagicError, MissingContextException, SQLMeshError
 
 logger = logging.getLogger(__name__)
@@ -198,9 +199,9 @@ class SQLMeshMagics(Magics):
     @magic_arguments()
     @argument("path", type=str, help="The path where the new SQLMesh project should be created.")
     @argument(
-        "sql_dialect",
+        "engine",
         type=str,
-        help=f"Default model SQL dialect. Supported values: {sqlglot_dialects()}.",
+        help=f"Project SQL engine. Supported values: '{', '.join([info[1] for info in sorted(INIT_DISPLAY_INFO_TO_TYPE.values(), key=lambda x: x[0])])}'.",  # type: ignore
     )
     @argument(
         "--template",
@@ -229,7 +230,12 @@ class SQLMeshMagics(Magics):
         except ValueError:
             raise MagicError(f"Invalid project template '{args.template}'")
         init_example_project(
-            args.path, args.sql_dialect, project_template, args.dlt_pipeline, args.dlt_path
+            path=args.path,
+            engine_type=args.engine,
+            dialect=None,
+            template=project_template,
+            pipeline=args.dlt_pipeline,
+            dlt_path=args.dlt_path,
         )
         html = str(
             h(

sqlmesh/utils/yaml.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import getpass
 import io
 import typing as t
 from decimal import Decimal
@@ -14,6 +15,7 @@ from sqlmesh.utils.jinja import ENVIRONMENT, create_var
 
 JINJA_METHODS = {
     "env_var": lambda key, default=None: getenv(key, default),
+    "user": lambda: getpass.getuser(),
 }
 
 

{sqlmesh-0.195.1.dev4.dist-info → sqlmesh-0.195.1.dev6.dist-info}/METADATA

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

{sqlmesh-0.195.1.dev4.dist-info → sqlmesh-0.195.1.dev6.dist-info}/RECORD

@@ -1,14 +1,14 @@
 sqlmesh/__init__.py,sha256=QjwaamJIdW7voXoS880yAx7tHm-Im4_mqGA-XJgafos,7631
-sqlmesh/_version.py,sha256=W2g-e2AVI33a-naNGAiuozPk-wN4pGYR9p2budZemfY,528
-sqlmesh/magics.py,sha256=d7udR_sieKWzp_YXNFPA2O173xDCqk6u9CIKB7Skb2c,41206
+sqlmesh/_version.py,sha256=9DEwfpD4oUIBKrKwEWsFtRxQ3tfvYMXwPW6bGESuRJI,528
+sqlmesh/magics.py,sha256=nMfwSW5rIkdnyO9MXYm9u24hNl6dqgAWybC-MnRcNnE,41451
 sqlmesh/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/cicd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/cicd/bot.py,sha256=2zlbn-DXkqQzr3lA0__IGU4XaIfXBXBKLWXNI2DRJX8,759
 sqlmesh/cicd/config.py,sha256=mpgkisSBBovlNrNZir2unT8Wes6b38RW2UsU_o4e8vY,109
 sqlmesh/cli/__init__.py,sha256=MAXAyO7isbyM-PaSdFjkJNcjn32WjOl0XzxT5gvp_vo,1690
-sqlmesh/cli/example_project.py,sha256=QAFQbw_kzqn30GLTthqsuWXbFDBpX8W6RsCgQ-jx65M,9308
-sqlmesh/cli/main.py,sha256=wo5_057ofKgB6D32bl6zBCNZDKwBSXrZv5IzGpRnB3o,33179
+sqlmesh/cli/main.py,sha256=5hFnJY_yvzdD-HNtXFE_p6CTaXiEIxzCko5LCrrN7Uo,35533
 sqlmesh/cli/options.py,sha256=-4ZclMIeIg8tghLowtmQNmpEFlm0QtOVEh40NqRdFHA,2499
+sqlmesh/cli/project_init.py,sha256=oqHZ8wSIfFwQHmcE6OUgqH0srCcXOFsD3_EABNasrx0,16418
 sqlmesh/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/core/_typing.py,sha256=e1f7xO2aZCy38M_3VoDy-XI3shyd99-IFctgIFSgXWM,497
 sqlmesh/core/console.py,sha256=_B9rmOn0WbgP8DsST8Lg9ODGu9u0WA2D2jRrJRX0VMM,153805
@@ -41,7 +41,7 @@ sqlmesh/core/config/__init__.py,sha256=b4gFb04tpeZpowqJD-7h3U3TLgxrpQhZahVEAo6VW
 sqlmesh/core/config/base.py,sha256=t8NQmsgQoZSc-k0dlDiCb8t1jj0AMYdGZ-6se9q_Pks,4898
 sqlmesh/core/config/categorizer.py,sha256=6vzUoNLjR6GOEb_2mYVz2TwmMv2BfldgHX2u-Le5HZs,1975
 sqlmesh/core/config/common.py,sha256=rsb2uVFqPEX3DMsWG_hApwztCuRJP-FAmaQ_5L3-S8g,4006
-sqlmesh/core/config/connection.py,sha256=sxRPhP0q088kInXtZinEK2FbkQHkzJZrGMDF-VnWmtA,82137
+sqlmesh/core/config/connection.py,sha256=-KF0xufXPt8HIYZmRdyQokyq59xOiCS4S2zSgIi0LUg,85462
 sqlmesh/core/config/feature_flag.py,sha256=JRcD31OG_t2cYc24meKbHDGB0iVID0P07V2oOeB_mgA,203
 sqlmesh/core/config/format.py,sha256=6CXFbvnor56xbldKE-Vrm9k_ABRoY4v6vgIb3mCihiQ,1355
 sqlmesh/core/config/gateway.py,sha256=tYngyqwd_4Qr9lhcv2hlvLvb_2pgYYtKu6hdGsTr-4I,1931
@@ -94,7 +94,7 @@ sqlmesh/core/model/meta.py,sha256=D9InI9M2-IXeb34vkXNQSLALL8xVXjZ_LXwI-Tqxm7I,21
 sqlmesh/core/model/schema.py,sha256=OClbAeA8LpW-IiSiLT_TlDWkEqmIIvSk0GXq8SWI-GQ,3443
 sqlmesh/core/model/seed.py,sha256=a0M-1zY1gOkN5ph2GQyataEdBSCtq50YjeFk2LyvInI,5058
 sqlmesh/core/plan/__init__.py,sha256=NKSvM7ZBVjw9ho3J65M1wFvG3KURB8PJ0FHHLmtSF44,443
-sqlmesh/core/plan/builder.py,sha256=OS6igFQvPRLwIxuYT4WYcuWnuSrPfCQArUA6ohxFnZw,41341
+sqlmesh/core/plan/builder.py,sha256=9M8Bzf6SZ3nnawowvu0jHSVCCVblz3srevJoOS7ppkM,41415
 sqlmesh/core/plan/definition.py,sha256=-jAO5EWvZdmn8jU7bMFJcprBPdfTVhSRgAvBPZ6kqBg,13613
 sqlmesh/core/plan/evaluator.py,sha256=DkpJ78R33_RBx5MVY13CcGU0x2-EcKWkcrETsjuyn10,20484
 sqlmesh/core/plan/explainer.py,sha256=SD7L41x-E_s4Cvf37wbP_-pdCrxdUkfsRKbFRIvVPG0,11826
@@ -157,7 +157,7 @@ sqlmesh/engines/spark/db_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 sqlmesh/engines/spark/db_api/errors.py,sha256=LSXuHHhkzHvKlcdwmhCM9qm51KyKoP8gQH-p_W3Oow4,148
 sqlmesh/engines/spark/db_api/spark_session.py,sha256=uQP0VFFYtp3N9mK7zKw6SoiGVhJDDYPylqx46yDwGEc,4667
 sqlmesh/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlmesh/integrations/dlt.py,sha256=Blj_707XadGtg9bQZI8nZN4vKsxILV8182JZbnJa8mc,7651
+sqlmesh/integrations/dlt.py,sha256=mA9ym16gAN2O8RYOzSPeTX5xsXPuXVRPdiX7dkGGZlo,7744
 sqlmesh/integrations/llm.py,sha256=URgp3JKr06HYv6hGlJ7DQ9m3QCc41xRWK23HzmGpbDI,1662
 sqlmesh/integrations/slack.py,sha256=nxLxu5WztGbZH3JdqnzyPqmJUMfRdJ_49LQ7zR-u39Q,6801
 sqlmesh/integrations/github/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -282,8 +282,8 @@ sqlmesh/utils/process.py,sha256=vpXcpJ1eIbivs7gZdwTKSJI7OS6kKBebnaBzz75ykvs,2428
 sqlmesh/utils/pydantic.py,sha256=I898jAFqa3qU6lG2uPpRebVFncOUo8ZrLWM_R3K3DHU,11685
 sqlmesh/utils/rich.py,sha256=BpB47G0-JcU41LkGkeGKroexj4NOV5fox4-GOIXPgIc,3545
 sqlmesh/utils/windows.py,sha256=r7Yin4WEwbvH7sKA3hOJtRsclmscNuBeCklCfVPvtQs,611
-sqlmesh/utils/yaml.py,sha256=np-WVcwmwsKghCgAj1OBBMsK1SXSRn4wR-H37cGiFr8,2282
-sqlmesh-0.195.1.dev4.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
+sqlmesh/utils/yaml.py,sha256=hvo5lmybYLcIx4p6CQwufS8X4MbwS60lEBnCmYJCXmU,2336
+sqlmesh-0.195.1.dev6.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
 web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web/client/dist/index.html,sha256=drXwzSCEVDTMfaIwzJYjnT8Xk4c-Y4wNJz-CflUa_vY,5472
 web/client/dist/assets/Audits-DrNQaTQA.js,sha256=E8JF632bsRUm6LGtgXlyHrJOYQe5VW2CgRZPaZNKvgg,1041
@@ -401,8 +401,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=OYuQ_4dgbhG9ibTcX1a8mvYgH3ANxw9Fhbb4wg6QWqc,9222
 web/server/api/endpoints/table_diff.py,sha256=SCy3-pr5x6bEEiOaZGCDbiHQhpgxwmnz3Acqa2Ie6jI,2090
-sqlmesh-0.195.1.dev4.dist-info/METADATA,sha256=L5VdwpRstKaJDH3j1MPFjmdhqzgNyDchcLQYXa-59hA,26690
-sqlmesh-0.195.1.dev4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlmesh-0.195.1.dev4.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
-sqlmesh-0.195.1.dev4.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
-sqlmesh-0.195.1.dev4.dist-info/RECORD,,
+sqlmesh-0.195.1.dev6.dist-info/METADATA,sha256=gTiNBZjgoyRY88D1h1234jYbevqusjTH2LCM6ubFDz4,26690
+sqlmesh-0.195.1.dev6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlmesh-0.195.1.dev6.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
+sqlmesh-0.195.1.dev6.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
+sqlmesh-0.195.1.dev6.dist-info/RECORD,,

sqlmesh/cli/example_project.py

@@ -1,338 +0,0 @@
-import typing as t
-from enum import Enum
-from pathlib import Path
-from dataclasses import dataclass
-
-import click
-from sqlglot import Dialect
-from sqlmesh.integrations.dlt import generate_dlt_models_and_settings
-from sqlmesh.utils.date import yesterday_ds
-
-from sqlmesh.core.config.connection import CONNECTION_CONFIG_TO_TYPE
-
-
-PRIMITIVES = (str, int, bool, float)
-
-
-class ProjectTemplate(Enum):
-    DBT = "dbt"
-    DLT = "dlt"
-    DEFAULT = "default"
-    EMPTY = "empty"
-
-
-def _gen_config(
-    dialect: t.Optional[str],
-    settings: t.Optional[str],
-    start: t.Optional[str],
-    template: ProjectTemplate,
-) -> str:
-    connection_settings = (
-        settings
-        or """      type: duckdb
-      database: db.db"""
-    )
-
-    if not settings and template != ProjectTemplate.DBT:
-        doc_link = "https://sqlmesh.readthedocs.io/en/stable/integrations/engines{engine_link}"
-        engine_link = ""
-
-        engine = "mssql" if dialect == "tsql" else dialect
-
-        if engine in CONNECTION_CONFIG_TO_TYPE:
-            required_fields = []
-            non_required_fields = []
-
-            for name, field in CONNECTION_CONFIG_TO_TYPE[engine].model_fields.items():
-                field_name = field.alias or name
-                default_value = field.get_default()
-
-                if isinstance(default_value, Enum):
-                    default_value = default_value.value
-                elif not isinstance(default_value, PRIMITIVES):
-                    default_value = ""
-
-                required = field.is_required() or field_name == "type"
-                option_str = f"      {'# ' if not required else ''}{field_name}: {default_value}\n"
-
-                # specify the DuckDB database field so quickstart runs out of the box
-                if engine == "duckdb" and field_name == "database":
-                    option_str = "      database: db.db\n"
-                    required = True
-
-                if required:
-                    required_fields.append(option_str)
-                else:
-                    non_required_fields.append(option_str)
-
-            connection_settings = "".join(required_fields + non_required_fields)
-
-            engine_link = f"/{engine}/#connection-options"
-
-        connection_settings = (
-            "      # For more information on configuring the connection to your execution engine, visit:\n"
-            "      # https://sqlmesh.readthedocs.io/en/stable/reference/configuration/#connections\n"
-            f"      # {doc_link.format(engine_link=engine_link)}\n{connection_settings}"
-        )
-
-    default_configs = {
-        ProjectTemplate.DEFAULT: f"""gateways:
-  {dialect}:
-    connection:
-{connection_settings}
-
-default_gateway: {dialect}
-
-model_defaults:
-  dialect: {dialect}
-  start: {start or yesterday_ds()}
-""",
-        ProjectTemplate.DBT: """from pathlib import Path
-
-from sqlmesh.dbt.loader import sqlmesh_config
-
-config = sqlmesh_config(Path(__file__).parent)
-""",
-    }
-
-    default_configs[ProjectTemplate.EMPTY] = default_configs[ProjectTemplate.DEFAULT]
-    default_configs[ProjectTemplate.DLT] = default_configs[ProjectTemplate.DEFAULT]
-    return default_configs[template]
-
-
-@dataclass
-class ExampleObjects:
-    schema_name: str
-    full_model_name: str
-    full_model_def: str
-    incremental_model_name: str
-    incremental_model_def: str
-    seed_model_name: str
-    seed_model_def: str
-    seed_data: str
-    audit_def: str
-    test_def: str
-
-    def models(self) -> t.Set[t.Tuple[str, str]]:
-        return {
-            (self.full_model_name, self.full_model_def),
-            (self.incremental_model_name, self.incremental_model_def),
-            (self.seed_model_name, self.seed_model_def),
-        }
-
-
-def _gen_example_objects(schema_name: str) -> ExampleObjects:
-    full_model_name = f"{schema_name}.full_model"
-    incremental_model_name = f"{schema_name}.incremental_model"
-    seed_model_name = f"{schema_name}.seed_model"
-
-    full_model_def = f"""MODEL (
-  name {full_model_name},
-  kind FULL,
-  cron '@daily',
-  grain item_id,
-  audits (assert_positive_order_ids),
-);
-
-SELECT
-  item_id,
-  COUNT(DISTINCT id) AS num_orders,
-FROM
-  {incremental_model_name}
-GROUP BY item_id
-  """
-
-    incremental_model_def = f"""MODEL (
-  name {incremental_model_name},
-  kind INCREMENTAL_BY_TIME_RANGE (
-    time_column event_date
-  ),
-  start '2020-01-01',
-  cron '@daily',
-  grain (id, event_date)
-);
-
-SELECT
-  id,
-  item_id,
-  event_date,
-FROM
-  {seed_model_name}
-WHERE
-  event_date BETWEEN @start_date AND @end_date
-  """
-
-    seed_model_def = f"""MODEL (
-  name {seed_model_name},
-  kind SEED (
-    path '../seeds/seed_data.csv'
-  ),
-  columns (
-    id INTEGER,
-    item_id INTEGER,
-    event_date DATE
-  ),
-  grain (id, event_date)
-);
-  """
-
-    audit_def = """AUDIT (
-  name assert_positive_order_ids,
-);
-
-SELECT *
-FROM @this_model
-WHERE
-  item_id < 0
-  """
-
-    seed_data = """id,item_id,event_date
-1,2,2020-01-01
-2,1,2020-01-01
-3,3,2020-01-03
-4,1,2020-01-04
-5,1,2020-01-05
-6,1,2020-01-06
-7,1,2020-01-07
-"""
-
-    test_def = f"""test_example_full_model:
-  model: {full_model_name}
-  inputs:
-    {incremental_model_name}:
-      rows:
-      - id: 1
-        item_id: 1
-      - id: 2
-        item_id: 1
-      - id: 3
-        item_id: 2
-  outputs:
-    query:
-      rows:
-      - item_id: 1
-        num_orders: 2
-      - item_id: 2
-        num_orders: 1
-  """
-
-    return ExampleObjects(
-        schema_name=schema_name,
-        full_model_name=full_model_name,
-        full_model_def=full_model_def,
-        incremental_model_name=incremental_model_name,
-        incremental_model_def=incremental_model_def,
-        seed_model_name=seed_model_name,
-        seed_model_def=seed_model_def,
-        seed_data=seed_data,
-        audit_def=audit_def,
-        test_def=test_def,
-    )
-
-
-def init_example_project(
-    path: t.Union[str, Path],
-    dialect: t.Optional[str],
-    template: ProjectTemplate = ProjectTemplate.DEFAULT,
-    pipeline: t.Optional[str] = None,
-    dlt_path: t.Optional[str] = None,
-    schema_name: str = "sqlmesh_example",
-) -> None:
-    root_path = Path(path)
-    config_extension = "py" if template == ProjectTemplate.DBT else "yaml"
-    config_path = root_path / f"config.{config_extension}"
-    audits_path = root_path / "audits"
-    macros_path = root_path / "macros"
-    models_path = root_path / "models"
-    seeds_path = root_path / "seeds"
-    tests_path = root_path / "tests"
-
-    if config_path.exists():
-        raise click.ClickException(f"Found an existing config in '{config_path}'")
-
-    if not dialect and template != ProjectTemplate.DBT:
-        raise click.ClickException(
-            "Default SQL dialect is a required argument for SQLMesh projects"
-        )
-
-    models: t.Set[t.Tuple[str, str]] = set()
-    settings = None
-    start = None
-    if template == ProjectTemplate.DLT:
-        if pipeline and dialect:
-            models, settings, start = generate_dlt_models_and_settings(
-                pipeline_name=pipeline, dialect=dialect, dlt_path=dlt_path
-            )
-        else:
-            raise click.ClickException(
-                "DLT pipeline is a required argument to generate a SQLMesh project from DLT"
-            )
-
-    _create_config(config_path, dialect, settings, start, template)
-    if template == ProjectTemplate.DBT:
-        return
-
-    _create_folders([audits_path, macros_path, models_path, seeds_path, tests_path])
-
-    if template == ProjectTemplate.DLT:
-        _create_models(models_path, models)
-        return
-
-    example_objects = _gen_example_objects(schema_name=schema_name)
-
-    if template != ProjectTemplate.EMPTY:
-        _create_macros(macros_path)
-        _create_audits(audits_path, example_objects)
-        _create_models(models_path, example_objects.models())
-        _create_seeds(seeds_path, example_objects)
-        _create_tests(tests_path, example_objects)
-
-
-def _create_folders(target_folders: t.Sequence[Path]) -> None:
-    for folder_path in target_folders:
-        folder_path.mkdir(exist_ok=True)
-        (folder_path / ".gitkeep").touch()
-
-
-def _create_config(
-    config_path: Path,
-    dialect: t.Optional[str],
-    settings: t.Optional[str],
-    start: t.Optional[str],
-    template: ProjectTemplate,
-) -> None:
-    if dialect:
-        Dialect.get_or_raise(dialect)
-
-    project_config = _gen_config(dialect, settings, start, template)
-
-    _write_file(
-        config_path,
-        project_config,
-    )
-
-
-def _create_macros(macros_path: Path) -> None:
-    (macros_path / "__init__.py").touch()
-
-
-def _create_audits(audits_path: Path, example_objects: ExampleObjects) -> None:
-    _write_file(audits_path / "assert_positive_order_ids.sql", example_objects.audit_def)
-
-
-def _create_models(models_path: Path, models: t.Set[t.Tuple[str, str]]) -> None:
-    for model_name, model_def in models:
-        _write_file(models_path / f"{model_name.split('.')[-1]}.sql", model_def)
-
-
-def _create_seeds(seeds_path: Path, example_objects: ExampleObjects) -> None:
-    _write_file(seeds_path / "seed_data.csv", example_objects.seed_data)
-
-
-def _create_tests(tests_path: Path, example_objects: ExampleObjects) -> None:
-    _write_file(tests_path / "test_full_model.yaml", example_objects.test_def)
-
-
-def _write_file(path: Path, payload: str) -> None:
-    with open(path, "w", encoding="utf-8") as fd:
-        fd.write(payload)