Make ParseResult and ParsedFeed generic on feed/entry type.

(In preparation for generic update pipeline base.)

Author: lemon24

src/reader/_parser/__init__.py

@@ -14,7 +14,6 @@
 from typing import ContextManager
 from typing import Generic
 from typing import NamedTuple
-from typing import Optional
 from typing import Protocol
 from typing import runtime_checkable
 from typing import TYPE_CHECKING
@@ -388,7 +387,11 @@ def process_feed_for_update(self, feed: FeedForUpdate) -> FeedForUpdate:
         """
 
 
-class ParseResult(NamedTuple, Generic[F, E]):
+FD = TypeVar('FD')
+ED = TypeVar('ED')
+
+
+class ParseResultBase(NamedTuple, Generic[F, FD, ED, E]):
     """The result of retrieving and parsing a feed, regardless of the outcome."""
 
     #: The feed (a :class:`FeedArgument`, usually a :class:`.FeedForUpdate`).
@@ -400,19 +403,19 @@ class ParseResult(NamedTuple, Generic[F, E]):
     #: * :const:`None`, if the feed didn't change
     #: * an exception
     #:
-    value: ParsedFeed | None | E
+    value: ParsedFeedBase[FD, ED] | None | E
 
     #: Details about the HTTP response.
     http_info: HTTPInfo | None = None
 
 
-class ParsedFeed(NamedTuple):
+class ParsedFeedBase(NamedTuple, Generic[FD, ED]):
     """A parsed feed."""
 
-    #: The feed.
-    feed: FeedData
-    #: The entries.
-    entries: Collection[EntryData]
+    #: The feed; usually :class:`FeedData`.
+    feed: FD
+    #: The entries; usually :class:`EntryData`.
+    entries: Collection[ED]
     #: The MIME type of the feed resource.
     #: Used by :meth:`~reader._parser.Parser.process_entry_pairs`
     #: to select an appropriate parser.
@@ -422,8 +425,16 @@ class ParsedFeed(NamedTuple):
     caching_info: JSONType | None = None
 
 
+class EntryPairBase(NamedTuple, Generic[ED]):
+    new: ED
+    old: EntryForUpdate | None
+
+
+ParseResult = ParseResultBase[FeedForUpdate, FeedData, EntryData, ParseError]
+ParsedFeed = ParsedFeedBase[FeedData, EntryData]
+EntryPair = EntryPairBase[EntryData]
+
 FeedAndEntries = tuple[FeedData, Collection[EntryData]]
-EntryPair = tuple[EntryData, Optional[EntryForUpdate]]
 
 
 class ParserType(Protocol[T_cv]):  # pragma: no cover

src/reader/_parser/_lazy.py

@@ -12,6 +12,8 @@
 from typing import cast
 from typing import ContextManager
 
+from .._types import EntryData
+from .._types import FeedData
 from .._types import FeedForUpdate
 from .._utils import MapFunction
 from ..exceptions import InvalidFeedURLError
@@ -25,6 +27,7 @@
 from . import NotModified
 from . import ParsedFeed
 from . import ParseResult
+from . import ParseResultBase
 from . import ParserType
 from . import RetrievedFeed
 from . import RetrieveError
@@ -86,7 +89,7 @@ def parallel(
         self,
         feeds: Iterable[F],
         map: MapFunction[Any, Any] = map,
-    ) -> Iterable[ParseResult[F, ParseError]]:
+    ) -> Iterable[ParseResult]:
         """Retrieve and parse many feeds, possibly in parallel.
 
         Yields the parsed feeds, as soon as they are ready.
