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

tnfr/__init__.py

@@ -43,7 +43,6 @@ 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",),
@@ -76,6 +75,21 @@ EXPORT_DEPENDENCIES: dict[str, dict[str, tuple[str, ...]]] = {
         ),
         "third_party": ("networkx",),
     },
+    "create_math_nfr": {
+        "submodules": (
+            "tnfr.structural",
+            "tnfr.constants",
+            "tnfr.dynamics",
+            "tnfr.operators.definitions",
+            "tnfr.operators.registry",
+            "tnfr.validation",
+            "tnfr.mathematics",
+        ),
+        "third_party": (
+            "networkx",
+            "numpy",
+        ),
+    },
     "run_sequence": {
         "submodules": (
             "tnfr.structural",
@@ -87,6 +101,27 @@ EXPORT_DEPENDENCIES: dict[str, dict[str, tuple[str, ...]]] = {
         ),
         "third_party": ("networkx",),
     },
+    "get_hz_bridge": {
+        "submodules": (
+            "tnfr.units",
+            "tnfr.constants",
+        ),
+        "third_party": ("networkx",),
+    },
+    "hz_str_to_hz": {
+        "submodules": (
+            "tnfr.units",
+            "tnfr.constants",
+        ),
+        "third_party": ("networkx",),
+    },
+    "hz_to_hz_str": {
+        "submodules": (
+            "tnfr.units",
+            "tnfr.constants",
+        ),
+        "third_party": ("networkx",),
+    },
 }
 
 
@@ -184,7 +219,9 @@ def _validate_export_dependencies() -> None:
                     f"helper '{export_name}' is missing '{key}' dependencies in EXPORT_DEPENDENCIES"
                 )
 
-    missing_exports = manifest_names.difference(export_names).difference(_MISSING_EXPORTS)
+    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):
@@ -235,7 +272,12 @@ _assign_exports("dynamics", ("step", "run"))
 _HAS_PREPARE_NETWORK = _assign_exports("ontosim", ("prepare_network",))
 
 
-_HAS_RUN_SEQUENCE = _assign_exports("structural", ("create_nfr", "run_sequence"))
+_HAS_STRUCTURAL_EXPORTS = _assign_exports(
+    "structural", ("create_nfr", "run_sequence", "create_math_nfr")
+)
+
+
+_assign_exports("units", ("get_hz_bridge", "hz_str_to_hz", "hz_to_hz_str"))
 
 
 def _emit_missing_dependency_warning() -> None:
@@ -261,10 +303,13 @@ __all__ = [
     "run",
     "prepare_network",
     "create_nfr",
+    "get_hz_bridge",
+    "hz_str_to_hz",
+    "hz_to_hz_str",
 ]
 
-if _HAS_RUN_SEQUENCE:
-    __all__.append("run_sequence")
+if _HAS_STRUCTURAL_EXPORTS:
+    __all__.extend(["run_sequence", "create_math_nfr"])
 
 
 _validate_export_dependencies()

tnfr/__init__.pyi

@@ -15,25 +15,18 @@ _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

tnfr/_compat.py

@@ -8,4 +8,3 @@ except (ImportError, AttributeError):  # pragma: no cover - Python < 3.10
     from typing_extensions import TypeAlias  # type: ignore[assignment]
 
 __all__ = ["TypeAlias"]
-

tnfr/_generated_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '7.0.0'
+__version_tuple__ = version_tuple = (7, 0, 0)
+
+__commit_id__ = commit_id = None

tnfr/_version.py

@@ -1,7 +1,49 @@
-"""Package version for :mod:`tnfr`."""
+"""Runtime version discovery for :mod:`tnfr`."""
 
 from __future__ import annotations
 
+import os
+from importlib import metadata
+from typing import Final
+
 __all__ = ["__version__"]
 
