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

tnfr/constants/__init__.py

@@ -0,0 +1,228 @@
+"""Shared constants."""
+
+from __future__ import annotations
+
+import copy
+from collections.abc import Mapping
+from types import MappingProxyType
+from typing import Callable, TypeVar, cast
+
+from .core import CORE_DEFAULTS, REMESH_DEFAULTS
+from .init import INIT_DEFAULTS
+from .metric import (
+    METRIC_DEFAULTS,
+    SIGMA,
+    TRACE,
+    METRICS,
+    GRAMMAR_CANON,
+    COHERENCE,
+    DIAGNOSIS,
+)
+
+from ..immutable import _is_immutable
+from ..types import GraphLike, TNFRConfigValue
+
+T = TypeVar("T")
+
+STATE_STABLE = "stable"
+STATE_TRANSITION = "transition"
+STATE_DISSONANT = "dissonant"
+
+CANONICAL_STATE_TOKENS = frozenset(
+    {STATE_STABLE, STATE_TRANSITION, STATE_DISSONANT}
+)
+
+def normalise_state_token(token: str) -> str:
+    """Return the canonical English token for ``token``.
+
+    The helper now enforces the English identifiers exclusively. Values that
+    do not match the canonical set raise :class:`ValueError` so callers can
+    surface explicit migration errors when legacy payloads are encountered.
+    """
+
+    if not isinstance(token, str):
+        raise TypeError("state token must be a string")
+
+    stripped = token.strip()
+    lowered = stripped.lower()
+
+    if stripped in CANONICAL_STATE_TOKENS:
+        return stripped
+
+    if lowered in CANONICAL_STATE_TOKENS:
+        return lowered
+
+    raise ValueError(
+        "state token must be one of 'stable', 'transition', or 'dissonant'"
+    )
+
+try:  # pragma: no cover - optional dependency
+    from ..utils import ensure_node_offset_map as _ensure_node_offset_map
+except ImportError:  # noqa: BLE001 - allow any import error
+    _ensure_node_offset_map = None
+
+ensure_node_offset_map: Callable[[GraphLike], None] | None = _ensure_node_offset_map
+
+# Exported sections
+DEFAULT_SECTIONS: Mapping[str, Mapping[str, TNFRConfigValue]] = MappingProxyType(
+    {
+        "core": CORE_DEFAULTS,
+        "init": INIT_DEFAULTS,
+        "remesh": REMESH_DEFAULTS,
+        "metric": METRIC_DEFAULTS,
+    }
+)
+
+# Combined exported dictionary
+# Merge the dictionaries from lowest to highest priority so that
+# ``METRIC_DEFAULTS`` overrides the rest, mirroring the previous ``ChainMap``
+# behaviour.
+DEFAULTS: Mapping[str, TNFRConfigValue] = MappingProxyType(
+    CORE_DEFAULTS | INIT_DEFAULTS | REMESH_DEFAULTS | METRIC_DEFAULTS
+)
+
+# -------------------------
+# Utilities
+# -------------------------
+
+
+def inject_defaults(
+    G: GraphLike,
+    defaults: Mapping[str, TNFRConfigValue] = DEFAULTS,
+    override: bool = False,
+) -> None:
+    """Inject ``defaults`` into ``G.graph``.
+
+    ``defaults`` is usually ``DEFAULTS``, combining all sub-dictionaries.
+    If ``override`` is ``True`` existing values are overwritten. Immutable
+    values (numbers, strings, tuples, etc.) are assigned directly. Tuples are
+    inspected recursively; if any element is mutable, a ``deepcopy`` is made
+    to avoid shared state.
+    """
+    G.graph.setdefault("_tnfr_defaults_attached", False)
+    for k, v in defaults.items():
+        if override or k not in G.graph:
+            G.graph[k] = (
+                v
+                if _is_immutable(v)
+                else cast(TNFRConfigValue, copy.deepcopy(v))
+            )
+    G.graph["_tnfr_defaults_attached"] = True
+    if ensure_node_offset_map is not None:
+        ensure_node_offset_map(G)
+
+
+def merge_overrides(G: GraphLike, **overrides: TNFRConfigValue) -> None:
+    """Apply specific changes to ``G.graph``.
+
+    Non-immutable values are deep-copied to avoid shared state with
+    :data:`DEFAULTS`.
+    """
+    for key, value in overrides.items():
+        if key not in DEFAULTS:
+            raise KeyError(f"Unknown parameter: '{key}'")
+        G.graph[key] = (
+            value
+            if _is_immutable(value)
+            else cast(TNFRConfigValue, copy.deepcopy(value))
+        )
+
+
+def get_param(G: GraphLike, key: str) -> TNFRConfigValue:
+    """Retrieve a parameter from ``G.graph`` or fall back to defaults."""
+    if key in G.graph:
+        return G.graph[key]
+    if key not in DEFAULTS:
+        raise KeyError(f"Unknown parameter: '{key}'")
+    return DEFAULTS[key]
+
+
+def get_graph_param(
+    G: GraphLike, key: str, cast: Callable[[object], T] = float
+) -> T | None:
+    """Return ``key`` from ``G.graph`` applying ``cast``.
+
+    The ``cast`` argument must be a function (e.g. ``float``, ``int``,
+    ``bool``). If the stored value is ``None`` it is returned without
+    casting.
+    """
+    val = get_param(G, key)
+    return None if val is None else cast(val)
+
+
+# Canonical keys with ASCII spellings
+VF_KEY = "νf"
+THETA_KEY = "theta"
+
+# Alias map for node attributes
+ALIASES: dict[str, tuple[str, ...]] = {
+    "VF": (VF_KEY, "nu_f", "nu-f", "nu", "freq", "frequency"),
+    "THETA": (THETA_KEY, "phase"),
+    "DNFR": ("ΔNFR", "delta_nfr", "dnfr"),
+    "EPI": ("EPI", "psi", "PSI", "value"),
+    "EPI_KIND": ("EPI_kind", "epi_kind", "source_glyph"),
+    "SI": ("Si", "sense_index", "S_i", "sense", "meaning_index"),
+    "DEPI": ("dEPI_dt", "dpsi_dt", "dEPI", "velocity"),
+    "D2EPI": ("d2EPI_dt2", "d2psi_dt2", "d2EPI", "accel"),
+    "DVF": ("dνf_dt", "dvf_dt", "dnu_dt", "dvf"),
+    "D2VF": ("d2νf_dt2", "d2vf_dt2", "d2nu_dt2", "B"),
+    "DSI": ("δSi", "delta_Si", "dSi"),
+}
+
+
+def get_aliases(key: str) -> tuple[str, ...]:
+    """Return alias tuple for canonical ``key``."""
+
+    return ALIASES[key]
+
+
+VF_PRIMARY = get_aliases("VF")[0]
+THETA_PRIMARY = get_aliases("THETA")[0]
+DNFR_PRIMARY = get_aliases("DNFR")[0]
+EPI_PRIMARY = get_aliases("EPI")[0]
+EPI_KIND_PRIMARY = get_aliases("EPI_KIND")[0]
+SI_PRIMARY = get_aliases("SI")[0]
+dEPI_PRIMARY = get_aliases("DEPI")[0]
+D2EPI_PRIMARY = get_aliases("D2EPI")[0]
+dVF_PRIMARY = get_aliases("DVF")[0]
+D2VF_PRIMARY = get_aliases("D2VF")[0]
+dSI_PRIMARY = get_aliases("DSI")[0]
+
+__all__ = (
+    "CORE_DEFAULTS",
+    "INIT_DEFAULTS",
+    "REMESH_DEFAULTS",
+    "METRIC_DEFAULTS",
+    "SIGMA",
+    "TRACE",
+    "METRICS",
+    "GRAMMAR_CANON",
+    "COHERENCE",
+    "DIAGNOSIS",
+    "DEFAULTS",
+    "DEFAULT_SECTIONS",
+    "ALIASES",
+    "inject_defaults",
+    "merge_overrides",
+    "get_param",
+    "get_graph_param",
+    "get_aliases",
+    "VF_KEY",
+    "THETA_KEY",
+    "VF_PRIMARY",
+    "THETA_PRIMARY",
+    "DNFR_PRIMARY",
+    "EPI_PRIMARY",
+    "EPI_KIND_PRIMARY",
+    "SI_PRIMARY",
+    "dEPI_PRIMARY",
+    "D2EPI_PRIMARY",
+    "dVF_PRIMARY",
+    "D2VF_PRIMARY",
+    "dSI_PRIMARY",
+    "STATE_STABLE",
+    "STATE_TRANSITION",
+    "STATE_DISSONANT",
+    "CANONICAL_STATE_TOKENS",
+    "normalise_state_token",
+)

