Download context_parser.py from j-js/GameAI: direct link, hf CLI and curl.
- Browser
- Download file 6.16 kB
-
https://huggingface.co/spaces/j-js/GameAI/resolve/508bc5133870fe40274885bfaf7405c77458bf2e/context_parser.py
- Command line
-
hf download hf://spaces/j-js/GameAI@508bc5133870fe40274885bfaf7405c77458bf2e/context_parser.py
-
curl -L -o context_parser.py https://huggingface.co/spaces/j-js/GameAI/resolve/508bc5133870fe40274885bfaf7405c77458bf2e/context_parser.py
6.16 kB
| from __future__ import annotations | |
| import re | |
| from typing import Any, Dict, List, Optional, Tuple | |
| def split_unity_message(text: str) -> Tuple[str, str]: | |
| """ | |
| Splits a Unity-style message into: | |
| - hidden/system/game context prefix | |
| - actual user-facing message | |
| If no obvious split is found, returns ("", original_text). | |
| """ | |
| raw = (text or "").strip() | |
| if not raw: | |
| return "", "" | |
| # Pattern like: | |
| # CONTEXT: ... | |
| # USER: ... | |
| m = re.search(r"(?is)^(.*?)(?:\buser\b|\bprompt\b|\bmessage\b)\s*:\s*(.+)$", raw) | |
| if m: | |
| hidden = (m.group(1) or "").strip() | |
| user = (m.group(2) or "").strip() | |
| return hidden, user | |
| return "", raw | |
| def _extract_options(text: str) -> List[str]: | |
| if not text: | |
| return [] | |
| lines = [line.strip() for line in text.splitlines() if line.strip()] | |
| options: List[str] = [] | |
| for line in lines: | |
| if re.match(r"^[A-E][\)\.\:]\s*", line, flags=re.I): | |
| options.append(re.sub(r"^[A-E][\)\.\:]\s*", "", line, flags=re.I).strip()) | |
| if options: | |
| return options | |
| # fallback: inline A) ... B) ... | |
| matches = re.findall(r"(?:^|\s)([A-E])[\)\.\:]\s*(.*?)(?=(?:\s+[A-E][\)\.\:])|$)", text, flags=re.I | re.S) | |
| if matches: | |
| return [m[1].strip() for m in matches if m[1].strip()] | |
| return [] | |
| def extract_game_context_fields(text: str) -> Dict[str, Any]: | |
| """ | |
| Extracts lightweight structured fields from hidden Unity/game context. | |
| Always returns stable keys expected by app.py. | |
| """ | |
| raw = (text or "").strip() | |
| result: Dict[str, Any] = { | |
| "question": "", | |
| "options": [], | |
| "difficulty": None, | |
| "category": None, | |
| "money": None, | |
| "has_choices": False, | |
| "looks_like_quant": False, | |
| } | |
| if not raw: | |
| return result | |
| # question | |
| q_match = re.search(r"\bquestion\s*[:=]\s*(.+?)(?=\n[A-Za-z_ ]+\s*[:=]|\Z)", raw, flags=re.I | re.S) | |
| if q_match: | |
| result["question"] = q_match.group(1).strip() | |
| # options block | |
| opt_match = re.search(r"\b(?:options|choices|answers)\s*[:=]\s*(.+?)(?=\n[A-Za-z_ ]+\s*[:=]|\Z)", raw, flags=re.I | re.S) | |
| if opt_match: | |
| result["options"] = _extract_options(opt_match.group(1)) | |
| # if no explicit options block, scan whole context | |
| if not result["options"]: | |
| result["options"] = _extract_options(raw) | |
| result["has_choices"] = len(result["options"]) > 0 | |
| # difficulty | |
| difficulty_match = re.search(r"\bdifficulty\s*[:=]\s*([A-Za-z0-9_\- ]+)", raw, flags=re.I) | |
| if difficulty_match: | |
| result["difficulty"] = difficulty_match.group(1).strip() | |
| # category/topic | |
| category_match = re.search(r"\b(?:category|topic)\s*[:=]\s*([A-Za-z0-9_\- /]+)", raw, flags=re.I) | |
| if category_match: | |
| result["category"] = category_match.group(1).strip() | |
| # money/balance | |
| money_match = re.search(r"\b(?:money|balance|bank)\s*[:=]\s*([\-]?\d+(?:\.\d+)?)", raw, flags=re.I) | |
| if money_match: | |
| try: | |
| result["money"] = float(money_match.group(1)) | |
| except Exception: | |
| pass | |
| lower = raw.lower() | |
| result["looks_like_quant"] = any( | |
| token in lower | |
| for token in [ | |
| "solve", | |
| "equation", | |
| "percent", | |
| "%", | |
| "ratio", | |
| "probability", | |
| "mean", | |
| "median", | |
| "algebra", | |
| "integer", | |
| "triangle", | |
| "circle", | |
| ] | |
| ) | |
| return result | |
| def detect_intent(text: str, incoming_help_mode: Optional[str] = None) -> str: | |
| """ | |
| Returns one of: | |
| answer, hint, instruction, walkthrough, explain, method, definition, concept | |
| """ | |
| forced = (incoming_help_mode or "").strip().lower() | |
| if forced in { | |
| "answer", | |
| "hint", | |
| "instruction", | |
| "walkthrough", | |
| "step_by_step", | |
| "explain", | |
| "method", | |
| "definition", | |
| "concept", | |
| }: | |
| return forced | |
| t = (text or "").strip().lower() | |
| if not t: | |
| return "answer" | |
| if ( | |
| re.search(r"\bdefine\b", t) | |
| or re.search(r"\bdefinition\b", t) | |
| or re.search(r"\bwhat does\b", t) | |
| or re.search(r"\bwhat is meant by\b", t) | |
| ): | |
| return "definition" | |
| if re.search(r"\bhint\b", t) or re.search(r"\bclue\b", t) or re.search(r"\bnudge\b", t): | |
| return "hint" | |
| if ( | |
| re.search(r"\bfirst step\b", t) | |
| or re.search(r"\bnext step\b", t) | |
| or re.search(r"\bwhat should i do first\b", t) | |
| or re.search(r"\bgive me the first step\b", t) | |
| or re.search(r"\bspecific step\b", t) | |
| ): | |
| return "instruction" | |
| if ( | |
| re.search(r"\bwalk ?through\b", t) | |
| or re.search(r"\bstep by step\b", t) | |
| or re.search(r"\bfull working\b", t) | |
| or re.search(r"\bwork through\b", t) | |
| ): | |
| return "walkthrough" | |
| if re.search(r"\bexplain\b", t) or re.search(r"\bwhy\b", t): | |
| return "explain" | |
| if ( | |
| re.search(r"\bmethod\b", t) | |
| or re.search(r"\bapproach\b", t) | |
| or re.search(r"\bhow do i solve\b", t) | |
| or re.search(r"\bhow to solve\b", t) | |
| or re.search(r"\bhow do i do this\b", t) | |
| ): | |
| return "method" | |
| if ( | |
| re.search(r"\bconcept\b", t) | |
| or re.search(r"\bprinciple\b", t) | |
| or re.search(r"\brule\b", t) | |
| or re.search(r"\bwhat is the idea\b", t) | |
| ): | |
| return "concept" | |
| if ( | |
| re.search(r"\bsolve\b", t) | |
| or re.search(r"\bwhat is\b", t) | |
| or re.search(r"\bfind\b", t) | |
| or re.search(r"\bgive (?:me )?the answer\b", t) | |
| or re.search(r"\bjust the answer\b", t) | |
| or re.search(r"\banswer only\b", t) | |
| or re.search(r"\bcalculate\b", t) | |
| ): | |
| return "answer" | |
| return "answer" | |
| def intent_to_help_mode(intent: str) -> str: | |
| if intent in {"walkthrough", "step_by_step", "explain", "method", "concept"}: | |
| return "walkthrough" | |
| if intent == "hint": | |
| return "hint" | |
| if intent in {"definition", "instruction"}: | |
| return intent | |
| return "answer" |