dbt-addons 0.1.0__tar.gz

dbt_addons-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: dbt-addons
+Version: 0.1.0
+Requires-Python: >=3.8
+Requires-Dist: dbt-core>=1.5.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: dbt-duckdb>=1.5.0; extra == "dev"
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python

dbt_addons-0.1.0/addons/cli/cli.py

@@ -0,0 +1,104 @@
+import sys
+import subprocess
+import json
+import shutil
+from pathlib import Path
+from .logger import log
+from ..wap.wap import get_executed_tables, read_wap_config
+from ..install import install_from_project, install_addon
+
+def get_real_dbt_path():
+    dbt_path = shutil.which('dbt')
+
+    if not dbt_path:
+        log.error("dbt not found in PATH")
+        sys.exit(1)
+
+    real_path = Path(dbt_path).resolve()
+
+    if real_path == Path(__file__).resolve():
+        import os
+        path_dirs = os.environ['PATH'].split(os.pathsep)
+        current_dir = str(Path(__file__).parent.resolve())
+        filtered_path = os.pathsep.join([d for d in path_dirs if d != current_dir])
+
+        old_path = os.environ['PATH']
+        os.environ['PATH'] = filtered_path
+        dbt_path = shutil.which('dbt')
+        os.environ['PATH'] = old_path
+
+        if not dbt_path:
+            log.error("Real dbt executable not found")
+            sys.exit(1)
+
+    return dbt_path
+
+
+def _merge_wap_vars(args: list, extra: dict) -> list:
+    """Inject extra vars into dbt args, merging with any existing --vars."""
+    import yaml
+    args = list(args)
+    if '--vars' in args:
+        idx = args.index('--vars')
+        try:
+            existing = yaml.safe_load(args[idx + 1]) or {}
+        except Exception:
+            existing = {}
+        existing.update(extra)
+        args[idx + 1] = json.dumps(existing)
+    else:
+        args += ['--vars', json.dumps(extra)]
+    return args
+
+
+def main():
+    real_dbt = get_real_dbt_path()
+    args = sys.argv[1:]
+
+    if args[:1] == ['install']:
+        return install_from_project()
+
+    if args[:2] == ['wap', 'install']:
+        return install_addon('wap')
+
+    if '--wap' not in args:
+        return subprocess.run([real_dbt] + args).returncode
+
+    args.remove('--wap')
+    dbt_command = args[0] if args else None
+
+    if dbt_command not in ['run', 'build']:
+        log.error("--wap only works with 'run' or 'build'")
+        return 1
+
+    dbt_args = list(args[1:])
+    wap_config = read_wap_config()
+    suffix = wap_config.get('wap_staging_suffix')
+    if suffix:
+        dbt_args = _merge_wap_vars(dbt_args, {'dbt_wap_staging_suffix': suffix})
+
+    log.info(f"Running dbt {' '.join([dbt_command] + dbt_args)}...")
+    result = subprocess.run([real_dbt, dbt_command] + dbt_args)
+    log.info("")
+
+    tables_to_copy, skipped = get_executed_tables()
+
+    if not tables_to_copy:
+        log.warning("No tables to copy")
+        return 0
+
+    log.info(f"[dbt-addon WAP] Publishing {len(tables_to_copy)} tables to prod...")
+    tables_json = json.dumps(tables_to_copy)
+    skipped_json = json.dumps(skipped)
+
+    deploy_result = subprocess.run([
+        real_dbt, 'run-operation', 'wap_deploy',
+        '--args', f'{{tables_to_copy: {tables_json}, skipped_tables: {skipped_json}}}'
+    ])
+    log.info("")
+
+    return deploy_result.returncode
+
+
+if __name__ == '__main__':
+    sys.exit(main())

dbt_addons-0.1.0/addons/cli/logger.py

