fakegen.py

#!/usr/bin/env python3
"""
fakegen -- Generate realistic fake data from the CLI. Zero deps.

Create test data instantly: names, emails, users, products, orders.
Output as lines, CSV, JSON, SQL, or markdown. Seed for reproducibility.

Usage:
    py fakegen.py name 10                      # 10 random names
    py fakegen.py email 5                      # 5 random emails
    py fakegen.py user 10 --format csv         # 10 fake users as CSV
    py fakegen.py user 5 --format json         # 5 fake users as JSON
    py fakegen.py product 20 --format sql      # 20 SQL INSERT statements
    py fakegen.py employee 10 --format md      # Markdown table
    py fakegen.py --list                       # Show all generators
    py fakegen.py --seed 42 user 10            # Reproducible output
"""

import argparse
import csv
import io
import json
import random
import string
import sys
import uuid
from datetime import datetime, timedelta

# --- Embedded data pools ---
FIRST_NAMES = [
    "Alice", "Bob", "Carol", "Dave", "Eve", "Frank", "Grace", "Hank", "Ivy", "Jack",
    "Kate", "Leo", "Mia", "Noah", "Olivia", "Pete", "Quinn", "Ruby", "Sam", "Tara",
    "Uma", "Vince", "Wendy", "Xander", "Yara", "Zach", "Aria", "Ben", "Chloe", "Dylan",
    "Emma", "Finn", "Gina", "Hugo", "Iris", "Jake", "Kira", "Luke", "Maya", "Nate",
    "Opal", "Paul", "Rae", "Sean", "Tina", "Uri", "Val", "Wade", "Xena", "Yuki",
    "Zara", "Aiden", "Blair", "Cruz", "Dana", "Eli", "Fay", "Gray", "Hope", "Ivan",
]
LAST_NAMES = [
    "Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis",
    "Wilson", "Moore", "Taylor", "Anderson", "Thomas", "Jackson", "White", "Harris",
    "Martin", "Thompson", "Robinson", "Clark", "Lewis", "Lee", "Walker", "Hall",
    "Allen", "Young", "King", "Wright", "Scott", "Green", "Baker", "Adams", "Nelson",
    "Hill", "Campbell", "Mitchell", "Roberts", "Carter", "Phillips", "Evans",
    "Turner", "Torres", "Parker", "Collins", "Edwards", "Stewart", "Morris", "Reed",
]
DOMAINS = [
    "gmail.com", "yahoo.com", "outlook.com", "proton.me", "icloud.com",
    "hotmail.com", "fastmail.com", "zoho.com", "mail.com", "aol.com",
]
COMPANY_DOMAINS = [
    "acme.com", "globex.io", "initech.com", "umbrella.co", "stark.dev",
    "wayne.tech", "lexcorp.com", "oscorp.io", "aperture.dev", "cyberdyne.ai",
]
CITIES = [
    "New York", "London", "Tokyo", "Paris", "Berlin", "Sydney", "Toronto",
    "Singapore", "Dubai", "Mumbai", "Seoul", "Amsterdam", "Stockholm",
    "Barcelona", "San Francisco", "Chicago", "Austin", "Denver", "Seattle",
    "Portland", "Boston", "Miami", "Dublin", "Zurich", "Vienna",
]
COUNTRIES = [
    "US", "UK", "JP", "DE", "FR", "AU", "CA", "SG", "AE", "IN",
    "KR", "NL", "SE", "ES", "CH", "IE", "AT", "IT", "BR", "NZ",
]
STREETS = [
    "Main St", "Oak Ave", "Cedar Ln", "Elm Dr", "Park Blvd", "Pine Rd",
    "Maple Way", "River Rd", "Lake Dr", "Hill St", "Valley Rd", "Forest Ave",
    "Spring St", "Sunset Blvd", "Broadway", "Church St", "Market St",
    "High St", "King St", "Queen St", "Victoria Rd", "Station Rd",
]
COMPANIES = [
    "Acme Corp", "Globex Inc", "Initech", "Umbrella Co", "Stark Industries",
    "Wayne Enterprises", "LexCorp", "Oscorp", "Aperture Science", "Cyberdyne Systems",
    "Weyland-Yutani", "Soylent Corp", "Tyrell Corp", "Massive Dynamic",
    "Hooli", "Pied Piper", "Delos Inc", "InGen", "Wonka Industries",
    "Dharma Initiative", "Gekko & Co", "Sterling Cooper", "TechCrunch Labs",
]
JOB_TITLES = [
    "Software Engineer", "Product Manager", "Designer", "Data Scientist",
    "DevOps Engineer", "QA Engineer", "Frontend Developer", "Backend Developer",
    "CTO", "VP Engineering", "Tech Lead", "Architect", "SRE",
    "Full Stack Developer", "ML Engineer", "Security Engineer", "DBA",
    "Scrum Master", "Project Manager", "Engineering Manager",
]
DEPARTMENTS = [
    "Engineering", "Marketing", "Sales", "Finance", "HR", "Operations",
    "Legal", "Customer Support", "Product", "Design", "Data", "Security",
]
PRODUCTS = [
    "Widget Pro", "Gadget X", "ThingaMajig", "SuperTool", "MegaApp",
    "CloudSync", "DataVault", "SmartDash", "QuickPay", "AutoBot",
    "StreamLine", "NetGuard", "CodeForge", "PixelPerfect", "LogicFlow",
    "TaskMaster", "ByteShift", "ClearView", "CoreStack", "FlexGrid",
]
CATEGORIES = [
    "Electronics", "Software", "Hardware", "Services", "Accessories",
    "Tools", "Books", "Gaming", "Health", "Food", "Education", "Security",
]
LOREM_WORDS = [
    "lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing",
    "elit", "sed", "do", "eiusmod", "tempor", "incididunt", "ut", "labore",
    "magna", "aliqua", "enim", "minim", "veniam", "quis", "nostrud",
    "exercitation", "ullamco", "laboris", "nisi", "aliquip", "commodo",
    "consequat", "duis", "aute", "irure", "voluptate", "velit", "esse",
    "cillum", "fugiat", "nulla", "pariatur", "excepteur", "sint", "occaecat",
    "cupidatat", "proident", "sunt", "culpa", "deserunt", "mollit", "anim",
]
STATUS_OPTIONS = ["active", "inactive", "pending", "suspended", "archived"]
LOG_LEVELS = ["INFO", "WARN", "ERROR", "DEBUG"]
HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH"]
HTTP_PATHS = ["/api/users", "/api/orders", "/api/products", "/api/auth", "/api/search",
              "/api/health", "/api/config", "/api/upload", "/api/webhook", "/api/metrics"]
