| """Shared helpers for audit scripts.""" |
|
|
| import sys |
| from pathlib import Path |
| from datetime import datetime |
|
|
| import pandas as pd |
| import numpy as np |
| import matplotlib |
| matplotlib.use('Agg') |
| import matplotlib.pyplot as plt |
| import seaborn as sns |
| from scipy import stats |
| import warnings |
|
|
| warnings.filterwarnings('ignore') |
| sns.set_style('whitegrid') |
| plt.rcParams['figure.figsize'] = (14, 6) |
|
|
| PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent |
| PARQUET_DIR = PROJECT_ROOT / 'output' / 'parquet' |
| DATA_DIR = PROJECT_ROOT / 'data' |
| OUTPUT_BASE = PROJECT_ROOT / 'output' / 'audit' |
|
|
|
|
| def setup_output_dir(dataset_name): |
| out = OUTPUT_BASE / dataset_name |
| out.mkdir(parents=True, exist_ok=True) |
| return out |
|
|
|
|
| def save_fig(output_dir, name): |
| path = output_dir / f'{name}.png' |
| plt.savefig(path, dpi=150, bbox_inches='tight') |
| print(f' -> saved {path.relative_to(PROJECT_ROOT)}') |
| plt.close() |
|
|
|
|
| def load_parquet(dataset_name): |
| if dataset_name == 'users': |
| path = PARQUET_DIR / 'users.parquet' |
| elif dataset_name == 'cardS': |
| path = PARQUET_DIR / 'cardS_cleaned.parquet' |
| elif dataset_name == 'cardD': |
| path = PARQUET_DIR / 'cardD_cleaned.parquet' |
| else: |
| path = PARQUET_DIR / f'{dataset_name}_cleaned.parquet' |
| print(f'Loading {path.name}...') |
| df = pd.read_parquet(path) |
| mem = df.memory_usage(deep=True).sum() |
| unit, divisor = ('GB', 1024**3) if mem > 1024**3 else ('MB', 1024**2) |
| print(f' {len(df):,} rows, {mem / divisor:.2f} {unit}') |
| return df |
|
|
|
|
| def print_section(title): |
| print() |
| print('=' * 80) |
| print(title) |
| print('=' * 80) |
|
|
|
|
| def standard_temporal_analysis(df, dataset_title, output_dir): |
| """Yearly bar chart + gap detection. Returns (yearly_counts, gaps).""" |
| print_section('TEMPORAL ANALYSIS') |
|
|
| ts_col = next((c for c in ['timestamp', 'start_time'] if c in df.columns), None) |
| if not ts_col: |
| print('No timestamp column found — skipping temporal analysis') |
| return pd.Series(dtype=int), [] |
|
|
| df['timestamp'] = pd.to_datetime(df[ts_col]) |
| df['date'] = df['timestamp'].dt.date |
| df['year'] = df['timestamp'].dt.year |
|
|
| print(f'First record: {df["timestamp"].min()}') |
| print(f'Last record: {df["timestamp"].max()}') |
| print(f'Time span: {(df["timestamp"].max() - df["timestamp"].min()).days} days') |
| print(f'Years: {df["year"].min()} - {df["year"].max()}') |
|
|
| yearly_counts = df['year'].value_counts().sort_index() |
| print('\nYEARLY DISTRIBUTION') |
| print(yearly_counts) |
|
|
| plt.figure(figsize=(14, 6)) |
| yearly_counts.plot(kind='bar', color='steelblue') |
| plt.title(f'{dataset_title} - Yearly Distribution', fontsize=14, fontweight='bold') |
| plt.xlabel('Year') |
| plt.ylabel('Number of Records') |
| plt.xticks(rotation=45) |
| plt.grid(axis='y', alpha=0.3) |
| plt.tight_layout() |
| save_fig(output_dir, 'yearly_distribution') |
|
|
| |
| daily_counts = df.groupby('date').size() |
| all_dates = pd.date_range(start=daily_counts.index.min(), |
| end=daily_counts.index.max(), freq='D') |
| missing_dates = pd.to_datetime(all_dates.difference(pd.to_datetime(daily_counts.index))) |
|
|
| gaps = [] |
| if len(missing_dates) > 0: |
| gap_start = missing_dates[0] |
| gap_end = missing_dates[0] |
| for i in range(1, len(missing_dates)): |
| if (missing_dates[i] - missing_dates[i - 1]).days == 1: |
| gap_end = missing_dates[i] |
| else: |
| if (gap_end - gap_start).days >= 7: |
| gaps.append((gap_start, gap_end, (gap_end - gap_start).days)) |
| gap_start = missing_dates[i] |
| gap_end = missing_dates[i] |
| if (gap_end - gap_start).days >= 7: |
| gaps.append((gap_start, gap_end, (gap_end - gap_start).days)) |
|
|
| if gaps: |
| print(f'\nFound {len(gaps)} gaps >= 7 days:') |
| for start, end, days in gaps: |
| print(f' {start.date()} to {end.date()} ({days} days)') |
| else: |
| print('\nNo significant temporal gaps (all gaps < 7 days)') |
|
|
| return yearly_counts, gaps |
|
|
|
|
| def standard_missing_data_analysis(df, output_dir): |
| """Missing data summary + chart.""" |
| print_section('MISSING DATA ANALYSIS') |
|
|
| missing = df.isnull().sum() |
| missing_pct = (missing / len(df) * 100).round(2) |
| missing_df = pd.DataFrame({ |
| 'Missing Count': missing, |
| 'Missing %': missing_pct |
| }).sort_values('Missing %', ascending=False) |
|
|
| has_missing = missing_df[missing_df['Missing Count'] > 0] |
| if len(has_missing) > 0: |
| print(has_missing) |
|
|
| top_missing = has_missing.head(10) |
| plt.figure(figsize=(12, 6)) |
| top_missing['Missing %'].plot(kind='barh', color='coral') |
| plt.title('Top 10 Columns by Missing Data %', fontweight='bold') |
| plt.xlabel('Missing %') |
| plt.gca().invert_yaxis() |
| plt.tight_layout() |
| save_fig(output_dir, 'missing_data') |
| else: |
| print('No missing data found.') |
|
|
| return missing_df |
|
|
|
|
| def standard_audit_summary(dataset_title, df, extra_lines=None): |
| """Print a summary block at the end of an audit.""" |
| print_section(f'AUDIT SUMMARY: {dataset_title}') |
| print(f'Audit Date: {datetime.now().strftime("%Y-%m-%d")}') |
| print(f'Total Rows: {len(df):,}') |
| ts_col = next((c for c in ['timestamp', 'start_time'] if c in df.columns), None) |
| if ts_col: |
| print(f'Date Range: {df[ts_col].min().date()} to {df[ts_col].max().date()}') |
| uid_col = next((c for c in ['user_id_hash', 'user_id', 'username'] if c in df.columns), None) |
| if uid_col: |
| print(f'Unique Users: {df[uid_col].nunique():,}') |
| if extra_lines: |
| for line in extra_lines: |
| print(line) |
| print('=' * 80) |
|
|