@@ -0,0 +1,19 @@
+import logging
+
+RESET  = "\033[0m"
+YELLOW = "\033[33m"
+CYAN   = "\033[36m"
+
+class _ColorFormatter(logging.Formatter):
+    def format(self, record):
+        prefix = f"{YELLOW}[WARN]{RESET} " if record.levelno == logging.WARNING else ""
+        record.msg = f"{prefix}{CYAN}{record.msg}{RESET}"
+        return super().format(record)
+
+_handler = logging.StreamHandler()
+_handler.setFormatter(_ColorFormatter(fmt="%(asctime)s  %(message)s", datefmt="%H:%M:%S"))
+
+log = logging.getLogger("dbta")
+log.setLevel(logging.INFO)
+log.addHandler(_handler)
+log.propagate = False

dbt_addons-0.1.0/addons/install.py

@@ -0,0 +1,102 @@
+import shutil
+from pathlib import Path
+from typing import List
+
+import yaml
+
+from .cli.logger import log
+
+ADDONS_ROOT = Path(__file__).parent
+
+
+def _install_addon(name: str) -> bool:
+    src = ADDONS_ROOT / name / 'macros'
+    if not src.exists():
+        log.warning(f"No macros found for addon '{name}' — skipping")
+        return False
+
+    dest = Path('macros/dbt_addons') / name
+    if dest.exists():
+        shutil.rmtree(dest)
+    shutil.copytree(src, dest)
+    log.info(f"Installed addon '{name}' → {dest}/")
+    return True
+
+
+def _active_adapter() -> str:
+    """Return the adapter type from profiles.yml for the active profile, or '' if unknown."""
+    project_file = Path('dbt_project.yml')
+    profiles_file = Path('profiles.yml')
+    if not project_file.exists() or not profiles_file.exists():
+        return ''
+    with open(project_file) as f:
+        profile_name = yaml.safe_load(f).get('profile', '')
+    with open(profiles_file) as f:
+        profiles = yaml.safe_load(f)
+    profile = profiles.get(profile_name, {})
+    target = profile.get('target', '')
+    return profile.get('outputs', {}).get(target, {}).get('type', '')
+
+
+def _install_wap_root_macro(cfg: dict) -> None:
+    """Install the root macros required for the configured WAP strategy."""
+    rename_mode = bool(cfg.get('wap_staging_suffix'))
+    Path('macros').mkdir(exist_ok=True)
+
+    # generate_schema_name is only needed for DuckDB — other adapters manage it themselves
+    if _active_adapter() == 'duckdb':
+        src = ADDONS_ROOT / 'wap' / 'root_macros' / 'generate_schema_name.sql'
+        shutil.copy(src, Path('macros') / 'generate_schema_name.sql')
+        log.info("  Added macros/generate_schema_name.sql (duckdb)")
+
+    if rename_mode:
+        src = ADDONS_ROOT / 'wap' / 'root_macros' / 'generate_alias_name.sql'
+        shutil.copy(src, Path('macros') / 'generate_alias_name.sql')
+        log.info("  Added macros/generate_alias_name.sql (rename mode)")
+    else:
+        dest = Path('macros') / 'generate_alias_name.sql'
+        if dest.exists():
+            dest.unlink()
+            log.info("  Removed macros/generate_alias_name.sql")
+
+
+def _read_project_cfg() -> dict:
+    project_file = Path('dbt_project.yml')
+    if not project_file.exists():
+        return {}
+    with open(project_file) as f:
+        project = yaml.safe_load(f)
+    return project.get('vars', {}).get('dbt-addons', {})
+
+
+def install_from_project() -> int:
+    project_file = Path('dbt_project.yml')
+    if not project_file.exists():
+        log.error("dbt_project.yml not found — run this from your dbt project root")
+        return 1
+
+    with open(project_file) as f:
+        project = yaml.safe_load(f)
+
+    cfg = project.get('vars', {}).get('dbt-addons', {})
+    addons: List[str] = cfg.get('addons', [])
+
+    if not addons:
+        log.warning("No addons configured under vars.dbt-addons.addons in dbt_project.yml")
+        return 0
+
+    log.info(f"Installing {len(addons)} addon(s): {', '.join(addons)}")
+    for name in addons:
+        _install_addon(name)
+        if name == 'wap':
+            _install_wap_root_macro(cfg)
+
+    return 0
+
+
+def install_addon(name: str) -> int:
+    if not _install_addon(name):
+        return 1
+    if name == 'wap':
+        _install_wap_root_macro(_read_project_cfg())
+    return 0