@@ -130,7 +133,7 @@ def parallel(
                         value.__cause__ = e.__cause__
                         result = result._replace(value=value)
 
-                yield cast(ParseResult[F, ParseError], result)
+                yield cast(ParseResult, result)
 
     def __call__(
         self, url: str, caching_info: JSONType | None = None
@@ -252,7 +255,7 @@ def _retrieve(
 
     def parse_fn(
         self, result: RetrieveResult[F, Any, Exception]
-    ) -> ParseResult[F, Exception]:
+    ) -> ParseResultBase[F, FeedData, EntryData, Exception]:
         """:meth:`parse` wrapper used by :meth:`parallel`.
 
         Takes one argument and does not raise exceptions.
@@ -292,7 +295,7 @@ def parse_fn(
             log.debug("parse_fn(): got unexpected error: %s: %s", type(e).__name__, e)
             value = e
 
-        return ParseResult(feed, value, http_info)
+        return ParseResultBase(feed, value, http_info)
 
     def parse(self, url: str, retrieved: RetrievedFeed[Any]) -> ParsedFeed:
         """Parse a retrieved feed.

src/reader/_update.py

@@ -12,9 +12,9 @@
 from itertools import tee
 from typing import Any
 from typing import NamedTuple
-from typing import Optional
 from typing import TYPE_CHECKING
 
+from ._parser import EntryPair
 from ._parser import ParseResult
 from ._types import EntryData
 from ._types import EntryForUpdate
@@ -46,9 +46,6 @@
 HASH_CHANGED_LIMIT = 24
 
 
-EntryPairs = Iterable[tuple[EntryData, Optional[EntryForUpdate]]]
-
-
 @dataclass(frozen=True)
 class Decider:
     """Decide whether a feed or entry should be updated.
@@ -89,8 +86,8 @@ def make_intents(
         now: datetime,
         global_now: datetime,
         config: UpdateConfig,
-        result: ParseResult[FeedForUpdate, ParseError],
-        entry_pairs: EntryPairs,
+        result: ParseResult,
+        entry_pairs: Iterable[EntryPair],
     ) -> tuple[FeedUpdateIntent, Iterable[EntryUpdateIntent]]:
         decider = cls(
             old_feed,
@@ -194,7 +191,9 @@ def debug(msg: str, *args: Any) -> None:
         debug("entry not updated, skipping")
         return None
 
-    def get_entries_to_update(self, pairs: EntryPairs) -> Iterable[EntryUpdateIntent]:
+    def get_entries_to_update(
+        self, pairs: Iterable[EntryPair]
+    ) -> Iterable[EntryUpdateIntent]:
         for feed_order, (new, old) in reversed(list(enumerate(pairs))):
             # This may fail if we ever implement changing the feed URL
             # in response to a permanent redirect.
@@ -235,8 +234,8 @@ def get_feed_to_update(
 
     def update(
         self,
-        result: ParseResult[FeedForUpdate, ParseError],
-        entry_pairs: EntryPairs,
+        result: ParseResult,
+        entry_pairs: Iterable[EntryPair],
     ) -> tuple[FeedUpdateIntent, Iterable[EntryUpdateIntent]]:
 
         # TODO: move entries_to_update in FeedToUpdate, maybe?
@@ -394,7 +393,7 @@ def update(self, filter: FeedFilter) -> Iterable[UpdateResult]:
         # Storing the exceptions until the end of the generator
         # might cause memory issues, but the caller may need to raise them.
         # TODO: Rework update pipeline to support process_feed_for_update() exceptions.
-        parser_process_feeds_for_update_errors = []
+        parser_process_feeds_for_update_errors: list[ParseResult] = []
 
         def parser_process_feeds_for_update(
             feeds: Iterable[FeedForUpdate],
@@ -428,7 +427,7 @@ def parser_process_feeds_for_update(
     def process_parse_result(
         self,
         config: UpdateConfig,
-        result: ParseResult[FeedForUpdate, ParseError],
+        result: ParseResult,
     ) -> tuple[str, UpdatedFeed | None | Exception]:
         feed, value, _ = result
 
@@ -470,13 +469,13 @@ def process_parse_result(
 
         return feed.url, UpdatedFeed(feed.url, *counts, total - sum(counts))
 
-    def get_entry_pairs(self, result: ParsedFeed) -> EntryPairs:
+    def get_entry_pairs(self, result: ParsedFeed) -> Iterable[EntryPair]:
         # give storage a chance to consume entries in a streaming fashion
         entries1, entries2 = tee(result.entries)
         entries_for_update = self.reader._storage.get_entries_for_update(
             (e.feed_url, e.id) for e in entries1
         )
-        return zip(entries2, entries_for_update, strict=True)
+        return map(EntryPair._make, zip(entries2, entries_for_update, strict=True))
 
     def update_feed(
         self,