oldnews 0.1.0__tar.gz → 0.3.0__tar.gz

{oldnews-0.1.0 → oldnews-0.3.0}/PKG-INFO

@@ -1,16 +1,15 @@
 Metadata-Version: 2.4
 Name: oldnews
-Version: 0.1.0
+Version: 0.3.0
 Summary: A terminal-based client for TheOldReader
 Keywords: atom,client,Google Reader,RSS,TheOldReader,terminal,news-reader,news
 Author: Dave Pearson
 Author-email: Dave Pearson <davep@davep.org>
 License-Expression: GPL-3.0-or-later
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
@@ -21,7 +20,7 @@ Requires-Dist: textual>=6.3.0
 Requires-Dist: textual-enhanced>=1.2.0
 Requires-Dist: typedal>=4.2.2
 Requires-Dist: xdg-base-dirs>=6.0.2
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Project-URL: Homepage, https://github.com/davep/oldnews
 Project-URL: Repository, https://github.com/davep/oldnews
 Project-URL: Documentation, https://oldnews.davep.dev/

{oldnews-0.1.0 → oldnews-0.3.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "oldnews"
-version = "0.1.0"
+version = "0.3.0"
 description = "A terminal-based client for TheOldReader"
 readme = "README.md"
 authors = [
     { name = "Dave Pearson", email = "davep@davep.org" }
 ]
-requires-python = ">=3.11"
+requires-python = ">=3.12"
 license = "GPL-3.0-or-later"
 keywords = [
     "atom",
@@ -27,11 +27,10 @@ dependencies = [
     "xdg-base-dirs>=6.0.2",
 ]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3 :: Only",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",

{oldnews-0.1.0 → oldnews-0.3.0}/src/oldnews/__main__.py

@@ -9,7 +9,7 @@ from operator import attrgetter
 ##############################################################################
 # Local imports.
 from . import __doc__, __version__
-from .data import initialise_database
+from .data import initialise_database, reset_data
 from .oldnews import OldNews
 
 
@@ -37,27 +37,48 @@ def get_args() -> Namespace:
         version=f"%(prog)s v{__version__}",
     )
 
-    # Add --license
+    # Add --theme
     parser.add_argument(
-        "--license",
-        "--licence",
+        "-t",
+        "--theme",
+        help="Set the theme for the application (see `themes` command for available themes)",
+    )
+
+    # Allow for commands on the command line.
+    sub_parser = parser.add_subparsers(
+        dest="command", help="Available commands", required=False
+    )
+
+    # Add the 'license' command.
+    sub_parser.add_parser(
+        "license",
+        aliases=["licence"],
         help="Show license information",
-        action="store_true",
     )
 
-    # Add --bindings
-    parser.add_argument(
-        "-b",
-        "--bindings",
+    # Add the 'bindings' command.
+    sub_parser.add_parser(
+        "bindings",
         help="List commands that can have their bindings changed",
-        action="store_true",
     )
 
-    # Add --theme
-    parser.add_argument(
-        "-t",
-        "--theme",
-        help="Set the theme for the application (set to ? to list available themes)",
+    # Add the 'themes' command.
+    sub_parser.add_parser(
+        "themes", help="List the available themes that can be used with --theme"
+    )
+
+    # Add the 'reset' command.
+    reset = sub_parser.add_parser(
+        "reset", help="Remove all data downloaded from TheOldReader"
+    )
+    reset.add_argument(
+        "-l", "--logout", help="Force a logout from TheOldReader", action="store_true"
+    )
+    reset.add_argument(
+        "-y",
+        "--yes",
+        help="Perform the reset without confirming first",
+        action="store_true",
     )
 
     # Finally, parse the command line.
@@ -91,18 +112,40 @@ def show_themes() -> None:
             print(theme)
 
 
+##############################################################################
+def reset_news(args: Namespace) -> None:
+    """Perform a reset on the news data.
+
+    Args:
+        args: The command line arguments.
+    """
+    from rich.prompt import Confirm
+
+    logout = " and log you out" if args.logout else ""
+    if args.yes or Confirm().ask(
+        f"This will erase all the local news data{logout}; are you sure?", default=False
+    ):
+        reset_data(args.logout)
+        print("Local data erased")
+        if args.logout:
+            print("Login token removed")
+
+
 ##############################################################################
 def main() -> None:
     """Main entry function."""
-    if (args := get_args()).license:
-        print(cleandoc(OldNews.HELP_LICENSE))
-    elif args.bindings:
-        show_bindable_commands()
-    elif args.theme == "?":
-        show_themes()
-    else:
-        initialise_database()
-        OldNews(args).run()
+    match (args := get_args()).command:
+        case "reset":
+            reset_news(args)
+        case "license" | "licence":
+            print(cleandoc(OldNews.HELP_LICENSE))
+        case "bindings":
+            show_bindable_commands()
+        case "themes":
+            show_themes()
+        case _:
+            initialise_database()
+            OldNews(args).run()
 
 
 ### __main__.py ends here

{oldnews-0.1.0 → oldnews-0.3.0}/src/oldnews/commands/__init__.py

@@ -8,6 +8,7 @@ from .main import (
     Next,
     NextUnread,
     OpenArticle,
+    OpenOrigin,
     Previous,
     PreviousUnread,
     RefreshFromTheOldReader,
@@ -22,6 +23,7 @@ __all__ = [
     "Next",
     "NextUnread",
     "OpenArticle",
+    "OpenOrigin",
     "Previous",
     "PreviousUnread",
     "RefreshFromTheOldReader",

{oldnews-0.1.0 → oldnews-0.3.0}/src/oldnews/commands/main.py

@@ -63,6 +63,13 @@ class OpenArticle(Command):
     BINDING_KEY = "o"
 
 
+##############################################################################
+class OpenOrigin(Command):
+    """Open the origin for the current article in the web browser"""
+
+    BINDING_KEY = "O"
+
+
 ##############################################################################
 class MarkAllRead(Command):
     """Mark all unread articles in the current category as read"""

{oldnews-0.1.0 → oldnews-0.3.0}/src/oldnews/data/__init__.py

@@ -12,6 +12,7 @@ from .config import (
 from .db import initialise_database
 from .last_grab import last_grabbed_data_at, remember_we_last_grabbed_at
 from .local_articles import (
+    clean_old_read_articles,
     get_local_articles,
     get_unread_article_ids,
     locally_mark_article_ids_read,
@@ -22,11 +23,13 @@ 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 .navigation_state import get_navigation_state, save_navigation_state
+from .reset import reset_data
 
 ##############################################################################
 # Exports.
 __all__ = [
     "Configuration",
+    "clean_old_read_articles",
     "get_auth_token",
     "get_local_articles",
     "get_local_folders",
@@ -41,6 +44,7 @@ __all__ = [
     "locally_mark_article_ids_read",
     "LocalUnread",
     "remember_we_last_grabbed_at",
+    "reset_data",
     "save_configuration",
     "save_local_articles",
     "save_local_folders",

{oldnews-0.1.0 → oldnews-0.3.0}/src/oldnews/data/db.py

@@ -3,11 +3,14 @@
 ##############################################################################
 # Python imports.
 from pathlib import Path
+from typing import Any
 
 ##############################################################################
 # TypeDAL imports.
-from typedal import TypeDAL, TypedTable
+from typedal import TypeDAL, TypedField, TypedTable
 from typedal.config import TypeDALConfig
+from typedal.helpers import get_field
+from typedal.types import Field
 
 ##############################################################################
 # Local imports.
@@ -30,7 +33,9 @@ def db_file() -> Path:
 
 
 ##############################################################################
-def _safely_index(table: type[TypedTable], name: str, field: str) -> None:
+def _safely_index(
+    table: type[TypedTable], name: str, field: str | Field | TypedField[Any]
+) -> None:
     """Create an index on a type, but handle errors.
 
     Args:
@@ -45,7 +50,9 @@ def _safely_index(table: type[TypedTable], name: str, field: str) -> None:
         just missed it.
     """
     try:
-        table.create_index(name, field)
+        table.create_index(
+            name, get_field(field) if isinstance(field, TypedField) else field
+        )
     except RuntimeError:
         pass
 
@@ -74,12 +81,11 @@ def initialise_database() -> TypeDAL:
     )
 
     dal.define(LocalArticleCategory)
-    # TODO: Need to make `field` more open.
-    # _safely_index(
-    #     LocalArticleCategory,
-    #     "idx_local_article_category_article",
-    #     LocalArticleCategory.article,
-    # )
+    _safely_index(
+        LocalArticleCategory,
+        "idx_local_article_category_article",
+        LocalArticleCategory.article,
+    )
     _safely_index(
         LocalArticleCategory,
         "idx_local_article_category_category",

{oldnews-0.1.0 → oldnews-0.3.0}/src/oldnews/data/local_articles.py

@@ -2,7 +2,7 @@
 
 ##############################################################################
 # Python imports.
-from datetime import datetime
+from datetime import datetime, timedelta
 from html import unescape
 from typing import Iterable, Iterator, cast
 
@@ -85,7 +85,7 @@ class LocalArticle(TypedTable):
 class LocalArticleCategory(TypedTable):
     """A local copy of the categories associated with an article."""
 
-    article: LocalArticle
+    article: TypedField[LocalArticle]
     """The article that this category belongs to."""
     category: str
     """The category."""
@@ -95,7 +95,7 @@ class LocalArticleCategory(TypedTable):
 class LocalArticleAlternate(TypedTable):
     """A local copy of the alternate URLs associated with an article."""
 
-    article: LocalArticle
+    article: TypedField[LocalArticle]
     """The article that this alternate belongs to."""
     href: str
     """The URL of the alternate."""
@@ -333,4 +333,19 @@ def get_unread_article_ids() -> list[str]:
     ]
 
 
+##############################################################################
+def clean_old_read_articles(cutoff: timedelta) -> int:
+    """Clean up articles that are older than the given cutoff time."""
+    assert LocalArticle._db is not None
+    read = get_local_read_article_ids()
+    retire_time = datetime.now() - cutoff
+    cleaned = len(
+        LocalArticle.where(
+            (LocalArticle.published < retire_time) & LocalArticle.id.belongs(read)
+        ).delete()
+    )
+    LocalArticle._db.commit()
+    return cleaned
+
+
 ### local_articles.py ends here

oldnews-0.3.0/src/oldnews/data/reset.py

@@ -0,0 +1,26 @@
+"""Provides a tool to reset all the data."""
+
+##############################################################################
+# Python imports.
+from pathlib import Path
+
+##############################################################################
+# Local imports.
+from .locations import data_dir
+
+
+##############################################################################
+def reset_data(logout: bool) -> None:
+    """Erase all the data.
+
+    Args:
+        logout: Should any token file be removed too?
+    """
+    to_remove: list[Path] = []
+    for pattern in ("*.table", "*.db", "*.log", *((".token",) if logout else ())):
+        to_remove.extend(data_dir().glob(pattern))
+    for data_file in to_remove:
+        data_file.unlink()
+
+
+### reset.py ends here

{oldnews-0.1.0 → oldnews-0.3.0}/src/oldnews/providers/main.py

@@ -18,6 +18,7 @@ from ..commands import (
     Next,
     NextUnread,
     OpenArticle,
+    OpenOrigin,
     Previous,
     PreviousUnread,
     RefreshFromTheOldReader,
@@ -41,6 +42,7 @@ class MainCommands(CommandsProvider):
         yield from self.maybe(Previous)
         yield from self.maybe(PreviousUnread)
         yield from self.maybe(OpenArticle)
+        yield from self.maybe(OpenOrigin)
         yield from self.maybe(MarkAllRead)
         yield ToggleShowAll()
         yield RefreshFromTheOldReader()

{oldnews-0.1.0 → oldnews-0.3.0}/src/oldnews/screens/main.py

@@ -3,14 +3,13 @@
 ##############################################################################
 # Python imports.
 from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timedelta
 from webbrowser import open as open_url
 
 ##############################################################################
 # OldAs imports.
 from oldas import (
     Article,
-    ArticleIDs,
     Articles,
     Folder,
     Folders,
@@ -44,6 +43,7 @@ from ..commands import (
     Next,
     NextUnread,
     OpenArticle,
+    OpenOrigin,
     Previous,
     PreviousUnread,
     RefreshFromTheOldReader,
@@ -51,23 +51,20 @@ from ..commands import (
 )
 from ..data import (
     LocalUnread,
+    clean_old_read_articles,
     get_local_articles,
     get_local_folders,
     get_local_subscriptions,
     get_local_unread,
-    get_unread_article_ids,
     last_grabbed_data_at,
     load_configuration,
     locally_mark_article_ids_read,
     locally_mark_read,
-    remember_we_last_grabbed_at,
-    save_local_articles,
-    save_local_folders,
-    save_local_subscriptions,
     total_unread,
     update_configuration,
 )
 from ..providers import MainCommands
+from ..sync import ToRSync
 from ..widgets import ArticleContent, ArticleList, Navigation
 
 
@@ -145,6 +142,7 @@ class Main(EnhancedScreen[None]):
         Previous,
         PreviousUnread,
         OpenArticle,
+        OpenOrigin,
         ChangeTheme,
     ]
 
@@ -195,6 +193,9 @@ class Main(EnhancedScreen[None]):
         counts: LocalUnread
         """The new unread counts."""
 
+    class SyncFinished(Message):
+        """Message sent when a sync from TheOldReader is finished."""
+
     def __init__(self, session: Session) -> None:
         """Initialise the main screen."""
         super().__init__()
@@ -236,7 +237,7 @@ class Main(EnhancedScreen[None]):
             # but okay let's be defensive... (when I can come up with a nice
             # little MRE I'll report it).
             return True
-        if action == OpenArticle.action_name():
+        if action in (OpenArticle.action_name(), OpenOrigin.action_name()):
             return self.article is not None
         if action in (Next.action_name(), Previous.action_name()):
             return self.articles is not None
@@ -245,6 +246,12 @@ class Main(EnhancedScreen[None]):
             PreviousUnread.action_name(),
             MarkAllRead.action_name(),
         ):
+            # If we're inside the navigation panel...
+            if self.query_one(Navigation).has_focus:
+                # ...we just care if there's anything unread somewhere.
+                return any(total for total in self.unread.values())
+            # Otherwise we care if we can see a current list of articles and
+            # if there's something unread amongst them.
             return self.articles is not None and any(
                 article.is_unread for article in self.articles
             )
@@ -289,6 +296,11 @@ class Main(EnhancedScreen[None]):
         self.unread = message.counts
         self.post_message(self.SubTitle(""))
 
+    def _refresh_article_list(self) -> None:
+        """Refresh the content of the article list."""
+        if self.current_category:
+            self.articles = get_local_articles(self.current_category, not self.show_all)
+
     @work(thread=True, exclusive=True)
     def _load_locally(self) -> None:
         """Load up any locally-held data."""
@@ -296,8 +308,13 @@ class Main(EnhancedScreen[None]):
             self.post_message(self.NewFolders(folders))
         if subscriptions := get_local_subscriptions():
             self.post_message(self.NewSubscriptions(subscriptions))
+        if cleaned := clean_old_read_articles(
+            timedelta(days=load_configuration().local_history)
+        ):
+            self.notify(f"Old read articles cleaned from local storage: {cleaned}")
         if unread := get_local_unread(folders, subscriptions):
             self.post_message(self.NewUnread(unread))
+        self._refresh_article_list()
         # If we've never grabbed data from ToR before, or if it's been long enough...
         if (last_grabbed := last_grabbed_data_at()) is None or (
             (datetime.now() - last_grabbed).seconds
@@ -306,95 +323,27 @@ class Main(EnhancedScreen[None]):
             # ...kick off a refresh from TheOldReader.
             self.post_message(RefreshFromTheOldReader())
 
-    async def _download_newest_articles(self) -> None:
-        """Download the latest articles available."""
-        last_grabbed = last_grabbed_data_at() or (
-            datetime.now() - timedelta(days=load_configuration().local_history)
-        )
-        new_grab = datetime.now(timezone.utc)
-        loaded = 0
-        async for article in Articles.stream_new_since(
-            self._session, last_grabbed, n=10
-        ):
-            # I've encountered articles that don't have an origin stream ID,
-            # which means that I can't relate them back to a stream, which
-            # means I'll never see them anyway...
-            if not article.origin.stream_id:
-                continue
-            # TODO: Right now I'm saving articles one at a time; perhaps I
-            # should save them in small batches? This would be simple enough
-            # -- perhaps same them in batches the same size as the buffer
-            # window I'm using right now (currently 10 articles per trip to
-            # ToR).
-            save_local_articles(Articles([article]))
-            loaded += 1
-            if (loaded % 10) == 0:
-                self.post_message(
-                    self.SubTitle(f"Downloading articles from TheOldReader: {loaded}")
-                )
-        if loaded:
-            self.notify(f"Articles downloaded: {loaded}")
-        else:
-            self.notify("No new articles found on TheOldReader")
-        remember_we_last_grabbed_at(new_grab)
-
-    async def _refresh_read_status(self) -> None:
-        """Refresh the read status from the server."""
-        self.post_message(
-            self.SubTitle("Getting list of unread articles from TheOldReader")
-        )
-        remote_unread_articles = set(
-            article_id.full_id
-            for article_id in await ArticleIDs.load_unread(self._session)
-        )
-        self.post_message(self.SubTitle("Comparing against locally-read articles"))
-        local_unread_articles = set(get_unread_article_ids())
-        if mark_as_read := local_unread_articles - remote_unread_articles:
-            locally_mark_article_ids_read(mark_as_read)
-            self.notify(
-                f"Articles found read elsewhere on TheOldReader: {len(mark_as_read)}"
-            )
+    @on(SyncFinished)
+    def _sync_finished(self) -> None:
+        """Clean up after a sync from TheOldReader has finished."""
+        self._refresh_article_list()
+        self.post_message(self.SubTitle(""))
 
     @on(RefreshFromTheOldReader)
     @work(exclusive=True)
     async def action_refresh_from_the_old_reader_command(self) -> None:
         """Load the main data from TheOldReader."""
-
-        # Get the folder list.
-        self.post_message(self.SubTitle("Getting folder list"))
-        self.post_message(
-            self.NewFolders(save_local_folders(await Folders.load(self._session)))
-        )
-
-        # Get the subscriptions list.
-        self.post_message(self.SubTitle("Getting subscriptions list"))
-        self.post_message(
-            self.NewSubscriptions(
-                save_local_subscriptions(await Subscriptions.load(self._session))
-            )
-        )
-
-        # Download the latest articles we don't know about.
-        if never_grabbed_before := last_grabbed_data_at() is None:
-            self.post_message(self.SubTitle("Getting available articles"))
-        else:
-            self.post_message(
-                self.SubTitle(f"Getting articles new since {last_grabbed_data_at()}")
-            )
-        await self._download_newest_articles()
-
-        # If we have grabbed data before, let's try and sync up what's been read.
-        if not never_grabbed_before:
-            await self._refresh_read_status()
-
-        # Recalculate the unread counts.
-        self.post_message(self.SubTitle("Calculating unread counts"))
-        self.post_message(
-            self.NewUnread(get_local_unread(self.folders, self.subscriptions))
-        )
-
-        # Finally we're all done.
-        self.post_message(self.SubTitle(""))
+        await ToRSync(
+            self._session,
+            on_new_step=lambda step: self.post_message(self.SubTitle(step)),
+            on_new_result=lambda result: self.notify(result),
+            on_new_folders=lambda folders: self.post_message(self.NewFolders(folders)),
+            on_new_subscriptions=lambda subscriptions: self.post_message(
+                self.NewSubscriptions(subscriptions)
+            ),
+            on_new_unread=lambda unread: self.post_message(self.NewUnread(unread)),
+            on_sync_finished=lambda: self.post_message(self.SyncFinished()),
+        ).refresh()
 
     @on(Navigation.CategorySelected)
     def _handle_navigaion_selection(self, message: Navigation.CategorySelected) -> None:
@@ -405,14 +354,9 @@ class Main(EnhancedScreen[None]):
         """
         self.current_category = message.category
         self.article = None
-        self.articles = get_local_articles(message.category, not self.show_all)
+        self._refresh_article_list()
         self.query_one(ArticleList).focus()
 
-    def _refresh_article_list(self) -> None:
-        """Refresh the content of the article list."""
-        if category := self.query_one(Navigation).current_category:
-            self.articles = get_local_articles(category, not self.show_all)
-
     def _watch_show_all(self) -> None:
         """Handle changes to the show all flag."""
         self._refresh_article_list()
@@ -487,14 +431,18 @@ class Main(EnhancedScreen[None]):
 
     def action_next_unread_command(self) -> None:
         """Go to the next unread article in the currently-viewed category."""
-        if self.article is None:
+        if (navigation := self.query_one(Navigation)).has_focus:
+            navigation.highlight_next_unread_category()
+        elif self.article is None:
             self.query_one(ArticleList).highlight_next_unread_article()
         else:
             self.query_one(ArticleList).select_next_unread_article()
 
     def action_previous_unread_command(self) -> None:
         """Go to the previous unread article in the currently-viewed category"""
-        if self.article is None:
+        if (navigation := self.query_one(Navigation)).has_focus:
+            navigation.highlight_previous_unread_category()
+        elif self.article is None:
             self.query_one(ArticleList).highlight_previous_unread_article()
         else:
             self.query_one(ArticleList).select_previous_unread_article()
@@ -546,5 +494,17 @@ class Main(EnhancedScreen[None]):
                     severity="error",
                 )
 
+    def action_open_origin_command(self) -> None:
+        """Open the origin of the current article in the web browser."""
+        if self.article is not None:
+            if self.article.origin.html_url:
+                open_url(self.article.origin.html_url)
+            else:
+                self.notify(
+                    "No URL available for the article's origin",
+                    severity="error",
+                    title="Can't visit",
+                )
+
 
 ### main.py ends here

oldnews-0.3.0/src/oldnews/sync/__init__.py

@@ -0,0 +1,11 @@
+"""Code to sync the local data from TheOldReader."""
+
+##############################################################################
+# Local imports.
+from .sync import ToRSync
+
+##############################################################################
+# Exports.
+__all__ = ["ToRSync"]
+
+### __init__.py ends here

oldnews-0.3.0/src/oldnews/sync/sync.py

@@ -0,0 +1,158 @@
+"""Provides a class to sync data from TheOldReader."""
+
+##############################################################################
+# Python imports.
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import Any, Callable
+
+##############################################################################
+# OldAS imports.
+from oldas import ArticleIDs, Articles, Folders, Session, Subscriptions
+
+##############################################################################
+from ..data import (
+    LocalUnread,
+    get_local_unread,
+    get_unread_article_ids,
+    last_grabbed_data_at,
+    load_configuration,
+    locally_mark_article_ids_read,
+    remember_we_last_grabbed_at,
+    save_local_articles,
+    save_local_folders,
+    save_local_subscriptions,
+)
+
+##############################################################################
+type Callback = Callable[[], Any] | None
+"""Type of a callback with no arguments."""
+type CallbackWith[T] = Callable[[T], Any] | None
+"""Type of callback with a single argument."""
+
+
+##############################################################################
+@dataclass
+class ToRSync:
+    """Class that handles syncing data from TheOldReader."""
+
+    session: Session
+    """The TheOldReader API session object."""
+    on_new_step: CallbackWith[str] = None
+    """Function to call when a new step starts."""
+    on_new_result: CallbackWith[str] = None
+    """Function to call when a result should be communicated."""
+    on_new_folders: CallbackWith[Folders] = None
+    """Function to call when new folders are acquired."""
+    on_new_subscriptions: CallbackWith[Subscriptions] = None
+    """Function to call when new subscriptions are acquired."""
+    on_new_unread: CallbackWith[LocalUnread] = None
+    """Function to call when new unread counts are calculated."""
+    on_sync_finished: Callback = None
+    """Function to call when the sync has finished."""
+
+    def _step(self, step: str) -> None:
+        """Mark a new step.
+
+        Args:
+            step: The step that is happening.
+        """
+        if self.on_new_step:
+            self.on_new_step(step)
+
+    def _result(self, result: str) -> None:
+        """Show a new result.
+
+        Args:
+            result: The result that should be shown.
+        """
+        if self.on_new_result:
+            self.on_new_result(result)
+
+    async def _download_newest_articles(self) -> None:
+        """Download the latest articles available."""
+        last_grabbed = last_grabbed_data_at() or (
+            datetime.now() - timedelta(days=load_configuration().local_history)
+        )
+        new_grab = datetime.now(timezone.utc)
+        loaded = 0
+        async for article in Articles.stream_new_since(
+            self.session, last_grabbed, n=10
+        ):
+            # I've encountered articles that don't have an origin stream ID,
+            # which means that I can't relate them back to a stream, which
+            # means I'll never see them anyway...
+            if not article.origin.stream_id:
+                continue
+            # TODO: Right now I'm saving articles one at a time; perhaps I
+            # should save them in small batches? This would be simple enough
+            # -- perhaps same them in batches the same size as the buffer
+            # window I'm using right now (currently 10 articles per trip to
+            # ToR).
+            save_local_articles(Articles([article]))
+            loaded += 1
+            if (loaded % 10) == 0:
+                self._step(f"Downloading articles from TheOldReader: {loaded}")
+        if loaded:
+            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:
+        """Refresh the read status from the server."""
+        self._step("Getting list of unread articles from 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:
+            locally_mark_article_ids_read(mark_as_read)
+            self._result(
+                f"Articles found read elsewhere on TheOldReader: {len(mark_as_read)}"
+            )
+
+    async def refresh(self) -> None:
+        """Refresh the data from TheOldReader.
+
+        Args:
+            session: The TheOldReader API session object.
+        """
+
+        # 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)
+
+        # Get the subscriptions list.
+        self._step("Getting subscriptions list")
+        subscriptions = save_local_subscriptions(await Subscriptions.load(self.session))
+        if self.on_new_subscriptions:
+            self.on_new_subscriptions(subscriptions)
+
+        # Download the latest articles we don't know about.
+        if never_grabbed_before := ((last_grab := last_grabbed_data_at()) is None):
+            self._step("Getting available articles")
+        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 not never_grabbed_before:
+            await self._refresh_read_status()
+
+        # Recalculate the unread counts.
+        self._step("Calculating unread counts")
+        unread = get_local_unread(folders, subscriptions)
+        if self.on_new_unread:
+            self.on_new_unread(unread)
+
+        # Finally we're all done.
+        if self.on_sync_finished:
+            self.on_sync_finished()
+
+
+### sync.py ends here

oldnews-0.3.0/src/oldnews/widgets/_after_highlight.py

@@ -0,0 +1,53 @@
+"""Support code for OptionLists that want to find things."""
+
+##############################################################################
+# Python imports.
+from typing import Callable, Iterator, Literal
+
+##############################################################################
+# Textual imports.
+from textual.widgets import OptionList
+
+##############################################################################
+type HighlightDirection = Literal["next", "previous"]
+"""Type of a unread search direction."""
+
+
+##############################################################################
+def options_after_highlight[T](
+    option_list: OptionList,
+    options: list[T],
+    direction: HighlightDirection,
+    option_filter: Callable[[T], bool] | None = None,
+) -> Iterator[T]:
+    """Return a list of `OptionList` options after the highlight.
+
+    Args:
+        option_list: The `OptionList` to work against.
+        options: The options from the given option list.
+        direction: The direction to consider as 'after'.
+        option_filter: Optional filter to apply to the list.
+
+    Returns:
+        An iterator of options.
+
+    Notes:
+        If there is no highlight, we default at position 0.
+
+        The options are taken as a parameter, rather than just been pulled
+        out of `option_list`, so that you have a chance to `cast` the list
+        to the desired type, which in turn ensures that the return type
+        matches.
+    """
+    option_filter = option_filter or (lambda _: True)
+    highlight = option_list.highlighted or 0
+    options = list(reversed(options)) if direction == "previous" else options
+    highlight = (len(options) - highlight - 1) if direction == "previous" else highlight
+    return (
+        option
+        for option in [*options[highlight:], *options[0:highlight]][1:]
+        if option_filter(option)
+    )
+
+
+### _after_highlight.py ends here

{oldnews-0.1.0 → oldnews-0.3.0}/src/oldnews/widgets/article_content.py

@@ -15,9 +15,9 @@ from oldas import Article
 ##############################################################################
 # Textual imports.
 from textual.app import ComposeResult
-from textual.containers import Vertical, VerticalScroll
+from textual.containers import Horizontal, Vertical, VerticalScroll
 from textual.reactive import var
-from textual.widgets import Label, Markdown
+from textual.widgets import Label, Markdown, Rule
 
 
 ##############################################################################
@@ -32,18 +32,36 @@ class ArticleContent(Vertical):
             display: block;
         }
 
+        Rule.-horizontal {
+            margin: 0;
+        }
+
         #header {
             height: auto;
             padding: 0 1 0 1;
 
+            Horizontal {
+                height: auto;
+            }
+
             #title {
                 color: $text-accent;
+                width: 1fr;
             }
             #published, #link {
                 color: $text-muted;
             }
         }
 
+        &:focus-within {
+            #header, Rule {
+                background: $boost;
+            }
+            Rule {
+                color: $border;
+            }
+        }
+
         Markdown {
             padding: 0 1 0 1;
         }
@@ -62,16 +80,18 @@ class ArticleContent(Vertical):
 
     def compose(self) -> ComposeResult:
         """Compose the content of the widget."""
+        yield Rule()
         with Vertical(id="header"):
-            yield Label(id="title", markup=False)
-            yield Label(id="published")
+            with Horizontal():
+                yield Label(id="title", markup=False)
+                yield Label(id="published")
             yield Label(id="link", markup=False)
+        yield Rule()
         with VerticalScroll():
             yield Markdown()
 
-    def _watch_article(self) -> None:
+    async def _watch_article(self) -> None:
         """React to the article being updated."""
-        self.set_class(self.article is not None, "--has-article")
         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))
@@ -81,7 +101,9 @@ class ArticleContent(Vertical):
             else:
                 link.visible = True
                 link.update(self.article.html_url)
-            self.query_one(Markdown).update(convert(self.article.summary.content))
+            await self.query_one(Markdown).update(convert(self.article.summary.content))
+            self.query_one(VerticalScroll).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)

{oldnews-0.1.0 → oldnews-0.3.0}/src/oldnews/widgets/article_list.py

@@ -1,9 +1,13 @@
 """Widget to show a list of articles."""
 
+##############################################################################
+# Backward compatibility.
+from __future__ import annotations
+
 ##############################################################################
 # Python imports.
 from dataclasses import dataclass
-from typing import Iterator, Literal, cast
+from typing import cast
 
 ##############################################################################
 # OldAs imports.
@@ -26,6 +30,10 @@ from textual.widgets.option_list import Option
 # Textual enhanced imports.
 from textual_enhanced.widgets import EnhancedOptionList
 
+##############################################################################
+# Local imports.
+from ._after_highlight import HighlightDirection, options_after_highlight
+
 
 ##############################################################################
 class ArticleView(Option):
@@ -73,11 +81,6 @@ class ArticleView(Option):
         return self._article
 
 
-##############################################################################
-UnreadSearchDirection = Literal["next", "previous"]
-"""Type of a unread search direction."""
-
-
 ##############################################################################
 class ArticleList(EnhancedOptionList):
     """Widget for showing a list of articles."""
@@ -139,36 +142,7 @@ class ArticleList(EnhancedOptionList):
         assert isinstance(message.option, ArticleView)
         self.post_message(self.ViewArticle(message.option.article))
 
-    def _unread_articles_after_highlight(
-        self, direction: UnreadSearchDirection
-    ) -> Iterator[ArticleView]:
-        """Return a list of all articles after the highlight.
-
-        Args:
-            direction: The direction to search in.
-
-        Returns:
-            An iterator of `ArticleView` objects that show an unread article.
-
-        Notes:
-            If there is no highlight, we default at position 0.
-        """
-        highlight = self.highlighted or 0
-        options = (
-            list(reversed(self.options)) if direction == "previous" else self.options
-        )
-        highlight = (
-            (len(options) - highlight - 1) if direction == "previous" else highlight
-        )
-        return (
-            article_view
-            for article_view in cast(
-                list[ArticleView], [*options[highlight:], *options[0:highlight]]
-            )[1:]
-            if article_view.article.is_unread
-        )
-
-    def _highlight_unread(self, direction: UnreadSearchDirection) -> bool:
+    def _highlight_unread(self, direction: HighlightDirection) -> bool:
         """Highlight the next unread article, if there is one.
 
         Args:
@@ -178,7 +152,15 @@ class ArticleList(EnhancedOptionList):
             `True` if an unread article was found and highlighted, `False`
             if not.
         """
-        if next_hit := next(self._unread_articles_after_highlight(direction), None):
+        if next_hit := next(
+            options_after_highlight(
+                self,
+                cast(list[ArticleView], self.options),
+                direction,
+                lambda article_view: article_view.article.is_unread,
+            ),
+            None,
+        ):
             if next_hit.id is not None:
                 self.highlighted = self.get_option_index(next_hit.id)
                 return True

{oldnews-0.1.0 → oldnews-0.3.0}/src/oldnews/widgets/navigation.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 ##############################################################################
 # Python imports.
 from dataclasses import dataclass
+from typing import cast
 
 ##############################################################################
 # OldAs imports.
@@ -34,6 +35,7 @@ from textual_enhanced.widgets import EnhancedOptionList
 ##############################################################################
 # Local imports.
 from ..data import LocalUnread, get_navigation_state, save_navigation_state
+from ._after_highlight import HighlightDirection, options_after_highlight
 
 
 ##############################################################################
@@ -102,7 +104,7 @@ class SubscriptionView(Option):
             "",
             str(unread) if unread else "",
         )
-        super().__init__(prompt)
+        super().__init__(prompt, id=subscription.id)
 
     @property
     def subscription(self) -> Subscription:
@@ -236,5 +238,38 @@ class Navigation(EnhancedOptionList):
             return selected.subscription
         raise ValueError("Unknown category")
 
+    def _highlight_unread(self, direction: HighlightDirection) -> bool:
+        """Highlight the next category with unread articles, if there is one.
+
+        Args:
+            direction: The direction to search.
+
+        Returns:
+            `True` if an unread category was found and highlighted, `False`
+            if not.
+        """
+        if next_hit := next(
+            options_after_highlight(
+                self,
+                cast(list[FolderView | SubscriptionView], self.options),
+                direction,
+                lambda category: bool(category.id and self.unread.get(category.id)),
+            ),
+            None,
+        ):
+            if next_hit.id is not None:
+                self.highlighted = self.get_option_index(next_hit.id)
+                return True
+        self.notify("No more folders or subscriptions with unread articles")
+        return False
+
+    def highlight_next_unread_category(self) -> None:
+        """Highlight the next unread category."""
+        self._highlight_unread("next")
+
+    def highlight_previous_unread_category(self) -> None:
+        """Highlight the previous unread category."""
+        self._highlight_unread("previous")
+
 
 ### navigation.py ends here