dbt_addons-0.1.0/addons/wap/macros/providers/utils.sql

@@ -0,0 +1,86 @@
+{% macro deploy_wap(tables_to_copy, skipped_tables, queries) %}
+  {% if execute %}
+    {% set total = (tables_to_copy | length) + (skipped_tables | length) %}
+    {% set width = 80 %}
+
+    {% for item in tables_to_copy %}
+      {% set start_label = loop.index ~ " of " ~ total ~ " START copying " ~ item.name %}
+      {% set start_dots = "." * ([width - start_label | length, 1] | max) %}
+      {% do log(start_label ~ " " ~ start_dots ~ " [RUN]", info=true) %}
+
+      {% do run_query(queries[loop.index - 1]) %}
+
+      {% set ok_label = loop.index ~ " of " ~ total ~ " OK " ~ item.name %}
+      {% set ok_dots = "." * ([width - ok_label | length, 1] | max) %}
+      {% do log(ok_label ~ " " ~ ok_dots ~ " [\x1b[32mOK\x1b[0m]", info=true) %}
+    {% endfor %}
+
+    {% for name in skipped_tables %}
+      {% set idx = (tables_to_copy | length) + loop.index %}
+      {% set fail_label = idx ~ " of " ~ total ~ " FAIL " ~ name %}
+      {% set fail_dots = "." * ([width - fail_label | length, 1] | max) %}
+      {% do log(fail_label ~ " " ~ fail_dots ~ " [\x1b[31mFAIL\x1b[0m]", info=true) %}
+    {% endfor %}
+
+    {% set n_copied = tables_to_copy | length %}
+    {% set n_failed = skipped_tables | length %}
+    {% set summary = "PASS=" ~ n_copied ~ " FAIL=" ~ n_failed ~ " TOTAL=" ~ total %}
+
+    {% do log("", info=true) %}
+    {% if n_copied == 0 %}
+      {% do log("[\x1b[31mNO TABLES\x1b[0m] " ~ summary, info=true) %}
+    {% elif n_copied < total %}
+      {% do log("[\x1b[33mPARTIAL\x1b[0m] " ~ summary, info=true) %}
+    {% else %}
+      {% do log("[\x1b[32mOK\x1b[0m] " ~ summary, info=true) %}
+    {% endif %}
+  {% endif %}
+{% endmacro %}
+
+{% macro all_required_variables_are_setup() %}
+  {% if execute %}
+    {% set adapter_type = adapter.type() %}
+    {% set cfg = var('dbt-addons', {}) %}
+    {% set required_vars = {} %}
+
+    {% set common_vars = {
+      'dbt_staging_schema': cfg.get('dbt_staging_schema'),
+      'dbt_prod_schema': cfg.get('dbt_prod_schema')
+    } %}
+
+    {% if adapter_type == 'snowflake' %}
+      {% set required_vars = common_vars %}
+
+    {% elif adapter_type == 'bigquery' %}
+      {% set required_vars = common_vars | combine({
+        'project_id': cfg.get('project_id'),
+        'prod_dataset': cfg.get('prod_dataset'),
+        'staging_dataset': cfg.get('staging_dataset')
+      }) %}
+
+    {% elif adapter_type == 'duckdb' %}
+      {% set required_vars = common_vars %}
+
+    {% else %}
+      {% do log("Unknown adapter: " ~ adapter_type, info=true) %}
+      {% set required_vars = common_vars %}
+    {% endif %}
+
+    {% set missing_vars = [] %}
+    {% for var_name, var_value in required_vars.items() %}
+      {% if var_value is none %}
+        {% do missing_vars.append(var_name) %}
+      {% endif %}
+    {% endfor %}
+
+    {% if missing_vars | length > 0 %}
+      {% do log("[" ~ adapter_type ~ "] Missing required variables: " ~ missing_vars | join(', '), info=true) %}
+      {% do exceptions.raise_compiler_error("Setup incomplete for " ~ adapter_type ~ ". Define: " ~ missing_vars | join(', ')) %}
+    {% else %}
+      {% do log("[" ~ adapter_type ~ "] All required variables configured", info=true) %}
+      {% for var_name, var_value in required_vars.items() %}
+        {% do log("   • " ~ var_name ~ ": " ~ var_value, info=true) %}
+      {% endfor %}
+    {% endif %}
+  {% endif %}
+{% endmacro %}