HTTP_STATUSES = [200, 200, 200, 200, 201, 204, 301, 400, 401, 403, 404, 500, 502, 503]

# --- Single value generators ---

def gen_name(_r: random.Random) -> str:
    return f"{_r.choice(FIRST_NAMES)} {_r.choice(LAST_NAMES)}"

def gen_first_name(_r: random.Random) -> str:
    return _r.choice(FIRST_NAMES)

def gen_last_name(_r: random.Random) -> str:
    return _r.choice(LAST_NAMES)

def gen_email(_r: random.Random) -> str:
    first = _r.choice(FIRST_NAMES).lower()
    last = _r.choice(LAST_NAMES).lower()
    sep = _r.choice([".", "_", ""])
    num = _r.choice(["", str(_r.randint(1, 99))])
    return f"{first}{sep}{last}{num}@{_r.choice(DOMAINS)}"

def gen_company_email(_r: random.Random) -> str:
    first = _r.choice(FIRST_NAMES).lower()
    last = _r.choice(LAST_NAMES).lower()
    return f"{first}.{last}@{_r.choice(COMPANY_DOMAINS)}"

def gen_phone(_r: random.Random) -> str:
    return f"+1-{_r.randint(200,999)}-{_r.randint(200,999)}-{_r.randint(1000,9999)}"

