src2sink 1.0.0__py3-none-any.whl

src2sink/aggregators/pii_flow_v2.py

@@ -0,0 +1,118 @@
+"""v2 PII flow roll-up (replaces v1 graphs/pii-flow.md)."""
+
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from ..graph_common import iter_nodes, load_v2_repo_records
+from ..renderers.markdown import md_table
+from ..sanitize import UNTRUSTED_CONTENT_NOTICE
+
+MAX_MD_ROWS = 200
+
+
+@dataclass
+class _PiiFlowCounts:
+    """Aggregated PII/HTTP/queue touchpoint counters across all repos."""
+
+    by_class: Counter[str] = field(default_factory=Counter)
+    by_repo: Counter[str] = field(default_factory=Counter)
+    field_counts: Counter[str] = field(default_factory=Counter)
+    sensitive_by_repo: Counter[str] = field(default_factory=Counter)
+    http_in_by_repo: Counter[str] = field(default_factory=Counter)
+    http_out_by_repo: Counter[str] = field(default_factory=Counter)
+    queue_by_repo: Counter[str] = field(default_factory=Counter)
+
+
+def _collect_pii_flow(records: list[dict[str, Any]]) -> _PiiFlowCounts:
+    """Tally PII, HTTP, and queue nodes per classification and per repo."""
+    c = _PiiFlowCounts()
+    for data in records:
+        rid = f"{data['group']}/{data['name']}"
+        for node in iter_nodes(data):
+            family = node.get("family")
+            if family in ("pii-field", "pii-log", "pii-storage"):
+                cls = node.get("pii_classification") or "unknown"
+                c.by_class[cls] += 1
+                c.by_repo[rid] += 1
+                field_name = (node.get("detail") or {}).get("field_name")
+                if field_name:
+                    c.field_counts[field_name.lower()] += 1
+                if cls in ("sensitive", "special-category-gdpr"):
+                    c.sensitive_by_repo[rid] += 1
+            elif family == "http-in":
+                c.http_in_by_repo[rid] += 1
+            elif family == "http-out":
+                c.http_out_by_repo[rid] += 1
+            elif family in ("queue-in", "queue-out"):
+                c.queue_by_repo[rid] += 1
+    return c
+
+
+def write_pii_flow_v2(metabase_root: Path, repo_jsons: list[Path]) -> None:
+    """Write the v2 PII flow roll-up markdown (graphs/pii-flow.md)."""
+    records = load_v2_repo_records(metabase_root, json_paths=repo_jsons)
+    c = _collect_pii_flow(records)
+    by_class = c.by_class
+    by_repo = c.by_repo
+    field_counts = c.field_counts
+    sensitive_by_repo = c.sensitive_by_repo
+    http_in_by_repo = c.http_in_by_repo
+    http_out_by_repo = c.http_out_by_repo
+    queue_by_repo = c.queue_by_repo
+
+    graphs_dir = metabase_root / "graphs"
+    graphs_dir.mkdir(parents=True, exist_ok=True)
+
+    md: list[str] = [
+        "# PII flow roll-up (v2)\n",
+        UNTRUSTED_CONTENT_NOTICE,
+        "_Aggregated from `pii-field`, `pii-log`, and `pii-storage` nodes. "
+        "For lifecycle stages see `pii-lifecycle.md`._\n",
+        "\n## By GDPR classification\n",
+        md_table(
+            ["Classification", "Touchpoints"],
+            [[k, str(v)] for k, v in by_class.most_common()],
+        ),
+        "\n## Top fields (all repos)\n",
+        md_table(
+            ["Field", "Count"],
+            [[k, str(v)] for k, v in field_counts.most_common(40)],
+        ),
+        "\n## Top repos by PII touchpoints\n",
+        md_table(
+            ["Repo", "Touchpoints"],
+            [[k, str(v)] for k, v in by_repo.most_common(MAX_MD_ROWS)],
+        ),
+    ]
+    tail = len(by_repo) - MAX_MD_ROWS
+    if tail > 0:
+        md.append(f"\n_{tail} more repos — see `taint/pii-sources.jsonl`._\n")
+
+    # Probable PII handlers: repos that have inbound HTTP endpoints AND
+    # reference at least one sensitive/special-category-gdpr PII node.
+    handlers = [
+        rid for rid in sensitive_by_repo
+        if http_in_by_repo.get(rid, 0) > 0
+    ]
+    handler_rows = sorted(
+        handlers,
+        key=lambda r: -sensitive_by_repo[r],
+    )
+    md.append(
+        "\n## Probable PII handlers\n"
+        "_Repos with inbound HTTP endpoints and `sensitive` or "
+        "`special-category-gdpr` PII nodes. Top candidates for PII & "
+        "data-minimisation review._\n"
+    )
+    md.append(md_table(
+        ["Repo", "HTTP-in", "HTTP-out", "Queue I/O", "Sensitive count"],
+        [[r, str(http_in_by_repo[r]), str(http_out_by_repo.get(r, 0)),
+          str(queue_by_repo.get(r, 0)), str(sensitive_by_repo[r])]
+         for r in handler_rows[:80]] or [["—", "—", "—", "—", "—"]],
+    ))
+
+    (graphs_dir / "pii-flow.md").write_text("\n".join(md), encoding="utf-8")

