Update text

text

@@ -1,248 +1,50 @@
-import json
-from typing import Dict, List, Optional
+import argparse
 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):
-    limit = ""
-    sql = f'SELECT * FROM "{schema}"."{table}"{limit}'
-
-    with engine.begin() as cx:
-        result: Result = (
-            cx.execution_options(stream_results=True)
-            .execute(text(sql))
+sys.path.append(r"C:\Users\FCI\Desktop\engineero_ai\pg-clean-search")
+from app.cleaning.pipeline import run_cleaning_from_yaml
+
+def main():
+    """Defines the command-line interface for the cleaning pipeline."""
+    p = argparse.ArgumentParser(
+        description="Run an in-place data cleaning pipeline on specified PostgreSQL tables.",
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+    p.add_argument(
+        "--cfg", 
+        # required=True,
+        default="scripts\clean_test.yaml", 
+        help="YAML file listing source schema, table names, primary keys, and culprit columns."
+    )
+    p.add_argument(
+        "--batch", 
+        type=int, 
+        default=1000, 
+        help=(
+            "If --clean-all=False, this is the maximum number of rows read (LIMIT) and processed (1 batch).\n"
+            "If --clean-all=True, this is the chunk size for reading/writing multiple batches."
         )
-
-        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)
-
-    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) ## Adding cleaned columns if missing
-    total_rows = _count_source_rows(schema, table) ## Count total rows in the table
+    p.add_argument(
+        "--clean-all", 
+        action="store_true", 
+        help="Process and clean every row in the table (overrides the LIMIT set by --batch)."
+    )
+    p.add_argument(
+        "--clean_cap",
+        type=int,
+        # default=20,
+        help="Maximum number of rows to clean per 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)
-
-            if pk in skip_pks:
-                skipped_existing += 1
-                continue
-
-            will_clean = (cap is None) or (rows_cleaned < cap)
-
-            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
-                else:
-                    r[f"{col}_clean"] = None
-
-            if will_clean:   
-                rows_cleaned += 1
-
-            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"
+    args = p.parse_args()
+    
+    run_cleaning_from_yaml(
+        args.cfg,
+        batch_size=args.batch,
+        clean_all=args.clean_all,
+        clean_cap=args.clean_cap,   # ← MUST PASS THIS
     )
 
-
-# ----------------------------------------------------
-# 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 __name__ == "__main__":
+    main()
+