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

tnfr/callback_utils.py

@@ -9,22 +9,20 @@ modify shared state.
 
 from __future__ import annotations
 
-
-from typing import Any, TypedDict
-from enum import Enum
+import threading
+import traceback
 from collections import defaultdict, deque
-from collections.abc import Callable, Mapping, Iterable
+from collections.abc import Callable, Iterable, Mapping
+from enum import Enum
+from typing import Any
+
+import networkx as nx
 
-import traceback
-import threading
-from .logging_utils import get_logger
 from .constants import DEFAULTS
 from .locking import get_lock
-
 from .trace import CallbackSpec
-from .collections_utils import is_non_string_sequence
-
-import networkx as nx  # type: ignore[import-untyped]
+from .utils import get_logger, is_non_string_sequence
+from .types import CallbackError
 
 __all__ = (
     "CallbackEvent",
@@ -42,6 +40,7 @@ class CallbackEvent(str, Enum):
     BEFORE_STEP = "before_step"
     AFTER_STEP = "after_step"
     ON_REMESH = "on_remesh"
+    CACHE_METRICS = "cache_metrics"
 
 
 class CallbackManager:
@@ -131,9 +130,7 @@ class CallbackManager:
             cb_name = name or getattr(func, "__name__", None)
             spec = CallbackSpec(cb_name, func)
             existing_map = cbs[event]
-            strict = bool(
-                G.graph.get("CALLBACKS_STRICT", DEFAULTS["CALLBACKS_STRICT"])
-            )
+            strict = bool(G.graph.get("CALLBACKS_STRICT", DEFAULTS["CALLBACKS_STRICT"]))
             key = _reconcile_callback(event, existing_map, spec, strict)
 
             existing_map[key] = spec
@@ -152,9 +149,7 @@ class CallbackManager:
         event = _normalize_event(event)
         with self._lock:
             cbs = dict(self._ensure_callbacks_nolock(G).get(event, {}))
-            strict = bool(
-                G.graph.get("CALLBACKS_STRICT", DEFAULTS["CALLBACKS_STRICT"])
-            )
+            strict = bool(G.graph.get("CALLBACKS_STRICT", DEFAULTS["CALLBACKS_STRICT"]))
         if ctx is None:
             ctx = {}
         for spec in cbs.values():
@@ -185,17 +180,6 @@ Callback = Callable[["nx.Graph", dict[str, Any]], None]
 CallbackRegistry = dict[str, dict[str, "CallbackSpec"]]
 
 
-class CallbackError(TypedDict):
-    """Metadata for a failed callback invocation."""
-
-    event: str
-    step: int | None
-    error: str
-    traceback: str
-    fn: str
-    name: str | None
-
-
 def _func_id(fn: Callable[..., Any]) -> str:
     """Return a deterministic identifier for ``fn``.
 
@@ -211,9 +195,7 @@ def _func_id(fn: Callable[..., Any]) -> str:
     return f"{module}.{qualname}"
 
 
-def _validate_registry(
-    G: "nx.Graph", cbs: Any, dirty: set[str]
-) -> CallbackRegistry:
+def _validate_registry(G: "nx.Graph", cbs: Any, dirty: set[str]) -> CallbackRegistry:
     """Validate and normalise the callback registry.
 
     ``cbs`` is coerced to a ``defaultdict(dict)`` and any events listed in
@@ -246,13 +228,13 @@ def _validate_registry(
     return cbs
 
 
-
-
 def _normalize_callbacks(entries: Any) -> dict[str, CallbackSpec]:
     """Return ``entries`` normalised into a callback mapping."""
     if isinstance(entries, Mapping):
         entries_iter = entries.values()
-    elif isinstance(entries, Iterable) and not isinstance(entries, (str, bytes, bytearray)):
+    elif isinstance(entries, Iterable) and not isinstance(
+        entries, (str, bytes, bytearray)
+    ):
         entries_iter = entries
     else:
         return {}
@@ -328,7 +310,6 @@ def _normalize_callback_entry(entry: Any) -> "CallbackSpec | None":
         return None
 
 
-
 def _reconcile_callback(
     event: str,
     existing_map: dict[str, CallbackSpec],
@@ -383,6 +364,3 @@ def _reconcile_callback(
 # ---------------------------------------------------------------------------
 
 callback_manager = CallbackManager()
-
-
-

tnfr/callback_utils.pyi

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import threading
+import traceback
+from collections import defaultdict, deque
+from collections.abc import Callable, Iterable, Mapping
+from enum import Enum
+from typing import Any
+
+import networkx as nx
+
+from .constants import DEFAULTS
+from .locking import get_lock
+from .trace import CallbackSpec
+from .types import CallbackError
+from .utils import get_logger, is_non_string_sequence
+
+__all__ = (
+    "CallbackEvent",
+    "CallbackManager",
+    "callback_manager",
+    "CallbackError",
+)
+
+logger: Any
+
+class CallbackEvent(str, Enum):
+    BEFORE_STEP = "before_step"
+    AFTER_STEP = "after_step"
+    ON_REMESH = "on_remesh"
+    CACHE_METRICS = "cache_metrics"
+
+Callback = Callable[[nx.Graph, dict[str, Any]], None]
+CallbackRegistry = dict[str, dict[str, CallbackSpec]]
+
+class CallbackManager:
+    def __init__(self) -> None: ...
+    def get_callback_error_limit(self) -> int: ...
+    def set_callback_error_limit(self, limit: int) -> int: ...
+    def register_callback(
+        self,
+        G: nx.Graph,
+        event: CallbackEvent | str,
+        func: Callback,
+        *,
+        name: str | None = ...,
+    ) -> Callback: ...
+    def invoke_callbacks(
+        self,
+        G: nx.Graph,
+        event: CallbackEvent | str,
+        ctx: dict[str, Any] | None = ...,
+    ) -> None: ...
+    def _record_callback_error(
+        self,
+        G: nx.Graph,
+        event: str,
+        ctx: dict[str, Any],
+        spec: CallbackSpec,
+        err: Exception,
+    ) -> None: ...
+    def _ensure_callbacks_nolock(self, G: nx.Graph) -> CallbackRegistry: ...
+    def _ensure_callbacks(self, G: nx.Graph) -> CallbackRegistry: ...
+
+callback_manager: CallbackManager
+
+def _func_id(fn: Callable[..., Any]) -> str: ...
+def _validate_registry(G: nx.Graph, cbs: Any, dirty: set[str]) -> CallbackRegistry: ...
+def _normalize_callbacks(entries: Any) -> dict[str, CallbackSpec]: ...
+def _normalize_event(event: CallbackEvent | str) -> str: ...
+def _is_known_event(event: str) -> bool: ...
+def _ensure_known_event(event: str) -> None: ...
+def _normalize_callback_entry(entry: Any) -> CallbackSpec | None: ...
+def _reconcile_callback(
+    event: str,
+    existing_map: dict[str, CallbackSpec],
+    spec: CallbackSpec,
+    strict: bool,
+) -> str: ...

tnfr/cli/__init__.py

@@ -1,3 +1,5 @@
+"""Command-line interface entry points for TNFR."""
+
 from __future__ import annotations
 
 import argparse
@@ -5,25 +7,27 @@ import logging
 import sys
 from typing import Optional
 
+from .. import __version__
+from ..utils import _configure_root, get_logger
 from .arguments import (
+    _add_metrics_parser,
+    _add_profile_parser,
+    _add_profile_pipeline_parser,
+    _add_run_parser,
+    _add_sequence_parser,
+    add_canon_toggle,
     add_common_args,
     add_grammar_args,
     add_grammar_selector_args,
     add_history_export_args,
-    add_canon_toggle,
-    _add_run_parser,
-    _add_sequence_parser,
-    _add_metrics_parser,
 )
 from .execution import (
-    build_basic_graph,
     apply_cli_config,
+    build_basic_graph,
     register_callbacks_and_observer,
-    run_program,
     resolve_program,
+    run_program,
 )
-from ..logging_utils import get_logger
-from .. import __version__
 
 logger = get_logger(__name__)
 
@@ -43,27 +47,43 @@ __all__ = (
 
 
 def main(argv: Optional[list[str]] = None) -> int:
-    logging.basicConfig(
-        level=logging.INFO, format="%(message)s", stream=sys.stdout, force=True
-    )
+    """Entry point for the ``tnfr`` CLI returning the exit status."""
+
+    _configure_root()
+
+    root = logging.getLogger()
+    root.setLevel(logging.INFO)
+
+    formatter = logging.Formatter("%(message)s")
+    for handler in list(root.handlers):
+        root.removeHandler(handler)
+
+    handler = logging.StreamHandler(stream=sys.stdout)
+    handler.setLevel(logging.INFO)
+    handler.setFormatter(formatter)
+    root.addHandler(handler)
 
     p = argparse.ArgumentParser(
         prog="tnfr",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog=(
-            "Ejemplo: tnfr sequence --sequence-file secuencia.json\n"
-            "secuencia.json:\n"
+            "Example: tnfr sequence --sequence-file sequence.json\n"
+            "sequence.json:\n"
             '[\n  {"WAIT": 1},\n  {"TARGET": "A"}\n]'
         ),
     )
     p.add_argument(
-        "--version", action="store_true", help="muestra versión y sale"
+        "--version",
+        action="store_true",
+        help=("show the actual version and exit (reads pyproject.toml in development)"),
     )
     sub = p.add_subparsers(dest="cmd")
 
     _add_run_parser(sub)
     _add_sequence_parser(sub)
     _add_metrics_parser(sub)
+    _add_profile_parser(sub)
+    _add_profile_pipeline_parser(sub)
 
     args = p.parse_args(argv)
     if args.version:

tnfr/cli/__init__.pyi

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import argparse
+from typing import Optional
+
+from ..types import ProgramTokens, TNFRGraph
+
+__all__: tuple[str, ...]
+
+def main(argv: Optional[list[str]] = None) -> int: ...
+def add_common_args(parser: argparse.ArgumentParser) -> None: ...
+def add_grammar_args(parser: argparse.ArgumentParser) -> None: ...
+def add_grammar_selector_args(parser: argparse.ArgumentParser) -> None: ...
+def add_history_export_args(parser: argparse.ArgumentParser) -> None: ...
+def add_canon_toggle(parser: argparse.ArgumentParser) -> None: ...
+def build_basic_graph(args: argparse.Namespace) -> TNFRGraph: ...
+def apply_cli_config(G: TNFRGraph, args: argparse.Namespace) -> None: ...
+def register_callbacks_and_observer(G: TNFRGraph) -> None: ...
+def resolve_program(
+    args: argparse.Namespace, default: Optional[ProgramTokens] = None
+) -> Optional[ProgramTokens]: ...
+def run_program(
+    G: Optional[TNFRGraph],
+    program: Optional[ProgramTokens],
+    args: argparse.Namespace,
+) -> TNFRGraph: ...

tnfr/cli/arguments.py

@@ -1,13 +1,25 @@
+"""Argument parser helpers shared across TNFR CLI commands."""
+
 from __future__ import annotations
 
 import argparse
-from typing import Any
+from pathlib import Path
+from typing import Any, Iterable
 
+from ..config.presets import PREFERRED_PRESET_NAMES
 from ..gamma import GAMMA_REGISTRY
+from ..telemetry.verbosity import TELEMETRY_VERBOSITY_LEVELS
+from ..types import ArgSpec
 from .utils import spec
 
+_PRESET_HELP = "Available presets: {}.".format(
+    ", ".join(PREFERRED_PRESET_NAMES),
+)
+
+TELEMETRY_VERBOSITY_CHOICES = TELEMETRY_VERBOSITY_LEVELS
 
-GRAMMAR_ARG_SPECS = (
+
+GRAMMAR_ARG_SPECS: tuple[ArgSpec, ...] = (
     spec("--grammar.enabled", action=argparse.BooleanOptionalAction),
     spec("--grammar.zhir_requires_oz_window", type=int),
     spec("--grammar.zhir_dnfr_min", type=float),
@@ -19,25 +31,35 @@ GRAMMAR_ARG_SPECS = (
 )
 
 
-# Especificaciones para opciones relacionadas con el histórico
-HISTORY_ARG_SPECS = (
+# History export/save specifications
+HISTORY_ARG_SPECS: tuple[ArgSpec, ...] = (
     spec("--save-history", type=str),
     spec("--export-history-base", type=str),
     spec("--export-format", choices=["csv", "json"], default="json"),
 )
 
 
-# Argumentos comunes a los subcomandos
-COMMON_ARG_SPECS = (
+# Arguments shared by CLI subcommands
+COMMON_ARG_SPECS: tuple[ArgSpec, ...] = (
     spec("--nodes", type=int, default=24),
     spec("--topology", choices=["ring", "complete", "erdos"], default="ring"),
     spec("--seed", type=int, default=1),
     spec(
         "--p",
         type=float,
-        help="Probabilidad de arista si topology=erdos",
+        help="Edge probability when topology=erdos",
+    ),
+    spec("--observer", action="store_true", help="Attach standard observer"),
+    spec(
+        "--trace-verbosity",
+        choices=TELEMETRY_VERBOSITY_CHOICES,
+        help="Select the trace capture preset",
+    ),
+    spec(
+        "--metrics-verbosity",
+        choices=TELEMETRY_VERBOSITY_CHOICES,
+        help="Select the metrics capture preset",
     ),
-    spec("--observer", action="store_true", help="Adjunta observador estándar"),
     spec("--config", type=str),
     spec("--dt", type=float),
     spec("--integrator", choices=["euler", "rk4"]),
@@ -45,10 +67,13 @@ COMMON_ARG_SPECS = (
     spec("--gamma-type", choices=list(GAMMA_REGISTRY.keys()), default="none"),
     spec("--gamma-beta", type=float, default=0.0),
     spec("--gamma-R0", type=float, default=0.0),
+    spec("--um-candidate-count", type=int),
+    spec("--stop-early-window", type=int),
+    spec("--stop-early-fraction", type=float),
 )
 
 
-def add_arg_specs(parser: argparse._ActionsContainer, specs) -> None:
+def add_arg_specs(parser: argparse._ActionsContainer, specs: Iterable[ArgSpec]) -> None:
     """Register arguments from ``specs`` on ``parser``."""
     for opt, kwargs in specs:
         parser.add_argument(opt, **kwargs)
@@ -77,9 +102,7 @@ def add_grammar_args(parser: argparse.ArgumentParser) -> None:
 def add_grammar_selector_args(parser: argparse.ArgumentParser) -> None:
     """Add grammar options and glyph selector."""
     add_grammar_args(parser)
-    parser.add_argument(
-        "--selector", choices=["basic", "param"], default="basic"
-    )
+    parser.add_argument("--selector", choices=["basic", "param"], default="basic")
 
 
 def add_history_export_args(parser: argparse.ArgumentParser) -> None:
@@ -94,26 +117,45 @@ def add_canon_toggle(parser: argparse.ArgumentParser) -> None:
         dest="grammar_canon",
         action="store_false",
         default=True,
-        help="Desactiva gramática canónica",
+        help="Disable canonical grammar",
     )
 
 
 def _add_run_parser(sub: argparse._SubParsersAction) -> None:
     """Configure the ``run`` subcommand."""
-    from .execution import cmd_run, DEFAULT_SUMMARY_SERIES_LIMIT
+
+    from .execution import DEFAULT_SUMMARY_SERIES_LIMIT, cmd_run
 
     p_run = sub.add_parser(
         "run",
-        help=(
-            "Correr escenario libre o preset y opcionalmente exportar history"
-        ),
+        help=("Run a free scenario or preset and optionally export history"),
     )
     add_common_args(p_run)
     p_run.add_argument("--steps", type=int, default=100)
+    p_run.add_argument(
+        "--use-Si",
+        dest="use_Si",
+        action=argparse.BooleanOptionalAction,
+        default=None,
+        help="Recompute the Sense Index during the run (use --no-use-Si to disable)",
+    )
+    p_run.add_argument(
+        "--apply-glyphs",
+        dest="apply_glyphs",
+        action=argparse.BooleanOptionalAction,
+        default=None,
+        help="Apply glyphs at every step (use --no-apply-glyphs to disable)",
+    )
+    p_run.add_argument(
+        "--dnfr-n-jobs",
+        dest="dnfr_n_jobs",
+        type=int,
+        help="Override ΔNFR parallel jobs forwarded to the runtime",
+    )
     add_canon_toggle(p_run)
     add_grammar_selector_args(p_run)
     add_history_export_args(p_run)
-    p_run.add_argument("--preset", type=str, default=None)
+    p_run.add_argument("--preset", type=str, default=None, help=_PRESET_HELP)
     p_run.add_argument("--sequence-file", type=str, default=None)
     p_run.add_argument("--summary", action="store_true")
     p_run.add_argument(
@@ -121,10 +163,68 @@ def _add_run_parser(sub: argparse._SubParsersAction) -> None:
         type=int,
         default=DEFAULT_SUMMARY_SERIES_LIMIT,
         help=(
-            "Número máximo de muestras por serie en el resumen (<=0 para"
-            " desactivar el recorte)"
+            "Maximum number of samples per series in the summary (<=0 to"
+            " disable trimming)"
+        ),
+    )
+
+    math_group = p_run.add_argument_group("Mathematical dynamics")
+    math_group.add_argument(
+        "--math-engine",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help=(
+            "Enable the spectral mathematical dynamics engine to project nodes"
+            " onto Hilbert space vectors and validate norm, coherence and"
+            " structural frequency invariants"
+        ),
+    )
+    math_group.add_argument(
+        "--math-dimension",
+        type=int,
+        help="Hilbert space dimension to use when the math engine is enabled",
+    )
+    math_group.add_argument(
+        "--math-coherence-spectrum",
+        type=float,
+        nargs="+",
+        metavar="λ",
+        help=(
+            "Eigenvalues for the coherence operator (defaults to a flat"
+            " spectrum when omitted)"
+        ),
+    )
+    math_group.add_argument(
+        "--math-coherence-c-min",
+        type=float,
+        help="Explicit coherence floor C_min for the operator",
+    )
+    math_group.add_argument(
+        "--math-coherence-threshold",
+        type=float,
+        help="Coherence expectation threshold enforced during validation",
+    )
+    math_group.add_argument(
+        "--math-frequency-diagonal",
+        type=float,
+        nargs="+",
+        metavar="ν",
+        help=(
+            "Diagonal entries for the structural frequency operator"
+            " (defaults to the identity spectrum)"
         ),
     )
+    math_group.add_argument(
+        "--math-generator-diagonal",
+        type=float,
+        nargs="+",
+        metavar="ω",
+        help=(
+            "Diagonal ΔNFR generator used by the mathematical dynamics"
+            " engine (defaults to the null generator)"
+        ),
+    )
+
     p_run.set_defaults(func=cmd_run)
 
 
@@ -134,10 +234,10 @@ def _add_sequence_parser(sub: argparse._SubParsersAction) -> None:
 
     p_seq = sub.add_parser(
         "sequence",
-        help="Ejecutar una secuencia (preset o YAML/JSON)",
+        help="Execute a sequence (preset or YAML/JSON)",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog=(
-            "Ejemplo de secuencia JSON:\n"
+            "JSON sequence example:\n"
             "[\n"
             '  "A",\n'
             '  {"WAIT": 1},\n'
@@ -146,7 +246,7 @@ def _add_sequence_parser(sub: argparse._SubParsersAction) -> None:
         ),
     )
     add_common_args(p_seq)
-    p_seq.add_argument("--preset", type=str, default=None)
+    p_seq.add_argument("--preset", type=str, default=None, help=_PRESET_HELP)
     p_seq.add_argument("--sequence-file", type=str, default=None)
     add_history_export_args(p_seq)
     add_grammar_args(p_seq)
@@ -157,9 +257,7 @@ def _add_metrics_parser(sub: argparse._SubParsersAction) -> None:
     """Configure the ``metrics`` subcommand."""
     from .execution import cmd_metrics
 
-    p_met = sub.add_parser(
-        "metrics", help="Correr breve y volcar métricas clave"
-    )
+    p_met = sub.add_parser("metrics", help="Run briefly and export key metrics")
     add_common_args(p_met)
     p_met.add_argument("--steps", type=int, default=None)
     add_canon_toggle(p_met)
@@ -170,8 +268,93 @@ def _add_metrics_parser(sub: argparse._SubParsersAction) -> None:
         type=int,
         default=None,
         help=(
-            "Número máximo de muestras por serie en el resumen (<=0 para"
-            " desactivar el recorte)"
+            "Maximum number of samples per series in the summary (<=0 to"
+            " disable trimming)"
         ),
     )
     p_met.set_defaults(func=cmd_metrics)
+
+
+def _add_profile_parser(sub: argparse._SubParsersAction) -> None:
+    """Configure the ``profile-si`` subcommand."""
+
+    from .execution import cmd_profile_si
+
+    p_prof = sub.add_parser(
+        "profile-si",
+        help="Profile compute_Si with and without NumPy",
+    )
+    p_prof.add_argument("--nodes", type=int, default=240)
+    p_prof.add_argument("--chord-step", type=int, default=7)
+    p_prof.add_argument("--loops", type=int, default=5)
+    p_prof.add_argument("--output-dir", type=Path, default=Path("profiles"))
+    p_prof.add_argument("--format", choices=("pstats", "json"), default="pstats")
+    p_prof.add_argument("--sort", choices=("cumtime", "tottime"), default="cumtime")
+    p_prof.set_defaults(func=cmd_profile_si)
+
+
+def _add_profile_pipeline_parser(sub: argparse._SubParsersAction) -> None:
+    """Configure the ``profile-pipeline`` subcommand."""
+
+    from .execution import cmd_profile_pipeline
+
+    p_profile = sub.add_parser(
+        "profile-pipeline",
+        help="Profile the Sense Index + ΔNFR pipeline",
+    )
+    p_profile.add_argument("--nodes", type=int, default=240, help="Number of nodes")
+    p_profile.add_argument(
+        "--edge-probability",
+        type=float,
+        default=0.32,
+        help="Probability passed to the Erdos-Renyi generator",
+    )
+    p_profile.add_argument(
+        "--loops",
+        type=int,
+        default=5,
+        help="How many times to execute the pipeline inside the profiler",
+    )
+    p_profile.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed used when generating the graph",
+    )
+    p_profile.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("profiles"),
+        help="Directory where profiling artefacts will be written",
+    )
+    p_profile.add_argument(
+        "--sort",
+        choices=("cumtime", "tottime"),
+        default="cumtime",
+        help="Sort order applied to profiling rows",
+    )
+    p_profile.add_argument(
+        "--si-chunk-sizes",
+        nargs="+",
+        metavar="SIZE",
+        help="Chunk sizes forwarded to G.graph['SI_CHUNK_SIZE']; use 'auto' for heuristics",
+    )
+    p_profile.add_argument(
+        "--dnfr-chunk-sizes",
+        nargs="+",
+        metavar="SIZE",
+        help="Chunk sizes forwarded to G.graph['DNFR_CHUNK_SIZE']; use 'auto' for heuristics",
+    )
+    p_profile.add_argument(
+        "--si-workers",
+        nargs="+",
+        metavar="COUNT",
+        help="Worker counts forwarded to G.graph['SI_N_JOBS']; use 'auto' for serial runs",
+    )
+    p_profile.add_argument(
+        "--dnfr-workers",
+        nargs="+",
+        metavar="COUNT",
+        help="Worker counts forwarded to G.graph['DNFR_N_JOBS']; use 'auto' for defaults",
+    )
+    p_profile.set_defaults(func=cmd_profile_pipeline)

tnfr/cli/arguments.pyi

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import argparse
+from typing import Any, Iterable
+
+from ..gamma import GAMMA_REGISTRY
+from ..types import ArgSpec
+from .utils import spec
+
+GRAMMAR_ARG_SPECS: tuple[ArgSpec, ...]
+HISTORY_ARG_SPECS: tuple[ArgSpec, ...]
+COMMON_ARG_SPECS: tuple[ArgSpec, ...]
+
+def add_arg_specs(
+    parser: argparse._ActionsContainer, specs: Iterable[ArgSpec]
+) -> None: ...
+def _args_to_dict(args: argparse.Namespace, prefix: str) -> dict[str, Any]: ...
+def add_common_args(parser: argparse.ArgumentParser) -> None: ...
+def add_grammar_args(parser: argparse.ArgumentParser) -> None: ...
+def add_grammar_selector_args(parser: argparse.ArgumentParser) -> None: ...
+def add_history_export_args(parser: argparse.ArgumentParser) -> None: ...
+def add_canon_toggle(parser: argparse.ArgumentParser) -> None: ...
+def _add_run_parser(sub: argparse._SubParsersAction) -> None: ...
+def _add_sequence_parser(sub: argparse._SubParsersAction) -> None: ...
+def _add_metrics_parser(sub: argparse._SubParsersAction) -> None: ...
+def _add_profile_parser(sub: argparse._SubParsersAction) -> None: ...
+def _add_profile_pipeline_parser(sub: argparse._SubParsersAction) -> None: ...