@oh-story/dsh 0.1.12 → 0.1.13

package/lib/video-recap/skills/video-understanding/scripts/detect.py

@@ -198,13 +198,12 @@ def _compact_ffmpeg_error(stderr, limit=400):
     return "…" + text[-limit:]
 
 def annotate_quiet_windows_with_asr(periods, asr_result=None, *, video_duration=None, configured_segment_seconds=None):
-    """Pure helper: annotate quiet windows with ASR-overlap confidence and QC.
+    """Pure helper: annotate quiet windows with ASR-overlap confidence.
 
     Coarse grid ASR (large synthetic windows from chunking) must not turn every quiet
-    window into speech. The return value is (annotated_periods, qc). Inputs are copied.
+    window into speech. Returns the annotated periods; inputs are copied.
     """
     out = [dict(p) for p in (periods or [])]
-    qc = {"coarse_asr_windows": 0, "low_confidence_speech_flags": 0, "asr_granularity": "none"}
     for qp in out:
         qp.setdefault("speech_overlap_ratio", 0.0)
         qp.setdefault("asr_overlap_seconds", 0.0)
@@ -212,7 +211,7 @@ def annotate_quiet_windows_with_asr(periods, asr_result=None, *, video_duration=
         qp.setdefault("has_speech", False)
         qp.setdefault("has_speech_reason", "no_asr_overlap")
     if not asr_result:
-        return out, qc
+        return out
 
     valid_segments = []
     for seg in asr_result:
@@ -232,8 +231,6 @@ def annotate_quiet_windows_with_asr(periods, asr_result=None, *, video_duration=
         (avg_seg_dur >= configured * 0.9 and asr_coverage > float(video_duration) * 0.7)
     )
     granularity = "coarse_grid" if coarse_asr else "segment"
-    qc["asr_granularity"] = granularity
-    qc["avg_asr_segment_seconds"] = round(avg_seg_dur, 3)
     for qp in out:
         overlap_seconds = 0.0
         for ss, se in valid_segments:
@@ -245,8 +242,6 @@ def annotate_quiet_windows_with_asr(periods, asr_result=None, *, video_duration=
         if coarse_asr:
             qp["has_speech"] = False
             qp["has_speech_reason"] = "coarse_asr_overlap_ignored" if overlap_seconds > 0 else "coarse_asr_no_overlap"
-            if overlap_seconds > 0:
-                qc["coarse_asr_windows"] += 1
             continue
         if ratio >= 0.3:
             qp["has_speech"] = True
@@ -254,11 +249,10 @@ def annotate_quiet_windows_with_asr(periods, asr_result=None, *, video_duration=
         elif overlap_seconds > 0:
             qp["has_speech"] = False
             qp["has_speech_reason"] = "asr_overlap_low_confidence_quiet"
-            qc["low_confidence_speech_flags"] += 1
         else:
             qp["has_speech"] = False
             qp["has_speech_reason"] = "no_asr_overlap"
-    return out, qc
+    return out
 
 
 def detect_silence_periods(video_path, work_dir, asr_result=None):
@@ -343,16 +337,13 @@ def detect_silence_periods(video_path, work_dir, asr_result=None):
     periods = [p for p in merged if p["duration"] >= quiet_min]
 
     # 与 ASR 交叉验证：标记有语音的窗口，并记录可观测 confidence/reason。
-    periods, qc = annotate_quiet_windows_with_asr(
+    periods = annotate_quiet_windows_with_asr(
         periods,
         asr_result,
         video_duration=get_video_duration(str(audio_path)) if asr_result else None,
         configured_segment_seconds=CONFIG["asr_segment_seconds"],
     )
 
-    (work_dir / "silence_periods.qc.json").write_text(
-        json.dumps(qc, ensure_ascii=False, indent=2), encoding="utf-8")
-
     # 保存
     (work_dir / "silence_periods.json").write_text(
         json.dumps(periods, ensure_ascii=False, indent=2), encoding="utf-8")
@@ -363,6 +354,106 @@ def detect_silence_periods(video_path, work_dir, asr_result=None):
     return periods
 
 
+SPEECH_BOUNDARY_ANCHORS_SCHEMA_VERSION = 2
+
+
+def anchors_current(work_dir):
+    """True when speech_boundary_anchors.json exists and has the current schema.
+
+    Schema 1 labelled coarse-ASR anchors `high` from a proportional position guess; a cached
+    schema-1 artifact must be regenerated rather than trusted.
+    """
+    path = Path(work_dir) / "speech_boundary_anchors.json"
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError, TypeError):
+        return False
+    return (
+        isinstance(payload, dict)
+        and payload.get("schema_version") == SPEECH_BOUNDARY_ANCHORS_SCHEMA_VERSION
+    )
+
+
+def _anchor_confidence(seconds):
+    return "high" if seconds <= 0.6 else ("medium" if seconds <= 1.2 else "low")
+
+
+def _classify_anchor(timing_bound, error):
+    """(confidence, boundary_use) from the ASR-window bound and the pause-snap distance."""
+    confidence = _anchor_confidence(max(timing_bound, error))
+    if confidence in {"high", "medium"}:
+        return confidence, "verified"
+    return confidence, ("unverified" if error <= 1.2 else "none")
+
+
+def _upgrade_schema1_anchors(payload, asr_result):
+    """Relabel a schema-1 payload as schema 2 without audio, or return None.
+
+    Schema 1 already stores each anchor's pause, snap error and ASR window index, so the
+    schema-2 labels can be recomputed from `asr_result` alone. Anchor times are unchanged.
+    Returns None when any anchor cannot be mapped back to its ASR window.
+    """
+    segments = list(asr_result or [])
+    upgraded = []
+    for anchor in payload.get("sentence_anchors") or []:
+        try:
+            segment = segments[int(anchor["asr_segment_index"])]
+            seg_start = float(segment["start"])
+            seg_end = float(segment["end"])
+            pause_start = float(anchor["pause_start"])
+            error = float(anchor["alignment_error"])
+        except (KeyError, IndexError, TypeError, ValueError):
+            return None
+        tail = str(anchor.get("text_tail") or "").strip()
+        if seg_end <= seg_start or (tail and tail not in str(segment.get("text", ""))):
+            return None
+        timing_bound = max(pause_start - seg_start, seg_end - pause_start, 0.0)
+        confidence, boundary_use = _classify_anchor(timing_bound, error)
+        upgraded.append({
+            **anchor,
+            "timing_bound_seconds": round(timing_bound, 3),
+            "timing_basis": "asr_window",
+            "confidence": confidence,
+            "boundary_use": boundary_use,
+        })
+    return {
+        **payload,
+        "schema_version": SPEECH_BOUNDARY_ANCHORS_SCHEMA_VERSION,
+        "sentence_anchors": upgraded,
+        "upgraded_from_schema": payload.get("schema_version"),
+    }
+
+
+def ensure_speech_boundary_anchors(work_dir, asr_result):
+    """Bring speech_boundary_anchors.json to the current schema without losing anchors.
+
+    With `audio.wav` present the anchors are re-detected. Without it (a material-library
+    restore copies the anchors but not the audio) a schema-1 file is relabelled in place from
+    `asr_result`; if that is impossible the file is left untouched, because consumers read
+    schema-1 high/medium as before. Usable anchors are never replaced by an `unavailable`
+    artifact. Only a missing file with no audio falls through to the detector's
+    `unavailable` report, as before.
+    """
+    work_dir = Path(work_dir)
+    if anchors_current(work_dir):
+        return
+    path = work_dir / "speech_boundary_anchors.json"
+    if (work_dir / "audio.wav").exists() or not path.exists():
+        detect_speech_boundary_anchors(work_dir, asr_result)
+        return
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError, TypeError):
+        return
+    if not isinstance(payload, dict):
+        return
+    upgraded = _upgrade_schema1_anchors(payload, asr_result)
+    if upgraded is None:
+        log("⚠️  speech_boundary_anchors.json 为旧格式且无法从 asr_result 重新标注，保持原样")
+        return
+    path.write_text(json.dumps(upgraded, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
 def detect_speech_boundary_anchors(work_dir, asr_result):
     """Write sentence-end entry anchors by aligning ASR punctuation to short pauses.
 
