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

tnfr/__init__.py

@@ -1,3 +1,4 @@
+
 from __future__ import annotations
 """
 TNFR — Teoría de la Naturaleza Fractal Resonante
@@ -7,42 +8,12 @@ Ecuación nodal:
     ∂EPI/∂t = νf · ΔNFR(t)
 """
 
-__version__ = "3.0.2"
-
-# -------------------------------------------------------------------
-# 1) Registrar alias en sys.modules ANTES de cargar submódulos que
-#    hacen imports absolutos (p.ej. `from constants import ...`).
-#    Orden: constants -> helpers -> operators -> observers
-#    Luego: dynamics / ontosim (que dependen de los anteriores)
-# -------------------------------------------------------------------
-import sys as _sys
-
-# 1.a constants (no depende de helpers/otros)
-from . import constants as _constants
-_sys.modules.setdefault("constants", _constants)
-
-# 1.b helpers (usa: from constants import ...)
-from . import helpers as _helpers
-_sys.modules.setdefault("helpers", _helpers)
-
-# 1.c operators (usa: from constants/helpers import ...)
-from . import operators as _operators
-_sys.modules.setdefault("operators", _operators)
-
-# 1.d observers (usa: from constants/helpers import ...)
-from . import observers as _observers
-_sys.modules.setdefault("observers", _observers)
-
-# 2) dynamics / ontosim (ya con alias creados)
-from . import dynamics as _dynamics
-from . import ontosim as _ontosim
-_sys.modules.setdefault("dynamics", _dynamics)
-_sys.modules.setdefault("ontosim",  _ontosim)
-
-# 3) Re-exports de la API pública
-from .dynamics import step, run, set_delta_nfr_hook
-from .ontosim import preparar_red
-from .observers import attach_standard_observer, coherencia_global, orden_kuramoto
+__version__ = "3.0.3"
+
+# Re-exports de la API pública
+from .dynamics import step, run, set_delta_nfr_hook
+from .ontosim import preparar_red
+from .observers import attach_standard_observer, coherencia_global, orden_kuramoto
 
 __all__ = [
     "preparar_red",

tnfr/dynamics.py

@@ -13,11 +13,13 @@ Incluye:
 from __future__ import annotations
 from typing import Dict, Any, Iterable
 import math
+from collections import deque
+import networkx as nx
 
-from observers import sincronía_fase, carga_glifica, orden_kuramoto, sigma_vector
-from operators import aplicar_remesh_si_estabilizacion_global
-from constants import DEFAULTS, ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, ALIAS_SI, ALIAS_dEPI, ALIAS_D2EPI
-from helpers import (
+from .observers import sincronía_fase, carga_glifica, orden_kuramoto, sigma_vector
+from .operators import aplicar_remesh_si_estabilizacion_global
+from .constants import DEFAULTS, ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, ALIAS_SI, ALIAS_dEPI, ALIAS_D2EPI
+from .helpers import (
      clamp, clamp01, list_mean, phase_distance,
      _get_attr, _set_attr, media_vecinal, fase_media,
      invoke_callbacks, reciente_glifo
@@ -120,8 +122,16 @@ def dnfr_epi_vf_mixed(G) -> None:
 # -------------------------
 
 def update_epi_via_nodal_equation(G, *, dt: float = None) -> None:
+    if not isinstance(G, (nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph)):
+        raise TypeError("G must be a networkx graph instance")
     if dt is None:
         dt = float(G.graph.get("DT", DEFAULTS["DT"]))
+    else:
+        if not isinstance(dt, (int, float)):
+            raise TypeError("dt must be a number")
+        if dt < 0:
+            raise ValueError("dt must be non-negative")
+        dt = float(dt)
     for n in G.nodes():
         nd = G.nodes[n]
         vf = _get_attr(nd, ALIAS_VF, 0.0)
@@ -175,20 +185,30 @@ def coordinar_fase_global_vecinal(G, fuerza_global: float | None = None, fuerza_
     Si no se pasan fuerzas explícitas, adapta kG/kL según estado (disonante / transición / estable).
     Estado se decide por R (Kuramoto) y carga glífica disruptiva reciente.
     """
+    g = G.graph
+    defaults = DEFAULTS
     # 0) Si hay fuerzas explícitas, usar y salir del modo adaptativo
     if (fuerza_global is not None) or (fuerza_vecinal is not None):
-        kG = float(fuerza_global if fuerza_global is not None else G.graph.get("PHASE_K_GLOBAL", DEFAULTS["PHASE_K_GLOBAL"]))
-        kL = float(fuerza_vecinal if fuerza_vecinal is not None else G.graph.get("PHASE_K_LOCAL",  DEFAULTS["PHASE_K_LOCAL"]))
+        kG = float(
+            fuerza_global
+            if fuerza_global is not None
+            else g.get("PHASE_K_GLOBAL", defaults["PHASE_K_GLOBAL"])
+        )
+        kL = float(
+            fuerza_vecinal
+            if fuerza_vecinal is not None
+            else g.get("PHASE_K_LOCAL", defaults["PHASE_K_LOCAL"])
+        )
     else:
         # 1) Lectura de configuración
-        cfg = G.graph.get("PHASE_ADAPT", DEFAULTS.get("PHASE_ADAPT", {}))
-        kG = float(G.graph.get("PHASE_K_GLOBAL", DEFAULTS["PHASE_K_GLOBAL"]))
-        kL = float(G.graph.get("PHASE_K_LOCAL",  DEFAULTS["PHASE_K_LOCAL"]))
+        cfg = g.get("PHASE_ADAPT", defaults.get("PHASE_ADAPT", {}))
+        kG = float(g.get("PHASE_K_GLOBAL", defaults["PHASE_K_GLOBAL"]))
+        kL = float(g.get("PHASE_K_LOCAL", defaults["PHASE_K_LOCAL"]))
 
         if bool(cfg.get("enabled", False)):
             # 2) Métricas actuales (no dependemos de history)
             R = orden_kuramoto(G)
-            win = int(G.graph.get("GLYPH_LOAD_WINDOW", DEFAULTS["GLYPH_LOAD_WINDOW"]))
+            win = int(g.get("GLYPH_LOAD_WINDOW", defaults["GLYPH_LOAD_WINDOW"]))
             dist = carga_glifica(G, window=win)
             disr = float(dist.get("_disruptivos", 0.0)) if dist else 0.0
 
@@ -216,7 +236,9 @@ def coordinar_fase_global_vecinal(G, fuerza_global: float | None = None, fuerza_
                 kG_t = 0.5 * (kG_min + kG_max)
                 kL_t = 0.5 * (kL_min + kL_max)
 
-            up = float(cfg.get("up", 0.10)); down = float(cfg.get("down", 0.07))
+            up = float(cfg.get("up", 0.10))
+            down = float(cfg.get("down", 0.07))
+
             def _step(curr, target, mn, mx):
                 gain = up if target > curr else down
                 nxt = curr + gain * (target - curr)
@@ -226,14 +248,19 @@ def coordinar_fase_global_vecinal(G, fuerza_global: float | None = None, fuerza_
             kL = _step(kL, kL_t, kL_min, kL_max)
 
             # 5) Persistir en G.graph y log de serie
-            G.graph["PHASE_K_GLOBAL"] = kG
-            G.graph["PHASE_K_LOCAL"]  = kL
-            hist = G.graph.setdefault("history", {})
-            hist.setdefault("phase_kG", []).append(float(kG))
-            hist.setdefault("phase_kL", []).append(float(kL))
-            hist.setdefault("phase_state", []).append(state)
-            hist.setdefault("phase_R", []).append(float(R))
-            hist.setdefault("phase_disr", []).append(float(disr))
+            g["PHASE_K_GLOBAL"] = kG
+            g["PHASE_K_LOCAL"] = kL
+            hist = g.setdefault("history", {})
+            hist_kG = hist.setdefault("phase_kG", [])
+            hist_kL = hist.setdefault("phase_kL", [])
+            hist_state = hist.setdefault("phase_state", [])
+            hist_R = hist.setdefault("phase_R", [])
+            hist_disr = hist.setdefault("phase_disr", [])
+            hist_kG.append(float(kG))
+            hist_kL.append(float(kL))
+            hist_state.append(state)
+            hist_R.append(float(R))
+            hist_disr.append(float(disr))
 
     # 6) Fase GLOBAL (centroide) para empuje
     X = list(math.cos(_get_attr(G.nodes[n], ALIAS_THETA, 0.0)) for n in G.nodes())
@@ -394,7 +421,7 @@ def step(G, *, dt: float | None = None, use_Si: bool = True, apply_glyphs: bool
 
     # 2) (opcional) Si
     if use_Si:
-        from helpers import compute_Si
+        from .helpers import compute_Si
         compute_Si(G, inplace=True)
 
     # 2b) Normalizadores para selector paramétrico (por paso)
@@ -403,7 +430,7 @@ def step(G, *, dt: float | None = None, use_Si: bool = True, apply_glyphs: bool
     # 3) Selección glífica + aplicación
     if apply_glyphs:
         selector = G.graph.get("glyph_selector", default_glyph_selector)
-        from operators import aplicar_glifo
+        from .operators import aplicar_glifo
         window = int(G.graph.get("GLYPH_HYSTERESIS_WINDOW", DEFAULTS["GLYPH_HYSTERESIS_WINDOW"]))
         for n in G.nodes():
             g = selector(G, n)
@@ -422,13 +449,13 @@ def step(G, *, dt: float | None = None, use_Si: bool = True, apply_glyphs: bool
     # 7) Observadores ligeros
     _update_history(G)
     # dynamics.py — dentro de step(), justo antes del punto 8)
-    epi_hist = G.graph.setdefault("_epi_hist", [])
-    epi_hist.append({n: _get_attr(G.nodes[n], ALIAS_EPI, 0.0) for n in G.nodes()})
-    # recorta el buffer para que no crezca sin límite
     tau = int(G.graph.get("REMESH_TAU", DEFAULTS["REMESH_TAU"]))
-    maxlen = max(2*tau + 5, 64)
-    if len(epi_hist) > maxlen:
-        del epi_hist[:-maxlen]
+    maxlen = max(2 * tau + 5, 64)
+    epi_hist = G.graph.get("_epi_hist")
+    if not isinstance(epi_hist, deque) or epi_hist.maxlen != maxlen:
+        epi_hist = deque(list(epi_hist or [])[-maxlen:], maxlen=maxlen)
+        G.graph["_epi_hist"] = epi_hist
+    epi_hist.append({n: _get_attr(G.nodes[n], ALIAS_EPI, 0.0) for n in G.nodes()})
 
     # 8) RE’MESH condicionado
     aplicar_remesh_si_estabilizacion_global(G)

tnfr/helpers.py

@@ -7,13 +7,14 @@ from __future__ import annotations
 from typing import Iterable, Dict, Any, Tuple, List
 import math
 from collections import deque
+from statistics import fmean, StatisticsError
 
 try:
     import networkx as nx  # solo para tipos
 except Exception:  # pragma: no cover
     nx = None  # type: ignore
 
-from constants import DEFAULTS, ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, ALIAS_SI
+from .constants import DEFAULTS, ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, ALIAS_SI
 
 # -------------------------
 # Utilidades numéricas
@@ -33,8 +34,10 @@ def clamp01(x: float) -> float:
 
 
 def list_mean(xs: Iterable[float], default: float = 0.0) -> float:
-    xs = list(xs)
-    return sum(xs) / len(xs) if xs else default
+    try:
+        return fmean(xs)
+    except StatisticsError:
+        return default
 
 
 def _wrap_angle(a: float) -> float:
@@ -82,7 +85,6 @@ def media_vecinal(G, n, aliases: Iterable[str], default: float = 0.0) -> float:
 
 def fase_media(G, n) -> float:
     """Promedio circular de las fases de los vecinos."""
-    import math
     x = 0.0
     y = 0.0
     count = 0

tnfr/observers.py

@@ -8,8 +8,8 @@ from collections import Counter
 from typing import Dict, Any
 import math
 
-from constants import ALIAS_DNFR, ALIAS_EPI, ALIAS_THETA, ALIAS_dEPI
-from helpers import _get_attr, list_mean, register_callback
+from .constants import ALIAS_DNFR, ALIAS_EPI, ALIAS_THETA, ALIAS_dEPI
+from .helpers import _get_attr, list_mean, register_callback
 
 # -------------------------
 # Observador estándar Γ(R)
@@ -44,15 +44,27 @@ def coherencia_global(G) -> float:
 
 
 def sincronía_fase(G) -> float:
-    X = list(math.cos(_get_attr(G.nodes[n], ALIAS_THETA, 0.0)) for n in G.nodes())
-    Y = list(math.sin(_get_attr(G.nodes[n], ALIAS_THETA, 0.0)) for n in G.nodes())
+    X = [math.cos(_get_attr(G.nodes[n], ALIAS_THETA, 0.0)) for n in G.nodes()]
+    Y = [math.sin(_get_attr(G.nodes[n], ALIAS_THETA, 0.0)) for n in G.nodes()]
     if not X:
         return 1.0
-    import math
-    th = math.atan2(sum(Y)/len(Y), sum(X)/len(X))
+    th = math.atan2(sum(Y) / len(Y), sum(X) / len(X))
     # varianza angular aproximada (0 = muy sincronizado)
     import statistics as st
-    var = st.pvariance([((_get_attr(G.nodes[n], ALIAS_THETA, 0.0) - th + math.pi) % (2*math.pi) - math.pi) for n in G.nodes()]) if len(X) > 1 else 0.0
+    var = (
+        st.pvariance(
+            [
+                (
+                    (_get_attr(G.nodes[n], ALIAS_THETA, 0.0) - th + math.pi)
+                    % (2 * math.pi)
+                    - math.pi
+                )
+                for n in G.nodes()
+            ]
+        )
+        if len(X) > 1
+        else 0.0
+    )
     return 1.0 / (1.0 + var)
 
 def orden_kuramoto(G) -> float:

tnfr/ontosim.py

@@ -5,20 +5,21 @@ Módulo de orquestación mínima que encadena:
 ΔNFR (campo) → Si → glifos → ecuación nodal → clamps → U’M → observadores → RE’MESH
 """
 from __future__ import annotations
-import networkx as nx
-import math
-import random
+import networkx as nx
+import math
+import random
+from collections import deque
 
-from constants import DEFAULTS, attach_defaults
-from dynamics import step as _step, run as _run
-from dynamics import default_compute_delta_nfr
+from .constants import DEFAULTS, attach_defaults
+from .dynamics import step as _step, run as _run
+from .dynamics import default_compute_delta_nfr
 
 # API de alto nivel
 
 def preparar_red(G: nx.Graph, *, override_defaults: bool = False, **overrides) -> nx.Graph:
     attach_defaults(G, override=override_defaults)
     if overrides:
-        from constants import merge_overrides
+        from .constants import merge_overrides
         merge_overrides(G, **overrides)
     # Inicializaciones blandas
     G.graph.setdefault("history", {
@@ -43,11 +44,13 @@ def preparar_red(G: nx.Graph, *, override_defaults: bool = False, **overrides) -
         "phase_R": [], 
         "phase_disr": [],
     })
-    G.graph.setdefault("_epi_hist", [])
+    tau = int(G.graph.get("REMESH_TAU", DEFAULTS["REMESH_TAU"]))
+    maxlen = max(2 * tau + 5, 64)
+    G.graph.setdefault("_epi_hist", deque(maxlen=maxlen))
     # Auto-attach del observador estándar si se pide
     if G.graph.get("ATTACH_STD_OBSERVER", False):
         try:
-            from observers import attach_standard_observer
+            from .observers import attach_standard_observer
             attach_standard_observer(G)
         except Exception as e:
             G.graph.setdefault("_callback_errors", []).append(

tnfr/operators.py

@@ -5,14 +5,15 @@ import math
 import random
 import hashlib
 
-from constants import DEFAULTS, ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, ALIAS_D2EPI
-from helpers import _get_attr, _set_attr, clamp, clamp01, list_mean, fase_media, push_glifo, invoke_callbacks
+from .constants import DEFAULTS, ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, ALIAS_D2EPI
+from .helpers import _get_attr, _set_attr, clamp, clamp01, list_mean, fase_media, push_glifo, invoke_callbacks
+from collections import deque
 
 """
 Este módulo implementa:
 - Los 13 glifos como operadores locales suaves.
 - Un dispatcher `aplicar_glifo` que mapea el nombre del glifo (con apóstrofo tipográfico) a su función.
-- RE’MESH de red: `aplicar_remesh_red` y `aplicar_remesh_si_estabilizacion_global`.
+- RE’MESH de red: `aplicar_remesh_red` y `aplicar_remesh_si_estabilización_global`.
 
 Nota sobre α (alpha) de RE’MESH: se toma por prioridad de
 1) G.graph["GLYPH_FACTORS"]["REMESH_alpha"]
@@ -186,7 +187,7 @@ def aplicar_remesh_red(G) -> None:
     """
     tau = int(G.graph.get("REMESH_TAU", DEFAULTS["REMESH_TAU"]))
     alpha, alpha_src = _remesh_alpha_info(G)
-    hist = G.graph.get("_epi_hist", [])
+    hist = G.graph.get("_epi_hist", deque())
     if len(hist) < tau + 1:
         return
 
@@ -256,7 +257,11 @@ def aplicar_remesh_red(G) -> None:
 
 def aplicar_remesh_si_estabilizacion_global(G, pasos_estables_consecutivos: Optional[int] = None) -> None:
     # Ventanas y umbrales
-    w_estab = int(G.graph.get("REMESH_STABILITY_WINDOW", DEFAULTS["REMESH_STABILITY_WINDOW"]))
+    w_estab = (
+        pasos_estables_consecutivos
+        if pasos_estables_consecutivos is not None
+        else int(G.graph.get("REMESH_STABILITY_WINDOW", DEFAULTS["REMESH_STABILITY_WINDOW"]))
+    )
     frac_req = float(G.graph.get("FRACTION_STABLE_REMESH", DEFAULTS["FRACTION_STABLE_REMESH"]))
     req_extra = bool(G.graph.get("REMESH_REQUIRE_STABILITY", DEFAULTS["REMESH_REQUIRE_STABILITY"]))
     min_sync = float(G.graph.get("REMESH_MIN_PHASE_SYNC", DEFAULTS["REMESH_MIN_PHASE_SYNC"]))
@@ -293,4 +298,4 @@ def aplicar_remesh_si_estabilizacion_global(G, pasos_estables_consecutivos: Opti
         return
     # 4) Aplicar y registrar
     aplicar_remesh_red(G)
-    G.graph["_last_remesh_step"] = step_idx
+    G.graph["_last_remesh_step"] = step_idx

tnfr-3.5.0.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: tnfr
+Version: 3.5.0
+Summary: TNFR canónica: dinámica glífica modular sobre redes.
+Author: fmg
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/tnfr/
+Project-URL: Repository, https://github.com/fermga/Teoria-de-la-naturaleza-fractal-resonante-TNFR-
+Keywords: TNFR,fractal resonante,resonancia,glifos,networkx,dinámica,coherencia,EPI,Kuramoto
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: networkx>=2.6
+Dynamic: license-file
+
+# General Project Structure
+
+* **Package entry point.** `__init__.py` registers modules under short names to avoid circular imports and exposes the public API: `preparar_red`, `step`, `run`, and observation utilities.
+
+* **Configuration & constants.** `constants.py` centralizes default parameters (discretization, EPI and νf ranges, mixing weights, re-mesh limits, etc.) and provides utilities to inject them into the network (`attach_defaults`, `merge_overrides`), along with standardized aliases for node attributes.
+
+* **Cross-cutting utilities.** `helpers.py` offers core numeric helpers, alias-based attribute accessors, neighborhood statistics, glyph history, a callback system, and computation of the sense index `Si` for each node.
+
+* **Dynamics engine.** `dynamics.py` implements the simulation loop: ΔNFR field computation, nodal equation integration, glyph selection/application, clamps, phase coordination, history updates, and conditional re-mesh (`step` and `run`).
+
+* **Glyph operators.** `operators.py` defines the 13 glyphs as local transformations, a dispatcher `aplicar_glifo`, and both direct and stability-conditioned re-mesh utilities.
+
+* **Observers & metrics.** `observers.py` registers standard callbacks and computes global coherence, phase synchrony, Kuramoto order, glyph distribution, and the sense vector `Σ⃗`, among others.
+
+* **Simulation orchestration.** `ontosim.py` prepares a NetworkX graph, attaches configuration, and initializes attributes (EPI, phases, frequencies) before delegating dynamics to `dynamics.step`/`run`.
+
+* **Demo CLI.** `main.py` generates an Erdős–Rényi network, lets you tweak basic parameters, and runs the simulation while displaying final metrics.
+
+---
+
+## Key Concepts to Grasp
+
+* **Aliased dependency tree.** Modules import each other via global aliases to simplify access and prevent cycles—essential for navigating the code unambiguously.
+
+* **Normalized node attributes.** All data (EPI, phase `θ`, frequency `νf`, `ΔNFR`, etc.) live in `G.nodes[n]` under compatible alias names, making extensions and custom hooks straightforward.
+
+* **Sense Index (`Si`).** Combines normalized frequency, phase dispersion, and field magnitude to evaluate each node’s “sense,” influencing glyph selection.
+
+* **Step-wise engine.** `dynamics.step` orchestrates eight phases: field computation, `Si`, glyph selection & application, integration, clamps, phase coordination, history update, and conditioned re-mesh.
+
+* **Glyphs as operators.** Each glyph applies a smooth transformation to node attributes (emission, diffusion, coupling, dissonance, etc.), dispatched by a configurable, typographic name.
+
+* **Network re-mesh.** Mixes the current state with a past one (memory `τ`) to stabilize the network, with clear precedence for `α` and conditions based on recent stability and synchrony history.
+
+* **Callbacks & observers.** The `Γ(R)` system lets you hook functions before/after each step and after re-mesh, enabling monitoring or external intervention.
+
+---
+
+## Recommendations for Going Deeper
+
+* **NetworkX & the Graph API.** Get comfortable with how NetworkX handles attributes and topology; all dynamics operate on `Graph` objects and their properties.
+
+* **Extending the ΔNFR field.** Explore `set_delta_nfr_hook` to implement alternative nodal fields and learn how metadata and mixing weights are recorded.
+
+* **Designing new glyphs.** Review `operators.py` to add operators or adjust factors in `DEFAULTS['GLYPH_FACTORS']`.
+
+* **Custom observers.** Implement your own metrics via `register_callback` or by extending `observers.py` to measure phenomena specific to your study.
+
+* **Theoretical reading.** For conceptual background, see the included PDFs (`TNFR.pdf`, *El Pulso que nos Atraviesa*), which deepen the fractal-resonant framework.
+
+* **Advanced parameters.** Experiment with adaptive phase coordination, stability criteria, and the glyph grammar to observe their impact on network self-organization.
+
+---
+
+**Mastering these pieces will let you extend the simulation, build analysis pipelines and connect the theory with computational applications.**
+
+## Testing
+
+Install the dependencies and project in editable mode before running the test suite with `pytest`:
+
+```
+pip install networkx
+pip install -e .
+pytest
+```

tnfr-3.5.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+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

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

tnfr-3.0.2.dist-info/licenses/LICENSE.txt → tnfr-3.5.0.dist-info/licenses/LICENSE.md

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright (c) [year] [fullname]
+Copyright (c) 2025 TNFR - Teoría de la naturaleza fractral resonante
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

tnfr-3.0.2.dist-info/METADATA

@@ -1,35 +0,0 @@
-Metadata-Version: 2.4
-Name: tnfr
-Version: 3.0.2
-Summary: TNFR canónica: dinámica glífica modular sobre redes.
-Author: Fer
-License: MIT
-Project-URL: Homepage, https://pypi.org/project/tnfr/
-Project-URL: Repository, https://github.com/fermga/Teoria-de-la-naturaleza-fractal-resonante-TNFR-
-Keywords: TNFR,fractal resonante,resonancia,glifos,networkx,dinámica,coherencia,EPI,Kuramoto
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: networkx>=2.6
-Dynamic: license-file
-
-# tnfr
-
-
-Paquete **tnfr** (canónica). Orquesta dinámica glífica sobre grafos `networkx`.
-
-
-```bash
-pip install tnfr

tnfr-3.0.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-tnfr/__init__.py,sha256=RBQO7L4qQQWMK0S6S9j2Ev52U6GOH2iNTaH2d8o5Zj8,1798
-tnfr/constants.py,sha256=_775sPHussR9vgkWRCLC6dzwgk_1_lLnSlWT8sBWR3U,7677
-tnfr/dynamics.py,sha256=7B38c9SVKLVFBrKHeJ1nXbghoRHfDs8Nl9CqUmCcAyI,23260
-tnfr/helpers.py,sha256=tZJsDXc8k9HIfg8BA9cVUEFKBoX1Rfnuhurl2Fvxsy0,6017
-tnfr/main.py,sha256=TEngteuC9MD7Ec9bNGuCC9ym-2ohbh202-HGArCR4tk,1506
-tnfr/observers.py,sha256=MoC-xLJuMP-UYj8cpIVlgSbXDsE1Uj70Zy51PSH3AJY,5192
-tnfr/ontosim.py,sha256=U0IeNVF8rFNhnmWWux91xDc0djTDZQkqRRosP6Z7FmE,5485
-tnfr/operators.py,sha256=M6ahJL8IuB2y4qiEalge5EufCz0eEbhw-O4xfh3NpwE,12146
-tnfr-3.0.2.dist-info/licenses/LICENSE.txt,sha256=xTjBNhy3N8pomFljrCkD1d34SmAEWv8hyJMMOjNMH0M,1071
-tnfr-3.0.2.dist-info/METADATA,sha256=IjrYafbG2gRYW4LcsQMsKFG4VqT3zw-H5qHolXKuk3g,1325
-tnfr-3.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tnfr-3.0.2.dist-info/top_level.txt,sha256=Q2HJnvc5Rt2VHwVvyBTnNPT4SfmJWnCj7XUxxEvQa7c,5
-tnfr-3.0.2.dist-info/RECORD,,