nardial 0.1.0__py3-none-any.whl

nardial/authoring/__init__.py

@@ -0,0 +1 @@
+from .loader import load_dialogs

nardial/authoring/export_html.py

@@ -0,0 +1,215 @@
+"""
+Export dialogs.json to a readable HTML report for reviews/printing.
+
+Usage:
+  - Default input: assets/dialogs/dialogs.json
+  - Default output: web/authoring/dialogs_report.html
+
+  python src/authoring/export_html.py
+  python src/authoring/export_html.py path/to/dialogs.json path/to/output.html
+"""
+from __future__ import annotations
+
+import json
+import sys
+import os
+from collections import defaultdict
+from html import escape
+
+
+def load_dialogs(path: str):
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    if not isinstance(data, list):
+        raise ValueError("dialogs.json must be a list of dialogs")
+    # ensure unique ids
+    ids = [d.get("id") for d in data]
+    dups = {i for i in ids if ids.count(i) > 1}
+    if dups:
+        print(f"Warning: duplicate dialog ids found: {sorted(dups)}")
+    return data
+
+
+def render_moves(moves: list[dict]) -> str:
+    rows = []
+    for m in moves or []:
+        t = escape(str(m.get("type", "")))
+        branch = m.get("branch")
+        branch_s = f"<code class=branch>{escape(str(branch))}</code>" if branch not in (None, "") else ""
+        text = m.get("text")
+        audio = m.get("audio")
+        options = m.get("options")
+        next_map = m.get("next")
+        set_var = m.get("set_variable")
+        add_int = m.get("add_interest")
+        add_from_ans = m.get("add_interest_from_answer")
+        add_from_var = m.get("add_interest_from_variable")
+
+        details = []
+        if text:
+            details.append(f"<div class=mv-text>{escape(text)}</div>")
+        if audio:
+            details.append(f"<div class=mv-audio>audio: <code>{escape(audio)}</code></div>")
+        if options:
+            details.append("<div class=mv-options>options: " + ", ".join(f"<code>{escape(str(o))}</code>" for o in options) + "</div>")
+        if set_var:
+            details.append(f"<div class=mv-set>set_variable: <code>{escape(set_var)}</code></div>")
+        if add_int:
+            details.append(f"<div class=mv-add>add_interest: <code>{escape(add_int)}</code></div>")
+        if add_from_ans:
+            details.append("<div class=mv-add>add_interest_from_answer: <code>true</code></div>")
+        if add_from_var:
+            details.append("<div class=mv-add>add_interest_from_variable: <code>true</code></div>")
+        if next_map:
+            try:
+                next_json = json.dumps(next_map, ensure_ascii=False)
+            except Exception:
+                next_json = escape(str(next_map))
+            details.append(f"<div class=mv-next>next: <code>{escape(next_json)}</code></div>")
+
+        rows.append(
+            """
+            <div class="move">
+              <div class="mv-head"><span class="mv-type">{t}</span> {branch}</div>
+              <div class="mv-body">{details}</div>
+            </div>
+            """.format(
+                t=t, branch=branch_s, details="".join(details)
+            )
+        )
+    return "\n".join(rows)
+
+
+def render_dialog(d: dict) -> str:
+    did = escape(str(d.get("id", "")))
+    dtype = escape(str(d.get("type", "")))
+    meta_bits = []
+    if dtype == "functional":
+        ft = d.get("functional_type")
+        if ft:
+            meta_bits.append(f"functional_type: <code>{escape(str(ft))}</code>")
+    if dtype == "narrative":
+        thr = d.get("thread")
+        pos = d.get("position")
+        if thr:
+            meta_bits.append(f"thread: <code>{escape(str(thr))}</code>")
+        if pos is not None:
+            meta_bits.append(f"position: <code>{escape(str(pos))}</code>")
+    if dtype == "chitchat":
+        theme = d.get("theme")
+        if theme:
+            meta_bits.append(f"theme: <code>{escape(str(theme))}</code>")
+        topics = d.get("topics") or []
+        if topics:
+            meta_bits.append("topics: " + ", ".join(f"<code>{escape(str(t))}</code>" for t in topics))
+
+    deps = d.get("dependencies") or []
+    vdeps = d.get("variable_dependencies") or []
+    if deps:
+        meta_bits.append("dependencies: " + ", ".join(f"<code>{escape(str(x))}</code>" for x in deps))
+    if vdeps:
+        # support strings or {variable, required}
+        def vd_to_str(v):
+            if isinstance(v, dict):
+                req = v.get("required")
+                return f"{v.get('variable')}" + (" (required)" if req else "")
+            return str(v)
+        meta_bits.append("variable_dependencies: " + ", ".join(f"<code>{escape(vd_to_str(x))}</code>" for x in vdeps))
+
+    moves_html = render_moves(d.get("moves") or [])
+
+    return f"""
+    <article class="dialog">
+      <h4><code>{did}</code> <span class="dtype">[{dtype}]</span></h4>
+      <div class="meta">{' • '.join(meta_bits) if meta_bits else ''}</div>
+      <div class="moves">{moves_html}</div>
+    </article>
+    """
+
+
+def build_html(dialogs: list[dict]) -> str:
+    # group
+    functionals = [d for d in dialogs if d.get("type") == "functional"]
+    narratives = [d for d in dialogs if d.get("type") == "narrative"]
+    chitchats = [d for d in dialogs if d.get("type") == "chitchat"]
+
+    narratives_by_thread = defaultdict(list)
+    for d in narratives:
+        narratives_by_thread[d.get("thread")].append(d)
+    for thr in narratives_by_thread:
+        narratives_by_thread[thr].sort(key=lambda x: (x.get("position") is None, x.get("position", 0)))
+
+    chitchats_by_theme = defaultdict(list)
+    for d in chitchats:
+        chitchats_by_theme[d.get("theme")].append(d)
+    for th in chitchats_by_theme:
+        chitchats_by_theme[th].sort(key=lambda x: x.get("id", ""))
+
+    def section(title: str, body: str) -> str:
+        return f"<section><h2>{escape(title)}</h2>{body}</section>"
+
+    functional_html = "".join(render_dialog(d) for d in sorted(functionals, key=lambda x: x.get("functional_type", "") + "_" + x.get("id", "")))
+
+    narrative_html = []
+    for thr in sorted(narratives_by_thread.keys(), key=lambda s: s or ""):
+        items = "".join(render_dialog(d) for d in narratives_by_thread[thr])
+        head = f"<h3>Thread: <code>{escape(str(thr))}</code></h3>" if thr else ""
+        narrative_html.append(f"<div class=thread>{head}{items}</div>")
+
+    chitchat_html = []
+    for th in sorted(chitchats_by_theme.keys(), key=lambda s: s or ""):
+        items = "".join(render_dialog(d) for d in chitchats_by_theme[th])
+        head = f"<h3>Theme: <code>{escape(str(th))}</code></h3>" if th else ""
+        chitchat_html.append(f"<div class=theme>{head}{items}</div>")
+
+    style = """
+    <style>
+      body{font-family:system-ui,-apple-system,Segoe UI,Roboto,Arial;background:#0b0f14;color:#e7eefb;margin:0;padding:24px}
+      h1,h2,h3,h4{margin:0 0 8px 0}
+      h2{margin-top:24px;border-bottom:1px solid #233046;padding-bottom:6px}
+      section{margin-bottom:24px}
+      .dialog{border:1px solid #233046;border-radius:8px;margin:12px 0;padding:12px;background:#121821}
+      .dtype{color:#89a1bd;font-weight:normal}
+      .meta{color:#89a1bd;font-size:12px;margin-bottom:8px}
+      .moves{display:flex;flex-direction:column;gap:8px}
+      .move{border:1px solid #233046;border-radius:6px}
+      .mv-head{background:#0f1623;padding:6px 8px}
+      .mv-type{background:#4ea1ff;color:#001229;padding:1px 6px;border-radius:999px;font-size:12px}
+      .branch{color:#89a1bd}
+      .mv-body{padding:8px 10px;display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:6px}
+      code{background:#0f1623;border:1px solid #233046;border-radius:4px;padding:0 4px}
+      .thread,.theme{margin:8px 0}
+    </style>
+    """
+
+    html = f"""
+    <!doctype html>
+    <html lang=\"en\">\n<meta charset=\"utf-8\">\n<title>Dialogs Report</title>
+    {style}
+    <h1>Dialogs Report</h1>
+    {section('Functional', functional_html)}
+    {section('Narrative', ''.join(narrative_html))}
+    {section('Chitchat', ''.join(chitchat_html))}
+    """
+    return html
+
+
+def main(argv: list[str]) -> int:
+    repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+    default_in = os.path.join(repo_root, "assets", "dialogs", "dialogs.json")
+    default_out = os.path.join(repo_root, "web", "authoring", "dialogs_report.html")
+
+    in_path = argv[1] if len(argv) > 1 else default_in
+    out_path = argv[2] if len(argv) > 2 else default_out
+
+    dialogs = load_dialogs(in_path)
+    html = build_html(dialogs)
+    os.makedirs(os.path.dirname(out_path), exist_ok=True)
+    with open(out_path, "w", encoding="utf-8") as f:
+        f.write(html)
+    print(f"Wrote HTML report: {out_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv))

nardial/authoring/factory.py

@@ -0,0 +1,178 @@
+from typing import Any, Dict, List
+
+from src.nardial.mini_dialogs import MiniDialog, NarrativeDialog, ChitchatDialog, FunctionalDialog, LLMDialog, DialogType
+from src.nardial.moves import MOVE_SAY, MOVE_ASK_OPEN, MOVE_ASK_YESNO, MOVE_ASK_OPTIONS, MOVE_PLAY_AUDIO
+
+
+ALLOWED_MOVE_TYPES = {MOVE_SAY, MOVE_ASK_YESNO, MOVE_ASK_OPEN, MOVE_ASK_OPTIONS, MOVE_PLAY_AUDIO}
+
+
+class MoveFactory:
+    @staticmethod
+    def validate(move: Dict[str, Any], idx: int = 0) -> List[str]:
+        errs: List[str] = []
+        if not isinstance(move, dict):
+            return [f"moves[{idx}] must be an object"]
+        mt = move.get("type")
+        if mt not in ALLOWED_MOVE_TYPES:
+            errs.append(f"moves[{idx}].type must be one of {sorted(ALLOWED_MOVE_TYPES)}")
+        if mt in {"say"}:
+            if not isinstance(move.get("text"), str):
+                errs.append(f"moves[{idx}].text must be string for say")
+        if mt in {MOVE_ASK_YESNO, MOVE_ASK_OPEN, MOVE_ASK_OPTIONS}:
+            if not isinstance(move.get("text"), str):
+                errs.append(f"moves[{idx}].text must be string for {mt}")
+        if mt == "ask_options":
+            opts = move.get("options")
+            if not isinstance(opts, list) or not all(isinstance(o, str) for o in opts):
+                errs.append(f"moves[{idx}].options must be a list of strings for ask_options")
+        if "set_variable" in move and not isinstance(move.get("set_variable"), str):
+            errs.append(f"moves[{idx}].set_variable must be string if present")
+        return errs
+
+    @staticmethod
+    def normalize(move: Dict[str, Any]) -> Dict[str, Any]:
+        # Keep as-is; runtime expects dict moves. We could strip unknown keys later if needed.
+        return dict(move)
+
+
+class DialogFactory:
+    @staticmethod
+    def _normalize_variable_dependencies(vdeps: Any) -> List[Dict[str, Any]]:
+        out: List[Dict[str, Any]] = []
+        if not vdeps:
+            return out
+        for item in vdeps:
+            if isinstance(item, str):
+                out.append({"variable": item, "required": True})
+            elif isinstance(item, dict) and item.get("variable"):
+                d = {"variable": str(item["variable"]), "required": bool(item.get("required", True))}
+                out.append(d)
+        return out
+
+    @staticmethod
+    def validate_doc(doc: Dict[str, Any]) -> List[str]:
+        errs: List[str] = []
+        t = doc.get("type")
+        did = doc.get("id")
+        if not isinstance(did, str) or not did:
+            errs.append("id must be non-empty string")
+        if t not in {"functional", "narrative", "chitchat"}:
+            errs.append("type must be 'functional' | 'narrative' | 'chitchat'")
+        # shared
+        deps = doc.get("dependencies")
+        if deps is not None and (not isinstance(deps, list) or not all(isinstance(x, str) for x in deps)):
+            errs.append("dependencies must be a list of strings")
+        # variable deps: allow list[str|obj]
+        vdeps = doc.get("variable_dependencies")
+        if vdeps is not None:
+            if not isinstance(vdeps, list):
+                errs.append("variable_dependencies must be a list")
+            else:
+                for idx, vd in enumerate(vdeps):
+                    if isinstance(vd, str):
+                        continue
+                    if not isinstance(vd, dict) or "variable" not in vd:
+                        errs.append(f"variable_dependencies[{idx}] must be string or object with 'variable'")
+        # type-specific
+        if t == "functional":
+            if not isinstance(doc.get("functional_type"), str):
+                errs.append("functional_type must be string for functional dialogs")
+        elif t == "narrative":
+            if not isinstance(doc.get("thread"), str):
+                errs.append("thread must be string for narrative dialogs")
+            try:
+                int(doc.get("position"))
+            except Exception:
+                errs.append("position must be integer for narrative dialogs")
+        elif t == "chitchat":
+            if not isinstance(doc.get("theme"), str):
+                errs.append("theme must be string for chitchat dialogs")
+            topics = doc.get("topics")
+            if topics is not None and (not isinstance(topics, list) or not all(isinstance(x, str) for x in topics)):
+                errs.append("topics must be a list of strings for chitchat dialogs")
+
+        moves = doc.get("moves")
+        if not isinstance(moves, list):
+            errs.append("moves must be a list")
+        else:
+            for i, mv in enumerate(moves):
+                errs.extend(MoveFactory.validate(mv, idx=i))
+        return errs
+
+    @staticmethod
+    def from_json(doc: Dict[str, Any]) -> MiniDialog:
+        errors = DialogFactory.validate_doc(doc)
+        if errors:
+            raise ValueError("; ".join(errors))
+
+        dtype = doc.get("type")
+        did = doc.get("id")
+        deps = list(doc.get("dependencies") or [])
+        vdeps = DialogFactory._normalize_variable_dependencies(doc.get("variable_dependencies"))
+        moves = [MoveFactory.normalize(m) for m in (doc.get("moves") or [])]
+
+        if dtype == DialogType.NARRATIVE.value:
+            return NarrativeDialog(
+                dialog_id=did,
+                moves=moves,
+                thread=doc["thread"],
+                position=int(doc["position"]),
+                dependencies=deps,
+                variable_dependencies=vdeps,
+            )
+        if dtype == DialogType.CHITCHAT.value:
+            return ChitchatDialog(
+                dialog_id=did,
+                moves=moves,
+                theme=doc.get("theme") or "",
+                topics=list(doc.get("topics") or []),
+                dependencies=deps,
+                variable_dependencies=vdeps,
+            )
+        if dtype == DialogType.FUNCTIONAL.value:
+            return FunctionalDialog(
+                dialog_id=did,
+                moves=moves,
+                type=doc["functional_type"],
+                dependencies=deps,
+            )
+        if dtype == DialogType.LLM_BASED.value:
+            return LLMDialog(
+                dialog_id=did,
+                moves=moves,
+                prompt=doc["prompt"],
+                max_turns=doc["max_turns"],
+                dependencies=deps,
+                variable_dependencies=vdeps,
+            )
+        return MiniDialog(did, moves, deps, vdeps)
+
+    @staticmethod
+    def to_json(d: MiniDialog) -> Dict[str, Any]:
+        base: Dict[str, Any] = {
+            "id": getattr(d, "dialog_id", None),
+            "dependencies": list(getattr(d, "dependencies", []) or []),
+            "variable_dependencies": list(getattr(d, "variable_dependencies", []) or []),
+            "moves": list(getattr(d, "moves", []) or []),
+        }
+        if isinstance(d, NarrativeDialog):
+            base.update({
+                "type": "narrative",
+                "thread": getattr(d, "thread", ""),
+                "position": int(getattr(d, "position", 0)),
+            })
+        elif isinstance(d, ChitchatDialog):
+            base.update({
+                "type": "chitchat",
+                "theme": getattr(d, "theme", ""),
+                "topics": list(getattr(d, "topics", []) or []),
+            })
+        elif isinstance(d, FunctionalDialog):
+            base.update({
+                "type": "functional",
+                "functional_type": getattr(d, "type", ""),
+            })
+        else:
+            base.update({"type": "unknown"})
+        return base

nardial/authoring/loader.py

@@ -0,0 +1,70 @@
+import json
+import os
+from typing import Any, Dict, List, Tuple
+
+from src.nardial.authoring.factory import DialogFactory
+from src.nardial.mini_dialogs import MiniDialog
+
+
+def _load_json_file(path: str) -> List[Dict[str, Any]]:
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    if isinstance(data, list):
+        return data
+    if isinstance(data, dict):
+        return [data]
+    raise ValueError(f"Unsupported JSON root in {path}: {type(data)}")
+
+
+def load_dialogs(path_or_dir: str) -> Tuple[List[MiniDialog], List[str]]:
+    """Load dialogs from a JSON file or all .json files in a directory.
+
+    Returns (dialogs, errors).
+    """
+    dialogs: List[MiniDialog] = []
+    errors: List[str] = []
+
+    try:
+        if os.path.isdir(path_or_dir):
+            for fn in os.listdir(path_or_dir):
+                if not fn.lower().endswith(".json"):
+                    continue
+                p = os.path.join(path_or_dir, fn)
+                try:
+                    for doc in _load_json_file(p):
+                        dialogs.append(DialogFactory.from_json(doc))
+                except Exception as e:
+                    errors.append(f"{p}: {e}")
+        else:
+            for doc in _load_json_file(path_or_dir):
+                try:
+                    dialogs.append(DialogFactory.from_json(doc))
+                except Exception as e:
+                    errors.append(f"{path_or_dir}: {e}")
+    except Exception as e:
+        errors.append(str(e))
+
+    return dialogs, errors
+
+
+def dialog_to_doc(d: MiniDialog) -> Dict[str, Any]:
+    """Serialize a dialog object back to a JSON-ready dict (round-trip)."""
+    return DialogFactory.to_json(d)
+
+
+def save_dialogs(path: str, dialogs: List[MiniDialog]) -> None:
+    """Save a list of dialog objects to a single JSON file (array root)."""
+    docs = [dialog_to_doc(d) for d in dialogs]
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(docs, f, indent=2, ensure_ascii=False)
+
+
+def save_dialogs_to_dir(directory: str, dialogs: List[MiniDialog]) -> None:
+    """Save each dialog to its own JSON file inside directory."""
+    os.makedirs(directory, exist_ok=True)
+    for d in dialogs:
+        did = getattr(d, "dialog_id", None) or "untitled"
+        safe_id = "".join(c for c in did if c.isalnum() or c in ("_", "-"))
+        path = os.path.join(directory, f"{safe_id}.json")
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(dialog_to_doc(d), f, indent=2, ensure_ascii=False)