tnfr/constants/__init__.pyi

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Callable, TypeVar
+
+from .core import CORE_DEFAULTS as CORE_DEFAULTS, REMESH_DEFAULTS as REMESH_DEFAULTS
+from .init import INIT_DEFAULTS as INIT_DEFAULTS
+from .metric import (
+    COHERENCE as COHERENCE,
+    DIAGNOSIS as DIAGNOSIS,
+    GRAMMAR_CANON as GRAMMAR_CANON,
+    METRICS as METRICS,
+    METRIC_DEFAULTS as METRIC_DEFAULTS,
+    SIGMA as SIGMA,
+    TRACE as TRACE,
+)
+from ..types import GraphLike, TNFRConfigValue
+
+T = TypeVar("T")
+
+__all__ = (
+    "CORE_DEFAULTS",
+    "INIT_DEFAULTS",
+    "REMESH_DEFAULTS",
+    "METRIC_DEFAULTS",
+    "SIGMA",
+    "TRACE",
+    "METRICS",
+    "GRAMMAR_CANON",
+    "COHERENCE",
+    "DIAGNOSIS",
+    "DEFAULTS",
+    "DEFAULT_SECTIONS",
+    "ALIASES",
+    "inject_defaults",
+    "merge_overrides",
+    "get_param",
+    "get_graph_param",
+    "get_aliases",
+    "VF_KEY",
+    "THETA_KEY",
+    "VF_PRIMARY",
+    "THETA_PRIMARY",
+    "DNFR_PRIMARY",
+    "EPI_PRIMARY",
+    "EPI_KIND_PRIMARY",
+    "SI_PRIMARY",
+    "dEPI_PRIMARY",
+    "D2EPI_PRIMARY",
+    "dVF_PRIMARY",
+    "D2VF_PRIMARY",
+    "dSI_PRIMARY",
+    "STATE_STABLE",
+    "STATE_TRANSITION",
+    "STATE_DISSONANT",
+    "CANONICAL_STATE_TOKENS",
+    "normalise_state_token",
+)
+
+ensure_node_offset_map: Callable[[GraphLike], None] | None
+DEFAULT_SECTIONS: Mapping[str, Mapping[str, TNFRConfigValue]]
+DEFAULTS: Mapping[str, TNFRConfigValue]
+ALIASES: dict[str, tuple[str, ...]]
+VF_KEY: str
+THETA_KEY: str
+VF_PRIMARY: str
+THETA_PRIMARY: str
+DNFR_PRIMARY: str
+EPI_PRIMARY: str
+EPI_KIND_PRIMARY: str
+SI_PRIMARY: str
+dEPI_PRIMARY: str
+D2EPI_PRIMARY: str
+dVF_PRIMARY: str
+D2VF_PRIMARY: str
+dSI_PRIMARY: str
+STATE_STABLE: str
+STATE_TRANSITION: str
+STATE_DISSONANT: str
+CANONICAL_STATE_TOKENS: frozenset[str]
+
+
+def inject_defaults(
+    G: GraphLike,
+    defaults: Mapping[str, TNFRConfigValue] = ...,
+    override: bool = ...,
+) -> None: ...
+
+
+def merge_overrides(G: GraphLike, **overrides: TNFRConfigValue) -> None: ...
+
+
+def get_param(G: GraphLike, key: str) -> TNFRConfigValue: ...
+
+
+def get_graph_param(
+    G: GraphLike, key: str, cast: Callable[[object], T] = ...
+) -> T | None: ...
+
+
+def get_aliases(key: str) -> tuple[str, ...]: ...
+
+
+def normalise_state_token(token: str) -> str: ...

