- Added 4 new recipes by NSPC911: (#14)

- Animation Effects: shaking.py
  - Architecture patterns: screen_push_wait.py
  - Modifying Widgets: progress_colors.py
  - Textual API usage: workers_exclusive.py
- Changed unicode characters in the recipe runner to normal emojis for better compatibility

Author: edward-jazzhands

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Textual Cookbook Changelog
 
+## [0.3.0] 2025-08-16
+
+- Added 4 new recipes by NSPC911:
+  - Animation Effects: shaking.py
+  - Architecture patterns: screen_push_wait.py
+  - Modifying Widgets: progress_colors.py
+  - Textual API usage: workers_exclusive.py
+- Changed unicode characters in the recipe runner to normal emojis for better compatibility
+
 ## [0.2.0] 2025-08-15
 
 - Added context menu recipe in Animations section

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "textual-cookbook"
-version = "0.2.0"
+version = "0.3.0"
 description = "Textual Cookbook: Recipes for Textual Applications"
 readme = "README.md"
 requires-python = ">=3.10"

src/textual_cookbook/main.py

@@ -189,8 +189,8 @@ def compose(self) -> ComposeResult:
             )
 
     def update(self, recipe_data: RecipeData):
-        self.query_one("#current_recipe", Static).update(f"🗎 {recipe_data['name']}.py  │")
-        self.query_one("#current_category", Static).update(f"🗁  {recipe_data['category']}")
+        self.query_one("#current_recipe", Static).update(f"📄 {recipe_data['name']}.py  │")
+        self.query_one("#current_category", Static).update(f"📁 {recipe_data['category']}")
         text_area = self.query_one(TextArea)
         text_area.language = "python"
         text_area.text = recipe_data['text_blob']

src/textual_cookbook/recipes/animation_effects/shaking.py

@@ -0,0 +1,36 @@
+"""This file demonstrates how to createa a "shaking" effect on a button.
+
+Recipe by NSPC911"""
+
+
+import sys
+from textual import work
+from textual.app import App, ComposeResult
+from textual.widgets import Button
+
+from asyncio import sleep
+
+class TextualApp(App[None]):
+    CSS = """
+    Button {
+        margin-left: 10
+    }
+    """
+    def compose(self) -> ComposeResult:
+        yield Button("Shake me!")
+    @work
+    async def on_button_pressed(self, event: Button.Pressed):
+        self.query_one(Button).styles.margin = (0,0,0,11)
+        await sleep(0.1)
+        self.query_one(Button).styles.margin = (0,0,0,10)
+        await sleep(0.1)
+        self.query_one(Button).styles.margin = (0,0,0,11)
+        await sleep(0.1)
+        self.query_one(Button).styles.margin = (0,0,0,10)
+
+
+
+if __name__ == "__main__":
+    app = TextualApp()
+    app.run()
+    sys.exit(app.return_code)

src/textual_cookbook/recipes/architecture_patterns/screen_push_wait.py

@@ -0,0 +1,104 @@
+"""This example demonstrates how the `push_screen_wait` method
+(A wrapper around `push_screen` with the `wait_for_dismiss` argument
+set to True) can be used to push a screen in the middle of a worker
+that will cause the worker to temporarily pause what it is doing. This
+is demonstrated in both a normal async worker and a threaded worker.
+
+Recipe by NSPC911  
+https://github.com/NSPC911"""
+
+import sys
+from typing import Any
+import asyncio
+
+from textual import on, work
+from textual.app import App, ComposeResult
+from textual.containers import Grid, Container
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, ProgressBar
+
+class Dismissable(ModalScreen[None]):
+    """Super simple screen that can be dismissed."""
+
+    DEFAULT_CSS = """
+    Dismissable {
+        align: center middle
+    }
+    #dialog {
+        grid-size: 1;
+        grid-gutter: 1 2;
+        grid-rows: 1fr 3;
+        padding: 1 3;
+        width: 50vw;
+        max-height: 13;
+        border: round $primary-lighten-3;
+        column-span: 3
+    }
+    #message {
+        height: 1fr;
+        width: 1fr;
+        content-align: center middle
+    }
+    Container {
+        align: center middle
+    }
+    Button {
+        width: 50%
+    }
+    """
+
+    def __init__(self, message: str, **kwargs: Any):
+        super().__init__(**kwargs)
+        self.message = message
+
+    def compose(self) -> ComposeResult:
+        with Grid(id="dialog"):
+            yield Label(self.message, id="message")
+            with Container():
+                yield Button("Ok", variant="primary", id="ok")
+
+    def on_mount(self) -> None:
+        self.query_one("#ok").focus()
+
+    @on(Button.Pressed, "#ok")
+    def on_button_pressed(self) -> None:
+        """Handle button presses."""
+        self.dismiss()
+
+
+class TextualApp(App[None]):
+    
+    def compose(self) -> ComposeResult:
+        yield Container()
+        yield Button("test in normal worker", id="test")
+        yield Button("test in threaded worker", id="test_threaded")
+        
+    @on(Button.Pressed, "#test")
+    @work
+    async def if_button_pressed(self, event: Button.Pressed) -> None:
+        
+        progress = ProgressBar(total=10)
+        self.mount(progress)
+        while progress.percentage != 1:
+            progress.advance()
+            await asyncio.sleep(0.5)
+            if progress.percentage == 0.5:
+                await self.push_screen_wait(Dismissable("hi"))
+                
+    @on(Button.Pressed, "#test_threaded")
+    @work(thread=True)
+    def if_button_pressed_thread(self) -> None:
+        
+        progress = ProgressBar(total=10)
+        self.call_from_thread(self.mount, progress)
+        while progress.percentage != 1:
+            self.call_from_thread(progress.advance)
+            self.call_from_thread(asyncio.sleep, 0.5)
+            if progress.percentage == 0.5:
+                self.call_from_thread(self.push_screen_wait, Dismissable("hi"))
+
+
+if __name__ == "__main__":
+    app = TextualApp()
+    app.run()
+    sys.exit(app.return_code)

