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

tnfr/validation/rules.py

@@ -0,0 +1,194 @@
+"""Validation helpers grouped by rule type.
+
+These utilities implement the canonical checks required by
+:mod:`tnfr.validation.grammar`.  They are organised here to make it
+explicit which pieces enforce repetition control, transition
+compatibility or stabilisation thresholds.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Mapping, TYPE_CHECKING
+
+from ..alias import get_attr
+from ..constants import get_aliases
+from ..glyph_history import recent_glyph
+from ..helpers.numeric import clamp01
+from ..metrics.common import normalize_dnfr
+from ..types import Glyph
+from .compatibility import CANON_COMPAT, CANON_FALLBACK
+
+if TYPE_CHECKING:  # pragma: no cover - only for typing
+    from .grammar import GrammarContext
+
+ALIAS_SI = get_aliases("SI")
+ALIAS_D2EPI = get_aliases("D2EPI")
+
+__all__ = [
+    "coerce_glyph",
+    "glyph_fallback",
+    "get_norm",
+    "normalized_dnfr",
+    "_norm_attr",
+    "_si",
+    "_accel_norm",
+    "_check_repeats",
+    "_maybe_force",
+    "_check_oz_to_zhir",
+    "_check_thol_closure",
+    "_check_compatibility",
+]
+
+
+def coerce_glyph(val: Any) -> Glyph | Any:
+    """Return ``val`` coerced to :class:`Glyph` when possible."""
+
+    try:
+        return Glyph(val)
+    except (ValueError, TypeError):
+        return val
+
+
+def glyph_fallback(cand_key: str, fallbacks: Mapping[str, Any]) -> Glyph | str:
+    """Determine fallback glyph for ``cand_key`` considering canon tables."""
+
+    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)
+
+
+# -------------------------
+# Normalisation helpers
+# -------------------------
+
+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 the structural sense index for ``nd`` clamped to ``[0, 1]``."""
+
+    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 normalized_dnfr(ctx: "GrammarContext", nd) -> float:
+    """Normalise |ΔNFR| using the configured global maximum."""
+
+    return normalize_dnfr(nd, get_norm(ctx, "dnfr_max"))
+
+
+# -------------------------
+# Validation rules
+# -------------------------
+
+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:
+    """Enforce OZ precedents before allowing ZHIR mutations."""
+
+    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))
+        if (
+            not recent_glyph(nd, Glyph.OZ, win)
+            and normalized_dnfr(ctx, nd) < dn_min
+        ):
+            return Glyph.OZ
+    return cand
+
+
+def _check_thol_closure(
+    ctx: "GrammarContext", n, cand: Glyph | str, st: dict[str, Any]
+) -> Glyph | str:
+    """Close THOL blocks with canonical glyphs once stabilised."""
+
+    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))
+        if st["thol_len"] >= maxlen or (
+            st["thol_len"] >= minlen
+            and normalized_dnfr(ctx, nd) <= 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:
+    """Verify canonical transition compatibility for ``cand``."""
+
+    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

tnfr/validation/rules.pyi

@@ -0,0 +1,18 @@
+from typing import Any
+
+__all__: Any
+
+def __getattr__(name: str) -> Any: ...
+
+_accel_norm: Any
+_check_compatibility: Any
+_check_oz_to_zhir: Any
+_check_repeats: Any
+_check_thol_closure: Any
+_maybe_force: Any
+_norm_attr: Any
+_si: Any
+coerce_glyph: Any
+get_norm: Any
+glyph_fallback: Any
+normalized_dnfr: Any

tnfr/validation/syntax.py

@@ -0,0 +1,151 @@
+"""Syntax validation for TNFR operator sequences."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from ..operators.registry import OPERATORS
+from ..config.operator_names import (
+    COHERENCE,
+    INTERMEDIATE_OPERATORS,
+    RECEPTION,
+    SELF_ORGANIZATION,
+    SELF_ORGANIZATION_CLOSURES,
+    VALID_END_OPERATORS,
+    VALID_START_OPERATORS,
+    canonical_operator_name,
+    operator_display_name,
+)
+
+__all__ = ("validate_sequence",)
+
+
+_MISSING = object()
+
+
+_CANONICAL_START = tuple(sorted(VALID_START_OPERATORS))
+_CANONICAL_INTERMEDIATE = tuple(sorted(INTERMEDIATE_OPERATORS))
+_CANONICAL_END = tuple(sorted(VALID_END_OPERATORS))
+
+
+def _format_token_group(tokens: tuple[str, ...]) -> str:
+    return ", ".join(operator_display_name(token) for token in sorted(tokens))
+
+
+def _validate_start(token: str) -> tuple[bool, str]:
+    """Ensure the sequence begins with a valid structural operator."""
+
+    if not isinstance(token, str):
+        return False, "tokens must be str"
+    if token not in VALID_START_OPERATORS:
+        valid_tokens = _format_token_group(_CANONICAL_START)
+        return False, f"must start with {valid_tokens}"
+    return True, ""
+
+
+def _validate_intermediate(
+    found_reception: bool, found_coherence: bool, seen_intermediate: bool
+) -> tuple[bool, str]:
+    """Check that the central TNFR segment is present."""
+
+    if not (found_reception and found_coherence):
+        return False, f"missing {RECEPTION}→{COHERENCE} segment"
+    if not seen_intermediate:
+        intermediate_tokens = _format_token_group(_CANONICAL_INTERMEDIATE)
+        return False, f"missing {intermediate_tokens} segment"
+    return True, ""
+
+
+def _validate_end(last_token: str, open_thol: bool) -> tuple[bool, str]:
+    """Validate closing operator and any pending THOL blocks."""
+
+    if last_token not in VALID_END_OPERATORS:
+        cierre_tokens = _format_token_group(_CANONICAL_END)
+        return False, f"sequence must end with {cierre_tokens}"
+    if open_thol:
+        return False, "THOL block without closure"
+    return True, ""
+
+
+def _validate_known_tokens(
+    token_to_canonical: dict[str, str]
+) -> tuple[bool, str]:
+    """Ensure all tokens map to canonical operators."""
+
+    unknown_tokens = {
+        alias
+        for alias, canonical in token_to_canonical.items()
+        if canonical not in OPERATORS
+    }
+    if unknown_tokens:
+        ordered = ", ".join(sorted(unknown_tokens))
+        return False, f"unknown tokens: {ordered}"
+    return True, ""
+
+
+def _validate_token_sequence(names: list[str]) -> tuple[bool, str]:
+    """Validate token format and logical coherence in one pass."""
+
+    if not names:
+        return False, "empty sequence"
+
+    ok, msg = _validate_start(names[0])
+    if not ok:
+        return False, msg
+
+    token_to_canonical: dict[str, str] = {}
+    found_reception = False
+    found_coherence = False
+    seen_intermediate = False
+    open_thol = False
+
+    for name in names:
+        if not isinstance(name, str):
+            return False, "tokens must be str"
+        canonical = canonical_operator_name(name)
+        token_to_canonical[name] = canonical
+
+        if canonical == RECEPTION and not found_reception:
+            found_reception = True
+        elif found_reception and canonical == COHERENCE and not found_coherence:
+            found_coherence = True
+        elif (
+            found_coherence
+            and not seen_intermediate
+            and canonical in INTERMEDIATE_OPERATORS
+        ):
+            seen_intermediate = True
+
+        if canonical == SELF_ORGANIZATION:
+            open_thol = True
+        elif open_thol and canonical in SELF_ORGANIZATION_CLOSURES:
+            open_thol = False
+
+    ok, msg = _validate_known_tokens(token_to_canonical)
+    if not ok:
+        return False, msg
+    ok, msg = _validate_intermediate(found_reception, found_coherence, seen_intermediate)
+    if not ok:
+        return False, msg
+    ok, msg = _validate_end(names[-1], open_thol)
+    if not ok:
+        return False, msg
+    return True, "ok"
+
+
+def validate_sequence(
+    names: Iterable[str] | object = _MISSING, **kwargs: object
+) -> tuple[bool, str]:
+    """Validate minimal TNFR syntax rules."""
+
+    if kwargs:
+        unexpected = ", ".join(sorted(kwargs))
+        raise TypeError(
+            f"validate_sequence() got unexpected keyword argument(s): {unexpected}"
+        )
+
+    if names is _MISSING:
+        raise TypeError("validate_sequence() missing required argument: 'names'")
+
+    sequence = list(names)
+    return _validate_token_sequence(sequence)

tnfr/validation/syntax.pyi

@@ -0,0 +1,7 @@
+from typing import Any
+
+__all__: Any
+
+def __getattr__(name: str) -> Any: ...
+
+validate_sequence: Any

tnfr-6.0.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: tnfr
+Version: 6.0.0
+Summary: Modular structural-based dynamics on networks.
+Author: fmg
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/tnfr/
+Project-URL: Repository, https://github.com/fermga/TNFR-Python-Engine
+Project-URL: GPT, https://chatgpt.com/g/g-67abc78885a88191b2d67f94fd60dc97-tnfr-teoria-de-la-naturaleza-fractal-resonante
+Keywords: TNFR,complex systems,fractals,resonance,networks,structural dynamics,structural analysis
+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: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: networkx>=2.6
+Requires-Dist: cachetools>=5
+Requires-Dist: typing-extensions>=4.4; python_version < "3.10"
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.24; extra == "numpy"
+Provides-Extra: yaml
+Requires-Dist: pyyaml>=6.0; extra == "yaml"
+Provides-Extra: orjson
+Requires-Dist: orjson>=3; extra == "orjson"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pytest-benchmark>=4; extra == "test"
+Requires-Dist: pydocstyle>=6; extra == "test"
+Requires-Dist: coverage>=7; extra == "test"
+Requires-Dist: flake8>=5; extra == "test"
+Requires-Dist: flake8-pyproject>=1.2; extra == "test"
+Requires-Dist: vulture>=2; extra == "test"
+Provides-Extra: typecheck
+Requires-Dist: mypy>=1.8; extra == "typecheck"
+Requires-Dist: networkx-stubs>=0.0.1; extra == "typecheck"
+Requires-Dist: types-cachetools>=6.0.0.0; extra == "typecheck"
+Requires-Dist: numpy>=1.24; extra == "typecheck"
+Dynamic: license-file
+
+# TNFR Python Engine
+
+Canonical implementation of the Resonant Fractal Nature Theory (TNFR) for modelling structural
+coherence. The engine seeds resonant nodes, applies structural operators, coordinates
+ΔNFR/phase dynamics, and measures coherence metrics (C(t), Si, νf) without breaking the nodal
+equation $\partial EPI/\partial t = \nu_f \cdot \Delta NFR(t)$.
+
+## Snapshot
+
+- **Operate:** build nodes with `tnfr.create_nfr`, execute trajectories via
+  `tnfr.structural.run_sequence`, and evolve dynamics with `tnfr.dynamics.run`.
+- **Observe:** register metrics/trace callbacks to capture ΔNFR, C(t), Si, and structural
+  histories
+  for every run.
+- **Extend:** rely on the canonical operator grammar and invariants before introducing new
+  utilities or telemetry.
+
+## Quickstart
+
+Install from PyPI (Python ≥ 3.9):
+
+```bash
+pip install tnfr
+```
+
+Then follow the [quickstart guide](docs/getting-started/quickstart.md) for Python and CLI
+walkthroughs plus optional dependency caching helpers.
+
+## Documentation map
+
+- [Documentation index](docs/index.md) — navigation hub for API chapters and examples.
+- [API overview](docs/api/overview.md) — package map, invariants, and structural data flow.
+- [Structural operators](docs/api/operators.md) — canonical grammar, key concepts, and typical
+  workflows.
+- [Telemetry & utilities](docs/api/telemetry.md) — coherence metrics, trace capture, locking,
+  and helper facades.
+- [Examples](docs/examples/README.md) — runnable scenarios, CLI artefacts, and token legend.
+
+## Documentation build workflow
+
+Netlify publishes the documentation with [MkDocs](https://www.mkdocs.org/) so the generated
+site preserves the canonical TNFR structure. The same steps can be executed locally:
+
+1. Create and activate a virtual environment (e.g. `python -m venv .venv && source .venv/bin/activate`).
+2. Install the documentation toolchain: `python -m pip install -r docs/requirements.txt`.
+3. Preview changes live with `mkdocs serve` or reproduce the Netlify pipeline with
+   `mkdocs build`, which writes the static site to the `site/` directory.
+
+The Netlify build (`netlify.toml`) runs `python -m pip install -r docs/requirements.txt && mkdocs build`
+and publishes the resulting `site/` directory, ensuring the hosted documentation matches local builds.
+
+## Local development
+
+Use the helper scripts to keep formatting aligned with the canonical configuration and to reproduce
+the quality gate locally:
+
+```bash
+./scripts/format.sh           # Apply Black and isort across src/, tests/, scripts/, and benchmarks/
+./scripts/format.sh --check   # Validate formatting without modifying files
+./scripts/run_tests.sh        # Execute the full QA battery (type checks, tests, coverage, linting)
+```
+
+The formatting helper automatically prefers `poetry run` when a Poetry environment is available and
+falls back to `python -m` invocations so local runs mirror the tooling invoked in continuous
+integration.
+
+## Additional resources
+
+- [ARCHITECTURE.md](ARCHITECTURE.md) — orchestration layers and invariant enforcement.
+- [CONTRIBUTING.md](CONTRIBUTING.md) — QA battery (`scripts/run_tests.sh`) and review
+  expectations.
+- [TNFR.pdf](TNFR.pdf) — theoretical background, structural operators, and paradigm glossary.
+
+## Migration notes
+
+- **Si dispersion keys:** Replace any remaining ``dSi_ddisp_fase`` entries in graph payloads
+  or configuration files with the English ``dSi_dphase_disp`` key before upgrading. The
+  runtime now raises :class:`ValueError` listing any unexpected sensitivity keys, and
+  :func:`tnfr.metrics.sense_index.compute_Si_node` rejects unknown keyword arguments.
+- Refer to the [release notes](docs/releases.md#1100-si-dispersion-legacy-keys-removed) for
+  a migration snippet that rewrites stored graphs in place prior to running the new version.
+
+## Licensing
+
+Released under the [MIT License](LICENSE.md). Cite the TNFR paradigm when publishing research
+or derived artefacts based on this engine.

tnfr-6.0.0.dist-info/RECORD

@@ -0,0 +1,157 @@
+tnfr/__init__.py,sha256=zgPWxn__aqj45uTXna_lzywQ-5-TuxBYYt-BkMLXPiY,8679
+tnfr/__init__.pyi,sha256=SVeCTtSpwlP-gtTzhX8OINlfFFuO43pyWunsc2I021Y,978
+tnfr/_compat.py,sha256=VuXrIrkfwCGk_KJjgubhh3JE3S49Q6zoNaKgMVgpXFE,414
+tnfr/_version.py,sha256=QBM2cy3Ta0_p9NQaMtYXdirM5XzS5wVntliMx9BDMgM,125
+tnfr/_version.pyi,sha256=DbyhsjJTujojo0nxFtOdH94bxGxzReRJNjZoHV-zG1s,95
+tnfr/alias.py,sha256=WfddprBly1jwWz10ozYErCi5I2ONAXjf2dwpOBxyqF8,18127
+tnfr/alias.pyi,sha256=x4sS9Rt_M-pzQF_tJitR-HRxoyKNrn1s1lIj8zcV9us,2926
+tnfr/cache.py,sha256=D5EZ1yDBQoXYcGH89wsdlnaojU3eH-MUACX8VDXWhFI,24442
+tnfr/cache.pyi,sha256=MIH_3rs5OE1xt2VYOziShL0hGRctHFx2i7PThT-X3qw,5872
+tnfr/callback_utils.py,sha256=YjGq7viVC95wFpSBJIt2fFDCp7OUWwpv5FpiWsTuzYA,12181
+tnfr/callback_utils.pyi,sha256=Osu0xb9opdU7KeWC4MleelthiJHVqhZ4ia8UrRxOtvs,2365
+tnfr/constants_glyphs.py,sha256=o0uTYkuLXaj3yM4CGAcnNcqwv9VC0I6x-hJzCPbzq9Q,401
+tnfr/constants_glyphs.pyi,sha256=Xtm8NhTukF_rpn4Y7hy9O7aT1IcWSuQLcDpFcUnZnbk,192
+tnfr/execution.py,sha256=md_Mzpe6M7VsQBt8_brKQPFfhnoRWftxi7YZC-LzmYM,5813
+tnfr/execution.pyi,sha256=iPskC4i_jBPwNtvCXVr5tH71WD9mQCqAvKq7QjKDi2w,1465
+tnfr/flatten.py,sha256=QbrZODPL0qTu9D7RVn3YGvq8QEq6f0GR60X-1kLho3c,8226
+tnfr/flatten.pyi,sha256=dI7sVL2BTvFYvN6bWoQVtIKybOXZSogeko3pCvtp9Vo,594
+tnfr/gamma.py,sha256=nkbBcP3H0gBZV_vABphsaY-Ick1i4gDj_X9PFnRoSQM,10998
+tnfr/gamma.pyi,sha256=b2KKWTBGQ4fAMYIBUTumIFgS73xixk9ekd01cGNyFV4,1005
+tnfr/glyph_history.py,sha256=ajLN0PIZWEQkaIaF8pJonseqAsem0utDZCD-UXirrWo,11527
+tnfr/glyph_history.pyi,sha256=rRAu_jVFfkE7o7l1VE9-CSWXCnbfRs2BG_4WjYPQF_s,1397
+tnfr/grammar.py,sha256=70lUuMqoB3GVomKD4rbQy_M5icBjp0-4XKwyAT6Z_gE,651
+tnfr/grammar.pyi,sha256=UM6ntYDCQ3hEfYnV6e2O9K9G21VTkpx-YJYnX5j-2Lw,236
+tnfr/immutable.py,sha256=SeNqRmbomKJjU6wC_ITe9gBGn9xEZjV1z67UQioSg7g,6445
+tnfr/immutable.pyi,sha256=DHx-gRaygFPX2G5zfDQUjLsRB-tW5sZhhBRc16woD9I,1283
+tnfr/initialization.py,sha256=ds8NfUEBku6pzIwWHNPOO8y1Gubio5dK6fYS80IHUJo,5914
+tnfr/initialization.pyi,sha256=hDr2PMQmpye4xoA7m5Fgbpr-p2FLg3_LVSXu6D-apj0,1345
+tnfr/io.py,sha256=U6eMQNSGa2wkHC7tsUrAq19UuPntoWiuCwd-br14qws,8316
+tnfr/io.pyi,sha256=_x06jeSFJVJsyksACDnq9S-4l5X01YXlxn44y9ACXCA,181
+tnfr/locking.py,sha256=mOvaENBNSsWw6KiBG_UXv4xXfZ9uQZvWw5SN2cKFmSU,1168
+tnfr/locking.pyi,sha256=GoQ-C3l87O78jCi38VmUDpXwMnocPe0eavJFEN4QdXU,92
+tnfr/node.py,sha256=qyEJ3ogOZoO9lAlCW3uyDhpRKqF7BinKrRy35ZywHGQ,7869
+tnfr/node.pyi,sha256=uLAM1iu10BW3s8O7BwJcc1PWYE0v9YIQxVT1ZxYG2SE,3450
+tnfr/observers.py,sha256=34OWK8YcE2m4UyqJeQMxpQBOv_KjSO4JG80F3nVziVI,5118
+tnfr/observers.pyi,sha256=_mLFNOwrJAZb894noHW9Y94xBd4Dap3LHV8vx-L8oNk,881
+tnfr/ontosim.py,sha256=Oqrgjib5J6igPi2sVbFJMLHKgw005lCVHPoZuboo08o,4035
+tnfr/ontosim.pyi,sha256=__X4twVj8Y7uirGqx5UDlzMIYOBoU8ZqRBKOf836e6Q,565
+tnfr/presets.py,sha256=FL2Fvi2mazD4PvaOxIosrQOnZ7KvNia-fiCf-4sF80U,312
+tnfr/presets.pyi,sha256=8oHCzjv8AOcfWWRZb4pgTJ40HJUXbbrDOyQoSb_XsD8,94
+tnfr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tnfr/rng.py,sha256=BzrmsBXHdKsS1pt4u4J6VFA8AaH8Qh4yOjN_vjGMsYU,14122
+tnfr/rng.pyi,sha256=95PakrXx9OYVrEUIrwR9xxuuGxiYK1ZZXWNm0cLf1AA,232
+tnfr/selector.py,sha256=CuiMRNJ_isi_mRVfhWeyhrY1DfdOhn8VSXddArn1zhg,6164
+tnfr/selector.pyi,sha256=LWwkUQloGu7SZFi4aedJA7snFd16oA9yaPYQP2tzvTY,379
+tnfr/sense.py,sha256=ZUiaFJsP8wz5AkCywLxJN3dz1V9huFfnlE6m5InyvWQ,10148
+tnfr/sense.pyi,sha256=9u-nqIEPaFp2GSrJF9AyNJEbhPnw-IjoIDM8QMc_R5I,794
+tnfr/structural.py,sha256=_o8Kqaue3o7ohyozwbCO0taTEn4nLVNfE7P4F37KJDw,2526
+tnfr/structural.pyi,sha256=WYLGl2quXH3iSnDZu0-ZKwsdGZLDpBtaWo0K3GOMQeY,847
+tnfr/tokens.py,sha256=IOLowDN6JuiEVAnGcYtclpF_S9Orlu5BnEug5O3aERA,1214
+tnfr/tokens.pyi,sha256=qo_cfFE3vybigYl6Bx6pstRwn0ay2Sdf91S5o8YWce0,683
+tnfr/trace.py,sha256=y8bDQ4Rpb5DEr5qfnmZLcNty3pDKBhujYO7U8F5jrc8,15043
+tnfr/trace.pyi,sha256=anufYVC1K-5UyoGcEk12f1BtGAwPG1bOUfT6XjQZxHk,1882
+tnfr/types.py,sha256=t6jd_Wb3V1OuWUAx3ycmCbFje2Sshj6B8TOJNrv7MtI,11351
+tnfr/types.pyi,sha256=VyfkdeGuwJP_3RXbVV4SozINJm7jr3XMEU9clJw6Mrw,4022
+tnfr/cli/__init__.py,sha256=FTblTvNLe0v2QIrsMgiWwcD0_JoRkNOVsIwGlyk_4sE,2127
+tnfr/cli/__init__.pyi,sha256=XYq749MAzQHqV9Lj7QHjN6I2qMTZTEP07w8S-odcNS0,1040
+tnfr/cli/arguments.py,sha256=pklvrCn2AjD5gmCjfJpNs9UQLFGA2NziBh7HjVbkL80,6336
+tnfr/cli/arguments.pyi,sha256=KzXFsqSohTnvvTAkMWBgRykWv2Fuc-lfIjbKyibY84s,1031
+tnfr/cli/execution.py,sha256=jP8NMwKBDQZ-KvC0pVZStEnIUaSh-K_meIBiQSbW0Nk,9897
+tnfr/cli/execution.pyi,sha256=IStpTub_NLFdMxMej3v15s7NPfIJB8hkL0pW_YuVdJc,2212
+tnfr/cli/utils.py,sha256=aTsWm1b5QRZp4ZZStA1kqHiYT_wboqEpyTVNXVXnOoQ,977
+tnfr/cli/utils.pyi,sha256=3ODz7i3t2cm9qjXfxzdLQgnfZHBdXTewEVsbwZdQGgs,105
+tnfr/config/__init__.py,sha256=hcAneY0S8dH9kjHDBH7rlGbPH6r0F_WpkZ8J-5c4Q0M,384
+tnfr/config/__init__.pyi,sha256=m1D1GQIyCbwnllwXNoPriPkxzBYIJUZBik-jJXdW_CA,113
+tnfr/config/constants.py,sha256=8d_nXHpuM7DBKMeKonT0Wwft-oZgKxljYdhhZOOzceg,2830
+tnfr/config/constants.pyi,sha256=Xtm8NhTukF_rpn4Y7hy9O7aT1IcWSuQLcDpFcUnZnbk,192
+tnfr/config/init.py,sha256=srfCPDT8ddj2N2B7i9raHQeYKv3m2yswCKM67o7cfFQ,1029
+tnfr/config/init.pyi,sha256=m1D1GQIyCbwnllwXNoPriPkxzBYIJUZBik-jJXdW_CA,113
+tnfr/config/operator_names.py,sha256=iSefOgf-qniQI5OQhgH7auhVRveoX_0n3mkP11xHOdo,2705
+tnfr/config/operator_names.pyi,sha256=9GgUMxZXzoemlnIjkTmtruOJ2DkA__DfjQTeouRNVu4,532
+tnfr/config/presets.py,sha256=XHGkFAjBQ6t34xgMeL_9O-S2jPaXhEfgysEFhXcMlmQ,2481
+tnfr/config/presets.pyi,sha256=8oHCzjv8AOcfWWRZb4pgTJ40HJUXbbrDOyQoSb_XsD8,94
+tnfr/constants/__init__.py,sha256=2aMheGK04vELJARf47xHxkNZThQcSJPSoOV8kb3VqtE,6479
+tnfr/constants/__init__.pyi,sha256=ukJKlu9VkWHKlcKlv_pyXHBKjE6HMqYckAO4pF6LqGc,2270
+tnfr/constants/core.py,sha256=F7kVXaP_-nVhZIDq4327Z2Kxp2AI8yab8WGHDePIgTw,4718
+tnfr/constants/core.pyi,sha256=H9oY3Skdse9qPSFw2gF7mpyAUzFCPwo3RaYIVnxDfvo,279
+tnfr/constants/init.py,sha256=WdMKkdPKO7vyQoJAuoFnhWbb3n1nBkmkzprwyYj_ZN8,805
+tnfr/constants/init.pyi,sha256=jdf_jVgcRlVxzFzioOw_ANXUbtAc-0iHfLLAT1tLyaw,169
+tnfr/constants/metric.py,sha256=P7Zrw-4p7Nd7QwCVLRMV7GWop3LoeAdlm9NgAQnnbJU,3290
+tnfr/constants/metric.pyi,sha256=x0U5uD9fzgmSUz_EoUdBE2zrEdbgnaMgbMxUFyA7vB8,280
+tnfr/dynamics/__init__.py,sha256=OBfdBpz52CTv_nlhFc8arfnACwwoRr9O1iJpGITzi2E,3296
+tnfr/dynamics/__init__.pyi,sha256=cRvvBpMV7G_5YF_mDJkvEcN1wTGBmdeEs-PJIihiZ1Q,1843
+tnfr/dynamics/adaptation.py,sha256=WkmuLYY5wTvOJbeGKLfYAk2jYdP5caPVBPpib9fqTq8,7072
+tnfr/dynamics/aliases.py,sha256=8SeUcsJRieXrvl7-oJiEcvLUke1AQSZnz4-djVJdeHg,445
+tnfr/dynamics/coordination.py,sha256=VKlgqS7DA-2tWklwJUlD8DICJdiFGZX1gYMIElMeC_w,10814
+tnfr/dynamics/dnfr.py,sha256=YXEpE-b5EWc1EFSBCneAf_GwK3JCUALw2JM3pGwmnzk,75723
+tnfr/dynamics/dnfr.pyi,sha256=-hiGDoEEFtLb9Ggox1jhE_-ehkiaBL1kh7ClV-8913M,655
+tnfr/dynamics/integrators.py,sha256=9zYrV4kr_s8L5CKPoXKwath0UIw_3r52jqce3jy95ks,16495
+tnfr/dynamics/integrators.pyi,sha256=6bJaNKzZ5b1s5u4gktB1eACRH4oxVQNJTil-f1O02vI,843
+tnfr/dynamics/runtime.py,sha256=ymP5BXZq5S7GtvfePUObMuMHMIhbUy6d6ZQbjcTYFU4,14762
+tnfr/dynamics/sampling.py,sha256=FR2VAgcHc0eiUAK7YdAn6Ad1Vq2VtZTMceyOQzlqEno,1247
+tnfr/dynamics/sampling.pyi,sha256=edfyDqgtvmK4w6zlBNG9nmGpZDVe3pdnNZYOLFbwIG8,102
+tnfr/dynamics/selectors.py,sha256=a8M26H3K5ywJm4u5vTNt4yzrjR2FG5m-e6BMRE0v4YU,22447
+tnfr/helpers/__init__.py,sha256=DrT3dtkR6oJ2-uv3XE_fbd7Pq69_tbyninrGMAtEAVQ,4042
+tnfr/helpers/__init__.pyi,sha256=dae6lQfR-iXR1FJF9kSUKgqlzlH6dju7803AqsSbRco,1688
+tnfr/helpers/numeric.py,sha256=ritFewhW1VNxCOHxBC71aNLSZUuJ23-MUsVn_IV7V8E,2693
+tnfr/helpers/numeric.pyi,sha256=m6Tf_k9ZH2sro6z6g0wxariWSip6rVMct288zMDDcvo,174
+tnfr/metrics/__init__.py,sha256=4gujlyn3aN95lkxCjQPPgKS_xJYm5ShcraeEkDYKR_E,885
+tnfr/metrics/__init__.pyi,sha256=W5fUkKR9FeEcdHg4OVW2JPzxIRlQ71qtiYqoaEoAM3w,412
+tnfr/metrics/coherence.py,sha256=BVzoJSLCt--eDaFTmTEYfRObZkRXjQgn_KzAcYcXQK0,46109
+tnfr/metrics/common.py,sha256=R7jOzuxpenNkv-Y0iURMQOA9vtLTxr5Hdmna1OXohKA,4361
+tnfr/metrics/common.pyi,sha256=QSOfl14yyDpQ0B6VvI3ecvpAH99mkrFXU35rJg_lXjU,289
+tnfr/metrics/core.py,sha256=1L1shli3RxlGn4Y8xuYrsNfaE-9I3Qx7kHMXLwdfq7A,7208
+tnfr/metrics/core.pyi,sha256=8s1j3oeTyzU5xyUIsuP_Q5DkXY6hja_j2xL7ghKcu-U,218
+tnfr/metrics/diagnosis.py,sha256=P42FWqhOs955UB1cPm0rf1lFVB7wyz_0HLLoUFSeYII,26509
+tnfr/metrics/diagnosis.pyi,sha256=I2PzErqAVEvYt8saFs8fF7ADFUXEwzPwiKuzRmR8XGs,2134
+tnfr/metrics/export.py,sha256=F-gEES5RZopTRE45ISzYPRF_4ZF5HDa3qF_XNvurVE0,4735
+tnfr/metrics/glyph_timing.py,sha256=0gdxDu-aMd6mlau_VCWpZxCxSZ6Iau53sCFDFpF7Wug,10851
+tnfr/metrics/reporting.py,sha256=XcBwZl1-kwYLqxZELLR9oPsTVN--Z_thWqzVIANlVC4,4121
+tnfr/metrics/reporting.pyi,sha256=uA7DP9bM7351dcq4qBooZDXJUSLXyWR3AE2_r9H29YI,194
+tnfr/metrics/sense_index.py,sha256=qAUt1zbmSvvFGRusmQ5ssUaScuLCdNLnVO6BCS4hPNQ,9314
+tnfr/metrics/sense_index.pyi,sha256=YK5rIvhGGN6KyZHVIirCrgBF3eDeJ2zPyfa7x19sqXM,135
+tnfr/metrics/trig.py,sha256=Jyg9uwqNjSVRYFnYtyjrqnWSsFPKnrB6qcLof_tTD4Y,6548
+tnfr/metrics/trig.pyi,sha256=nSssWGsGS7k4jvKWAYxICzoB13laM8PKTpPstWgIJNQ,249
+tnfr/metrics/trig_cache.py,sha256=IPPIopGf5za8filSUGeymNHXEwfMZSRp0SNYgMdkHkc,3009
+tnfr/metrics/trig_cache.pyi,sha256=wqxVFp27iiUBB9Uep8rEIU_MIh1PjtsaK_d2RpLGnfE,163
+tnfr/operators/__init__.py,sha256=ea7doh9GgKIHpFOxkI4-ladMQcnIkWD1rvjurxx_ffA,13394
+tnfr/operators/__init__.pyi,sha256=5xE25x2yK-o0JuqxbUmlP62dRXW4uWFDYcHfR5SifKg,588
+tnfr/operators/definitions.py,sha256=4KG8BtIQ2sXKzyylqSoeJFnECdKVCujoVfFLHU4-iTY,3985
+tnfr/operators/definitions.pyi,sha256=9Zj4-HjCy8kX3havevz5EPL5q3TtMuyabxfHRw95bak,1528
+tnfr/operators/jitter.py,sha256=nO7gY2466UcKOYlpaVDEi4d5wvvNJRJWsbLU5xmcp0E,7833
+tnfr/operators/jitter.pyi,sha256=FSrSKP51D5N7AdekOH9H-sVzBBaqnnmM2IQKfWlnQN0,188
+tnfr/operators/registry.py,sha256=b7dO6n3gpUXgnYPhJhAQd0oElYNol43jkeQCP8iZn3U,2433
+tnfr/operators/registry.pyi,sha256=CHuuHsvKsSo7mWSXMQJdJoXD0AHO6jrCjv8lVGuoEkY,314
+tnfr/operators/remesh.py,sha256=VKqIucYJkQWUc1Ux0RlEpa8wOSjtN3u8MZWMt-0WdxQ,17869
+tnfr/telemetry/__init__.py,sha256=Ugqk4Qiv4dIYTVpxGXdKnEBORDdmw19A7Ni2TBPsp7o,286
+tnfr/telemetry/verbosity.py,sha256=6fN7IMhwtLKVQbch-PIN_vLxn3dw178SownD8-xlhKM,1048
+tnfr/utils/__init__.py,sha256=UOUnzZVN-WGqyCHVGYiM9xkwwb83Mm4N6AqXySV_Da0,4375
+tnfr/utils/__init__.pyi,sha256=EC12WoblgdRd4q_49XinqXklju2hyN9lvGUXbKRtCcw,2946
+tnfr/utils/cache.py,sha256=brzDTG_cFBy8ENZs2je3GbFRgGKGl2t8bI8QsiIGd4c,22602
+tnfr/utils/cache.pyi,sha256=sZnm7KKTvpM9CwI2y5v2G9L1NW3Gbo4MNMtC-_zZhOE,3782
+tnfr/utils/data.py,sha256=nQFN0aWYHTX36UkniGXzBrqNYxCabBLVL2Rh99-y8ts,7805
+tnfr/utils/data.pyi,sha256=O3Iy37c8KUE6kFozWTAU2FyaWuUGIrIM3sxdaBgpap4,1595
+tnfr/utils/graph.py,sha256=wnkkAB-yS2KlGRWcwfLwdHjJLcenaa8S2xEzzsVHcRE,2780
+tnfr/utils/graph.pyi,sha256=mrMVWDkJQhu8K3l2eUvOSgKCWlWij7e8pANzJjOFXKA,165
+tnfr/utils/init.py,sha256=4tP7frGVtapI_TLWFW8k83AIzXL3FaGGjDPSmSrcJsU,22561
+tnfr/utils/init.pyi,sha256=26t_q-CeJ5BDyXu80QsYojBknKlKQl7AoRTVgrbQNVw,2446
+tnfr/utils/io.py,sha256=W3-aZ3axvLx0gmYR2zUmUvs9yMH2UPRIbp9Y-Z__rws,4730
+tnfr/utils/io.pyi,sha256=l2_9a0mYrsnM4Frpi7jCxeueUD3-e6fYyKpZVya6ARY,168
+tnfr/utils/validators.py,sha256=R0bvCZO0qXP1OqiVEKLMBX4P5nsy-tyuWKVf6mteg3E,3892
+tnfr/utils/validators.pyi,sha256=6nPYp8N_vLAA8FNyQM_5iR41W8-OZS9oEdZwAz219uw,513
+tnfr/validation/__init__.py,sha256=tVsCpQKc4SoBoQdKktI2pFDsaxzoeZXExSiW-ulXh5o,617
+tnfr/validation/__init__.pyi,sha256=nSObG9II_9WCpYvvw3bOjIjw0iXHw8Sr0bazmXwR94k,315
+tnfr/validation/compatibility.py,sha256=FNNU8VotjVv7eRFMDolixZC7vlsSZRqWLriqkH_gjLk,1788
+tnfr/validation/compatibility.pyi,sha256=ELqyFWaYRgJzcuO-930v0eKxYxJFNCn2-P_AlOvSA-s,116
+tnfr/validation/grammar.py,sha256=XmdRjtkvVWsC4qclG66vR37srO2vtohQgSGDTXIRpz8,4387
+tnfr/validation/grammar.pyi,sha256=uavU-at-x10RBpFw_YcUC7yLepx1uo1B1sJYPGRWH0E,198
+tnfr/validation/rules.py,sha256=fVJ5gX4bUkJQJsA4gBc0IMzirSUUHiGs_fj3sS5yIbM,5814
+tnfr/validation/rules.pyi,sha256=WuHUQDS2o4Wrj7BRovHvwbQ6DiQSomJVgYWB0eyDL5M,305
+tnfr/validation/syntax.py,sha256=O2cpQHv2FABfH7CCIcvg_Kw8zyHMzrwSF5VwjBNCrLg,4573
+tnfr/validation/syntax.pyi,sha256=c8seASIj0bdS0Wof6AhupuTqkvC1x9FdmeEFk8SbETg,101
+tnfr-6.0.0.dist-info/licenses/LICENSE.md,sha256=SRvvhXLrKtseuK6DARbuJffuXOXqAyk3wvF2n0t1SWA,1109
+tnfr-6.0.0.dist-info/METADATA,sha256=61t5DnOqYNsIzIMnNDK8t50Bm3iKIfOwKqhN-_dSeP0,6226
+tnfr-6.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tnfr-6.0.0.dist-info/entry_points.txt,sha256=j4-QRHqeT2WnchHe_mvK7npGTLjlyfLpvRONFe9Z4MU,39
+tnfr-6.0.0.dist-info/top_level.txt,sha256=Q2HJnvc5Rt2VHwVvyBTnNPT4SfmJWnCj7XUxxEvQa7c,5
+tnfr-6.0.0.dist-info/RECORD,,