binding iterator

Author: willmcgugan

src/textual/app.py

@@ -80,7 +80,7 @@
 from .actions import ActionParseResult, SkipAction
 from .await_complete import AwaitComplete
 from .await_remove import AwaitRemove
-from .binding import Binding, BindingType, _Bindings
+from .binding import Binding, BindingsMap, BindingType
 from .command import CommandPalette, Provider
 from .css.errors import StylesheetError
 from .css.query import NoMatches
@@ -3000,14 +3000,14 @@ def bell(self) -> None:
             self._driver.write("\07")
 
     @property
-    def _binding_chain(self) -> list[tuple[DOMNode, _Bindings]]:
+    def _binding_chain(self) -> list[tuple[DOMNode, BindingsMap]]:
         """Get a chain of nodes and bindings to consider.
 
         If no widget is focused, returns the bindings from both the screen and the app level bindings.
         Otherwise, combines all the bindings from the currently focused node up the DOM to the root App.
         """
         focused = self.focused
-        namespace_bindings: list[tuple[DOMNode, _Bindings]]
+        namespace_bindings: list[tuple[DOMNode, BindingsMap]]
 
         if focused is None:
             namespace_bindings = [

src/textual/binding.py

@@ -8,7 +8,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Iterable, NamedTuple
+from typing import TYPE_CHECKING, Iterable, Iterator, NamedTuple
 
 import rich.repr
 
@@ -64,7 +64,7 @@ class ActiveBinding(NamedTuple):
 
 
 @rich.repr.auto
-class _Bindings:
+class BindingsMap:
     """Manage a set of bindings."""
 
     def __init__(
@@ -118,21 +118,39 @@ def make_bindings(bindings: Iterable[BindingType]) -> Iterable[Binding]:
         for binding in make_bindings(bindings or {}):
             self.keys.setdefault(binding.key, []).append(binding)
 
-    def copy(self) -> _Bindings:
+    def __iter__(self) -> Iterator[tuple[str, Binding]]:
+        return iter(
+            [
+                (key, bindings)
+                for key, bindings in self.keys.items()
+                for binding in bindings
+            ]
+        )
+        # for key, bindings in self.keys.items():
+        #     for binding in bindings:
+        #         yield key, binding
+
+    @classmethod
+    def from_keys(cls, keys: dict[str, list[Binding]]) -> BindingsMap:
+        bindings = cls()
+        bindings.keys = keys
+        return bindings
+
+    def copy(self) -> BindingsMap:
         """Return a copy of this instance.
 
         Return:
             New bindings object.
         """
-        copy = _Bindings()
+        copy = BindingsMap()
         copy.keys = self.keys.copy()
         return copy
 
     def __rich_repr__(self) -> rich.repr.Result:
         yield self.keys
 
     @classmethod
-    def merge(cls, bindings: Iterable[_Bindings]) -> _Bindings:
+    def merge(cls, bindings: Iterable[BindingsMap]) -> BindingsMap:
         """Merge a bindings. Subsequent bound keys override initial keys.
 
         Args:
@@ -146,9 +164,7 @@ def merge(cls, bindings: Iterable[_Bindings]) -> _Bindings:
             for key, key_bindings in _bindings.keys.items():
                 keys.setdefault(key, []).extend(key_bindings)
 
-        new_bindings = _Bindings()
-        new_bindings.keys = keys
-        return new_bindings
+        return BindingsMap.from_keys(keys)
 
     @property
     def shown_keys(self) -> list[Binding]:

src/textual/dom.py

@@ -32,7 +32,7 @@
 from ._context import NoActiveAppError, active_message_pump
 from ._node_list import NodeList
 from ._types import WatchCallbackType
-from .binding import Binding, BindingType, _Bindings
+from .binding import Binding, BindingsMap, BindingType
 from .color import BLACK, WHITE, Color
 from .css._error_tools import friendly_list
 from .css.constants import VALID_DISPLAY, VALID_VISIBILITY
@@ -158,7 +158,7 @@ class DOMNode(MessagePump):
     _css_type_name: str = ""
 
     # Generated list of bindings
-    _merged_bindings: ClassVar[_Bindings | None] = None
+    _merged_bindings: ClassVar[BindingsMap | None] = None
 
     _reactives: ClassVar[dict[str, Reactive]]
 
@@ -197,7 +197,7 @@ def __init__(
         self._auto_refresh_timer: Timer | None = None
         self._css_types = {cls.__name__ for cls in self._css_bases(self.__class__)}
         self._bindings = (
-            _Bindings()
+            BindingsMap()
             if self._merged_bindings is None
             else self._merged_bindings.copy()
         )
@@ -590,27 +590,30 @@ def _css_bases(cls, base: Type[DOMNode]) -> Sequence[Type[DOMNode]]:
         return classes
 
     @classmethod
-    def _merge_bindings(cls) -> _Bindings:
+    def _merge_bindings(cls) -> BindingsMap:
         """Merge bindings from base classes.
 
         Returns:
             Merged bindings.
         """
-        bindings: list[_Bindings] = []
+        bindings: list[BindingsMap] = []
 
         for base in reversed(cls.__mro__):
             if issubclass(base, DOMNode):
                 if not base._inherit_bindings:
                     bindings.clear()
                 bindings.append(
-                    _Bindings(
+                    BindingsMap(
                         base.__dict__.get("BINDINGS", []),
                     )
                 )
-        keys: dict[str, Binding] = {}
+        keys: dict[str, list[Binding]] = {}
         for bindings_ in bindings:
-            keys.update(bindings_.keys)
-        return _Bindings(keys.values())
+            for key, key_bindings in bindings_.keys.items():
+                keys.setdefault(key, []).extend(key_bindings)
+
+        new_bindings = BindingsMap().from_keys(keys)
+        return new_bindings
 
     def _post_register(self, app: App) -> None:
         """Called when the widget is registered

src/textual/screen.py

@@ -36,7 +36,7 @@
 from ._path import CSSPathType, _css_path_type_as_list, _make_path_object_relative
 from ._types import CallbackType
 from .await_complete import AwaitComplete
-from .binding import ActiveBinding, Binding, _Bindings
+from .binding import ActiveBinding, Binding, BindingsMap
 from .css.match import match
 from .css.parse import parse_selectors
 from .css.query import NoMatches, QueryType
@@ -289,12 +289,12 @@ def refresh_bindings(self) -> None:
         self.check_idle()
 
     @property
-    def _binding_chain(self) -> list[tuple[DOMNode, _Bindings]]:
+    def _binding_chain(self) -> list[tuple[DOMNode, BindingsMap]]:
         """Binding chain from this screen."""
         focused = self.focused
         if focused is not None and focused.loading:
             focused = None
-        namespace_bindings: list[tuple[DOMNode, _Bindings]]
+        namespace_bindings: list[tuple[DOMNode, BindingsMap]]
 
         if focused is None:
             namespace_bindings = [
@@ -309,7 +309,7 @@ def _binding_chain(self) -> list[tuple[DOMNode, _Bindings]]:
         return namespace_bindings
 
     @property
-    def _modal_binding_chain(self) -> list[tuple[DOMNode, _Bindings]]:
+    def _modal_binding_chain(self) -> list[tuple[DOMNode, BindingsMap]]:
         """The binding chain, ignoring everything before the last modal."""
         binding_chain = self._binding_chain
         for index, (node, _bindings) in enumerate(binding_chain, 1):
@@ -332,7 +332,7 @@ def active_bindings(self) -> dict[str, ActiveBinding]:
 
         bindings_map: dict[str, ActiveBinding] = {}
         for namespace, bindings in self._modal_binding_chain:
-            for key, binding in bindings.keys.items():
+            for key, binding in bindings:
                 action_state = self.app._check_action_state(binding.action, namespace)
                 if action_state is False:
                     continue

tests/test_binding.py

@@ -3,7 +3,13 @@
 import pytest
 
 from textual.app import App
-from textual.binding import Binding, BindingError, InvalidBinding, NoBinding, _Bindings
+from textual.binding import (
+    Binding,
+    BindingError,
+    BindingsMap,
+    InvalidBinding,
+    NoBinding,
+)
 
 BINDING1 = Binding("a,b", action="action1", description="description1")
 BINDING2 = Binding("c", action="action2", description="description2")
@@ -12,12 +18,12 @@
 
 @pytest.fixture
 def bindings():
-    yield _Bindings([BINDING1, BINDING2])
+    yield BindingsMap([BINDING1, BINDING2])
 
 
 @pytest.fixture
 def more_bindings():
-    yield _Bindings([BINDING1, BINDING2, BINDING3])
+    yield BindingsMap([BINDING1, BINDING2, BINDING3])
 
 
 def test_bindings_get_key(bindings):
@@ -34,38 +40,40 @@ def test_bindings_get_key_spaced_list(more_bindings):
 
 
 def test_bindings_merge_simple(bindings):
-    left = _Bindings([BINDING1])
-    right = _Bindings([BINDING2])
-    assert _Bindings.merge([left, right]).keys == bindings.keys
+    left = BindingsMap([BINDING1])
+    right = BindingsMap([BINDING2])
+    assert BindingsMap.merge([left, right]).keys == bindings.keys
 
 
 def test_bindings_merge_overlap():
-    left = _Bindings([BINDING1])
+    left = BindingsMap([BINDING1])
     another_binding = Binding(
         "a", action="another_action", description="another_description"
     )
-    assert _Bindings.merge([left, _Bindings([another_binding])]).keys == {
+    assert BindingsMap.merge([left, BindingsMap([another_binding])]).keys == {
         "a": another_binding,
         "b": Binding("b", action="action1", description="description1"),
     }
 
 
 def test_bad_binding_tuple():
     with pytest.raises(BindingError):
-        _ = _Bindings((("a",),))
+        _ = BindingsMap((("a",),))
     with pytest.raises(BindingError):
-        _ = _Bindings((("a", "action", "description", "too much"),))
+        _ = BindingsMap((("a", "action", "description", "too much"),))
 
 
 def test_binding_from_tuples():
     assert (
-        _Bindings(((BINDING2.key, BINDING2.action, BINDING2.description),)).get_key("c")
+        BindingsMap(((BINDING2.key, BINDING2.action, BINDING2.description),)).get_key(
+            "c"
+        )
         == BINDING2
     )
 
 
 def test_shown():
-    bindings = _Bindings(
+    bindings = BindingsMap(
         [
             Binding(
                 key,