python-statemachine 3.1.2__py3-none-any.whl → 3.2.1__py3-none-any.whl

statemachine/spec_parser.py

@@ -1,10 +1,9 @@
 import ast
 import operator
 import re
+from collections.abc import Callable
 from functools import reduce
 from inspect import isawaitable
-from typing import Callable
-from typing import Dict
 
 replacements = {"!": "not ", "^": " and ", "v": " or "}
 
@@ -20,6 +19,15 @@ comparison_repr = {
 }
 
 
+class UnsupportedExpression(ValueError):
+    """The expression contains a structure that is not on the parser allowlist.
+
+    Distinguishes a rejected expression from errors raised by the ``variable_hook``
+    while resolving names, so callers can report each one properly. Inherits from
+    ``ValueError`` to keep the previous behavior for callers catching it.
+    """
+
+
 def _unique_key(left, right, operator) -> str:
     left_key = getattr(left, "unique_key", "")
     right_key = getattr(right, "unique_key", "")
@@ -115,7 +123,7 @@ def build_constant(constant) -> Callable:
 
 
 class Functions:
-    registry: Dict[str, Callable] = {}
+    registry: dict[str, Callable] = {}
 
     @classmethod
     def register(cls, id) -> Callable:
@@ -129,7 +137,7 @@ class Functions:
     def get(cls, func_id):
         func_id = func_id.lower()
         if func_id not in cls.registry:
-            raise ValueError(f"Unsupported function: {func_id}")
+            raise UnsupportedExpression(f"Unsupported function: {func_id}")
         return cls.registry[func_id]
 
 
@@ -178,45 +186,142 @@ def build_custom_operator(operator) -> Callable:
     return custom_comparator
 
 