def gen_address(_r: random.Random) -> str:
    return f"{_r.randint(1,9999)} {_r.choice(STREETS)}, {_r.choice(CITIES)}"

def gen_city(_r: random.Random) -> str:
    return _r.choice(CITIES)

def gen_country(_r: random.Random) -> str:
    return _r.choice(COUNTRIES)

def gen_company(_r: random.Random) -> str:
    return _r.choice(COMPANIES)

def gen_job(_r: random.Random) -> str:
    return _r.choice(JOB_TITLES)

def gen_department(_r: random.Random) -> str:
    return _r.choice(DEPARTMENTS)

def gen_ip(_r: random.Random) -> str:
    return f"{_r.randint(1,254)}.{_r.randint(0,255)}.{_r.randint(0,255)}.{_r.randint(1,254)}"

def gen_url(_r: random.Random) -> str:
    return f"https://{_r.choice(COMPANY_DOMAINS)}/{_r.choice(LOREM_WORDS)}/{_r.choice(LOREM_WORDS)}"

def gen_uuid(_r: random.Random) -> str:
    return str(uuid.UUID(int=_r.getrandbits(128), version=4))

def gen_date(_r: random.Random) -> str:
    days = _r.randint(0, 365 * 5)
    d = datetime(2020, 1, 1) + timedelta(days=days)
    return d.strftime("%Y-%m-%d")

def gen_datetime(_r: random.Random) -> str:
    days = _r.randint(0, 365 * 5)
    secs = _r.randint(0, 86400)
    d = datetime(2020, 1, 1) + timedelta(days=days, seconds=secs)
    return d.strftime("%Y-%m-%dT%H:%M:%SZ")

def gen_int(_r: random.Random) -> str:
    return str(_r.randint(1, 10000))

def gen_float(_r: random.Random) -> str:
    return f"{_r.uniform(0, 1000):.2f}"

def gen_bool(_r: random.Random) -> str:
    return str(_r.choice([True, False])).lower()

def gen_color(_r: random.Random) -> str:
    return f"#{_r.randint(0, 0xFFFFFF):06x}"

def gen_word(_r: random.Random) -> str:
    return _r.choice(LOREM_WORDS)

def gen_sentence(_r: random.Random) -> str:
    n = _r.randint(5, 12)
    words = [_r.choice(LOREM_WORDS) for _ in range(n)]
    words[0] = words[0].capitalize()
    return " ".join(words) + "."

def gen_paragraph(_r: random.Random) -> str:
    return " ".join(gen_sentence(_r) for _ in range(_r.randint(3, 6)))

def gen_password(_r: random.Random) -> str:
    chars = string.ascii_letters + string.digits + "!@#$%"
    return "".join(_r.choice(chars) for _ in range(16))

def gen_product(_r: random.Random) -> str:
    return _r.choice(PRODUCTS)

def gen_category(_r: random.Random) -> str:
    return _r.choice(CATEGORIES)

def gen_status(_r: random.Random) -> str:
    return _r.choice(STATUS_OPTIONS)

def gen_price(_r: random.Random) -> str:
    return f"{_r.uniform(1, 500):.2f}"

# --- Templates (structured records) ---

def tmpl_user(_r: random.Random) -> dict:
    first, last = _r.choice(FIRST_NAMES), _r.choice(LAST_NAMES)
    return {
        "id": _r.randint(1000, 99999),
        "name": f"{first} {last}",
        "email": f"{first.lower()}.{last.lower()}@{_r.choice(DOMAINS)}",
        "phone": gen_phone(_r),
        "city": _r.choice(CITIES),
        "status": _r.choice(STATUS_OPTIONS),
        "created": gen_date(_r),
    }

