stats.py

import argparse
import csv
import statistics
from pathlib import Path
from typing import Dict, List, Optional, Tuple


def _to_float(value: str) -> Optional[float]:
    s = value.strip()
    if not s:
        return None
    try:
        return float(s)
    except ValueError:
        return None


def _read_rows(path: Path, encoding: str) -> Tuple[List[str], List[Dict[str, str]]]:
    with path.open("r", encoding=encoding, newline="") as f:
        sample = f.read(65536)
        f.seek(0)

        try:
            dialect = csv.Sniffer().sniff(sample)
        except csv.Error:
            dialect = csv.excel

        try:
            has_header = csv.Sniffer().has_header(sample)
        except csv.Error:
            has_header = True

        if has_header:
            reader = csv.DictReader(f, dialect=dialect)
            if not reader.fieldnames:
                raise ValueError("CSV appears to have no header row (field names not found).")
            rows = [row for row in reader if row]
            return list(reader.fieldnames), rows

        reader2 = csv.reader(f, dialect=dialect)
        first = next(reader2, None)
        if first is None:
            raise ValueError("CSV file is empty.")
        fieldnames = [f"col_{i+1}" for i in range(len(first))]

        rows2: List[Dict[str, str]] = [dict(zip(fieldnames, first))]
        for r in reader2:
            if not r:
                continue
            rows2.append(dict(zip(fieldnames, r)))
        return fieldnames, rows2


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Compute mean/min/max/sum for numeric columns in a CSV file."
    )
    parser.add_argument("csv_path", help="Path to CSV file")
    parser.add_argument(
        "--encoding",
        default="utf-8",
        help="File encoding (default: utf-8). Example: cp1251",
    )
    args = parser.parse_args()

    path = Path(args.csv_path)
    if not path.exists():
        raise SystemExit(f"File not found: {path}")
    if not path.is_file():
        raise SystemExit(f"Not a file: {path}")

    fieldnames, rows = _read_rows(path, args.encoding)
    values_by_col: Dict[str, List[float]] = {name: [] for name in fieldnames}

    for row in rows:
        for name in fieldnames:
            raw = row.get(name, "")
            if raw is None:
                continue
            v = _to_float(raw)
            if v is None:
                continue
            values_by_col[name].append(v)

    printed_any = False
    for name in fieldnames:
        vals = values_by_col[name]
        if not vals:
            continue
        printed_any = True
        print(f"Column: {name}")
        print(f"  count: {len(vals)}")
        print(f"  mean : {statistics.mean(vals)}")
        print(f"  min  : {min(vals)}")
        print(f"  max  : {max(vals)}")
        print(f"  sum  : {sum(vals)}")
        print()

    if not printed_any:
        print("No numeric columns found (or all numeric values are empty).")

    return 0


if __name__ == "__main__":
    raise SystemExit(main())