JSON ও স্কিমা: ফিল্ড, টাইপ, enum ও অনুপস্থিত মান

Aiko Tan would like the Sakura room on 3 November for about 45 minutes, with two
colleagues. She needs a projector. Her email is aiko@example.jp.

{"requester_name": "Aiko Tan", "requester_email": "aiko@example.jp", "room": "Sakura",
 "date": "2026-11-03", "duration_minutes": 45, "needs_projector": true,
 "attendees": [{"name": "Ben Ito", "email": null}, {"name": "Mei Sato", "email": null}]}

Give me the booking details as JSON.

Extract the meeting request below as ONE JSON object and nothing else.
No Markdown, no code fence, no text before or after the JSON.

Fields (use exactly these names, no others):
- requester_name: string
- requester_email: string, or null if not given
- room: one of "Sakura", "Maple", "Cedar", "unknown"
- date: "YYYY-MM-DD", or null if the request gives no exact date
- duration_minutes: integer, or null if not given
- needs_projector: true or false (false if not mentioned)
- attendees: array of {"name": string, "email": string or null}; [] if none
- notes: string, optional; leave the field out if there is nothing to add

Never guess a missing value: use null (or "unknown" for room).

### REQUEST
{request}

import json, re
from jsonschema import Draft202012Validator

ROOMS = ["Sakura", "Maple", "Cedar"]
SCHEMA = {
    "type": "object",
    "properties": {
        "requester_name": {"type": "string", "minLength": 1},
        "requester_email": {"type": ["string", "null"]},
        "room": {"enum": ROOMS + ["unknown"]},                      # fixed categories, with an explicit escape
        "date": {"type": ["string", "null"], "pattern": r"^\d{4}-\d{2}-\d{2}$"},   # null when the request gives no date
        "duration_minutes": {"type": ["integer", "null"], "minimum": 1},
        "needs_projector": {"type": "boolean"},
        "attendees": {"type": "array", "items": {                 # array of nested objects
            "type": "object",
            "properties": {"name": {"type": "string"}, "email": {"type": ["string", "null"]}},
            "required": ["name", "email"], "additionalProperties": False}},
        "notes": {"type": "string"},                                # optional: not in "required"
    },
    "required": ["requester_name", "requester_email", "room", "date", "duration_minutes", "needs_projector", "attendees"],
    "additionalProperties": False,                                  # no invented fields
}
Draft202012Validator.check_schema(SCHEMA)                           # the schema itself is valid

def problems(doc):
    """Short, sorted schema problems (sorted so the output is stable)."""
    out = []
    for e in Draft202012Validator(SCHEMA).iter_errors(doc):
        msg = e.message if e.validator in ("required", "additionalProperties") else f"{e.instance!r} fails {e.validator}"
        out.append(f"{'/'.join(map(str, e.path)) or '(top)'}: {msg}")
    return sorted(out)

good = {"requester_name": "Aiko Tan", "requester_email": "aiko@example.jp", "room": "Sakura", "date": "2026-11-03",
        "duration_minutes": 45, "needs_projector": True, "attendees": [{"name": "Ben Ito", "email": None}]}
print(problems(good))
print(problems({**good, "room": "sakura", "duration_minutes": "45", "colour": "red", "attendees": [{"name": "Ben Ito"}]}))

[]
["(top): Additional properties are not allowed ('colour' was unexpected)", "attendees/0: 'email' is a required property", "duration_minutes: '45' fails type", "room: 'sakura' fails enum"]

for label, patch in [("date null", {"date": None}), ("date empty string", {"date": ""}), ("date 'N/A'", {"date": "N/A"}),
                     ("duration null", {"duration_minutes": None}), ("duration 0", {"duration_minutes": 0}),
                     ("room unknown", {"room": "unknown"}), ("email missing key", {"requester_email": ...})]:
    doc = {k: v for k, v in {**good, **patch}.items() if v is not ...}
    print(f"{label:18}", problems(doc) or "valid")

date null          valid
date empty string  ["date: '' fails pattern"]
date 'N/A'         ["date: 'N/A' fails pattern"]
duration null      valid
duration 0         ['duration_minutes: 0 fails minimum']
room unknown       valid
email missing key  ["(top): 'requester_email' is a required property"]

from promptlab import Client, render

PEOPLE = [("Aiko Tan", "aiko@example.jp", "Sakura", "2026-11-03", 45, ["Ben Ito", "Mei Sato"], True),
          ("Kwame Mensah", "kwame@example.gh", "Maple", "2026-11-04", 60, [], False),
          ("Lena Fischer", "lena@example.de", "Cedar", None, 30, ["Omar Haddad"], False),
          ("Priya Nair", "priya@example.in", "Sakura", "2026-11-05", 120, ["Nadia Rahman"], True)] * 3
MODES = ["clean", "fence", "clean", "prose", "comma", "clean", "string_number", "bad_enum", "clean", "extra_key", "missing_key", "truncated"]

def request_text(k, p):
    name, mail, room, date, mins, others, proj = p
    when = f"on {date}" if date else "sometime next week"
    dur = f"{mins // 60} hours" if mins % 60 == 0 and mins >= 120 else f"{mins} minutes"
    who = f" {' and '.join(others)} will join." if others else ""
    return f"#{k}: Hi, this is {name} ({mail}). Please book {room} {when} for {dur}.{who}" + (" We need a projector." if proj else "")

