tnfr 4.5.2__py3-none-any.whl → 8.5.0__py3-none-any.whl

tnfr/collections_utils.py

@@ -1,300 +0,0 @@
-"""Utilities for working with generic collections and weight mappings."""
-
-from __future__ import annotations
-
-import logging
-from collections import deque
-from collections.abc import Collection, Iterable, Mapping, Sequence
-from itertools import islice
-from typing import Any, Callable, Iterator, TypeVar, cast
-
-from .logging_utils import get_logger
-from .logging_utils import warn_once as _warn_once_factory
-from .value_utils import convert_value
-from .helpers.numeric import kahan_sum_nd
-
-T = TypeVar("T")
-
-logger = get_logger(__name__)
-
-STRING_TYPES = (str, bytes, bytearray)
-
-NEGATIVE_WEIGHTS_MSG = "Negative weights detected: %s"
-
-_NEGATIVE_WARN_ONCE_MAXSIZE = 1024
-
-
-def negative_weights_warn_once(
-    *, maxsize: int = _NEGATIVE_WARN_ONCE_MAXSIZE
-) -> Callable[[Mapping[str, float]], None]:
-    """Return a ``WarnOnce`` callable for negative weight warnings.
-
-    The returned callable may be reused across multiple
-    :func:`normalize_weights` invocations to suppress duplicate warnings for
-    the same keys.
-    """
-
-    return _warn_once_factory(logger, NEGATIVE_WEIGHTS_MSG, maxsize=maxsize)
-
-
-def _log_negative_weights(negatives: Mapping[str, float]) -> None:
-    """Log negative weight warnings without deduplicating keys."""
-
-    logger.warning(NEGATIVE_WEIGHTS_MSG, negatives)
-
-
-def _resolve_negative_warn_handler(
-    warn_once: bool | Callable[[Mapping[str, float]], None]
-) -> Callable[[Mapping[str, float]], None]:
-    """Return a callable that logs negative weight warnings."""
-
-    if callable(warn_once):
-        return warn_once
-    if warn_once:
-        return negative_weights_warn_once()
-    return _log_negative_weights
-
-
-def is_non_string_sequence(obj: Any) -> bool:
-    """Return ``True`` if ``obj`` is an ``Iterable`` but not string-like or a mapping."""
-    return isinstance(obj, Iterable) and not isinstance(obj, (*STRING_TYPES, Mapping))
-
-
-def flatten_structure(
-    obj: Any,
-    *,
-    expand: Callable[[Any], Iterable[Any] | None] | None = None,
-) -> Iterator[Any]:
-    """Yield leaf items from ``obj``.
-
-    The order of yielded items follows the order of the input iterable when it
-    is defined. For unordered iterables like :class:`set` the resulting order is
-    arbitrary. Mappings are treated as atomic items and not expanded.
-
-    Parameters
-    ----------
-    obj:
-        Object that may contain nested iterables.
-    expand:
-        Optional callable returning a replacement iterable for ``item``. When
-        it returns ``None`` the ``item`` is processed normally.
-    """
-
-    stack = deque([obj])
-    seen: set[int] = set()
-    while stack:
-        item = stack.pop()
-        item_id = id(item)
-        if item_id in seen:
-            continue
-        if expand is not None:
-            replacement = expand(item)
-            if replacement is not None:
-                seen.add(item_id)
-                stack.extendleft(replacement)
-                continue
-        if is_non_string_sequence(item):
-            seen.add(item_id)
-            stack.extendleft(item)
-        else:
-            yield item
-
-
-__all__ = (
-    "MAX_MATERIALIZE_DEFAULT",
-    "normalize_materialize_limit",
-    "is_non_string_sequence",
-    "flatten_structure",
-    "STRING_TYPES",
-    "ensure_collection",
-    "normalize_weights",
-    "negative_weights_warn_once",
-    "normalize_counter",
-    "mix_groups",
-)
-
-MAX_MATERIALIZE_DEFAULT: int = 1000
-"""Default materialization limit used by :func:`ensure_collection`.
-
-This guard prevents accidentally consuming huge or infinite iterables when a
-limit is not explicitly provided. Pass ``max_materialize=None`` to disable the
-limit.
-"""
-
-
-def normalize_materialize_limit(max_materialize: int | None) -> int | None:
-    """Normalize and validate ``max_materialize`` returning a usable limit."""
-    if max_materialize is None:
-        return None
-    limit = int(max_materialize)
-    if limit < 0:
-        raise ValueError("'max_materialize' must be non-negative")
-    return limit
-
-
-def ensure_collection(
-    it: Iterable[T],
-    *,
-    max_materialize: int | None = MAX_MATERIALIZE_DEFAULT,
-    error_msg: str | None = None,
-) -> Collection[T]:
-    """Return ``it`` as a :class:`Collection`, materializing when needed.
-
-    Checks are executed in the following order:
-
-    1. Existing collections are returned directly. String-like inputs
-       (``str``, ``bytes`` and ``bytearray``) are wrapped as a single item
-       tuple.
-    2. The object must be an :class:`Iterable`; otherwise ``TypeError`` is
-       raised.
-    3. Remaining iterables are materialized up to ``max_materialize`` items.
-       ``None`` disables the limit. ``error_msg`` customizes the
-       :class:`ValueError` raised when the iterable yields more items than
-       allowed. The input is consumed at most once and no extra items beyond the
-       limit are stored in memory.
-    """
-
-    # Step 1: early-return for collections and raw strings/bytes
-    if isinstance(it, Collection):
-        if isinstance(it, STRING_TYPES):
-            return (cast(T, it),)
-        else:
-            return it
-
-    # Step 2: ensure the input is iterable
-    if not isinstance(it, Iterable):
-        raise TypeError(f"{it!r} is not iterable")
-
-    # Step 3: validate limit and materialize items once
-    limit = normalize_materialize_limit(max_materialize)
-    if limit is None:
-        return tuple(it)
-    if limit == 0:
-        return ()
-
-    items = tuple(islice(it, limit + 1))
-    if len(items) > limit:
-        examples = ", ".join(repr(x) for x in items[:3])
-        msg = error_msg or (
-            f"Iterable produced {len(items)} items, exceeds limit {limit}; first items: [{examples}]"
-        )
-        raise ValueError(msg)
-    return items
-
-
-def _convert_and_validate_weights(
-    dict_like: Mapping[str, Any],
-    keys: Iterable[str] | Sequence[str],
-    default: float,
-    *,
-    error_on_conversion: bool,
-    error_on_negative: bool,
-    warn_once: bool | Callable[[Mapping[str, float]], None],
-) -> tuple[dict[str, float], list[str], float]:
-    """Return converted weights, deduplicated keys and the accumulated total."""
-
-    keys_list = list(dict.fromkeys(keys))
-    default_float = float(default)
-
-    def convert(k: str) -> float:
-        ok, val = convert_value(
-            dict_like.get(k, default_float),
-            float,
-            strict=error_on_conversion,
-            key=k,
-            log_level=logging.WARNING,
-        )
-        return cast(float, val) if ok else default_float
-
-    weights = {k: convert(k) for k in keys_list}
-    negatives = {k: w for k, w in weights.items() if w < 0}
-    total = kahan_sum_nd(((w,) for w in weights.values()), dims=1)[0]
-
-    if negatives:
-        if error_on_negative:
-            raise ValueError(NEGATIVE_WEIGHTS_MSG % negatives)
-        warn_negative = _resolve_negative_warn_handler(warn_once)
-        warn_negative(negatives)
-        for key, weight in negatives.items():
-            weights[key] = 0.0
-            total -= weight
-
-    return weights, keys_list, total
-
-
-def normalize_weights(
-    dict_like: Mapping[str, Any],
-    keys: Iterable[str] | Sequence[str],
-    default: float = 0.0,
-    *,
-    error_on_negative: bool = False,
-    warn_once: bool | Callable[[Mapping[str, float]], None] = True,
-    error_on_conversion: bool = False,
-) -> dict[str, float]:
-    """Normalize ``keys`` in mapping ``dict_like`` so their sum is 1.
-
-    ``keys`` may be any iterable of strings and is materialized once while
-    collapsing repeated entries preserving their first occurrence.
-
-    Negative weights are handled according to ``error_on_negative``. When
-    ``True`` a :class:`ValueError` is raised. Otherwise negatives are logged,
-    replaced with ``0`` and the remaining weights are renormalized. If all
-    weights are non-positive a uniform distribution is returned.
-
-    Conversion errors are controlled separately by ``error_on_conversion``. When
-    ``True`` any :class:`TypeError` or :class:`ValueError` while converting a
-    value to ``float`` is propagated. Otherwise the error is logged and the
-    ``default`` value is used.
-
-    ``warn_once`` accepts either a boolean or a callable. ``False`` logs all
-    negative weights using :func:`logging.Logger.warning`. ``True`` (the
-    default) creates a fresh :class:`~tnfr.logging_utils.WarnOnce` instance for
-    the call, emitting a single warning containing all negative keys. To reuse
-    deduplication state across calls, pass a callable such as
-    :func:`negative_weights_warn_once`.
-    """
-    weights, keys_list, total = _convert_and_validate_weights(
-        dict_like,
-        keys,
-        default,
-        error_on_conversion=error_on_conversion,
-        error_on_negative=error_on_negative,
-        warn_once=warn_once,
-    )
-    if not keys_list:
-        return {}
-    if total <= 0:
-        uniform = 1.0 / len(keys_list)
-        return {k: uniform for k in keys_list}
-    return {k: w / total for k, w in weights.items()}
-
-
-def normalize_counter(
-    counts: Mapping[str, float | int],
-) -> tuple[dict[str, float], float]:
-    """Normalize a ``Counter`` returning proportions and total."""
-    total = kahan_sum_nd(((c,) for c in counts.values()), dims=1)[0]
-    if total <= 0:
-        return {}, 0
-    dist = {k: v / total for k, v in counts.items() if v}
-    return dist, total
-
-
-def mix_groups(
-    dist: Mapping[str, float],
-    groups: Mapping[str, Iterable[str]],
-    *,
-    prefix: str = "_",
-) -> dict[str, float]:
-    """Aggregate values of ``dist`` according to ``groups``."""
-    out: dict[str, float] = dict(dist)
-    out.update(
-        {
-            f"{prefix}{label}": kahan_sum_nd(
-                ((dist.get(k, 0.0),) for k in keys),
-                dims=1,
-            )[0]
-            for label, keys in groups.items()
-        }
-    )
-    return out