def tmpl_employee(_r: random.Random) -> dict:
    first, last = _r.choice(FIRST_NAMES), _r.choice(LAST_NAMES)
    return {
        "id": _r.randint(1000, 99999),
        "name": f"{first} {last}",
        "email": f"{first.lower()}.{last.lower()}@{_r.choice(COMPANY_DOMAINS)}",
        "department": _r.choice(DEPARTMENTS),
        "title": _r.choice(JOB_TITLES),
        "salary": _r.randint(45, 180) * 1000,
        "start_date": gen_date(_r),
    }

def tmpl_product(_r: random.Random) -> dict:
    return {
        "id": _r.randint(1000, 99999),
        "name": _r.choice(PRODUCTS),
        "category": _r.choice(CATEGORIES),
        "price": round(_r.uniform(5, 500), 2),
        "stock": _r.randint(0, 1000),
        "rating": round(_r.uniform(1, 5), 1),
    }

def tmpl_order(_r: random.Random) -> dict:
    qty = _r.randint(1, 10)
    price = round(_r.uniform(10, 200), 2)
    return {
        "order_id": gen_uuid(_r)[:8],
        "customer": gen_name(_r),
        "product": _r.choice(PRODUCTS),
        "quantity": qty,
        "unit_price": price,
        "total": round(qty * price, 2),
        "status": _r.choice(["pending", "shipped", "delivered", "cancelled"]),
        "date": gen_date(_r),
    }

def tmpl_company(_r: random.Random) -> dict:
    return {
        "name": _r.choice(COMPANIES),
        "industry": _r.choice(["Tech", "Finance", "Healthcare", "Retail", "Energy", "Media"]),
        "employees": _r.randint(10, 50000),
        "revenue_m": _r.randint(1, 5000),
        "city": _r.choice(CITIES),
        "country": _r.choice(COUNTRIES),
        "founded": _r.randint(1950, 2024),
    }

def tmpl_event(_r: random.Random) -> dict:
    return {
        "id": gen_uuid(_r)[:8],
        "type": _r.choice(["click", "pageview", "signup", "purchase", "logout", "error"]),
        "user_id": _r.randint(1000, 99999),
        "timestamp": gen_datetime(_r),
        "ip": gen_ip(_r),
        "path": _r.choice(HTTP_PATHS),
    }

def tmpl_log_entry(_r: random.Random) -> dict:
    return {
        "timestamp": gen_datetime(_r),
        "level": _r.choice(LOG_LEVELS),
        "message": gen_sentence(_r),
        "service": _r.choice(["api", "web", "worker", "db", "cache", "auth"]),
        "request_id": gen_uuid(_r)[:8],
    }

# --- Registries ---

SINGLE_GENERATORS = {
    "name": gen_name, "first_name": gen_first_name, "last_name": gen_last_name,
    "email": gen_email, "company_email": gen_company_email, "phone": gen_phone,
    "address": gen_address, "city": gen_city, "country": gen_country,
    "company": gen_company, "job": gen_job, "department": gen_department,
    "ip": gen_ip, "url": gen_url, "uuid": gen_uuid,
    "date": gen_date, "datetime": gen_datetime,
    "int": gen_int, "float": gen_float, "bool": gen_bool,
    "color": gen_color, "word": gen_word, "sentence": gen_sentence,
    "paragraph": gen_paragraph, "password": gen_password,
    "product": gen_product, "category": gen_category,
    "status": gen_status, "price": gen_price,
}

TEMPLATE_GENERATORS = {
    "user": tmpl_user, "employee": tmpl_employee, "product": tmpl_product,
    "order": tmpl_order, "company": tmpl_company, "event": tmpl_event,
    "log_entry": tmpl_log_entry,
}


# --- Output formatters ---

def output_lines(data, _headers=None):
    for item in data:
        if isinstance(item, dict):
            print(json.dumps(item))
        else:
            print(item)

def output_csv(data, headers=None):
    if not data:
        return
    if isinstance(data[0], dict):
        headers = headers or list(data[0].keys())
        writer = csv.DictWriter(sys.stdout, fieldnames=headers, lineterminator="\n")
        writer.writeheader()
        for row in data:
            writer.writerow({k: str(v) for k, v in row.items()})
    else:
        for item in data:
            print(item)