dbt_addons-0.1.0/addons/wap/macros/providers/wap_bigquery.sql

@@ -0,0 +1,15 @@
+{% macro wap_deploy_bigquery(tables_to_copy, skipped_tables=[]) %}
+    {% set project_id = var('dbt-addons')['project_id'] %}
+    {% set prod_dataset = var('dbt-addons')['prod_dataset'] %}
+
+    {% set queries = [] %}
+    {% for item in tables_to_copy %}
+        {% set q %}
+            CREATE OR REPLACE TABLE `{{ project_id }}.{{ prod_dataset }}.{{ item.name }}` AS
+            SELECT * FROM {{ item.relation }}
+        {% endset %}
+        {% do queries.append(q) %}
+    {% endfor %}
+
+    {{ deploy_wap(tables_to_copy, skipped_tables, queries) }}
+{% endmacro %}

dbt_addons-0.1.0/addons/wap/macros/providers/wap_databricks.sql

@@ -0,0 +1,15 @@
+{% macro wap_deploy_databricks(tables_to_copy, skipped_tables=[]) %}
+    {% set catalog = var('dbt-addons')['catalog'] %}
+    {% set prod_schema = var('dbt-addons')['dbt_prod_schema'] %}
+
+    {% set queries = [] %}
+    {% for item in tables_to_copy %}
+        {% set q %}
+            CREATE OR REPLACE TABLE `{{ catalog }}`.`{{ prod_schema }}`.`{{ item.name }}`
+            SHALLOW CLONE {{ item.relation }}
+        {% endset %}
+        {% do queries.append(q) %}
+    {% endfor %}
+
+    {{ deploy_wap(tables_to_copy, skipped_tables, queries) }}
+{% endmacro %}

dbt_addons-0.1.0/addons/wap/macros/providers/wap_duckdb.sql

@@ -0,0 +1,17 @@
+{% macro wap_deploy_duckdb(tables_to_copy, skipped_tables=[]) %}
+    {% set prod_schema = var('dbt-addons')['dbt_prod_schema'] %}
+
+    {% do run_query("CREATE SCHEMA IF NOT EXISTS " ~ prod_schema) %}
+    {% do log("", info=true) %}
+
+    {% set queries = [] %}
+    {% for item in tables_to_copy %}
+        {% set q %}
+            CREATE OR REPLACE TABLE {{ prod_schema }}.{{ item.name }} AS
+            SELECT * FROM {{ item.relation }}
+        {% endset %}
+        {% do queries.append(q) %}
+    {% endfor %}
+
+    {{ deploy_wap(tables_to_copy, skipped_tables, queries) }}
+{% endmacro %}

dbt_addons-0.1.0/addons/wap/macros/providers/wap_rename.sql

