tnfr 6.0.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

tnfr/metrics/core.py

@@ -2,9 +2,19 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
+from collections.abc import Mapping, MutableMapping
 from typing import Any, NamedTuple, cast
 
+from ..callback_utils import CallbackEvent, callback_manager
+from ..constants import get_param
+from ..glyph_history import append_metric, ensure_history
+from ..telemetry import ensure_nu_f_telemetry
+from ..units import get_hz_bridge
+from ..telemetry.verbosity import (
+    TELEMETRY_VERBOSITY_DEFAULT,
+    TELEMETRY_VERBOSITY_LEVELS,
+    TelemetryVerbosity,
+)
 from ..types import (
     GlyphSelector,
     NodeId,
@@ -17,32 +27,23 @@ from ..types import (
     TraceFieldMap,
     TraceFieldRegistry,
 )
-
-from ..callback_utils import CallbackEvent, callback_manager
-from ..constants import get_param
-from ..glyph_history import append_metric, ensure_history
 from ..utils import get_logger
-from ..telemetry.verbosity import (
-    TelemetryVerbosity,
-    TELEMETRY_VERBOSITY_DEFAULT,
-    TELEMETRY_VERBOSITY_LEVELS,
-)
 from .coherence import (
+    GLYPH_LOAD_STABILIZERS_KEY,
     _aggregate_si,
     _track_stability,
     _update_coherence,
     _update_phase_sync,
     _update_sigma,
     register_coherence_callbacks,
-    GLYPH_LOAD_STABILIZERS_KEY,
 )
 from .diagnosis import register_diagnosis_callbacks
-from .glyph_timing import _compute_advanced_metrics, GlyphMetricsHistory
+from .glyph_timing import GlyphMetricsHistory, _compute_advanced_metrics
 from .reporting import (
     Tg_by_node,
     Tg_global,
-    glyphogram_series,
     glyph_top,
+    glyphogram_series,
     latency_series,
 )
 
@@ -79,6 +80,7 @@ class MetricsVerbositySpec(NamedTuple):
     enable_advanced: bool
     attach_coherence_hooks: bool
     attach_diagnosis_hooks: bool
+    enable_nu_f: bool
 
 
 METRICS_VERBOSITY_DEFAULT = TELEMETRY_VERBOSITY_DEFAULT
@@ -89,7 +91,8 @@ _METRICS_VERBOSITY_PRESETS: dict[str, MetricsVerbositySpec] = {}
 def _register_metrics_preset(spec: MetricsVerbositySpec) -> None:
     if spec.name not in TELEMETRY_VERBOSITY_LEVELS:
         raise ValueError(
-            "Unknown metrics verbosity '%s'; use %s" % (
+            "Unknown metrics verbosity '%s'; use %s"
+            % (
                 spec.name,
                 ", ".join(TELEMETRY_VERBOSITY_LEVELS),
             )
@@ -106,6 +109,7 @@ _register_metrics_preset(
         enable_advanced=False,
         attach_coherence_hooks=False,
         attach_diagnosis_hooks=False,
+        enable_nu_f=False,
     )
 )
 
@@ -117,6 +121,7 @@ _detailed_spec = MetricsVerbositySpec(
     enable_advanced=False,
     attach_coherence_hooks=True,
     attach_diagnosis_hooks=False,
+    enable_nu_f=True,
 )
 _register_metrics_preset(_detailed_spec)
 _register_metrics_preset(
@@ -124,6 +129,7 @@ _register_metrics_preset(
         name=TelemetryVerbosity.DEBUG.value,
         enable_advanced=True,
         attach_diagnosis_hooks=True,
+        enable_nu_f=True,
     )
 )
 
@@ -139,6 +145,51 @@ _METRICS_SIGMA_HISTORY_KEYS = (
     "sense_sigma_angle",
 )
 _METRICS_SI_HISTORY_KEYS = ("Si_mean", "Si_hi_frac", "Si_lo_frac")
+_METRICS_NU_F_HISTORY_KEYS = (
+    "nu_f_rate_hz_str",
+    "nu_f_rate_hz",
+    "nu_f_ci_lower_hz_str",
+    "nu_f_ci_upper_hz_str",
+    "nu_f_ci_lower_hz",
+    "nu_f_ci_upper_hz",
+)
+
+
+def _update_nu_f_snapshot(
+    G: TNFRGraph,
+    hist: MutableMapping[str, Any],
+    *,
+    record_history: bool,
+) -> None:
+    """Refresh νf telemetry snapshot and optionally persist it in history."""
+
+    accumulator = ensure_nu_f_telemetry(G, confidence_level=None)
+    snapshot = accumulator.snapshot(graph=G)
+    payload = snapshot.as_payload()
+    bridge: float | None
+    try:
+        bridge = float(get_hz_bridge(G))
+    except (TypeError, ValueError, KeyError):
+        bridge = None
+    else:
+        payload["hz_bridge"] = bridge
+
+    telemetry = G.graph.setdefault("telemetry", {})
+    if not isinstance(telemetry, MutableMapping):
+        telemetry = {}
+        G.graph["telemetry"] = telemetry
+    telemetry["nu_f_snapshot"] = payload
+    telemetry["nu_f_bridge"] = bridge
+
+    if record_history:
+        append_metric(hist, "nu_f_rate_hz_str", snapshot.rate_hz_str)
+        append_metric(hist, "nu_f_rate_hz", snapshot.rate_hz)
+        append_metric(hist, "nu_f_ci_lower_hz_str", snapshot.ci_lower_hz_str)
+        append_metric(hist, "nu_f_ci_upper_hz_str", snapshot.ci_upper_hz_str)
+        append_metric(hist, "nu_f_ci_lower_hz", snapshot.ci_lower_hz)
+        append_metric(hist, "nu_f_ci_upper_hz", snapshot.ci_upper_hz)
+
+    G.graph["_nu_f_snapshot_payload"] = payload
 
 
 def _resolve_metrics_verbosity(cfg: Mapping[str, Any]) -> MetricsVerbositySpec:
@@ -187,6 +238,9 @@ def _metrics_step(G: TNFRGraph, ctx: dict[str, Any] | None = None) -> None:
         if spec.enable_aggregate_si:
             for key in _METRICS_SI_HISTORY_KEYS:
                 hist.setdefault(key, [])
+        if spec.enable_nu_f:
+            for key in _METRICS_NU_F_HISTORY_KEYS:
+                hist.setdefault(key, [])
         G.graph[metrics_sentinel_key] = history_id
 
     dt = float(get_param(G, "DT"))
@@ -233,6 +287,8 @@ def _metrics_step(G: TNFRGraph, ctx: dict[str, Any] | None = None) -> None:
     if spec.enable_aggregate_si:
         _aggregate_si(G, hist, n_jobs=metrics_jobs)
 
+    _update_nu_f_snapshot(G, hist, record_history=spec.enable_nu_f)
+
     if spec.enable_advanced:
         _compute_advanced_metrics(
             G,
@@ -245,6 +301,8 @@ def _metrics_step(G: TNFRGraph, ctx: dict[str, Any] | None = None) -> None:
 
 
 def register_metrics_callbacks(G: TNFRGraph) -> None:
+    """Attach canonical metrics callbacks according to graph configuration."""
+
     cfg = cast(Mapping[str, Any], get_param(G, "METRICS"))
     spec = _resolve_metrics_verbosity(cfg)
     callback_manager.register_callback(

tnfr/metrics/diagnosis.py

@@ -3,28 +3,28 @@
 from __future__ import annotations
 
 import math
+from collections import deque
+from collections.abc import Mapping, MutableMapping, Sequence
 from concurrent.futures import ProcessPoolExecutor
 from dataclasses import dataclass
 from functools import partial
 from operator import ge, le
 from statistics import StatisticsError, fmean
 from typing import Any, Callable, Iterable, cast
-from collections import deque
-from collections.abc import Mapping, MutableMapping, Sequence
 
+from ..alias import get_attr
+from ..callback_utils import CallbackEvent, callback_manager
 from ..constants import (
     STATE_DISSONANT,
     STATE_STABLE,
     STATE_TRANSITION,
     VF_KEY,
-    get_aliases,
     get_param,
     normalise_state_token,
 )
-from ..callback_utils import CallbackEvent, callback_manager
+from ..constants.aliases import ALIAS_DNFR, ALIAS_EPI, ALIAS_SI, ALIAS_VF
 from ..glyph_history import append_metric, ensure_history
-from ..alias import get_attr
-from ..helpers.numeric import clamp01, similarity_abs
+from ..utils import clamp01, resolve_chunk_size, similarity_abs
 from ..types import (
     DiagnosisNodeData,
     DiagnosisPayload,
@@ -36,31 +36,17 @@ from ..types import (
     TNFRGraph,
 )
 from ..utils import get_numpy
-from .common import compute_dnfr_accel_max, min_max_range, normalize_dnfr
 from .coherence import CoherenceMatrixPayload, coherence_matrix, local_phase_sync
+from .common import (
+    _coerce_jobs,
+    compute_dnfr_accel_max,
+    min_max_range,
+    normalize_dnfr,
+)
 from .trig_cache import compute_theta_trig, get_trig_cache
 
-ALIAS_EPI = get_aliases("EPI")
-ALIAS_VF = get_aliases("VF")
-ALIAS_SI = get_aliases("SI")
-ALIAS_DNFR = get_aliases("DNFR")
-
 CoherenceSeries = Sequence[CoherenceMatrixPayload | None]
 CoherenceHistory = Mapping[str, CoherenceSeries]
-
-
-def _coerce_jobs(raw_jobs: Any | None) -> int | None:
-    """Normalise ``n_jobs`` values coming from user configuration."""
-
-    try:
-        jobs = None if raw_jobs is None else int(raw_jobs)
-    except (TypeError, ValueError):
-        return None
-    if jobs is not None and jobs <= 0:
-        return None
-    return jobs
-
-
 def _coherence_matrix_to_numpy(
     weight_matrix: Any,
     size: int,
@@ -376,7 +362,9 @@ def _node_diagnostics(
 
     if compute_symmetry:
         epi_bar = node_data.get("neighbor_epi_mean")
-        symm = 1.0 if epi_bar is None else similarity_abs(EPI, epi_bar, epi_min, epi_max)
+        symm = (
+            1.0 if epi_bar is None else similarity_abs(EPI, epi_bar, epi_min, epi_max)
+        )
     else:
         symm = None
 
@@ -505,10 +493,7 @@ def _diagnosis_step(
 
     if supports_vector:
         epi_arr = np_mod.fromiter(
-            (
-                cast(float, get_attr(nd, ALIAS_EPI, 0.0))
-                for _, nd in nodes_data
-            ),
+            (cast(float, get_attr(nd, ALIAS_EPI, 0.0)) for _, nd in nodes_data),
             dtype=float,
             count=len(nodes_data),
         )
@@ -518,10 +503,7 @@ def _diagnosis_step(
 
         si_arr = np_mod.clip(
             np_mod.fromiter(
-                (
-                    cast(float, get_attr(nd, ALIAS_SI, 0.0))
-                    for _, nd in nodes_data
-                ),
+                (cast(float, get_attr(nd, ALIAS_SI, 0.0)) for _, nd in nodes_data),
                 dtype=float,
                 count=len(nodes_data),
             ),
@@ -531,10 +513,7 @@ def _diagnosis_step(
         si_vals = si_arr.tolist()
 
         vf_arr = np_mod.fromiter(
-            (
-                cast(float, get_attr(nd, ALIAS_VF, 0.0))
-                for _, nd in nodes_data
-            ),
+            (cast(float, get_attr(nd, ALIAS_VF, 0.0)) for _, nd in nodes_data),
             dtype=float,
             count=len(nodes_data),
         )
@@ -595,9 +574,7 @@ def _diagnosis_step(
     if supports_vector:
         size = len(coherence_nodes)
         matrix_np = (
-            _coherence_matrix_to_numpy(weight_matrix, size, np_mod)
-            if size
-            else None
+            _coherence_matrix_to_numpy(weight_matrix, size, np_mod) if size else None
         )
         if matrix_np is not None and size:
             cos_weight = np_mod.fromiter(
@@ -617,8 +594,7 @@ def _diagnosis_step(
                 np_mod,
             )
             rloc_map = {
-                coherence_nodes[idx]: float(weighted_sync[idx])
-                for idx in range(size)
+                coherence_nodes[idx]: float(weighted_sync[idx]) for idx in range(size)
             }
         else:
             rloc_map = {}
@@ -647,14 +623,19 @@ def _diagnosis_step(
             rloc_values = [rloc_map.get(node, 0.0) for node in nodes]
     else:
         if n_jobs and n_jobs > 1 and len(nodes) > 1:
-            chunk_size = max(1, math.ceil(len(nodes) / n_jobs))
+            approx_chunk = math.ceil(len(nodes) / n_jobs) if n_jobs else None
+            chunk_size = resolve_chunk_size(
+                approx_chunk,
+                len(nodes),
+                minimum=1,
+            )
             rloc_values = []
             with ProcessPoolExecutor(max_workers=n_jobs) as executor:
                 futures = [
                     executor.submit(
                         _rlocal_worker,
                         RLocalWorkerArgs(
-                            chunk=nodes[idx:idx + chunk_size],
+                            chunk=nodes[idx : idx + chunk_size],
                             coherence_nodes=coherence_nodes,
                             weight_matrix=weight_matrix,
                             weight_index=weight_index,
@@ -681,7 +662,9 @@ def _diagnosis_step(
             )
 
     if isinstance(Wi_last, (list, tuple)) and Wi_last:
-        wi_values = [Wi_last[i] if i < len(Wi_last) else None for i in range(len(nodes))]
+        wi_values = [
+            Wi_last[i] if i < len(Wi_last) else None for i in range(len(nodes))
+        ]
     else:
         wi_values = [None] * len(nodes)
 
@@ -697,7 +680,12 @@ def _diagnosis_step(
                 np_mod,
             )
         elif n_jobs and n_jobs > 1 and len(nodes) > 1:
-            chunk_size = max(1, math.ceil(len(nodes) / n_jobs))
+            approx_chunk = math.ceil(len(nodes) / n_jobs) if n_jobs else None
+            chunk_size = resolve_chunk_size(
+                approx_chunk,
+                len(nodes),
+                minimum=1,
+            )
             neighbor_means = cast(list[float | None], [])
             with ProcessPoolExecutor(max_workers=n_jobs) as executor:
                 submit = cast(Callable[..., Any], executor.submit)
@@ -708,7 +696,7 @@ def _diagnosis_step(
                             _neighbor_mean_worker,
                         ),
                         NeighborMeanWorkerArgs(
-                            chunk=nodes[idx:idx + chunk_size],
+                            chunk=nodes[idx : idx + chunk_size],
                             neighbors_map=neighbors_map,
                             epi_map=epi_map,
                         ),
@@ -716,9 +704,7 @@ def _diagnosis_step(
                     for idx in range(0, len(nodes), chunk_size)
                 ]
                 for fut in futures:
-                    neighbor_means.extend(
-                        cast(list[float | None], fut.result())
-                    )
+                    neighbor_means.extend(cast(list[float | None], fut.result()))
         else:
             neighbor_means = _neighbor_mean_worker(
                 NeighborMeanWorkerArgs(
@@ -754,7 +740,12 @@ def _diagnosis_step(
     }
 
     if n_jobs and n_jobs > 1 and len(node_payload) > 1:
-        chunk_size = max(1, math.ceil(len(node_payload) / n_jobs))
+        approx_chunk = math.ceil(len(node_payload) / n_jobs) if n_jobs else None
+        chunk_size = resolve_chunk_size(
+            approx_chunk,
+            len(node_payload),
+            minimum=1,
+        )
         diag_pairs: DiagnosisResultList = []
         with ProcessPoolExecutor(max_workers=n_jobs) as executor:
             submit = cast(Callable[..., Any], executor.submit)
@@ -767,7 +758,7 @@ def _diagnosis_step(
                         ],
                         _diagnosis_worker_chunk,
                     ),
-                    node_payload[idx:idx + chunk_size],
+                    node_payload[idx : idx + chunk_size],
                     shared,
                 )
                 for idx in range(0, len(node_payload), chunk_size)
@@ -785,9 +776,7 @@ def _diagnosis_step(
     append_metric(hist, key, diag)
 
 
-def dissonance_events(
-    G: TNFRGraph, ctx: DiagnosisSharedState | None = None
-) -> None:
+def dissonance_events(G: TNFRGraph, ctx: DiagnosisSharedState | None = None) -> None:
     """Emit per-node structural dissonance start/end events.
 
     Events are recorded as ``"dissonance_start"`` and ``"dissonance_end"``.
@@ -823,6 +812,8 @@ def dissonance_events(
 
 
 def register_diagnosis_callbacks(G: TNFRGraph) -> None:
+    """Attach diagnosis observers (Si/dissonance tracking) to ``G``."""
+
     raw_jobs = G.graph.get("DIAGNOSIS_N_JOBS")
     n_jobs = _coerce_jobs(raw_jobs)
 

tnfr/metrics/diagnosis.pyi

@@ -61,7 +61,6 @@ class RLocalWorkerArgs:
         sin_map: Mapping[Any, float],
     ) -> None: ...
 
-
 class NeighborMeanWorkerArgs:
     chunk: Sequence[Any]
     neighbors_map: Mapping[Any, tuple[Any, ...]]
@@ -74,15 +73,12 @@ class NeighborMeanWorkerArgs:
         epi_map: Mapping[Any, float],
     ) -> None: ...
 
-
 def _rlocal_worker(args: RLocalWorkerArgs) -> list[float]: ...
-
 def _neighbor_mean_worker(args: NeighborMeanWorkerArgs) -> list[float | None]: ...
-
-def _state_from_thresholds(Rloc: float, dnfr_n: float, cfg: Mapping[str, Any]) -> str: ...
-
+def _state_from_thresholds(
+    Rloc: float, dnfr_n: float, cfg: Mapping[str, Any]
+) -> str: ...
 def _recommendation(state: str, cfg: Mapping[str, Any]) -> list[Any]: ...
-
 def _get_last_weights(
     G: TNFRGraph,
     hist: Mapping[str, Sequence[CoherenceMatrixPayload | None]],

tnfr/metrics/export.py

@@ -5,16 +5,14 @@ from __future__ import annotations
 import csv
 import math
 from collections.abc import Iterable, Iterator, Sequence
-from itertools import zip_longest, tee
+from itertools import tee, zip_longest
 from typing import Mapping, TextIO
 
 from ..config.constants import GLYPHS_CANONICAL
 from ..glyph_history import ensure_history
-from ..io import safe_write
-from ..utils import json_dumps
-from ..types import Graph
+from ..utils import json_dumps, safe_write
+from ..types import Graph, SigmaTrace
 from .core import glyphogram_series
-from .glyph_timing import SigmaTrace
 
 
 def _write_csv(

tnfr/metrics/glyph_timing.py

@@ -2,20 +2,38 @@
 
 from __future__ import annotations
 
+import math
 from collections import Counter, defaultdict
 from concurrent.futures import ProcessPoolExecutor
 from dataclasses import dataclass
-import math
 from types import ModuleType
-from typing import Any, Callable, Mapping, MutableMapping, MutableSequence, Sequence, TypedDict, cast
+from typing import (
+    Any,
+    Callable,
+    Mapping,
+    MutableMapping,
+    Sequence,
+    cast,
+)
 
 from ..alias import get_attr
-from ..constants import get_aliases, get_param
 from ..config.constants import GLYPH_GROUPS, GLYPHS_CANONICAL
-from ..glyph_history import append_metric, last_glyph
-from ..types import GraphLike
-
-ALIAS_EPI = get_aliases("EPI")
+from ..constants import get_param
+from ..constants.aliases import ALIAS_EPI
+from ..glyph_history import append_metric
+from ..glyph_runtime import last_glyph
+from ..utils import resolve_chunk_size
+from ..types import (
+    GlyphCounts,
+    GlyphMetricsHistory,
+    GlyphMetricsHistoryValue,
+    GlyphTimingByNode,
+    GlyphTimingTotals,
+    GlyphogramRow,
+    GraphLike,
+    MetricsListHistory,
+    SigmaTrace,
+)
 
 LATENT_GLYPH: str = "SHA"
 DEFAULT_EPI_SUPPORT_LIMIT = 0.05
@@ -36,26 +54,6 @@ def _has_numpy_support(np_obj: object) -> bool:
         and hasattr(np_obj, "fromiter")
         and hasattr(np_obj, "bincount")
     )
-
-
-class SigmaTrace(TypedDict):
-    """Time-aligned σ(t) trace exported alongside glyphograms."""
-
-    t: list[float]
-    sigma_x: list[float]
-    sigma_y: list[float]
-    mag: list[float]
-    angle: list[float]
-
-
-GlyphogramRow = MutableMapping[str, float]
-GlyphTimingTotals = MutableMapping[str, float]
-GlyphTimingByNode = MutableMapping[Any, MutableMapping[str, MutableSequence[float]]]
-GlyphCounts = Mapping[str, int]
-GlyphMetricsHistoryValue = MutableMapping[Any, Any] | MutableSequence[Any]
-GlyphMetricsHistory = MutableMapping[str, GlyphMetricsHistoryValue]
-MetricsListHistory = MutableMapping[str, list[Any]]
-
 _GLYPH_TO_INDEX = {glyph: idx for idx, glyph in enumerate(GLYPHS_CANONICAL)}
 
 
@@ -70,6 +68,8 @@ def _coerce_float(value: Any) -> float:
 
 @dataclass
 class GlyphTiming:
+    """Mutable accumulator tracking the active glyph and its dwell time."""
+
     curr: str | None = None
     run: float = 0.0
 
@@ -219,11 +219,16 @@ def _update_tg(
             }
         )
     elif n_jobs is not None and n_jobs > 1 and len(glyph_sequence) > 1:
-        chunk_size = max(1, math.ceil(len(glyph_sequence) / n_jobs))
+        approx_chunk = math.ceil(len(glyph_sequence) / n_jobs) if n_jobs else None
+        chunk_size = resolve_chunk_size(
+            approx_chunk,
+            len(glyph_sequence),
+            minimum=1,
+        )
         futures = []
         with ProcessPoolExecutor(max_workers=n_jobs) as executor:
             for start in range(0, len(glyph_sequence), chunk_size):
-                chunk = glyph_sequence[start:start + chunk_size]
+                chunk = glyph_sequence[start : start + chunk_size]
                 futures.append(executor.submit(_count_glyphs_chunk, chunk))
             for future in futures:
                 counts.update(future.result())
@@ -299,12 +304,17 @@ def _update_epi_support(
             abs(_coerce_float(get_attr(nd, ALIAS_EPI, 0.0)))
             for _, nd in G.nodes(data=True)
         ]
-        chunk_size = max(1, math.ceil(len(values) / n_jobs))
+        approx_chunk = math.ceil(len(values) / n_jobs) if n_jobs else None
+        chunk_size = resolve_chunk_size(
+            approx_chunk,
+            len(values),
+            minimum=1,
+        )
         totals: list[tuple[float, int]] = []
         with ProcessPoolExecutor(max_workers=n_jobs) as executor:
             futures = []
             for start in range(0, len(values), chunk_size):
-                chunk = values[start:start + chunk_size]
+                chunk = values[start : start + chunk_size]
                 futures.append(executor.submit(_epi_support_chunk, chunk, threshold))
             for future in futures:
                 totals.append(future.result())

tnfr/metrics/reporting.py

@@ -3,14 +3,13 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import Any
-
 from heapq import nlargest
-from statistics import mean, fmean, StatisticsError
+from statistics import StatisticsError, fmean, mean
+from typing import Any
 
 from ..glyph_history import ensure_history
-from ..types import NodeId, TNFRGraph
 from ..sense import sigma_rose
+from ..types import NodeId, TNFRGraph
 from .glyph_timing import for_each_glyph
 
 __all__ = [
@@ -70,6 +69,8 @@ def Tg_by_node(
 
 
 def latency_series(G: TNFRGraph) -> dict[str, list[float]]:
+    """Return latency samples as ``{"t": [...], "value": [...]}``."""
+
     hist = ensure_history(G)
     xs = hist.get("latency_index", [])
     return {
@@ -79,11 +80,15 @@ def latency_series(G: TNFRGraph) -> dict[str, list[float]]:
 
 
 def glyphogram_series(G: TNFRGraph) -> dict[str, list[float]]:
+    """Return glyphogram time series keyed by glyph label."""
+
     hist = ensure_history(G)
     xs = hist.get("glyphogram", [])
     if not xs:
         return {"t": []}
-    out: dict[str, list[float]] = {"t": [float(x.get("t", i)) for i, x in enumerate(xs)]}
+    out: dict[str, list[float]] = {
+        "t": [float(x.get("t", i)) for i, x in enumerate(xs)]
+    }
 
     def add(g: str) -> None:
         out[g] = [float(x.get(g, 0.0)) for x in xs]
@@ -104,7 +109,9 @@ def glyph_top(G: TNFRGraph, k: int = 3) -> list[tuple[str, float]]:
 
 def build_metrics_summary(
     G: TNFRGraph, *, series_limit: int | None = None
-) -> tuple[dict[str, float | dict[str, float] | dict[str, list[float]] | dict[str, int]], bool]:
+) -> tuple[
+    dict[str, float | dict[str, float] | dict[str, list[float]] | dict[str, int]], bool
+]:
     """Collect a compact metrics summary for CLI reporting.
 
     Parameters