tnfr/config.py

@@ -1,32 +0,0 @@
-"""Configuration utilities."""
-
-from __future__ import annotations
-from typing import Any, TYPE_CHECKING
-from collections.abc import Mapping
-from pathlib import Path
-from .io import read_structured_file
-
-from .constants import inject_defaults
-
-if TYPE_CHECKING:  # pragma: no cover - only for type checkers
-    import networkx as nx  # type: ignore[import-untyped]
-
-__all__ = ("load_config", "apply_config")
-
-
-def load_config(path: str | Path) -> Mapping[str, Any]:
-    """Read a JSON/YAML file and return a mapping with parameters."""
-    path_obj = path if isinstance(path, Path) else Path(path)
-    data = read_structured_file(path_obj)
-    if not isinstance(data, Mapping):
-        raise ValueError("Configuration file must contain an object")
-    return data
-
-
-def apply_config(G: nx.Graph, path: str | Path) -> None:
-    """Inject parameters from ``path`` into ``G.graph``.
-
-    Reuses :func:`inject_defaults` to keep canonical default semantics.
-    """
-    cfg = load_config(path)
-    inject_defaults(G, cfg, override=True)

tnfr/grammar.py

@@ -1,344 +0,0 @@
-"""Grammar rules."""
-
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import Any, Iterable, Optional, Callable
-
-from .constants import DEFAULTS, get_aliases, get_param
-from .alias import get_attr
-from .helpers.numeric import clamp01
-from .glyph_history import recent_glyph
-from .types import Glyph
-from .operators import apply_glyph  # avoid repeated import inside functions
-from .metrics.common import normalize_dnfr
-
-ALIAS_SI = get_aliases("SI")
-ALIAS_D2EPI = get_aliases("D2EPI")
-
-
-@dataclass
-class GrammarContext:
-    """Shared context for grammar helpers.
-
-    Collects graph-level settings to reduce positional parameters across
-    helper functions.
-    """
-
-    G: Any
-    cfg_soft: dict[str, Any]
-    cfg_canon: dict[str, Any]
-    norms: dict[str, Any]
-
-    @classmethod
-    def from_graph(cls, G: Any) -> "GrammarContext":
-        """Create a :class:`GrammarContext` for ``G``."""
-        return cls(
-            G=G,
-            cfg_soft=G.graph.get("GRAMMAR", DEFAULTS.get("GRAMMAR", {})),
-            cfg_canon=G.graph.get(
-                "GRAMMAR_CANON", DEFAULTS.get("GRAMMAR_CANON", {})
-            ),
-            norms=G.graph.get("_sel_norms") or {},
-        )
-
-
-__all__ = (
-    "CANON_COMPAT",
-    "CANON_FALLBACK",
-    "enforce_canonical_grammar",
-    "on_applied_glyph",
-    "apply_glyph_with_grammar",
-    "GrammarContext",
-)
-
-# -------------------------
-# Per-node grammar state
-# -------------------------
-
-
-def _gram_state(nd: dict[str, Any]) -> dict[str, Any]:
-    """Create or return the node grammar state.
-
-    Fields:
-      - thol_open (bool)
-      - thol_len (int)
-    """
-    return nd.setdefault("_GRAM", {"thol_open": False, "thol_len": 0})
-
-
-# -------------------------
-# Canonical compatibilities (allowed next glyphs)
-# -------------------------
-CANON_COMPAT: dict[Glyph, set[Glyph]] = {
-    # Inicio / apertura
-    Glyph.AL: {Glyph.EN, Glyph.RA, Glyph.NAV, Glyph.VAL, Glyph.UM},
-    Glyph.EN: {Glyph.IL, Glyph.UM, Glyph.RA, Glyph.NAV},
-    # Estabilización / difusión / acople
-    Glyph.IL: {Glyph.RA, Glyph.VAL, Glyph.UM, Glyph.SHA},
-    Glyph.UM: {Glyph.RA, Glyph.IL, Glyph.VAL, Glyph.NAV},
-    Glyph.RA: {Glyph.IL, Glyph.VAL, Glyph.UM, Glyph.NAV},
-    Glyph.VAL: {Glyph.UM, Glyph.RA, Glyph.IL, Glyph.NAV},
-    # Disonancia → transición → mutación
-    Glyph.OZ: {Glyph.ZHIR, Glyph.NAV},
-    Glyph.ZHIR: {Glyph.IL, Glyph.NAV},
-    Glyph.NAV: {Glyph.OZ, Glyph.ZHIR, Glyph.RA, Glyph.IL, Glyph.UM},
-    # Cierres / latencias
-    Glyph.SHA: {Glyph.AL, Glyph.EN},
-    Glyph.NUL: {Glyph.AL, Glyph.IL},
-    # Bloques autoorganizativos
-    Glyph.THOL: {
-        Glyph.OZ,
-        Glyph.ZHIR,
-        Glyph.NAV,
-        Glyph.RA,
-        Glyph.IL,
-        Glyph.UM,
-        Glyph.SHA,
-        Glyph.NUL,
-    },
-}
-
-# Canonical fallbacks when a transition is not allowed
-CANON_FALLBACK: dict[Glyph, Glyph] = {
-    Glyph.AL: Glyph.EN,
-    Glyph.EN: Glyph.IL,
-    Glyph.IL: Glyph.RA,
-    Glyph.NAV: Glyph.RA,
-    Glyph.NUL: Glyph.AL,
-    Glyph.OZ: Glyph.ZHIR,
-    Glyph.RA: Glyph.IL,
-    Glyph.SHA: Glyph.AL,
-    Glyph.THOL: Glyph.NAV,
-    Glyph.UM: Glyph.RA,
-    Glyph.VAL: Glyph.RA,
-    Glyph.ZHIR: Glyph.IL,
-}
-
-
-def _coerce_glyph(val: Any) -> Glyph | Any:
-    """Return ``val`` as ``Glyph`` when possible."""
-    try:
-        return Glyph(val)
-    except (ValueError, TypeError):
-        return val
-
-
-def _glyph_fallback(cand_key: str, fallbacks: dict[str, Any]) -> Glyph | str:
-    """Determine fallback glyph for ``cand_key`` and return converted value."""
-    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)
-
-
-# -------------------------
-# THOL closures and ZHIR preconditions
-# -------------------------
-
-
-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 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 _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:
-    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))
-        dnfr_max = get_norm(ctx, "dnfr_max")
-        if (
-            not recent_glyph(nd, Glyph.OZ, win)
-            and normalize_dnfr(nd, dnfr_max) < dn_min
-        ):
-            return Glyph.OZ
-    return cand
-
-
-def _check_thol_closure(
-    ctx: GrammarContext, n, cand: Glyph | str, st: dict[str, Any]
-) -> Glyph | str:
-    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))
-        dnfr_max = get_norm(ctx, "dnfr_max")
-        if st["thol_len"] >= maxlen or (
-            st["thol_len"] >= minlen
-            and normalize_dnfr(nd, dnfr_max) <= 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:
-    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
-
-
-# -------------------------
-# Core: enforce grammar on a candidate
-# -------------------------
-
-
-def enforce_canonical_grammar(
-    G, n, cand: Glyph | str, ctx: Optional[GrammarContext] = None
-) -> Glyph | str:
-    """Validate and adjust a candidate glyph according to canonical grammar.
-
-    Key rules:
-      - Repeat window with forces based on |ΔNFR| and acceleration.
-      - Transition compatibilities (TNFR path).
-      - OZ→ZHIR: mutation requires recent dissonance or high |ΔNFR|.
-      - THOL[...]: forces closure with SHA or NUL when the field stabilises
-        or block length is reached; maintains per-node state.
-
-    Returns the effective glyph to apply.
-    """
-    if ctx is None:
-        ctx = GrammarContext.from_graph(G)
-
-    nd = ctx.G.nodes[n]
-    st = _gram_state(nd)
-
-    raw_cand = cand
-    cand = _coerce_glyph(cand)
-    input_was_str = isinstance(raw_cand, str)
-
-    # 0) If glyphs outside the alphabet arrive, leave untouched
-    if not isinstance(cand, Glyph) or cand not in CANON_COMPAT:
-        return raw_cand if input_was_str else cand
-
-    original = cand
-    cand = _check_repeats(ctx, n, cand)
-
-    dnfr_accessor = lambda ctx, nd: normalize_dnfr(nd, get_norm(ctx, "dnfr_max"))
-    cand = _maybe_force(ctx, n, cand, original, dnfr_accessor, "force_dnfr")
-    cand = _maybe_force(ctx, n, cand, original, _accel_norm, "force_accel")
-    cand = _check_oz_to_zhir(ctx, n, cand)
-    cand = _check_thol_closure(ctx, n, cand, st)
-    cand = _check_compatibility(ctx, n, cand)
-
-    coerced_final = _coerce_glyph(cand)
-    if input_was_str:
-        if isinstance(coerced_final, Glyph):
-            return coerced_final.value
-        return str(cand)
-    return coerced_final if isinstance(coerced_final, Glyph) else cand
-
-
-# -------------------------
-# Post-selection: update grammar state
-# -------------------------
-
-
-def on_applied_glyph(G, n, applied: str) -> None:
-    nd = G.nodes[n]
-    st = _gram_state(nd)
-    if applied == Glyph.THOL:
-        st["thol_open"] = True
-        st["thol_len"] = 0
-    elif applied in (Glyph.SHA, Glyph.NUL):
-        st["thol_open"] = False
-        st["thol_len"] = 0
-
-
-# -------------------------
-# Direct application with canonical grammar
-# -------------------------
-
-
-def apply_glyph_with_grammar(
-    G,
-    nodes: Optional[Iterable[Any]],
-    glyph: Glyph | str,
-    window: Optional[int] = None,
-) -> None:
-    """Apply ``glyph`` to ``nodes`` enforcing the canonical grammar.
-
-    ``nodes`` may be a ``NodeView`` or any iterable. The iterable is consumed
-    directly to avoid unnecessary materialisation; callers must materialise if
-    they need indexing.
-    """
-    if window is None:
-        window = get_param(G, "GLYPH_HYSTERESIS_WINDOW")
-
-    g_str = glyph.value if isinstance(glyph, Glyph) else str(glyph)
-    iter_nodes = G.nodes() if nodes is None else nodes
-    ctx = GrammarContext.from_graph(G)
-    for n in iter_nodes:
-        g_eff = enforce_canonical_grammar(G, n, g_str, ctx)
-        apply_glyph(G, n, g_eff, window=window)
-        on_applied_glyph(G, n, g_eff)