Datasets:

SkillEvolBench-Team
/

Skill-Evol-Bench

import os
import random
import sqlite3
from datetime import date, timedelta

random.seed(1337)

DB_PATH = "store.db"


def ensure_project_dir():
    os.makedirs(".", exist_ok=True)


def remove_zero_width(s: str) -> str:
    for ch in ("\u200b", "\u200c", "\u200d", "\ufeff"):
        s = s.replace(ch, "")
    return s


def normalize_email(email):
    if email is None:
        return None
    s = str(email).strip().lower()
    s = remove_zero_width(s)
    if s in ("", "null", "none", "na"):
        return None
    return s


def random_signup():
    start = date(2020, 1, 1)
    return (start + timedelta(days=random.randint(0, 1600))).isoformat()


def random_order_date_valid():
    d = date(2023, 1, 1) + timedelta(days=random.randint(0, 730))
    fmt = random.choice(["iso", "slash", "us"])
    if fmt == "iso":
        return d.strftime("%Y-%m-%d")
    if fmt == "slash":
        return d.strftime("%Y/%m/%d")
    return d.strftime("%m/%d/%Y")


def random_order_date_invalid():
    return random.choice(
        [
            "2024-13-01",
            "2024/99/99",
            "31/31/2024",
            "not-a-date",
            "",
            "2024-02-30",
        ]
    )


def amount_to_storage(value):
    style = random.choice(
        ["float", "plain", "ws", "currency", "comma", "currency_ws"]
    )
    if style == "float":
        return round(value, 2)
    if style == "plain":
        return f"{value:.2f}"
    if style == "ws":
        return f"  {value:.2f}  "
    if style == "currency":
        return f"${value:.2f}"
    if style == "comma":
        return f"{value:,.2f}"
    return f"  ${value:,.2f}  "


def bad_amount():
    return random.choice(
        ["", "abc", "null", "None", "$", "1,2,3", "12.3.4", "  ", None]
    )


def status_variant(base):
    variants = {
        "paid": ["paid", "PAID", " paid ", "Paid"],
        "shipped": ["shipped", "SHIPPED", " shipped ", "Shipped"],
        "bad": ["pending", "cancelled", "refunded", " failed ", "", "unknown"],
    }
    return random.choice(variants[base])


def source_variant():
    return random.choice(["web", "mobile", "store", "import", "partner"])