-def build_expression(node, variable_hook, operator_mapping):  # noqa: C901
-    if isinstance(node, ast.BoolOp):
-        # Handle `and` / `or` operations
-        operator_fn = operator_mapping[type(node.op)]
-        left_expr = build_expression(node.values[0], variable_hook, operator_mapping)
-        for right in node.values[1:]:
-            right_expr = build_expression(right, variable_hook, operator_mapping)
-            left_expr = operator_fn(left_expr, right_expr)
-        return left_expr
-    elif isinstance(node, ast.Compare):
-        # Handle `==` / `!=` / `>` / `<` / `>=` / `<=` operations
-        expressions = []
-        left_expr = build_expression(node.left, variable_hook, operator_mapping)
-        for right_op, right in zip(node.ops, node.comparators):  # noqa: B905  # strict=True requires 3.10+
-            right_expr = build_expression(right, variable_hook, operator_mapping)
-            operator_fn = operator_mapping[type(right_op)]
-            expression = operator_fn(left_expr, right_expr)
-            left_expr = right_expr
-            expressions.append(expression)
-
-        return reduce(custom_and, expressions)
-    elif isinstance(node, ast.Call):
-        # Handle function calls
-        assert isinstance(node.func, ast.Name)
-        constructor = Functions.get(node.func.id)
-        params = [arg.value for arg in node.args if isinstance(arg, ast.Constant)]
-        return constructor(*params)
-    elif isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not):
-        # Handle `not` operation
-        operand_expr = build_expression(node.operand, variable_hook, operator_mapping)
-        return operator_mapping[type(node.op)](operand_expr)
-    elif isinstance(node, ast.Name):
-        # Handle variables by calling the variable_hook
-        return variable_hook(node.id)
-    elif isinstance(node, ast.Constant):
-        # Handle constants by returning the value
-        return build_constant(node.value)
-    else:
-        raise ValueError(f"Unsupported expression structure: {node.__class__.__name__}")
+def build_binop(op_fn, left: Callable, right: Callable) -> Callable:
+    def decorated(*args, **kwargs):
+        return op_fn(left(*args, **kwargs), right(*args, **kwargs))
+
+    decorated.__name__ = f"({left.__name__} {op_fn.__name__} {right.__name__})"
+    return decorated
+
+
+def build_unaryop(op_fn, operand: Callable) -> Callable:
+    def decorated(*args, **kwargs):
+        return op_fn(operand(*args, **kwargs))
+
+    decorated.__name__ = f"{op_fn.__name__}({operand.__name__})"
+    return decorated
+
+
+def build_collection(factory, item_exprs: "list[Callable]") -> Callable:
+    def decorated(*args, **kwargs):
+        return factory(item(*args, **kwargs) for item in item_exprs)
+
+    decorated.__name__ = f"{factory.__name__}(...)"
+    return decorated
+
+
+def build_dict(key_exprs: "list[Callable]", value_exprs: "list[Callable]") -> Callable:
+    def decorated(*args, **kwargs):
+        return {
+            key(*args, **kwargs): value(*args, **kwargs)
+            for key, value in zip(key_exprs, value_exprs, strict=True)
+        }
+
+    decorated.__name__ = "dict(...)"
+    return decorated
+
+
+def build_subscript(value_expr: Callable, slice_expr: Callable) -> Callable:
+    def decorated(*args, **kwargs):
+        return value_expr(*args, **kwargs)[slice_expr(*args, **kwargs)]
+
+    decorated.__name__ = f"{value_expr.__name__}[{slice_expr.__name__}]"
+    return decorated
+
+
+def build_attribute(value_expr: Callable, attr: str) -> Callable:
+    def decorated(*args, **kwargs):
+        return getattr(value_expr(*args, **kwargs), attr)
+
+    decorated.__name__ = f"{value_expr.__name__}.{attr}"
+    return decorated
+
+
+def build_expression(  # noqa: C901
+    node, variable_hook, operator_mapping, allow_value_nodes: bool = False
+):
+    """Build a callable from an AST node using an allowlist of allowed structures.
+
+    Args:
+        allow_value_nodes: when ``True``, value-producing structures (arithmetic,
+            collections, subscript, attribute read) are also accepted. The DSL
+            boolean-guard parser keeps this ``False`` so non-boolean expressions
+            (e.g. ``a * b``, ``{}``) remain rejected; the SCXML datamodel parser
+            (:func:`parse_expr`) sets it ``True``.
+    """
+
+    def recurse(child):
+        return build_expression(child, variable_hook, operator_mapping, allow_value_nodes)
+
+    match node:
+        case ast.BoolOp():
+            # `and` / `or` operations
+            operator_fn = operator_mapping[type(node.op)]
+            left_expr = recurse(node.values[0])
+            for right in node.values[1:]:
+                right_expr = recurse(right)
+                left_expr = operator_fn(left_expr, right_expr)
+            return left_expr
+        case ast.Compare():
+            # `==` / `!=` / `>` / `<` / `>=` / `<=` operations
+            expressions = []
+            left_expr = recurse(node.left)
+            for right_op, right in zip(node.ops, node.comparators, strict=True):
+                right_expr = recurse(right)
+                operator_fn = operator_mapping[type(right_op)]
+                expression = operator_fn(left_expr, right_expr)
+                left_expr = right_expr
+                expressions.append(expression)
+            return reduce(custom_and, expressions)
+        case ast.Call(func=ast.Name(id=func_id)):
+            # Only allowlisted functions from the registry (e.g. ``In(...)``) are
+            # callable. Method calls (``obj.method()``) have an ``ast.Attribute``
+            # func and fall through to the ``case _`` guard below — this prevents
+            # using calls as a sandbox-escape vector.
+            constructor = Functions.get(func_id)
+            params = [arg.value for arg in node.args if isinstance(arg, ast.Constant)]
+            return constructor(*params)
+        case ast.UnaryOp(op=ast.Not()):
+            return operator_mapping[type(node.op)](recurse(node.operand))
+        case ast.UnaryOp(op=(ast.USub() | ast.UAdd())) if allow_value_nodes:
+            return build_unaryop(unary_operators[type(node.op)], recurse(node.operand))
+        case ast.BinOp() if allow_value_nodes:
+            op_type = type(node.op)
+            if op_type not in binary_operators:
+                # e.g. bitwise ``^``/``|``/``<<`` are outside the allowlist. (``**`` and ``*``
+                # are allowed but magnitude-capped — see ``binary_operators``.)
+                raise ValueError(f"Binary operator '{op_type.__name__}' is not allowed")
+            return build_binop(binary_operators[op_type], recurse(node.left), recurse(node.right))
+        case ast.List(elts=elts) if allow_value_nodes:
+            return build_collection(list, [recurse(e) for e in elts])
+        case ast.Tuple(elts=elts) if allow_value_nodes:
+            return build_collection(tuple, [recurse(e) for e in elts])
+        case ast.Set(elts=elts) if allow_value_nodes:
+            return build_collection(set, [recurse(e) for e in elts])
+        case ast.Dict(keys=keys, values=values) if allow_value_nodes and all(
+            key is not None for key in keys
+        ):
+            # ``key is not None`` rejects dict unpacking (``{**other}``), whose key
+            # node is ``None``.
+            return build_dict([recurse(key) for key in keys], [recurse(value) for value in values])
+        case ast.Subscript() if allow_value_nodes:
+            return build_subscript(recurse(node.value), recurse(node.slice))
+        case ast.Attribute(attr=attr) if allow_value_nodes:
+            # Block dunder/private attribute access (``__class__``, ``__globals__``,
+            # ...), the classic sandbox-escape chain. Subscript is allowed because,
+            # without underscore-attribute access or method calls, it cannot reach
+            # type objects.
+            if attr.startswith("_"):
+                raise UnsupportedExpression(f"Attribute access to '{attr}' is not allowed")
+            return build_attribute(recurse(node.value), attr)
+        case ast.Name(id=name):
+            return variable_hook(name)
+        case ast.Constant(value=value):
+            return build_constant(value)
+        case _:
+            raise UnsupportedExpression(
+                f"Unsupported expression structure: {node.__class__.__name__}"
+            )
 
 
 def parse_boolean_expr(expr, variable_hook, operator_mapping):
