Update text

text

@@ -1,571 +1,248 @@
-# app/cleaning/prompts.py
-from __future__ import annotations
-
-from textwrap import dedent
-from typing import Dict, Iterable, List, Optional, Set, Tuple
-
+import json
+from typing import Dict, List, Optional
+import sys
+from sqlalchemy import text
+from sqlalchemy.engine import Result
+from app.db import engine
 from app.config import settings
+from app.cleaning.prompts import CLEAN_PROMPT
+from app.cleaning.llm import LLM
 
 
-DEFAULT_ALLOWED_TABLES: Tuple[str, ...] = (
-    # "test_products", ## sample table for navin testing
-    "tblModelDetails",
-    "tblDimensionInfo",
-    "tblInstances",
-    "tblModelBoundingBox",
-    "tblModelCheckerResults",
-    "tblModelDetailsHub",
-    "tblModelFloorPlanMapping",
-    "tblModels",
-    "tblNWCViewExport",
-    "tblTypes",
-    "tblProjects",
-    "tblProjectSubTypes",
-    "tblRFISubType",
-    "tblViews",
-    "tblUsers",
-    "tblWorkflowStatuses",
-    "tblCategory",
-    "tblAssembly",
-    "tblElements",
-    "tblMaterials",
-    "tblModelRoomDetails",
-    "tblGeometryDataNew",
-    "tblGeometryDataBatchMapping",
-)
-
-RELATIONSHIP_SUMMARY = dedent("""\
-# Relational Structure Summary
-
-tblModelDetails ← (central entity)
-    ↑ tblDimensionInfo.ModelID
-    ↑ tblInstances.ModelID
-    ↑ tblModelBoundingBox.ModelID
-    ↑ tblModelCheckerResults.ModelID
-    ↑ tblModelDetailsHub.ModelID
-    ↑ tblModelFloorPlanMapping.ModelID
-    ↑ tblModels.ModelID
-    ↑ tblNWCViewExport.ModelID
-    ↑ tblTypes.ModelID
-
-tblProjects ← referenced by:
-    tblModelDetails.ProjectID
-    tblTypes.ProjectID
-
-tblTypes ← referenced by:
-    tblInstances.TypeID / RFITypeID / ProjectTypeID
-    tblProjectSubTypes.TypeID / RFITypeID / ProjectTypeID
-    tblRFISubType.TypeID / RFITypeID / ProjectTypeID
-
-tblViews ← referenced by:
-    tblModelBoundingBox.ViewID
-
-tblUsers ← referenced by:
-    tblModelDetails.ExportedBy
-
-tblWorkflowStatuses ← referenced by:
-    tblModelDetails.StatusID
-
-tblCategory ← referenced by:
-    tblTypes.CategoryID
-""")
-
-# -------------------------------
-#  Cleaning prompt (for culprit columns)
-# -------------------------------
-CLEAN_PROMPT = dedent("""\
-    You are cleaning noisy product/part names into a canonical short form.
-
-    Rules:
-    - Normalize inch units: 4", 4 inch, 4 in -> "4 in".
-    - Fix obvious misspellings: "elbw" -> "elbow".
-    - Remove opaque trailing codes like "-rr20" unless essential to identity.
-    - Keep it compact and human-readable.
-    - Return ONLY the cleaned text. No quotes, no explanations.
-""")
-
-
-# -------------------------------
-#  SQL generation (system prompt)
-# -------------------------------
-SQL_PROMPT_SYSTEM = dedent("""\
-    You are an expert Postgres SQL generator.
-
-    CONTEXT
-    - All tables are in the `public` schema of the `TransactionalData` database.
-    - The `public` schema already contains cleaned columns (e.g., *_clean).
-    - Use only the tables and columns that exist in `public`.
-    - You MUST restrict yourself to only the tables/relations that appear in the relational summary
-      provided in the user message. Do not invent tables or columns.
-
-    OUTPUT
-    - Return a single SELECT statement only (no CTEs across multiple statements, no DDL/DML).
-    - Qualify identifiers when needed using the `public.` schema.
-    - Avoid vendor-specific functions beyond standard Postgres.
-    - If units appear, assume inches unless the column clearly uses *_mm.
-
-    JOINING & FILTERING
-    - Use only joins that are consistent with the relational summary (respect directionality).
-    - When matching human-entered part names/sizes:
-        * Prefer cleaned columns (e.g., name_clean, title_clean) when they exist.
-        * Otherwise use ILIKE with robust patterns and simple normalization
-          (e.g., replace double quotes with " in).
-    - Limit columns to those that answer the question clearly.
-
-    IF UNSURE
-    - If the schema lacks a required join path, prefer a simpler query over a wrong join.
-    - You may add safe assumptions in comments inside the SQL (using --) but DO NOT return prose.
-""")
-
-
-
-# -------------------------------
-#  Catalog-aware prompt (default for sql_gen)
-# -------------------------------
-def sql_user_prompt(
-    question: str,
-    catalog_snapshot: Iterable[Dict[str, str]],
-    allowed_tables: Iterable[str] = DEFAULT_ALLOWED_TABLES,
-) -> str:
-    allowed = list(dict.fromkeys(allowed_tables))
-
-    # The source and target schema are the same now.
-    target_schema = settings.POSTGRES_SOURCE_SCHEMAS
-
-    column_map: Dict[str, Dict[str, Set[str]]] = {}
-    for row in catalog_snapshot:
-        row_data = row if isinstance(row, dict) else dict(row)
-        schema = row_data.get("table_schema")
-        table = row_data.get("table_name")
-        column = row_data.get("column_name")
-        if not schema or not table or not column:
-            continue
-        if table not in allowed:
-            continue
-        column_map.setdefault(schema, {}).setdefault(table, set()).add(column)
-
-    def render_columns(schema: str) -> List[str]:
-        lines: List[str] = []
-        tables = column_map.get(schema)
-        if not tables:
-            return lines
-        lines.append(f"{schema}:")
-        for table in allowed:
-            cols = tables.get(table)
-            if not cols:
-                continue
-            lines.append(f"  {table}:")
-            for col in sorted(cols):
-                lines.append(f"    - {col}")
-        lines.append("")
-        return lines
-
-    column_lines: List[str] = []
-    seen_schemas: Set[str] = set()
-
-    # Only one schema: public
-    for schema in [target_schema]:
-        if schema in seen_schemas:
-            continue
-        seen_schemas.add(schema)
-        column_lines.extend(render_columns(schema))
-
-    if not column_lines:
-        columns_block = "(no columns discovered for the curated tables)"
-    else:
-        columns_block = "\n".join(column_lines).rstrip()
-
-    relationship_block = RELATIONSHIP_SUMMARY.strip()
-
-    return dedent(f"""\
-        Question: {question}
-
-        Focus tables and columns (curated set):
-        {columns_block}
-
-        {relationship_block}
-
-        Guidance:
-        - Use tables only from the `public` schema.
-        - Prefer cleaned columns (e.g., *_clean) when they exist in `public`.
-        - Restrict joins to the relationships shown above; do not invent tables or links.
-        - Return ONE PostgreSQL SELECT statement (no modifications).
-    """)
-
-
-# -------------------------------
-#  Convenience: pack system + user together
-# -------------------------------
-def build_full_sql_prompt(
-    question: str,
-    allowed_tables: Iterable[str] = DEFAULT_ALLOWED_TABLES,
-    catalog_snapshot: Optional[Iterable[Dict[str, str]]] = None,
-) -> Dict[str, str]:
-    """
-    Returns {"system": SQL_PROMPT_SYSTEM, "user": <combined user text>}
-    """
-    if catalog_snapshot is None:
-        from app.db import get_catalog_snapshot  # local import to avoid cycles
-        catalog_snapshot = get_catalog_snapshot()
-
-    user = sql_user_prompt(
-        question=question,
-        catalog_snapshot=catalog_snapshot or [],
-        allowed_tables=allowed_tables,
-    )
-    return {"system": SQL_PROMPT_SYSTEM, "user": user}
+"""
+IN-PLACE CLEANING PIPELINE (Original Logic, No Mirroring)
+
+- Reads from SAME TABLE
+- Writes back into SAME TABLE
+- Adds <col>_clean columns if missing
+- Cleans only up to clean_cap rows (default 20)
+- Preserves original data completely
+- No target schema, no cloned tables, no mirroring
+"""
 
