Test flakiness investigation and attempted fixes ❄

src/textual/_animator.py

@@ -349,6 +349,7 @@ def _animate(
             duration is None and speed is not None
         ), "An Animation should have a duration OR a speed"
 
+        # If an animation is already scheduled for this attribute, unschedule it.
         animation_key = (id(obj), attribute)
         try:
             del self._scheduled[animation_key]
@@ -359,9 +360,7 @@ def _animate(
             final_value = value
 
         start_time = self._get_time()
-
         easing_function = EASING[easing] if isinstance(easing, str) else easing
-
         animation: Animation | None = None
 
         if hasattr(obj, "__textual_animation__"):

src/textual/app.py

@@ -1595,28 +1595,39 @@ def mount_all(
         """
         return self.mount(*widgets, before=before, after=after)
 
-    def _init_mode(self, mode: str) -> None:
+    def _init_mode(self, mode: str) -> AwaitMount:
         """Do internal initialisation of a new screen stack mode.
 
         Args:
             mode: Name of the mode.
+
+        Returns:
+            An optionally awaitable object indicating whether this mode
         """
 
         stack = self._screen_stacks.get(mode, [])
-        if not stack:
+        if stack:
+            await_mount = AwaitMount(stack[0], [])
+        else:
             _screen = self.MODES[mode]
             new_screen: Screen | str = _screen() if callable(_screen) else _screen
-            screen, _ = self._get_screen(new_screen)
+            screen, await_mount = self._get_screen(new_screen)
             stack.append(screen)
             self._load_screen_css(screen)
+
         self._screen_stacks[mode] = stack
+        return await_mount
 
-    def switch_mode(self, mode: str) -> None:
+    def switch_mode(self, mode: str) -> AwaitMount:
         """Switch to a given mode.
 
         Args:
             mode: The mode to switch to.
 
+        Returns:
+            An optionally awaitable object which waits for the screen associated
+                with the mode to be mounted.
+
         Raises:
             UnknownModeError: If trying to switch to an unknown mode.
         """
@@ -1627,13 +1638,19 @@ def switch_mode(self, mode: str) -> None:
         self.screen.refresh()
 
         if mode not in self._screen_stacks:
-            self._init_mode(mode)
+            await_mount = self._init_mode(mode)
+        else:
+            await_mount = AwaitMount(self.screen, [])
+
         self._current_mode = mode
         self.screen._screen_resized(self.size)
         self.screen.post_message(events.ScreenResume())
+
         self.log.system(f"{self._current_mode!r} is the current mode")
         self.log.system(f"{self.screen} is active")
 
+        return await_mount
+
     def add_mode(
         self, mode: str, base_screen: str | Screen | Callable[[], Screen]
     ) -> None:

src/textual/await_complete.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from asyncio import Future, gather, wait
+from typing import Coroutine
+
+
+class AwaitComplete:
+    """An 'optionally-awaitable' object."""
+
+    _instances: list["AwaitComplete"] = []
+    """Track all active instances of AwaitComplete."""
+
+    def __init__(self, *coroutine: Coroutine) -> None:
+        """Create an AwaitComplete.
+
+        Args:
+            coroutine: One or more coroutines to execute.
+        """
+        self.coroutine = coroutine
+        AwaitComplete._instances.append(self)
+        self._future: Future = gather(*[coroutine for coroutine in self.coroutine])
+        self._future.add_done_callback(self._on_done)
+
+    async def __call__(self):
+        await self
+
+    def __await__(self):
+        return self._future.__await__()
+
+    def _on_done(self, _: Future) -> None:
+        """Stop tracking this instance once it's done."""
+        AwaitComplete._instances.remove(self)
+
+    @property
+    def is_done(self) -> bool:
+        """Returns True if the task has completed."""
+        return self._future is not None and self._future.done()
+
+    @property
+    def exception(self) -> BaseException | None:
+        """An exception if it occurred in any of the coroutines."""
+        if self._future and self._future.done():
+            return self._future.exception()
+        return None
+
+    @classmethod
+    async def wait_all(cls):
+        """Await all instances of AwaitComplete."""
+        await wait(
+            [instance._future for instance in cls._instances if instance._future],
+            timeout=1.0,
+        )
+
+    @classmethod
+    def nothing(cls):
+        """Returns an already completed instance of AwaitComplete."""
+        instance = cls()
+        instance._future = Future()
+        instance._future.set_result(None)  # Mark it as completed with no result
+        return instance

src/textual/widgets/_button.py

@@ -151,9 +151,6 @@ class Button(Static, can_focus=True):
 
     BINDINGS = [Binding("enter", "press", "Press Button", show=False)]
 
-    ACTIVE_EFFECT_DURATION = 0.3
-    """When buttons are clicked they get the `-active` class for this duration (in seconds)"""
-
     label: reactive[TextType] = reactive[TextType]("")
     """The text label that appears within the button."""
 
@@ -209,6 +206,9 @@ def __init__(
 
         self.variant = self.validate_variant(variant)
 
+        self.active_effect_duration = 0.3
+        """Amount of time in seconds the button 'press' animation lasts."""
+
     def __rich_repr__(self) -> rich.repr.Result:
         yield from super().__rich_repr__()
         yield "variant", self.variant, "default"
@@ -252,10 +252,11 @@ def press(self) -> Self:
 
     def _start_active_affect(self) -> None:
         """Start a small animation to show the button was clicked."""
-        self.add_class("-active")
-        self.set_timer(
-            self.ACTIVE_EFFECT_DURATION, partial(self.remove_class, "-active")
-        )
+        if self.active_effect_duration > 0:
+            self.add_class("-active")
+            self.set_timer(
+                self.active_effect_duration, partial(self.remove_class, "-active")
+            )
 
     def action_press(self) -> None:
         """Activate a press of the button."""

src/textual/widgets/_directory_tree.py

@@ -5,6 +5,8 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Callable, ClassVar, Iterable, Iterator
 
+from ..await_complete import AwaitComplete
+
 if TYPE_CHECKING:
     from typing_extensions import Self
 
@@ -152,7 +154,7 @@ def __init__(
         )
         self.path = path
 
-    def _add_to_load_queue(self, node: TreeNode[DirEntry]) -> None:
+    def _add_to_load_queue(self, node: TreeNode[DirEntry]) -> AwaitComplete:
         """Add the given node to the load queue.
 
         Args:
@@ -163,7 +165,9 @@ def _add_to_load_queue(self, node: TreeNode[DirEntry]) -> None:
             node.data.loaded = True
             self._load_queue.put_nowait(node)
 
-    def reload(self) -> None:
+        return AwaitComplete(self._load_queue.join())
+
+    def reload(self) -> AwaitComplete:
         """Reload the `DirectoryTree` contents."""
         self.reset(str(self.path), DirEntry(self.PATH(self.path)))
         # Orphan the old queue...
@@ -172,7 +176,8 @@ def reload(self) -> None:
         self._loader()
         # We have a fresh queue, we have a fresh loader, get the fresh root
         # loading up.
-        self._add_to_load_queue(self.root)
+        queue_processed = self._add_to_load_queue(self.root)
+        return queue_processed
 
     def clear_node(self, node: TreeNode[DirEntry]) -> Self:
         """Clear all nodes under the given node.
@@ -213,7 +218,7 @@ def reset_node(
         node.data = data
         return self
 
-    def reload_node(self, node: TreeNode[DirEntry]) -> None:
+    def reload_node(self, node: TreeNode[DirEntry]) -> AwaitComplete:
         """Reload the given node's contents.
 
         Args:
@@ -222,7 +227,7 @@ def reload_node(self, node: TreeNode[DirEntry]) -> None:
         self.reset_node(
             node, str(node.data.path.name), DirEntry(self.PATH(node.data.path))
         )
-        self._add_to_load_queue(node)
+        return self._add_to_load_queue(node)
 
     def validate_path(self, path: str | Path) -> Path:
         """Ensure that the path is of the `Path` type.
@@ -239,13 +244,13 @@ def validate_path(self, path: str | Path) -> Path:
         """
         return self.PATH(path)
 
-    def watch_path(self) -> None:
+    async def watch_path(self) -> None:
         """Watch for changes to the `path` of the directory tree.
 
         If the path is changed the directory tree will be repopulated using
         the new value as the root.
         """
-        self.reload()
+        await self.reload()
 
     def process_label(self, label: TextType) -> Text:
         """Process a str or Text into a label. Maybe overridden in a subclass to modify how labels are rendered.
@@ -421,16 +426,17 @@ async def _loader(self) -> None:
                 # the tree.
                 if content:
                     self._populate_node(node, content)
-            # Mark this iteration as done.
-            self._load_queue.task_done()
+            finally:
+                # Mark this iteration as done.
+                self._load_queue.task_done()
 
-    def _on_tree_node_expanded(self, event: Tree.NodeExpanded) -> None:
+    async def _on_tree_node_expanded(self, event: Tree.NodeExpanded):
         event.stop()
         dir_entry = event.node.data
         if dir_entry is None:
             return
         if self._safe_is_dir(dir_entry.path):
-            self._add_to_load_queue(event.node)
+            await self._add_to_load_queue(event.node)
         else:
             self.post_message(self.FileSelected(event.node, dir_entry.path))
 

src/textual/widgets/_input.py

@@ -19,6 +19,7 @@
 from ..message import Message
 from ..reactive import reactive
 from ..suggester import Suggester, SuggestionReady
+from ..timer import Timer
 from ..validation import ValidationResult, Validator
 from ..widget import Widget
 
@@ -157,7 +158,7 @@ class Input(Widget, can_focus=True):
     }
     """
 
-    cursor_blink = reactive(True)
+    cursor_blink = reactive(True, init=False)
     value = reactive("", layout=True, init=False)
     input_scroll_offset = reactive(0)
     cursor_position = reactive(0)
@@ -255,6 +256,9 @@ def __init__(
         if value is not None:
             self.value = value
 
+        self._blink_timer: Timer | None = None
+        """Timer controlling the blinking of the cursor, instantiated in `on_mount`."""
+
         self.placeholder = placeholder
         self.highlighter = highlighter
         self.password = password
@@ -330,6 +334,15 @@ def _watch_cursor_position(self) -> None:
 
         self.app.cursor_position = self.cursor_screen_offset
 
+    def _watch_cursor_blink(self, blink: bool) -> None:
+        """Ensure we handle updating the cursor blink at runtime."""
+        if self._blink_timer is not None:
+            if blink:
+                self._blink_timer.resume()
+            else:
+                self._cursor_visible = True
+                self._blink_timer.pause()
+
     @property
     def cursor_screen_offset(self) -> Offset:
         """The offset of the cursor of this input in screen-space. (x, y)/(column, row)"""
@@ -419,27 +432,27 @@ def _toggle_cursor(self) -> None:
         self._cursor_visible = not self._cursor_visible
 
     def _on_mount(self, _: Mount) -> None:
-        self.blink_timer = self.set_interval(
+        self._blink_timer = self.set_interval(
             0.5,
             self._toggle_cursor,
             pause=not (self.cursor_blink and self.has_focus),
         )
 
     def _on_blur(self, _: Blur) -> None:
-        self.blink_timer.pause()
+        self._blink_timer.pause()
         if "blur" in self.validate_on:
             self.validate(self.value)
 
     def _on_focus(self, _: Focus) -> None:
         self.cursor_position = len(self.value)
         if self.cursor_blink:
-            self.blink_timer.resume()
+            self._blink_timer.resume()
         self.app.cursor_position = self.cursor_screen_offset
 
     async def _on_key(self, event: events.Key) -> None:
         self._cursor_visible = True
         if self.cursor_blink:
-            self.blink_timer.reset()
+            self._blink_timer.reset()
 
         if event.is_printable:
             event.stop()