def output_json(data, _headers=None):
    if data and isinstance(data[0], dict):
        print(json.dumps(data, indent=2, default=str))
    else:
        print(json.dumps(data, indent=2))

def output_sql(data, headers=None):
    if not data or not isinstance(data[0], dict):
        print("-- SQL output requires template generators (user, product, etc.)")
        return
    table = "data"
    for row in data:
        cols = ", ".join(row.keys())
        vals = ", ".join(f"'{str(v).replace(chr(39), chr(39)+chr(39))}'" for v in row.values())
        print(f"INSERT INTO {table} ({cols}) VALUES ({vals});")

def output_md(data, headers=None):
    if not data or not isinstance(data[0], dict):
        return
    headers = headers or list(data[0].keys())
    widths = {h: len(str(h)) for h in headers}
    for row in data:
        for h in headers:
            widths[h] = max(widths[h], len(str(row.get(h, ""))))
    print("| " + " | ".join(h.ljust(widths[h]) for h in headers) + " |")
    print("| " + " | ".join("-" * widths[h] for h in headers) + " |")
    for row in data:
        print("| " + " | ".join(str(row.get(h, "")).ljust(widths[h]) for h in headers) + " |")


FORMATTERS = {
    "lines": output_lines, "csv": output_csv, "json": output_json,
    "sql": output_sql, "md": output_md,
}


def list_generators():
    print("\n  Available generators:\n")
    print("  Single values:")
    for name in sorted(SINGLE_GENERATORS):
        print(f"    {name}")
    print("\n  Templates (structured records):")
    for name in sorted(TEMPLATE_GENERATORS):
        sample = TEMPLATE_GENERATORS[name](random.Random(42))
        fields = ", ".join(sample.keys())
        print(f"    {name:<15} -> {fields}")
    print(f"\n  Formats: {', '.join(FORMATTERS.keys())}")
    print()


def main():
    parser = argparse.ArgumentParser(
        description="fakegen -- generate realistic fake data",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument("generator", nargs="?", help="Generator name (e.g. name, email, user)")
    parser.add_argument("count", nargs="?", type=int, default=10, help="Number of items (default: 10)")
    parser.add_argument("--format", "-F", choices=list(FORMATTERS.keys()), default="lines",
                        help="Output format (default: lines)")
    parser.add_argument("--seed", "-s", type=int, help="Random seed for reproducibility")
    parser.add_argument("--list", "-l", action="store_true", help="List available generators")
    parser.add_argument("--table", "-t", help="Table name for SQL output (default: data)")

    args = parser.parse_args()

    if args.list or not args.generator:
        list_generators()
        return

    _r = random.Random(args.seed) if args.seed is not None else random.Random()
    gen_name_str = args.generator.lower().replace("-", "_")

    # Templates take priority (richer output for structured formats)
    if gen_name_str in TEMPLATE_GENERATORS:
        pass  # handled below
    elif gen_name_str in SINGLE_GENERATORS:
        gen_fn = SINGLE_GENERATORS[gen_name_str]
        data = [gen_fn(_r) for _ in range(args.count)]
        # For single generators with structured format, wrap in dicts
        if args.format in ("csv", "json", "sql", "md"):
            data = [{gen_name_str: v} for v in data]
        formatter = FORMATTERS[args.format]
        formatter(data)
        return

    if gen_name_str in TEMPLATE_GENERATORS:
        tmpl_fn = TEMPLATE_GENERATORS[gen_name_str]
        data = [tmpl_fn(_r) for _ in range(args.count)]
    else:
        print(f"Error: unknown generator '{args.generator}'", file=sys.stderr)
        print(f"Use --list to see available generators", file=sys.stderr)
        sys.exit(1)

    formatter = FORMATTERS[args.format]
    formatter(data)


if __name__ == "__main__":
    main()