src/textual_cookbook/recipes/modifying_widgets/progress_colors.py

@@ -0,0 +1,45 @@
+"""This example demonstrates making a progress bar with different colors
+for different states: indeterminate, complete, incomplete, and error.
+
+Recipe by NSPC911  
+https://github.com/NSPC911"""
+
+import sys
+from textual.app import App, ComposeResult
+from textual.widgets import ProgressBar
+
+class TextualApp(App[None]):
+    CSS = """
+    .bar {
+      color: $warning
+    }
+    .bar--indeterminate {
+      color: $accent
+    }
+    .bar--complete {
+      color: $success;
+    }
+    .error .bar--complete,
+    .error .bar--bar {
+      color: $error;
+    }
+    """
+    def compose(self) -> ComposeResult:
+        yield ProgressBar(total=None, id="indeterminate")
+        yield ProgressBar(total=100, id="complete", classes="complete")
+        yield ProgressBar(total=100, id="incomplete", classes="incomplete")
+        yield ProgressBar(total=100, id="error", classes="error complete")
+        yield ProgressBar(total=100, id="incompleteerror", classes="error incomplete")
+        
+    def on_mount(self) -> None:
+        for widget in self.query("ProgressBar.incomplete"):
+            widget.update(progress=50)
+        for widget in self.query("ProgressBar.complete"):
+            widget.update(progress=100)
+            
+
+
+if __name__ == "__main__":
+    app = TextualApp()
+    app.run()
+    sys.exit(app.return_code)

src/textual_cookbook/recipes/textual_api_usage/workers_exclusive.py

@@ -0,0 +1,48 @@
+"""This file demonstrates how the `exclusive` parameter of the `work`
+decorator can only be used to cancel/debounce workers that are normal
+async workers (non-threaded). The normal worker will be restarted
+each time the button is pressed and effectively cancel the currently
+running worker. But threaded workers will not be cancelled
+and will run to completion, even if the button is pressed multiple
+times (This is a limitation of threading in Python and not because of Textual).
+
+Recipe by NSPC911  
+https://github.com/NSPC911"""
+
+
+from asyncio import sleep
+
+import sys
+from textual import work, on
+from textual.app import App, ComposeResult
+from textual.widgets import Button, RichLog
+from textual.containers import HorizontalGroup
+
+class TextualApp(App[None]):
+    def compose(self) -> ComposeResult:
+        self.richlog = RichLog()
+        yield self.richlog
+        with HorizontalGroup():
+            yield Button("Run worker", id="worker")
+            yield Button("Run worker THREAD", id="thread")
+
+    def on_button_pressed(self, event:Button.Pressed):
+        self.richlog.write(event.button.id)
+
+    @on(Button.Pressed, "#worker")
+    @work(exclusive=True, thread=False)
+    async def worker_runner(self, event:Button.Pressed):
+        await sleep(1) # simulate process intensive thing
+        self.richlog.write("Worker completed!")
+
+    @on(Button.Pressed, "#thread")
+    @work(exclusive=True, thread=True)
+    def thread_runner(self, event:Button.Pressed):
+        self.call_from_thread(sleep, 1)
+        self.richlog.write("Thread completed!")
+
+
+if __name__ == "__main__":
+    app = TextualApp()
+    app.run()
+    sys.exit(app.return_code)

src/textual_cookbook/styles.tcss

@@ -75,7 +75,7 @@ TableScreen {
                 Static { 
                     color: $success; 
                     width: auto;
-                    padding: 0 1;
+                    padding: 0 0 0 1;
                 }
                 Button { 
                     min-width: 7;