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

tnfr/glyph_history.py

@@ -2,15 +2,14 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, cast
 from collections import deque, Counter
 from itertools import islice
-from collections.abc import Iterable, Mapping
-from functools import lru_cache
+from collections.abc import Iterable, Mapping, MutableMapping
 
-from .constants import get_param
-from .collections_utils import ensure_collection
-from .logging_utils import get_logger
+from .constants import get_param, normalise_state_token
+from .utils import ensure_collection, get_logger, validate_window
+from .types import TNFRGraph
 
 logger = get_logger(__name__)
 
@@ -26,23 +25,12 @@ __all__ = (
 )
 
 
-@lru_cache(maxsize=1)
-def _resolve_validate_window():
-    from .validators import validate_window
-
-    return validate_window
-
-
-def _validate_window(window: int, *, positive: bool = False) -> int:
-    return _resolve_validate_window()(window, positive=positive)
-
-
 def _ensure_history(
-    nd: dict[str, Any], window: int, *, create_zero: bool = False
-) -> tuple[int, deque | None]:
+    nd: MutableMapping[str, Any], window: int, *, create_zero: bool = False
+) -> tuple[int, deque[str] | None]:
     """Validate ``window`` and ensure ``nd['glyph_history']`` deque."""
 
-    v_window = _validate_window(window)
+    v_window = validate_window(window)
     if v_window == 0 and not create_zero:
         return v_window, None
     hist = nd.setdefault("glyph_history", deque(maxlen=v_window))
@@ -58,12 +46,12 @@ def _ensure_history(
                     "Discarding non-iterable glyph history value %r", hist
                 )
                 items = ()
-        hist = deque(items, maxlen=v_window)
+        hist = deque((str(item) for item in items), maxlen=v_window)
         nd["glyph_history"] = hist
     return v_window, hist
 
 
-def push_glyph(nd: dict[str, Any], glyph: str, window: int) -> None:
+def push_glyph(nd: MutableMapping[str, Any], glyph: str, window: int) -> None:
     """Add ``glyph`` to node history with maximum size ``window``.
 
     ``window`` validation and deque creation are handled by
@@ -74,7 +62,9 @@ def push_glyph(nd: dict[str, Any], glyph: str, window: int) -> None:
     hist.append(str(glyph))
 
 
-def recent_glyph(nd: dict[str, Any], glyph: str, window: int) -> bool:
+def recent_glyph(
+    nd: MutableMapping[str, Any], glyph: str, window: int
+) -> bool:
     """Return ``True`` if ``glyph`` appeared in last ``window`` emissions.
 
     ``window`` validation and deque creation are handled by
@@ -89,7 +79,7 @@ def recent_glyph(nd: dict[str, Any], glyph: str, window: int) -> bool:
     return gl in hist
 
 
-class HistoryDict(dict):
+class HistoryDict(dict[str, Any]):
     """Dict specialized for bounded history series and usage counts.
 
     Usage counts are tracked explicitly via :meth:`get_increment`. Accessing
@@ -108,7 +98,7 @@ class HistoryDict(dict):
 
     def __init__(
         self,
-        data: dict[str, Any] | None = None,
+        data: Mapping[str, Any] | None = None,
         *,
         maxlen: int = 0,
     ) -> None:
@@ -129,7 +119,7 @@ class HistoryDict(dict):
         """Increase usage count for ``key``."""
         self._counts[key] += 1
 
-    def _to_deque(self, val: Any) -> deque:
+    def _to_deque(self, val: Any) -> deque[Any]:
         """Coerce ``val`` to a deque respecting ``self._maxlen``.
 
         ``Iterable`` inputs (excluding ``str`` and ``bytes``) are expanded into
@@ -160,21 +150,21 @@ class HistoryDict(dict):
         self._increment(key)
         return val
 
-    def __getitem__(self, key):  # type: ignore[override]
+    def __getitem__(self, key: str) -> Any:  # type: ignore[override]
         return self._resolve_value(key, None, insert=False)
 
-    def get(self, key, default=None):  # type: ignore[override]
+    def get(self, key: str, default: Any | None = None) -> Any:  # type: ignore[override]
         try:
             return self._resolve_value(key, None, insert=False)
         except KeyError:
             return default
 
