566 lines
22 KiB
Python
566 lines
22 KiB
Python
"""Role-aware, bounded excerpt selection and presentation from actual evidence."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
from tools.answers.context_policy import normalized
|
|
from tools.answers.question_intent import (
|
|
FACET_LABELS,
|
|
planned_experiments,
|
|
requested_facets,
|
|
actual_methods_requested,
|
|
)
|
|
|
|
COMPLETED = (
|
|
r"\b(?:(?:implementovan|natrenovan|vytvoren|extrahovan|vykonan|vyhodnoten|nameran|"
|
|
r"vyriesen|odstranen|otestovan|porovnan|dosiahnut|dokoncen)(?:y|a|e|u|ou|ych|ym|ymi|om)|"
|
|
r"urobene vyhodnotenie|implementoval\w*|natrenoval\w*|vyhodnotil\w*|funguje|funguju)\b"
|
|
)
|
|
PLANNED = r"\b(?:bude|budu|planuj\w*|planovan\w*|cielom|mal by|ma sa|ma (?:implementovat|vypracovat|vyhodnotit|vytvorit|navrhnut|natrenovat|otestovat)|treba|pripravte|navrhnite|otestujte|vyhodnotte)\b"
|
|
ADMIN = r"\b(?:konzultac\w*|struktura prace|pisomn\w*|pisat|odovzda\w*\s+(?:text\w*|pisomn\w*|prac\w*)|wip|termin\w*)\b"
|
|
NOT_COMPLETED = r"\b(?:nie je|nie su|nebol\w*|este nie|zatial nie|nebude|nebudu|nefung\w*|neimplementov\w*|nevytvoren\w*|nevyhodnoten\w*)\b"
|
|
|
|
|
|
# Named tools in a record: acronyms (RAG, MCP), CamelCase (OpenWebUI, GraphRAG), names with digits
|
|
# (Neo4J, Fast120, me5mini), domains, and common lower-case tool names.
|
|
TOOL_NAMES = set("""python pytorch tensorflow keras docker kubernetes unsloth llamafactory qlora lora optuna whisper
|
|
bert slovakbert mistral llama qwen olmo gemma huggingface transformers spacy stanza prodigy rasa langchain llamaindex
|
|
elasticsearch opensearch neo4j cypher postgres postgresql sqlite mysql mongodb redis fastapi flask django react vue
|
|
angular nodejs javascript typescript java kotlin matlab opencv yolo onnx ollama openwebui telegram discord grafana
|
|
prometheus jupyter colab git gitea github gitlab slurm faiss qdrant chroma milvus pandas numpy scikit sklearn skills
|
|
skill streamlit gradio langgraph cogdb""".split())
|
|
TOOL_PATTERN = re.compile(r"(?<![\w.])(?:[A-Z][A-Za-z]*[A-Z][A-Za-z]*|[A-Za-z]+\d[\w.]*|\d+[A-Za-z][\w]*|[a-z0-9-]+\.[a-z]{2,4})(?![\w])")
|
|
SEARCH_METHODS = r"\b(?:vektorov\w* vyhladav\w*|textov\w* vyhladav\w*|vyhladavani\w*|dotrenov\w*|fine.?tun\w*|embedding\w*|grafov\w* databaz\w*|znalostn\w* graf\w*)\b"
|
|
|
|
|
|
def named_tools(text: str) -> list[str]:
|
|
"""Tool and technology names the record mentions (not dates, not plain words)."""
|
|
found = [m for m in TOOL_PATTERN.findall(text or "") if not re.fullmatch(r"\d+[.:]\d*", m) and len(m) >= 2]
|
|
found += [w for w in re.findall(r"[A-Za-z][A-Za-z0-9]+", text or "") if w.lower() in TOOL_NAMES]
|
|
return list(dict.fromkeys(found))
|
|
|
|
|
|
def has_qualification(text: str) -> bool:
|
|
return bool(
|
|
re.search(
|
|
r"\b(?:iba|len|avsak|ale|zatial|podmien\w*|obmedzen\w*|nebol\w*|nie|nepotvrd\w*)\b",
|
|
normalized(text),
|
|
)
|
|
)
|
|
|
|
|
|
def administrative_only(text: str) -> bool:
|
|
n = normalized(text)
|
|
return bool(re.search(ADMIN, n) and not re.search(COMPLETED, n))
|
|
|
|
|
|
def reference_only(text: str) -> bool:
|
|
"""A link alone establishes a reference, never an implemented result."""
|
|
value = re.sub(r"^\s*(?:[-*+]|\d+[.)])\s+", "", text).strip()
|
|
if re.fullmatch(r"\[[^]]+\]\([^\s]+\)", value):
|
|
return True
|
|
from tools.answers.context_policy import text_urls
|
|
|
|
links = text_urls(value)
|
|
if not links:
|
|
return False
|
|
for url in links:
|
|
value = value.replace(url, "")
|
|
return bool(
|
|
re.fullmatch(
|
|
r"(?:repozitar(?: s \w+(?: \w+)?)?|zdrojove kody|vystup je tu|vystupy su tu|odkaz|git)?",
|
|
normalized(value),
|
|
)
|
|
)
|
|
|
|
|
|
def split_units(text: str) -> list[str]:
|
|
from tools.answers.rag_evidence import descriptive_text
|
|
|
|
parts = re.split(r"\n\s*\n|(?=^[ \t]*(?:\d+[.)]|[-+*])\s+)", text, flags=re.M)
|
|
units = []
|
|
for part in parts:
|
|
part = part.strip()
|
|
if not descriptive_text(part):
|
|
continue
|
|
# A source paragraph is kept literal, including its negations and qualifications.
|
|
for unit in (
|
|
[part]
|
|
if len(part) <= 900 or has_qualification(part)
|
|
else re.split(r"(?<=[.!?])\s+(?=[A-ZÁČĎÉÍĽŇÓŠŤÚÝŽ])", part)
|
|
):
|
|
if descriptive_text(unit):
|
|
units.append(unit.strip())
|
|
return units
|
|
|
|
|
|
def effective_role(text: str, role: str) -> str:
|
|
n = normalized(re.sub(r"^\s*(?:\d+[.)]|[-+*])\s+", "", text))
|
|
if role in {"other", "progress"}:
|
|
from tools.answers.presentation import GOAL_VERBS
|
|
|
|
first = n.split()[0] if n else ""
|
|
if (
|
|
first in {normalized(word) for word in [*GOAL_VERBS, *GOAL_VERBS.values()]}
|
|
or n.startswith("cielom je")
|
|
or re.search(PLANNED, n)
|
|
):
|
|
return "task"
|
|
if role == "other" and re.search(COMPLETED, n) and not re.search(PLANNED, n):
|
|
return "progress"
|
|
return role
|
|
|
|
|
|
def evidence_phase(text: str, role: str, source_phase: str = "unknown") -> str:
|
|
if reference_only(text):
|
|
return "unknown"
|
|
if role == "assignment":
|
|
return "assignment"
|
|
if role == "task":
|
|
return "planned"
|
|
if re.search(PLANNED, normalized(text)):
|
|
return "planned"
|
|
if administrative_only(text):
|
|
return "administrative"
|
|
if role == "progress":
|
|
n = normalized(text)
|
|
negative_finding = re.search(r"\b(?:nebol uspesny|nebola uspesna|neboli uspesne|neprekonal\w*|nezlepsil\w*)\b",n)
|
|
if negative_finding and re.search(r"\b(?:test\w*|meran\w*|experiment\w*|vyhodnot\w*)\b",n):
|
|
return "result"
|
|
if re.search(NOT_COMPLETED, n):
|
|
return "progress"
|
|
if source_phase == "result" or (
|
|
not re.search(NOT_COMPLETED, normalized(text))
|
|
and re.search(COMPLETED, normalized(text))
|
|
):
|
|
return "result"
|
|
return "progress"
|
|
return "unknown"
|
|
|
|
|
|
def facets_for(text: str, role: str, question: str, phase: str | None = None) -> list[str]:
|
|
if reference_only(text):
|
|
return []
|
|
n = normalized(text)
|
|
facets = []
|
|
if role == "assignment":
|
|
facets.append("assignment")
|
|
if role == "task":
|
|
facets.append("plans")
|
|
if role == "progress" and not re.search(PLANNED, n) and not administrative_only(text):
|
|
facets.append("progress")
|
|
if (phase or evidence_phase(text, role)) == "result":
|
|
facets.append("results")
|
|
if re.search(
|
|
r"\b(?:problem\w*|tazkost\w*|tazke|prekazk\w*|chyb\w*|zlyha\w*|nepodar\w*|nevyries\w*|nefung\w*|nepasuj\w*|nesulad\w*|nekompatibil\w*)\b", n
|
|
) and role not in {"assignment", "task"}:
|
|
facets.append("problems")
|
|
tools = named_tools(text)
|
|
if re.search(
|
|
r"\b(?:metod\w*|technolog\w*|nastroj\w*|pouzi\w*|vyuziv\w*|pomocou|implementovan\w*|natrenovan\w* model\w*|indexov\w*|databaz\w*|webov\w* rozhrani\w*|frontend\w*|backend\w*|vyskus\w*|sumarizac\w*)\b",
|
|
n,
|
|
) or tools or re.search(SEARCH_METHODS, n):
|
|
actual_use = actual_methods_requested(question)
|
|
# A status/result record naming a tool ("Sú Skills aj MCP server", "začíname pracovať na
|
|
# GraphRAG a Neo4J") states real use unless it is phrased as a plan or as not done.
|
|
stated_in_status = (role in {"progress", "result"} and bool(tools or re.search(SEARCH_METHODS, n))
|
|
and not re.search(PLANNED, n))
|
|
actual_statement = not re.search(NOT_COMPLETED, n) and (
|
|
re.search(COMPLETED, n) or re.search(r'\bvyskus(?:any|ana|ane|al|ala|ali)\b',n)
|
|
or re.search(r"\b(?:pouziva\w*|pouzil\w*|vyuziva\w*|vyuzil\w*|vieme indexov\w*)\b", n)
|
|
or (not re.search(PLANNED,n) and re.search(r'\b(?:frontend|backend)\s+\w+',n))
|
|
or stated_in_status
|
|
)
|
|
if not actual_use or (role not in {"assignment", "task"} and actual_statement):
|
|
facets.append("methods")
|
|
if re.search(
|
|
r"\b(?:experiment\w*|meran\w*|test\w*|otest\w*|vyhodnot\w*|benchmark\w*|f1|presnost\w*)\b",
|
|
n,
|
|
):
|
|
wants_done = re.search(
|
|
r"\b(?:vykonal\w*|vykonan\w*|otestoval\w*|uskutocnil\w*|uskutocnen\w*|realizovan\w*|vyhodnotil\w*)\b",
|
|
normalized(question),
|
|
)
|
|
if wants_done and role in {"assignment", "task"}:
|
|
pass
|
|
elif (
|
|
not planned_experiments(question)
|
|
or role in {"assignment", "task"}
|
|
or re.search(PLANNED, n)
|
|
):
|
|
facets.append("experiments")
|
|
return facets
|
|
|
|
|
|
def unit_score(text: str, role: str, facet: str = "") -> int:
|
|
n = normalized(text)
|
|
score = 25 if role == "progress" else 10
|
|
if re.search(COMPLETED, n):
|
|
score += 45
|
|
if re.search(
|
|
r"\b(?:model|system|algoritm\w*|vyhodnot\w*|experiment\w*|presnost\w*|pagerank|bert)\b", n
|
|
):
|
|
score += 15
|
|
if administrative_only(text):
|
|
score -= 70
|
|
if facet == "problems" and re.search(r"\b(?:problem\w*|chyb\w*|zlyha\w*)\b", n):
|
|
score += 35
|
|
if role in {"assignment", "task"} and facet == "results":
|
|
score -= 100
|
|
return score
|
|
|
|
|
|
def prioritize_frames(frames: list[str], question: str) -> list[str]:
|
|
"""Order whole source windows before budgeting; do not rewrite their text."""
|
|
from tools.answers.rag_evidence import content_sections, TITLE_LABELS
|
|
|
|
rankings = []
|
|
for facet in requested_facets(question):
|
|
scores = []
|
|
for index, frame in enumerate(frames):
|
|
relevant = []
|
|
for section in content_sections(frame):
|
|
for text in split_units(section["text"]):
|
|
role = effective_role(text, section["kind"])
|
|
phase = evidence_phase(text, role, section.get("phase", "unknown"))
|
|
if len(text) <= 2500 and facet in facets_for(text, role, question, phase):
|
|
relevant.append(unit_score(text, role, facet))
|
|
if relevant:
|
|
scores.append((index, max(relevant)))
|
|
rankings.append([i for i, _ in sorted(scores, key=lambda item: -item[1])])
|
|
order = []
|
|
if re.search(r"\bnaz(?:ov|v)\w*\b", normalized(question)) and frames:
|
|
order = [
|
|
i
|
|
for i, frame in enumerate(frames)
|
|
if any(
|
|
":" in line and normalized(line.split(":", 1)[0]) in TITLE_LABELS
|
|
for line in frame.splitlines()
|
|
)
|
|
] or [0]
|
|
seen = set(order)
|
|
for pos in range(max(map(len, rankings), default=0)):
|
|
for ranking in rankings:
|
|
if pos < len(ranking) and ranking[pos] not in seen:
|
|
seen.add(ranking[pos])
|
|
order.append(ranking[pos])
|
|
return [frames[i] for i in [*order, *(i for i in range(len(frames)) if i not in seen)]]
|
|
|
|
|
|
def evidence_units(context: dict, quotes: list[dict] | None = None) -> list[dict]:
|
|
from tools.answers.rag_evidence import content_sections, quote_sections, quote_matches_passage
|
|
|
|
rows = []
|
|
for passage in context.get("content_passages", []):
|
|
pieces = (
|
|
content_sections(passage["text"])
|
|
if quotes is None
|
|
else [
|
|
piece
|
|
for quote in quotes
|
|
if quote_matches_passage(quote, passage)
|
|
for piece in quote_sections(quote, {"content_passages": [passage]})
|
|
]
|
|
)
|
|
for piece in pieces:
|
|
for unit in split_units(piece["text"]):
|
|
role = effective_role(unit, piece["kind"])
|
|
phase = evidence_phase(unit, role, piece.get("phase", "unknown"))
|
|
rows.append(
|
|
{
|
|
k: passage.get(k)
|
|
for k in [
|
|
"person",
|
|
"work_type",
|
|
"year",
|
|
"work_label",
|
|
"source_id",
|
|
"passage_id",
|
|
]
|
|
}
|
|
| {
|
|
"text": unit,
|
|
"kind": role,
|
|
"phase": phase,
|
|
"facets": facets_for(unit, role, context.get("question", ""), phase),
|
|
}
|
|
)
|
|
# Overlapping chunks/quotes can repeat the same fact with different roles.
|
|
# An explicit role wins over an unlabelled duplicate, within the same work.
|
|
unique = {}
|
|
for row in rows:
|
|
clean = re.sub(r"^\s*(?:\d+[.)]|[-+*])\s+", "", row["text"])
|
|
key = tuple(row.get(k) for k in ["person", "work_type", "year"]) + (
|
|
normalized(row.get("work_label")),
|
|
row["phase"],
|
|
" ".join(clean.split()),
|
|
)
|
|
old = unique.get(key)
|
|
if old is None or (old["kind"] == "other" and row["kind"] != "other"):
|
|
unique[key] = row
|
|
units = list(unique.values())
|
|
|
|
# Prefer a whole longer excerpt over its overlapping prefix, within one
|
|
# work and phase. Never merge people, years or plans with recorded results.
|
|
def plain(row):
|
|
return " ".join(re.sub(r"^\s*(?:\d+[.)]|[-+*])\s+", "", row["text"]).split())
|
|
|
|
return [
|
|
row
|
|
for row in units
|
|
if not any(
|
|
all(row.get(k) == other.get(k) for k in ["person", "work_type", "year", "phase"])
|
|
and normalized(row.get("work_label")) == normalized(other.get("work_label"))
|
|
and len(plain(row)) < len(plain(other))
|
|
and " " + plain(row) + " " in " " + plain(other) + " "
|
|
for other in units
|
|
)
|
|
]
|
|
|
|
|
|
def scope_groups(context: dict) -> list[tuple]:
|
|
req = context.get("requirements", {})
|
|
groups = []
|
|
for person in req.get("people", []):
|
|
labels = list(
|
|
dict.fromkeys(
|
|
s.get("work_label")
|
|
for s in context.get("work_scopes", [])
|
|
if s.get("person") == person
|
|
)
|
|
)
|
|
(
|
|
groups.extend((person, label) for label in labels)
|
|
if req.get("separate_works") and labels
|
|
else groups.append((person, None))
|
|
)
|
|
return groups
|
|
|
|
|
|
def matches_scope(row: dict, person: str, label: str | None) -> bool:
|
|
return row.get("person") == person and (
|
|
label is None or normalized(row.get("work_label")) == normalized(label)
|
|
)
|
|
|
|
|
|
def scope_context(context: dict, person: str, label: str | None) -> dict:
|
|
return {
|
|
**context,
|
|
"content_passages": [
|
|
p for p in context.get("content_passages", []) if matches_scope(p, person, label)
|
|
],
|
|
}
|
|
|
|
|
|
def candidates(context: dict) -> list[dict]:
|
|
from tools.answers.evidence_selection import identify
|
|
|
|
facets = context["requirements"].get("facets", [])
|
|
selected = []
|
|
seen = set()
|
|
units = evidence_units(context)
|
|
for person, label in scope_groups(context):
|
|
for facet in facets:
|
|
relevant = [
|
|
u for u in units if matches_scope(u, person, label) and facet in u["facets"]
|
|
]
|
|
if (
|
|
facet == "progress"
|
|
and "results" in facets
|
|
and any(u["phase"] == "progress" for u in relevant)
|
|
):
|
|
relevant = [u for u in relevant if u["phase"] == "progress"]
|
|
if facet != "assignment":
|
|
relevant.sort(key=lambda u: -unit_score(u["text"], u["kind"], facet))
|
|
accepted = 0
|
|
for unit in relevant:
|
|
text = unit["text"]
|
|
if len(text) > 2500:
|
|
context["complete"] = False
|
|
context["truncated"] = True
|
|
context["truncation_reasons"] = list(
|
|
dict.fromkeys(
|
|
[*(context.get("truncation_reasons") or []), "evidence_unit_limit"]
|
|
)
|
|
)
|
|
continue
|
|
key = (unit.get("passage_id"), unit["source_id"], text, unit["phase"])
|
|
if key not in seen:
|
|
seen.add(key)
|
|
selected.append(
|
|
identify(
|
|
{**unit, "text": text},
|
|
required=unit["kind"] == "assignment" and "assignment" in facets,
|
|
)
|
|
)
|
|
accepted += 1
|
|
if accepted == 2 and facet != "assignment":
|
|
break
|
|
return selected
|
|
|
|
|
|
def missing_facets(answer: dict, context: dict) -> list[tuple[str, str]]:
|
|
return list(
|
|
dict.fromkeys(
|
|
(person, facet) for person, _label, facet in missing_work_facets(answer, context)
|
|
)
|
|
)
|
|
|
|
|
|
def missing_work_facets(answer: dict, context: dict) -> list[tuple]:
|
|
found = evidence_units(context, answer.get("evidence_quotes", []))
|
|
return [
|
|
(person, label, facet)
|
|
for person, label in scope_groups(context)
|
|
for facet in context["requirements"].get("facets", [])
|
|
if not any(matches_scope(row, person, label) and facet in row["facets"] for row in found)
|
|
]
|
|
|
|
|
|
def fit_candidates(sent: dict, context: dict, limit: int, encoding: str) -> None:
|
|
"""Budget the actual candidate JSON, sharing space across named people."""
|
|
import json
|
|
from tools.rag.build_chunks import TokenCounter
|
|
|
|
counter = TokenCounter(encoding)
|
|
if counter.encoding is None:
|
|
raise RuntimeError("Missing context tokenizer")
|
|
original = list(context.get("content_candidates", []))
|
|
groups = [
|
|
[row for row in original if matches_scope(row, person, label)]
|
|
for person, label in scope_groups(context)
|
|
]
|
|
ordered = [
|
|
group[i]
|
|
for i in range(max(map(len, groups), default=0))
|
|
for group in groups
|
|
if i < len(group)
|
|
]
|
|
selected = []
|
|
for row in ordered:
|
|
if (
|
|
counter.count(
|
|
json.dumps({**sent, "content_candidates": [*selected, row]}, ensure_ascii=False)
|
|
)
|
|
<= limit
|
|
):
|
|
selected.append(row)
|
|
if len(selected) != len(original):
|
|
context["complete"] = False
|
|
context["truncated"] = True
|
|
context["truncation_reasons"] = list(
|
|
dict.fromkeys([*(context.get("truncation_reasons") or []), "answer_candidate_budget"])
|
|
)
|
|
sent.update({key: context[key] for key in ["complete", "truncated", "truncation_reasons"]})
|
|
context["content_candidates"] = selected
|
|
sent["content_candidates"] = selected
|
|
# Account for the added limitation metadata as well.
|
|
while selected and counter.count(json.dumps(sent, ensure_ascii=False)) > limit:
|
|
selected.pop()
|
|
if counter.count(json.dumps(sent, ensure_ascii=False)) > limit:
|
|
raise ValueError("Mandatory answer metadata exceeds context budget")
|
|
|
|
|
|
def facet_lines(answer: dict, context: dict) -> list[str]:
|
|
from tools.answers.presentation import (
|
|
goal_text,
|
|
evidence_subject,
|
|
missing_aspects,
|
|
comparison_table,
|
|
)
|
|
|
|
req = context["requirements"]
|
|
units = evidence_units(context, answer.get("evidence_quotes", []))
|
|
facets = req.get("facets", [])
|
|
groups = []
|
|
labels = {f: FACET_LABELS[f] for f in facets}
|
|
if "experiments" in facets and planned_experiments(context.get("question", "")):
|
|
labels["experiments"] = "Plánované experimenty a vyhodnotenie"
|
|
for person, work_label in scope_groups(context):
|
|
group = {
|
|
"subject": (
|
|
evidence_subject(person, scope_context(context, person, work_label))
|
|
if work_label is None
|
|
else person + " — " + " ".join(work_label.split())
|
|
),
|
|
"items": {},
|
|
"missing": [],
|
|
}
|
|
seen = set()
|
|
for facet in facets:
|
|
rows = [
|
|
u for u in units if matches_scope(u, person, work_label) and facet in u["facets"]
|
|
]
|
|
if (
|
|
facet == "progress"
|
|
and "results" in facets
|
|
and any(u["phase"] == "progress" for u in rows)
|
|
):
|
|
rows = [u for u in rows if u["phase"] == "progress"]
|
|
if facet != "assignment":
|
|
rows.sort(key=lambda u: -unit_score(u["text"], u["kind"], facet))
|
|
if not rows:
|
|
group["missing"].append(facet)
|
|
rendered = []
|
|
for row in rows:
|
|
key = (
|
|
" ".join(re.sub(r"^\s*(?:\d+[.)]|[-+*])\s+", "", row["text"]).split()),
|
|
row["phase"],
|
|
)
|
|
if key in seen:
|
|
continue
|
|
text = row["text"]
|
|
if row["kind"] in {"assignment", "task"}:
|
|
text, _ = goal_text(text)
|
|
text = re.sub(r"^\s*(?:\d+[.)]|[-+*])\s+", "", text)
|
|
phase = (
|
|
" (plán)"
|
|
if row["kind"] in {"assignment", "task"}
|
|
and facet not in {"assignment", "plans"}
|
|
else ""
|
|
)
|
|
state = (
|
|
"Zaznamenaný výsledok: "
|
|
if row["phase"] == "result" and "results" in facets and facet != "results"
|
|
else ""
|
|
)
|
|
rendered.append(state + text + phase)
|
|
seen.add(key)
|
|
if len(rendered) == 2 and facet != "assignment":
|
|
break
|
|
group["items"][facet] = rendered
|
|
groups.append(group)
|
|
if len(groups) > 1 and re.search(r"\bporovnaj\w*\b", normalized(context.get("question", ""))):
|
|
rows = []
|
|
for facet in facets:
|
|
if not any(g["items"][facet] for g in groups):
|
|
if all(facet not in g["missing"] for g in groups):
|
|
continue
|
|
values = [
|
|
"\n".join(g["items"][facet])
|
|
or ("V podkladoch chýbajú údaje." if facet in g["missing"] else "Doložené vyššie.")
|
|
for g in groups
|
|
]
|
|
rows.append((labels[facet], values))
|
|
if any(any(g["items"][f] for f in facets) for g in groups):
|
|
table = comparison_table(["Oblasť", *(g["subject"] for g in groups)], rows)
|
|
if table is not None:
|
|
return table
|
|
lines = []
|
|
for group in groups:
|
|
title = group["subject"]
|
|
if len(facets) == 1 and group["items"][facets[0]]:
|
|
title += " — " + labels[facets[0]].lower()
|
|
lines.extend(["**" + title + "**", ""])
|
|
for facet in facets:
|
|
items = group["items"][facet]
|
|
if not items:
|
|
continue
|
|
if len(facets) > 1:
|
|
lines.append("**" + labels[facet] + ":**")
|
|
lines.extend("- " + text for text in items)
|
|
lines.append("")
|
|
if group["missing"]:
|
|
lines.extend([missing_aspects(group["missing"], context.get("question", "")), ""])
|
|
return lines
|