tnfr 3.5.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

tnfr/sense.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+from typing import Dict, Any, List, Tuple
+import math
+from collections import Counter
+
+from .constants import DEFAULTS, ALIAS_SI, ALIAS_EPI
+from .helpers import _get_attr, clamp01, register_callback
+
+# -------------------------
+# Canon: orden circular de glifos y ángulos
+# -------------------------
+GLYPHS_CANONICAL: List[str] = [
+    "A’L",  # 0
+    "E’N",  # 1
+    "I’L",  # 2
+    "U’M",  # 3
+    "R’A",  # 4
+    "VA’L", # 5
+    "O’Z",  # 6
+    "Z’HIR",# 7
+    "NA’V", # 8
+    "T’HOL",# 9
+    "NU’L", #10
+    "SH’A", #11
+    "RE’MESH" #12
+]
+
+_SIGMA_ANGLES: Dict[str, float] = {g: (2.0*math.pi * i / len(GLYPHS_CANONICAL)) for i, g in enumerate(GLYPHS_CANONICAL)}
+
+# -------------------------
+# Config por defecto
+# -------------------------
+DEFAULTS.setdefault("SIGMA", {
+    "enabled": True,
+    "weight": "Si",      # "Si" | "EPI" | "1"
+    "smooth": 0.0,        # EMA sobre el vector global (0=off)
+    "history_key": "sigma_global",   # dónde guardar en G.graph['history']
+    "per_node": False,    # si True, guarda trayectoria σ por nodo (más pesado)
+})
+
+# -------------------------
+# Utilidades básicas
+# -------------------------
+
+def glyph_angle(g: str) -> float:
+    return float(_SIGMA_ANGLES.get(g, 0.0))
+
+
+def glyph_unit(g: str) -> complex:
+    a = glyph_angle(g)
+    return complex(math.cos(a), math.sin(a))
+
+
+def _weight(G, n, mode: str) -> float:
+    nd = G.nodes[n]
+    if mode == "Si":
+        return clamp01(_get_attr(nd, ALIAS_SI, 0.5))
+    if mode == "EPI":
+        return max(0.0, float(_get_attr(nd, ALIAS_EPI, 0.0)))
+    return 1.0
+
+
+def _last_glifo(nd: Dict[str, Any]) -> str | None:
+    hist = nd.get("hist_glifos")
+    if not hist:
+        return None
+    try:
+        return list(hist)[-1]
+    except Exception:
+        return None
+
+
+# -------------------------
+# σ por nodo y σ global
+# -------------------------
+
+def sigma_vector_node(G, n, weight_mode: str | None = None) -> Dict[str, float] | None:
+    nd = G.nodes[n]
+    g = _last_glifo(nd)
+    if g is None:
+        return None
+    w = _weight(G, n, weight_mode or G.graph.get("SIGMA", DEFAULTS["SIGMA"]).get("weight", "Si"))
+    z = glyph_unit(g) * w
+    x, y = z.real, z.imag
+    mag = math.hypot(x, y)
+    ang = math.atan2(y, x) if mag > 0 else glyph_angle(g)
+    return {"x": float(x), "y": float(y), "mag": float(mag), "angle": float(ang), "glifo": g, "w": float(w)}
+
+
+def sigma_vector_global(G, weight_mode: str | None = None) -> Dict[str, float]:
+    """Vector global del plano del sentido σ.
+
+    Mapea el último glifo de cada nodo a un vector unitario en S¹, ponderado
+    por `Si` (o `EPI`/1), y promedia para obtener:
+      - componentes (x, y), magnitud |σ| y ángulo arg(σ).
+
+    Interpretación TNFR: |σ| mide cuán alineada está la red en su
+    **recorrido glífico**; arg(σ) indica la **dirección funcional** dominante
+    (p. ej., torno a I’L/RA para consolidación/distribución, O’Z/Z’HIR para cambio).
+    """
+    cfg = G.graph.get("SIGMA", DEFAULTS["SIGMA"])
+    weight_mode = weight_mode or cfg.get("weight", "Si")
+    acc = complex(0.0, 0.0)
+    cnt = 0
+    for n in G.nodes():
+        v = sigma_vector_node(G, n, weight_mode)
+        if v is None:
+            continue
+        acc += complex(v["x"], v["y"])
+        cnt += 1
+    if cnt == 0:
+        return {"x": 1.0, "y": 0.0, "mag": 1.0, "angle": 0.0, "n": 0}
+    x, y = acc.real / max(1, cnt), acc.imag / max(1, cnt)
+    mag = math.hypot(x, y)
+    ang = math.atan2(y, x)
+    return {"x": float(x), "y": float(y), "mag": float(mag), "angle": float(ang), "n": cnt}
+
+
+# -------------------------
+# Historia / series
+# -------------------------
+
+def _ensure_history(G):
+    if "history" not in G.graph:
+        G.graph["history"] = {}
+    return G.graph["history"]
+
+
+def push_sigma_snapshot(G, t: float | None = None) -> None:
+    cfg = G.graph.get("SIGMA", DEFAULTS["SIGMA"])
+    if not cfg.get("enabled", True):
+        return
+    hist = _ensure_history(G)
+    key = cfg.get("history_key", "sigma_global")
+
+    # Global
+    sv = sigma_vector_global(G, cfg.get("weight", "Si"))
+
+    # Suavizado exponencial (EMA) opcional
+    alpha = float(cfg.get("smooth", 0.0))
+    if alpha > 0 and hist.get(key):
+        prev = hist[key][-1]
+        x = (1-alpha)*prev["x"] + alpha*sv["x"]
+        y = (1-alpha)*prev["y"] + alpha*sv["y"]
+        mag = math.hypot(x, y)
+        ang = math.atan2(y, x)
+        sv = {"x": x, "y": y, "mag": mag, "angle": ang, "n": sv.get("n", 0)}
+
+    sv["t"] = float(G.graph.get("_t", 0.0) if t is None else t)
+
+    hist.setdefault(key, []).append(sv)
+
+    # Conteo de glifos por paso (útil para rosa glífica)
+    counts = Counter()
+    for n in G.nodes():
+        g = _last_glifo(G.nodes[n])
+        if g:
+            counts[g] += 1
+    hist.setdefault("sigma_counts", []).append({"t": sv["t"], **counts})
+
+    # Trayectoria por nodo (opcional)
+    if cfg.get("per_node", False):
+        per = hist.setdefault("sigma_per_node", {})
+        for n in G.nodes():
+            nd = G.nodes[n]
+            g = _last_glifo(nd)
+            if not g:
+                continue
+            a = glyph_angle(g)
+            d = per.setdefault(n, [])
+            d.append({"t": sv["t"], "g": g, "angle": a})
+
+
+# -------------------------
+# Registro como callback automático (after_step)
+# -------------------------
+
+def register_sigma_callback(G) -> None:
+    register_callback(G, when="after_step", func=push_sigma_snapshot, name="sigma_snapshot")
+
+
+# -------------------------
+# Series de utilidad
+# -------------------------
+
+def sigma_series(G, key: str | None = None) -> Dict[str, List[float]]:
+    cfg = G.graph.get("SIGMA", DEFAULTS["SIGMA"])
+    key = key or cfg.get("history_key", "sigma_global")
+    hist = G.graph.get("history", {})
+    xs = hist.get(key, [])
+    if not xs:
+        return {"t": [], "angle": [], "mag": []}
+    return {
+        "t": [float(x.get("t", i)) for i, x in enumerate(xs)],
+        "angle": [float(x["angle"]) for x in xs],
+        "mag": [float(x["mag"]) for x in xs],
+    }
+
+
+def sigma_rose(G, steps: int | None = None) -> Dict[str, int]:
+    """Histograma de glifos en los últimos `steps` pasos (o todos)."""
+    hist = G.graph.get("history", {})
+    counts = hist.get("sigma_counts", [])
+    if not counts:
+        return {g: 0 for g in GLYPHS_CANONICAL}
+    if steps is None or steps >= len(counts):
+        agg = Counter()
+        for row in counts:
+            agg.update({k: v for k, v in row.items() if k != "t"})
+        out = {g: int(agg.get(g, 0)) for g in GLYPHS_CANONICAL}
+        return out
+    agg = Counter()
+    for row in counts[-int(steps):]:
+        agg.update({k: v for k, v in row.items() if k != "t"})
+    return {g: int(agg.get(g, 0)) for g in GLYPHS_CANONICAL}