+MAX_ROWS_PER_TABLE = 20
 
 
+# ----------------------------------------------------
+# ADD <col>_clean columns into SAME TABLE
+# ----------------------------------------------------
+def ensure_clean_columns(schema: str, table: str, culprit_columns: List[str]):
+    if not culprit_columns:
+        return
 
+    with engine.begin() as cx:
+        for col in culprit_columns:
+            col_clean = f"{col}_clean"
+            sql = (
+                f'ALTER TABLE "{schema}"."{table}" '
+                f'ADD COLUMN IF NOT EXISTS "{col_clean}" TEXT'
+            )
+            cx.execute(text(sql))
+
+
+# ----------------------------------------------------
+# Count rows
+# ----------------------------------------------------
+def _count_source_rows(schema: str, table: str) -> int:
+    try:
+        with engine.begin() as cx:
+            row = cx.execute(
+                text(f'SELECT COUNT(*) FROM "{schema}"."{table}"')
+            ).first()
+            return int(row[0])
+    except Exception:
+        return -1
 
 
+# ----------------------------------------------------
+# Stream rows from SAME TABLE
+# ----------------------------------------------------
+def stream_rows(schema: str, table: str, batch_size=1000):
+    limit = ""
+    sql = f'SELECT * FROM "{schema}"."{table}"{limit}'
 
