| |
| """SML's path-preserving conversation decoder. Python 3.9+, standard library only. |
| |
| Follows recorded branches; never generates a response, merges equal sentences, |
| or rewrites the source. JSON pointers use RFC 6901, indices are zero-based. |
| """ |
| import argparse |
| import hashlib |
| import json |
| import sys |
| from dataclasses import dataclass |
| from pathlib import Path |
|
|
| VERSION = "1.0.0" |
|
|
|
|
| class DecodeError(ValueError): |
| """The requested path or source structure cannot be decoded faithfully.""" |
|
|
|
|
| def pointer(base, *parts): |
| return base + "".join("/" + str(p).replace("~", "~0").replace("/", "~1") for p in parts) |
|
|
|
|
| def resolve(document, path): |
| if path == "": |
| return document |
| if not path.startswith("/"): |
| raise DecodeError("A JSON pointer must start with /.") |
| value = document |
| for part in path[1:].split("/"): |
| part = part.replace("~1", "/").replace("~0", "~") |
| value = value[int(part)] if isinstance(value, list) else value[part] |
| return value |
|
|
|
|
| def sentence(value): |
| if isinstance(value, str): |
| return value |
| if isinstance(value, dict): |
| for key in ("sentence", "content", "text", "words"): |
| if isinstance(value.get(key), str): |
| return value[key] |
| return "" |
|
|
|
|
| @dataclass(frozen=True) |
| class Schema: |
| name: str |
| prompt_keys: tuple |
| branches: str |
| answer: str |
| prompt_role: str = "Partner" |
| answer_role: str = "Response" |
|
|
|
|
| QA = Schema("question / answer", ("question",), "branches", "answer") |
| AAC = Schema("AAC / continuation", ("initial_statement", "other_person_says", "initial_question"), |
| "response_branches", "aac_response") |
| GOLDEN = Schema("doctor / patient", ("root", "doctor"), "branches", "patient", "Doctor", "Patient") |
| CALL = Schema("caller / dispatcher", ("initial_call", "caller_says"), |
| "response_branches", "dispatcher_response", "Caller", "Dispatcher") |
| DISPATCH = Schema("dispatcher / AAC", ("initial_dispatcher_message", "dispatcher_says"), |
| "response_branches", "aac_response", "Dispatcher", "Caller") |
| SCHEMAS = (QA, AAC, GOLDEN, CALL, DISPATCH) |
|
|
|
|
| def schema_for(value): |
| if not isinstance(value, dict): |
| return None |
| for schema in SCHEMAS: |
| if any(k in value for k in schema.prompt_keys) and schema.branches in value: |
| return schema |
| return None |
|
|
|
|
| def tile(value, path, role): |
| text = sentence(value) |
| if not text: |
| raise DecodeError("Missing recorded text at " + (path or "/")) |
| metadata = value if isinstance(value, dict) else {} |
| return {"text": text, "role": metadata.get("role") or role, |
| "pointer": path, "emoji": metadata.get("emoji", ""), |
| "tile_id": metadata.get("tile_id"), "metadata": metadata} |
|
|
|
|
| class Conversation: |
| def __init__(self, value, path, schema=None): |
| self.value, self.pointer, self.schema = value, path, schema |
| self.linear = schema is None |
|
|
| def summary(self, index): |
| v = self.value |
| if self.linear: |
| prompt = sentence(v["messages"][0]) if v["messages"] else "" |
| else: |
| prompt = sentence(next((v[k] for k in self.schema.prompt_keys if k in v), None)) |
| return {"index": index, "conversation_id": v.get("conversation_id"), |
| "title": v.get("topic") or v.get("emergency_type") or |
| (v.get("metadata") or {}).get("topic") or prompt or "Untitled conversation", |
| "prompt": prompt, "pointer": self.pointer, |
| "schema": "linear messages" if self.linear else self.schema.name} |
|
|
| def _state(self, node, path): |
| if node is None: |
| return None, [], None |
| if isinstance(node, str): |
| return tile(node, path, self.schema.prompt_role), [], None |
| if not isinstance(node, dict): |
| raise DecodeError("Unsupported continuation at " + path) |
| key = next((k for k in self.schema.prompt_keys if k in node), None) |
| if key is None: |
| raise DecodeError("Missing recorded prompt at " + path) |
| prompt = tile(node[key], pointer(path, key), self.schema.prompt_role) |
| branches = node.get(self.schema.branches, []) |
| if not isinstance(branches, list): |
| raise DecodeError("Branches must be an array at " + path) |
| options = [] |
| for index, branch in enumerate(branches): |
| bp = pointer(path, self.schema.branches, index) |
| if not isinstance(branch, dict) or self.schema.answer not in branch: |
| raise DecodeError("Missing recorded response at " + bp) |
| response = tile(branch[self.schema.answer], pointer(bp, self.schema.answer), |
| self.schema.answer_role) |
| options.append({**response, "index": index, |
| "has_continuation": branch.get("continuation") is not None}) |
| return prompt, options, branches |
|
|
| def trace(self, choices=()): |
| choices = list(choices) |
| if any(type(i) is not int or i < 0 for i in choices): |
| raise DecodeError("Branch indices must be nonnegative integers.") |
| if self.linear: |
| return self._linear_trace(choices) |
| history = [] |
| node, path = self.value, self.pointer |
| prompt, options, branches = self._state(node, path) |
| if prompt: |
| history.append({**prompt, "kind": "prompt", "step": 0}) |
| for step, choice in enumerate(choices, 1): |
| if choice >= len(options): |
| raise DecodeError("Branch %d does not exist at step %d." % (choice, step)) |
| response = options[choice] |
| history.append({**response, "kind": "response", "step": step}) |
| branch = branches[choice] |
| path = pointer(path, self.schema.branches, choice, "continuation") |
| node = branch.get("continuation") |
| prompt, options, branches = self._state(node, path) |
| if prompt: |
| history.append({**prompt, "kind": "prompt", "step": step}) |
| return self._result(choices, history, options, path if node is not None else None) |
|
|
| def _linear_trace(self, choices): |
| messages = self.value["messages"] |
| if any(i != 0 for i in choices) or len(choices) >= len(messages): |
| raise DecodeError("Linear conversations have one recorded next message (branch 0).") |
| history = [] |
| for i, message in enumerate(messages[:len(choices) + 1]): |
| history.append({**tile(message, pointer(self.pointer, "messages", i), "Message"), |
| "kind": "message", "step": i}) |
| next_index = len(history) |
| options = [] |
| if next_index < len(messages): |
| options = [{**tile(messages[next_index], pointer(self.pointer, "messages", next_index), |
| "Message"), "index": 0, "has_continuation": next_index + 1 < len(messages)}] |
| return self._result(choices, history, options, history[-1]["pointer"] if history else None) |
|
|
| def _result(self, choices, history, options, path): |
| return {"decoder_version": VERSION, "conversation_id": self.value.get("conversation_id"), |
| "root_pointer": self.pointer, "node_pointer": path, |
| "schema": "linear messages" if self.linear else self.schema.name, |
| "branch_path": choices, "depth": len(choices), "history": history, |
| "options": options, "terminal": not options, "linear": self.linear} |
|
|
| def walk(self): |
| """Emit every reachable state, retaining full history and original pointers.""" |
| pending = [()] |
| while pending: |
| path = pending.pop() |
| result = self.trace(path) |
| yield result |
| pending.extend(path + (o["index"],) for o in reversed(result["options"])) |
|
|
|
|
| class Document: |
| def __init__(self, value): |
| self.value = value |
| self.conversations = [] |
| self._discover(value) |
|
|
| def _discover(self, value): |
| pending = [(value, "")] |
| while pending: |
| item, path = pending.pop() |
| schema = schema_for(item) |
| if schema: |
| self.conversations.append(Conversation(item, path, schema)) |
| continue |
| if isinstance(item, dict) and isinstance(item.get("messages"), list): |
| if item["messages"] and all(sentence(m) for m in item["messages"]): |
| self.conversations.append(Conversation(item, path)) |
| continue |
| if isinstance(item, dict): |
| pending.extend((v, pointer(path, k)) for k, v in reversed(list(item.items())) |
| if isinstance(v, (dict, list))) |
| elif isinstance(item, list): |
| pending.extend((item[i], pointer(path, i)) for i in reversed(range(len(item))) |
| if isinstance(item[i], (dict, list))) |
|
|
| def summaries(self): |
| return [c.summary(i) for i, c in enumerate(self.conversations)] |
|
|
| def trace(self, conversation=0, choices=()): |
| if type(conversation) is not int or not 0 <= conversation < len(self.conversations): |
| raise DecodeError("Conversation index is out of range, or this file contains no supported conversations.") |
| return {**self.conversations[conversation].trace(choices), "conversation_index": conversation} |
|
|
| def walk(self): |
| for index, conversation in enumerate(self.conversations): |
| for state in conversation.walk(): |
| yield {**state, "conversation_index": index} |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("source", type=Path, help="Original tree JSON file") |
| parser.add_argument("--list", action="store_true", help="List conversation roots") |
| parser.add_argument("--conversation", type=int, default=0, help="Zero-based conversation index") |
| parser.add_argument("--path", default="", help="Zero-based branch indices, e.g. 0,2,1") |
| parser.add_argument("--all", action="store_true", help="Export every reachable state as JSONL") |
| args = parser.parse_args() |
| try: |
| raw = args.source.read_bytes() |
| doc = Document(json.loads(raw)) |
| provenance = {"sha256": hashlib.sha256(raw).hexdigest(), "file_name": args.source.name} |
| if args.list: |
| print(json.dumps(doc.summaries(), ensure_ascii=False, indent=2)) |
| elif args.all: |
| if not doc.conversations: |
| raise DecodeError("No supported conversation trees or message sequences in this file.") |
| for row in doc.walk(): |
| print(json.dumps({**row, "source": provenance}, ensure_ascii=False)) |
| else: |
| choices = [int(i) for i in args.path.split(",")] if args.path else [] |
| print(json.dumps({**doc.trace(args.conversation, choices), "source": provenance}, |
| ensure_ascii=False, indent=2)) |
| except (OSError, ValueError, RecursionError) as error: |
| parser.exit(2, "Decoder error: %s\n" % error) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