@@ -224,14 +329,39 @@ def parse_boolean_expr(expr, variable_hook, operator_mapping):
     if expr.strip() == "":
         raise SyntaxError("Empty expression")
 
-    # Optimization trying to avoid parsing the expression if not needed
-    if "!" not in expr and " " not in expr and "In(" not in expr:
+    # Optimization: a lone identifier can only be a variable name, so there is
+    # nothing to parse. Anything else (operators, comparisons, spaces, calls)
+    # goes through the parser.
+    if expr.isidentifier():
         return variable_hook(expr)
     expr = replace_operators(expr)
     tree = ast.parse(expr, mode="eval")
     return build_expression(tree.body, variable_hook, operator_mapping)
 
 
+def parse_expr(expr: str, variable_hook: Callable) -> Callable:
+    """Parse a value expression into a callable using the restricted AST allowlist.
+
+    Unlike :func:`parse_boolean_expr`, this does not apply the DSL operator
+    replacement (``!``/``^``/``v``) and does not coerce the top-level result to
+    ``bool`` — it returns the raw evaluated value. Used to safely evaluate SCXML
+    datamodel expressions (``<assign>``, ``<send>``, ``<foreach>``, ``<data>``)
+    without :func:`eval`.
+
+    Raises:
+        ValueError: if the expression uses a structure outside the allowlist
+            (e.g. attribute access to dunders, method calls, lambdas).
+        SyntaxError: if the expression is empty or not valid Python.
+    """
+    if expr.strip() == "":
+        raise SyntaxError("Empty expression")
+    tree = ast.parse(expr, mode="eval")
+    compiled: Callable = build_expression(
+        tree.body, variable_hook, operator_mapping, allow_value_nodes=True
+    )
+    return compiled
+
+
 operator_mapping = {
     ast.Or: custom_or,
     ast.And: custom_and,
@@ -243,3 +373,56 @@ operator_mapping = {
     ast.Eq: build_custom_operator(operator.eq),
     ast.NotEq: build_custom_operator(operator.ne),
 }
+
+# Result-size caps for the two operators that can blow up cheaply. Ordinary scalar
+# arithmetic (``x * 2``, ``x ** 2``) is well under these; the caps only reject the
+# denial-of-service forms (``9**9**9`` bignum, ``[0]*20000000`` sequence replication).
+_MAX_POW_RESULT_BITS = 4096
+_MAX_SEQUENCE_LEN = 1_000_000
+
+
+def _guarded_pow(base, exp):
+    """``**`` with a magnitude cap (GHSA-r8gj-366q-cgvj).
+
+    ``int ** int`` can allocate a giant bignum from a tiny expression (``9**9**9`` is a
+    ~370-million-digit number). The result size is estimated *before* computing, so the
+    allocation never happens. Non-integer operands (floats overflow to ``inf`` instead of
+    growing without bound) are passed straight through.
+    """
+    if isinstance(base, int) and isinstance(exp, int) and exp > 0 and base not in (0, 1, -1):
+        if base.bit_length() * exp > _MAX_POW_RESULT_BITS:
+            raise ValueError("'**' result is too large for the restricted evaluator")
+    return operator.pow(base, exp)
+
+
+def _guarded_mul(a, b):
+    """``*`` with a sequence-replication cap (GHSA-r8gj-366q-cgvj).
+
+    ``seq * n`` (list/str/bytes/tuple times an int) can allocate an enormous object from a
+    12-character expression (``[0]*20000000``). The resulting length is checked *before*
+    allocating. Scalar numeric multiplication is unaffected.
+    """
+    for seq, n in ((a, b), (b, a)):
+        if isinstance(seq, (str, bytes, bytearray, list, tuple)) and isinstance(n, int):
+            if n > 0 and n * len(seq) > _MAX_SEQUENCE_LEN:
+                raise ValueError("'*' repetition is too large for the restricted evaluator")
+    return operator.mul(a, b)
+
+
+# ``**`` and ``*`` stay available for ordinary arithmetic but are wrapped so a tiny untrusted
+# expression cannot exhaust CPU/memory (GHSA-r8gj-366q-cgvj). ``trusted=True`` uses the full
+# Python evaluator instead, without these caps.
+binary_operators = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: _guarded_mul,
+    ast.Div: operator.truediv,
+    ast.FloorDiv: operator.floordiv,
+    ast.Mod: operator.mod,
+    ast.Pow: _guarded_pow,
+}
+
+unary_operators = {
+    ast.USub: operator.neg,
+    ast.UAdd: operator.pos,
+}