+    with engine.begin() as cx:
+        result: Result = (
+            cx.execution_options(stream_results=True)
+            .execute(text(sql))
+        )
 
+        batch = []
+        yielded = 0
 
+        for row in result.mappings():
+            batch.append(dict(row))
+            yielded += 1
 
+            if len(batch) >= batch_size:
+                yield batch
+                batch = []
 
+        if batch:
+            yield batch
 
 
+# ----------------------------------------------------
+# Write back INTO SAME TABLE
+# ----------------------------------------------------
+def write_batch(schema: str, table: str, rows: List[Dict], pk_col: str):
+    if not rows:
+        return
+    print(f"rows : {rows}")  
+    for r in rows:
+        # json encode dict/list so SQL can accept it
+        for k, v in list(r.items()):
+            if isinstance(v, (dict, list)):
+                r[k] = json.dumps(v)
 
-import re
-import sqlparse
-from sqlalchemy import text
-from app.db import engine, get_catalog_snapshot
-from app.cleaning.llm import LLM
-from app.cleaning.prompts import SQL_PROMPT_SYSTEM, sql_user_prompt
-from app.config import settings
-
-def is_safe_select(sql: str) -> bool:
-    parsed = sqlparse.parse(sql)
-    if not parsed:
-        return False
-    stmt = parsed[0]
-    if stmt.get_type() != "SELECT":
-        return False
-    # crude safeguards
-    forbidden = re.compile(r'\b(INSERT|UPDATE|DELETE|DROP|TRUNCATE|ALTER|CREATE|GRANT|REVOKE)\b', re.I)
-    return not forbidden.search(sql)
-
-def _quote_schema_identifiers(sql: str) -> str:
-    """Quote occurrences of <schema>.<identifier> where not already quoted.
-    This fixes case-sensitivity issues when the LLM emits MixedCase table names.
-    """
-    import re as _re
-    schema = settings.POSTGRES_SOURCE_SCHEMAS
-    # Quote occurrences like normalizeddata.tblTypes -> "normalizeddata"."tblTypes"
-    pat = _re.compile(rf'(?<!\")\b{_re.escape(schema)}\.(?!\")(\w+)', _re.IGNORECASE)
-    sql = pat.sub(lambda m: f'"{schema}"."{m.group(1)}"', sql)
-    # Also quote public.<identifier> forms
-    pat_pub = _re.compile(r'(?<!\")\bpublic\.(?!\")(\w+)', _re.IGNORECASE)
-    sql = pat_pub.sub(lambda m: f'"public"."{m.group(1)}"', sql)
-    return sql
-
-def _quote_alias_columns(sql: str) -> str:
-    """Quote occurrences of alias.column where column isn't already quoted or a wildcard.
-    Keeps alias as-is and wraps the column with quotes to preserve case.
-    """
-    import re as _re
-    # Skip cases like alias."Column" and alias.*
-    pat = _re.compile(r'\b([A-Za-z_][\w]*)\.(?!\")(\w+)')
-    reserved = {"public", settings.POSTGRES_SOURCE_SCHEMAS.lower(), "pg_catalog", "information_schema"}
-    def _repl(m: _re.Match[str]) -> str:
-        alias = m.group(1)
-        col = m.group(2)
-        if alias.lower() in reserved:
-            return m.group(0)
-        return f'{alias}."{col}"'
-    return pat.sub(_repl, sql)
-
-def nl_to_sql(question: str) -> str:
-    catalog = get_catalog_snapshot()
-    prompt = sql_user_prompt(question, catalog)
-    llm = LLM()
-    if not llm.enabled():
-        raise RuntimeError("LLM disabled: set LLM_PROVIDER in .env to enable NL→SQL.")
-    sql = llm.nl_to_sql(SQL_PROMPT_SYSTEM, prompt)
-    # strip code fences if any
-    sql = sql.strip().strip("`")
-    if sql.startswith("sql"):
-        sql = sql[3:].strip()
-    if "```" in sql:
-        sql = re.sub(r"```sql|```", "", sql, flags=re.I).strip()
-    # Quote schema identifiers to preserve MixedCase table names
-    sql = _quote_schema_identifiers(sql)
-    # Quote alias columns (e.g., e.ElementID -> e."ElementID")
-    sql = _quote_alias_columns(sql)
-    if not is_safe_select(sql):
-        raise ValueError("Generated SQL failed safety checks (SELECT-only required).")
-    return sql
-
-def run_sql(sql: str, limit: int = 200):
-    # enforce a hard cap to avoid huge result sets
-    sql_wrapped = f"SELECT * FROM ({sql}) AS sub LIMIT {limit}"
     with engine.begin() as cx:
-        rows = cx.execute(text(sql_wrapped)).mappings().all()
-    return [dict(r) for r in rows]
-
-
-
-
-
-
+        for r in rows:
+            pk_val = r[pk_col]
 
+            set_list = ", ".join(
+                f'"{c}" = :{c}' for c in r.keys() if c != pk_col
+            )
 
+            sql = (
+                f'UPDATE "{schema}"."{table}" '
+                f'SET {set_list} '
+                f'WHERE "{pk_col}" = :{pk_col}'
+            )
 
+            cx.execute(text(sql), r)
 
 
-import re
-from typing import List, Tuple, Dict, Set
+# ----------------------------------------------------
+# LLM clean
+# ----------------------------------------------------
+def clean_value(llm: LLM, value: str) -> str:
+    if not llm.enabled():
+        return value
 
-from sqlalchemy import text
-from app.config import settings
+    out = llm.clean_text(
+        value,
+        system=CLEAN_PROMPT,
+        instruction="Clean the following product text."
+    )
+    return out.strip() or value
+
+
+# ----------------------------------------------------
+# MAIN FUNCTION — identical logic to old pipeline
+# ----------------------------------------------------
+def run_clean_table(
+    schema: str,
+    table: str,
+    culprit_columns: List[str],
+    batch_size: int = 1000,
+    clean_cap: Optional[int] = None,
+    primary_key: Optional[str] = None,
+    clean_all: bool = False,
+):
+    if not primary_key:
+        raise ValueError("primary_key required")
 
-from app.db import engine, get_catalog_snapshot
-from app.cleaning.llm import LLM
-from app.cleaning.prompts import SQL_PROMPT_SYSTEM, sql_user_prompt
-
-
-def _strip_code_fences(s: str) -> str:
-    s = s.strip()
-    s = re.sub(r"^```sql\s*|\s*```$", "", s, flags=re.I | re.M)
-    return s.strip("`").strip()
-
-
-EXTRA_GUIDANCE = """
-Requirements:
-- Search across cleaned columns only (use *_clean):
-  Types(TypeName_clean, FamilyName_clean), Elements(ElementName_clean),
-  Assembly(AssemblyName_clean), Materials(Name_clean), Views(ViewName_clean),
-  ModelDetails(ModelName_clean), ModelRoomDetails(RoomName_clean),
-  ModelFloorPlanMapping(FloorPlanName_clean), GeometryDataNew(GeometryFileName_clean).
-- Prefer normalized units (e.g., 4 in). Treat 4", 4 inch, 4 inches as 4 in.
-- Match singular/plural (e.g., wall/walls, elbow/elbows) using robust ILIKE patterns.
-- Follow relationships to Types to return the correct TypeID when searching non-Type tables.
-- Final output should be a single SELECT that includes a column aliased exactly as TypeID
-  (e.g., SELECT DISTINCT t."TypeID" AS TypeID, ...). Avoid returning other columns.
-"""
+    llm = LLM()
 