def main():
    ensure_project_dir()
    if os.path.exists(DB_PATH):
        os.remove(DB_PATH)

    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()

    cur.execute(
        """
        CREATE TABLE customers (
            id INTEGER PRIMARY KEY,
            name TEXT,
            email TEXT,
            city TEXT,
            signup_date TEXT
        )
        """
    )

    cur.execute(
        """
        CREATE TABLE orders (
            id INTEGER PRIMARY KEY,
            customer_id INTEGER,
            amount,
            order_date TEXT,
            status TEXT,
            source TEXT
        )
        """
    )

    customer_rows = []
    logical_customers = []

    cities = ["New York", "Chicago", "Dallas", "Seattle", "Austin", "Miami"]

    # 900 unique-email logical customers
    next_customer_id = 1
    for i in range(1, 901):
        email = f"customer{i:04d}@example.com"
        row = (
            next_customer_id,
            f"Customer_{i:04d}",
            email,
            random.choice(cities),
            random_signup(),
        )
        customer_rows.append(row)
        logical_customers.append(
            {
                "canonical_id": next_customer_id,
                "all_ids": [next_customer_id],
                "name": row[1],
                "norm_email": normalize_email(email),
            }
        )
        next_customer_id += 1

    # 50 duplicate groups, each with 2 rows => 50 logical customers, 100 physical rows
    for i in range(901, 951):
        base_email = f"dup{i:04d}@example.com"
        email1 = base_email.upper()
        email2 = " \u200b" + base_email + " "
        id1 = next_customer_id
        customer_rows.append(
            (
                id1,
                f"Customer_{i:04d}_A",
                email1,
                random.choice(cities),
                random_signup(),
            )
        )
        next_customer_id += 1
        id2 = next_customer_id
        customer_rows.append(
            (
                id2,
                f"Customer_{i:04d}_B",
                email2,
                random.choice(cities),
                random_signup(),
            )
        )
        next_customer_id += 1
        logical_customers.append(
            {
                "canonical_id": min(id1, id2),
                "all_ids": [id1, id2],
                "name": f"Customer_{i:04d}_A",
                "norm_email": normalize_email(base_email),
            }
        )

    # 50 missing-email customers, each remains distinct logical customer
    missing_email_values = [None, "", " ", "NULL", "None", "na", "\u200b", " NA "]
    for i in range(951, 1001):
        email = random.choice(missing_email_values)
        row = (
            next_customer_id,
            f"Customer_{i:04d}",
            email,
            random.choice(cities),
            random_signup(),
        )
        customer_rows.append(row)
        logical_customers.append(
            {
                "canonical_id": next_customer_id,
                "all_ids": [next_customer_id],
                "name": row[1],
                "norm_email": None,
            }
        )
        next_customer_id += 1

    cur.executemany(
        "INSERT INTO customers (id, name, email, city, signup_date) VALUES (?, ?, ?, ?, ?)",
        customer_rows,
    )

    # Orders
    order_rows = []
    next_order_id = 1

    # 700 logical customers active, 300 inactive
    active_indices = set(random.sample(range(len(logical_customers)), 700))

    for idx, logical in enumerate(logical_customers):
        ids = logical["all_ids"]
        if idx in active_indices:
            # 1-6 qualifying orders, spread across duplicate ids if any
            qcount = random.randint(1, 6)
            for _ in range(qcount):
                cust_id = random.choice(ids)
                amount = round(random.uniform(5, 2500), 2)
                order_rows.append(
                    (
                        next_order_id,
                        cust_id,
                        amount_to_storage(amount),
                        random_order_date_valid(),
                        status_variant(random.choice(["paid", "shipped"])),
                        source_variant(),
                    )
                )
                next_order_id += 1

            # plus 0-3 junk orders for same logical customer
            for _ in range(random.randint(0, 3)):
                cust_id = random.choice(ids)
                junk_kind = random.choice(["bad_status", "bad_amount", "bad_date", "nonpos"])
                if junk_kind == "bad_status":
                    amount = round(random.uniform(5, 500), 2)
                    order_rows.append(
                        (
                            next_order_id,
                            cust_id,
                            amount_to_storage(amount),
                            random_order_date_valid(),
                            status_variant("bad"),
                            source_variant(),
                        )
                    )
                elif junk_kind == "bad_amount":
                    order_rows.append(
                        (
                            next_order_id,
                            cust_id,
                            bad_amount(),
                            random_order_date_valid(),
                            status_variant(random.choice(["paid", "shipped"])),
                            source_variant(),
                        )
                    )
                elif junk_kind == "bad_date":
                    amount = round(random.uniform(5, 500), 2)
                    order_rows.append(
                        (
                            next_order_id,
                            cust_id,
                            amount_to_storage(amount),
                            random_order_date_invalid(),
                            status_variant(random.choice(["paid", "shipped"])),
                            source_variant(),
                        )
                    )
                else:
                    amount = random.choice([0, "0", "0.00", -5, "-10.00", "$0.00"])
                    order_rows.append(
                        (
                            next_order_id,
                            cust_id,
                            amount,
                            random_order_date_valid(),
                            status_variant(random.choice(["paid", "shipped"])),
                            source_variant(),
                        )
                    )
                next_order_id += 1
        else:
            # inactive logical customers may still have only non-qualifying orders
            for _ in range(random.randint(0, 2)):
                cust_id = random.choice(ids)
                junk_kind = random.choice(["bad_status", "bad_amount", "bad_date", "nonpos"])
                if junk_kind == "bad_status":
                    amount = round(random.uniform(5, 500), 2)
                    order_rows.append(
                        (
                            next_order_id,
                            cust_id,
                            amount_to_storage(amount),
                            random_order_date_valid(),
                            status_variant("bad"),
                            source_variant(),
                        )
                    )
                elif junk_kind == "bad_amount":
                    order_rows.append(
                        (
                            next_order_id,
                            cust_id,
                            bad_amount(),
                            random_order_date_valid(),
                            status_variant(random.choice(["paid", "shipped"])),
                            source_variant(),
                        )
                    )
                elif junk_kind == "bad_date":
                    amount = round(random.uniform(5, 500), 2)
                    order_rows.append(
                        (
                            next_order_id,
                            cust_id,
                            amount_to_storage(amount),
                            random_order_date_invalid(),
                            status_variant(random.choice(["paid", "shipped"])),
                            source_variant(),
                        )
                    )
                else:
                    amount = random.choice([0, "0", "0.00", -1, "-2.50", "$0.00"])
                    order_rows.append(
                        (
                            next_order_id,
                            cust_id,
                            amount,
                            random_order_date_valid(),
                            status_variant(random.choice(["paid", "shipped"])),
                            source_variant(),
                        )
                    )
                next_order_id += 1

    # Add orphan orders with nonexistent customer ids
    for _ in range(120):
        fake_customer_id = random.randint(5000, 7000)
        amount = round(random.uniform(10, 900), 2)
        order_rows.append(
            (
                next_order_id,
                fake_customer_id,
                amount_to_storage(amount),
                random_order_date_valid(),
                status_variant(random.choice(["paid", "shipped"])),
                source_variant(),
            )
        )
        next_order_id += 1

    cur.executemany(
        """
        INSERT INTO orders (id, customer_id, amount, order_date, status, source)
        VALUES (?, ?, ?, ?, ?, ?)
        """,
        order_rows,
    )

    conn.commit()
    conn.close()

    print(
        f"Generated {len(customer_rows)} customer rows, "
        f"{len(logical_customers)} logical customers, "
        f"{len(order_rows)} orders."
    )


