Spaces:
Running on Zero
Running on Zero
| """Conversion between the Clef question schema (JSON) and the visual editor's state. | |
| Editor state is a list of questions, each: | |
| {"id": str, "type": "noul"|"choice"|"score", "instructions": str, | |
| "options": [{"id": str, "desc": str}, ...], # choice: id + description; score: ordered levels | |
| "true": str, "false": str} # noul: optional descriptions | |
| Text fields hold strings; a value that parses as a JSON object/array is exported as JSON. | |
| """ | |
| import json | |
| QUESTION_TYPES = ("noul", "choice", "score") | |
| QUESTION_KEYS = {"type", "instructions", "criteria"} | |
| def dumps(value): | |
| return json.dumps(value, indent=2, ensure_ascii=False) | |
| def to_text(value): | |
| if value is None: | |
| return "" | |
| return value if isinstance(value, str) else json.dumps(value, ensure_ascii=False) | |
| def to_value(text): | |
| stripped = (text or "").strip() | |
| if not stripped: | |
| return None | |
| if stripped[:1] in "{[": | |
| try: | |
| return json.loads(stripped) | |
| except json.JSONDecodeError: | |
| pass | |
| return text | |
| def new_question(existing_ids, qtype="noul"): | |
| n = len(existing_ids) + 1 | |
| while f"question_{n}" in existing_ids: | |
| n += 1 | |
| question = {"id": f"question_{n}", "type": qtype, "instructions": "", "options": [], "true": "", "false": ""} | |
| seed_options(question) | |
| return question | |
| def seed_options(question): | |
| """Give choice/score questions two empty options if they have none.""" | |
| if question["type"] == "choice" and not question["options"]: | |
| question["options"] = [{"id": "option_1", "desc": ""}, {"id": "option_2", "desc": ""}] | |
| elif question["type"] == "score" and not question["options"]: | |
| question["options"] = [{"id": "0", "desc": ""}, {"id": "1", "desc": ""}] | |
| def new_option(question): | |
| ids = {o["id"] for o in question["options"]} | |
| n = len(ids) + 1 | |
| if question["type"] == "choice": | |
| while f"option_{n}" in ids: | |
| n += 1 | |
| return {"id": f"option_{n}", "desc": ""} | |
| return {"id": str(len(question["options"])), "desc": ""} | |
| def from_schema(schema): | |
| """Parse a questions object into editor state. Raises ValueError with a readable message.""" | |
| if not isinstance(schema, dict) or not schema: | |
| raise ValueError("Top level must be a non-empty JSON object mapping question ID to question.") | |
| questions = [] | |
| for qid, q in schema.items(): | |
| if not isinstance(q, dict): | |
| raise ValueError(f"`{qid}`: each question must be a JSON object.") | |
| qtype = q.get("type") | |
| if qtype not in QUESTION_TYPES: | |
| raise ValueError(f"`{qid}`: `type` must be noul, choice, or score (got {json.dumps(qtype)}).") | |
| unknown = sorted(set(q) - QUESTION_KEYS) | |
| if unknown: | |
| raise ValueError(f"`{qid}`: unsupported keys {unknown}; allowed keys are type, instructions, criteria.") | |
| criteria = q.get("criteria") | |
| item = { | |
| "id": str(qid), | |
| "type": qtype, | |
| "instructions": to_text(q.get("instructions")), | |
| "options": [], | |
| "true": "", | |
| "false": "", | |
| } | |
| if qtype == "choice": | |
| if not isinstance(criteria, dict): | |
| raise ValueError(f"`{qid}`: choice `criteria` must be an object of option ID to description.") | |
| item["options"] = [{"id": str(k), "desc": to_text(v)} for k, v in criteria.items()] | |
| elif qtype == "score": | |
| if not isinstance(criteria, list): | |
| raise ValueError(f"`{qid}`: score `criteria` must be a list of level descriptions.") | |
| item["options"] = [{"id": str(i), "desc": to_text(v)} for i, v in enumerate(criteria)] | |
| elif criteria is not None: | |
| if not isinstance(criteria, dict) or set(criteria) - {"true", "false"}: | |
| raise ValueError(f"`{qid}`: noul `criteria` may only contain `true` and `false` descriptions.") | |
| item["true"] = to_text(criteria.get("true")) | |
| item["false"] = to_text(criteria.get("false")) | |
| questions.append(item) | |
| return questions | |
| def to_schema(questions): | |
| schema = {} | |
| for q in questions: | |
| out = {"type": q["type"]} | |
| instructions = to_value(q["instructions"]) | |
| if instructions is not None: | |
| out["instructions"] = instructions | |
| if q["type"] == "choice": | |
| out["criteria"] = {o["id"]: to_value(o["desc"]) for o in q["options"]} | |
| elif q["type"] == "score": | |
| out["criteria"] = [to_value(o["desc"]) for o in q["options"]] | |
| else: | |
| criteria = {k: to_value(q[k]) for k in ("true", "false") if to_value(q[k]) is not None} | |
| if criteria: | |
| out["criteria"] = criteria | |
| schema[q["id"]] = out | |
| return schema | |
| def validate(questions): | |
| problems = [] | |
| if not questions: | |
| problems.append("Add at least one question.") | |
| seen = set() | |
| for i, q in enumerate(questions, 1): | |
| name = f"Question {i} (`{q['id']}`)" if q["id"].strip() else f"Question {i}" | |
| if not q["id"].strip(): | |
| problems.append(f"{name}: ID is empty.") | |
| elif q["id"] in seen: | |
| problems.append(f"{name}: duplicate ID; only the last one is kept.") | |
| seen.add(q["id"]) | |
| if q["type"] in ("choice", "score") and not q["options"]: | |
| problems.append(f"{name}: needs at least one option.") | |
| if q["type"] == "choice": | |
| option_ids = [o["id"] for o in q["options"]] | |
| if any(not oid.strip() for oid in option_ids): | |
| problems.append(f"{name}: an option ID is empty.") | |
| if len(set(option_ids)) != len(option_ids): | |
| problems.append(f"{name}: duplicate option IDs.") | |
| return problems | |
| def status_markdown(questions): | |
| problems = validate(questions) | |
| if not problems: | |
| return "" | |
| return "**Schema issues**\n\n" + "\n".join(f"- {p}" for p in problems) | |