+    # Ensure <col>_clean exists
+    ensure_clean_columns(schema, table, culprit_columns) ## Adding cleaned columns if missing
+    total_rows = _count_source_rows(schema, table) ## Count total rows in the table
+    
+    cap = None if clean_all else (clean_cap or MAX_ROWS_PER_TABLE)
+
+    print(f"\n→ In-place cleaning {schema}.{table} (rows={total_rows}, cap={cap})")
+    sys.stdout.flush()
+
+    # Skip rows already cleaned
+    skip_pks = set()
+    if culprit_columns:
+        cond = " AND ".join([f'"{c}_clean" IS NOT NULL' for c in culprit_columns])
+        sql = (
+            f'SELECT "{primary_key}" FROM "{schema}"."{table}" '
+            f'WHERE {cond}'
+        )
+        try:
+            with engine.begin() as cx:
+                rows = cx.execute(text(sql)).fetchall()
+                skip_pks = {r[0] for r in rows}
+        except:
+            skip_pks = set()
 
-def _is_select(sql: str) -> bool:
-    return bool(sql and sql.strip().lower().startswith("select"))
+    rows_cleaned = 0
+    rows_processed = 0
+    skipped_existing = 0
 
+    # STREAM + CLEAN + UPDATE SAME TABLE
+    for rows in stream_rows(schema, table, batch_size=batch_size):
+        out_rows = []
 
-def _quote_schema_identifiers(sql: str) -> str:
-    """Quote occurrences of <schema>.<identifier> where not already quoted.
-    This helps when the LLM emits MixedCase table names without quotes.
-    """
-    schema = settings.POSTGRES_SOURCE_SCHEMAS
-    # Quote occurrences like normalizeddata.tblTypes -> "normalizeddata"."tblTypes"
-    pat = re.compile(rf'(?<!")\b{re.escape(schema)}\.(?!")(\w+)', re.IGNORECASE)
-    sql = pat.sub(lambda m: f'"{schema}"."{m.group(1)}"', sql)
-    # Also quote public.<identifier> forms
-    pat_pub = re.compile(r'(?<!")\bpublic\.(?!")(\w+)', re.IGNORECASE)
-    sql = pat_pub.sub(lambda m: f'"public"."{m.group(1)}"', sql)
-    return sql
+        for r in rows:
+            pk = r.get(primary_key)
 
+            if pk in skip_pks:
+                skipped_existing += 1
+                continue
 
-def nl_to_typeids(question: str) -> Tuple[List[int], str]:
-    """Generate SQL via LLM that returns DISTINCT TypeID for the user question
-    and execute it, returning a list of TypeID values.
-    """
-    # Build a focused prompt with columns and relations
-    catalog = get_catalog_snapshot()
-    user = sql_user_prompt(question, catalog_snapshot=catalog)
-    user += "\n\n" + EXTRA_GUIDANCE
+            will_clean = (cap is None) or (rows_cleaned < cap)
 
-    llm = LLM()
-    if not llm.enabled():
-        raise RuntimeError("LLM disabled: set LLM_PROVIDER in .env to enable NL→SQL.")
+            for col in culprit_columns:
+                original = r.get(col)
+                original_s = None if original is None else str(original)
 
-    sql = llm.nl_to_sql(SQL_PROMPT_SYSTEM, user)
-    sql = _strip_code_fences(sql)
-    sql = _quote_schema_identifiers(sql)
-    if not _is_select(sql):
-        raise ValueError("LLM did not return a SELECT statement.")
+                if will_clean:
+                    cleaned = clean_value(llm, original_s) if original_s else None
+                    r[f"{col}_clean"] = cleaned
+                else:
+                    r[f"{col}_clean"] = None
 