@@ -0,0 +1,68 @@
+{% macro wap_rename_snowflake(tables_to_copy, skipped_tables, suffix) %}
+    {% set queries = [] %}
+    {% for item in tables_to_copy %}
+        {% set staging_name = item.name ~ suffix %}
+        {% set target = item.relation
+            | replace(staging_name | upper, item.name | upper)
+            | replace(staging_name, item.name) %}
+        {% set q %}
+            CREATE OR REPLACE TABLE {{ target }} CLONE {{ item.relation }}
+        {% endset %}
+        {% do queries.append(q) %}
+    {% endfor %}
+
+    {{ deploy_wap(tables_to_copy, skipped_tables, queries) }}
+{% endmacro %}
+
+
+{% macro wap_rename_databricks(tables_to_copy, skipped_tables, suffix) %}
+    {% set queries = [] %}
+    {% for item in tables_to_copy %}
+        {% set staging_name = item.name ~ suffix %}
+        {% set target = item.relation
+            | replace(staging_name | upper, item.name | upper)
+            | replace(staging_name, item.name) %}
+        {% set q %}
+            CREATE OR REPLACE TABLE {{ target }} SHALLOW CLONE {{ item.relation }}
+        {% endset %}
+        {% do queries.append(q) %}
+    {% endfor %}
+
+    {{ deploy_wap(tables_to_copy, skipped_tables, queries) }}
+{% endmacro %}
+
+
+{% macro wap_rename_bigquery(tables_to_copy, skipped_tables, suffix) %}
+    {% set queries = [] %}
+    {% for item in tables_to_copy %}
+        {% set staging_name = item.name ~ suffix %}
+        {% set target = item.relation
+            | replace(staging_name | upper, item.name | upper)
+            | replace(staging_name, item.name) %}
+        {% set q %}
+            CREATE OR REPLACE TABLE {{ target }} AS
+            SELECT * FROM {{ item.relation }}
+        {% endset %}
+        {% do queries.append(q) %}
+    {% endfor %}
+
+    {{ deploy_wap(tables_to_copy, skipped_tables, queries) }}
+{% endmacro %}
+
+
+{% macro wap_rename_duckdb(tables_to_copy, skipped_tables, suffix) %}
+    {% set queries = [] %}
+    {% for item in tables_to_copy %}
+        {% set staging_name = item.name ~ suffix %}
+        {% set target = item.relation
+            | replace(staging_name | upper, item.name | upper)
+            | replace(staging_name, item.name) %}
+        {% set q %}
+            CREATE OR REPLACE TABLE {{ target }} AS
+            SELECT * FROM {{ item.relation }}
+        {% endset %}
+        {% do queries.append(q) %}
+    {% endfor %}
+
+    {{ deploy_wap(tables_to_copy, skipped_tables, queries) }}
+{% endmacro %}

dbt_addons-0.1.0/addons/wap/macros/providers/wap_snowflake.sql

@@ -0,0 +1,14 @@
+{% macro wap_deploy_snowflake(tables_to_copy, skipped_tables=[]) %}
+    {% set prod_schema = var('dbt-addons')['dbt_prod_schema'] %}
+
+    {% set queries = [] %}
+    {% for item in tables_to_copy %}
+        {% set q %}
+            CREATE OR REPLACE TABLE {{ prod_schema }}.{{ item.name }}
+            CLONE {{ item.relation }}
+        {% endset %}
+        {% do queries.append(q) %}
+    {% endfor %}
+
+    {{ deploy_wap(tables_to_copy, skipped_tables, queries) }}
+{% endmacro %}

dbt_addons-0.1.0/addons/wap/macros/wap_deploy.sql

