Merge branch 'main' into fix-button-prevent-text-selection

Author: willmcgugan

CHANGELOG.md

@@ -5,13 +5,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+
 ## Unreleased
 
 ### Fixed
 
-- Fixed `OptionList` causing excessive redrawing https://github.com/Textualize/textual/pull/5766
+- Fixed `VERTICAL_BREAKPOINTS` doesn't work https://github.com/Textualize/textual/pull/5785
 - Fixed `Button` allowing text selection https://github.com/Textualize/textual/pull/5770
 
+## [3.2.0] - 2025-05-02
+
+### Fixed
+
+- Fixed `OptionList` causing excessive redrawing https://github.com/Textualize/textual/pull/5766
+- Log messages could be written to stdout when there was no app, which could happen when using run_async or threads. Now they will be suppressed, unless the env var `TEXTUAL_DEBUG` is set https://github.com/Textualize/textual/pull/5782
+
+### Added
+
+- Added `:first-child` and `:last-child` pseudo classes https://github.com/Textualize/textual/pull/5776
+- Added `toggle_class` parameter to reactives https://github.com/Textualize/textual/pull/5778
+- Added `compact` parameter and reactive to `Button`, `Input`, `ToggleButton`, `RadioSet`, `OptionList`, `TextArea` https://github.com/Textualize/textual/pull/5778
+- Added `HORIZONTAL_BREAKPOINTS` and `VERTICAL_BREAKPOINTS` to `App` and `Screen` https://github.com/Textualize/textual/pull/5779
+
+### Changed
+
+- `RadioSet` now has a default width of `1fr` https://github.com/Textualize/textual/pull/5778
+
 ## [3.1.1] - 2025-04-22
 
 ### Fixed
@@ -2860,6 +2879,7 @@ https://textual.textualize.io/blog/2022/11/08/version-040/#version-040
 - New handler system for messages that doesn't require inheritance
 - Improved traceback handling
 
+[3.2.0]: https://github.com/Textualize/textual/compare/v3.1.1...v3.2.0
 [3.1.1]: https://github.com/Textualize/textual/compare/v3.1.0...v3.1.1
 [3.1.0]: https://github.com/Textualize/textual/compare/v3.0.1...v3.1.0
 [3.0.1]: https://github.com/Textualize/textual/compare/v3.0.0...v3.0.1

docs/guide/CSS.md

@@ -343,10 +343,12 @@ Here are some other pseudo classes:
 - `:disabled` Matches widgets which are in a disabled state.
 - `:enabled` Matches widgets which are in an enabled state.
 - `:even` Matches a widget at an evenly numbered position within its siblings.
+- `:first-child` Matches a widget that is the first amongst its siblings.
 - `:first-of-type` Matches a widget that is the first of its type amongst its siblings.
 - `:focus-within` Matches widgets with a focused child widget.
 - `:focus` Matches widgets which have input focus.
 - `:inline` Matches widgets when the app is running in inline mode.
+- `:last-child` Matches a widget that is the last amongst its siblings.
 - `:last-of-type` Matches a widget that is the last of its type amongst its siblings.
 - `:light` Matches widgets in light themes (where `App.theme.dark == False`).
 - `:odd` Matches a widget at an oddly numbered position within its siblings.

docs/guide/reactivity.md

@@ -65,7 +65,7 @@ You may want to add explicit type hints if the attribute type is a superset of t
 
 ## Smart refresh
 
-The first superpower we will look at is "smart refresh". When you modify a reactive attribute, Textual will make note of the fact that it has changed and refresh automatically.
+The first superpower we will look at is "smart refresh". When you modify a reactive attribute, Textual will make note of the fact that it has changed and refresh automatically by calling the widget's [`render()`][textual.widget.Widget.render] method to get updated content.
 
 !!! information
 

docs/tutorial.md