tnfr/constants/core.py

@@ -0,0 +1,158 @@
+"""Core constants."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict, field
+from typing import Any, Mapping
+from types import MappingProxyType
+
+
+SELECTOR_THRESHOLD_DEFAULTS: Mapping[str, float] = MappingProxyType(
+    {
+        "si_hi": 0.66,
+        "si_lo": 0.33,
+        "dnfr_hi": 0.50,
+        "dnfr_lo": 0.10,
+        "accel_hi": 0.50,
+        "accel_lo": 0.10,
+    }
+)
+
+
+@dataclass(frozen=True, slots=True)
+class CoreDefaults:
+    """Default parameters for the core engine.
+
+    The fields are exported via :data:`CORE_DEFAULTS` and may therefore appear
+    unused to static analysis tools such as Vulture.
+    """
+
+    DT: float = 1.0
+    INTEGRATOR_METHOD: str = "euler"
+    DT_MIN: float = 0.1
+    EPI_MIN: float = -1.0
+    EPI_MAX: float = 1.0
+    VF_MIN: float = 0.0
+    VF_MAX: float = 1.0
+    THETA_WRAP: bool = True
+    DNFR_WEIGHTS: dict[str, float] = field(
+        default_factory=lambda: {
+            "phase": 0.34,
+            "epi": 0.33,
+            "vf": 0.33,
+            "topo": 0.0,
+        }
+    )
+    SI_WEIGHTS: dict[str, float] = field(
+        default_factory=lambda: {"alpha": 0.34, "beta": 0.33, "gamma": 0.33}
+    )
+    PHASE_K_GLOBAL: float = 0.05
+    PHASE_K_LOCAL: float = 0.15
+    PHASE_ADAPT: dict[str, Any] = field(
+        default_factory=lambda: {
+            "enabled": True,
+            "R_hi": 0.90,
+            "R_lo": 0.60,
+            "disr_hi": 0.50,
+            "disr_lo": 0.25,
+            "kG_min": 0.01,
+            "kG_max": 0.20,
+            "kL_min": 0.05,
+            "kL_max": 0.25,
+            "up": 0.10,
+            "down": 0.07,
+        }
+    )
+    UM_COMPAT_THRESHOLD: float = 0.75
+    UM_CANDIDATE_MODE: str = "sample"
+    UM_CANDIDATE_COUNT: int = 0
+    GLYPH_HYSTERESIS_WINDOW: int = 7
+    AL_MAX_LAG: int = 5
+    EN_MAX_LAG: int = 3
+    GLYPH_SELECTOR_MARGIN: float = 0.05
+    VF_ADAPT_TAU: int = 5
+    VF_ADAPT_MU: float = 0.1
+    GLYPH_FACTORS: dict[str, float] = field(
+        default_factory=lambda: {
+            "AL_boost": 0.05,
+            "EN_mix": 0.25,
+            "IL_dnfr_factor": 0.7,
+            "OZ_dnfr_factor": 1.3,
+            "UM_theta_push": 0.25,
+            "RA_epi_diff": 0.15,
+            "SHA_vf_factor": 0.85,
+            "VAL_scale": 1.15,
+            "NUL_scale": 0.85,
+            "THOL_accel": 0.10,
+            "ZHIR_theta_shift": 1.57079632679,
+            "NAV_jitter": 0.05,
+            "NAV_eta": 0.5,
+            "REMESH_alpha": 0.5,
+        }
+    )
+    GLYPH_THRESHOLDS: dict[str, float] = field(
+        default_factory=lambda: {"hi": 0.66, "lo": 0.33, "dnfr": 1e-3}
+    )
+    NAV_RANDOM: bool = True
+    NAV_STRICT: bool = False
+    RANDOM_SEED: int = 0
+    JITTER_CACHE_SIZE: int = 256
+    OZ_NOISE_MODE: bool = False
+    OZ_SIGMA: float = 0.1
+    GRAMMAR: dict[str, Any] = field(
+        default_factory=lambda: {
+            "window": 3,
+            "avoid_repeats": ["ZHIR", "OZ", "THOL"],
+            "force_dnfr": 0.60,
+            "force_accel": 0.60,
+            "fallbacks": {"ZHIR": "NAV", "OZ": "ZHIR", "THOL": "NAV"},
+        }
+    )
+    SELECTOR_WEIGHTS: dict[str, float] = field(
+        default_factory=lambda: {"w_si": 0.5, "w_dnfr": 0.3, "w_accel": 0.2}
+    )
+    SELECTOR_THRESHOLDS: dict[str, float] = field(
+        default_factory=lambda: dict(SELECTOR_THRESHOLD_DEFAULTS)
+    )
+    GAMMA: dict[str, Any] = field(
+        default_factory=lambda: {"type": "none", "beta": 0.0, "R0": 0.0}
+    )
+    CALLBACKS_STRICT: bool = False
+    VALIDATORS_STRICT: bool = False
+    PROGRAM_TRACE_MAXLEN: int = 50
+    HISTORY_MAXLEN: int = 0
+
+
+@dataclass(frozen=True, slots=True)
+class RemeshDefaults:
+    """Default parameters for the remeshing subsystem.
+
+    As with :class:`CoreDefaults`, the fields are exported via
+    :data:`REMESH_DEFAULTS` and may look unused to static analysers.
+    """
+
+    EPS_DNFR_STABLE: float = 1e-3
+    EPS_DEPI_STABLE: float = 1e-3
+    FRACTION_STABLE_REMESH: float = 0.80
+    REMESH_COOLDOWN_WINDOW: int = 20
+    REMESH_COOLDOWN_TS: float = 0.0
+    REMESH_REQUIRE_STABILITY: bool = True
+    REMESH_STABILITY_WINDOW: int = 25
+    REMESH_MIN_PHASE_SYNC: float = 0.85
+    REMESH_MAX_GLYPH_DISR: float = 0.35
+    REMESH_MIN_SIGMA_MAG: float = 0.50
+    REMESH_MIN_KURAMOTO_R: float = 0.80
+    REMESH_MIN_SI_HI_FRAC: float = 0.50
+    REMESH_LOG_EVENTS: bool = True
+    REMESH_MODE: str = "knn"
+    REMESH_COMMUNITY_K: int = 2
+    REMESH_TAU_GLOBAL: int = 8
+    REMESH_TAU_LOCAL: int = 4
+    REMESH_ALPHA: float = 0.5
+    REMESH_ALPHA_HARD: bool = False
+
+_core_defaults = asdict(CoreDefaults())
+_remesh_defaults = asdict(RemeshDefaults())
+
+CORE_DEFAULTS = MappingProxyType(_core_defaults)
+REMESH_DEFAULTS = MappingProxyType(_remesh_defaults)

tnfr/constants/core.pyi

@@ -0,0 +1,17 @@
+from typing import Any
+
+__all__: Any
+
+def __getattr__(name: str) -> Any: ...
+
+CORE_DEFAULTS: Any
+CoreDefaults: Any
+Mapping: Any
+MappingProxyType: Any
+REMESH_DEFAULTS: Any
+RemeshDefaults: Any
+SELECTOR_THRESHOLD_DEFAULTS: Any
+annotations: Any
+asdict: Any
+dataclass: Any
+field: Any

tnfr/constants/init.py

@@ -0,0 +1,31 @@
+"""Initialization constants."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+import math
+
+
+@dataclass(frozen=True, slots=True)
+class InitDefaults:
+    """Default parameters for node initialisation.
+
+    The fields are collected into :data:`INIT_DEFAULTS` and may therefore
+    appear unused to tools like Vulture.
+    """
+
+    INIT_RANDOM_PHASE: bool = True
+    INIT_THETA_MIN: float = -math.pi
+    INIT_THETA_MAX: float = math.pi
+    INIT_VF_MODE: str = "uniform"
+    INIT_VF_MIN: float | None = None
+    INIT_VF_MAX: float | None = None
+    INIT_VF_MEAN: float = 0.5
+    INIT_VF_STD: float = 0.15
+    INIT_VF_CLAMP_TO_LIMITS: bool = True
+    INIT_SI_MIN: float = 0.4
+    INIT_SI_MAX: float = 0.7
+    INIT_EPI_VALUE: float = 0.0
+
+
+INIT_DEFAULTS = asdict(InitDefaults())