@@ -0,0 +1,41 @@
+{% macro wap_deploy(tables_to_copy, skipped_tables=[]) %}
+  {% set provider = adapter.type() %}
+  {% set cfg = var('dbt-addons', {}) %}
+  {% set wap_staging_suffix = cfg.get('wap_staging_suffix') %}
+
+  {% if wap_staging_suffix %}
+    {# Rename mode: models built with suffix, promoted within the same schema #}
+    {% if provider == 'snowflake' %}
+      {{ wap_rename_snowflake(tables_to_copy, skipped_tables, wap_staging_suffix) }}
+    {% elif provider == 'bigquery' %}
+      {{ wap_rename_bigquery(tables_to_copy, skipped_tables, wap_staging_suffix) }}
+    {% elif provider == 'databricks' %}
+      {{ wap_rename_databricks(tables_to_copy, skipped_tables, wap_staging_suffix) }}
+    {% elif provider == 'duckdb' %}
+      {{ wap_rename_duckdb(tables_to_copy, skipped_tables, wap_staging_suffix) }}
+    {% else %}
+      {% do exceptions.raise_compiler_error("WAP rename mode not supported for provider: " ~ provider) %}
+    {% endif %}
+
+  {% else %}
+    {# Cross-schema mode: copy from staging schema to prod schema #}
+    {% if not all_required_variables_are_setup() %}
+      {% do exceptions.raise_compiler_error("All the variables needed for WAP are not setup.") %}
+    {% endif %}
+
+    {% if provider == 'snowflake' %}
+      {{ wap_deploy_snowflake(tables_to_copy) }}
+    {% elif provider == 'bigquery' %}
+      {{ wap_deploy_bigquery(tables_to_copy) }}
+    {% elif provider == 'databricks' %}
+      {{ wap_deploy_databricks(tables_to_copy) }}
+    {% elif provider == 'duckdb' %}
+      {{ wap_deploy_duckdb(tables_to_copy, skipped_tables) }}
+    {% else %}
+      {% do log("WAP not supported for provider: " ~ provider, info=true) %}
+      {% do exceptions.raise_compiler_error("Unsupported provider for WAP") %}
+    {% endif %}
+
+  {% endif %}
+
+{% endmacro %}

dbt_addons-0.1.0/addons/wap/root_macros/generate_alias_name.sql

@@ -0,0 +1,8 @@
+{% macro generate_alias_name(custom_alias_name=none, node=none) -%}
+    {%- set suffix = var('dbt_wap_staging_suffix', '') if node.resource_type == 'model' else '' -%}
+    {%- if custom_alias_name is none -%}
+        {{ node.name }}{{ suffix }}
+    {%- else -%}
+        {{ custom_alias_name }}{{ suffix }}
+    {%- endif -%}
+{%- endmacro %}

dbt_addons-0.1.0/addons/wap/root_macros/generate_schema_name.sql

@@ -0,0 +1,7 @@
+{% macro generate_schema_name(custom_schema_name, node) -%}
+    {%- if custom_schema_name is none -%}
+        {{ target.schema }}
+    {%- else -%}
+        {{ custom_schema_name | trim }}
+    {%- endif -%}
+{%- endmacro %}

dbt_addons-0.1.0/addons/wap/wap.py

@@ -0,0 +1,104 @@
+import json
+import fnmatch
+from pathlib import Path
+from typing import List, Optional
+
+import yaml
+
+
+def read_wap_config() -> dict:
+    project_path = Path('dbt_project.yml')
+    if not project_path.exists():
+        return {}
+    with open(project_path) as f:
+        project = yaml.safe_load(f)
+    return project.get('vars', {}).get('dbt-addons', {})
+
+
+def _matches_wap_paths(model_path: str, wap_paths: List[str]) -> bool:
+    """Return True if model_path (e.g. 'marts/fct_customers.sql') matches any pattern."""
+    for pattern in wap_paths:
+        norm = pattern.rstrip('/')
+        # Folder prefix: 'marts' matches 'marts/fct_customers.sql'
+        if model_path.startswith(norm + '/') or model_path == norm:
+            return True
+        # Glob pattern: 'marts/*.sql' or 'core/fct_*'
+        if fnmatch.fnmatch(model_path, pattern):
+            return True
+    return False
+
+
+def get_executed_tables() -> List[str]:
+    """Extract successfully built models whose tests all passed from run_results.json."""
+    run_results_path = Path('target/run_results.json')
+    manifest_path = Path('target/manifest.json')
+
+    if not run_results_path.exists():
+        return [], []
+
+    with open(run_results_path) as f:
+        run_results = json.load(f)
+
+    results = run_results.get('results', [])
+
+    manifest = {}
+    if manifest_path.exists():
+        with open(manifest_path) as f:
+            manifest = json.load(f)
+
+    wap_config = read_wap_config()
+    wap_paths: Optional[List[str]] = wap_config.get('wap_paths')  # None = all models
+
+    # Find models blocked by a failing test via manifest dependency graph
+    failed_model_ids: set = set()
+    for result in results:
+        if result.get('status') not in ('fail', 'error'):
+            continue
+        uid = result.get('unique_id', '')
+        if not uid.startswith('test.'):
+            continue
+        test_node = manifest.get('nodes', {}).get(uid, {})
+        for dep in test_node.get('depends_on', {}).get('nodes', []):
+            if dep.startswith('model.'):
+                failed_model_ids.add(dep)
+
+    promoted = []
+    skipped = []
+    for result in results:
+        if result.get('status') != 'success':
+            continue
+        uid = result.get('unique_id', '')
+        if not uid.startswith('model.'):
+            continue
+
+        node = manifest.get('nodes', {}).get(uid, {})
+
+        if wap_paths is not None:
+            model_path = node.get('path', '')
+            if not _matches_wap_paths(model_path, wap_paths):
+                continue
+
+        table_name = uid.split('.')[-1]
+        if uid in failed_model_ids:
+            skipped.append(table_name)
+            continue
+        relation_name = result.get('relation_name')
+        if relation_name:
+            promoted.append({"name": table_name, "relation": relation_name})
+
+    return sorted(promoted, key=lambda t: t["name"]), sorted(skipped)
+
+
+
+def run_with_wap(args: List[str]) -> int:
+    """Run dbt run with WAP deployment."""
+    import subprocess
+    
+    return subprocess.run(['dbt', 'run'] + args).returncode
+
+
+def build_with_wap(args: List[str]) -> int:
+    """Run dbt build with WAP deployment."""
+    import subprocess
+    
+    return subprocess.run(['dbt', 'build'] + args).returncode

dbt_addons-0.1.0/dbt_addons.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: dbt-addons
+Version: 0.1.0
+Requires-Python: >=3.8
+Requires-Dist: dbt-core>=1.5.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: dbt-duckdb>=1.5.0; extra == "dev"
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python

dbt_addons-0.1.0/dbt_addons.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+setup.py
+addons/__init__.py
+addons/install.py
+addons/cli/__init__.py
+addons/cli/cli.py
+addons/cli/logger.py
+addons/wap/__init__.py
+addons/wap/wap.py
+addons/wap/macros/wap_deploy.sql
+addons/wap/macros/providers/utils.sql
+addons/wap/macros/providers/wap_bigquery.sql
+addons/wap/macros/providers/wap_databricks.sql
+addons/wap/macros/providers/wap_duckdb.sql
+addons/wap/macros/providers/wap_rename.sql
+addons/wap/macros/providers/wap_snowflake.sql
+addons/wap/root_macros/generate_alias_name.sql
+addons/wap/root_macros/generate_schema_name.sql
+dbt_addons.egg-info/PKG-INFO
+dbt_addons.egg-info/SOURCES.txt
+dbt_addons.egg-info/dependency_links.txt
+dbt_addons.egg-info/entry_points.txt
+dbt_addons.egg-info/requires.txt
+dbt_addons.egg-info/top_level.txt

dbt_addons-0.1.0/dbt_addons.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dbt_addons-0.1.0/dbt_addons.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dbta = addons.cli.cli:main

dbt_addons-0.1.0/dbt_addons.egg-info/requires.txt

@@ -0,0 +1,5 @@
+dbt-core>=1.5.0
+pyyaml>=6.0
+
+[dev]
+dbt-duckdb>=1.5.0

dbt_addons-0.1.0/dbt_addons.egg-info/top_level.txt

@@ -0,0 +1 @@
+addons

dbt_addons-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dbt_addons-0.1.0/setup.py

@@ -0,0 +1,29 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="dbt-addons",
+    version="0.1.0",
+    packages=find_packages(),
+    package_data={
+        "addons": [
+            "wap/macros/**/*.sql",
+            "wap/macros/*.sql",
+            "wap/root_macros/*.sql",
+        ],
+    },
+    install_requires=[
+        "dbt-core>=1.5.0",
+        "pyyaml>=6.0",
+    ],
+    extras_require={
+        "dev": [
+            "dbt-duckdb>=1.5.0",
+        ],
+    },
+    entry_points={
+        "console_scripts": [
+            "dbta=addons.cli.cli:main",
+        ],
+    },
+    python_requires=">=3.8",
+)