oldnews 0.2.0__tar.gz → 0.3.0__tar.gz

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: oldnews
-Version: 0.2.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

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

@@ -1,6 +1,6 @@
 [project]
 name = "oldnews"
-version = "0.2.0"
+version = "0.3.0"
 description = "A terminal-based client for TheOldReader"
 readme = "README.md"
 authors = [
@@ -27,7 +27,7 @@ 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",

{oldnews-0.2.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.2.0 → oldnews-0.3.0}/src/oldnews/data/__init__.py

@@ -23,6 +23,7 @@ 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.
@@ -43,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.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.2.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,
@@ -57,19 +56,15 @@ from ..data import (
     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
 
 
@@ -198,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__()
@@ -298,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."""
@@ -311,6 +314,7 @@ class Main(EnhancedScreen[None]):
             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
@@ -319,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:
@@ -418,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()

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.2.0 → oldnews-0.3.0}/src/oldnews/widgets/article_content.py

@@ -17,7 +17,7 @@ from oldas import Article
 from textual.app import ComposeResult
 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,6 +32,10 @@ class ArticleContent(Vertical):
             display: block;
         }
 
+        Rule.-horizontal {
+            margin: 0;
+        }
+
         #header {
             height: auto;
             padding: 0 1 0 1;
@@ -49,6 +53,15 @@ class ArticleContent(Vertical):
             }
         }
 
+        &:focus-within {
+            #header, Rule {
+                background: $boost;
+            }
+            Rule {
+                color: $border;
+            }
+        }
+
         Markdown {
             padding: 0 1 0 1;
         }
@@ -67,11 +80,13 @@ class ArticleContent(Vertical):
 
     def compose(self) -> ComposeResult:
         """Compose the content of the widget."""
+        yield Rule()
         with Vertical(id="header"):
             with Horizontal():
                 yield Label(id="title", markup=False)
                 yield Label(id="published")
             yield Label(id="link", markup=False)
+        yield Rule()
         with VerticalScroll():
             yield Markdown()
 
@@ -87,7 +102,7 @@ class ArticleContent(Vertical):
                 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()
+            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: