taldbt 0.2.0__tar.gz

taldbt-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Sourav Roy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

taldbt-0.2.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include README.md
+include LICENSE
+recursive-include taldbt/templates *.sql *.yml *.yaml
+recursive-include taldbt/expert *.json
+recursive-include taldbt/ui *.css *.svg *.html *.py

taldbt-0.2.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: taldbt
+Version: 0.2.0
+Summary: AI-powered Talend to dbt migration. $0 cost. No infrastructure. One click.
+Author-email: Sourav Roy <souravroy.etl@gmail.com>
+License: MIT
+Project-URL: Homepage, https://taldbt.netlify.app
+Project-URL: Documentation, https://taldbt.netlify.app
+Project-URL: Demo, https://taldbt.streamlit.app
+Project-URL: Docker, https://hub.docker.com/r/souravetl/taldbt
+Project-URL: Issues, https://github.com/SouravRoy-ETL/taldbt/issues
+Keywords: talend,dbt,migration,etl,data-engineering,duckdb,temporal,ai,llm,sql
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lxml>=5.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: duckdb>=1.0
+Requires-Dist: jinja2>=3.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0
+Requires-Dist: requests>=2.31
+Requires-Dist: dbt-core>=1.7
+Requires-Dist: dbt-duckdb>=1.7
+Requires-Dist: sqlglot>=25.0
+Requires-Dist: faker>=28.0
+Provides-Extra: ui
+Requires-Dist: streamlit>=1.30; extra == "ui"
+Provides-Extra: temporal
+Requires-Dist: temporalio>=1.7; extra == "temporal"
+Provides-Extra: all
+Requires-Dist: streamlit>=1.30; extra == "all"
+Requires-Dist: temporalio>=1.7; extra == "all"
+Dynamic: license-file
+
+# taldbt — AI Powered Talend to dbt Migration
+
+Convert legacy Talend ETL to modern dbt SQL using semantic AI transpilation.
+
+**Product Page:** https://taldbt.netlify.app
+**Live Demo:** https://taldbt.streamlit.app
+**Docker Image:** `docker pull souravetl/taldbt:latest`
+
+## Quick Start
+
+### Docker (recommended)
+```bash
+docker pull souravetl/taldbt:latest
+docker pull ollama/ollama:latest
+docker compose up -d
+docker exec taldbt-ollama ollama pull qwen3-coder:30b
+# Open http://localhost:8501
+```
+
+### Cloud (no install)
+Upload your Talend ZIP at https://taldbt.streamlit.app
+
+### Local Development
+```bash
+pip install -r requirements.txt
+streamlit run taldbt/ui/app.py
+```
+
+## Tech Stack
+
+| Component | Purpose |
+|-----------|---------|
+| DuckDB + Flock | In-process analytics + LLM-in-SQL validation |
+| dbt-core | SQL transformation framework |
+| Temporal.io | DAG-aware workflow orchestration |
+| Ollama / Cerebras / Groq | AI translation (local or cloud) |
+| sqlglot | Multi-dialect SQL transpilation |
+| Faker | Synthetic test data with FK integrity |
+| networkx | Dependency graph + topological sort |
+| lxml + Pydantic | XML parsing + type-safe AST |
+
+## Project Structure
+
+```
+taldbt/
+├── Dockerfile              # Tier 1: Docker image
+├── docker-compose.yml      # Tier 1: full stack
+├── docker-compose.cpu.yml  # Tier 1: no-GPU override
+├── docker/entrypoint.sh    # Docker startup script
+├── requirements.txt        # Python dependencies
+├── packages.txt            # Tier 3: apt deps (Streamlit Cloud)
+├── .streamlit/             # Streamlit config + secrets
+├── dist/                   # Air-gapped distribution package
+├── docs/                   # Architecture + knowledge transfer
+├── main.py                 # CLI entry point
+└── taldbt/                 # Core application
+    ├── ui/                 # Streamlit web app
+    ├── parsers/            # XML parsing + component parsers
+    ├── codegen/            # SQL generation + dbt scaffolding
+    ├── engine/             # DuckDB + validation + test data
+    ├── expert/             # Component knowledge base
+    ├── graphing/           # DAG builder + data lineage
+    ├── llm/                # LLM provider chain
+    ├── models/             # Pydantic AST models
+    ├── orchestration/      # Temporal + AutoPilot
+    └── tests/              # Test suite
+```
+
+## Deployment Tiers
+
+- **Tier 1 (Docker):** `docker compose up -d` — Ollama + Temporal + UI
+- **Tier 3 (Cloud):** Streamlit Cloud + Cerebras/Groq AI — no local install
+
+## License
+
+Proprietary. Contact souravroy.etl@gmail.com for licensing.
+
+---
+Made with care by Sourav Roy

taldbt-0.2.0/README.md

@@ -0,0 +1,79 @@
+# taldbt — AI Powered Talend to dbt Migration
+
+Convert legacy Talend ETL to modern dbt SQL using semantic AI transpilation.
+
+**Product Page:** https://taldbt.netlify.app
+**Live Demo:** https://taldbt.streamlit.app
+**Docker Image:** `docker pull souravetl/taldbt:latest`
+
+## Quick Start
+
+### Docker (recommended)
+```bash
+docker pull souravetl/taldbt:latest
+docker pull ollama/ollama:latest
+docker compose up -d
+docker exec taldbt-ollama ollama pull qwen3-coder:30b
+# Open http://localhost:8501
+```
+
+### Cloud (no install)
+Upload your Talend ZIP at https://taldbt.streamlit.app
+
+### Local Development
+```bash
+pip install -r requirements.txt
+streamlit run taldbt/ui/app.py
+```
+
+## Tech Stack
+
+| Component | Purpose |
+|-----------|---------|
+| DuckDB + Flock | In-process analytics + LLM-in-SQL validation |
+| dbt-core | SQL transformation framework |
+| Temporal.io | DAG-aware workflow orchestration |
+| Ollama / Cerebras / Groq | AI translation (local or cloud) |
+| sqlglot | Multi-dialect SQL transpilation |
+| Faker | Synthetic test data with FK integrity |
+| networkx | Dependency graph + topological sort |
+| lxml + Pydantic | XML parsing + type-safe AST |
+
+## Project Structure
+
+```
+taldbt/
+├── Dockerfile              # Tier 1: Docker image
+├── docker-compose.yml      # Tier 1: full stack
+├── docker-compose.cpu.yml  # Tier 1: no-GPU override
+├── docker/entrypoint.sh    # Docker startup script
+├── requirements.txt        # Python dependencies
+├── packages.txt            # Tier 3: apt deps (Streamlit Cloud)
+├── .streamlit/             # Streamlit config + secrets
+├── dist/                   # Air-gapped distribution package
+├── docs/                   # Architecture + knowledge transfer
+├── main.py                 # CLI entry point
+└── taldbt/                 # Core application
+    ├── ui/                 # Streamlit web app
+    ├── parsers/            # XML parsing + component parsers
+    ├── codegen/            # SQL generation + dbt scaffolding
+    ├── engine/             # DuckDB + validation + test data
+    ├── expert/             # Component knowledge base
+    ├── graphing/           # DAG builder + data lineage
+    ├── llm/                # LLM provider chain
+    ├── models/             # Pydantic AST models
+    ├── orchestration/      # Temporal + AutoPilot
+    └── tests/              # Test suite
+```
+
+## Deployment Tiers
+
+- **Tier 1 (Docker):** `docker compose up -d` — Ollama + Temporal + UI
+- **Tier 3 (Cloud):** Streamlit Cloud + Cerebras/Groq AI — no local install
+
+## License
+
+Proprietary. Contact souravroy.etl@gmail.com for licensing.
+
+---
+Made with care by Sourav Roy

taldbt-0.2.0/pyproject.toml

@@ -0,0 +1,74 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "taldbt"
+version = "0.2.0"
+description = "AI-powered Talend to dbt migration. $0 cost. No infrastructure. One click."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [
+    {name = "Sourav Roy", email = "souravroy.etl@gmail.com"}
+]
+keywords = [
+    "talend", "dbt", "migration", "etl", "data-engineering",
+    "duckdb", "temporal", "ai", "llm", "sql"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Topic :: Database",
+    "Topic :: Software Development :: Code Generators",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "lxml>=5.0",
+    "networkx>=3.0",
+    "pydantic>=2.0",
+    "duckdb>=1.0",
+    "jinja2>=3.0",
+    "pyyaml>=6.0",
+    "rich>=13.0",
+    "requests>=2.31",
+    "dbt-core>=1.7",
+    "dbt-duckdb>=1.7",
+    "sqlglot>=25.0",
+    "faker>=28.0",
+]
+
+[project.optional-dependencies]
+ui = ["streamlit>=1.30"]
+temporal = ["temporalio>=1.7"]
+all = ["streamlit>=1.30", "temporalio>=1.7"]
+
+[project.urls]
+Homepage = "https://taldbt.netlify.app"
+Documentation = "https://taldbt.netlify.app"
+Demo = "https://taldbt.streamlit.app"
+Docker = "https://hub.docker.com/r/souravetl/taldbt"
+Issues = "https://github.com/SouravRoy-ETL/taldbt/issues"
+
+[project.scripts]
+taldbt = "taldbt.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["taldbt*"]
+
+[tool.setuptools.package-data]
+taldbt = [
+    "templates/**/*.sql",
+    "templates/**/*.yml",
+    "templates/**/*.yaml",
+    "expert/**/*.json",
+    "ui/**/*.css",
+    "ui/**/*.svg",
+    "ui/**/*.html",
+]

taldbt-0.2.0/setup.cfg

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

taldbt-0.2.0/taldbt/__init__.py

@@ -0,0 +1,3 @@
+"""taldbt - AI Powered Talend to dbt Migration"""
+__version__ = "0.2.0"
+__author__ = "Sourav Roy"

taldbt-0.2.0/taldbt/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running taldbt as: python -m taldbt"""
+from taldbt.cli import main
+
+if __name__ == "__main__":
+    main()

taldbt-0.2.0/taldbt/cli.py

@@ -0,0 +1,144 @@
+"""
+taldbt CLI — entry point for `pip install taldbt`
+
+Usage:
+    taldbt ui                           # Launch Streamlit web UI
+    taldbt discover <talend_dir>        # Scan and analyze a Talend project
+    taldbt migrate <talend_dir> <out>   # Full migration to dbt
+    taldbt version                      # Print version
+"""
+import sys
+import os
+
+
+def main():
+    args = sys.argv[1:]
+
+    if not args or args[0] in ("-h", "--help", "help"):
+        _print_help()
+        return
+
+    if args[0] in ("version", "--version", "-v"):
+        from taldbt import __version__
+        print(f"taldbt v{__version__}")
+        return
+
+    if args[0] == "ui":
+        _launch_ui()
+        return
+
+    if args[0] == "discover" and len(args) >= 2:
+        _discover(args[1], args[2] if len(args) > 2 else "migration_plan.json")
+        return
+
+    if args[0] == "migrate" and len(args) >= 3:
+        _migrate(args[1], args[2])
+        return
+
+    print(f"Unknown command: {args[0]}")
+    _print_help()
+    sys.exit(1)
+
+
+def _print_help():
+    from taldbt import __version__
+    print(f"""
+taldbt v{__version__} — AI Powered Talend to dbt Migration
+
+Usage:
+    taldbt ui                              Launch the web UI
+    taldbt discover <talend_dir> [output]  Scan & analyze a Talend project
+    taldbt migrate <talend_dir> <out_dir>  Full migration to dbt
+    taldbt version                         Print version
+
+Examples:
+    taldbt ui
+    taldbt discover ./my_talend_project
+    taldbt migrate ./my_talend_project ./dbt_output
+
+More info: https://taldbt.netlify.app
+    """.strip())
+
+
+def _launch_ui():
+    try:
+        import streamlit
+    except ImportError:
+        print("Streamlit not installed. Run: pip install taldbt[ui]")
+        sys.exit(1)
+
+    ui_path = os.path.join(os.path.dirname(__file__), "ui", "app.py")
+    os.system(f"streamlit run {ui_path}")
+
+
+def _discover(input_path, out_path):
+    from taldbt.parsers.project_scanner import scan_project
+    from taldbt.parsers.xml_parser import parse_job
+    from taldbt.models.ast_models import ProjectAST, JobType
+    from taldbt.graphing.dag_builder import apply_dag_to_project
+    import json
+
+    print(f"[taldbt] Scanning {input_path}...")
+
+    scan = scan_project(input_path)
+    project = ProjectAST(
+        project_name=os.path.basename(input_path),
+        input_path=input_path,
+    )
+
+    for entry in scan["process_jobs"]:
+        job = parse_job(entry["path"], entry["name"])
+        project.jobs[entry["name"]] = job
+
+    for entry in scan.get("joblets", []):
+        job = parse_job(entry["path"], entry["name"], JobType.JOBLET)
+        project.joblets[entry["name"]] = job
+
+    apply_dag_to_project(project)
+
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(project.model_dump(), f, indent=2, default=str)
+
+    n_jobs = len(project.jobs)
+    n_src = sum(len(j.sources) for j in project.jobs.values())
+    n_comp = sum(len(j.components) for j in project.jobs.values())
+    print(f"[taldbt] {n_jobs} jobs, {n_src} sources, {n_comp} components")
+    print(f"[taldbt] Discovery complete -> {out_path}")
+
+
+def _migrate(input_path, output_path):
+    from taldbt.parsers.project_scanner import scan_project
+    from taldbt.parsers.xml_parser import parse_job
+    from taldbt.models.ast_models import ProjectAST
+    from taldbt.graphing.dag_builder import apply_dag_to_project
+    from taldbt.codegen.model_assembler import assemble_model
+    from taldbt.codegen.dbt_scaffolder import scaffold_dbt_project, write_model_file
+
+    print(f"[taldbt] Migrating {input_path} -> {output_path}")
+
+    scan = scan_project(input_path)
+    project = ProjectAST(
+        project_name=os.path.basename(input_path),
+        input_path=input_path,
+    )
+
+    for entry in scan["process_jobs"]:
+        job = parse_job(entry["path"], entry["name"])
+        project.jobs[entry["name"]] = job
+
+    apply_dag_to_project(project)
+    scaffold_dbt_project(project, output_path)
+
+    generated = 0
+    for name, job in project.jobs.items():
+        sql = assemble_model(job)
+        if sql:
+            write_model_file(sql, name, output_path)
+            generated += 1
+            print(f"  [ok] {name}")
+
+    print(f"[taldbt] Done. {generated} models generated in {output_path}")
+
+
+if __name__ == "__main__":
+    main()

taldbt-0.2.0/taldbt/codegen/dbt_scaffolder.py

@@ -0,0 +1,200 @@
+"""
+dbt Project Scaffolder: generates dbt_project.yml, profiles.yml, sources.yml,
+schema.yml, and the folder structure for the output dbt project.
+"""
+from __future__ import annotations
+import os
+import re
+from pathlib import Path
+import yaml
+from taldbt.models.ast_models import ProjectAST, JobAST, SourceInfo, ColumnSchema
+
+
+def scaffold_dbt_project(project: ProjectAST, output_dir: str):
+    """Generate a complete dbt project structure from the parsed Talend project."""
+    os.makedirs(output_dir, exist_ok=True)
+    os.makedirs(os.path.join(output_dir, "models", "staging"), exist_ok=True)
+    os.makedirs(os.path.join(output_dir, "models", "intermediate"), exist_ok=True)
+    os.makedirs(os.path.join(output_dir, "models", "marts"), exist_ok=True)
+    os.makedirs(os.path.join(output_dir, "macros"), exist_ok=True)
+    os.makedirs(os.path.join(output_dir, "tests"), exist_ok=True)
+    os.makedirs(os.path.join(output_dir, "seeds"), exist_ok=True)
+
+    _write_dbt_project_yml(project, output_dir)
+    _write_profiles_yml(project, output_dir)
+    _write_sources_yml(project, output_dir)
+    _write_schema_yml(project, output_dir)
+
+
+def _write_dbt_project_yml(project: ProjectAST, output_dir: str):
+    name = project.project_name.replace("-", "_").replace(" ", "_").lower() or "taldbt_project"
+    config = {
+        "name": name,
+        "version": "1.0.0",
+        "config-version": 2,
+        "profile": name,
+        "model-paths": ["models"],
+        "test-paths": ["tests"],
+        "macro-paths": ["macros"],
+        "seed-paths": ["seeds"],
+        "models": {
+            name: {
+                "staging": {"materialized": "view"},
+                "intermediate": {"materialized": "view"},
+                "marts": {"materialized": "table"},
+            }
+        },
+    }
+
+    # Add context variables as dbt vars
+    all_vars = {}
+    for ctx_name, ctx_vars in project.contexts.items():
+        all_vars.update(ctx_vars)
+    if all_vars:
+        config["vars"] = all_vars
+
+    path = os.path.join(output_dir, "dbt_project.yml")
+    with open(path, "w", encoding="utf-8") as f:
+        f.write("# Generated by taldbt - Talend to dbt migration tool\n\n")
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+
+def _write_profiles_yml(project: ProjectAST, output_dir: str):
+    name = project.project_name.replace("-", "_").replace(" ", "_").lower() or "taldbt_project"
+    # Use absolute paths so dbt always finds the right DuckDB file
+    dev_db = os.path.join(output_dir, "dev.duckdb").replace("\\", "/")
+    prod_db = os.path.join(output_dir, "prod.duckdb").replace("\\", "/")
+
+    profile = {
+        name: {
+            "target": "dev",
+            "outputs": {
+                "dev": {
+                    "type": "duckdb",
+                    "path": dev_db,
+                    "threads": 4,
+                },
+                "prod": {
+                    "type": "duckdb",
+                    "path": prod_db,
+                    "threads": 8,
+                },
+            },
+        },
+    }
+
+    path = os.path.join(output_dir, "profiles.yml")
+    with open(path, "w", encoding="utf-8") as f:
+        f.write("# Generated by taldbt\n")
+        f.write("# Change 'type: duckdb' to snowflake/bigquery/etc for production\n\n")
+        yaml.dump(profile, f, default_flow_style=False, sort_keys=False)
+
+
+def _write_sources_yml(project: ProjectAST, output_dir: str):
+    """Generate sources.yml from the discovered source catalog."""
+    if not project.source_catalog:
+        return
+
+    # Group sources by database
+    by_db: dict[str, list[SourceInfo]] = {}
+    for sid, src in project.source_catalog.items():
+        db = "raw"
+        if src.connection and src.connection.database:
+            db = src.connection.database.replace('"', '').replace("'", "")
+        by_db.setdefault(db, []).append(src)
+
+    sources = []
+    for db_name, src_list in by_db.items():
+        tables = []
+        for src in src_list:
+            tbl_name = src.connection.table.replace('"', '').replace("'", "") if src.connection else src.source_id
+            table_entry = {"name": tbl_name}
+
+            # Add column definitions if available
+            if src.columns:
+                table_entry["columns"] = [
+                    {"name": c.name, "description": c.comment or ""}
+                    for c in src.columns
+                ]
+            tables.append(table_entry)
+
+        sources.append({
+            "name": db_name.replace("-", "_").replace(".", "_"),
+            "tables": tables,
+        })
+
+    config = {"version": 2, "sources": sources}
+    path = os.path.join(output_dir, "models", "sources.yml")
+    with open(path, "w", encoding="utf-8") as f:
+        f.write("# Generated by taldbt from Talend source metadata\n\n")
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+
+def _write_schema_yml(project: ProjectAST, output_dir: str):
+    """Generate schema.yml with model definitions and basic tests."""
+    models = []
+    for name, job in project.jobs.items():
+        if job.job_type.value == "ORCHESTRATION":
+            continue
+
+        model_entry = {
+            "name": _model_name(name),
+            "description": f"Migrated from Talend job: {name}",
+        }
+
+        # Add column tests from output schemas (deduplicated)
+        columns = []
+        seen_col_names = set()
+        for comp in job.components.values():
+            if comp.behavior.value == "DATA_SINK" and comp.schemas:
+                # Use FLOW connector only, skip REJECT
+                flow_cols = comp.schemas.get("FLOW", [])
+                if not flow_cols:
+                    # Fallback: use first non-REJECT connector
+                    for conn_name, cols in comp.schemas.items():
+                        if conn_name != "REJECT":
+                            flow_cols = cols
+                            break
+                for col in flow_cols:
+                    if col.name.lower() in seen_col_names or not col.name:
+                        continue
+                    seen_col_names.add(col.name.lower())
+                    col_entry = {"name": col.name}
+                    tests = []
+                    if col.is_key:
+                        tests.extend(["not_null", "unique"])
+                    elif not col.nullable:
+                        tests.append("not_null")
+                    if tests:
+                        col_entry["tests"] = tests
+                    columns.append(col_entry)
+                break  # only use first DATA_SINK component
+
+        if columns:
+            model_entry["columns"] = columns
+        models.append(model_entry)
+
+    if models:
+        config = {"version": 2, "models": models}
+        path = os.path.join(output_dir, "models", "schema.yml")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write("# Generated by taldbt\n\n")
+            yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+
+def _model_name(job_name: str) -> str:
+    """Convert Talend job name to a clean dbt model name."""
+    name = job_name.replace(" ", "_").lower()
+    # Remove version suffix: _0.1, _1.0
+    import re
+    name = re.sub(r'_\d+\.\d+$', '', name)
+    return name
+
+
+def write_model_file(sql: str, job_name: str, output_dir: str, subfolder: str = "marts") -> str:
+    """Write a generated SQL model to the dbt project."""
+    model_name = _model_name(job_name)
+    out = Path(output_dir) / "models" / subfolder / f"{model_name}.sql"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(sql, encoding="utf-8")
+    return str(out)