-    # Execute LLM SQL directly and extract any column that looks like TypeID
-    try:
-        with engine.begin() as cx:
-            # Favor normalizeddata then public on the search_path for convenience
-            try:
-                cx.execute(text(
-                    f"SET LOCAL search_path TO \"{settings.POSTGRES_SOURCE_SCHEMAS}\", " + ",".join(settings.source_schemas)
-                ))
-            except Exception:
-                pass
-            rows = cx.execute(text(sql)).mappings().all()
-
-        if not rows:
-            return ([], sql)
-
-        # Find a key resembling TypeID (case-insensitive, underscores allowed)
-        keys = list(rows[0].keys())
-
-        def is_typeid(k: str) -> bool:
-            return bool(re.fullmatch(r"(?i)type[_ ]?id", k))
-
-        cand = None
-        for k in keys:
-            if is_typeid(k):
-                cand = k
-                break
-        if cand is None:
-            for k in keys:
-                if k.lower() in ("typeid", "type_id"):
-                    cand = k
-                    break
-        if cand is None:
-            return ([], sql)
-
-        vals: set[int] = set()
-        for r in rows:
-            v = r.get(cand)
-            if v is None:
-                continue
-            try:
-                vals.add(int(v))
-            except Exception:
-                try:
-                    vals.add(int(str(v).strip()))
-                except Exception:
-                    continue
-        return (sorted(vals), sql)
-    except Exception:
-        # Fallback: build a deterministic UNION-based search using only verified joins/columns
-        return _fallback_union_search(question)
-
-
-def _fallback_union_search(question: str) -> Tuple[List[int], str]:
-    """Fallback SQL builder that unions TypeIDs discovered via safe, known paths."""
-    catalog = get_catalog_snapshot()
-    target = settings.POSTGRES_SOURCE_SCHEMAS
-    cmap: Dict[str, Dict[str, Set[str]]] = {}
-    for r in catalog:
-        schema = r["table_schema"]
-        table = r["table_name"]
-        col = r["column_name"]
-        cmap.setdefault(schema, {}).setdefault(table, set()).add(col)
-
-    def has(table: str, *cols: str, schema: str = target) -> bool:
-        return table in cmap.get(schema, {}) and all(c in cmap[schema][table] for c in cols)
-
-    def normalize_inches(txt: str) -> str:
-        t = txt
-        t = re.sub(r"(\d+)\s*(?:inches|inch|in|\")\b", r"\1 in", t, flags=re.I)
-        return t
-
-    qn = normalize_inches(question.lower())
-    tokens = []
-    for tok in re.findall(r"\d+\s+in|[a-zA-Z]+", qn):
-        tokens.append(tok.strip())
-    alts: Set[str] = set(tokens)
-    for t in list(tokens):
-        if len(t) > 2 and t.isalpha():
-            if t.endswith("s"):
-                alts.add(t[:-1])
-            else:
-                alts.add(t + "s")
-    pats = [f"%{t}%" for t in sorted(alts)]
-
-    def like_all(col: str) -> str:
-        return " AND ".join([f"{col} ILIKE :p{i}" for i in range(len(pats))]) if pats else "TRUE"
-
-    parts: List[str] = []
-
-    if has("tblTypes", "TypeID", "TypeName_clean"):
-        conds = like_all('t."TypeName_clean"')
-        parts.append(
-            f'SELECT DISTINCT t."TypeID" AS TypeID FROM "{target}"."tblTypes" t WHERE {conds}'
-        )
-    if has("tblTypes", "TypeID", "FamilyName_clean"):
-        conds = like_all('t."FamilyName_clean"')
-        parts.append(
-            f'SELECT DISTINCT t."TypeID" AS TypeID FROM "{target}"."tblTypes" t WHERE {conds}'
-        )
+            if will_clean:   
+                rows_cleaned += 1
 
-    if has("tblElements", "TypeID", "ElementName_clean"):
-        conds = like_all('e."ElementName_clean"')
-        parts.append(
-            f'SELECT DISTINCT e."TypeID" AS TypeID FROM "{target}"."tblElements" e WHERE {conds}'
-        )
+            out_rows.append(r)
 
-    if has("tblTypes", "TypeID", "MaterialID") and has("tblMaterials", "MaterialID", "Name_clean"):
-        conds = like_all('m."Name_clean"')
-        parts.append(
-            f'SELECT DISTINCT t."TypeID" AS TypeID '
-            f'FROM "{target}"."tblTypes" t '
-            f'JOIN "{target}"."tblMaterials" m ON t."MaterialID" = m."MaterialID" '
-            f'WHERE {conds}'
-        )
 
-    if has("tblTypes", "TypeID", "ModelID") and has("tblModelDetails", "ModelID", "ModelName_clean"):
-        conds = like_all('md."ModelName_clean"')
-        parts.append(
-            f'SELECT DISTINCT t."TypeID" AS TypeID '
-            f'FROM "{target}"."tblTypes" t '
-            f'JOIN "{target}"."tblModelDetails" md ON t."ModelID" = md."ModelID" '
-            f'WHERE {conds}'
-        )
+        # Write back to same table
+        write_batch(schema, table, out_rows, pk_col=primary_key)
+        rows_processed += len(out_rows)
 
