Notifications (#2866)

* Add a notification class and a class to hold notifications

This provides the core classes for holding information on a single
notification, and then on top of that a class for managing a collection of
notifications.

* WiP: End of day/week commit to pick up post-holiday

* Ask permission rather than forgiveness

Yes, this does go against all things Pythonic, but in this case it's likely
less costly to do the check first; moreover it works around the problem I
ran in to: #2863

* Move the handling of "I've seen this" into the toast rack

This way the interface becomes "here's a bunch of notifications, you go work
this out".

* Add a notify method to all widgets

* The removal time for a toast should be the time left

When it was per-screen, it made sense that it was the timeout; now that
we're carrying them over between screens we're going to make sure they're
only around for as long as they need to be.

* Carry notifications between screens

* Remove the test code

* Drop the borders from the toasts

Except for the title, keep that.

* Provide access to the notification timeout

* Remove the title panel from a Toast if the title is empty

* Make the Toast CSS classes "private"

Prefix with a - to reduce the chance of a clash with userspace.

* Refresh a docstring

* Stop widget leakage

The Toasts were removing themselves, but they're wrapped inside a helper
container that keeps them aligned right. So the problem was that the
alignment containers were leaking. This ensures that when a Toast goes away
it takes its parent with it.

* Make the alignment container hidden

This doesn't really make any difference, but it feels like it makes sense to
hide it if there's nothing to show -- it's purely for alignment.

* 🚚 Rename the toast container

This is about getting the toasts to align correctly (even when you do align
things, they don't really align as expected due to the way that a container
aligns the bounding box of all if its children, not the individual
children). However, I had this named after where it aligned them to; someone
using the system may wish to change that, so let's make the name more
generic.

* Improve ToastRack._toast_id

Add a docstring, and also change the format of the identity somewhat so that
it's even "more internal".

* Add some initial low-level notification testing

* Add initial testing of notifications within an application

* Add tests for notifying from the 3 main levels within the DOM

* Add a toast example to the docs and a snapshot test

This might not be the final form, but it'll do for the moment. I want to get
the snapshot test in place at least.

* Add a snapshot test for notifications persisting between screens

* Add some documentation for a Toast

This isn't going into the index, just yet. This is *technically* an internal
widget so I'm not sure how and where it makes sense to document it; if at
all. But let's get some documentation in here anyway.

* Flesh out the docstrings for the notify methods

* Add a missing docstring to the Notifications __init__ method

* Add snapshot tests for persisting notifications through mode switches

* Remove unused import

Looks like eglot/pyright tried to be "helpful" at some point and I didn't
notice.

* Correct the Toast severity level classes in the docs

Originally they weren't in the "internal" namespace, then I decided that
they should be so there's less chance of a clash with dev-space code; but I
forgot to reflect this in the docs.

This fixes that.

* Make the removal of notifications/toasts a two way thing

The addition of the ability to dismiss a toast by clicking on it had a flaw:
the notification->toast code had been written with things being one way. The
expiration of notifications happened in the notification handler, and the
expiration of Toasts was done in the Toast system, on purpose (notifications
might end up being routed via elsewhere so this needs to be done).

But... this meant that hand-removed Toasts kept coming back from the dead
when a new notification was raised iff the hand-removed ones hadn't yet
expired.

So here I add the ability the remove a notification from the notification
collection.

* Remove an unhelpful comment

Sort of a hangover from what was initially looking like it was going to be a
longer body of code. It doesn't really need explaining any more.

* Add in support to the notification collection

* Change the toast rack adder to be a general "show" method

This turns the method into one that further aids making the connection
between the notifications and the toasts two way. Now it makes sense that if
there are toasts for notifications that no longer exist, they also get
removed.

This makes it easier to add all sorts of clear options later on.

* Add a method to clear notifications

* Add an App method for clearing all existing notifications

* Add a missing docstring to _refresh_notifications

* Return the notification from the notify methods

It can be seen as, and used as, a handle of sorts (see unnotify); so return
it so people can use it.

* Add some more notifications unit testing

* Add some more app-level notification unit testing

* Style tweaks

* docs

* added notifications

* snapshots

---------

Co-authored-by: Will McGugan <[email protected]>

Author: davep

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 
 - Added `DataTable.remove_column` method https://github.com/Textualize/textual/pull/2899
+- Added notifications https://github.com/Textualize/textual/pull/2866
 
 ### Fixed
 
@@ -26,9 +27,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 
 - Updated `DataTable.get_cell` type hints to accept string keys https://github.com/Textualize/textual/issues/2586
-- Added `DataTable.get_cell_coordinate` method 
+- Added `DataTable.get_cell_coordinate` method
 - Added `DataTable.get_row_index` method https://github.com/Textualize/textual/issues/2587
-- Added `DataTable.get_column_index` method   
+- Added `DataTable.get_column_index` method
 - Added can-focus pseudo-class to target widgets that may receive focus
 - Make `Markdown.update` optionally awaitable https://github.com/Textualize/textual/pull/2838
 - Added `default` parameter to `DataTable.add_column` for populating existing rows https://github.com/Textualize/textual/pull/2836

docs/examples/widgets/toast.py

@@ -0,0 +1,26 @@
+from textual.app import App
+
+
+class ToastApp(App[None]):
+    def on_mount(self) -> None:
+        # Show an information notification.
+        self.notify("It's an older code, sir, but it checks out.")
+
+        # Show a warning. Note that Textual's notification system allows
+        # for the use of Rich console markup.
+        self.notify(
+            "Now witness the firepower of this fully "
+            "[b]ARMED[/b] and [i][b]OPERATIONAL[/b][/i] battle station!",
+            title="Possible trap detected",
+            severity="warning",
+        )
+
+        # Show an error. Set a longer timeout so it's noticed.
+        self.notify("It's a trap!", severity="error", timeout=10)
+
+        # Show an information notification, but without any sort of title.
+        self.notify("It's against my programming to impersonate a deity.", title="")
+
+
+if __name__ == "__main__":
+    ToastApp().run()

docs/widgets/toast.md

@@ -0,0 +1,79 @@
+# Toast
+
+!!! tip "Added in version 0.30.0"
+
+A widget which displays a notification message.
+
+- [ ] Focusable
+- [ ] Container
+
+Note that `Toast` isn't designed to be used directly in your applications,
+but it is instead used by [`notify`][textual.app.App.notify] to
+display a message when using Textual's built-in notification system.
+
+## Styling
+
+You can customize the style of Toasts by targeting the `Toast` [CSS type](/guide/CSS/#type-selector).
+For example:
+
+
+```scss
+Toast {
+    padding: 3;
+}
+```
+
+The three severity levels also have corresponding
+[classes](/guide/CSS/#class-name-selector), allowing you to target the
+different styles of notification. They are:
+
+- `-information`
+- `-warning`
+- `-error`
+
+If you wish to tailor the notifications for your application you can add
+rules to your CSS like this:
+
+```scss
+Toast.-information {
+    /* Styling here. */
+}
+
+Toast.-warning {
+    /* Styling here. */
+}
+
+Toast.-error {
+    /* Styling here. */
+}
+```
+
+You can customize just the title wih the `toast--title` class.
+The following would make the title italic for an information toast:
+
+```scss
+Toast.-information .toast--title {
+    text-style: italic;
+}
+
+```
+
+## Example
+
+=== "Output"
+
+    ```{.textual path="docs/examples/widgets/toast.py"}
+    ```
+
+=== "toast.py"
+
+    ```python
+    --8<-- "docs/examples/widgets/toast.py"
+    ```
+
+---
+
+::: textual.widgets._toast
+    options:
+      show_root_heading: true
+      show_root_toc_entry: true