REQUESTS = [request_text(k, p) for k, p in enumerate(PEOPLE)]
GOLD = [{"requester_name": n, "requester_email": m, "room": r, "date": d, "duration_minutes": t,
         "needs_projector": pr, "attendees": [{"name": a, "email": None} for a in o]} for n, m, r, d, t, o, pr in PEOPLE]
print(REQUESTS[0]); print(REQUESTS[3])

def toy_prompted(messages, **settings):
    """Stand-in for a model that was only ASKED for JSON. It answers correctly, then applies one typical
    drift per request. The mix of drifts is invented for teaching; real rates differ by model and prompt."""
    k = int(re.search(r"#(\d+):", messages[-1]["content"]).group(1))
    rec, mode = json.loads(json.dumps(GOLD[k])), MODES[k]
    if mode == "string_number": rec["duration_minutes"] = str(rec["duration_minutes"])
    if mode == "bad_enum": rec["room"] += " Room"
    if mode == "extra_key": rec["confidence"] = 0.9
    if mode == "missing_key": del rec["requester_email"]
    text = json.dumps(rec)
    return {"fence": f"```json\n{text}\n```", "prose": f"Here is the JSON you asked for:\n{text}",
            "comma": text[:-1] + ",}", "truncated": text[:70]}.get(mode, text)

#0: Hi, this is Aiko Tan (aiko@example.jp). Please book Sakura on 2026-11-03 for 45 minutes. Ben Ito and Mei Sato will join. We need a projector.
#3: Hi, this is Priya Nair (priya@example.in). Please book Sakura on 2026-11-05 for 2 hours. Nadia Rahman will join. We need a projector.

PROMPT = "Extract the meeting request as JSON.\n### REQUEST\n{request}"      # the toy ignores the wording; your checks matter here

def classify(text):
    try: doc = json.loads(text)
    except json.JSONDecodeError as exc: return f"not JSON ({exc.msg})"
    return "valid" if not problems(doc) else "schema: " + problems(doc)[0][:48]

client = Client(toy_prompted)
raw = [client.complete([{"role": "user", "content": render(PROMPT, request=r)}]).text for r in REQUESTS]
for k, text in enumerate(raw): print(f"#{k:<2}", classify(text))
print("valid:", sum(classify(t) == "valid" for t in raw), "of", len(raw))

#0  valid
#1  not JSON (Expecting value)
#2  valid
#3  not JSON (Expecting value)
#4  not JSON (Expecting property name enclosed in double quotes)
#5  valid
#6  schema: duration_minutes: '30' fails type
#7  schema: room: 'Sakura Room' fails enum
#8  valid
#9  schema: (top): Additional properties are not allowed ('c
#10 schema: (top): 'requester_email' is a required property
#11 not JSON (Expecting ',' delimiter)
valid: 4 of 12

from collections import Counter

def extract_json(text):
    """Defensive rescue: keep the text from the first '{' to the last '}'. It removes wrappers; it cannot repair content."""
    start, end = text.find("{"), text.rfind("}")
    return text[start:end + 1] if 0 <= start < end else text

after = [classify(extract_json(t)) for t in raw]
print("valid after rescue:", after.count("valid"), "of", len(raw))
print(sorted(Counter(a.split(":")[0].split(" (")[0] for a in after if a != "valid").items()))

def toy_constrained(messages, **settings):
    """Stand-in for schema-constrained generation: every reply parses and fits SCHEMA, but a value can still be wrong
    (here it reads the first number after 'for', so '2 hours' becomes 2 minutes)."""
    k = int(re.search(r"#(\d+):", messages[-1]["content"]).group(1))
    rec = json.loads(json.dumps(GOLD[k]))
    rec["duration_minutes"] = int(re.search(r"for (\d+)", messages[-1]["content"]).group(1))
    return json.dumps(rec)

cons = Client(toy_constrained)
out = [json.loads(cons.complete([{"role": "user", "content": render(PROMPT, request=r)}]).text) for r in REQUESTS]
print("fit the schema:", sum(not problems(d) for d in out), "of", len(out))
print("equal to the true record:", sum(d == g for d, g in zip(out, GOLD)), "of", len(out))
print("wrong duration in requests:", [k for k, (d, g) in enumerate(zip(out, GOLD)) if d != g])

valid after rescue: 6 of 12
[('not JSON', 2), ('schema', 4)]
fit the schema: 12 of 12
equal to the true record: 9 of 12
wrong duration in requests: [3, 7, 11]

SCHEMA["properties"]["room"]["enum"].append("Online")
print(problems({**good, "room": "Online"}) or "valid", problems({**good, "room": "online"}))

valid ["room: 'online' fails enum"]

SCHEMA["properties"]["needs_projector"] = {"type": ["boolean", "null"]}      # null = the request did not say
for v in (True, None, "yes"):
    print(repr(v), problems({**good, "needs_projector": v}) or "valid")

True valid
None valid
'yes' ["needs_projector: 'yes' fails type"]

def parse_strict(text):
    """Accept bare JSON, or ONE fenced block with nothing else around it. Return (document, note)."""
    body = text.strip()
    fenced = re.fullmatch(r"```(?:json)?\n(.*)\n```", body, re.S)
    try: return json.loads(fenced.group(1) if fenced else body), "fenced" if fenced else "clean"
    except json.JSONDecodeError as exc: return None, f"rejected: {exc.msg}"

for k in (0, 1, 3, 4):
    print(k, *parse_strict(raw[k])[1:])

0 clean
1 fenced
3 rejected: Expecting value
4 rejected: Expecting property name enclosed in double quotes