-    if has("tblTypes", "TypeID", "ModelID") and has("tblViews", "ModelID", "ViewName_clean"):
-        conds = like_all('v."ViewName_clean"')
-        parts.append(
-            f'SELECT DISTINCT t."TypeID" AS TypeID '
-            f'FROM "{target}"."tblTypes" t '
-            f'JOIN "{target}"."tblViews" v ON t."ModelID" = v."ModelID" '
-            f'WHERE {conds}'
-        )
+        # progress
+        target = cap or total_rows
+        pct = int(min(rows_cleaned, target) * 100 / target)
 
-    if has("tblTypes", "TypeID", "ModelID") and has("tblAssembly", "ModelID", "AssemblyName_clean"):
-        conds = like_all('a."AssemblyName_clean"')
-        parts.append(
-            f'SELECT DISTINCT t."TypeID" AS TypeID '
-            f'FROM "{target}"."tblTypes" t '
-            f'JOIN "{target}"."tblAssembly" a ON t."ModelID" = a."ModelID" '
-            f'WHERE {conds}'
+        print(
+            f"   {table}: cleaned {rows_cleaned}/{target} ({pct}%) "
+            f"| updated rows: {rows_processed} | skipped: {skipped_existing}"
         )
+        sys.stdout.flush()
 
-    if has("tblTypes", "TypeID", "ModelID") and has("tblModelRoomDetails", "ModelID", "RoomName_clean"):
-        conds = like_all('mrd."RoomName_clean"')
-        parts.append(
-            f'SELECT DISTINCT t."TypeID" AS TypeID '
-            f'FROM "{target}"."tblTypes" t '
-            f'JOIN "{target}"."tblModelRoomDetails" mrd ON t."ModelID" = mrd."ModelID" '
-            f'WHERE {conds}'
-        )
+    print(
+        f"✓ DONE: {schema}.{table} in-place cleaned "
+        f"(cleaned={rows_cleaned}, skipped={skipped_existing})\n"
+    )
 
-    if has("tblTypes", "TypeID", "ModelID") and has("tblModelFloorPlanMapping", "ModelID", "FloorPlanName_clean"):
-        conds = like_all('mfpm."FloorPlanName_clean"')
-        parts.append(
-            f'SELECT DISTINCT t."TypeID" AS TypeID '
-            f'FROM "{target}"."tblTypes" t '
-            f'JOIN "{target}"."tblModelFloorPlanMapping" mfpm ON t."ModelID" = mfpm."ModelID" '
-            f'WHERE {conds}'
-        )
 
-    if has("tblTypes", "TypeID", "ModelID") and has("tblGeometryDataNew", "ModelID", "GeometryFileName_clean"):
-        conds = like_all('g."GeometryFileName_clean"')
-        parts.append(
-            f'SELECT DISTINCT t."TypeID" AS TypeID '
-            f'FROM "{target}"."tblTypes" t '
-            f'JOIN "{target}"."tblGeometryDataNew" g ON t."ModelID" = g."ModelID" '
-            f'WHERE {conds}'
+# ----------------------------------------------------
+# YAML Loader
+# ----------------------------------------------------
+def run_cleaning_from_yaml(
+    yaml_path: str,
+    batch_size: int = 1000,
+    clean_cap: Optional[int] = None,
+    clean_all: bool = False,
+):
+    import yaml
+
+    with open(yaml_path, "r") as f:
+        cfg = yaml.safe_load(f)
+
+    for t in cfg.get("tables", []):
+        run_clean_table(
+            schema=t["schema"], ## public
+            table=t["name"], ## test_products
+            culprit_columns=t["culprit_columns"], ## ["title", "description"]
+            batch_size=batch_size, ## 30
+            primary_key=t["primary_key"], ## id
+            clean_cap=clean_cap, ## 10
+            clean_all=clean_all,## True/False
         )
 
-    if not parts:
-        return ([], "-- no valid search paths found")
-
-    sql = "\nUNION\n".join(parts)
-
-    params = {f"p{i}": pats[i] for i in range(len(pats))}
-    with engine.begin() as cx:
-        rows = cx.execute(text(sql), params).scalars().all()
-    # rows already ints
-    out = sorted({int(x) for x in rows if x is not None})
-    return (out, sql)
-
-
-
-
-