@@ -118,7 +118,7 @@ Let's examine `stopwatch01.py` in more detail.
 ```
 
 The first line imports `App` class, which is the base class for all Textual apps.
-The second line imports two builtin widgets: [`Footer`](widgets/footer.md) which shows a bar at the bottom of the screen with bound keys, and [`Header`](widgets/header) which shows a title at the top of the screen.
+The second line imports two builtin widgets: [`Footer`](widgets/footer.md) which shows a bar at the bottom of the screen with bound keys, and [`Header`](widgets/header.md) which shows a title at the top of the screen.
 Widgets are re-usable components responsible for managing a part of the screen.
 We will cover how to build widgets in this tutorial.
 

examples/breakpoints.py

@@ -0,0 +1,53 @@
+from textual.app import App, ComposeResult
+from textual.containers import Grid
+from textual.widgets import Footer, Markdown, Placeholder
+
+HELP = """\
+## Breakpoints
+
+A demonstration of how to make an app respond to the dimensions of the terminal.
+
+Try resizing the terminal, then have a look at the source to see how it works!
+"""
+
+
+class BreakpointApp(App):
+
+    # A breakpoint consists of a width and a class name to set
+    HORIZONTAL_BREAKPOINTS = [
+        (0, "-narrow"),
+        (40, "-normal"),
+        (80, "-wide"),
+        (120, "-very-wide"),
+    ]
+
+    CSS = """
+    Screen {        
+        Placeholder { padding: 2; }
+        Grid { grid-rows: auto; height: auto; }
+        # Change the styles according to the breakpoint classes
+        &.-narrow {
+            Grid { grid-size: 1; }
+        }
+        &.-normal {
+            Grid { grid-size: 2; }
+        }
+        &.-wide {
+            Grid { grid-size: 4; }
+        }
+        &.-very-wide {
+            Grid { grid-size: 6; }
+        }
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Markdown(HELP)
+        with Grid():
+            for n in range(16):
+                yield Placeholder(f"Placeholder {n+1}")
+        yield Footer()
+
+
+if __name__ == "__main__":
+    BreakpointApp().run()

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "textual"
-version = "3.1.1"
+version = "3.2.0"
 homepage = "https://github.com/Textualize/textual"
 repository = "https://github.com/Textualize/textual"
 documentation = "https://textual.textualize.io/"

src/textual/__init__.py

@@ -85,8 +85,12 @@ def __call__(self, *args: object, **kwargs) -> None:
         try:
             app = active_app.get()
         except LookupError:
-            print_args = (*args, *[f"{key}={value!r}" for key, value in kwargs.items()])
-            print(*print_args)
+            if constants.DEBUG:
+                print_args = (
+                    *args,
+                    *[f"{key}={value!r}" for key, value in kwargs.items()],
+                )
+                print(*print_args)
             return
         if app.devtools is None or not app.devtools.is_connected:
             return
@@ -108,8 +112,12 @@ def __call__(self, *args: object, **kwargs) -> None:
             )
         except LoggerError:
             # If there is not active app, try printing
-            print_args = (*args, *[f"{key}={value!r}" for key, value in kwargs.items()])
-            print(*print_args)
+            if constants.DEBUG:
+                print_args = (
+                    *args,
+                    *[f"{key}={value!r}" for key, value in kwargs.items()],
+                )
+                print(*print_args)
 
     def verbosity(self, verbose: bool) -> Logger:
         """Get a new logger with selective verbosity.

src/textual/app.py

@@ -18,7 +18,7 @@
 import threading
 import uuid
 import warnings
-from asyncio import Task, create_task
+from asyncio import AbstractEventLoop, Task, create_task
 from concurrent.futures import Future
 from contextlib import (
     asynccontextmanager,
@@ -150,9 +150,6 @@
 if constants.DEBUG:
     warnings.simplefilter("always", ResourceWarning)
 
-# `asyncio.get_event_loop()` is deprecated since Python 3.10:
-_ASYNCIO_GET_EVENT_LOOP_IS_DEPRECATED = sys.version_info >= (3, 10, 0)
-
 ComposeResult = Iterable[Widget]
 RenderResult: TypeAlias = "RenderableType | Visual | SupportsVisual"
 """Result of Widget.render()"""
@@ -482,6 +479,31 @@ class MyApp(App[None]):
     SUSPENDED_SCREEN_CLASS: ClassVar[str] = ""
     """Class to apply to suspended screens, or empty string for no class."""
 
+    HORIZONTAL_BREAKPOINTS: ClassVar[list[tuple[int, str]]] | None = []
+    """List of horizontal breakpoints for responsive classes.
+
+    This allows for styles to be responsive to the dimensions of the terminal.
+    For instance, you might want to show less information, or fewer columns on a narrow displays -- or more information when the terminal is sized wider than usual.
+    
+    A breakpoint consists of a tuple containing the minimum width where the class should applied, and the name of the class to set.
+
+    Note that only one class name is set, and if you should avoid having more than one breakpoint set for the same size.
+
+    Example:
+        ```python
+        # Up to 80 cells wide, the app has the class "-normal"
+        # 80 - 119 cells wide, the app has the class "-wide"
+        # 120 cells or wider, the app has the class "-very-wide"
+        HORIZONTAL_BREAKPOINTS = [(0, "-normal"), (80, "-wide"), (120, "-very-wide")]
+        ```
+    
+    """
+    VERTICAL_BREAKPOINTS: ClassVar[list[tuple[int, str]]] | None = []
+    """List of vertical breakpoints for responsive classes.
+    
+    Contents are the same as [`HORIZONTAL_BREAKPOINTS`][textual.app.App.HORIZONTAL_BREAKPOINTS], but the integer is compared to the height, rather than the width.
+    """
+
     _PSEUDO_CLASSES: ClassVar[dict[str, Callable[[App[Any]], bool]]] = {
         "focus": lambda app: app.app_focus,
         "blur": lambda app: not app.app_focus,
@@ -2034,7 +2056,6 @@ async def run_async(
         from textual.pilot import Pilot
 
         app = self
-
         auto_pilot_task: Task | None = None
 
         if auto_pilot is None and constants.PRESS:
@@ -2067,27 +2088,29 @@ async def run_auto_pilot(
                     run_auto_pilot(auto_pilot, pilot), name=repr(pilot)
                 )
 
-        try:
-            app._loop = asyncio.get_running_loop()
-            app._thread_id = threading.get_ident()
-
-            await app._process_messages(
-                ready_callback=None if auto_pilot is None else app_ready,
-                headless=headless,
-                inline=inline,
-                inline_no_clear=inline_no_clear,
-                mouse=mouse,
-                terminal_size=size,
-            )
-        finally:
+        app._loop = asyncio.get_running_loop()
+        app._thread_id = threading.get_ident()
+        with app._context():
             try:
-                if auto_pilot_task is not None:
-                    await auto_pilot_task
+                await app._process_messages(
+                    ready_callback=None if auto_pilot is None else app_ready,
+                    headless=headless,
+                    inline=inline,
+                    inline_no_clear=inline_no_clear,
+                    mouse=mouse,
+                    terminal_size=size,
+                )
             finally:
                 try:
-                    await asyncio.shield(app._shutdown())
-                except asyncio.CancelledError:
-                    pass
+                    if auto_pilot_task is not None:
+                        await auto_pilot_task
+                finally:
+                    try:
+                        await asyncio.shield(app._shutdown())
+                    except asyncio.CancelledError:
+                        pass
+                app._loop = None
+                app._thread_id = 0
 
         return app.return_value
 
@@ -2100,6 +2123,7 @@ def run(
         mouse: bool = True,
         size: tuple[int, int] | None = None,
         auto_pilot: AutopilotCallbackType | None = None,
+        loop: AbstractEventLoop | None = None,
     ) -> ReturnType | None:
         """Run the app.
 
@@ -2111,36 +2135,24 @@ def run(
             size: Force terminal size to `(WIDTH, HEIGHT)`,
                 or None to auto-detect.
             auto_pilot: An auto pilot coroutine.
-
+            loop: Asyncio loop instance, or `None` to use default.
         Returns:
             App return value.
         """
 
         async def run_app() -> None:
             """Run the app."""
-            self._loop = asyncio.get_running_loop()
-            self._thread_id = threading.get_ident()
-            with self._context():
-                try:
-                    await self.run_async(
-                        headless=headless,
-                        inline=inline,
-                        inline_no_clear=inline_no_clear,
-                        mouse=mouse,
-                        size=size,
-                        auto_pilot=auto_pilot,
-                    )
-                finally:
-                    self._loop = None
-                    self._thread_id = 0
+            await self.run_async(
+                headless=headless,
+                inline=inline,
+                inline_no_clear=inline_no_clear,
+                mouse=mouse,
+                size=size,
+                auto_pilot=auto_pilot,
+            )
 
-        if _ASYNCIO_GET_EVENT_LOOP_IS_DEPRECATED:
-            # N.B. This doesn't work with Python<3.10, as we end up with 2 event loops:
-            asyncio.run(run_app())
-        else:
-            # However, this works with Python<3.10:
-            event_loop = asyncio.get_event_loop()
-            event_loop.run_until_complete(run_app())
+        event_loop = asyncio.get_event_loop() if loop is None else loop
+        event_loop.run_until_complete(run_app())
         return self.return_value
 
     async def _on_css_change(self) -> None:

src/textual/color.py

@@ -53,7 +53,7 @@
 
 
 class HSL(NamedTuple):
-    """A color in HLS (Hue, Saturation, Lightness) format."""
+    """A color in HSL (Hue, Saturation, Lightness) format."""
 
     h: float
     """Hue in range 0 to 1."""
@@ -199,12 +199,12 @@ def from_rich_color(
 
     @classmethod
     def from_hsl(cls, h: float, s: float, l: float) -> Color:
-        """Create a color from HLS components.
+        """Create a color from HSL components.
 
         Args:
             h: Hue.
-            l: Lightness.
             s: Saturation.
+            l: Lightness.
 
         Returns:
             A new color.

src/textual/css/constants.py

@@ -76,6 +76,8 @@
     "nocolor",
     "first-of-type",
     "last-of-type",
+    "first-child",
+    "last-child",
     "odd",
     "even",
 }