-    def __setitem__(self, key, value):  # type: ignore[override]
+    def __setitem__(self, key: str, value: Any) -> None:  # type: ignore[override]
         super().__setitem__(key, value)
         if key not in self._counts:
             self._counts[key] = 0
 
-    def setdefault(self, key, default=None):  # type: ignore[override]
+    def setdefault(self, key: str, default: Any | None = None) -> Any:  # type: ignore[override]
         insert = key not in self
         val = self._resolve_value(key, default, insert=insert)
         if insert:
@@ -198,7 +188,7 @@ class HistoryDict(dict):
                 break
 
 
-def ensure_history(G) -> dict[str, Any]:
+def ensure_history(G: TNFRGraph) -> HistoryDict | dict[str, Any]:
     """Ensure ``G.graph['history']`` exists and return it.
 
     ``HISTORY_MAXLEN`` must be non-negative; otherwise a
@@ -220,6 +210,8 @@ def ensure_history(G) -> dict[str, Any]:
             replaced = True
         if replaced:
             G.graph.pop(sentinel_key, None)
+        if isinstance(hist, MutableMapping):
+            _normalise_state_streams(hist)
         return hist
     if (
         not isinstance(hist, HistoryDict)
@@ -233,31 +225,52 @@ def ensure_history(G) -> dict[str, Any]:
         hist.pop_least_used_batch(excess)
     if replaced:
         G.graph.pop(sentinel_key, None)
+    _normalise_state_streams(cast(MutableMapping[str, Any], hist))
     return hist
 
 
-def current_step_idx(G) -> int:
+def current_step_idx(G: TNFRGraph | Mapping[str, Any]) -> int:
     """Return the current step index from ``G`` history."""
 
     graph = getattr(G, "graph", G)
     return len(graph.get("history", {}).get("C_steps", []))
 
-    
 
-def append_metric(hist: dict[str, Any], key: str, value: Any) -> None:
+def append_metric(
+    hist: MutableMapping[str, list[Any]], key: str, value: Any
+) -> None:
     """Append ``value`` to ``hist[key]`` list, creating it if missing."""
+    if key == "phase_state" and isinstance(value, str):
+        value = normalise_state_token(value)
+    elif key == "nodal_diag" and isinstance(value, Mapping):
+        snapshot: dict[Any, Any] = {}
+        for node, payload in value.items():
+            if isinstance(payload, Mapping):
+                state_value = payload.get("state")
+                if isinstance(payload, MutableMapping):
+                    updated = payload
+                else:
+                    updated = dict(payload)
+                if isinstance(state_value, str):
+                    updated["state"] = normalise_state_token(state_value)
+                snapshot[node] = updated
+            else:
+                snapshot[node] = payload
+        hist.setdefault(key, []).append(snapshot)
+        return
+
     hist.setdefault(key, []).append(value)
 
 
-def last_glyph(nd: dict[str, Any]) -> str | None:
+def last_glyph(nd: Mapping[str, Any]) -> str | None:
     """Return the most recent glyph for node or ``None``."""
     hist = nd.get("glyph_history")
     return hist[-1] if hist else None
 
 
 def count_glyphs(
-    G, window: int | None = None, *, last_only: bool = False
-) -> Counter:
+    G: TNFRGraph, window: int | None = None, *, last_only: bool = False
+) -> Counter[str]:
     """Count recent glyphs in the network.
 
     If ``window`` is ``None``, the full history for each node is used. A