-__version__ = "6.0.0"
+
+def _read_version() -> str:
+    """Resolve the published package version while preserving TNFR invariants."""
+
+    env_version = os.environ.get("TNFR_VERSION")
+    if env_version:
+        return env_version
+
+    try:
+        return metadata.version("tnfr")
+    except metadata.PackageNotFoundError:
+        pass
+
+    try:  # pragma: no cover - only present in built distributions
+        from . import _generated_version  # type: ignore
+    except ImportError:  # pragma: no cover - optional artifact
+        pass
+    else:
+        generated = getattr(_generated_version, "version", None)
+        if isinstance(generated, str) and generated:
+            return generated
+        legacy = getattr(_generated_version, "__version__", None)
+        if isinstance(legacy, str) and legacy:
+            return legacy
+
+    try:
+        from setuptools_scm import get_version
+    except Exception:  # pragma: no cover - optional dependency
+        pass
+    else:
+        try:
+            return get_version(relative_to=__file__)
+        except LookupError:
+            pass
+
+    return "0.0.0"
+
+
+__version__: Final[str] = _read_version()

tnfr/alias.py

@@ -7,6 +7,7 @@ alias-based attribute access. Legacy wrappers ``alias_get`` and
 """
 
 from __future__ import annotations
+
 from collections import defaultdict
 from collections.abc import Iterable, Mapping, MutableMapping, Sized
 from dataclasses import dataclass
@@ -24,14 +25,10 @@ from typing import (
     cast,
 )
 
-from .constants import get_aliases
+from .constants.aliases import ALIAS_DNFR, ALIAS_THETA, ALIAS_VF
 from .types import FloatArray, NodeId
 from .utils import convert_value
 
-ALIAS_VF = get_aliases("VF")
-ALIAS_DNFR = get_aliases("DNFR")
-ALIAS_THETA = get_aliases("THETA")
-
 if TYPE_CHECKING:  # pragma: no cover
     import networkx
 
@@ -133,6 +130,8 @@ class AliasAccessor(Generic[T]):
         log_level: int | None = None,
         conv: Callable[[Any], T] | None = None,
     ) -> Optional[T]:
+        """Return ``value`` for the first alias present in ``d``."""
+
         aliases, conv, default = self._prepare(aliases, conv, default)
         cache_key, key = self._resolve_cache_key(d, aliases)
         if key is not None:
@@ -169,6 +168,8 @@ class AliasAccessor(Generic[T]):
         value: Any,
         conv: Callable[[Any], T] | None = None,
     ) -> T:
+        """Write ``value`` under the first matching alias and cache the choice."""
+
         aliases, conv, _ = self._prepare(aliases, conv)
         cache_key, key = self._resolve_cache_key(d, aliases)
         if key is not None:
@@ -269,7 +270,9 @@ def collect_attr(
         return float(get_attr(G.nodes[node], aliases, default))
 
     if np is not None:
-        values: FloatArray = np.fromiter((_value(n) for n in nodes_iter), float, count=size)
+        values: FloatArray = np.fromiter(
+            (_value(n) for n in nodes_iter), float, count=size
+        )
         return values
     return [_value(n) for n in nodes_iter]
 
@@ -297,7 +300,9 @@ def collect_theta_attr(
         return float(get_theta_attr(G.nodes[node], default))
 
     if np is not None:
-        values: FloatArray = np.fromiter((_value(n) for n in nodes_iter), float, count=size)
+        values: FloatArray = np.fromiter(
+            (_value(n) for n in nodes_iter), float, count=size
+        )
         return values
 
     return [_value(n) for n in nodes_iter]
@@ -445,9 +450,7 @@ def _update_cached_abs_max(
     cur_node = cast(Hashable | None, G.graph.get(node_key))
 
     if val >= cur:
-        return _compute_abs_max_result(
-            G, aliases, key=key, candidate=(n, val)
-        )
+        return _compute_abs_max_result(G, aliases, key=key, candidate=(n, val))
     if cur_node == n:
         return _compute_abs_max_result(G, aliases, key=key)
     return AbsMaxResult(max_value=cur, node=cur_node)
@@ -518,9 +521,7 @@ def set_scalar(
     return set_attr_and_cache(G, n, alias, value, cache=cache, extra=extra)
 
 
-def _increment_trig_version(
-    G: "networkx.Graph", _: Hashable, __: float
-) -> None:
+def _increment_trig_version(G: "networkx.Graph", _: Hashable, __: float) -> None:
     """Increment cached trig version to invalidate trig caches."""
     g = G.graph
     g["_trig_version"] = int(g.get("_trig_version", 0)) + 1

tnfr/alias.pyi

@@ -15,15 +15,12 @@ __all__: list[str]
 
 def __getattr__(name: str) -> Any: ...
 
-
 class AbsMaxResult:
     max_value: float
     node: Hashable | None
 
-
 SCALAR_SETTERS: dict[str, dict[str, Any]]
 
-
 def get_attr(
     d: dict[str, Any],
     aliases: Iterable[str],
@@ -33,8 +30,6 @@ def get_attr(
     log_level: int | None = ...,
     conv: Callable[[Any], T] = ...,
 ) -> T | None: ...
-
-
 def get_theta_attr(
     d: Mapping[str, Any],
     default: T | None = ...,
@@ -43,8 +38,6 @@ def get_theta_attr(
     log_level: int | None = ...,
     conv: Callable[[Any], T] = ...,
 ) -> T | None: ...
-
-
 def collect_attr(
     G: "nx.Graph",
     nodes: Iterable[NodeId],
@@ -53,8 +46,6 @@ def collect_attr(
     *,
     np: ModuleType | None = ...,
 ) -> FloatArray | list[float]: ...
-
-
 def collect_theta_attr(
     G: "nx.Graph",
     nodes: Iterable[NodeId],
@@ -62,8 +53,6 @@ def collect_theta_attr(
     *,
     np: ModuleType | None = ...,
 ) -> FloatArray | list[float]: ...
-
-
 def set_attr_generic(
     d: dict[str, Any],
     aliases: Iterable[str],
@@ -71,13 +60,12 @@ def set_attr_generic(
     *,
     conv: Callable[[Any], T],
 ) -> T: ...
-
-
 def set_attr(
-    d: dict[str, Any], aliases: Iterable[str], value: Any, conv: Callable[[Any], T] = ...
+    d: dict[str, Any],
+    aliases: Iterable[str],
+    value: Any,
+    conv: Callable[[Any], T] = ...,
 ) -> T: ...
-
-
 def get_attr_str(
     d: dict[str, Any],
     aliases: Iterable[str],
@@ -87,19 +75,11 @@ def get_attr_str(
     log_level: int | None = ...,
     conv: Callable[[Any], str] = ...,
 ) -> str | None: ...
-
-
 def set_attr_str(d: dict[str, Any], aliases: Iterable[str], value: Any) -> str: ...
-
-
 def set_theta_attr(d: MutableMapping[str, Any], value: Any) -> float: ...
-
-
 def multi_recompute_abs_max(
     G: "nx.Graph", alias_map: Mapping[str, tuple[str, ...]]
 ) -> dict[str, float]: ...
-
-
 def set_attr_and_cache(
     G: "nx.Graph",
     n: Hashable,
@@ -109,13 +89,9 @@ def set_attr_and_cache(
     cache: str | None = ...,
     extra: Callable[["nx.Graph", Hashable, float], None] | None = ...,
 ) -> AbsMaxResult | None: ...
-
-
 def set_attr_with_max(
     G: "nx.Graph", n: Hashable, aliases: tuple[str, ...], value: float, *, cache: str
 ) -> AbsMaxResult: ...
-
-
 def set_scalar(
     G: "nx.Graph",
     n: Hashable,
@@ -125,16 +101,8 @@ def set_scalar(
     cache: str | None = ...,
     extra: Callable[["nx.Graph", Hashable, float], None] | None = ...,
 ) -> AbsMaxResult | None: ...
-
-
 def set_vf(
     G: "nx.Graph", n: Hashable, value: float, *, update_max: bool = ...
 ) -> AbsMaxResult | None: ...
-
-
 def set_dnfr(G: "nx.Graph", n: Hashable, value: float) -> AbsMaxResult | None: ...
-
-
-def set_theta(
-    G: "nx.Graph", n: Hashable, value: float
-) -> AbsMaxResult | None: ...
+def set_theta(G: "nx.Graph", n: Hashable, value: float) -> AbsMaxResult | None: ...