src2sink/aggregators/pii_lifecycle.py

@@ -0,0 +1,19 @@
+"""Fleet-wide PII lifecycle graph from v2 flow nodes (Phase 3)."""
+
+from __future__ import annotations
+
+from .pii_lifecycle_report import (
+    MAX_MD_ROWS,
+    aggregate_by_field,
+    write_pii_lifecycle_graph,
+)
+from .pii_touchpoint_collect import collect_pii_touchpoints
+from ..models.pii_lifecycle import PiiTouchpoint
+
+__all__ = [
+    "MAX_MD_ROWS",
+    "PiiTouchpoint",
+    "aggregate_by_field",
+    "collect_pii_touchpoints",
+    "write_pii_lifecycle_graph",
+]

src2sink/aggregators/pii_lifecycle_report.py

@@ -0,0 +1,121 @@
+"""Render PII lifecycle graph markdown and JSONL."""
+
+from __future__ import annotations
+
+import json
+from collections import Counter
+from pathlib import Path
+
+from ..graph_common import load_v2_repo_records
+from ..models.pii_lifecycle import LIFECYCLE_STAGES, FieldLifecycleAggregate, PiiTouchpoint
+from ..sanitize import UNTRUSTED_CONTENT_NOTICE
+from ..renderers.markdown import md_table
+
+from .pii_touchpoint_collect import collect_pii_touchpoints
+
+MAX_MD_ROWS = 400
+
+
+def aggregate_by_field(touches: list[PiiTouchpoint]) -> dict[str, FieldLifecycleAggregate]:
+    """Group touchpoints into per-(field, classification) lifecycle aggregates."""
+    buckets: dict[str, FieldLifecycleAggregate] = {}
+    for touch in touches:
+        bucket_key = f"{touch.field_key}|{touch.pii_classification}"
+        if bucket_key not in buckets:
+            buckets[bucket_key] = FieldLifecycleAggregate(
+                field_key=touch.field_key,
+                pii_classification=touch.pii_classification,
+            )
+        buckets[bucket_key].add(touch)
+    return buckets
+
+
+def _append_phone_example(
+    md: list[str],
+    aggregates: dict[str, FieldLifecycleAggregate],
+) -> None:
+    """Append a worked `phone` lifecycle example section to the markdown lines."""
+    phone_agg = [a for a in aggregates.values() if a.field_key == "phone"]
+    if not phone_agg:
+        return
+    md.append("\n## Worked example: `phone` (direct PII)\n")
+    for agg in sorted(phone_agg, key=lambda a: -a.touchpoints)[:3]:
+        md.append(f"\n### Classification: `{agg.pii_classification}`\n")
+        md.append(
+            md_table(
+                ["Stage", "Repos (count)"],
+                [
+                    [s, str(len(agg.repos_by_stage.get(s, set())))]
+                    for s in LIFECYCLE_STAGES
+                ],
+            ),
+        )
+        if agg.sample_refs:
+            md.append("\nSample locations:\n")
+            for ref in agg.sample_refs:
+                md.append(f"- {ref}\n")
+
+
+def write_pii_lifecycle_graph(
+    metabase_root: Path,
+    repo_jsons: list[Path] | None = None,
+) -> list[PiiTouchpoint]:
+    """Write the PII lifecycle graph (JSONL + markdown) to graphs/ and return touches."""
+    records = load_v2_repo_records(metabase_root, json_paths=repo_jsons)
+    touches = collect_pii_touchpoints(records)
+    aggregates = aggregate_by_field(touches)
+
+    graphs_dir = metabase_root / "graphs"
+    graphs_dir.mkdir(parents=True, exist_ok=True)
+
+    jsonl_path = graphs_dir / "pii-lifecycle.jsonl"
+    with jsonl_path.open("w", encoding="utf-8") as fh:
+        for touch in touches:
+            fh.write(json.dumps(touch.to_dict(), ensure_ascii=False) + "\n")
+
+    stage_counts = Counter(t.stage for t in touches)
+    class_counts = Counter(t.pii_classification for t in touches)
+
+    md: list[str] = [
+        "# PII lifecycle (fleet)\n",
+        UNTRUSTED_CONTENT_NOTICE,
+        "_Static analysis from v2 `pii-field`, `pii-storage`, `pii-log`, and "
+        "file-local proximity to SQL/HTTP/crypto. Not a runtime data-flow proof._\n",
+        "\n## Stage totals\n",
+        md_table(
+            ["Stage", "Touchpoints"],
+            [[s, str(stage_counts.get(s, 0))] for s in LIFECYCLE_STAGES],
+        ),
+        "\n## By GDPR classification\n",
+        md_table(
+            ["Classification", "Touchpoints"],
+            [[k, str(v)] for k, v in class_counts.most_common()],
+        ),
+    ]
+
+    _append_phone_example(md, aggregates)
+
+    md.append("\n## Field catalogue (top by touchpoints)\n")
+    ranked = sorted(aggregates.values(), key=lambda a: -a.touchpoints)
+    md.append(
+        md_table(
+            ["Field", "Classification", "Touchpoints", "Collect repos", "Store repos", "Log repos"],
+            [
+                [
+                    a.field_key,
+                    a.pii_classification,
+                    str(a.touchpoints),
+                    str(len(a.repos_by_stage.get("collect", set()))),
+                    str(len(a.repos_by_stage.get("store", set()))),
+                    str(len(a.repos_by_stage.get("log", set()))),
+                ]
+                for a in ranked[:MAX_MD_ROWS]
+            ],
+        ),
+    )
+    tail = max(0, len(ranked) - MAX_MD_ROWS)
+    if tail:
+        md.append(f"\n_{tail} more fields in `pii-lifecycle.jsonl`._\n")
+
+    (graphs_dir / "pii-lifecycle.md").write_text("\n".join(md), encoding="utf-8")
+    return touches