@@ -266,7 +279,7 @@ def count_glyphs(
     """
 
     if window is not None:
-        window = _validate_window(window)
+        window = validate_window(window)
         if window == 0:
             return Counter()
 
@@ -288,3 +301,37 @@ def count_glyphs(
         counts.update(seq)
 
     return counts
+
+
+def _normalise_state_streams(hist: MutableMapping[str, Any]) -> None:
+    """Normalise legacy state tokens stored in telemetry history."""
+
+    phase_state = hist.get("phase_state")
+    if isinstance(phase_state, deque):
+        canonical = [normalise_state_token(str(item)) for item in phase_state]
+        if canonical != list(phase_state):
+            phase_state.clear()
+            phase_state.extend(canonical)
+    elif isinstance(phase_state, list):
+        canonical = [normalise_state_token(str(item)) for item in phase_state]
+        if canonical != phase_state:
+            hist["phase_state"] = canonical
+
+    diag_history = hist.get("nodal_diag")
+    if isinstance(diag_history, list):
+        for snapshot in diag_history:
+            if not isinstance(snapshot, Mapping):
+                continue
+            for node, payload in snapshot.items():
+                if not isinstance(payload, Mapping):
+                    continue
+                state_value = payload.get("state")
+                if not isinstance(state_value, str):
+                    continue
+                canonical = normalise_state_token(state_value)
+                if canonical == state_value:
+                    continue
+                if isinstance(payload, MutableMapping):
+                    payload["state"] = canonical
+                else:
+                    snapshot[node] = {**payload, "state": canonical}

tnfr/glyph_history.pyi

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Mapping, MutableMapping
+from typing import Any
+
+from .types import TNFRGraph
+
+__all__: tuple[str, ...]
+
+
+class HistoryDict(dict[str, Any]):
+    _maxlen: int
+    _counts: Counter[str]
+
+    def __init__(
+        self, data: Mapping[str, Any] | None = ..., *, maxlen: int = ...
+    ) -> None: ...
+
+    def get_increment(self, key: str, default: Any = ...) -> Any: ...
+    def __getitem__(self, key: str) -> Any: ...
+    def get(self, key: str, default: Any | None = ...) -> Any: ...
+    def __setitem__(self, key: str, value: Any) -> None: ...
+    def setdefault(self, key: str, default: Any | None = ...) -> Any: ...
+    def pop_least_used(self) -> Any: ...
+    def pop_least_used_batch(self, k: int) -> None: ...
+
+
+def push_glyph(nd: MutableMapping[str, Any], glyph: str, window: int) -> None: ...
+
+
+def recent_glyph(
+    nd: MutableMapping[str, Any], glyph: str, window: int
+) -> bool: ...
+
+
+def ensure_history(G: TNFRGraph) -> HistoryDict | dict[str, Any]: ...
+
+
+def current_step_idx(G: TNFRGraph | Mapping[str, Any]) -> int: ...
+
+
+def append_metric(
+    hist: MutableMapping[str, list[Any]], key: str, value: Any
+) -> None: ...
+
+
+def last_glyph(nd: Mapping[str, Any]) -> str | None: ...
+
+
+def count_glyphs(
+    G: TNFRGraph, window: int | None = ..., *, last_only: bool = ...
+) -> Counter[str]: ...

tnfr/grammar.py

@@ -1,344 +1,25 @@
-"""Grammar rules."""
-
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import Any, Iterable, Optional, Callable
-
-from .constants import DEFAULTS, get_aliases, get_param
-from .alias import get_attr
-from .helpers.numeric import clamp01
-from .glyph_history import recent_glyph
-from .types import Glyph
-from .operators import apply_glyph  # avoid repeated import inside functions
-from .metrics.common import normalize_dnfr
-
-ALIAS_SI = get_aliases("SI")
-ALIAS_D2EPI = get_aliases("D2EPI")
-
-
-@dataclass
-class GrammarContext:
-    """Shared context for grammar helpers.
-
-    Collects graph-level settings to reduce positional parameters across
-    helper functions.
-    """
-
-    G: Any
-    cfg_soft: dict[str, Any]
-    cfg_canon: dict[str, Any]
-    norms: dict[str, Any]
-
-    @classmethod
-    def from_graph(cls, G: Any) -> "GrammarContext":
-        """Create a :class:`GrammarContext` for ``G``."""
-        return cls(
-            G=G,
-            cfg_soft=G.graph.get("GRAMMAR", DEFAULTS.get("GRAMMAR", {})),
-            cfg_canon=G.graph.get(
-                "GRAMMAR_CANON", DEFAULTS.get("GRAMMAR_CANON", {})
-            ),
-            norms=G.graph.get("_sel_norms") or {},
-        )
-
+"""Backwards compatibility layer for grammar helpers.
+
+The canonical implementations now live in :mod:`tnfr.validation`.  This
+module only re-exports them to avoid breaking external callers until the
+new import paths are fully adopted.
+"""
+
+from .validation.compatibility import CANON_COMPAT, CANON_FALLBACK
+from .validation.grammar import (
+    GrammarContext,
+    apply_glyph_with_grammar,
+    enforce_canonical_grammar,
+    on_applied_glyph,
+    _gram_state,
+)
 
-__all__ = (
+__all__ = [
+    "GrammarContext",
     "CANON_COMPAT",
     "CANON_FALLBACK",
     "enforce_canonical_grammar",
     "on_applied_glyph",
     "apply_glyph_with_grammar",
-    "GrammarContext",
-)
-
-# -------------------------
-# Per-node grammar state
-# -------------------------
-
-
-def _gram_state(nd: dict[str, Any]) -> dict[str, Any]:
-    """Create or return the node grammar state.
-
-    Fields:
-      - thol_open (bool)
-      - thol_len (int)
-    """
-    return nd.setdefault("_GRAM", {"thol_open": False, "thol_len": 0})
-
-
-# -------------------------
-# Canonical compatibilities (allowed next glyphs)
-# -------------------------
-CANON_COMPAT: dict[Glyph, set[Glyph]] = {
-    # Inicio / apertura
-    Glyph.AL: {Glyph.EN, Glyph.RA, Glyph.NAV, Glyph.VAL, Glyph.UM},
-    Glyph.EN: {Glyph.IL, Glyph.UM, Glyph.RA, Glyph.NAV},
-    # Estabilización / difusión / acople
-    Glyph.IL: {Glyph.RA, Glyph.VAL, Glyph.UM, Glyph.SHA},
-    Glyph.UM: {Glyph.RA, Glyph.IL, Glyph.VAL, Glyph.NAV},
-    Glyph.RA: {Glyph.IL, Glyph.VAL, Glyph.UM, Glyph.NAV},
-    Glyph.VAL: {Glyph.UM, Glyph.RA, Glyph.IL, Glyph.NAV},
-    # Disonancia → transición → mutación
-    Glyph.OZ: {Glyph.ZHIR, Glyph.NAV},
-    Glyph.ZHIR: {Glyph.IL, Glyph.NAV},
-    Glyph.NAV: {Glyph.OZ, Glyph.ZHIR, Glyph.RA, Glyph.IL, Glyph.UM},
-    # Cierres / latencias
-    Glyph.SHA: {Glyph.AL, Glyph.EN},
-    Glyph.NUL: {Glyph.AL, Glyph.IL},
-    # Bloques autoorganizativos
-    Glyph.THOL: {
-        Glyph.OZ,
-        Glyph.ZHIR,
-        Glyph.NAV,
-        Glyph.RA,
-        Glyph.IL,
-        Glyph.UM,
-        Glyph.SHA,
-        Glyph.NUL,
-    },
-}
-
-# Canonical fallbacks when a transition is not allowed
-CANON_FALLBACK: dict[Glyph, Glyph] = {
-    Glyph.AL: Glyph.EN,
-    Glyph.EN: Glyph.IL,
-    Glyph.IL: Glyph.RA,
-    Glyph.NAV: Glyph.RA,
-    Glyph.NUL: Glyph.AL,
-    Glyph.OZ: Glyph.ZHIR,
-    Glyph.RA: Glyph.IL,
-    Glyph.SHA: Glyph.AL,
-    Glyph.THOL: Glyph.NAV,
-    Glyph.UM: Glyph.RA,
-    Glyph.VAL: Glyph.RA,
-    Glyph.ZHIR: Glyph.IL,
-}
-
-
-def _coerce_glyph(val: Any) -> Glyph | Any:
-    """Return ``val`` as ``Glyph`` when possible."""
-    try:
-        return Glyph(val)
-    except (ValueError, TypeError):
-        return val
-
-
-def _glyph_fallback(cand_key: str, fallbacks: dict[str, Any]) -> Glyph | str:
-    """Determine fallback glyph for ``cand_key`` and return converted value."""
-    glyph_key = _coerce_glyph(cand_key)
-    canon_fb = (
-        CANON_FALLBACK.get(glyph_key, cand_key)
-        if isinstance(glyph_key, Glyph)
-        else cand_key
-    )
-    fb = fallbacks.get(cand_key, canon_fb)
-    return _coerce_glyph(fb)
-
-
-# -------------------------
-# THOL closures and ZHIR preconditions
-# -------------------------
-
-
-def get_norm(ctx: GrammarContext, key: str) -> float:
-    """Retrieve a global normalisation value from ``ctx.norms``."""
-    return float(ctx.norms.get(key, 1.0)) or 1.0
-
-
-def _norm_attr(ctx: GrammarContext, nd, attr_alias: str, norm_key: str) -> float:
-    """Normalise ``attr_alias`` using the global maximum ``norm_key``."""
-
-    max_val = get_norm(ctx, norm_key)
-    return clamp01(abs(get_attr(nd, attr_alias, 0.0)) / max_val)
-
-
-def _si(nd) -> float:
-    return clamp01(get_attr(nd, ALIAS_SI, 0.5))
-
-
-def _accel_norm(ctx: GrammarContext, nd) -> float:
-    """Normalise acceleration using the global maximum."""
-    return _norm_attr(ctx, nd, ALIAS_D2EPI, "accel_max")
-
-
-def _check_repeats(ctx: GrammarContext, n, cand: Glyph | str) -> Glyph | str:
-    """Avoid recent repetitions according to ``ctx.cfg_soft``."""
-    nd = ctx.G.nodes[n]
-    cfg = ctx.cfg_soft
-    gwin = int(cfg.get("window", 0))
-    avoid = set(cfg.get("avoid_repeats", []))
-    fallbacks = cfg.get("fallbacks", {})
-    cand_key = cand.value if isinstance(cand, Glyph) else str(cand)
-    if gwin > 0 and cand_key in avoid and recent_glyph(nd, cand_key, gwin):
-        return _glyph_fallback(cand_key, fallbacks)
-    return cand
-
-
-def _maybe_force(
-    ctx: GrammarContext,
-    n,
-    cand: Glyph | str,
-    original: Glyph | str,
-    accessor: Callable[[GrammarContext, dict[str, Any]], float],
-    key: str,
-) -> Glyph | str:
-    """Restore ``original`` if ``accessor`` exceeds ``key`` threshold."""
-    if cand == original:
-        return cand
-    force_th = float(ctx.cfg_soft.get(key, 0.60))
-    if accessor(ctx, ctx.G.nodes[n]) >= force_th:
-        return original
-    return cand
-
-
-def _check_oz_to_zhir(ctx: GrammarContext, n, cand: Glyph | str) -> Glyph | str:
-    nd = ctx.G.nodes[n]
-    cand_glyph = _coerce_glyph(cand)
-    if cand_glyph == Glyph.ZHIR:
-        cfg = ctx.cfg_canon
-        win = int(cfg.get("zhir_requires_oz_window", 3))
-        dn_min = float(cfg.get("zhir_dnfr_min", 0.05))
-        dnfr_max = get_norm(ctx, "dnfr_max")
-        if (
-            not recent_glyph(nd, Glyph.OZ, win)
-            and normalize_dnfr(nd, dnfr_max) < dn_min
-        ):
-            return Glyph.OZ
-    return cand
-
-
-def _check_thol_closure(
-    ctx: GrammarContext, n, cand: Glyph | str, st: dict[str, Any]
-) -> Glyph | str:
-    nd = ctx.G.nodes[n]
-    if st.get("thol_open", False):
-        st["thol_len"] = int(st.get("thol_len", 0)) + 1
-        cfg = ctx.cfg_canon
-        minlen = int(cfg.get("thol_min_len", 2))
-        maxlen = int(cfg.get("thol_max_len", 6))
-        close_dn = float(cfg.get("thol_close_dnfr", 0.15))
-        dnfr_max = get_norm(ctx, "dnfr_max")
-        if st["thol_len"] >= maxlen or (
-            st["thol_len"] >= minlen
-            and normalize_dnfr(nd, dnfr_max) <= close_dn
-        ):
-            return (
-                Glyph.NUL
-                if _si(nd) >= float(cfg.get("si_high", 0.66))
-                else Glyph.SHA
-            )
-    return cand
-
-
-def _check_compatibility(ctx: GrammarContext, n, cand: Glyph | str) -> Glyph | str:
-    nd = ctx.G.nodes[n]
-    hist = nd.get("glyph_history")
-    prev = hist[-1] if hist else None
-    prev_glyph = _coerce_glyph(prev)
-    cand_glyph = _coerce_glyph(cand)
-    if isinstance(prev_glyph, Glyph):
-        allowed = CANON_COMPAT.get(prev_glyph)
-        if allowed is None:
-            return cand
-        if isinstance(cand_glyph, Glyph):
-            if cand_glyph not in allowed:
-                return CANON_FALLBACK.get(prev_glyph, cand_glyph)
-        else:
-            return CANON_FALLBACK.get(prev_glyph, cand)
-    return cand
-
-
-# -------------------------
-# Core: enforce grammar on a candidate
-# -------------------------
-
-
-def enforce_canonical_grammar(
-    G, n, cand: Glyph | str, ctx: Optional[GrammarContext] = None
-) -> Glyph | str:
-    """Validate and adjust a candidate glyph according to canonical grammar.
-
-    Key rules:
-      - Repeat window with forces based on |ΔNFR| and acceleration.
-      - Transition compatibilities (TNFR path).
-      - OZ→ZHIR: mutation requires recent dissonance or high |ΔNFR|.
-      - THOL[...]: forces closure with SHA or NUL when the field stabilises
-        or block length is reached; maintains per-node state.
-
-    Returns the effective glyph to apply.
-    """
-    if ctx is None:
-        ctx = GrammarContext.from_graph(G)
-
-    nd = ctx.G.nodes[n]
-    st = _gram_state(nd)
-
-    raw_cand = cand
-    cand = _coerce_glyph(cand)
-    input_was_str = isinstance(raw_cand, str)
-
-    # 0) If glyphs outside the alphabet arrive, leave untouched
-    if not isinstance(cand, Glyph) or cand not in CANON_COMPAT:
-        return raw_cand if input_was_str else cand
-
-    original = cand
-    cand = _check_repeats(ctx, n, cand)
-
-    dnfr_accessor = lambda ctx, nd: normalize_dnfr(nd, get_norm(ctx, "dnfr_max"))
-    cand = _maybe_force(ctx, n, cand, original, dnfr_accessor, "force_dnfr")
-    cand = _maybe_force(ctx, n, cand, original, _accel_norm, "force_accel")
-    cand = _check_oz_to_zhir(ctx, n, cand)
-    cand = _check_thol_closure(ctx, n, cand, st)
-    cand = _check_compatibility(ctx, n, cand)
-
-    coerced_final = _coerce_glyph(cand)
-    if input_was_str:
-        if isinstance(coerced_final, Glyph):
-            return coerced_final.value
-        return str(cand)
-    return coerced_final if isinstance(coerced_final, Glyph) else cand
-
-
-# -------------------------
-# Post-selection: update grammar state
-# -------------------------
-
-
-def on_applied_glyph(G, n, applied: str) -> None:
-    nd = G.nodes[n]
-    st = _gram_state(nd)
-    if applied == Glyph.THOL:
-        st["thol_open"] = True
-        st["thol_len"] = 0
-    elif applied in (Glyph.SHA, Glyph.NUL):
-        st["thol_open"] = False
-        st["thol_len"] = 0
-
-
-# -------------------------
-# Direct application with canonical grammar
-# -------------------------
-
-
-def apply_glyph_with_grammar(
-    G,
-    nodes: Optional[Iterable[Any]],
-    glyph: Glyph | str,
-    window: Optional[int] = None,
-) -> None:
-    """Apply ``glyph`` to ``nodes`` enforcing the canonical grammar.
-
-    ``nodes`` may be a ``NodeView`` or any iterable. The iterable is consumed
-    directly to avoid unnecessary materialisation; callers must materialise if
-    they need indexing.
-    """
-    if window is None:
-        window = get_param(G, "GLYPH_HYSTERESIS_WINDOW")
-
-    g_str = glyph.value if isinstance(glyph, Glyph) else str(glyph)
-    iter_nodes = G.nodes() if nodes is None else nodes
-    ctx = GrammarContext.from_graph(G)
-    for n in iter_nodes:
-        g_eff = enforce_canonical_grammar(G, n, g_str, ctx)
-        apply_glyph(G, n, g_eff, window=window)
-        on_applied_glyph(G, n, g_eff)
+    "_gram_state",
+]

tnfr/grammar.pyi

@@ -0,0 +1,13 @@
+from typing import Any
+
+__all__: Any
+
+def __getattr__(name: str) -> Any: ...
+
+CANON_COMPAT: Any
+CANON_FALLBACK: Any
+GrammarContext: Any
+_gram_state: Any
+apply_glyph_with_grammar: Any
+enforce_canonical_grammar: Any
+on_applied_glyph: Any