if __name__ == "__main__":
    main()

	import os
	import random
	import sqlite3
	from datetime import date, timedelta

	random.seed(1337)

	DB_PATH = "store.db"


	def ensure_project_dir():
	os.makedirs(".", exist_ok=True)


	def remove_zero_width(s: str) -> str:
	for ch in ("\u200b", "\u200c", "\u200d", "\ufeff"):
	s = s.replace(ch, "")
	return s


	def normalize_email(email):
	if email is None:
	return None
	s = str(email).strip().lower()
	s = remove_zero_width(s)
	if s in ("", "null", "none", "na"):
	return None
	return s


	def random_signup():
	start = date(2020, 1, 1)
	return (start + timedelta(days=random.randint(0, 1600))).isoformat()


	def random_order_date_valid():
	d = date(2023, 1, 1) + timedelta(days=random.randint(0, 730))
	fmt = random.choice(["iso", "slash", "us"])
	if fmt == "iso":
	return d.strftime("%Y-%m-%d")
	if fmt == "slash":
	return d.strftime("%Y/%m/%d")
	return d.strftime("%m/%d/%Y")


	def random_order_date_invalid():
	return random.choice(
	[
	"2024-13-01",
	"2024/99/99",
	"31/31/2024",
	"not-a-date",
	"",
	"2024-02-30",
	]
	)


	def amount_to_storage(value):
	style = random.choice(
	["float", "plain", "ws", "currency", "comma", "currency_ws"]
	)
	if style == "float":
	return round(value, 2)
	if style == "plain":
	return f"{value:.2f}"
	if style == "ws":
	return f" {value:.2f} "
	if style == "currency":
	return f"${value:.2f}"
	if style == "comma":
	return f"{value:,.2f}"
	return f" ${value:,.2f} "


	def bad_amount():
	return random.choice(
	["", "abc", "null", "None", "$", "1,2,3", "12.3.4", " ", None]
	)


	def status_variant(base):
	variants = {
	"paid": ["paid", "PAID", " paid ", "Paid"],
	"shipped": ["shipped", "SHIPPED", " shipped ", "Shipped"],
	"bad": ["pending", "cancelled", "refunded", " failed ", "", "unknown"],
	}
	return random.choice(variants[base])


	def source_variant():
	return random.choice(["web", "mobile", "store", "import", "partner"])


	def main():
	ensure_project_dir()
	if os.path.exists(DB_PATH):
	os.remove(DB_PATH)

	conn = sqlite3.connect(DB_PATH)
	cur = conn.cursor()

	cur.execute(
	"""
	CREATE TABLE customers (
	id INTEGER PRIMARY KEY,
	name TEXT,
	email TEXT,
	city TEXT,
	signup_date TEXT
	)
	"""
	)

	cur.execute(
	"""
	CREATE TABLE orders (
	id INTEGER PRIMARY KEY,
	customer_id INTEGER,
	amount,
	order_date TEXT,
	status TEXT,
	source TEXT
	)
	"""
	)

	customer_rows = []
	logical_customers = []

	cities = ["New York", "Chicago", "Dallas", "Seattle", "Austin", "Miami"]

	# 900 unique-email logical customers
	next_customer_id = 1
	for i in range(1, 901):
	email = f"customer{i:04d}@example.com"
	row = (
	next_customer_id,
	f"Customer_{i:04d}",
	email,
	random.choice(cities),
	random_signup(),
	)
	customer_rows.append(row)
	logical_customers.append(
	{
	"canonical_id": next_customer_id,
	"all_ids": [next_customer_id],
	"name": row[1],
	"norm_email": normalize_email(email),
	}
	)
	next_customer_id += 1

	# 50 duplicate groups, each with 2 rows => 50 logical customers, 100 physical rows
	for i in range(901, 951):
	base_email = f"dup{i:04d}@example.com"
	email1 = base_email.upper()
	email2 = " \u200b" + base_email + " "
	id1 = next_customer_id
	customer_rows.append(
	(
	id1,
	f"Customer_{i:04d}_A",
	email1,
	random.choice(cities),
	random_signup(),
	)
	)
	next_customer_id += 1
	id2 = next_customer_id
	customer_rows.append(
	(
	id2,
	f"Customer_{i:04d}_B",
	email2,
	random.choice(cities),
	random_signup(),
	)
	)
	next_customer_id += 1
	logical_customers.append(
	{
	"canonical_id": min(id1, id2),
	"all_ids": [id1, id2],
	"name": f"Customer_{i:04d}_A",
	"norm_email": normalize_email(base_email),
	}
	)

	# 50 missing-email customers, each remains distinct logical customer
	missing_email_values = [None, "", " ", "NULL", "None", "na", "\u200b", " NA "]
	for i in range(951, 1001):
	email = random.choice(missing_email_values)
	row = (
	next_customer_id,
	f"Customer_{i:04d}",
	email,
	random.choice(cities),
	random_signup(),
	)
	customer_rows.append(row)
	logical_customers.append(
	{
	"canonical_id": next_customer_id,
	"all_ids": [next_customer_id],
	"name": row[1],
	"norm_email": None,
	}
	)
	next_customer_id += 1

	cur.executemany(
	"INSERT INTO customers (id, name, email, city, signup_date) VALUES (?, ?, ?, ?, ?)",
	customer_rows,
	)

	# Orders
	order_rows = []
	next_order_id = 1

	# 700 logical customers active, 300 inactive
	active_indices = set(random.sample(range(len(logical_customers)), 700))

	for idx, logical in enumerate(logical_customers):
	ids = logical["all_ids"]
	if idx in active_indices:
	# 1-6 qualifying orders, spread across duplicate ids if any
	qcount = random.randint(1, 6)
	for _ in range(qcount):
	cust_id = random.choice(ids)
	amount = round(random.uniform(5, 2500), 2)
	order_rows.append(
	(
	next_order_id,
	cust_id,
	amount_to_storage(amount),
	random_order_date_valid(),
	status_variant(random.choice(["paid", "shipped"])),
	source_variant(),
	)
	)
	next_order_id += 1

	# plus 0-3 junk orders for same logical customer
	for _ in range(random.randint(0, 3)):
	cust_id = random.choice(ids)
	junk_kind = random.choice(["bad_status", "bad_amount", "bad_date", "nonpos"])
	if junk_kind == "bad_status":
	amount = round(random.uniform(5, 500), 2)
	order_rows.append(
	(
	next_order_id,
	cust_id,
	amount_to_storage(amount),
	random_order_date_valid(),
	status_variant("bad"),
	source_variant(),
	)
	)
	elif junk_kind == "bad_amount":
	order_rows.append(
	(
	next_order_id,
	cust_id,
	bad_amount(),
	random_order_date_valid(),
	status_variant(random.choice(["paid", "shipped"])),
	source_variant(),
	)
	)
	elif junk_kind == "bad_date":
	amount = round(random.uniform(5, 500), 2)
	order_rows.append(
	(
	next_order_id,
	cust_id,
	amount_to_storage(amount),
	random_order_date_invalid(),
	status_variant(random.choice(["paid", "shipped"])),
	source_variant(),
	)
	)
	else:
	amount = random.choice([0, "0", "0.00", -5, "-10.00", "$0.00"])
	order_rows.append(
	(
	next_order_id,
	cust_id,
	amount,
	random_order_date_valid(),
	status_variant(random.choice(["paid", "shipped"])),
	source_variant(),
	)
	)
	next_order_id += 1
	else:
	# inactive logical customers may still have only non-qualifying orders
	for _ in range(random.randint(0, 2)):
	cust_id = random.choice(ids)
	junk_kind = random.choice(["bad_status", "bad_amount", "bad_date", "nonpos"])
	if junk_kind == "bad_status":
	amount = round(random.uniform(5, 500), 2)
	order_rows.append(
	(
	next_order_id,
	cust_id,
	amount_to_storage(amount),
	random_order_date_valid(),
	status_variant("bad"),
	source_variant(),
	)
	)
	elif junk_kind == "bad_amount":
	order_rows.append(
	(
	next_order_id,
	cust_id,
	bad_amount(),
	random_order_date_valid(),
	status_variant(random.choice(["paid", "shipped"])),
	source_variant(),
	)
	)
	elif junk_kind == "bad_date":
	amount = round(random.uniform(5, 500), 2)
	order_rows.append(
	(
	next_order_id,
	cust_id,
	amount_to_storage(amount),
	random_order_date_invalid(),
	status_variant(random.choice(["paid", "shipped"])),
	source_variant(),
	)
	)
	else:
	amount = random.choice([0, "0", "0.00", -1, "-2.50", "$0.00"])
	order_rows.append(
	(
	next_order_id,
	cust_id,
	amount,
	random_order_date_valid(),
	status_variant(random.choice(["paid", "shipped"])),
	source_variant(),
	)
	)
	next_order_id += 1

	# Add orphan orders with nonexistent customer ids
	for _ in range(120):
	fake_customer_id = random.randint(5000, 7000)
	amount = round(random.uniform(10, 900), 2)
	order_rows.append(
	(
	next_order_id,
	fake_customer_id,
	amount_to_storage(amount),
	random_order_date_valid(),
	status_variant(random.choice(["paid", "shipped"])),
	source_variant(),
	)
	)
	next_order_id += 1

	cur.executemany(
	"""
	INSERT INTO orders (id, customer_id, amount, order_date, status, source)
	VALUES (?, ?, ?, ?, ?, ?)
	""",
	order_rows,
	)

	conn.commit()
	conn.close()

	print(
	f"Generated {len(customer_rows)} customer rows, "
	f"{len(logical_customers)} logical customers, "
	f"{len(order_rows)} orders."
	)


	if __name__ == "__main__":
	main()