tnfr/trace.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+from typing import Any, Dict, List, Optional
+from collections import Counter
+
+from .constants import DEFAULTS
+from .helpers import register_callback
+
+try:
+    from .gamma import kuramoto_R_psi
+except Exception:  # pragma: no cover
+    def kuramoto_R_psi(G):
+        return 0.0, 0.0
+
+try:
+    from .sense import sigma_vector_global
+except Exception:  # pragma: no cover
+    def sigma_vector_global(G, *args, **kwargs):
+        return {"x": 1.0, "y": 0.0, "mag": 1.0, "angle": 0.0, "n": 0}
+
+# -------------------------
+# Defaults
+# -------------------------
+DEFAULTS.setdefault("TRACE", {
+    "enabled": True,
+    "capture": ["gamma", "grammar", "selector", "dnfr_mix", "callbacks", "thol_state", "sigma", "kuramoto", "glifo_counts"],
+    "history_key": "trace_meta",
+})
+
+# -------------------------
+# Helpers
+# -------------------------
+
+def _ensure_history(G):
+    if "history" not in G.graph:
+        G.graph["history"] = {}
+    return G.graph["history"]
+
+
+def _last_glifo(nd: Dict[str, Any]) -> str | None:
+    h = nd.get("hist_glifos")
+    if not h:
+        return None
+    try:
+        return list(h)[-1]
+    except Exception:
+        return None
+
+
+# -------------------------
+# Snapshots
+# -------------------------
+
+def _trace_before(G, *args, **kwargs):
+    if not G.graph.get("TRACE", DEFAULTS["TRACE"]).get("enabled", True):
+        return
+    cfg = G.graph.get("TRACE", DEFAULTS["TRACE"])
+    capture: List[str] = list(cfg.get("capture", []))
+    hist = _ensure_history(G)
+    key = cfg.get("history_key", "trace_meta")
+
+    meta: Dict[str, Any] = {"t": float(G.graph.get("_t", 0.0)), "phase": "before"}
+
+    if "gamma" in capture:
+        meta["gamma"] = dict(G.graph.get("GAMMA", {}))
+
+    if "grammar" in capture:
+        meta["grammar"] = dict(G.graph.get("GRAMMAR_CANON", {}))
+
+    if "selector" in capture:
+        sel = G.graph.get("glyph_selector")
+        meta["selector"] = getattr(sel, "__name__", str(sel)) if sel else None
+
+    if "dnfr_mix" in capture:
+        # tratar de capturar varias convenciones posibles
+        mix = G.graph.get("DNFR_MIX") or G.graph.get("DELTA_NFR_MIX") or G.graph.get("NFR_MIX")
+        meta["dnfr_mix"] = mix if isinstance(mix, dict) else {"value": mix}
+
+    if "callbacks" in capture:
+        # si el motor guarda los callbacks, exponer nombres por fase
+        cb = G.graph.get("_callbacks")
+        if isinstance(cb, dict):
+            out = {k: [getattr(f, "__name__", "fn") for (_, f, *_rest) in v] if isinstance(v, list) else None for k, v in cb.items()}
+            meta["callbacks"] = out
+
+    if "thol_state" in capture:
+        # cuántos nodos tienen bloque T’HOL abierto
+        th_open = 0
+        for n in G.nodes():
+            st = G.nodes[n].get("_GRAM", {})
+            if st.get("thol_open", False):
+                th_open += 1
+        meta["thol_open_nodes"] = th_open
+
+    hist.setdefault(key, []).append(meta)
+
+
+def _trace_after(G, *args, **kwargs):
+    if not G.graph.get("TRACE", DEFAULTS["TRACE"]).get("enabled", True):
+        return
+    cfg = G.graph.get("TRACE", DEFAULTS["TRACE"])
+    capture: List[str] = list(cfg.get("capture", []))
+    hist = _ensure_history(G)
+    key = cfg.get("history_key", "trace_meta")
+
+    meta: Dict[str, Any] = {"t": float(G.graph.get("_t", 0.0)), "phase": "after"}
+
+    if "kuramoto" in capture:
+        R, psi = kuramoto_R_psi(G)
+        meta["kuramoto"] = {"R": float(R), "psi": float(psi)}
+
+    if "sigma" in capture:
+        sv = sigma_vector_global(G)
+        meta["sigma"] = {"x": float(sv.get("x", 1.0)), "y": float(sv.get("y", 0.0)), "mag": float(sv.get("mag", 1.0)), "angle": float(sv.get("angle", 0.0))}
+
+    if "glifo_counts" in capture:
+        cnt = Counter()
+        for n in G.nodes():
+            g = _last_glifo(G.nodes[n])
+            if g:
+                cnt[g] += 1
+        meta["glifos"] = dict(cnt)
+
+    hist.setdefault(key, []).append(meta)
+
+
+# -------------------------
+# API
+# -------------------------
+
+def register_trace(G) -> None:
+    """Activa snapshots before/after step y vuelca metadatos operativos en history.
+
+    Guarda en G.graph['history'][TRACE.history_key] una lista de entradas {'phase': 'before'|'after', ...} con:
+      - gamma: especificación activa de Γi(R)
+      - grammar: configuración de gramática canónica
+      - selector: nombre del selector glífico
+      - dnfr_mix: mezcla (si el motor la expone en G.graph)
+      - callbacks: callbacks registrados por fase (si están en G.graph['_callbacks'])
+      - thol_open_nodes: cuántos nodos tienen bloque T’HOL abierto
+      - kuramoto: (R, ψ) de la red
+      - sigma: vector global del plano del sentido
+      - glifos: conteos por glifo tras el paso
+    """
+    register_callback(G, when="before_step", func=_trace_before, name="trace_before")
+    register_callback(G, when="after_step", func=_trace_after, name="trace_after")