statemachine/state.py

@@ -1,8 +1,7 @@
+from collections.abc import Generator
 from enum import Enum
 from typing import TYPE_CHECKING
 from typing import Any
-from typing import Generator
-from typing import List
 from typing import cast
 from weakref import ref
 
@@ -214,8 +213,8 @@ class State:
         initial: bool = False,
         final: bool = False,
         parallel: bool = False,
-        states: "List[State] | None" = None,
-        history: "List[HistoryState] | None" = None,
+        states: "list[State] | None" = None,
+        history: "list[HistoryState] | None" = None,
         enter: Any = None,
         exit: Any = None,
         invoke: Any = None,
@@ -284,7 +283,7 @@ class State:
             f"on_invoke_{self.id}", priority=CallbackPriority.NAMING, is_convention=True
         )
 
-    def _on_event_defined(self, event: str, transition: Transition, states: List["State"]):
+    def _on_event_defined(self, event: str, transition: Transition, states: list["State"]):
         """Called by statemachine factory when an event is defined having a transition
         starting from this state.
         """
@@ -297,7 +296,7 @@ class State:
         )
 
     def __str__(self):
-        return self.name
+        return str(self.name)
 
     @property
     def id(self) -> str:
@@ -309,7 +308,7 @@ class State:
             self.value = id
         if not self.name:
             self.name = humanize_id(self._id)
-        self._hash = hash((self.name, self._id))
+        self._hash = hash((str(self.name), self._id))
 
         return self
 
@@ -417,7 +416,7 @@ class AnyState(State):
     until the state machine class is evaluated.
     """
 
-    def _on_event_defined(self, event: str, transition: Transition, states: List[State]):
+    def _on_event_defined(self, event: str, transition: Transition, states: list[State]):
         for state in states:
             if state.final:
                 continue

statemachine/statemachine.py

@@ -1,11 +1,9 @@
 import warnings
+from collections.abc import MutableSet
 from inspect import isawaitable
 from typing import TYPE_CHECKING
 from typing import Any
-from typing import Dict
 from typing import Generic
-from typing import List
-from typing import MutableSet
 from typing import TypeVar
 
 from statemachine.orderedset import OrderedSet
@@ -106,7 +104,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
     produce an ``error.execution`` internal event instead of propagating, as mandated by the
     SCXML specification. If ``False``, exceptions propagate normally."""
 
