| from __future__ import annotations |
|
|
| import json |
| import re |
| from typing import Any |
|
|
| from src.domain import Family, InventoryInstance |
|
|
|
|
| def extract_json(text: str) -> dict[str, Any] | None: |
| if not text or not str(text).strip(): |
| return None |
| raw = str(text).strip() |
| candidates = [raw] |
| fenced = re.findall(r"```(?:json)?\s*(\{.*?\})\s*```", raw, flags=re.S) |
| candidates.extend(fenced) |
| start = raw.find("{") |
| end = raw.rfind("}") |
| if start >= 0 and end > start: |
| candidates.append(raw[start : end + 1]) |
| for item in candidates: |
| try: |
| payload = json.loads(item) |
| except json.JSONDecodeError: |
| continue |
| if isinstance(payload, dict) and payload: |
| if "schema_payload" in payload and isinstance(payload["schema_payload"], dict): |
| return payload["schema_payload"] |
| return payload |
| return None |
|
|
|
|
| def extract_template(text: str, family: Family | str) -> dict[str, Any] | None: |
| family = Family(family) |
| if not text: |
| return None |
| labeled = _extract_labeled_blocks(text) |
| if labeled: |
| return labeled |
| if family == Family.INVENTORY: |
| return _extract_inventory_prose(text) |
| return None |
|
|
|
|
| def _extract_labeled_blocks(text: str) -> dict[str, Any] | None: |
| blocks = re.findall(r"SCHEMA_BEGIN\s*(\{.*?\})\s*SCHEMA_END", text, flags=re.S) |
| for block in blocks: |
| try: |
| payload = json.loads(block) |
| except json.JSONDecodeError: |
| continue |
| if isinstance(payload, dict): |
| return payload |
| return None |
|
|
|
|
| def _extract_inventory_prose(text: str) -> dict[str, Any] | None: |
| budget = _first_int(text, r"(?:BUDGET|budget|بودجه)\s*[:=]?\s*(\d+)") |
| capacity = _first_int(text, r"(?:CAPACITY|capacity|ظرفیت انبار)\s*[:=]?\s*(\d+)") |
| periods = _first_int(text, r"(?:PERIODS|periods|دوره)\s*[:=]?\s*(\d+)") |
| cover = bool(re.search(r"COVER_REQUIRED:\s*1|cover is required|پوشش کامل الزامی", text, flags=re.I)) |
| sku_lines = re.findall( |
| r"SKU\s+([A-Za-z0-9_-]+).*?demand=([0-9,]+).*?pack=(\d+).*?cost=(\d+).*?hold=(\d+).*?short=(\d+).*?stock=(\d+)", |
| text, |
| flags=re.I, |
| ) |
| if budget is None or not sku_lines: |
| return None |
| skus = [] |
| for sku_id, demand, pack, cost, hold, short, stock in sku_lines: |
| values = [int(item) for item in demand.split(",") if item.strip().isdigit()] |
| skus.append( |
| { |
| "sku_id": sku_id, |
| "name": sku_id, |
| "demand": values, |
| "initial_stock": int(stock), |
| "unit_cost": int(cost), |
| "holding_cost": int(hold), |
| "shortage_cost": int(short), |
| "pack_size": int(pack), |
| "lead_time": 0, |
| } |
| ) |
| periods = periods or (len(skus[0]["demand"]) if skus else 0) |
| try: |
| InventoryInstance.model_validate( |
| { |
| "periods": periods, |
| "budget": budget, |
| "warehouse_capacity": capacity if capacity is not None else 10**6, |
| "cover_required": cover, |
| "lost_sales": True, |
| "skus": skus, |
| } |
| ) |
| except Exception: |
| return None |
| return { |
| "periods": periods, |
| "budget": budget, |
| "warehouse_capacity": capacity if capacity is not None else 10**6, |
| "cover_required": cover, |
| "lost_sales": True, |
| "skus": skus, |
| } |
|
|
|
|
| def _first_int(text: str, pattern: str) -> int | None: |
| match = re.search(pattern, text, flags=re.I) |
| if not match: |
| return None |
| return int(match.group(1)) |
|
|
|
|
| def flatten_facts(family: Family | str, payload: dict) -> dict[str, str]: |
| family = Family(family) |
| facts: dict[str, str] = {} |
| if family == Family.INVENTORY: |
| facts["periods"] = str(payload.get("periods")) |
| facts["budget"] = str(payload.get("budget")) |
| facts["warehouse_capacity"] = str(payload.get("warehouse_capacity")) |
| facts["cover_required"] = str(bool(payload.get("cover_required"))) |
| for sku in payload.get("skus") or []: |
| key = sku.get("sku_id") |
| facts[f"{key}.demand"] = ",".join(str(int(v)) for v in sku.get("demand") or []) |
| facts[f"{key}.pack"] = str(sku.get("pack_size")) |
| facts[f"{key}.cost"] = str(sku.get("unit_cost")) |
| facts[f"{key}.stock"] = str(sku.get("initial_stock")) |
| facts[f"{key}.hold"] = str(sku.get("holding_cost")) |
| facts[f"{key}.short"] = str(sku.get("shortage_cost")) |
| elif family == Family.ASSIGNMENT: |
| facts["n_tasks"] = str(len(payload.get("tasks") or [])) |
| facts["n_agents"] = str(len(payload.get("agents") or [])) |
| for task in payload.get("tasks") or []: |
| facts[f"task.{task.get('task_id')}.size"] = str(task.get("size")) |
| facts[f"task.{task.get('task_id')}.required"] = str(bool(task.get("required"))) |
| facts[f"task.{task.get('task_id')}.skills"] = ",".join(sorted(task.get("skills") or [])) |
| for agent in payload.get("agents") or []: |
| facts[f"agent.{agent.get('agent_id')}.cap"] = str(agent.get("capacity")) |
| facts[f"agent.{agent.get('agent_id')}.skills"] = ",".join(sorted(agent.get("skills") or [])) |
| for row in payload.get("costs") or []: |
| facts[f"cost.{row.get('task_id')}.{row.get('agent_id')}"] = str(row.get("cost")) |
| else: |
| facts["machines"] = ",".join(payload.get("machines") or []) |
| for job in payload.get("jobs") or []: |
| jid = job.get("job_id") |
| facts[f"job.{jid}.dur"] = str(job.get("duration")) |
| facts[f"job.{jid}.rel"] = str(job.get("release")) |
| facts[f"job.{jid}.due"] = str(job.get("due")) |
| facts[f"job.{jid}.w"] = str(job.get("weight")) |
| facts[f"job.{jid}.hard"] = str(bool(job.get("hard_due"))) |
| facts[f"job.{jid}.m"] = ",".join(sorted(job.get("machine_eligible") or [])) |
| for idx, edge in enumerate(payload.get("precedences") or []): |
| facts[f"pred.{idx}"] = f"{edge.get('before')}->{edge.get('after')}" |
| return facts |
|
|
|
|
| def constraint_fidelity(family: Family | str, gold: dict, extracted: dict | None) -> float | None: |
| if extracted is None: |
| return 0.0 |
| gold_facts = flatten_facts(family, gold) |
| got = flatten_facts(family, extracted) |
| if not gold_facts: |
| return 1.0 |
| hits = sum(1 for key, value in gold_facts.items() if got.get(key) == value) |
| return hits / len(gold_facts) |
|
|
|
|
| def drop_constraint(family: Family | str, payload: dict, prompt: str) -> tuple[dict, str]: |
| family = Family(family) |
| clone = json.loads(json.dumps(payload)) |
| if family == Family.INVENTORY: |
| clone["budget"] = 10**9 |
| stripped = re.sub(r"(BUDGET|budget|بودجه)\s*[:=]?\s*\d+", "BUDGET omitted", prompt) |
| return clone, stripped |
| if family == Family.ASSIGNMENT: |
| for agent in clone.get("agents") or []: |
| agent["capacity"] = 10**6 |
| stripped = re.sub(r"(capacity|ظرفیت)\s*[:=]?\s*\d+", "capacity omitted", prompt, flags=re.I) |
| return clone, stripped |
| for job in clone.get("jobs") or []: |
| job["hard_due"] = False |
| job["due"] = job.get("due", 0) + 10**4 |
| stripped = re.sub(r"(hard due|موعد سخت)", "due relaxed", prompt, flags=re.I) |
| return clone, stripped |
|
|
