| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import random |
| from pathlib import Path |
|
|
| from src.domain import ( |
| DEFAULT_SEED, |
| N_ASSIGNMENT, |
| N_INVENTORY, |
| N_PROBLEMS, |
| N_SCHEDULING, |
| AssignmentAgent, |
| AssignmentCost, |
| AssignmentInstance, |
| AssignmentTask, |
| Difficulty, |
| Family, |
| InventoryInstance, |
| InventorySku, |
| ProblemRecord, |
| ScheduleInstance, |
| ScheduleJob, |
| SchedulePrecedence, |
| Split, |
| ) |
| from src.optimizer import solve_instance |
|
|
| DEV_TEMPLATES = ("D-A", "D-B", "D-C") |
| TEST_TEMPLATES = ("T-A", "T-B") |
| SKU_NAMES = ("bearing", "seal", "gasket", "filter", "hose", "valve") |
| SKU_FA = ("بلبرینگ", "آببند", "واشر", "فیلتر", "شیلنگ", "شیر") |
| TASK_SKILLS = ("weld", "inspect", "pack", "lift") |
| INTERACTIVE_IDS = ( |
| "INV-001", |
| "INV-008", |
| "INV-014", |
| "INV-021", |
| "INV-028", |
| "INV-031", |
| "INV-034", |
| "ASN-001", |
| "ASN-006", |
| "ASN-012", |
| "ASN-018", |
| "ASN-024", |
| "ASN-029", |
| "ASN-033", |
| "SCH-001", |
| "SCH-007", |
| "SCH-013", |
| "SCH-019", |
| "SCH-027", |
| "SCH-033", |
| ) |
|
|
|
|
| def _split_for(index: int, n_items: int) -> Split: |
| |
| _ = n_items |
| return Split.DEVELOPMENT if index <= 20 else Split.TEST |
|
|
|
|
| def _difficulty(index: int, n_items: int, infeasible_tail: int) -> Difficulty: |
| if index > n_items - infeasible_tail: |
| return Difficulty.INFEASIBLE |
| if index % 7 == 0: |
| return Difficulty.HARD |
| if index % 3 == 0: |
| return Difficulty.MEDIUM |
| return Difficulty.EASY |
|
|
|
|
| def _template(split: Split, index: int) -> str: |
| pool = DEV_TEMPLATES if split == Split.DEVELOPMENT else TEST_TEMPLATES |
| return pool[(index - 1) % len(pool)] |
|
|
|
|
| def _key(*parts: object) -> str: |
| raw = "|".join(str(item) for item in parts) |
| return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] |
|
|
|
|
| def _wrap_schema(payload: dict, template_id: str) -> str: |
| if template_id.startswith("D-"): |
| return "SCHEMA_BEGIN\n" + json.dumps(payload, ensure_ascii=False) + "\nSCHEMA_END\n" |
| return "" |
|
|
|
|
| def _json_prompt(payload: dict) -> str: |
| return json.dumps(payload, ensure_ascii=False, indent=2) |
|
|
|
|
| def make_inventory(index: int, rng: random.Random) -> tuple[InventoryInstance, str]: |
| difficulty = _difficulty(index, N_INVENTORY, 3) |
| n_sku = 2 if difficulty == Difficulty.EASY else 3 if difficulty != Difficulty.HARD else 4 |
| periods = 3 if difficulty != Difficulty.HARD else 4 |
| cover = difficulty in {Difficulty.HARD, Difficulty.INFEASIBLE} or index % 5 == 0 |
| skus = [] |
| for k in range(n_sku): |
| demand = [rng.randint(2, 8) for _ in range(periods)] |
| pack = rng.choice([1, 2, 3]) |
| skus.append( |
| InventorySku( |
| sku_id=f"S{k + 1}", |
| name=SKU_NAMES[k], |
| demand=demand, |
| initial_stock=rng.randint(0, 3), |
| unit_cost=rng.randint(3, 9), |
| holding_cost=rng.randint(1, 3), |
| shortage_cost=rng.randint(6, 14), |
| pack_size=pack, |
| lead_time=0, |
| ) |
| ) |
| total_need = sum(max(0, sum(sku.demand) - sku.initial_stock) for sku in skus) |
| min_buy = 0 |
| for sku in skus: |
| need = max(0, sum(sku.demand) - sku.initial_stock) |
| packs = (need + sku.pack_size - 1) // sku.pack_size |
| min_buy += packs * sku.pack_size * sku.unit_cost |
| cap = max(8, int(total_need * 0.7) + rng.randint(2, 8)) |
| if difficulty == Difficulty.INFEASIBLE: |
| for sku in skus: |
| sku.initial_stock = 0 |
| sku.demand = [max(3, value) for value in sku.demand] |
| total_need = sum(sum(sku.demand) for sku in skus) |
| min_buy = 0 |
| for sku in skus: |
| packs = (sum(sku.demand) + sku.pack_size - 1) // sku.pack_size |
| min_buy += packs * sku.pack_size * sku.unit_cost |
| budget = max(1, min_buy // 5) |
| cover = True |
| cap = max(6, total_need) |
| elif difficulty == Difficulty.HARD: |
| budget = max(min_buy, int(min_buy * 1.05) + 2) |
| else: |
| budget = min_buy + rng.randint(8, 24) |
| instance = InventoryInstance( |
| periods=periods, |
| budget=int(budget), |
| warehouse_capacity=int(cap), |
| cover_required=cover, |
| lost_sales=True, |
| skus=skus, |
| ) |
| return instance, difficulty.value |
|
|
|
|
| def render_inventory(instance: InventoryInstance, template_id: str, language: str) -> tuple[str, str]: |
| labeled = [] |
| for sku in instance.skus: |
| labeled.append( |
| f"SKU {sku.sku_id} demand={','.join(str(v) for v in sku.demand)} pack={sku.pack_size} " |
| f"cost={sku.unit_cost} hold={sku.holding_cost} short={sku.shortage_cost} stock={sku.initial_stock}" |
| ) |
| labels = ( |
| f"PERIODS: {instance.periods}\nBUDGET: {instance.budget}\nCAPACITY: {instance.warehouse_capacity}\n" |
| f"COVER_REQUIRED: {1 if instance.cover_required else 0}\n" + "\n".join(labeled) |
| ) |
| schema_block = _wrap_schema(instance.model_dump(), template_id) |
| names = ", ".join(f"{sku.sku_id} ({sku.name})" for sku in instance.skus) |
| names_fa = ", ".join(f"{sku.sku_id} ({SKU_FA[int(sku.sku_id[1:]) - 1]})" for sku in instance.skus) |
| cover_en = "All demand must be covered; lost sales are forbidden." if instance.cover_required else "Lost sales are allowed and charged." |
| cover_fa = "پوشش کامل تقاضا الزامی است." if instance.cover_required else "کمبود مجاز است و جریمه دارد." |
| if template_id in {"D-A", "D-B", "D-C"}: |
| en = ( |
| f"A B2B warehouse plans {instance.periods} weeks for {len(instance.skus)} SKUs: {names}. " |
| f"{cover_en} Orders are pack multiples. Lead time is 0. " |
| f"Budget is {instance.budget} currency units. Storage holds at most {instance.warehouse_capacity} units in total. " |
| "Minimize purchase + holding + shortage.\n" |
| f"{labels}\n{schema_block}" |
| ) |
| fa = ( |
| f"یک انبار B2B برای {instance.periods} هفته و {len(instance.skus)} کالا برنامه میخرد: {names_fa}. " |
| f"{cover_fa} سفارش مضرب بسته است. زمان تأمین صفر است. " |
| f"بودجه برابر {instance.budget} واحد پول و ظرفیت انبار {instance.warehouse_capacity} واحد است. " |
| "هدف کمینهکردن خرید + نگهداری + کمبود است.\n" |
| f"{labels}\n{schema_block}" |
| ) |
| else: |
| demand_txt = "; ".join(f"{sku.sku_id} wants {sku.demand} at pack {sku.pack_size}" for sku in instance.skus) |
| en = ( |
| f"Replenish {names} over a {instance.periods}-week horizon. {cover_en} " |
| f"The buyer cannot spend more than {instance.budget}. On-hand stock across SKUs cannot exceed {instance.warehouse_capacity}. " |
| f"{demand_txt}. Costs and opening stock are in the JSON companion." |
| ) |
| fa = ( |
| f"برای {names_fa} در افق {instance.periods} هفته خرید کنید. {cover_fa} " |
| f"سقف هزینه {instance.budget} و سقف موجودی کل {instance.warehouse_capacity} است. " |
| "جزئیات تقاضا و بسته در فایل JSON همراه است." |
| ) |
| return en, fa |
|
|
|
|
| def make_assignment(index: int, rng: random.Random) -> tuple[AssignmentInstance, str]: |
| difficulty = _difficulty(index, N_ASSIGNMENT, 2) |
| n_tasks = 4 if difficulty == Difficulty.EASY else 6 if difficulty != Difficulty.HARD else 8 |
| n_agents = 3 if difficulty != Difficulty.HARD else 4 |
| tasks = [] |
| for k in range(n_tasks): |
| skills = [rng.choice(TASK_SKILLS)] |
| if difficulty != Difficulty.EASY and rng.random() < 0.35: |
| skills.append(rng.choice(TASK_SKILLS)) |
| skills = sorted(set(skills)) |
| tasks.append( |
| AssignmentTask( |
| task_id=f"T{k + 1}", |
| name=f"job-{k + 1}", |
| size=rng.randint(1, 3), |
| required=True if difficulty == Difficulty.INFEASIBLE else (k < n_tasks - 1 or difficulty != Difficulty.EASY), |
| skills=skills, |
| penalty=rng.randint(20, 40), |
| ) |
| ) |
| agents = [] |
| for k in range(n_agents): |
| skills = [TASK_SKILLS[k % len(TASK_SKILLS)]] |
| if difficulty != Difficulty.EASY: |
| skills.append(TASK_SKILLS[(k + 1) % len(TASK_SKILLS)]) |
| agents.append( |
| AssignmentAgent( |
| agent_id=f"A{k + 1}", |
| name=f"tech-{k + 1}", |
| capacity=rng.randint(3, 6) if difficulty != Difficulty.INFEASIBLE else 1, |
| skills=sorted(set(skills)), |
| ) |
| ) |
| if difficulty == Difficulty.INFEASIBLE: |
| for task in tasks: |
| task.required = True |
| task.size = 3 |
| for agent in agents: |
| agent.capacity = 1 |
| else: |
| for idx, task in enumerate(tasks): |
| agent = agents[idx % len(agents)] |
| if not (set(task.skills) & set(agent.skills)): |
| task.skills = sorted(set(task.skills + agent.skills[:1])) |
| required_load = sum(task.size for task in tasks if task.required) |
| agents[-1].skills = sorted(set(TASK_SKILLS)) |
| total_cap = sum(agent.capacity for agent in agents) |
| if required_load > total_cap: |
| agents[-1].capacity += required_load - total_cap + 2 |
| else: |
| agents[-1].capacity += 2 |
| costs = [] |
| for task in tasks: |
| for agent in agents: |
| if set(task.skills) & set(agent.skills) or not task.skills: |
| costs.append(AssignmentCost(task_id=task.task_id, agent_id=agent.agent_id, cost=rng.randint(4, 18))) |
| return AssignmentInstance(tasks=tasks, agents=agents, costs=costs), difficulty.value |
|
|
|
|
| def render_assignment(instance: AssignmentInstance, template_id: str) -> tuple[str, str]: |
| payload = instance.model_dump() |
| schema_block = _wrap_schema(payload, template_id) |
| task_txt = ", ".join(f"{task.task_id} size {task.size} skills {'/'.join(task.skills)}" for task in instance.tasks) |
| agent_txt = ", ".join(f"{agent.agent_id} cap {agent.capacity} skills {'/'.join(agent.skills)}" for agent in instance.agents) |
| if template_id.startswith("D-"): |
| en = ( |
| "Assign each required maintenance task to at most one eligible technician. " |
| "Do not exceed agent capacity. Optional leftover tasks pay a penalty.\n" |
| f"TASKS: {task_txt}\nAGENTS: {agent_txt}\n{schema_block}" |
| ) |
| fa = ( |
| "هر کار الزامی را حداکثر به یک تکنسین واجد مهارت بدهید و از ظرفیت نفر تجاوز نکنید. " |
| "کار اختیاریِ انجامنشده جریمه دارد.\n" |
| f"TASKS: {task_txt}\nAGENTS: {agent_txt}\n{schema_block}" |
| ) |
| else: |
| en = ( |
| f"A service desk has technicians {agent_txt}. Work orders: {task_txt}. " |
| "A task may use an agent only when they share a skill. Minimize assignment cost plus leftover penalties." |
| ) |
| fa = ( |
| f"میز خدمت تکنسینهای {agent_txt} را دارد. سفارشها: {task_txt}. " |
| "تخصیص فقط با مهارت مشترک مجاز است. هزینه تخصیص بهعلاوه جریمه کار باقیمانده کمینه شود." |
| ) |
| return en, fa |
|
|
|
|
| def make_schedule(index: int, rng: random.Random) -> tuple[ScheduleInstance, str]: |
| difficulty = _difficulty(index, N_SCHEDULING, 3) |
| n_jobs = 4 if difficulty == Difficulty.EASY else 6 if difficulty != Difficulty.HARD else 8 |
| machines = ["M1"] if difficulty == Difficulty.EASY else ["M1", "M2"] |
| jobs = [] |
| cursor = 0 |
| for k in range(n_jobs): |
| duration = rng.randint(2, 5) |
| release = rng.choice([0, 0, 1, 2]) |
| due = cursor + duration + rng.randint(1, 4) |
| hard = difficulty == Difficulty.INFEASIBLE and k < 2 |
| if difficulty == Difficulty.INFEASIBLE and k < 2: |
| due = release + duration - 1 |
| eligible = machines[:] if difficulty == Difficulty.EASY or rng.random() < 0.7 else [rng.choice(machines)] |
| jobs.append( |
| ScheduleJob( |
| job_id=f"J{k + 1}", |
| name=f"op-{k + 1}", |
| duration=duration, |
| release=release, |
| due=max(due, release + duration), |
| weight=rng.randint(1, 4), |
| hard_due=hard, |
| machine_eligible=eligible, |
| ) |
| ) |
| cursor += duration |
| if difficulty == Difficulty.INFEASIBLE and len(jobs) >= 2: |
| jobs[0].hard_due = True |
| jobs[0].due = jobs[0].release + jobs[0].duration - 1 |
| jobs[1].hard_due = True |
| jobs[1].due = jobs[1].release + jobs[1].duration - 1 |
| if jobs[0].due < jobs[0].release + jobs[0].duration: |
| pass |
| precedences = [] |
| if difficulty != Difficulty.EASY and n_jobs >= 3: |
| precedences.append(SchedulePrecedence(before="J1", after="J3")) |
| if difficulty == Difficulty.HARD and n_jobs >= 5: |
| precedences.append(SchedulePrecedence(before="J2", after="J5")) |
| horizon = sum(job.duration for job in jobs) + 8 |
| return ScheduleInstance(machines=machines, jobs=jobs, precedences=precedences, horizon=horizon), difficulty.value |
|
|
|
|
| def render_schedule(instance: ScheduleInstance, template_id: str) -> tuple[str, str]: |
| payload = instance.model_dump() |
| schema_block = _wrap_schema(payload, template_id) |
| job_txt = ", ".join( |
| f"{job.job_id} dur {job.duration} rel {job.release} due {job.due}{' hard' if job.hard_due else ''}" |
| for job in instance.jobs |
| ) |
| pred = ", ".join(f"{edge.before}->{edge.after}" for edge in instance.precedences) or "none" |
| if template_id.startswith("D-"): |
| en = ( |
| f"Schedule jobs on machines {', '.join(instance.machines)} without overlap. " |
| f"Respect release times and precedences ({pred}). Hard due dates are deadlines.\n" |
| f"JOBS: {job_txt}\n{schema_block}" |
| ) |
| fa = ( |
| f"کارها را روی ماشینهای {', '.join(instance.machines)} بدون همپوشانی زمانبندی کنید. " |
| f"زمان آزادسازی و تقدم ({pred}) رعایت شود. موعد سخت ضربالاجل است.\n" |
| f"JOBS: {job_txt}\n{schema_block}" |
| ) |
| else: |
| en = ( |
| f"A shop has machines {', '.join(instance.machines)}. Jobs: {job_txt}. " |
| f"Precedence: {pred}. Minimize weighted tardiness. Do not overlap a machine." |
| ) |
| fa = ( |
| f"کارگاه ماشینهای {', '.join(instance.machines)} را دارد. کارها: {job_txt}. " |
| f"تقدم: {pred}. تأخیر وزنی کمینه شود و ماشین همپوشانی نداشته باشد." |
| ) |
| return en, fa |
|
|
|
|
| def _finalize( |
| problem_id: str, |
| family: Family, |
| index: int, |
| n_items: int, |
| instance, |
| difficulty: str, |
| template_id: str, |
| language: str, |
| seed: int, |
| prompt_en: str, |
| prompt_fa: str, |
| notes: str, |
| ) -> ProblemRecord: |
| split = _split_for(index, n_items) |
| payload = instance.model_dump() |
| gold = solve_instance(family, payload, seconds=6.0, threads=1) |
| wanted = Difficulty(difficulty) |
| if wanted == Difficulty.INFEASIBLE and gold.solution.status.value != "infeasible": |
| notes = (notes + " requested infeasible; solver found a plan so the row is hard.").strip() |
| wanted = Difficulty.HARD |
| structural = _key( |
| family.value, |
| split.value, |
| template_id, |
| problem_id, |
| json.dumps(payload, sort_keys=True, ensure_ascii=False), |
| wanted.value, |
| ) |
| return ProblemRecord( |
| problem_id=problem_id, |
| family=family, |
| split=split, |
| interactive=problem_id in INTERACTIVE_IDS, |
| difficulty=wanted, |
| language=language, |
| template_id=template_id, |
| seed=seed, |
| prompt_en=prompt_en, |
| prompt_fa=prompt_fa, |
| prompt_json=_json_prompt(payload), |
| schema_payload=payload, |
| gold_status=gold.solution.status.value, |
| gold_objective=gold.solution.objective, |
| gold_bound=gold.solution.bound, |
| gold_solution=gold.solution.as_dict(), |
| structural_key=structural, |
| notes=notes, |
| ) |
|
|
|
|
| def generate_catalog(seed: int = DEFAULT_SEED) -> list[ProblemRecord]: |
| problems: list[ProblemRecord] = [] |
| for index in range(1, N_INVENTORY + 1): |
| rng = random.Random(seed * 1000 + index) |
| instance, difficulty = make_inventory(index, rng) |
| split = _split_for(index, N_INVENTORY) |
| template_id = _template(split, index) |
| language = "en" if index % 2 else "fa" |
| en, fa = render_inventory(instance, template_id, language) |
| problems.append( |
| _finalize( |
| f"INV-{index:03d}", |
| Family.INVENTORY, |
| index, |
| N_INVENTORY, |
| instance, |
| difficulty, |
| template_id, |
| language, |
| seed * 1000 + index, |
| en, |
| fa, |
| "lead time is 0; units are abstract currency and pieces", |
| ) |
| ) |
| for index in range(1, N_ASSIGNMENT + 1): |
| rng = random.Random(seed * 2000 + index) |
| instance, difficulty = make_assignment(index, rng) |
| split = _split_for(index, N_ASSIGNMENT) |
| template_id = _template(split, index) |
| language = "fa" if index % 2 else "en" |
| en, fa = render_assignment(instance, template_id) |
| problems.append( |
| _finalize( |
| f"ASN-{index:03d}", |
| Family.ASSIGNMENT, |
| index, |
| N_ASSIGNMENT, |
| instance, |
| difficulty, |
| template_id, |
| language, |
| seed * 2000 + index, |
| en, |
| fa, |
| "skill intersection is the eligibility rule", |
| ) |
| ) |
| for index in range(1, N_SCHEDULING + 1): |
| rng = random.Random(seed * 3000 + index) |
| instance, difficulty = make_schedule(index, rng) |
| split = _split_for(index, N_SCHEDULING) |
| template_id = _template(split, index) |
| language = "en" if index % 3 else "fa" |
| en, fa = render_schedule(instance, template_id) |
| problems.append( |
| _finalize( |
| f"SCH-{index:03d}", |
| Family.SCHEDULING, |
| index, |
| N_SCHEDULING, |
| instance, |
| difficulty, |
| template_id, |
| language, |
| seed * 3000 + index, |
| en, |
| fa, |
| "objective reported as weighted tardiness; makespan is a tie-break inside the solver only", |
| ) |
| ) |
| if len(problems) != N_PROBLEMS: |
| raise RuntimeError(f"expected {N_PROBLEMS} problems, got {len(problems)}") |
| return problems |
|
|
|
|
| def write_catalog(path: Path, seed: int = DEFAULT_SEED) -> list[ProblemRecord]: |
| problems = generate_catalog(seed) |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open("w", encoding="utf-8") as handle: |
| for row in problems: |
| handle.write(row.model_dump_json() + "\n") |
| return problems |
|
|
|
|
| def load_catalog(path: Path | None = None) -> list[ProblemRecord]: |
| if path and path.exists(): |
| rows = [] |
| for line in path.read_text(encoding="utf-8").splitlines(): |
| if line.strip(): |
| rows.append(ProblemRecord.model_validate_json(line)) |
| return rows |
| return generate_catalog() |
|
|
