oldnews 0.5.0__tar.gz → 0.6.0__tar.gz

{oldnews-0.5.0 → oldnews-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oldnews
-Version: 0.5.0
+Version: 0.6.0
 Summary: A terminal-based client for TheOldReader
 Keywords: atom,client,Google Reader,RSS,TheOldReader,terminal,news-reader,news
 Author: Dave Pearson

{oldnews-0.5.0 → oldnews-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "oldnews"
-version = "0.5.0"
+version = "0.6.0"
 description = "A terminal-based client for TheOldReader"
 readme = "README.md"
 authors = [

{oldnews-0.5.0 → oldnews-0.6.0}/src/oldnews/__main__.py

@@ -10,6 +10,7 @@ from operator import attrgetter
 # Local imports.
 from . import __doc__, __version__
 from .data import initialise_database, reset_data
+from .data.locations import config_dir, data_dir
 from .oldnews import OldNews
 
 
@@ -49,6 +50,13 @@ def get_args() -> Namespace:
         dest="command", help="Available commands", required=False
     )
 
+    # Add the 'directories' command.
+    sub_parser.add_parser(
+        "directories",
+        aliases=["dirs", "d"],
+        help="Show the directories created and used by OldNews",
+    )
+
     # Add the 'license' command.
     sub_parser.add_parser(
         "license",
@@ -135,6 +143,9 @@ def reset_news(args: Namespace) -> None:
 def main() -> None:
     """Main entry function."""
     match (args := get_args()).command:
+        case "d" | "dirs" | "directories":
+            print(config_dir())
+            print(data_dir())
         case "reset":
             reset_news(args)
         case "license" | "licence":

{oldnews-0.5.0 → oldnews-0.6.0}/src/oldnews/data/__init__.py

@@ -10,6 +10,7 @@ from .config import (
     update_configuration,
 )
 from .db import initialise_database
+from .dump import data_dump
 from .last_grab import last_grabbed_data_at, remember_we_last_grabbed_at
 from .local_articles import (
     clean_old_read_articles,
@@ -26,6 +27,7 @@ from .local_articles import (
 from .local_folders import get_local_folders, save_local_folders
 from .local_subscriptions import get_local_subscriptions, save_local_subscriptions
 from .local_unread import LocalUnread, get_local_unread, total_unread
+from .log import Log
 from .navigation_state import get_navigation_state, save_navigation_state
 from .reset import reset_data
 
@@ -33,7 +35,9 @@ from .reset import reset_data
 # Exports.
 __all__ = [
     "Configuration",
+    "Log",
     "clean_old_read_articles",
+    "data_dump",
     "get_auth_token",
     "get_local_articles",
     "get_local_folders",

oldnews-0.6.0/src/oldnews/data/dump.py

@@ -0,0 +1,75 @@
+"""Provides tools to dump data into an easy-to-browse format."""
+
+##############################################################################
+# Python imports.
+from functools import singledispatch
+from typing import Any
+
+##############################################################################
+# OldAS imports.
+from oldas import Article, Folder, Subscription
+
+##############################################################################
+type DataDump = tuple[tuple[str, str], ...]
+"""Type of a data dump."""
+
+
+##############################################################################
+@singledispatch
+def data_dump(data: Any) -> DataDump:
+    """Dump the given data into an easy-to-browse format.
+
+    Args:
+        data: The data to dump.
+
+    Returns:
+        A `DataDump` of the data.
+    """
+    return (("Data", str(data)),)
+
+
+##############################################################################
+@data_dump.register
+def _(data: Folder) -> DataDump:
+    return (("ID", data.id), ("Sort ID", data.sort_id))
+
+
+##############################################################################
+@data_dump.register
+def _(data: Subscription) -> DataDump:
+    return (
+        ("ID", data.id),
+        ("Title", data.title),
+        ("Sort ID", data.sort_id),
+        ("First Item Time", f"{data.first_item_time}"),
+        ("URL", data.url),
+        ("HTML URL", data.html_url),
+        *(
+            (
+                f"Category[{n}]",
+                f"{category.id}, {category.label}",
+            )
+            for n, category in enumerate(data.categories)
+        ),
+    )
+
+
+##############################################################################
+@data_dump.register
+def _(data: Article) -> DataDump:
+    # TODO: The article has pretty rich data, so in here I'm not showing
+    # it all, just enough to be useful. In the future perhaps make it a
+    # lot richer.
+    return (
+        ("ID", data.id),
+        ("Title", data.title),
+        ("Published", f"{data.published}"),
+        ("Updated", f"{data.updated}"),
+        *(
+            (f"Category[{n}]", f"{category}")
+            for n, category in enumerate(data.categories)
+        ),
+    )
+
+
+### dump.py ends here

{oldnews-0.5.0 → oldnews-0.6.0}/src/oldnews/data/local_articles.py

@@ -17,6 +17,7 @@ from typedal import TypedField, TypedTable, relationship
 
 ##############################################################################
 # Local imports.
+from .log import Log
 from .tools import commit
 
 
@@ -339,11 +340,13 @@ def clean_old_read_articles(cutoff: timedelta) -> int:
     """Clean up articles that are older than the given cutoff time."""
     read = get_local_read_article_ids()
     retire_time = datetime.now() - cutoff
+    Log().debug(f"Cleaning up read articles published before {retire_time}")
     cleaned = len(
         LocalArticle.where(
             (LocalArticle.published < retire_time) & LocalArticle.id.belongs(read)
         ).delete()
     )
+    Log().debug(f"Cleaned: {cleaned}")
     commit(LocalArticle)
     return cleaned
 
@@ -358,6 +361,7 @@ def rename_folder_for_articles(rename_from: str | Folder, rename_to: str) -> Non
     """
     rename_from = Folders.full_id(rename_from)
     rename_to = Folders.full_id(rename_to)
+    Log().debug(f"Renaming folder for local articles from {rename_from} to {rename_to}")
     LocalArticleCategory.where(LocalArticleCategory.category == rename_from).update(
         category=rename_to
     )
@@ -371,9 +375,9 @@ def remove_folder_from_articles(folder: str | Folder) -> None:
     Args:
         folder: The folder to remove from all articles.
     """
-    LocalArticleCategory.where(
-        LocalArticleCategory.category == Folders.full_id(folder)
-    ).delete()
+    folder = Folders.full_id(folder)
+    Log().debug(f"Removing folder {folder} from all local articles")
+    LocalArticleCategory.where(LocalArticleCategory.category == folder).delete()
     commit(LocalArticleCategory)
 
 
@@ -394,6 +398,9 @@ def move_subscription_articles(
         Folders.full_id(from_folder) if from_folder is not None else from_folder
     )
     to_folder = Folders.full_id(to_folder) if to_folder is not None else to_folder
+    Log().debug(
+        f"Moving all articles of {subscription.title} ({subscription.id}) from folder {from_folder} to {to_folder}"
+    )
     for article in LocalArticle.where(origin_stream_id=subscription.id).join().select():
         if from_folder:
             LocalArticleCategory.where(
@@ -407,13 +414,16 @@ def move_subscription_articles(
 
 
 ##############################################################################
-def remove_subscription_articles(subscription: Subscription) -> None:
+def remove_subscription_articles(subscription: str | Subscription) -> None:
     """Remove all the articles associated with the given subscription.
 
     Args:
         subscription: The subscription to remove the articles for.
     """
-    LocalArticle.where(origin_stream_id=subscription.id).delete()
+    if isinstance(subscription, Subscription):
+        subscription = subscription.id
+    Log().debug(f"Removing all local articles for subscription {subscription}")
+    LocalArticle.where(origin_stream_id=subscription).delete()
     commit(LocalArticle)
 
 

oldnews-0.6.0/src/oldnews/data/log.py

@@ -0,0 +1,38 @@
+"""Provides the application's logger."""
+
+##############################################################################
+# Python imports.
+from functools import cache
+from logging import DEBUG, INFO, Formatter, Logger, getLogger
+from logging.handlers import RotatingFileHandler
+from os import getenv
+
+##############################################################################
+# Local imports.
+from .locations import data_dir
+
+
+##############################################################################
+def _build_logger() -> Logger:
+    """Build a logger for the application.
+
+    Returns:
+        A configured `Logger` object.
+    """
+    logger = getLogger("oldnews")
+    logger.setLevel(DEBUG if getenv("OLDNEWS_DEBUG") else INFO)
+    file_handler = RotatingFileHandler(
+        data_dir() / "oldnews.log", maxBytes=1024 * 1024, backupCount=5
+    )
+    file_handler.setFormatter(
+        Formatter("%(asctime)s - %(levelname)s - %(module)s:%(lineno)d - %(message)s")
+    )
+    logger.addHandler(file_handler)
+    return logger
+
+
+##############################################################################
+Log = cache(_build_logger)
+"""The application-wide logging object."""
+
+### log.py ends here

{oldnews-0.5.0 → oldnews-0.6.0}/src/oldnews/screens/login.py

@@ -9,6 +9,7 @@ from oldas import OldASError, OldASInvalidLogin, Session
 from textual import on
 from textual.app import ComposeResult
 from textual.containers import Horizontal, Vertical
+from textual.getters import query_one
 from textual.screen import ModalScreen
 from textual.widgets import Button, Input
 
@@ -48,6 +49,11 @@ class Login(ModalScreen[Session | None]):
 
     BINDINGS = [("escape", "cancel")]
 
+    user_name = query_one("#user-name", Input)
+    """The user name input widget."""
+    password = query_one("#password", Input)
+    """The password input widget."""
+
     def __init__(self, session: Session) -> None:
         """Initialise the login dialog.
 
@@ -71,9 +77,7 @@ class Login(ModalScreen[Session | None]):
     @on(Button.Pressed, "#login")
     async def login(self) -> None:
         """Log into TheOldReader."""
-        if (user := self.query_one("#user-name", Input).value) and (
-            password := self.query_one("#password", Input).value
-        ):
+        if (user := self.user_name.value) and (password := self.password.value):
             try:
                 # TODO: Add some sort of busy effect as the login happens.
                 await self._session.login(user, password)

{oldnews-0.5.0 → oldnews-0.6.0}/src/oldnews/screens/main.py

@@ -62,6 +62,7 @@ from ..commands import (
 from ..data import (
     LocalUnread,
     clean_old_read_articles,
+    data_dump,
     get_local_articles,
     get_local_folders,
     get_local_subscriptions,
@@ -159,24 +160,24 @@ class Main(EnhancedScreen[None]):
         Quit,
         RefreshFromTheOldReader,
         # Everything else.
+        AddSubscription,
+        ChangeTheme,
+        Copy,
+        CopyArticleToClipboard,
+        CopyFeedToClipboard,
+        CopyHomePageToClipboard,
         Escape,
         Information,
         MarkAllRead,
+        MoveSubscription,
         Next,
         NextUnread,
-        Previous,
-        PreviousUnread,
         OpenArticle,
         OpenHomePage,
-        ChangeTheme,
-        CopyHomePageToClipboard,
-        CopyFeedToClipboard,
-        CopyArticleToClipboard,
-        Copy,
-        AddSubscription,
-        Rename,
+        Previous,
+        PreviousUnread,
         Remove,
-        MoveSubscription,
+        Rename,
     ]
 
     BINDINGS = Command.bindings(*COMMAND_MESSAGES)
@@ -767,48 +768,13 @@ class Main(EnhancedScreen[None]):
     @work
     async def action_information_command(self) -> None:
         """Show some information about the current item."""
-        # TODO: The article has pretty rich data, so in here I'm not showing
-        # it all, just enough to be useful. In the future perhaps make it a
-        # lot richer.
         information: InformationDisplay | None = None
         if self.navigation.has_focus and (category := self.navigation.current_category):
-            if isinstance(category, Folder):
-                information = InformationDisplay(
-                    "Folder", (("ID", category.id), ("Sort ID", category.sort_id))
-                )
-            elif isinstance(category, Subscription):
-                information = InformationDisplay(
-                    "Subscription",
-                    (
-                        ("ID", category.id),
-                        ("Title", category.title),
-                        ("Sort ID", category.sort_id),
-                        ("First Item Time", f"{category.first_item_time}"),
-                        ("URL", category.url),
-                        ("HTML URL", category.html_url),
-                        *(
-                            (
-                                f"Category[{n}]",
-                                f"{sub_category.id}, {sub_category.label}",
-                            )
-                            for n, sub_category in enumerate(category.categories)
-                        ),
-                    ),
-                )
-        elif self.article_view.has_focus_within and self.article:
             information = InformationDisplay(
-                "Article",
-                (
-                    ("ID", self.article.id),
-                    ("Title", self.article.title),
-                    ("Published", f"{self.article.published}"),
-                    ("Updated", f"{self.article.updated}"),
-                    *(
-                        (f"Category[{n}]", f"{sub_category}")
-                        for n, sub_category in enumerate(self.article.categories)
-                    ),
-                ),
+                category.__class__.__name__, data_dump(category)
             )
+        elif self.article_view.has_focus_within and self.article:
+            information = InformationDisplay("Article", data_dump(self.article))
         if information:
             await self.app.push_screen_wait(information)
 

{oldnews-0.5.0 → oldnews-0.6.0}/src/oldnews/screens/new_subscription.py

@@ -13,6 +13,7 @@ from oldas import Folders
 from textual import on
 from textual.app import ComposeResult
 from textual.containers import Horizontal, Vertical
+from textual.getters import query_one
 from textual.screen import ModalScreen
 from textual.widgets import Button, Input, Label
 
@@ -66,6 +67,13 @@ class NewSubscription(ModalScreen[NewSubscriptionData | None]):
 
     BINDINGS = [("escape", "cancel")]
 
+    feed_input = query_one("#feed", Input)
+    """The feed input widget."""
+    folder_input = query_one("#folder", Input)
+    """The folder input widget."""
+    add_button = query_one("#add", Button)
+    """The add button."""
+
     def __init__(self, folders: Folders) -> None:
         """Initialise the dialog object.
 
@@ -98,18 +106,16 @@ class NewSubscription(ModalScreen[NewSubscriptionData | None]):
     @on(Input.Changed, "#feed")
     def _refresh_state(self) -> None:
         """Refresh the state of the dialog."""
-        self.query_one("#add").disabled = not bool(
-            self.query_one("#feed", Input).value.strip()
-        )
+        self.add_button.disabled = not bool(self.feed_input.value.strip())
 
     @on(Button.Pressed, "#add")
     def action_add(self) -> None:
         """React to the user pressing the add button."""
-        if feed := self.query_one("#feed", Input).value.strip():
+        if feed := self.feed_input.value.strip():
             self.dismiss(
                 NewSubscriptionData(
                     feed=feed,
-                    folder=self.query_one("#folder", Input).value.strip(),
+                    folder=self.folder_input.value.strip(),
                 )
             )
 

{oldnews-0.5.0 → oldnews-0.6.0}/src/oldnews/sync.py

@@ -21,6 +21,7 @@ from oldas import (
 ##############################################################################
 from .data import (
     LocalUnread,
+    Log,
     get_local_subscriptions,
     get_local_unread,
     get_unread_article_ids,
@@ -28,6 +29,7 @@ from .data import (
     load_configuration,
     locally_mark_article_ids_read,
     remember_we_last_grabbed_at,
+    remove_subscription_articles,
     save_local_articles,
     save_local_folders,
     save_local_subscriptions,
@@ -60,12 +62,22 @@ class ToRSync:
     on_sync_finished: Callback = None
     """Function to call when the sync has finished."""
 
-    def _step(self, step: str) -> None:
+    def __post_init__(self) -> None:
+        """Initialise the sync object."""
+        self._last_sync = last_grabbed_data_at()
+        """The time at which we last did a sync."""
+        self._first_sync = self._last_sync is None
+        """Is this our first ever sync?"""
+
+    def _step(self, step: str, *, log: bool = True) -> None:
         """Mark a new step.
 
         Args:
             step: The step that is happening.
+            log: Should we log the step?
         """
+        if log:
+            Log().info(step)
         if self.on_new_step:
             self.on_new_step(step)
 
@@ -75,6 +87,7 @@ class ToRSync:
         Args:
             result: The result that should be shown.
         """
+        Log().info(result)
         if self.on_new_result:
             self.on_new_result(result)
 
@@ -103,34 +116,21 @@ class ToRSync:
             save_local_articles(Articles([article]))
             loaded += 1
             if (loaded % 10) == 0:
-                self._step(f"{description}: {loaded}")
+                self._step(f"{description}: {loaded}", log=False)
         return loaded
 
-    async def _download_newest_articles(self) -> None:
-        """Download the latest articles available."""
-        new_grab = datetime.now(timezone.utc)
-        last_grabbed = last_grabbed_data_at() or (
-            new_grab - timedelta(days=load_configuration().local_history)
-        )
-        if loaded := await self._download(
-            Articles.stream_new_since(self.session, last_grabbed, n=10),
-            "Downloading articles from TheOldReader",
-        ):
-            self._result(f"Articles downloaded: {loaded}")
-        else:
-            self._result("No new articles found on TheOldReader")
-        remember_we_last_grabbed_at(new_grab)
-
-    async def _refresh_read_status(self) -> None:
+    async def _get_updated_read_status(self) -> None:
         """Refresh the read status from the server."""
-        self._step("Getting list of unread articles from TheOldReader")
+        if self._first_sync:
+            return
+        self._step("Syncing read/unread status with TheOldReader")
         remote_unread_articles = set(
             article_id.full_id
             for article_id in await ArticleIDs.load_unread(self.session)
         )
-        self._step("Comparing against locally-read articles")
         local_unread_articles = set(get_unread_article_ids())
         if mark_as_read := local_unread_articles - remote_unread_articles:
+            Log().debug(f"Articles found as marked read elsewhere: {mark_as_read}")
             locally_mark_article_ids_read(mark_as_read)
             self._result(
                 f"Articles found read elsewhere on TheOldReader: {len(mark_as_read)}"
@@ -154,61 +154,134 @@ class ToRSync:
                     f"Downloaded article backlog for {subscription.title}: {loaded}"
                 )
 
-    async def refresh(self) -> None:
-        """Refresh the data from TheOldReader.
+    async def _get_folders(self) -> Folders:
+        """Get the list of folders from the server.
 
-        Args:
-            session: The TheOldReader API session object.
+        Returns:
+            The folders.
         """
-
-        # Get the folder list.
         self._step("Getting folder list")
         folders = save_local_folders(await Folders.load(self.session))
         if self.on_new_folders:
             self.on_new_folders(folders)
+        return folders
 
-        # Get the subscriptions list.
-        exising_subscriptions = get_local_subscriptions()
+    async def _get_subscriptions(self) -> tuple[Subscriptions, Subscriptions]:
+        """Get the list of subscriptions from the server.
+
+        Returns:
+            A tuple of the original subscription list before the sync, and
+            after.
+        """
         self._step("Getting subscriptions list")
+        original_subscriptions = get_local_subscriptions()
         subscriptions = save_local_subscriptions(await Subscriptions.load(self.session))
         if self.on_new_subscriptions:
             self.on_new_subscriptions(subscriptions)
+        return original_subscriptions, subscriptions
 
-        # Download the latest articles we don't know about.
-        if grabbed_before := ((last_grab := last_grabbed_data_at()) is not None):
-            self._step("Getting available articles")
+    async def _get_new_articles(self) -> None:
+        """Download any new articles."""
+        self._step(
+            "Getting available articles"
+            if self._first_sync
+            else f"Getting new articles since {self._last_sync}"
+        )
+        new_grab = datetime.now(timezone.utc)
+        last_grabbed = self._last_sync or (
+            new_grab - timedelta(days=load_configuration().local_history)
+        )
+        if loaded := await self._download(
+            Articles.stream_new_since(self.session, last_grabbed, n=10),
+            "Downloading articles from TheOldReader",
+        ):
+            self._result(f"Articles downloaded: {loaded}")
         else:
-            self._step(f"Getting new articles since {last_grab}")
-        await self._download_newest_articles()
-
-        # If we have grabbed data before, let's try and sync up what's been read.
-        if grabbed_before:
-            await self._refresh_read_status()
-
-        # It's possible we have subscriptions we didn't know about before,
-        # so we want to go and backfill their content regardless of read or
-        # unread status. So, if it looks like we've grabbed data before but
-        # now we have subscriptions we didn't know about before... let's
-        # grab their history regardless.
-        if grabbed_before:
-            was_subscribed_to = set(
-                subscription.id for subscription in exising_subscriptions
+            self._result("No new articles found on TheOldReader")
+        remember_we_last_grabbed_at(new_grab)
+
+    @staticmethod
+    def _set_of_ids(subscriptions: Subscriptions) -> set[str]:
+        """Get a set of the IDs of the given subscriptions.
+
+        Args:
+            subscriptions: The subscriptions to get the IDs of.
+
+        Returns:
+            A [set][`set`] of subscription IDs.
+        """
+        return {subscription.id for subscription in subscriptions}
+
+    async def _get_historical_articles(
+        self,
+        original_subscriptions: Subscriptions,
+        current_subscriptions: Subscriptions,
+    ) -> None:
+        """Download article histories for any new subscriptions.
+
+        Args:
+            original_subscriptions: The known subscriptions before the sync.
+            current_subscriptions: The subscriptions we're now subscribed to.
+
+        It's possible we have subscriptions we didn't know about before, so
+        we want to go and backfill their content regardless of read or
+        unread status. So, if it looks like we've grabbed data before but
+        now we have subscriptions we didn't know about before... let's grab
+        their history regardless.
+        """
+        Log().info("Checking for historical articles")
+        if not self._first_sync and (
+            new_subscriptions := self._set_of_ids(current_subscriptions)
+            - self._set_of_ids(original_subscriptions)
+        ):
+            Log().info(f"New subscriptions found: {new_subscriptions}")
+            await self._download_backlog(
+                subscription
+                for subscription in current_subscriptions
+                if subscription.id in new_subscriptions
             )
-            now_subscribed_to = set(subscription.id for subscription in subscriptions)
-            if new_subscriptions := now_subscribed_to - was_subscribed_to:
-                await self._download_backlog(
-                    subscription
-                    for subscription in subscriptions
-                    if subscription.id in new_subscriptions
-                )
 
-        # Recalculate the unread counts.
-        self._step("Calculating unread counts")
+    def _clean_orphaned_articles(
+        self,
+        original_subscriptions: Subscriptions,
+        current_subscriptions: Subscriptions,
+    ) -> None:
+        """Clean any articles left over from removed subscriptions.
+
+        Args:
+            original_subscriptions: The known subscriptions before the sync.
+            current_subscriptions: The subscriptions we're now subscribed to.
+        """
+        Log().info("Checking for orphaned articles")
+        if not self._first_sync and (
+            removed_subscriptions := self._set_of_ids(original_subscriptions)
+            - self._set_of_ids(current_subscriptions)
+        ):
+            Log().info(f"Found remotely-removed subscriptions: {removed_subscriptions}")
+            for subscription in removed_subscriptions:
+                remove_subscription_articles(subscription)
+
+    def _get_unread_counts(
+        self, folders: Folders, subscriptions: Subscriptions
+    ) -> None:
+        """Get the updated unread counts."""
         unread = get_local_unread(folders, subscriptions)
         if self.on_new_unread:
             self.on_new_unread(unread)
 
-        # Finally we're all done.
+    async def refresh(self) -> None:
+        """Refresh the data from TheOldReader.
+
+        Args:
+            session: The TheOldReader API session object.
+        """
+        folders = await self._get_folders()
+        original_subscriptions, subscriptions = await self._get_subscriptions()
+        await self._get_new_articles()
+        await self._get_updated_read_status()
+        await self._get_historical_articles(original_subscriptions, subscriptions)
+        self._clean_orphaned_articles(original_subscriptions, subscriptions)
+        self._get_unread_counts(folders, subscriptions)
         if self.on_sync_finished:
             self.on_sync_finished()
 

{oldnews-0.5.0 → oldnews-0.6.0}/src/oldnews/widgets/article_content.py

@@ -16,6 +16,7 @@ from oldas import Article
 # Textual imports.
 from textual.app import ComposeResult
 from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.getters import query_one
 from textual.reactive import var
 from textual.widgets import Label, Markdown, Rule
 
@@ -78,6 +79,17 @@ class ArticleContent(Vertical):
     article: var[Article | None] = var(None)
     """The article being viewed."""
 
+    title = query_one("#title", Label)
+    """The title label."""
+    published = query_one("#published", Label)
+    """The published date label."""
+    link = query_one("#link", Label)
+    """The link label."""
+    markdown = query_one(Markdown)
+    """The markdown display for the article."""
+    content = query_one(VerticalScroll)
+    """The article content."""
+
     def compose(self) -> ComposeResult:
         """Compose the content of the widget."""
         yield Rule()
@@ -93,20 +105,19 @@ class ArticleContent(Vertical):
     async def _watch_article(self) -> None:
         """React to the article being updated."""
         if self.article is not None:
-            self.query_one("#title", Label).update(self.article.title)
-            self.query_one("#published", Label).update(str(self.article.published))
-            link = self.query_one("#link", Label)
+            self.title.update(self.article.title)
+            self.published.update(str(self.article.published))
             if self.article.html_url is None:
-                link.visible = False
+                self.link.visible = False
             else:
-                link.visible = True
-                link.update(self.article.html_url)
-            await self.query_one(Markdown).update(convert(self.article.summary.content))
-            self.query_one(VerticalScroll).scroll_home(animate=False)
+                self.link.visible = True
+                self.link.update(self.article.html_url)
+            await self.markdown.update(convert(self.article.summary.content))
+            self.content.scroll_home(animate=False)
         self.set_class(self.article is not None, "--has-article")
 
     def focus(self, scroll_visible: bool = True) -> Self:
-        self.query_one(VerticalScroll).focus(scroll_visible)
+        self.content.focus(scroll_visible)
         return self
 
 

{oldnews-0.5.0 → oldnews-0.6.0}/src/oldnews/widgets/navigation.py

@@ -123,7 +123,13 @@ class Navigation(EnhancedOptionList):
     """
 
     BINDINGS = [
-        HelpfulBinding("ctrl+enter", "toggle_folder", tooltip="Expand/collapse folder")
+        HelpfulBinding("ctrl+enter", "toggle_folder", tooltip="Expand/collapse folder"),
+        HelpfulBinding(
+            "ctrl+right_square_bracket", "expand_all", tooltip="Expand all folders"
+        ),
+        HelpfulBinding(
+            "ctrl+left_square_bracket", "collapse_all", tooltip="Collapse all folders"
+        ),
     ]
 
     folders: var[Folders] = var(Folders)
@@ -213,6 +219,18 @@ class Navigation(EnhancedOptionList):
             self._save_state()
             self._refresh_navigation()
 
+    def _action_expand_all(self) -> None:
+        """Action that expands all folders."""
+        self._expanded = {folder.id for folder in self.folders}
+        self._save_state()
+        self._refresh_navigation()
+
+    def _action_collapse_all(self) -> None:
+        """Action that collapses all folders."""
+        self._expanded = set()
+        self._save_state()
+        self._refresh_navigation()
+
     @work(thread=True)
     def _save_state(self) -> None:
         """Save the folder expanded/collapsed state."""

{oldnews-0.5.0 → oldnews-0.6.0}/src/oldnews/providers/main.py

@@ -45,28 +45,28 @@ class MainCommands(CommandsProvider):
         Yields:
             The commands for the command palette.
         """
+        yield AddSubscription()
+        yield ChangeTheme()
+        yield from self.maybe(Copy)
+        yield from self.maybe(CopyArticleToClipboard)
+        yield from self.maybe(CopyFeedToClipboard)
+        yield from self.maybe(CopyHomePageToClipboard)
         yield Escape()
+        yield Help()
+        yield from self.maybe(Information)
+        yield from self.maybe(MarkAllRead)
+        yield from self.maybe(MoveSubscription)
         yield from self.maybe(Next)
         yield from self.maybe(NextUnread)
-        yield from self.maybe(Previous)
-        yield from self.maybe(PreviousUnread)
         yield from self.maybe(OpenArticle)
         yield from self.maybe(OpenHomePage)
-        yield from self.maybe(MarkAllRead)
-        yield from self.maybe(MoveSubscription)
-        yield from self.maybe(CopyHomePageToClipboard)
-        yield from self.maybe(CopyFeedToClipboard)
-        yield from self.maybe(CopyArticleToClipboard)
-        yield from self.maybe(Copy)
+        yield from self.maybe(Previous)
+        yield from self.maybe(PreviousUnread)
+        yield Quit()
+        yield RefreshFromTheOldReader()
         yield from self.maybe(Rename)
         yield from self.maybe(Remove)
-        yield from self.maybe(Information)
-        yield AddSubscription()
         yield ToggleShowAll()
-        yield RefreshFromTheOldReader()
-        yield ChangeTheme()
-        yield Help()
-        yield Quit()
 
 
 ### main.py ends here