Create text

text

@@ -0,0 +1,260 @@
+import sys
+sys.path.append("../..")
+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
+
+
+"""
+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, max_rows=None):
+    limit = ""
+    if max_rows:
+        limit = f" LIMIT {int(max_rows)}"
+
+    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 max_rows and yielded >= max_rows:
+                break
+
+        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
+
+    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)
+
+    with engine.begin() as cx:
+        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)
+
+
+# ----------------------------------------------------
+# LLM clean
+# ----------------------------------------------------
+def clean_value(llm: LLM, value: str) -> str:
+    if not llm.enabled():
+        return value
+
+    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")
+
+    llm = LLM()
+
+    # Ensure <col>_clean exists
+    ensure_clean_columns(schema, table, culprit_columns)
+
+    # Determine cleaning cap
+    total_rows = _count_source_rows(schema, 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()
+
+    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 = []
+
+        for r in rows:
+            pk = r.get(primary_key)
+
+            # Skip already cleaned rows
+            if pk in skip_pks:
+                skipped_existing += 1
+                continue
+
+            will_clean = (cap is None) or (rows_cleaned < cap)
+
+            # Clean selected columns
+            for col in culprit_columns:
+                original = r.get(col)
+                original_s = None if original is None else str(original)
+
+                if will_clean:
+                    cleaned = clean_value(llm, original_s) if original_s else None
+                    r[f"{col}_clean"] = cleaned
+                    rows_cleaned += 1
+                else:
+                    # out-of-cap rows → NULL clean column (old behavior)
+                    r[f"{col}_clean"] = None
+
+            out_rows.append(r)
+
+        # Write back to same table
+        write_batch(schema, table, out_rows, pk_col=primary_key)
+        rows_processed += len(out_rows)
+
+        # progress
+        target = cap or total_rows
+        pct = int(min(rows_cleaned, target) * 100 / target)
+
+        print(
+            f"   {table}: cleaned {rows_cleaned}/{target} ({pct}%) "
+            f"| updated rows: {rows_processed} | skipped: {skipped_existing}"
+        )
+        sys.stdout.flush()
+
+    print(
+        f"✓ DONE: {schema}.{table} in-place cleaned "
+        f"(cleaned={rows_cleaned}, skipped={skipped_existing})\n"
+    )
+
+
+# ----------------------------------------------------
+# 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"],
+            table=t["name"],
+            culprit_columns=t["culprit_columns"],
+            batch_size=batch_size,
+            primary_key=t["primary_key"],
+            clean_cap=clean_cap,
+            clean_all=clean_all,
+        )
+
+
+
+