-    start_configuration_values: List[Any] = []
+    start_configuration_values: list[Any] = []
     """Default state values to be entered when the state machine starts.
 
     If empty (default), the root ``initial`` state will be used.
@@ -123,21 +121,21 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
     states: "States"
     """Collection of top-level :ref:`State` objects declared on this class."""
 
-    states_map: Dict[Any, "State"]
+    states_map: dict[Any, "State"]
     """Mapping from each state's ``value`` to the corresponding :ref:`State` instance.
     Includes states at all nesting levels (compound children, parallel regions, etc.)."""
 
     initial_state: "State | None"
     """The single top-level initial :ref:`State`, or ``None`` for abstract classes."""
 
-    final_states: "List[State]"
+    final_states: "list[State]"
     """List of top-level :ref:`State` objects marked as ``final``."""
 
     _abstract: bool
-    _events: "Dict[Event, None]"
+    _events: "dict[Event, None]"
     _protected_attrs: set
     _specs: CallbackSpecList
-    _class_listeners: List[Any]
+    _class_listeners: list[Any]
     prepare: SpecListGrouper
 
     def __init__(
@@ -145,14 +143,14 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         model: "TModel | None" = None,
         state_field: str = "state",
         start_value: Any = None,
-        listeners: "List[object] | None" = None,
+        listeners: "list[object] | None" = None,
         **kwargs: Any,
     ):
         self.model: TModel = model if model is not None else Model()  # type: ignore[assignment]
         """The external model object that holds domain state, or an internal
         :class:`Model` instance when none is provided.  See :ref:`domain models`."""
 
-        self.history_values: Dict[str, List[State]] = {}
+        self.history_values: dict[str, list[State]] = {}
         """Mapping from compound state IDs to the list of states that were active
         the last time that compound state was exited. Used by history pseudo-states
         to restore previous configurations."""
@@ -162,7 +160,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         )
         self._callbacks = CallbacksRegistry()
         self._config = self._build_configuration()
-        self._listeners: Dict[int, Any] = {}
+        self._listeners: dict[int, Any] = {}
         """Listeners that provides attributes to be used as callbacks."""
 
         if self._abstract:
@@ -184,8 +182,8 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
 
         return SyncEngine(self)
 
-    def _resolve_class_listeners(self, **kwargs: Any) -> List[object]:
-        resolved: List[object] = []
+    def _resolve_class_listeners(self, **kwargs: Any) -> list[object]:
+        resolved: list[object] = []
         for entry in self._class_listeners:
             if callable(entry):
                 instance = entry()
@@ -206,11 +204,11 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
 
     def _build_configuration(self) -> Configuration:
         """Create InstanceState entries and return a new Configuration."""
-        instance_states: Dict[str, Any] = {}
+        instance_states: dict[Any, Any] = {}
         events = self.__class__._events
         for state in self.states_map.values():
             ist = InstanceState(state, self)
-            instance_states[state.id] = ist
+            instance_states[state.value] = ist
             if state.id not in events:
                 vars(self)[state.id] = ist
         return Configuration(
@@ -259,7 +257,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         del state["_engine"]
         return state
 
-    def __setstate__(self, state: Dict[str, Any]) -> None:
+    def __setstate__(self, state: dict[str, Any]) -> None:
         listeners = state.pop("_listeners")
         self.__dict__.update(state)  # type: ignore[attr-defined]
         self._callbacks = CallbacksRegistry()
@@ -312,7 +310,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
 
         return self
 
-    def _register_callbacks(self, listeners: List[object]):
+    def _register_callbacks(self, listeners: list[object]):
         self._listeners.update({id(listener): listener for listener in listeners})
         self._add_listener(
             Listeners.from_listeners(
@@ -336,7 +334,7 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         self._callbacks.async_or_sync()
 
     @property
-    def active_listeners(self) -> List[object]:
+    def active_listeners(self) -> list[object]:
         """List of all active listeners attached to this instance.
 
         Includes class-level listeners (resolved from the ``listeners`` class attribute),
