tnfr 4.5.1__tar.gz → 6.0.0__tar.gz

tnfr-6.0.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,86 @@
+# 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/pyproject.toml

@@ -0,0 +1,115 @@
+[project]
+name = "tnfr"
+dynamic = ["version"]
+description = "Modular structural-based dynamics on networks."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "fmg" }]
+keywords = [
+  "TNFR", "complex systems", "fractals", "resonance", 
+  "networks", "structural dynamics", 
+  "structural analysis"
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering",
+  "Topic :: Scientific/Engineering :: Information Analysis",
+  "Topic :: Scientific/Engineering :: Mathematics"
+]
+dependencies = [
+  "networkx>=2.6",
+  "cachetools>=5",
+  "typing-extensions>=4.4; python_version < \"3.10\"",
+]
+
+[project.optional-dependencies]
+numpy = ["numpy>=1.24"]
+yaml = ["pyyaml>=6.0"]
+orjson = ["orjson>=3"]
+test = [
+  "pytest>=7",
+  "pytest-benchmark>=4",
+  "pydocstyle>=6",
+  "coverage>=7",
+  "flake8>=5",
+  "flake8-pyproject>=1.2",
+  "vulture>=2",
+]
+typecheck = [
+  "mypy>=1.8",
+  "networkx-stubs>=0.0.1",
+  "types-cachetools>=6.0.0.0",
+  "numpy>=1.24",
+]
+
+[project.scripts]
+tnfr = "tnfr.cli:main"
+
+[project.urls]
+Homepage = "https://pypi.org/project/tnfr/"
+Repository = "https://github.com/fermga/TNFR-Python-Engine"
+GPT = "https://chatgpt.com/g/g-67abc78885a88191b2d67f94fd60dc97-tnfr-teoria-de-la-naturaleza-fractal-resonante"
+
+[tool.setuptools.dynamic]
+version = { attr = "tnfr._version.__version__" }
+
+[tool.setuptools.package-data]
+tnfr = ["py.typed"]
+
+[tool.black]
+line-length = 88
+target-version = ["py39", "py310", "py311", "py312"]
+
+[tool.isort]
+profile = "black"
+line_length = 88
+skip = ["benchmarks"]
+
+[tool.flake8]
+max-line-length = 88
+ignore = ["E501", "W503"]
+exclude = ["benchmarks/"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+addopts = "-m 'not slow' --benchmark-skip"
+markers = [
+  "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+  "benchmarks: run with 'pytest benchmarks --benchmark-only' to execute the benchmark suite",
+]
+
+[tool.mypy]
+python_version = "3.10"
+warn_unused_configs = true
+warn_return_any = false
+no_implicit_optional = false
+strict_equality = false
+disallow_any_unimported = false
+show_error_codes = true
+follow_imports = "skip"
+allow_redefinition = true
+allow_untyped_defs = false
+allow_untyped_calls = false
+allow_untyped_globals = false
+
+[[tool.mypy.overrides]]
+module = ["networkx", "networkx.*"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["yaml", "yaml.*"]
+ignore_missing_imports = true
+
+
+[build-system]
+requires = ["setuptools>=78.1.1", "wheel"]
+build-backend = "setuptools.build_meta"

tnfr-6.0.0/src/tnfr/__init__.py

@@ -0,0 +1,270 @@
+"""Minimal public API for :mod:`tnfr`.
+
+This package only re-exports a handful of high level helpers.  Most
+functionality lives in submodules that should be imported directly, for
+example :mod:`tnfr.metrics`, :mod:`tnfr.observers` or the DSL utilities
+in :mod:`tnfr.tokens`, :mod:`tnfr.flatten` and :mod:`tnfr.execution`.
+
+Exported helpers and their dependencies
+---------------------------------------
+The :data:`EXPORT_DEPENDENCIES` mapping enumerates which internal
+submodules and third-party packages are required to load each helper.
+The imports are grouped as follows:
+
+``step`` / ``run``
+    Provided by :mod:`tnfr.dynamics`.  These helpers rely on the
+    machinery defined within the :mod:`tnfr.dynamics` package (operator
+    orchestration, validation hooks and metrics integration) and require
+    the ``networkx`` package for graph handling.
+
+``prepare_network``
+    Defined in :mod:`tnfr.ontosim`.  Besides :mod:`tnfr.ontosim`
+    itself, the helper imports :mod:`tnfr.callback_utils`,
+    :mod:`tnfr.constants`, :mod:`tnfr.dynamics`, :mod:`tnfr.glyph_history`,
+    :mod:`tnfr.initialization` and :mod:`tnfr.utils` to assemble the
+    graph preparation pipeline.  It also requires ``networkx`` at import
+    time.
+
+``create_nfr`` / ``run_sequence``
+    Re-exported from :mod:`tnfr.structural`.  They depend on
+    :mod:`tnfr.structural`, :mod:`tnfr.constants`, :mod:`tnfr.dynamics`,
+    :mod:`tnfr.operators.definitions`, :mod:`tnfr.operators.registry` and
+    :mod:`tnfr.validation`, and additionally require the ``networkx``
+    package.
+
+``cached_import`` and ``prune_failed_imports`` remain available from
+``tnfr.utils`` for optional dependency management.
+"""
+
+from __future__ import annotations
+
+import warnings
+from importlib import import_module, metadata
+from importlib.metadata import PackageNotFoundError
+from typing import Any, Callable, NoReturn
+
+
+EXPORT_DEPENDENCIES: dict[str, dict[str, tuple[str, ...]]] = {
+    "step": {
+        "submodules": ("tnfr.dynamics",),
+        "third_party": ("networkx",),
+    },
+    "run": {
+        "submodules": ("tnfr.dynamics",),
+        "third_party": ("networkx",),
+    },
+    "prepare_network": {
+        "submodules": (
+            "tnfr.ontosim",
+            "tnfr.callback_utils",
+            "tnfr.constants",
+            "tnfr.dynamics",
+            "tnfr.glyph_history",
+            "tnfr.initialization",
+            "tnfr.utils",
+        ),
+        "third_party": ("networkx",),
+    },
+    "create_nfr": {
+        "submodules": (
+            "tnfr.structural",
+            "tnfr.constants",
+            "tnfr.dynamics",
+            "tnfr.operators.definitions",
+            "tnfr.operators.registry",
+            "tnfr.validation",
+        ),
+        "third_party": ("networkx",),
+    },
+    "run_sequence": {
+        "submodules": (
+            "tnfr.structural",
+            "tnfr.constants",
+            "tnfr.dynamics",
+            "tnfr.operators.definitions",
+            "tnfr.operators.registry",
+            "tnfr.validation",
+        ),
+        "third_party": ("networkx",),
+    },
+}
+
+
+try:  # pragma: no cover - exercised in version resolution tests
+    __version__ = metadata.version("tnfr")
+except PackageNotFoundError:  # pragma: no cover - fallback tested explicitly
+    from ._version import __version__ as _fallback_version
+
+    __version__ = _fallback_version
+
+
+def _is_internal_import_error(exc: ImportError) -> bool:
+    missing_name = getattr(exc, "name", None) or ""
+    if missing_name.startswith("tnfr"):
+        return True
+
+    module_name = getattr(exc, "module", None) or ""
+    if module_name.startswith("tnfr"):
+        return True
+
+    missing_path = getattr(exc, "path", None) or ""
+    if missing_path:
+        normalized = missing_path.replace("\\", "/")
+        if "/tnfr/" in normalized or normalized.endswith("/tnfr"):
+            return True
+
+    message = str(exc)
+    lowered = message.lower()
+    mentions_base_package = "module 'tnfr'" in lowered or 'module "tnfr"' in lowered
+    if ("tnfr." in message or mentions_base_package) and (
+        "circular import" in lowered or "partially initialized module" in lowered
+    ):
+        return True
+
+    return False
+
+
+def _missing_dependency(
+    name: str, exc: ImportError, *, module: str | None = None
+) -> Callable[..., NoReturn]:
+    missing_name = getattr(exc, "name", None)
+
+    def _stub(*args: Any, **kwargs: Any) -> NoReturn:
+        raise ImportError(
+            f"{name} is unavailable because required dependencies could not be imported. "
+            f"Original error ({exc.__class__.__name__}): {exc}. "
+            "Install the missing packages (e.g. 'networkx' or grammar modules)."
+        ) from exc
+
+    _stub.__tnfr_missing_dependency__ = {
+        "export": name,
+        "module": module,
+        "missing": missing_name,
+    }
+    return _stub
+
+
+_MISSING_EXPORTS: dict[str, dict[str, Any]] = {}
+
+
+class ExportDependencyError(RuntimeError):
+    """Raised when the export dependency manifest is inconsistent."""
+
+
+def _validate_export_dependencies() -> None:
+    """Ensure exported helpers and their manifest entries stay in sync."""
+
+    if "__all__" not in globals():
+        # Defensive guard for unusual import orders (should never trigger).
+        return
+
+    issues: list[str] = []
+    manifest = EXPORT_DEPENDENCIES
+    export_names = [name for name in __all__ if name != "__version__"]
+    manifest_names = set(manifest)
+
+    for export_name in export_names:
+        if export_name not in manifest:
+            issues.append(
+                f"helper '{export_name}' is exported via __all__ but missing from EXPORT_DEPENDENCIES"
+            )
+            continue
+
+        entry = manifest[export_name]
+        if not isinstance(entry, dict):
+            issues.append(
+                f"helper '{export_name}' has a malformed manifest entry (expected mapping, got {type(entry)!r})"
+            )
+            continue
+
+        for key in ("submodules", "third_party"):
+            value = entry.get(key)
+            if not value:
+                issues.append(
+                    f"helper '{export_name}' is missing '{key}' dependencies in EXPORT_DEPENDENCIES"
+                )
+
+    missing_exports = manifest_names.difference(export_names).difference(_MISSING_EXPORTS)
+    for manifest_only in sorted(missing_exports):
+        entry = manifest[manifest_only]
+        if not isinstance(entry, dict):
+            issues.append(
+                f"helper '{manifest_only}' has a malformed manifest entry (expected mapping, got {type(entry)!r})"
+            )
+            continue
+
+        for key in ("submodules", "third_party"):
+            value = entry.get(key)
+            if not value:
+                issues.append(
+                    f"helper '{manifest_only}' is missing '{key}' dependencies in EXPORT_DEPENDENCIES"
+                )
+
+        issues.append(
+            f"helper '{manifest_only}' is listed in EXPORT_DEPENDENCIES but not exported via __all__"
+        )
+
+    if issues:
+        raise ExportDependencyError(
+            "Invalid TNFR export dependency manifest:\n- " + "\n- ".join(issues)
+        )
+
+
+def _assign_exports(module: str, names: tuple[str, ...]) -> bool:
+    try:  # pragma: no cover - exercised in import tests
+        mod = import_module(f".{module}", __name__)
+    except ImportError as exc:  # pragma: no cover - no missing deps in CI
+        if _is_internal_import_error(exc):
+            raise
+        for export_name in names:
+            stub = _missing_dependency(export_name, exc, module=module)
+            globals()[export_name] = stub
+            _MISSING_EXPORTS[export_name] = getattr(
+                stub, "__tnfr_missing_dependency__", {}
+            )
+        return False
+    else:
+        for export_name in names:
+            globals()[export_name] = getattr(mod, export_name)
+        return True
+
+
+_assign_exports("dynamics", ("step", "run"))
+
+
+_HAS_PREPARE_NETWORK = _assign_exports("ontosim", ("prepare_network",))
+
+
+_HAS_RUN_SEQUENCE = _assign_exports("structural", ("create_nfr", "run_sequence"))
+
+
+def _emit_missing_dependency_warning() -> None:
+    if not _MISSING_EXPORTS:
+        return
+    details = ", ".join(
+        f"{name} (missing: {info.get('missing') or 'unknown'})"
+        for name, info in sorted(_MISSING_EXPORTS.items())
+    )
+    warnings.warn(
+        "TNFR helpers disabled because dependencies are missing: " + details,
+        ImportWarning,
+        stacklevel=2,
+    )
+
+
+_emit_missing_dependency_warning()
+
+
+__all__ = [
+    "__version__",
+    "step",
+    "run",
+    "prepare_network",
+    "create_nfr",
+]
+
+if _HAS_RUN_SEQUENCE:
+    __all__.append("run_sequence")
+
+
+_validate_export_dependencies()

tnfr-6.0.0/src/tnfr/__init__.pyi

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, NoReturn
+
+from .dynamics import run, step
+from .ontosim import prepare_network
+from .structural import create_nfr, run_sequence
+
+EXPORT_DEPENDENCIES: dict[str, dict[str, tuple[str, ...]]]
+"""Manifest describing required submodules and third-party packages."""
+
+_MISSING_EXPORTS: dict[str, dict[str, Any]]
+
+__version__: str
+__all__: list[str]
+
+
+class ExportDependencyError(RuntimeError):
+    """Raised when the export dependency manifest is inconsistent."""
+
+
+def _is_internal_import_error(exc: ImportError) -> bool: ...
+
+def _missing_dependency(
+    name: str,
+    exc: ImportError,
+    *,
+    module: str | None = ...,
+) -> Callable[..., NoReturn]: ...
+
+
+def _validate_export_dependencies() -> None: ...
+
+def _assign_exports(module: str, names: tuple[str, ...]) -> bool: ...
+
+def _emit_missing_dependency_warning() -> None: ...
+
+_HAS_PREPARE_NETWORK: bool
+_HAS_RUN_SEQUENCE: bool

tnfr-6.0.0/src/tnfr/_compat.py

@@ -0,0 +1,11 @@
+"""Compatibility helpers for bridging typing features across Python versions."""
+
+from __future__ import annotations
+
+try:  # pragma: no cover - exercised implicitly by importers
+    from typing import TypeAlias  # type: ignore[attr-defined]
+except (ImportError, AttributeError):  # pragma: no cover - Python < 3.10
+    from typing_extensions import TypeAlias  # type: ignore[assignment]
+
+__all__ = ["TypeAlias"]
+

tnfr-6.0.0/src/tnfr/_version.py

@@ -0,0 +1,7 @@
+"""Package version for :mod:`tnfr`."""
+
+from __future__ import annotations
+
+__all__ = ["__version__"]
+
+__version__ = "6.0.0"

tnfr-6.0.0/src/tnfr/_version.pyi

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