@@ -370,13 +461,20 @@ def detect_speech_boundary_anchors(work_dir, asr_result):
     punctuation time from its character position inside the ASR window, then snap it to the
     closest short acoustic pause. The output is guidance + a deterministic pre-TTS gate; it
     never rewrites narration timing on its own.
+
+    The character-position estimate is a guess, so `confidence` is not taken from the snap
+    distance alone: the sentence end can be anywhere inside the ASR window, which bounds the
+    real error by `timing_bound_seconds` (the farther window edge from the pause). Only a
+    narrow window can yield `high`/`medium` (`boundary_use: verified`); a wide window yields
+    `low`, and an anchor that still snapped within the alignment limit is `unverified`
+    (usable by gates, labelled as an estimate) rather than dropped.
     """
     work_dir = Path(work_dir)
     audio_path = work_dir / "audio.wav"
     out_path = work_dir / "speech_boundary_anchors.json"
     segments = list(asr_result or [])
     report = {
-        "schema_version": 1,
+        "schema_version": SPEECH_BOUNDARY_ANCHORS_SCHEMA_VERSION,
         "artifact": "speech_boundary_anchors.json",
         "status": "completed",
         "detector": {
@@ -448,14 +546,18 @@ def detect_speech_boundary_anchors(work_dir, asr_result):
             used.add(pause["index"])
             last_midpoint = pause["midpoint"]
             error = abs(pause["midpoint"] - expected)
-            confidence = "high" if error <= 0.6 else ("medium" if error <= 1.2 else "low")
+            timing_bound = max(pause["start"] - seg_start, seg_end - pause["start"], 0.0)
+            confidence, boundary_use = _classify_anchor(timing_bound, error)
             anchors.append({
                 "time": pause["end"],
                 "pause_start": pause["start"],
                 "pause_end": pause["end"],
                 "expected_time": round(expected, 3),
                 "alignment_error": round(error, 3),
+                "timing_bound_seconds": round(timing_bound, 3),
+                "timing_basis": "asr_window",
                 "confidence": confidence,
+                "boundary_use": boundary_use,
                 "punctuation": match.group(0),
                 "text_tail": text[max(0, match.end() - 32):match.end()],
                 "asr_segment_index": asr_index,

package/lib/video-recap/skills/video-understanding/scripts/index_normalize.py

@@ -0,0 +1,359 @@
+"""Deterministic clean-up of the model-written understanding index (consolidate.py Pass B).
+
+Two defects seen in real indexes are repaired here, after the model reply is parsed:
+
+- `plot_points[*].time` written as "00:95" (seconds >= 60, i.e. raw scene seconds poured into
+  the ss field). The time is re-read as minutes * 60 + seconds and rewritten as canonical
+  "MM:SS" ("H:MM:SS" past an hour). A time that cannot be parsed, or that lies past the end
+  of the analysed scenes, is dropped instead of kept as a wrong timestamp.
+- The same character split into two `characters` entries where one's name is the other's name
+  or alias (a shared alias alone is not enough, and an entry that would bridge two different
+  characters is left on its own). Which entries merge does not depend on their order; the
+  merged character sits at the first occurrence and keeps the first name any member has, the
+  other names become aliases, and relationships are re-pointed at the surviving name.
+
+Pure functions only: no I/O, no model calls.
+"""
+
+import json
+import re
+
+_TIME_RE = re.compile(r"^\s*(?:(\d+):)?(\d+):(\d+(?:\.\d+)?)\s*$")
+_APPROX_RE = re.compile(r"^(?:大约|约)\s*")
+# "01:20左右" / "3分钟前后" / "80秒许": approximation words, dropped wherever they sit.
+_APPROX_WORD_RE = re.compile(r"\s*(?:左右|前后|许)")
+# "第3分钟" / "第95秒" / "第2小时": an ordinal names the Nth unit, read as its start
+# ((N-1) units, "第1分钟" is 00:00). Only a lone whole unit: "第3分20秒" is the time 03:20.
+_ORDINAL_UNIT_RE = re.compile(
+    r"^第\s*(\d+)\s*(小时|分钟|分|秒)(?=\s*(?:$|[-~～—–至到]))"
+)
+_ORDINAL_UNIT_SECONDS = {"小时": 3600, "分钟": 60, "分": 60, "秒": 1}
+# Any other ordinal prefix on a time ("第01:20", "第3分20秒") reads as that time.
+_ORDINAL_RE = re.compile(r"^第\s*(?=\d)")
+# A range starts with a digit, so a leading "-" (a negative time) is not a range separator.
+_RANGE_RE = re.compile(r"^(\d[\d:.]*?)\s*(?:秒|s|S)?\s*(?:-|~|～|—|–|至|到)\s*\d")
+_UNIT_RE = re.compile(r"\s*(?:秒|s|S)$")
+# "3分20秒" / "1小时2分3秒" / "3分钟" / "1.5分": rewritten as seconds ("200.0" / "3723.0" /
+# "180.0" / "90.0") before parsing.
+_CN_TIME_RE = re.compile(
+    r"(?:(\d+)\s*(?:小时|时)\s*)?(\d+(?:\.\d+)?)\s*分(?:钟)?\s*(?:(\d+(?:\.\d+)?)\s*秒?)?"
+)
+_DURATION_SLACK_SECONDS = 1.0
+_CONFIDENCE_RANK = {"high": 3, "medium": 2, "low": 1}
+_LIST_FIELDS = ("aliases", "visual_descriptions", "asr_mentions", "evidence_ids")
+
+
+def _ordinal_unit(match):
+    count, unit = match.groups()
+    return repr(max(int(count) - 1, 0) * _ORDINAL_UNIT_SECONDS[unit])
+
+
+def _cn_time(match):
+    hours, minutes, secs = match.groups()
+    return repr(int(hours or 0) * 3600 + float(minutes) * 60 + float(secs or 0))
+
+
+def _plot_time_text(value):
+    """Strip the wrappers models put around a time: 约/大约/左右/前后/许, an ordinal 第, a
+    trailing 秒/s, a range tail.
+
+    A full-width colon ("00：95") is read as ":", minute/second words ("3分20秒", "1.5分")
+    are rewritten as seconds, an ordinal unit ("第3分钟") as the start of that unit."""
+    text = str(value or "").strip().replace("：", ":")
+    text = _APPROX_WORD_RE.sub("", _APPROX_RE.sub("", text))
+    text = _ORDINAL_UNIT_RE.sub(_ordinal_unit, text)
+    text = _ORDINAL_RE.sub("", text)
+    text = _CN_TIME_RE.sub(_cn_time, text)
+    match = _RANGE_RE.match(text)
+    if match:
+        text = match.group(1)
+    return _UNIT_RE.sub("", text).strip()
+
+
+def parse_plot_time(value):
+    """Seconds for "MM:SS" / "H:MM:SS" / a bare number, or None when unreadable.
+
+    Fields are not range-checked: "00:95" is 95 s, "1:75" is 135 s (the model wrote scene
+    seconds into the seconds field). "约01:20", "01:20左右", "12.5秒", "00：95", "3分20秒",
+    "1.5分", an ordinal unit ("第3分钟" is the third minute, read as its start 02:00; "第1分钟"
+    and "第0分钟" are 00:00; "第95秒" is 94 s; "第2小时" is 1:00:00) and the start of a range
+    ("01:20-01:45") are read too.
+    Negative or non-finite values are unreadable."""
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        seconds = float(value)
+    else:
+        text = _plot_time_text(value)
+        match = _TIME_RE.match(text)
+        if match:
+            hours, minutes, secs = match.groups()
+            seconds = int(hours or 0) * 3600 + int(minutes) * 60 + float(secs)
+        else:
+            try:
+                seconds = float(text)
+            except ValueError:
+                return None
+    if seconds != seconds or seconds in (float("inf"), float("-inf")) or seconds < 0:
+        return None
+    return seconds
+
+
+def format_plot_time(seconds):
+    whole = int(seconds)
+    hours, rest = divmod(whole, 3600)
+    minutes, secs = divmod(rest, 60)
+    return f"{hours}:{minutes:02d}:{secs:02d}" if hours else f"{minutes:02d}:{secs:02d}"
+
+
+def normalize_plot_times(plot_points, duration=None):
+    """Rewrite each object plot point's `time` as canonical text; drop unusable times.
+
+    Returns (plot_points, dropped_count). Bare-string plot points pass through unchanged."""
+    out = []
+    dropped = 0
+    for point in plot_points or []:
+        if not isinstance(point, dict) or "time" not in point:
+            out.append(point)
+            continue
+        point = dict(point)
+        seconds = parse_plot_time(point["time"])
+        if seconds is None or (
+            duration is not None and seconds > duration + _DURATION_SLACK_SECONDS
+        ):
+            point.pop("time")
+            dropped += 1
+        else:
+            point["time"] = format_plot_time(seconds)
+        out.append(point)
+    return out, dropped
+
+
+def _term_key(value):
+    return " ".join(str(value or "").split()).casefold()
+
+
+def _aliases(character):
+    """`aliases` as a list; a bare string is one alias, not a sequence of characters."""
+    value = character.get("aliases")
+    if value is None or value == "":
+        return []
+    if isinstance(value, (list, tuple)):
+        return list(value)
+    return [value]
+
+
+def _alias_keys(character):
+    return {key for key in (_term_key(alias) for alias in _aliases(character)) if key}
+
+
+def _stable_union(*lists):
+    seen = set()
+    out = []
+    for values in lists:
+        for value in values or []:
+            key = json.dumps(value, ensure_ascii=False, sort_keys=True)
+            if key not in seen:
+                seen.add(key)
+                out.append(value)
+    return out
+
+
+def _merge_into(target, other):
+    other_name = str(other.get("name", "")).strip()
+    aliases = _aliases(other)
+    if other_name and _term_key(other_name) != _term_key(target.get("name")):
+        aliases = [other_name] + aliases
+    for field in _LIST_FIELDS:
+        if field == "aliases":
+            target[field] = _stable_union(_aliases(target), aliases)
+        else:
+            target[field] = _stable_union(target.get(field), other.get(field))
+    target["aliases"] = [
+        alias for alias in target["aliases"]
+        if _term_key(alias) != _term_key(target.get("name"))
+    ]
+    for field in ("description", "research_role"):
+        if not str(target.get(field) or "").strip() and str(other.get(field) or "").strip():
+            target[field] = other[field]
+    ranks = [
+        _CONFIDENCE_RANK.get(str(item.get("confidence")), 0) for item in (target, other)
+    ]
+    if ranks[1] > ranks[0]:
+        target["confidence"] = other["confidence"]
+
+
+def _character_nodes(characters):
+    """Pool dict entries by name key: entries with the same name are one character.
+
+    Returns nodes as {"members": [input positions], "name": key, "aliases": alias keys}; an
+    entry without a name is a node of its own."""
+    nodes = []
+    by_name = {}
+    for position, item in enumerate(characters):
+        if not isinstance(item, dict):
+            continue
+        name = _term_key(item.get("name"))
+        aliases = _alias_keys(item)
+        if name and name in by_name:
+            node = nodes[by_name[name]]
+            node["members"].append(position)
+            node["aliases"] |= aliases
+            continue
+        if name:
+            by_name[name] = len(nodes)
+        nodes.append({"members": [position], "name": name, "aliases": set(aliases)})
+    return nodes
+
+
+def _linked(x, y):
+    """True when one node's name is the other's alias. Two aliases alone never link: a
+    generic alias the model hands two people (男子, 老板) must not fold them into one."""
+    return bool(
+        (x["name"] and x["name"] in y["aliases"]) or (y["name"] and y["name"] in x["aliases"])
+    )
+
+
+def _character_groups(nodes):
+    """Partition nodes into characters, independent of their order.
+
+    A node whose linked neighbours include two nodes not linked to each other is a bridge
+    (a 男子 extra named by an alias two leads share, or one entry carrying two people's
+    names): it stays on its own and links nothing. The other nodes are unioned along their
+    links. Returns groups as sorted member-position lists, ordered by first occurrence."""
+    count = len(nodes)
+    links = [
+        [j for j in range(count) if j != i and _linked(nodes[i], nodes[j])]
+        for i in range(count)
+    ]
+    bridge = [
+        any(
+            not _linked(nodes[j], nodes[k])
+            for a, j in enumerate(neighbours)
+            for k in neighbours[a + 1:]
+        )
+        for neighbours in links
+    ]
+    parent = list(range(count))
+
+    def root(i):
+        while parent[i] != i:
+            parent[i] = parent[parent[i]]
+            i = parent[i]
+        return i
+
+    for i in range(count):
+        if bridge[i]:
+            continue
+        for j in links[i]:
+            if not bridge[j]:
+                parent[root(i)] = root(j)
+    members = {}
+    for i, node in enumerate(nodes):
+        members.setdefault(root(i), []).extend(node["members"])
+    return sorted((sorted(group) for group in members.values()), key=lambda group: group[0])
+
+def merge_characters(characters):
+    """Merge character entries that are the same person by name (case/space-insensitive).
+
+    Entries with the same name are one character. Two characters merge when one's name is
+    the other's alias; a shared alias alone does not merge, and an entry that links two
+    characters not linked to each other is kept on its own instead of folding them together.
+    The partition does not depend on input order: each merged character sits at its first
+    entry's position and keeps the name of its first entry that has one, the others' names
+    become aliases. Returns (characters, renames) where renames maps every merged name key
+    to the surviving name. Non-dict entries pass through."""
+    characters = list(characters or [])
+    groups = _character_groups(_character_nodes(characters))
+    first_of = {group[0]: group for group in groups}
+    merged = []
+    renames = {}
+    for position, item in enumerate(characters):
+        if not isinstance(item, dict):
+            merged.append(item)
+            continue
+        group = first_of.get(position)
+        if group is None:
+            continue  # folded into an earlier entry
+        entry = dict(item)
+        if not _term_key(entry.get("name")):
+            # A nameless first entry keeps its position but takes the first member name.
+            named = next(
+                (characters[m] for m in group if _term_key(characters[m].get("name"))), None
+            )
+            if named is not None:
+                entry = {"name": named["name"], **{k: v for k, v in entry.items() if k != "name"}}
+        for other in group[1:]:
+            _merge_into(entry, characters[other])
+            name = _term_key(characters[other].get("name"))
+            if name:
+                renames[name] = entry.get("name")
+        merged.append(entry)
+    return merged, renames
+
+
+def repoint_relationships(relationships, renames):
+    """Point relationships at surviving character names; drop self-loops and duplicates."""
+    out = []
+    by_key = {}
+    for rel in relationships or []:
+        if not isinstance(rel, dict):
+            out.append(rel)
+            continue
+        rel = dict(rel)
+        renamed = False
+        for side in ("a", "b"):
+            key = _term_key(rel.get(side))
+            if key in renames:
+                rel[side] = renames[key]
+                renamed = True
+        if renamed and _term_key(rel.get("a")) == _term_key(rel.get("b")):
+            continue  # "X — 同一人 — X" left over from the split entries
+        key = (_term_key(rel.get("a")), _term_key(rel.get("b")), _term_key(rel.get("relation")))
+        if key in by_key:
+            existing = by_key[key]
+            existing["evidence_ids"] = _stable_union(
+                existing.get("evidence_ids"), rel.get("evidence_ids")
+            )
+            continue
+        by_key[key] = rel
+        out.append(rel)
+    return out
+
+
+def scenes_end(scenes):
+    """Latest scene end (source seconds), or None when no scene carries a usable end."""
+    ends = []
+    for scene in scenes or []:
+        try:
+            ends.append(float(scene["end"]))
+        except (KeyError, TypeError, ValueError):
+            continue
+    return max(ends) if ends else None
+
+
+def coerce_character_aliases(characters):
+    """Rewrite a non-list `aliases` on each character as a list (a string is one alias)."""
+    return [
+        dict(item, aliases=_aliases(item))
+        if isinstance(item, dict) and "aliases" in item and not isinstance(item["aliases"], list)
+        else item
+        for item in characters or []
+    ]
+
+
+def normalize_index(index, duration=None):
+    """Apply both repairs to a parsed index; returns (index, report)."""
+    index = dict(index)
+    before = len(index.get("characters") or [])
+    characters, renames = merge_characters(coerce_character_aliases(index.get("characters")))
+    renames = {
+        key: name for key, name in renames.items() if key != _term_key(name)
+    }
+    index["characters"] = characters
+    index["relationships"] = repoint_relationships(index.get("relationships"), renames)
+    index["plot_points"], dropped = normalize_plot_times(index.get("plot_points"), duration)
+    return index, {
+        "merged_characters": before - len(characters),
+        "dropped_plot_times": dropped,
+    }