@@ -423,12 +421,12 @@ class StateChart(Generic[TModel], metaclass=StateMachineMetaclass):
         self.current_state_value = value.value
 
     @property
-    def events(self) -> "List[Event]":
+    def events(self) -> "list[Event]":
         """List of all :ref:`Event` instances declared on this state machine."""
         return [getattr(self, event) for event in self.__class__._events]
 
     @property
-    def allowed_events(self) -> "List[Event]":
+    def allowed_events(self) -> "list[Event]":
         """List of the current allowed events."""
         return [
             getattr(self, event)

statemachine/states.py

@@ -1,11 +1,9 @@
 from enum import Enum
-from typing import Dict  # deprecated since 3.9: https://peps.python.org/pep-0585/
-from typing import Type
 
 from .state import State
 from .utils import ensure_iterable
 
-EnumType = Type[Enum]
+EnumType = type[Enum]
 
 
 class States:
@@ -35,7 +33,7 @@ class States:
 
     """
 
-    def __init__(self, states: "Dict[str, State] | None" = None) -> None:
+    def __init__(self, states: "dict[str, State] | None" = None) -> None:
         """
         Initializes a new instance of the States class.
 
@@ -45,7 +43,7 @@ class States:
         Returns:
             None.
         """
-        self._states: Dict[str, State] = states if states is not None else {}
+        self._states: dict[str, State] = states if states is not None else {}
 
     def __repr__(self):
         return f"{list(self)}"

statemachine/transition.py

@@ -1,6 +1,5 @@
 from copy import deepcopy
 from typing import TYPE_CHECKING
-from typing import List
 
 from .callbacks import CallbackGroup
 from .callbacks import CallbackPriority
@@ -43,7 +42,7 @@ class Transition:
     def __init__(
         self,
         source: "State",
-        target: "State | List[State] | None" = None,
+        target: "State | list[State] | None" = None,
         event=None,
         internal=False,
         initial=False,
@@ -56,7 +55,7 @@ class Transition:
     ):
         self.source = source
         if isinstance(target, list):
-            self._targets: "List[State]" = target
+            self._targets: "list[State]" = target
         elif target is not None:
             self._targets = [target]
         else:
@@ -104,7 +103,7 @@ class Transition:
         return self._targets[0] if self._targets else None
 
     @property
-    def targets(self) -> "List[State]":
+    def targets(self) -> "list[State]":
         """All target states. For single-target transitions, returns a one-element list."""
         return self._targets
 

statemachine/transition_list.py

@@ -1,6 +1,5 @@
+from collections.abc import Iterable
 from typing import TYPE_CHECKING
-from typing import Iterable
-from typing import List
 
 from .callbacks import CallbackGroup
 from .transition import Transition
@@ -22,7 +21,7 @@ class TransitionList(AddCallbacksMixin):
                 Defaults to `None`.
 
         """
-        self.transitions: List[Transition] = list(transitions) if transitions else []
+        self.transitions: list[Transition] = list(transitions) if transitions else []
 
     def __repr__(self):
         """Return a string representation of the :ref:`TransitionList`."""
@@ -42,7 +41,7 @@ class TransitionList(AddCallbacksMixin):
         """
         return TransitionList(self.transitions).add_transitions(other)
 
-    def _on_event_defined(self, event: str, states: List["State"]):
+    def _on_event_defined(self, event: str, states: list["State"]):
         self.add_event(event)
 
         for transition in self.transitions:
@@ -111,7 +110,7 @@ class TransitionList(AddCallbacksMixin):
             transition.add_event(event)
 
     @property
-    def unique_events(self) -> List["Event"]:
+    def unique_events(self) -> list["Event"]:
         """
         Returns a list of unique event names across all transitions in the :ref:`TransitionList`
         instance.

statemachine/transition_mixin.py

@@ -1,5 +1,5 @@
+from collections.abc import Callable
 from typing import Any
-from typing import Callable
 from typing import TypeVar
 
 from .callbacks import CallbackGroup