| from __future__ import annotations |
|
|
| from collections import defaultdict |
|
|
| from src.domain import ( |
| AssignmentInstance, |
| Family, |
| InventoryInstance, |
| ScheduleInstance, |
| Solution, |
| ValidationIssue, |
| ValidationReport, |
| parse_instance, |
| ) |
|
|
|
|
| def _issue(code: str, message: str, entity_id: str | None = None, passed: bool = False) -> ValidationIssue: |
| return ValidationIssue(code=code, message=message, entity_id=entity_id, passed=passed) |
|
|
|
|
| def validate_schema(family: Family | str, payload: dict) -> ValidationReport: |
| issues: list[ValidationIssue] = [] |
| checked = ["schema", "ids", "values"] |
| try: |
| instance = parse_instance(family, payload) |
| except Exception as exc: |
| return ValidationReport(ok=False, issues=[_issue("schema", f"schema rejected: {exc}")], checked=checked) |
|
|
| if isinstance(instance, InventoryInstance): |
| ids = [sku.sku_id for sku in instance.skus] |
| if len(ids) != len(set(ids)): |
| issues.append(_issue("ids", "duplicate SKU ids")) |
| if not instance.skus: |
| issues.append(_issue("schema", "inventory needs at least one SKU")) |
| for sku in instance.skus: |
| if len(sku.demand) != instance.periods: |
| issues.append(_issue("values", f"{sku.sku_id} demand length must equal periods", sku.sku_id)) |
| if any(value < 0 for value in sku.demand): |
| issues.append(_issue("values", f"{sku.sku_id} demand must be non-negative", sku.sku_id)) |
| elif isinstance(instance, AssignmentInstance): |
| if not instance.tasks or not instance.agents: |
| issues.append(_issue("schema", "assignment needs tasks and agents")) |
| task_ids = [task.task_id for task in instance.tasks] |
| agent_ids = [agent.agent_id for agent in instance.agents] |
| if len(task_ids) != len(set(task_ids)) or len(agent_ids) != len(set(agent_ids)): |
| issues.append(_issue("ids", "duplicate task or agent ids")) |
| known = {(task.task_id, agent.agent_id) for task in instance.tasks for agent in instance.agents} |
| for row in instance.costs: |
| if (row.task_id, row.agent_id) not in known: |
| issues.append(_issue("references", f"cost for unknown pair {row.task_id}/{row.agent_id}")) |
| else: |
| job_ids = [job.job_id for job in instance.jobs] |
| if len(job_ids) != len(set(job_ids)): |
| issues.append(_issue("ids", "duplicate job ids")) |
| if not instance.machines or not instance.jobs: |
| issues.append(_issue("schema", "scheduling needs jobs and machines")) |
| seen = set() |
| for edge in instance.precedences: |
| if edge.before not in job_ids or edge.after not in job_ids: |
| issues.append(_issue("references", f"precedence {edge.before}->{edge.after} is unknown")) |
| if edge.before == edge.after: |
| issues.append(_issue("values", f"self precedence on {edge.before}", edge.before)) |
| pair = (edge.before, edge.after) |
| if pair in seen: |
| continue |
| seen.add(pair) |
| if _has_cycle(instance.precedences): |
| issues.append(_issue("values", "precedence graph has a cycle")) |
| return ValidationReport(ok=not issues, issues=issues, checked=checked) |
|
|
|
|
| def _has_cycle(edges) -> bool: |
| graph: dict[str, list[str]] = defaultdict(list) |
| nodes: set[str] = set() |
| for edge in edges: |
| graph[edge.before].append(edge.after) |
| nodes.add(edge.before) |
| nodes.add(edge.after) |
| state: dict[str, int] = {} |
|
|
| def visit(node: str) -> bool: |
| state[node] = 1 |
| for nxt in graph.get(node, []): |
| if state.get(nxt) == 1: |
| return True |
| if state.get(nxt, 0) == 0 and visit(nxt): |
| return True |
| state[node] = 2 |
| return False |
|
|
| return any(state.get(node, 0) == 0 and visit(node) for node in nodes) |
|
|
|
|
| def validate_solution(family: Family | str, payload: dict, solution: Solution | dict) -> ValidationReport: |
| family = Family(family) |
| schema_report = validate_schema(family, payload) |
| if not schema_report.ok: |
| return schema_report |
| instance = parse_instance(family, payload) |
| if not isinstance(solution, Solution): |
| solution = Solution.model_validate(solution) |
| if family == Family.INVENTORY: |
| return _validate_inventory(instance, solution) |
| if family == Family.ASSIGNMENT: |
| return _validate_assignment(instance, solution) |
| return _validate_schedule(instance, solution) |
|
|
|
|
| def _validate_inventory(instance: InventoryInstance, solution: Solution) -> ValidationReport: |
| issues: list[ValidationIssue] = [] |
| checked = ["pack", "budget", "balance", "capacity", "cover", "objective"] |
| qty = {(row.sku_id, int(row.period)): int(row.qty) for row in solution.orders} |
| spend = 0 |
| hold_cost = 0 |
| short_cost = 0 |
| stock = {sku.sku_id: sku.initial_stock for sku in instance.skus} |
| for t in range(1, instance.periods + 1): |
| ending = 0 |
| for sku in instance.skus: |
| order = int(qty.get((sku.sku_id, t), 0)) |
| if order < 0: |
| issues.append(_issue("values", f"negative order {sku.sku_id}@{t}", sku.sku_id)) |
| if sku.pack_size and order % sku.pack_size != 0: |
| issues.append(_issue("pack", f"{sku.sku_id}@{t} qty {order} is not a multiple of pack {sku.pack_size}", sku.sku_id)) |
| spend += order * sku.unit_cost |
| demand = int(sku.demand[t - 1]) |
| available = stock[sku.sku_id] + order |
| sold = min(available, demand) |
| short = demand - sold |
| stock[sku.sku_id] = available - sold |
| if stock[sku.sku_id] < 0: |
| issues.append(_issue("balance", f"negative inventory {sku.sku_id}@{t}", sku.sku_id)) |
| if instance.cover_required and short: |
| issues.append(_issue("cover", f"{sku.sku_id}@{t} shortage {short} while cover is required", sku.sku_id)) |
| ending += stock[sku.sku_id] |
| hold_cost += stock[sku.sku_id] * sku.holding_cost |
| short_cost += short * sku.shortage_cost |
| if ending > instance.warehouse_capacity: |
| issues.append(_issue("capacity", f"period {t} inventory {ending} exceeds capacity {instance.warehouse_capacity}")) |
| if spend > instance.budget: |
| issues.append(_issue("budget", f"purchase {spend} exceeds budget {instance.budget}")) |
| objective = float(spend + hold_cost + short_cost) |
| return ValidationReport(ok=not issues, issues=issues, checked=checked, recomputed_objective=objective) |
|
|
|
|
| def _validate_assignment(instance: AssignmentInstance, solution: Solution) -> ValidationReport: |
| issues: list[ValidationIssue] = [] |
| checked = ["unique", "eligible", "capacity", "required", "objective"] |
| seen_tasks: set[str] = set() |
| load: dict[str, int] = defaultdict(int) |
| cost_map = instance.cost_map() |
| agents = {agent.agent_id: agent for agent in instance.agents} |
| tasks = {task.task_id: task for task in instance.tasks} |
| spend = 0 |
| for row in solution.assignments: |
| if row.task_id in seen_tasks: |
| issues.append(_issue("unique", f"task {row.task_id} assigned more than once", row.task_id)) |
| seen_tasks.add(row.task_id) |
| task = tasks.get(row.task_id) |
| agent = agents.get(row.agent_id) |
| if task is None or agent is None: |
| issues.append(_issue("references", f"unknown pair {row.task_id}/{row.agent_id}", row.task_id)) |
| continue |
| if not instance.eligible(task, agent): |
| issues.append(_issue("eligible", f"{row.task_id} is not eligible for {row.agent_id}", row.task_id)) |
| if (row.task_id, row.agent_id) not in cost_map: |
| issues.append(_issue("references", f"no cost for {row.task_id}/{row.agent_id}", row.task_id)) |
| else: |
| spend += cost_map[(row.task_id, row.agent_id)] |
| load[row.agent_id] += task.size |
| for agent in instance.agents: |
| if load[agent.agent_id] > agent.capacity: |
| issues.append(_issue("capacity", f"{agent.agent_id} load {load[agent.agent_id]} exceeds {agent.capacity}", agent.agent_id)) |
| leftover = set(solution.unassigned) |
| for task in instance.tasks: |
| assigned = task.task_id in seen_tasks |
| if task.required and not assigned: |
| issues.append(_issue("required", f"required task {task.task_id} is unassigned", task.task_id)) |
| if not assigned: |
| leftover.add(task.task_id) |
| spend += task.penalty |
| if assigned and task.task_id in leftover: |
| leftover.discard(task.task_id) |
| return ValidationReport(ok=not issues, issues=issues, checked=checked, recomputed_objective=float(spend)) |
|
|
|
|
| def _validate_schedule(instance: ScheduleInstance, solution: Solution) -> ValidationReport: |
| issues: list[ValidationIssue] = [] |
| checked = ["unique", "eligible", "release", "overlap", "precedence", "hard_due", "duration", "objective"] |
| jobs = {job.job_id: job for job in instance.jobs} |
| seen: set[str] = set() |
| by_machine: dict[str, list[tuple[int, int, str]]] = defaultdict(list) |
| ends: dict[str, int] = {} |
| starts: dict[str, int] = {} |
| tardy = 0 |
| for row in solution.starts: |
| if row.job_id in seen: |
| issues.append(_issue("unique", f"job {row.job_id} starts more than once", row.job_id)) |
| seen.add(row.job_id) |
| job = jobs.get(row.job_id) |
| if job is None: |
| issues.append(_issue("references", f"unknown job {row.job_id}", row.job_id)) |
| continue |
| if row.machine_id not in instance.machines: |
| issues.append(_issue("references", f"unknown machine {row.machine_id}", row.job_id)) |
| if job.machine_eligible and row.machine_id not in set(job.machine_eligible): |
| issues.append(_issue("eligible", f"{row.job_id} cannot use {row.machine_id}", row.job_id)) |
| if row.start < job.release: |
| issues.append(_issue("release", f"{row.job_id} starts at {row.start} before release {job.release}", row.job_id)) |
| if row.end - row.start != job.duration: |
| issues.append(_issue("duration", f"{row.job_id} duration {row.end - row.start} != {job.duration}", row.job_id)) |
| if job.hard_due and row.end > job.due: |
| issues.append(_issue("hard_due", f"{row.job_id} ends at {row.end} after hard due {job.due}", row.job_id)) |
| by_machine[row.machine_id].append((row.start, row.end, row.job_id)) |
| ends[row.job_id] = row.end |
| starts[row.job_id] = row.start |
| tardy += job.weight * max(0, row.end - job.due) |
| for job in instance.jobs: |
| if job.job_id not in seen: |
| issues.append(_issue("cover", f"job {job.job_id} has no start", job.job_id)) |
| for machine, blocks in by_machine.items(): |
| ordered = sorted(blocks) |
| for prev, cur in zip(ordered, ordered[1:]): |
| if prev[1] > cur[0]: |
| issues.append(_issue("overlap", f"{machine} overlap {prev[2]} and {cur[2]}", machine)) |
| for edge in instance.precedences: |
| if edge.before in ends and edge.after in starts and ends[edge.before] > starts[edge.after]: |
| issues.append(_issue("precedence", f"{edge.before} must finish before {edge.after}", edge.after)) |
| return ValidationReport(ok=not issues, issues=issues, checked=checked, recomputed_objective=float(tardy)) |
|
|
|
|
| def format_input_error(report: ValidationReport) -> str: |
| if report.ok: |
| return "" |
| return " | ".join(f"{item.code}: {item.message}" for item in report.issues[:8]) |
|
|
