#!/usr/bin/env python3 """ Phase 1 — Data Quality / Cleaning / Validation / Provenance Compliments Reference DB Pipeline Authoritative Input: https://huggingface.co/datasets/saraNour/compliments-brand/blob/main/source_of_truth/products.parquet This phase: 1. Downloads the authoritative products.parquet from HuggingFace 2. Validates schema, row count, nulls, duplicates 3. Performs deterministic cleaning/standardization 4. Preserves raw values for traceability where cleaning modifies data 5. Analyzes UPC patterns, brand values, size fields 6. Documents provenance of every column 7. Drops 100% null columns with explicit documentation 8. Produces clean Phase 1 output + validation + statistics Cleaning operations (Phase 1 = data quality foundation): A. String normalization: whitespace trim, empty-to-null B. Brand cleaning: whitespace/case normalization, preserve raw C. UPC validation: format, nulls, duplicates, reused UPCs D. external_id validation: nulls, duplicates E. Title cleaning: whitespace normalization F. Size fields: consistency audit (semantic parsing is Phase 2) G. Null column handling: documented removal of 100% null columns """ import json import re import sys from datetime import datetime, timezone from pathlib import Path import pandas as pd import numpy as np from huggingface_hub import hf_hub_download # --------------------------------------------------------------------------- # Configuration # --------------------------------------------------------------------------- HF_REPO = "saraNour/compliments-brand" HF_FILE = "source_of_truth/products.parquet" HF_REPO_TYPE = "dataset" OUTPUT_DIR = Path(__file__).resolve().parent.parent / "outputs" VALIDATION_DIR = Path(__file__).resolve().parent.parent / "validation" STATISTICS_DIR = Path(__file__).resolve().parent.parent / "statistics" VERSION = "3.0.0" TIMESTAMP = datetime.now(timezone.utc).isoformat() def log(msg: str) -> None: print(f"[Phase1] {msg}") # =========================================================================== # A. STRING NORMALIZATION # =========================================================================== def normalize_whitespace(s): """Trim leading/trailing whitespace, collapse repeated internal whitespace.""" if pd.isna(s): return s s_str = str(s).strip() s_str = re.sub(r"\s+", " ", s_str) return s_str if s_str else None def empty_to_null(s): """Convert empty/whitespace-only strings to None.""" if pd.isna(s): return None s_str = str(s).strip() return None if s_str == "" else s_str # =========================================================================== # B. BRAND CLEANING # =========================================================================== def clean_brand(raw_brand): """ Clean brand string: trim whitespace, normalize case for downstream. Returns (brand_clean, brand_raw). """ if pd.isna(raw_brand): return None, None raw = str(raw_brand) cleaned = raw.strip() # Normalize obvious case noise: "COMPLIMENTS" -> "Compliments" # But preserve mixed case that might be intentional if cleaned.upper() == cleaned and len(cleaned) > 1: cleaned = cleaned.title() return cleaned, raw # =========================================================================== # C. UPC VALIDATION # =========================================================================== def validate_upc(upc_val): """ Validate a single UPC value. Returns dict with validation results. """ if pd.isna(upc_val): return {"valid": False, "reason": "null"} s = str(upc_val).strip() if s == "" or s == "nan": return {"valid": False, "reason": "empty"} # Check for non-digit characters (allow decimal point for float representation) # UPCs stored as floats may have .0 suffix s_clean = s.replace(".0", "") if s.endswith(".0") else s if not s_clean.isdigit(): return {"valid": False, "reason": f"non_digit_chars: {s}"} # Check length (standard UPC is 12 digits, but variants exist) if len(s_clean) < 6 or len(s_clean) > 14: return {"valid": False, "reason": f"unusual_length: {len(s_clean)}"} return {"valid": True, "cleaned": s_clean} def audit_upcs(df): """Comprehensive UPC audit.""" upc = df["upc"] # Validate each UPC validations = upc.apply(validate_upc) valid_mask = validations.apply(lambda x: x["valid"]) invalid_upcs = df[~valid_mask].copy() # Count reused UPCs upc_counts = upc.value_counts() reused = upc_counts[upc_counts > 1] # Analyze reused UPCs: do they map to different titles? reused_analysis = [] for upc_val in reused.index: if pd.isna(upc_val): continue subset = df[df["upc"] == upc_val] titles = subset["title"].unique() brands = subset["brand"].unique() sizes = subset["size"].unique() reused_analysis.append({ "upc": str(upc_val), "count": int(reused[upc_val]), "unique_titles": len(titles), "titles": [str(t) for t in titles[:5]], "unique_brands": len(brands), "brands": [str(b) for b in brands], "unique_sizes": len(sizes), "sizes": [str(s) for s in sizes[:5]], }) return { "total_rows": len(df), "null_count": int(upc.isna().sum()), "unique_count": int(upc.nunique()), "invalid_format_count": int((~valid_mask).sum()), "invalid_format_examples": invalid_upcs[["external_id", "title", "upc"]].head(10).to_dict("records"), "reused_upc_count": int(len(reused)), "reused_upc_total_rows": int(reused.sum()), "reused_upc_examples": reused_analysis[:15], } # =========================================================================== # D. EXTERNAL_ID VALIDATION # =========================================================================== def audit_external_ids(df): """Validate external_id field.""" ext = df["external_id"] return { "total_rows": len(df), "null_count": int(ext.isna().sum()), "unique_count": int(ext.nunique()), "duplicate_count": int(ext.duplicated().sum()), "pass": int(ext.duplicated().sum()) == 0 and ext.isna().sum() == 0, } # =========================================================================== # E. TITLE CLEANING # =========================================================================== def clean_title(raw_title): """ Clean title: trim whitespace, collapse repeated spaces. Returns (title_clean, title_raw). """ if pd.isna(raw_title): return None, None raw = str(raw_title) cleaned = raw.strip() cleaned = re.sub(r"\s+", " ", cleaned) return cleaned if cleaned else None, raw def audit_titles(df): """Audit title field quality.""" titles = df["title"] # Check for leading/trailing whitespace has_leading = titles.apply(lambda x: str(x) != str(x).strip() if pd.notna(x) else False).sum() has_repeated_ws = titles.apply(lambda x: bool(re.search(r"\s{2,}", str(x))) if pd.notna(x) else False).sum() empty_titles = titles.isna().sum() + (titles.apply(lambda x: str(x).strip() == "" if pd.notna(x) else False).sum()) # Duplicated titles title_counts = titles.value_counts() duplicated_titles = title_counts[title_counts > 1] return { "total_rows": len(titles), "null_count": int(titles.isna().sum()), "unique_count": int(titles.nunique()), "leading_trailing_whitespace": int(has_leading), "repeated_whitespace": int(has_repeated_ws), "empty_titles": int(empty_titles), "duplicated_title_count": int(len(duplicated_titles)), "duplicated_title_total_rows": int(duplicated_titles.sum()), "duplicated_title_examples": {str(k): int(v) for k, v in list(duplicated_titles.head(10).items())}, } # =========================================================================== # F. SIZE FIELDS AUDIT # =========================================================================== def audit_sizes(df): """Audit size-related fields for consistency.""" size_str = df["size"] size_amount = df["size_amount"] size_unit = df["size_unit"] size_unit_norm = df["size_unit_norm"] size_qty = df["size_qty"] # Check: when size_amount is null, is size_unit also null? amount_null = size_amount.isna() unit_null = size_unit.isna() both_null = (amount_null & unit_null).sum() amount_null_unit_not = (amount_null & ~unit_null).sum() unit_null_amount_not = (~amount_null & unit_null).sum() # Check: size_qty should usually be 1 qty_distribution = size_qty.value_counts().to_dict() return { "size_string": { "null_count": int(size_str.isna().sum()), "unique_count": int(size_str.nunique()), }, "size_amount": { "null_count": int(amount_null.sum()), "null_pct": round(amount_null.sum() / len(df) * 100, 2), }, "size_unit": { "null_count": int(unit_null.sum()), "null_pct": round(unit_null.sum() / len(df) * 100, 2), "distribution": {str(k): int(v) for k, v in size_unit.value_counts().items()}, }, "size_unit_norm": { "null_count": int(size_unit_norm.isna().sum()), "distribution": {str(k): int(v) for k, v in size_unit_norm.value_counts().items()}, }, "consistency": { "both_amount_and_unit_null": int(both_null), "amount_null_unit_not_null": int(amount_null_unit_not), "unit_null_amount_null_not": int(unit_null_amount_not), }, "size_qty": { "distribution": {str(k): int(v) for k, v in qty_distribution.items()}, }, } # =========================================================================== # G. NULL COLUMN HANDLING # =========================================================================== def identify_null_columns(df): """Identify columns that are 100% null.""" null_cols = [] for col in df.columns: if df[col].isna().all(): null_cols.append(col) return null_cols # =========================================================================== # H. DUPLICATE AUDIT # =========================================================================== def audit_duplicates(df): """Comprehensive duplicate audit.""" full_dupes = int(df.duplicated().sum()) ext_dupes = int(df["external_id"].duplicated().sum()) upc_dupes = int(df["upc"].duplicated().sum()) # Title + size + brand combinations if "size" in df.columns: combo = df["title"].fillna("") + "|" + df["size"].fillna("") + "|" + df["brand"].fillna("") combo_dupes = int(combo.duplicated().sum()) else: combo_dupes = 0 return { "full_row_duplicates": full_dupes, "external_id_duplicates": ext_dupes, "upc_duplicates": upc_dupes, "title_size_brand_duplicates": combo_dupes, } # =========================================================================== # MAIN # =========================================================================== def main(): log("Starting Phase 1 (v2.0.0 — Data Quality Foundation)") # Ensure output dirs exist OUTPUT_DIR.mkdir(parents=True, exist_ok=True) VALIDATION_DIR.mkdir(parents=True, exist_ok=True) STATISTICS_DIR.mkdir(parents=True, exist_ok=True) # ------------------------------------------------------------------ # 1. LOAD # ------------------------------------------------------------------ log(f"Downloading {HF_REPO}/{HF_FILE} ...") path = hf_hub_download(HF_REPO, HF_FILE, repo_type=HF_REPO_TYPE) df_raw = pd.read_parquet(path) log(f"Loaded: {df_raw.shape[0]} rows, {df_raw.shape[1]} columns") # Preserve raw copy for provenance df_raw_copy = df_raw.copy() # ------------------------------------------------------------------ # 2. SCHEMA VALIDATION # ------------------------------------------------------------------ log("Validating schema ...") EXPECTED_COLUMNS = [ "upc", "external_id", "brand", "title", "price", "price_currency", "size", "size_amount", "size_unit", "size_qty", "size_per_unit", "size_unit_norm", "size_total", "image_url", "source", "source_url", ] missing = [c for c in EXPECTED_COLUMNS if c not in df_raw.columns] assert len(missing) == 0, f"Missing columns: {missing}" assert len(df_raw) == 4440, f"Expected 4440 rows, got {len(df_raw)}" log(" Schema: PASS") # ------------------------------------------------------------------ # 3. AUDIT (before cleaning) # ------------------------------------------------------------------ log("Auditing raw data ...") null_info = {} for col in df_raw.columns: n = int(df_raw[col].isna().sum()) null_info[col] = { "null_count": n, "null_pct": round(n / len(df_raw) * 100, 2), "is_100pct_null": n == len(df_raw), } dup_info_raw = audit_duplicates(df_raw) upc_info_raw = audit_upcs(df_raw) ext_info_raw = audit_external_ids(df_raw) title_info_raw = audit_titles(df_raw) size_info_raw = audit_sizes(df_raw) brand_info_raw = { "unique_count": int(df_raw["brand"].nunique()), "distribution": {str(k): int(v) for k, v in df_raw["brand"].value_counts().items()}, } # ------------------------------------------------------------------ # 4. CLEANING # ------------------------------------------------------------------ log("Cleaning data ...") df = df_raw.copy() # A. String normalization on all string columns log(" A. Normalizing whitespace on string columns ...") string_cols = ["upc", "external_id", "brand", "title", "size", "size_unit", "size_unit_norm", "image_url", "source", "source_url"] cleaning_log = {} for col in string_cols: if col in df.columns: before_nulls = int(df[col].isna().sum()) df[col] = df[col].apply(empty_to_null) after_nulls = int(df[col].isna().sum()) new_nulls = after_nulls - before_nulls if new_nulls > 0: cleaning_log[col] = {"empty_to_null_count": new_nulls} # B. Brand cleaning log(" B. Cleaning brand field ...") brand_clean_results = df["brand"].apply(clean_brand) df["brand_clean"] = brand_clean_results.apply(lambda x: x[0]) log(f" Cleaned brands: {df['brand_clean'].nunique()} unique") # C. Title cleaning log(" C. Cleaning title field ...") title_clean_results = df["title"].apply(clean_title) df["title_clean"] = title_clean_results.apply(lambda x: x[0]) # D. Generate source_product_id (composite identifier) log(" D. Generating source_product_id ...") df["source_product_id"] = df.apply( lambda row: f"{row['source']}|{row['upc']}|{row['external_id']}" if pd.notna(row['source']) and pd.notna(row['upc']) and pd.notna(row['external_id']) else f"{row['source']}|{row['external_id']}", axis=1 ) log(f" source_product_id unique: {df['source_product_id'].nunique()}") # E. Drop 100% null columns null_100pct = [c for c, v in null_info.items() if v["is_100pct_null"]] log(f" F. Dropping 100% null columns: {null_100pct}") df = df.drop(columns=null_100pct) # ------------------------------------------------------------------ # 5. REORDER COLUMNS # ------------------------------------------------------------------ log("Reordering columns ...") new_order = [ "source_product_id", "upc", "external_id", "brand", "brand_clean", "title", "title_clean", "price", "price_currency", "size", "size_amount", "size_unit", "size_qty", "size_unit_norm", "image_url", "source", "source_url", ] df = df[new_order] # ------------------------------------------------------------------ # 6. POST-CLEANING AUDIT # ------------------------------------------------------------------ log("Auditing cleaned data ...") dup_info_clean = audit_duplicates(df) upc_info_clean = audit_upcs(df) ext_info_clean = audit_external_ids(df) title_info_clean = audit_titles(df) size_info_clean = audit_sizes(df) brand_info_clean = { "unique_count": int(df["brand_clean"].nunique()), "distribution": {str(k): int(v) for k, v in df["brand_clean"].value_counts().items()}, } # ------------------------------------------------------------------ # 7. STATISTICS # ------------------------------------------------------------------ statistics = { "version": VERSION, "timestamp": TIMESTAMP, "input": { "source": f"{HF_REPO}/{HF_FILE}", "row_count": len(df_raw), "column_count": len(df_raw.columns), }, "output": { "row_count": len(df), "column_count": len(df.columns), "columns_dropped": null_100pct, "columns_added": ["brand_clean", "title_clean"], }, "cleaning_summary": cleaning_log, "nulls_before_cleaning": {c: v for c, v in null_info.items() if v["null_count"] > 0}, "duplicates_raw": dup_info_raw, "duplicates_cleaned": dup_info_clean, "upc": upc_info_clean, "external_id": ext_info_clean, "title": title_info_clean, "size": size_info_raw, "brand": brand_info_clean, } # ------------------------------------------------------------------ # 8. VALIDATION # ------------------------------------------------------------------ all_pass = True failures = [] # external_id must be unique if not ext_info_clean["pass"]: all_pass = False failures.append("external_id_not_unique") # No full-row duplicates if dup_info_clean["full_row_duplicates"] > 0: all_pass = False failures.append(f"full_row_duplicates: {dup_info_clean['full_row_duplicates']}") # Check no unexpected 100% null columns expected_null = {"size_per_unit", "size_total"} for col in df.columns: if df[col].isna().all() and col not in expected_null: all_pass = False failures.append(f"unexpected_100pct_null: {col}") validation = { "version": VERSION, "timestamp": TIMESTAMP, "result": "PASS" if all_pass else "FAIL", "failures": failures, "checks": { "schema": {"pass": True, "note": "All 16 expected columns present"}, "external_id_uniqueness": ext_info_clean, "duplicates": dup_info_clean, "null_columns": {"expected_100pct_null": list(expected_null), "dropped": null_100pct}, }, } # ------------------------------------------------------------------ # 9. SAVE OUTPUTS # ------------------------------------------------------------------ log("Saving outputs ...") df.to_parquet(OUTPUT_DIR / "phase1_output.parquet", index=False) log(f" Saved phase1_output.parquet ({df.shape[0]} rows, {df.shape[1]} cols)") with open(VALIDATION_DIR / "phase1_validation.json", "w") as f: json.dump(validation, f, indent=2, default=str) log(" Saved phase1_validation.json") with open(STATISTICS_DIR / "phase1_statistics.json", "w") as f: json.dump(statistics, f, indent=2, default=str) log(" Saved phase1_statistics.json") # ------------------------------------------------------------------ # SUMMARY # ------------------------------------------------------------------ log("") log("=== PHASE 1 COMPLETE (v2.0.0) ===") log(f"Input: {df_raw.shape[0]} rows, {df_raw.shape[1]} columns") log(f"Output: {df.shape[0]} rows, {df.shape[1]} columns") log(f"Columns dropped: {null_100pct}") log(f"Columns added: ['brand_clean', 'title_clean']") log(f"Validation: {validation['result']}") if failures: log(f"Failures: {failures}") log("========================") return df, validation, statistics if __name__ == "__main__": main()