tnfr/types.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Dict, Any
+
+
+@dataclass
+class NodeState:
+    EPI: float = 0.0
+    vf: float = 1.0   # νf
+    theta: float = 0.0  # θ
+    Si: float = 0.5
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+    def to_attrs(self) -> Dict[str, Any]:
+        d = {"EPI": self.EPI, "νf": self.vf, "θ": self.theta, "Si": self.Si}
+        d.update(self.extra)
+        return d

{tnfr-3.5.0.dist-info → tnfr-4.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tnfr
-Version: 3.5.0
+Version: 4.0.0
 Summary: TNFR canónica: dinámica glífica modular sobre redes.
 Author: fmg
 License: MIT
@@ -81,6 +81,9 @@ Dynamic: license-file
 
 **Mastering these pieces will let you extend the simulation, build analysis pipelines and connect the theory with computational applications.**
 
+## Optional Node environment
+The repository includes a minimal `package.json` and `netlify.toml` used for an experimental Remix web demo. They are not required for the core Python package; feel free to ignore them unless you plan to build the demo via `npm run build`.
+
 ## Testing
 
 Install the dependencies and project in editable mode before running the test suite with `pytest`:
@@ -89,4 +92,10 @@ Install the dependencies and project in editable mode before running the test su
 pip install networkx
 pip install -e .
 pytest
+
+```
+
+## Installation
+```
+pip install tnfr
 ```

tnfr-4.0.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+tnfr/__init__.py,sha256=nN8P2Xm26kvJvqDhmRITnimew3SgBgw4fSUHPOAiYts,1880
+tnfr/cli.py,sha256=fdzmIOVerg6J1j6cBuu7m2-nKFG_WqiNu-e2Wg8eECQ,5980
+tnfr/constants.py,sha256=PUhps2gBXeh_rJIrCF9HpWRdi02sfRXvVp066AOgkyQ,8912
+tnfr/dynamics.py,sha256=FeFv7h4m9e8qhbU9tIRss3K6P2uz4Hfmtbldf2AhfyQ,25286
+tnfr/gamma.py,sha256=1hGqYTBYIYirgmSSSbvSuFWPVy_KGzPNH3eD7wmRUu0,2689
+tnfr/grammar.py,sha256=X50-BzTzaYkFIi-ljcgB_XXC6c2srvqzDqOKa91nsuA,5090
+tnfr/helpers.py,sha256=foJgwyC__6lQeOpPY02slFRggY3tCy1CxeFlEQcI-gY,7014
+tnfr/main.py,sha256=XqjI1YEdF-OqRzTMa5dYIxCig4qyAR-l1FPcyxpC8WY,1926
+tnfr/metrics.py,sha256=XusywHo1-GgLqYy1Jz43Xc4zRsggrn_DwoaFWfAy82M,6640
+tnfr/observers.py,sha256=PTw3hxk7KD-Yx_CvCIU09icuhyYD6uNU6SvF80UvP-Y,5354
+tnfr/ontosim.py,sha256=9GfEtiLIdJOPJUTufcq_MssAA9J8AfChHU6HKb3DIJY,5628
+tnfr/operators.py,sha256=Q2QvtK2oQUuMsq_CPdfaK9eCrhniI1NaWEfwQH08zSk,12936
+tnfr/presets.py,sha256=vaqgqz1pVU93hEOITQn-2CUGfMbN2n47A9GBFmjWRpo,661
+tnfr/program.py,sha256=qGqj74qBqXILm-Yrw73__0uIlx2gJiSF9dDHxOGTbCs,5798
+tnfr/scenarios.py,sha256=FgsXzA6ENRkalENnG5ZuBNFguEGaKZTM6y0quW5fJI4,808
+tnfr/sense.py,sha256=1yVlphcs4o_uOQ51MDqW9dphydMiDNKv1Z1EdgbJgpU,6778
+tnfr/trace.py,sha256=YtqSKJM2tCH5eLa22nObPLnYgsn4Bm6inipY0n_mwXY,4887
+tnfr/types.py,sha256=xyFHp0PptEqPNUekAFH6DcAnyMx4bCQutMyFUXMd2sA,457
+tnfr-4.0.0.dist-info/licenses/LICENSE.md,sha256=SRvvhXLrKtseuK6DARbuJffuXOXqAyk3wvF2n0t1SWA,1109
+tnfr-4.0.0.dist-info/METADATA,sha256=xzcC2N34E82NmkgYly3jpfgzLVgI9fQLNnMiXLWk2RQ,5898
+tnfr-4.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tnfr-4.0.0.dist-info/entry_points.txt,sha256=j4-QRHqeT2WnchHe_mvK7npGTLjlyfLpvRONFe9Z4MU,39
+tnfr-4.0.0.dist-info/top_level.txt,sha256=Q2HJnvc5Rt2VHwVvyBTnNPT4SfmJWnCj7XUxxEvQa7c,5
+tnfr-4.0.0.dist-info/RECORD,,

tnfr-4.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tnfr = tnfr.cli:main

tnfr-3.5.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-tnfr/__init__.py,sha256=LYIpDLjPnC4MxrviM2-Lg8KudbzXM_56aepRg_BEJG4,581
-tnfr/constants.py,sha256=_775sPHussR9vgkWRCLC6dzwgk_1_lLnSlWT8sBWR3U,7677
-tnfr/dynamics.py,sha256=btDyC3jIOmND1c1qqA2RDo0f3NraJKZwggO5BqBAmCA,23967
-tnfr/helpers.py,sha256=3DT7nb2FBrJxSEFcZ_Q9qiR9JGbjCNJOzA49bzN6hbM,6067
-tnfr/main.py,sha256=TEngteuC9MD7Ec9bNGuCC9ym-2ohbh202-HGArCR4tk,1506
-tnfr/observers.py,sha256=PTw3hxk7KD-Yx_CvCIU09icuhyYD6uNU6SvF80UvP-Y,5354
-tnfr/ontosim.py,sha256=9GfEtiLIdJOPJUTufcq_MssAA9J8AfChHU6HKb3DIJY,5628
-tnfr/operators.py,sha256=ONUC0tzB7y0Ad4MppLjFc8bmlTjPol-l_xdEB_84uaw,12293
-tnfr-3.5.0.dist-info/licenses/LICENSE.md,sha256=SRvvhXLrKtseuK6DARbuJffuXOXqAyk3wvF2n0t1SWA,1109
-tnfr-3.5.0.dist-info/METADATA,sha256=N420pHD6T9d8kkDwi202Klyh7mu7oIx3-CmwYZo_CwA,5576
-tnfr-3.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tnfr-3.5.0.dist-info/entry_points.txt,sha256=6ZYrYA3Z-kKvqiYddIAj9c8ZcoVlK7pj-qCBvlNtuLE,40
-tnfr-3.5.0.dist-info/top_level.txt,sha256=Q2HJnvc5Rt2VHwVvyBTnNPT4SfmJWnCj7XUxxEvQa7c,5
-tnfr-3.5.0.dist-info/RECORD,,

tnfr-3.5.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-tnfr = tnfr.main:main