tnfr/constants/init.pyi

@@ -0,0 +1,12 @@
+from typing import Any
+
+__all__: Any
+
+def __getattr__(name: str) -> Any: ...
+
+INIT_DEFAULTS: Any
+InitDefaults: Any
+annotations: Any
+asdict: Any
+dataclass: Any
+math: Any

tnfr/constants/metric.py

@@ -0,0 +1,102 @@
+"""Metric constants."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict, field
+from typing import Any
+from types import MappingProxyType
+
+
+@dataclass(frozen=True, slots=True)
+class MetricDefaults:
+    """Default parameters for metric computation.
+
+    The fields are gathered into :data:`METRIC_DEFAULTS` and exposed through
+    read-only views below, so they may appear unused to static analysis tools.
+    """
+
+    PHASE_HISTORY_MAXLEN: int = 50
+    STOP_EARLY: dict[str, Any] = field(
+        default_factory=lambda: {
+            "enabled": False,
+            "window": 25,
+            "fraction": 0.90,
+        }
+    )
+    SIGMA: dict[str, Any] = field(
+        default_factory=lambda: {
+            "enabled": True,
+            "weight": "Si",  # "Si" | "EPI" | "1"
+            "smooth": 0.0,  # EMA sobre el vector global (0=off)
+            "history_key": "sigma_global",
+            "per_node": False,
+        }
+    )
+    TRACE: dict[str, Any] = field(
+        default_factory=lambda: {
+            "enabled": True,
+            "verbosity": "debug",
+            "history_key": "trace_meta",
+        }
+    )
+    METRICS: dict[str, Any] = field(
+        default_factory=lambda: {
+            "enabled": True,
+            "save_by_node": True,
+            "normalize_series": False,
+            "n_jobs": 1,
+            "verbosity": "debug",
+        }
+    )
+    GRAMMAR_CANON: dict[str, Any] = field(
+        default_factory=lambda: {
+            "enabled": True,
+            "zhir_requires_oz_window": 3,
+            "zhir_dnfr_min": 0.05,
+            "thol_min_len": 2,
+            "thol_max_len": 6,
+            "thol_close_dnfr": 0.15,
+            "si_high": 0.66,
+        }
+    )
+    COHERENCE: dict[str, Any] = field(
+        default_factory=lambda: {
+            "enabled": True,
+            "scope": "neighbors",
+            "weights": {"phase": 0.34, "epi": 0.33, "vf": 0.20, "si": 0.13},
+            "self_on_diag": True,
+            "store_mode": "sparse",
+            "threshold": 0.0,
+            "n_jobs": 1,
+            "history_key": "W_sparse",
+            "Wi_history_key": "W_i",
+            "stats_history_key": "W_stats",
+        }
+    )
+    DIAGNOSIS: dict[str, Any] = field(
+        default_factory=lambda: {
+            "enabled": True,
+            "window": 16,
+            "history_key": "nodal_diag",
+            "stable": {"Rloc_hi": 0.80, "dnfr_lo": 0.20, "persist": 3},
+            "dissonance": {"Rloc_lo": 0.40, "dnfr_hi": 0.50, "persist": 3},
+            "transition": {"persist": 2},
+            "compute_symmetry": True,
+            "include_typology": False,
+            "advice": {
+                "stable": ["Coherence", "Coupling", "Resonance"],
+                "transition": ["Transition", "Resonance", "Self-organisation"],
+                "dissonant": ["Silence", "Contraction", "Mutation"],
+            },
+        }
+    )
+
+
+METRIC_DEFAULTS = asdict(MetricDefaults())
+
+SIGMA = MappingProxyType(METRIC_DEFAULTS["SIGMA"])
+TRACE = MappingProxyType(METRIC_DEFAULTS["TRACE"])
+METRICS = MappingProxyType(METRIC_DEFAULTS["METRICS"])
+GRAMMAR_CANON = MappingProxyType(METRIC_DEFAULTS["GRAMMAR_CANON"])
+COHERENCE = MappingProxyType(METRIC_DEFAULTS["COHERENCE"])
+DIAGNOSIS = MappingProxyType(METRIC_DEFAULTS["DIAGNOSIS"])

tnfr/constants/metric.pyi

@@ -0,0 +1,19 @@
+from typing import Any
+
+__all__: Any
+
+def __getattr__(name: str) -> Any: ...
+
+COHERENCE: Any
+DIAGNOSIS: Any
+GRAMMAR_CANON: Any
+METRICS: Any
+METRIC_DEFAULTS: Any
+MappingProxyType: Any
+MetricDefaults: Any
+SIGMA: Any
+TRACE: Any
+annotations: Any
+asdict: Any
+dataclass: Any
+field: Any

tnfr/constants_glyphs.py

@@ -0,0 +1,16 @@
+"""Backward compatibility shim for glyph constants."""
+
+from __future__ import annotations
+
+import warnings
+
+from .config.constants import *  # noqa: F401,F403 - re-export legacy API
+from .config.constants import __all__ as _CONFIG_ALL
+
+warnings.warn(
+    "'tnfr.constants_glyphs' is deprecated; use 'tnfr.config.constants' instead",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+__all__ = _CONFIG_ALL