Upload analysis.py with huggingface_hub

analysis.py

@@ -0,0 +1,202 @@
+import re
+import subprocess
+from itertools import combinations
+from pathlib import Path
+
+import pandas as pd
+
+CSV_DIR = None
+while CSV_DIR is None:
+    user_input = input("Enter the full path to the CSV directory: ").strip()
+    if not user_input:
+        continue
+    csv_path = Path(user_input)
+    if not csv_path.is_dir():
+        continue
+    CSV_DIR = csv_path
+
+OUTPUT_FILE = Path("./schema_comparison_output.txt")
+N_ROWS = 1000
+SAMPLE_ROWS = 5
+
+output_lines = []
+
+
+def output(*args, **kwargs):
+    line = " ".join(str(a) for a in args)
+    print(line, **kwargs)
+    output_lines.append(line)
+
+
+def extract_date(filename: str) -> str:
+    match = re.match(r"^(.*?_\d{2}_\d{2}_\d{4})", filename)
+    return match.group(1) if match else None
+
+
+def get_row_count(filepath: Path) -> int:
+    result = subprocess.run(
+        ["wc", "-l", str(filepath)],
+        capture_output=True,
+        text=True,
+    )
+    return int(result.stdout.strip().split()[0]) - 1
+
+
+def load_schema(filepath: Path, nrows: int = N_ROWS) -> tuple[dict, pd.DataFrame]:
+    try:
+        df = pd.read_csv(filepath, nrows=nrows)
+    except Exception as e:
+        output(f"Warning: Could not read {filepath.name}: {e}")
+        return {}, pd.DataFrame()
+    schema = dict(df.dtypes)
+    return schema, df
+
+
+def compare_schemas(
+    schema1: dict,
+    df1: pd.DataFrame,
+    name1: str,
+    schema2: dict,
+    df2: pd.DataFrame,
+    name2: str,
+):
+    cols1 = set(schema1.keys())
+    cols2 = set(schema2.keys())
+
+    missing_in_1 = cols2 - cols1
+    missing_in_2 = cols1 - cols2
+    common_cols = cols1 & cols2
+
+    dtype_mismatches = {}
+    for col in common_cols:
+        if str(schema1[col]) != str(schema2[col]):
+            dtype_mismatches[col] = (schema1[col], schema2[col])
+
+    if missing_in_1 or missing_in_2 or dtype_mismatches:
+        return False, missing_in_1, missing_in_2, dtype_mismatches
+    return True, None, None, None
+
+
+def print_mismatch(
+    name1: str,
+    name2: str,
+    missing_in_1: set,
+    missing_in_2: set,
+    dtype_mismatches: dict,
+    df1: pd.DataFrame,
+    df2: pd.DataFrame,
+):
+    output(f"\n{'=' * 60}")
+    output(f"MISMATCH: {name1} <-> {name2}")
+    output(f"{'=' * 60}")
+
+    if missing_in_1:
+        output(f"\nColumns in {name2} but not in {name1}: {missing_in_1}")
+    if missing_in_2:
+        output(f"\nColumns in {name1} but not in {name2}: {missing_in_2}")
+
+    if dtype_mismatches:
+        output("\n--- DTYPE MISMATCHES ---")
+        for col, (dt1, dt2) in dtype_mismatches.items():
+            output(f"  {col}: {name1}={dt1}, {name2}={dt2}")
+
+        output("\n--- SAMPLE DATA FOR MISMATCHED COLUMNS ---")
+        for col in dtype_mismatches.keys():
+            output(f"\n--- {col} ---")
+            output(f"{name1} ({SAMPLE_ROWS} rows):")
+            output(df1[col].head(SAMPLE_ROWS).to_list())
+            output(f"{name2} ({SAMPLE_ROWS} rows):")
+            output(df2[col].head(SAMPLE_ROWS).to_list())
+
+
+def main():
+    global output_lines
+
+    csv_files = list(CSV_DIR.glob("*.csv"))
+
+    date_groups = {}
+    for f in csv_files:
+        date = extract_date(f.name)
+        if date:
+            date_groups.setdefault(date, []).append(f)
+
+    file_stats = {}
+
+    for date, files in sorted(date_groups.items()):
+        if len(files) < 2:
+            output(f"\nSkipping {date} (only 1 file: {files[0].name})")
+            for f in files:
+                schema, df = load_schema(f)
+                file_stats[f.name] = {
+                    "row_count": get_row_count(f),
+                    "col_count": len(df.columns),
+                }
+            continue
+
+        output(f"\n{'#' * 60}")
+        output(f"DATE GROUP: {date}")
+
+        row_counts = {}
+        schemas = {}
+        dataframes = {}
+
+        for f in files:
+            row_counts[f.name] = get_row_count(f)
+            file_stats[f.name] = {
+                "row_count": row_counts[f.name],
+                "col_count": 0,
+            }
+            schema, df = load_schema(f)
+            schemas[f.name] = schema
+            dataframes[f.name] = df
+            file_stats[f.name]["col_count"] = len(df.columns)
+
+        file_info = ", ".join(f"{f.name} ({row_counts[f.name]:,} rows)" for f in files)
+        output(f"Files: {file_info}")
+        output(f"{'#' * 60}")
+
+        has_mismatch = False
+        for f1, f2 in combinations(files, 2):
+            name1, name2 = f1.name, f2.name
+            is_match, missing_in_1, missing_in_2, dtype_mismatches = compare_schemas(
+                schemas[name1],
+                dataframes[name1],
+                name1,
+                schemas[name2],
+                dataframes[name2],
+                name2,
+            )
+
+            if not is_match:
+                has_mismatch = True
+                print_mismatch(
+                    name1,
+                    name2,
+                    missing_in_1,
+                    missing_in_2,
+                    dtype_mismatches,
+                    dataframes[name1],
+                    dataframes[name2],
+                )
+
+        if not has_mismatch:
+            output("\nAll files in this group have matching schemas.")
+
+    output(f"\n{'#' * 60}")
+    output("FILE STATISTICS")
+    output(f"{'#' * 60}")
+    output(f"\n{'File':<60} {'Rows':>12} {'Columns':>10}")
+    output("-" * 82)
+    grand_total_rows = 0
+    for name, stats in sorted(file_stats.items()):
+        output(f"{name:<60} {stats['row_count']:>12,} {stats['col_count']:>10}")
+        grand_total_rows += stats["row_count"]
+    output("-" * 82)
+    output(f"{'TOTAL':<60} {grand_total_rows:>12,}")
+
+    OUTPUT_FILE.write_text("\n".join(output_lines))
+    print(f"\nOutput saved to {OUTPUT_FILE}")
+
+
+if __name__ == "__main__":
+    main()