oldnews 0.6.0__tar.gz → 0.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oldnews
-Version: 0.6.0
+Version: 0.8.0
 Summary: A terminal-based client for TheOldReader
 Keywords: atom,client,Google Reader,RSS,TheOldReader,terminal,news-reader,news
 Author: Dave Pearson
@@ -14,8 +14,9 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Typing :: Typed
+Requires-Dist: bagofstuff>=0.1.0
 Requires-Dist: html-to-markdown>=2.15.0
-Requires-Dist: oldas>=0.6.0
+Requires-Dist: oldas>=0.10.0
 Requires-Dist: textual>=6.3.0
 Requires-Dist: textual-autocomplete>=4.0.6
 Requires-Dist: textual-enhanced>=1.2.0

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

@@ -1,6 +1,6 @@
 [project]
 name = "oldnews"
-version = "0.6.0"
+version = "0.8.0"
 description = "A terminal-based client for TheOldReader"
 readme = "README.md"
 authors = [
@@ -19,8 +19,9 @@ keywords = [
     "news",
 ]
 dependencies = [
+    "bagofstuff>=0.1.0",
     "html-to-markdown>=2.15.0",
-    "oldas>=0.6.0",
+    "oldas>=0.10.0",
     "textual>=6.3.0",
     "textual-autocomplete>=4.0.6",
     "textual-enhanced>=1.2.0",

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

@@ -6,6 +6,10 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta
 from webbrowser import open as open_url
 
+##############################################################################
+# BagOfStuff imports.
+from bagofstuff.pipe import Pipe
+
 ##############################################################################
 # OldAs imports.
 from oldas import (
@@ -79,11 +83,12 @@ from ..data import (
     update_configuration,
 )
 from ..providers import MainCommands
-from ..sync import ToRSync
+from ..sync import TheOldReaderSync
 from ..widgets import ArticleContent, ArticleList, Navigation
 from .folder_input import FolderInput
 from .information_display import InformationDisplay
 from .new_subscription import NewSubscription
+from .process_subscription import ProcessSubscription
 
 
 ##############################################################################
@@ -402,17 +407,19 @@ class Main(EnhancedScreen[None]):
     @work(exclusive=True)
     async def action_refresh_from_the_old_reader_command(self) -> None:
         """Load the main data from TheOldReader."""
-        await ToRSync(
+        await TheOldReaderSync(
             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_step=Pipe[str, bool](self.SubTitle, self.post_message),
+            on_new_result=self.notify,
+            on_new_folders=Pipe[Folders, bool](self.NewFolders, self.post_message),
+            on_new_subscriptions=Pipe[Subscriptions, bool](
+                self.NewSubscriptions, self.post_message
+            ),
+            on_new_unread=Pipe[LocalUnread, bool](self.NewUnread, self.post_message),
+            on_sync_finished=Pipe[Pipe.Nullary, bool](
+                self.SyncFinished, self.post_message
             ),
-            on_new_unread=lambda unread: self.post_message(self.NewUnread(unread)),
-            on_sync_finished=lambda: self.post_message(self.SyncFinished()),
-        ).refresh()
+        ).sync()
 
     @on(Navigation.CategorySelected)
     def _handle_navigaion_selection(self, message: Navigation.CategorySelected) -> None:
@@ -624,11 +631,10 @@ class Main(EnhancedScreen[None]):
         if subscription := await self.app.push_screen_wait(
             NewSubscription(self.folders)
         ):
-            self.notify(
-                subscription.feed, title="Subscription request sent to TheOldReader..."
-            )
             if (
-                result := await Subscriptions.add(self._session, subscription.feed)
+                result := await self.app.push_screen_wait(
+                    ProcessSubscription(self._session, subscription)
+                )
             ).failed:
                 self.notify(
                     result.error or "TheOldReader did not give a reason",

oldnews-0.8.0/src/oldnews/screens/process_subscription.py

@@ -0,0 +1,87 @@
+"""Provides a dialog for waiting for TheOldReader to add a subscription."""
+
+##############################################################################
+# OldAS imports.
+from oldas import Session, Subscriptions
+from oldas.subscriptions import SubscribeResult
+
+##############################################################################
+# Textual imports.
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Center, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Label, LoadingIndicator
+
+##############################################################################
+# Local data.
+from .new_subscription import NewSubscriptionData
+
+
+##############################################################################
+class ProcessSubscription(ModalScreen[SubscribeResult]):
+    """Dialog for waiting for TheOldReader to process a subscription."""
+
+    CSS = """
+    ProcessSubscription {
+        align: center middle;
+
+        &> Vertical {
+            padding: 1 2;
+            width: auto;
+            height: auto;
+            min-width: 60%;
+            max-width: 90%;
+            background: $panel;
+            border: panel $border;
+            LoadingIndicator {
+                margin-top: 1;
+            }
+            Center {
+                width: 100%;
+            }
+        }
+    }
+    """
+
+    def __init__(self, session: Session, new_subscription: NewSubscriptionData) -> None:
+        """Initialise the subscription processing dialog object.
+
+        Args:
+            session: The ToR API session object.
+            new_subscription: The new subscription.
+        """
+        self._session = session
+        """The API session object."""
+        self._feed = new_subscription.feed
+        """The feed to subscribe to."""
+        self._folder = new_subscription.folder
+        """The folder to place the subscription in."""
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose the content of the screen."""
+        with Vertical() as dialog:
+            dialog.border_title = "Waiting for TheOldReader to add the feed..."
+            yield Label(
+                f"Subscribing to {self._feed}"
+                + (f" and adding it to {self._folder}" if self._folder else "")
+                + ".\n\n"
+                "TheOldReader can take a short while to scan and add a feed. Please wait...",
+                shrink=True,
+                markup=False,
+            )
+            with Center():
+                yield LoadingIndicator()
+
+    @work
+    async def _request_subscription(self) -> None:
+        """Process the request."""
+        self.dismiss(await Subscriptions.add(self._session, self._feed))
+
+    def on_mount(self) -> None:
+        """Start the work once the DOM is ready."""
+        self._request_subscription()
+
+
+### process_subscription.py ends here

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

@@ -4,7 +4,7 @@
 # Python imports.
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
-from typing import Any, AsyncIterator, Callable, Iterable
+from typing import Any, AsyncIterator, Callable, Final, Iterable
 
 ##############################################################################
 # OldAS imports.
@@ -41,10 +41,14 @@ type Callback = Callable[[], Any] | None
 type CallbackWith[T] = Callable[[T], Any] | None
 """Type of callback with a single argument."""
 
+##############################################################################
+BATCH_SIZE: Final[int] = 10
+"""Batch size for downloading articles."""
+
 
 ##############################################################################
 @dataclass
-class ToRSync:
+class TheOldReaderSync:
     """Class that handles syncing data from TheOldReader."""
 
     session: Session
@@ -111,11 +115,11 @@ class ToRSync:
             # 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).
+            # window I'm using right now (currently BATCH_SIZE articles per
+            # trip to ToR).
             save_local_articles(Articles([article]))
             loaded += 1
-            if (loaded % 10) == 0:
+            if (loaded % BATCH_SIZE) == 0:
                 self._step(f"{description}: {loaded}", log=False)
         return loaded
 
@@ -147,7 +151,9 @@ class ToRSync:
         )
         for subscription in subscriptions:
             if loaded := await self._download(
-                Articles.stream_new_since(self.session, cutoff, subscription, n=10),
+                Articles.stream_new_since(
+                    self.session, cutoff, subscription, n=BATCH_SIZE
+                ),
                 f"Downloading article backlog for {subscription.title}",
             ):
                 self._result(
@@ -192,7 +198,7 @@ class ToRSync:
             new_grab - timedelta(days=load_configuration().local_history)
         )
         if loaded := await self._download(
-            Articles.stream_new_since(self.session, last_grabbed, n=10),
+            Articles.stream_new_since(self.session, last_grabbed, n=BATCH_SIZE),
             "Downloading articles from TheOldReader",
         ):
             self._result(f"Articles downloaded: {loaded}")
@@ -264,17 +270,17 @@ class ToRSync:
     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)
-
-    async def refresh(self) -> None:
-        """Refresh the data from TheOldReader.
+        """Get the updated unread counts.
 
         Args:
-            session: The TheOldReader API session object.
+            folders: The folders to get the counts for.
+            subscriptions: The subscriptions to get the counts for.
         """
+        if self.on_new_unread:
+            self.on_new_unread(get_local_unread(folders, subscriptions))
+
+    async def sync(self) -> None:
+        """Sync the data from TheOldReader."""
         folders = await self._get_folders()
         original_subscriptions, subscriptions = await self._get_subscriptions()
         await self._get_new_articles()

oldnews-0.8.0/src/oldnews/widgets/_next_matching_option.py

@@ -0,0 +1,52 @@
+"""Support code for OptionLists that want to find things."""
+
+##############################################################################
+# Python imports.
+from typing import Callable
+
+##############################################################################
+# BagOfStuff imports.
+from bagofstuff.itertools import Direction, starting_at
+
+
+##############################################################################
+def next_matching_option[T](
+    options: list[T],
+    current_highlight: int | None,
+    direction: Direction,
+    matching: Callable[[T], bool] | None = None,
+) -> T | None:
+    """Return a list of `OptionList` options after the highlight.
+
+    Args:
+        options: The options from the given option list.
+        current_highlight: The current highlighted option.
+        direction: The direction to work in.
+        matching: Optional filter to apply to the list.
+
+    Returns:
+        The next matching option, or `None` if there isn't one.
+
+    Notes:
+        If there is no highlight, we default at position 0.
+    """
+    matching = matching or (lambda _: True)
+    if current_highlight is None:
+        current_highlight = 0
+    else:
+        current_highlight += 1 if direction == "forward" else -1
+    return next(
+        (
+            option
+            for option in starting_at(options, current_highlight, direction)
+            if matching(option)
+        ),
+        None,
+    )
+
+
+##############################################################################
+# Re-export the direction type.
+__all__ = ["Direction"]
+
+### _next_matching_option.py ends here

{oldnews-0.6.0 → oldnews-0.8.0}/src/oldnews/widgets/article_list.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 ##############################################################################
 # Python imports.
 from dataclasses import dataclass
+from operator import attrgetter
 from typing import cast
 
 ##############################################################################
@@ -32,7 +33,7 @@ from textual_enhanced.widgets import EnhancedOptionList
 
 ##############################################################################
 # Local imports.
-from ._after_highlight import HighlightDirection, options_after_highlight
+from ._next_matching_option import Direction, next_matching_option
 
 
 ##############################################################################
@@ -142,7 +143,7 @@ class ArticleList(EnhancedOptionList):
         assert isinstance(message.option, ArticleView)
         self.post_message(self.ViewArticle(message.option.article))
 
-    def _highlight_unread(self, direction: HighlightDirection) -> bool:
+    def _highlight_unread(self, direction: Direction) -> bool:
         """Highlight the next unread article, if there is one.
 
         Args:
@@ -152,14 +153,11 @@ class ArticleList(EnhancedOptionList):
             `True` if an unread article was found and highlighted, `False`
             if not.
         """
-        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 := next_matching_option(
+            cast(list[ArticleView], self.options),
+            self.highlighted,
+            direction,
+            attrgetter("article.is_unread"),
         ):
             if next_hit.id is not None:
                 self.highlighted = self.get_option_index(next_hit.id)
@@ -177,11 +175,11 @@ class ArticleList(EnhancedOptionList):
 
     def highlight_next_unread_article(self) -> None:
         """Highlight the next unread article in the list."""
-        self._highlight_unread("next")
+        self._highlight_unread("forward")
 
     def highlight_previous_unread_article(self) -> None:
         """Highlight the previous unread article in the list."""
-        self._highlight_unread("previous")
+        self._highlight_unread("backward")
 
     def select_next_article(self) -> None:
         """Select the next article in the list."""
@@ -195,12 +193,12 @@ class ArticleList(EnhancedOptionList):
 
     def select_next_unread_article(self) -> None:
         """Select the next unread article in the list."""
-        if self._highlight_unread("next"):
+        if self._highlight_unread("forward"):
             self.call_later(self.run_action, "select")
 
     def select_previous_unread_article(self) -> None:
         """Select the next unread article in the list."""
-        if self._highlight_unread("previous"):
+        if self._highlight_unread("backward"):
             self.call_later(self.run_action, "select")
 
 

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

@@ -7,7 +7,7 @@ from __future__ import annotations
 ##############################################################################
 # Python imports.
 from dataclasses import dataclass
-from typing import cast
+from typing import Callable, Iterable, Iterator, cast
 
 ##############################################################################
 # OldAs imports.
@@ -35,7 +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
+from ._next_matching_option import Direction, next_matching_option
 
 
 ##############################################################################
@@ -157,41 +157,86 @@ class Navigation(EnhancedOptionList):
         self._expanded = get_navigation_state()
         """The IDs of the folders that are expanded."""
 
-    def _add_subscriptions(self, parent_folder: str) -> None:
-        """Add the subscriptions for a given parent folder.
+    @staticmethod
+    def _key(attr: str) -> Callable[[object], str]:
+        """Create a key to use with `sorted`.
 
         Args:
-            parent_folder: The parent folder to add the subscriptions for.
+            attr: The attribute to sort on.
+
+        Returns:
+            A function to get a `casefold` version of the attribute.
         """
-        for subscription in self.subscriptions:
-            if any(
-                category.id == parent_folder for category in subscription.categories
-            ):
-                self.add_option(SubscriptionView(subscription, self.unread))
 
-    def _add_folder(self, folder: Folder) -> None:
-        """Add the given folder to the navigation.
+        def _casefold(value: object) -> str:
+            return cast(str, getattr(value, attr)).casefold()
+
+        return _casefold
+
+    def _viewable(
+        self, subscriptions: Iterable[Subscription]
+    ) -> Iterator[SubscriptionView]:
+        """Given a iterable of subscriptions, make them viewable.
 
         Args:
-            folder: The folder to add.
+            subscriptions: The subscriptions to make viewable.
+
+        Yields:
+            Views of the subscriptions.
         """
-        self.add_option(
-            FolderView(folder, expanded := folder.id in self._expanded, self.unread)
+        yield from (
+            SubscriptionView(subscription, self.unread)
+            for subscription in sorted(subscriptions, key=self._key("title"))
+        )
+
+    def _gather_subscriptions_for_folder(
+        self, parent_folder: Folder
+    ) -> Iterator[SubscriptionView]:
+        """Gather the subscriptions for a given parent folder.
+
+        Args:
+            parent_folder: The parent folder to add the subscriptions for.
+
+        Yields:
+            The subscriptions within that folder.
+        """
+        yield from self._viewable(
+            subscription
+            for subscription in self.subscriptions
+            if parent_folder in subscription.categories
+        )
+
+    def _gather_folders(self) -> Iterator[FolderView | SubscriptionView]:
+        """Gather up all the folders and their subscriptions.
+
+        Yields:
+            Folder and subscription options.
+        """
+        for folder in sorted(self.folders, key=self._key("name")):
+            yield FolderView(
+                folder, expanded := folder.id in self._expanded, self.unread
+            )
+            if expanded:
+                yield from self._gather_subscriptions_for_folder(folder)
+
+    def _gather_folderless_subscrtiptions(self) -> Iterator[SubscriptionView]:
+        """Gather up all the subscriptions that don't live in a folder.
+
+        Yields:
+            Subscription options for folderless subscriptions.
+        """
+        yield from self._viewable(
+            subscription
+            for subscription in self.subscriptions
+            if not subscription.categories
         )
-        if expanded:
-            self._add_subscriptions(folder.id)
 
     def _refresh_navigation(self) -> None:
         """Refresh the content of the navigation widget."""
         with self.preserved_highlight:
-            self.clear_options()
-            # First off, add subscriptions that lack a folder.
-            for subscription in self.subscriptions:
-                if not subscription.categories:
-                    self.add_option(SubscriptionView(subscription, self.unread))
-            # Now add all the subscriptions that are within folders.
-            for folder in self.folders:
-                self._add_folder(folder)
+            self.set_options(
+                (*self._gather_folderless_subscrtiptions(), *self._gather_folders())
+            )
 
     def _watch_folders(self) -> None:
         """React to the folders being updated."""
@@ -205,6 +250,25 @@ class Navigation(EnhancedOptionList):
         """React to the unread data being updated."""
         self._refresh_navigation()
 
+    @work(thread=True)
+    def _save_state(self, state: set[str]) -> None:
+        """Save the folder expanded/collapsed state.
+
+        Args:
+            state: The state to save.
+        """
+        save_navigation_state(state)
+
+    def _set_expansion(self, new_state: set[str]) -> None:
+        """Set the new navigation state.
+
+        Args:
+            new_state: The new state to set.
+        """
+        self._expanded = new_state
+        self._save_state(new_state)
+        self._refresh_navigation()
+
     def _action_toggle_folder(self) -> None:
         """Action that toggles the expanded state of a folder."""
         if self.highlighted is None:
@@ -215,26 +279,15 @@ class Navigation(EnhancedOptionList):
             self.notify("Only folders can be collapsed/expanded", severity="warning")
             return
         if option.folder.id is not None:
-            self._expanded ^= {option.folder.id}
-            self._save_state()
-            self._refresh_navigation()
+            self._set_expansion(self._expanded ^ {option.folder.id})
 
     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()
+        self._set_expansion({folder.id for folder in self.folders})
 
     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."""
-        save_navigation_state(self._expanded)
+        self._set_expansion(set())
 
     @on(EnhancedOptionList.OptionSelected)
     def _handle_selection(self, message: EnhancedOptionList.OptionSelected) -> None:
@@ -275,7 +328,18 @@ class Navigation(EnhancedOptionList):
             return current
         return None
 
-    def _highlight_unread(self, direction: HighlightDirection) -> bool:
+    def _contains_unread(self, category: FolderView | SubscriptionView) -> bool:
+        """Does the given folder or subscription have unread items?
+
+        Args:
+            category: The folder or subscription to check.
+
+        Returns:
+            `True` if there are unread items, `False` if not.
+        """
+        return bool(category.id and self.unread.get(category.id))
+
+    def _highlight_unread(self, direction: Direction) -> bool:
         """Highlight the next category with unread articles, if there is one.
 
         Args:
@@ -285,14 +349,11 @@ class Navigation(EnhancedOptionList):
             `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 := next_matching_option(
+            cast(list[FolderView | SubscriptionView], self.options),
+            self.highlighted,
+            direction,
+            self._contains_unread,
         ):
             if next_hit.id is not None:
                 self.highlighted = self.get_option_index(next_hit.id)
@@ -302,11 +363,11 @@ class Navigation(EnhancedOptionList):
 
     def highlight_next_unread_category(self) -> None:
         """Highlight the next unread category."""
-        self._highlight_unread("next")
+        self._highlight_unread("forward")
 
     def highlight_previous_unread_category(self) -> None:
         """Highlight the previous unread category."""
-        self._highlight_unread("previous")
+        self._highlight_unread("backward")
 
 
 ### navigation.py ends here

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

@@ -1,53 +0,0 @@
-"""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