src2sink/aggregators/pii_touchpoint_collect.py

@@ -0,0 +1,134 @@
+"""Collect fleet-wide PII lifecycle touchpoints from v2 flow nodes."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..graph_common import iter_nodes, repo_id
+from ..models.pii_lifecycle import PiiTouchpoint
+
+from .pii_touchpoint_utils import (
+    PROXIMITY_LINES,
+    DELETE_RX,
+    lines_by_file,
+    nearby,
+    proximity_touch,
+    touch_from_node,
+)
+
+
+def _maybe_add_proximity(
+    touches: list[PiiTouchpoint],
+    seen_intra: set[tuple[str, str, str, int]],
+    base: PiiTouchpoint,
+    *,
+    stage: str,
+    family: str,
+    evidence: str,
+    file: str,
+    line: int,
+    by_file: dict[str, list[tuple[int, str, dict[str, Any]]]],
+    probe_families: set[str],
+) -> None:
+    """Add a deduplicated proximity touchpoint if a probe family is near the line."""
+    if not nearby(by_file, file, line, probe_families, window=PROXIMITY_LINES):
+        return
+    sig = (base.repo, base.field_key, stage, line)
+    if sig in seen_intra:
+        return
+    seen_intra.add(sig)
+    touches.append(proximity_touch(base, stage=stage, family=family, evidence=evidence))
+
+
+def _collect_pii_field_node(
+    rid: str,
+    node: dict[str, Any],
+    by_file: dict[str, list[tuple[int, str, dict[str, Any]]]],
+    touches: list[PiiTouchpoint],
+    seen_intra: set[tuple[str, str, str, int]],
+) -> None:
+    """Emit a collect touch for a pii-field node plus nearby process/transmit/encrypt touches."""
+    line = int(node.get("line") or 0)
+    file = node.get("file", "")
+    t = touch_from_node(rid, "collect", node)
+    if t:
+        touches.append(t)
+    if not t:
+        return
+    _maybe_add_proximity(
+        touches, seen_intra, t,
+        stage="process", family="sql+near-pii-field",
+        evidence="sql sink within file window",
+        file=file, line=line, by_file=by_file, probe_families={"sql"},
+    )
+    _maybe_add_proximity(
+        touches, seen_intra, t,
+        stage="transmit", family="http-out+near-pii-field",
+        evidence="http-out within file window",
+        file=file, line=line, by_file=by_file, probe_families={"http-out"},
+    )
+    _maybe_add_proximity(
+        touches, seen_intra, t,
+        stage="encrypt", family="crypto+near-pii-field",
+        evidence="crypto op within file window",
+        file=file, line=line, by_file=by_file,
+        probe_families={"crypto-algorithm", "crypto-config"},
+    )
+
+
+def _collect_delete_hints(
+    rid: str,
+    data: dict[str, Any],
+    by_file: dict[str, list[tuple[int, str, dict[str, Any]]]],
+    touches: list[PiiTouchpoint],
+) -> None:
+    """Emit delete-stage touches where a delete/remove op sits near a PII field."""
+    for node in iter_nodes(data):
+        if node.get("family") not in ("pii-log", "pii-storage", "pii-field"):
+            continue
+        detail = node.get("detail") or {}
+        field_name = detail.get("field_name")
+        if not field_name:
+            continue
+        file = node.get("file", "")
+        line = int(node.get("line") or 0)
+        for ln, _, n in by_file.get(file, []):
+            if abs(ln - line) > 30:
+                continue
+            raw = (n.get("detail") or {}).get("raw", "")
+            if DELETE_RX.search(raw):
+                t = touch_from_node(
+                    rid,
+                    "delete",
+                    node,
+                    evidence="delete/remove near field",
+                )
+                if t:
+                    touches.append(t)
+                break
+
+
+def collect_pii_touchpoints(records: list[dict[str, Any]]) -> list[PiiTouchpoint]:
+    """Collect all PII lifecycle touchpoints across the given repo records."""
+    touches: list[PiiTouchpoint] = []
+    for data in records:
+        rid = repo_id(data)
+        by_file = lines_by_file(data)
+        seen_intra: set[tuple[str, str, str, int]] = set()
+
+        for node in iter_nodes(data):
+            family = node.get("family", "")
+            if family == "pii-field":
+                _collect_pii_field_node(rid, node, by_file, touches, seen_intra)
+            elif family == "pii-storage":
+                t = touch_from_node(rid, "store", node)
+                if t:
+                    touches.append(t)
+            elif family == "pii-log":
+                t = touch_from_node(rid, "log", node)
+                if t:
+                    touches.append(t)
+
+        _collect_delete_hints(rid, data, by_file, touches)
+
+    return touches

src2sink/aggregators/pii_touchpoint_utils.py

@@ -0,0 +1,96 @@
+"""Shared helpers for PII lifecycle touchpoint collection."""
+
+from __future__ import annotations
+
+import re
+from collections import defaultdict
+from typing import Any
+
+from ..models.pii_lifecycle import PiiTouchpoint, normalize_field_key
+
+PROXIMITY_LINES = 80
+
+DELETE_RX = re.compile(
+    r"\b(delete|remove|erase|purge|forget)\w*\b",
+    re.IGNORECASE,
+)
+
+
+def lines_by_file(data: dict[str, Any]) -> dict[str, list[tuple[int, str, dict[str, Any]]]]:
+    """file -> [(line, family, node), ...] sorted by line."""
+    by_file: dict[str, list[tuple[int, str, dict[str, Any]]]] = defaultdict(list)
+    for node in data.get("nodes", []):
+        by_file[node.get("file", "")].append(
+            (int(node.get("line") or 0), node.get("family", ""), node),
+        )
+    for entries in by_file.values():
+        entries.sort(key=lambda x: x[0])
+    return by_file
+
+
+def nearby(
+    by_file: dict[str, list[tuple[int, str, dict[str, Any]]]],
+    file: str,
+    line: int,
+    families: set[str],
+    *,
+    window: int = PROXIMITY_LINES,
+) -> bool:
+    """Return True if any node of the given families sits within window lines."""
+    for ln, fam, _ in by_file.get(file, []):
+        if fam in families and abs(ln - line) <= window:
+            return True
+    return False
+
+
+def touch_from_node(
+    rid: str,
+    stage: str,
+    node: dict[str, Any],
+    *,
+    evidence: str = "",
+) -> PiiTouchpoint | None:
+    """Build a PiiTouchpoint from a flow node, or None if it carries no usable field."""
+    detail = node.get("detail") or {}
+    field_name = detail.get("field_name") or ""
+    if not field_name and stage not in ("encrypt", "delete"):
+        if node.get("family") not in ("pii-log", "pii-storage"):
+            return None
+    field_key = normalize_field_key(field_name or "unknown")
+    pii_c = node.get("pii_classification") or "unknown"
+    return PiiTouchpoint(
+        repo=rid,
+        stage=stage,
+        family=node.get("family", ""),
+        field_key=field_key,
+        field_name=field_name or field_key,
+        pii_classification=pii_c,
+        data_class=node.get("data_class"),
+        file=node.get("file", ""),
+        line=int(node.get("line") or 0),
+        confidence=node.get("confidence", "medium"),
+        evidence=evidence,
+    )
+
+
+def proximity_touch(
+    base: PiiTouchpoint,
+    *,
+    stage: str,
+    family: str,
+    evidence: str,
+) -> PiiTouchpoint:
+    """Clone a collect-stage touch with a proximity-derived stage."""
+    return PiiTouchpoint(
+        repo=base.repo,
+        stage=stage,
+        family=family,
+        field_key=base.field_key,
+        field_name=base.field_name,
+        pii_classification=base.pii_classification,
+        data_class=base.data_class,
+        file=base.file,
+        line=base.line,
+        confidence="low",
+        evidence=evidence,
+    )

src2sink/aggregators/queues.py

@@ -0,0 +1,141 @@
+"""Queue / messaging graph aggregator — v2 queue-pub / queue-sub nodes."""
+
+from __future__ import annotations
+
+import json
+import re
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+from ..graph_common import iter_nodes, load_v2_repo_records, repo_id
+from ..sanitize import UNTRUSTED_CONTENT_NOTICE, for_markdown, for_mermaid_label
+from ..renderers.markdown import md_table
+
+
+def _collect_queue_topics(records: list[dict[str, Any]]) -> dict[str, dict[str, set[str]]]:
+    """Map each topic to producing/consuming repos and messaging systems."""
+    topics: dict[str, dict[str, set[str]]] = defaultdict(
+        lambda: {"produce": set(), "consume": set(), "systems": set()},
+    )
+    for data in records:
+        rid = repo_id(data)
+        for node in iter_nodes(data):
+            family = node.get("family", "")
+            detail = node.get("detail") or {}
+            topic = detail.get("topic", "")
+            if not topic or topic == "?":
+                continue
+            role = {"queue-pub": "produce", "queue-sub": "consume"}.get(family)
+            if not role:
+                continue
+            topics[topic][role].add(rid)
+            system = detail.get("system") or ""
+            if system:
+                topics[topic]["systems"].add(system)
+    return topics
+
+
+def _queue_rows_and_orphans(
+    topics: dict[str, dict[str, set[str]]],
+) -> tuple[list[list[str]], list[str], list[str]]:
+    """Build topic table rows plus produce-only and consume-only orphan lists."""
+    rows: list[list[str]] = []
+    orphans_produce: list[str] = []
+    orphans_consume: list[str] = []
+    for topic, dirs in sorted(topics.items()):
+        producers = sorted(dirs["produce"])
+        consumers = sorted(dirs["consume"])
+        systems = sorted(dirs["systems"])
+        rows.append([
+            topic,
+            ", ".join(systems) if systems else "—",
+            ", ".join(producers) if producers else "—",
+            ", ".join(consumers) if consumers else "—",
+        ])
+        if producers and not consumers:
+            orphans_produce.append(topic)
+        if consumers and not producers:
+            orphans_consume.append(topic)
+    return rows, orphans_produce, orphans_consume
+
+
+def _orphan_line(label: str, topics: list[str]) -> str:
+    """Format a labelled bullet listing orphan topics (capped at 30)."""
+    return (
+        f"- **{label}** ({len(topics)}): "
+        # topics are untrusted extracted literals emitted outside a table cell.
+        + ", ".join(for_markdown(t, max_len=80) for t in topics[:30])
+        + (" …" if len(topics) > 30 else "")
+        + "\n"
+    )
+
+
+def _queue_mermaid(topics: dict[str, dict[str, set[str]]]) -> list[str]:
+    """Render a Mermaid flowchart for topics that have both producers and consumers."""
+    both = [t for t, d in topics.items() if d["produce"] and d["consume"]][:25]
+    if not both:
+        return []
+    md = ["\n## Mermaid (topics with producers and consumers)\n\n```mermaid\nflowchart LR\n"]
+    for topic in both:
+        d = topics[topic]
+        # Both the node id and the label are attacker-influenced: the id must be a
+        # strict slug (drop everything non-alphanumeric) or the topic's quotes /
+        # newlines break out of the node; the label is neutralised separately.
+        tid = re.sub(r"[^A-Za-z0-9_]", "_", topic)[:50]
+        topic_label = for_mermaid_label(topic)
+        for p in sorted(d["produce"])[:3]:
+            pid = re.sub(r"[^A-Za-z0-9_]", "_", p)[:30]
+            md.append(f'  {pid}["{for_mermaid_label(p)}"] -->|{topic_label}| hub_{tid}["{topic_label}"]\n')
+        for c in sorted(d["consume"])[:3]:
+            cid = re.sub(r"[^A-Za-z0-9_]", "_", c)[:30]
+            md.append(f'  hub_{tid} --> {cid}["{for_mermaid_label(c)}"]\n')
+    md.append("```\n")
+    return md
+
+
+def _write_queue_jsonl(path: Path, topics: dict[str, dict[str, set[str]]]) -> None:
+    """Write one JSON line per topic with its systems, producers, and consumers."""
+    with path.open("w", encoding="utf-8") as fh:
+        for topic, dirs in sorted(topics.items()):
+            systems = sorted(dirs["systems"])
+            fh.write(json.dumps({
+                "topic": topic,
+                "queue_types": systems,
+                "queue_type": ", ".join(systems) if systems else None,
+                "producers": sorted(dirs["produce"]),
+                "consumers": sorted(dirs["consume"]),
+            }, ensure_ascii=False) + "\n")
+
+
+def write_queue_graph(metabase_root: Path, repo_jsons: list[Path]) -> None:
+    """Write the queue/messaging graph markdown + jsonl from v2 queue nodes."""
+    records = load_v2_repo_records(metabase_root, json_paths=repo_jsons)
+    topics = _collect_queue_topics(records)
+
+    out_dir = metabase_root / "graphs"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    rows, orphans_produce, orphans_consume = _queue_rows_and_orphans(topics)
+    md: list[str] = [
+        "# Queue / messaging graph (v2)\n",
+        UNTRUSTED_CONTENT_NOTICE,
+        "_Producers (`queue-pub`) and consumers (`queue-sub`) per topic from "
+        "v2 flow nodes. **Queue type** is the `detail.system` from the extractor "
+        "(kafka, rabbitmq, sqs, sns, redis-stream, nats, jms, …)._\n",
+        "\n## Topics\n",
+        md_table(
+            ["Topic", "Queue type", "Producers", "Consumers"],
+            rows or [["—", "—", "—", "—"]],
+        ),
+    ]
+    if orphans_produce or orphans_consume:
+        md.append("\n## Orphan topics\n")
+        if orphans_produce:
+            md.append(_orphan_line("Produce-only", orphans_produce))
+        if orphans_consume:
+            md.append(_orphan_line("Consume-only", orphans_consume))
+    md.extend(_queue_mermaid(topics))
+
+    (out_dir / "queue-graph.md").write_text("\n".join(md), encoding="utf-8")
+    _write_queue_jsonl(out_dir / "queue-graph.jsonl", topics)