tbr-deal-finder 0.1.7__py3-none-any.whl → 0.2.0__py3-none-any.whl

tbr_deal_finder/retailer/kindle.py

@@ -0,0 +1,141 @@
+import asyncio
+import readline  # type: ignore
+
+from tbr_deal_finder.config import Config
+from tbr_deal_finder.retailer.amazon import Amazon
+from tbr_deal_finder.book import Book, BookFormat, get_normalized_title, get_normalized_authors, is_matching_authors
+
+
+class Kindle(Amazon):
+
+    @property
+    def name(self) -> str:
+        return "Kindle"
+
+    @property
+    def format(self) -> BookFormat:
+        return BookFormat.EBOOK
+
+    def _get_base_url(self) -> str:
+        return f"https://www.amazon.{self._auth.locale.domain}"
+
+    async def get_book_asin(
+        self,
+        target: Book,
+        semaphore: asyncio.Semaphore
+    ) -> Book:
+        title = target.title
+        async with semaphore:
+            match = await self._client.get(
+                f"{self._get_base_url()}/kindle-dbs/kws?userCode=AndroidKin&deviceType=A3VNNDO1I14V03&node=2671536011&excludedNodes=&page=1&size=20&autoSpellCheck=1&rank=r",
+                query=title,
+            )
+
+            for product in match.get("items", []):
+                normalized_authors = get_normalized_authors(product["authors"])
+                if (
+                    get_normalized_title(product["title"]) != title
+                    or not is_matching_authors(target.normalized_authors, normalized_authors)
+                ):
+                    continue
+                try:
+                    target.ebook_asin = product["asin"]
+                    break
+                except KeyError:
+                    continue
+
+            return target
+
+    async def get_book(
+        self,
+        target: Book,
+        semaphore: asyncio.Semaphore
+    ) -> Book:
+        target.exists = False
+
+        if not target.ebook_asin:
+            return target
+
+        asin = target.ebook_asin
+        async with semaphore:
+            match = await self._client.get(
+                f"{self._get_base_url()}/api/bifrost/offers/batch/v1/{asin}?ref_=KindleDeepLinkOffers",
+                headers={"x-client-id": "kindle-android-deeplink"},
+            )
+            products = match.get("resources", [])
+            if not products:
+                return target
+
+            actions = products[0].get("personalizedActionOutput", {}).get("personalizedActions", [])
+            if not actions:
+                return target
+
+            for action in actions:
+                if "printListPrice" in action["offer"]:
+                    target.list_price = action["offer"]["printListPrice"]["value"]
+                    target.current_price = action["offer"]["digitalPrice"]["value"]
+                    target.exists = True
+                    break
+
+            return target
+
+    async def get_wishlist(self, config: Config) -> list[Book]:
+        """Not currently supported
+
+        Getting this info is proving to be a nightmare
+
+        :param config:
+        :return:
+        """
+        return []
+
+    async def get_library(self, config: Config) -> list[Book]:
+        """Not currently supported
+
+        Getting this info is proving to be a nightmare
+
+        :param config:
+        :return:
+        """
+        return []
+
+    async def _get_library_attempt(self, config: Config) -> list[Book]:
+        """This should work, but it's returning a redirect
+
+        The user is already authenticated at this point, so I'm not sure what's happening
+        """
+        response = []
+        pagination_token = 0
+        total_pages = 1
+
+        while pagination_token < total_pages:
+            optional_params = {}
+            if pagination_token:
+                optional_params["paginationToken"] = pagination_token
+
+            response = await self._client.get(
+                "https://read.amazon.com/kindle-library/search",
+                query="",
+                libraryType="BOOKS",
+                sortType="recency",
+                resourceType="EBOOK",
+                querySize=5,
+                **optional_params
+            )
+
+            if "paginationToken" in response:
+                total_pages = int(response["paginationToken"])
+
+            for book in response["itemsList"]:
+                response.append(
+                    Book(
+                        retailer=self.name,
+                        title = book["title"],
+                        authors = book["authors"][0],
+                        format=self.format,
+                        timepoint=config.run_time,
+                        ebook_asin=book["asin"],
+                    )
+                )
+
+        return response

tbr_deal_finder/retailer/librofm.py

@@ -4,17 +4,16 @@ import os
 import urllib.parse
 from datetime import datetime, timedelta
 
-import aiohttp
 import click
 
 from tbr_deal_finder import TBR_DEALS_PATH
 from tbr_deal_finder.config import Config
-from tbr_deal_finder.retailer.models import Retailer
-from tbr_deal_finder.book import Book, BookFormat, get_normalized_authors, is_matching_authors
+from tbr_deal_finder.retailer.models import AioHttpSession, Retailer
+from tbr_deal_finder.book import Book, BookFormat, get_normalized_authors, is_matching_authors, get_normalized_title
 from tbr_deal_finder.utils import currency_to_float
 
 
-class LibroFM(Retailer):
+class LibroFM(AioHttpSession, Retailer):
     BASE_URL = "https://libro.fm"
     USER_AGENT = "okhttp/3.14.9"
     USER_AGENT_DOWNLOAD = (
@@ -27,6 +26,8 @@ class LibroFM(Retailer):
     )
 
     def __init__(self):
+        super().__init__()
+
         self.auth_token = None
 
     @property
@@ -44,17 +45,17 @@ class LibroFM(Retailer):
         if self.auth_token:
             headers["authorization"] = f"Bearer {self.auth_token}"
 
-        async with aiohttp.ClientSession() as http_client:
-            response = await http_client.request(
-                request_type.upper(),
-                url,
-                headers=headers,
-                **kwargs
-            )
-            if response.ok:
-                return await response.json()
-            else:
-                return {}
+        session = await self._get_session()
+        response = await session.request(
+            request_type.upper(),
+            url,
+            headers=headers,
+            **kwargs
+        )
+        if response.ok:
+            return await response.json()
+        else:
+            return {}
 
     async def set_auth(self):
         auth_path = TBR_DEALS_PATH.joinpath("libro_fm.json")
@@ -76,11 +77,11 @@ class LibroFM(Retailer):
                 "password": click.prompt("Libro FM Password", hide_input=True),
             }
         )
-        self.auth_token = response
+        self.auth_token = response["access_token"]
         with open(auth_path, "w") as f:
             json.dump(response, f)
 
-    async def get_book_isbn(self, book: Book, runtime: datetime, semaphore: asyncio.Semaphore) -> Book:
+    async def get_book_isbn(self, book: Book, semaphore: asyncio.Semaphore) -> Book:
         # runtime isn't used but get_book_isbn must follow the get_book method signature.
 
         title = book.title
@@ -100,7 +101,7 @@ class LibroFM(Retailer):
             normalized_authors = get_normalized_authors(b["authors"])
 
             if (
-                title == b["title"]
+                title == get_normalized_title(b["title"])
                 and is_matching_authors(book.normalized_authors, normalized_authors)
             ):
                 book.audiobook_isbn = b["isbn"]
@@ -109,24 +110,11 @@ class LibroFM(Retailer):
         return book
 
     async def get_book(
-        self, target: Book, runtime: datetime, semaphore: asyncio.Semaphore
+        self, target: Book, semaphore: asyncio.Semaphore
     ) -> Book:
-        if target.format == BookFormat.AUDIOBOOK and not target.audiobook_isbn:
-            # When "format" is AUDIOBOOK here that means the target was pulled from an audiobook retailer wishlist
-            # In this flow, there is no attempt to resolve the isbn ahead of time, so it's done here instead.
-            await self.get_book_isbn(target, runtime, semaphore)
-
         if not target.audiobook_isbn:
-            return Book(
-                retailer=self.name,
-                title=target.title,
-                authors=target.authors,
-                list_price=0,
-                current_price=0,
-                timepoint=runtime,
-                format=BookFormat.AUDIOBOOK,
-                exists=False,
-            )
+            target.exists = False
+            return target
 
         async with semaphore:
             response = await self.make_request(
@@ -135,26 +123,12 @@ class LibroFM(Retailer):
             )
 
         if response:
-            return Book(
-                retailer=self.name,
-                title=target.title,
-                authors=target.authors,
-                list_price=target.audiobook_list_price,
-                current_price=currency_to_float(response["data"]["purchase_info"]["price"]),
-                timepoint=runtime,
-                format=BookFormat.AUDIOBOOK,
-            )
+            target.list_price = target.audiobook_list_price
+            target.current_price = currency_to_float(response["data"]["purchase_info"]["price"])
+            return target
 
-        return Book(
-            retailer=self.name,
-            title=target.title,
-            authors=target.authors,
-            list_price=0,
-            current_price=0,
-            timepoint=runtime,
-            format=BookFormat.AUDIOBOOK,
-            exists=False,
-        )
+        target.exists = False
+        return target
 
     async def get_wishlist(self, config: Config) -> list[Book]:
         wishlist_books = []

tbr_deal_finder/retailer/models.py

@@ -1,6 +1,7 @@
 import abc
 import asyncio
-from datetime import datetime
+
+import aiohttp
 
 from tbr_deal_finder.book import Book, BookFormat
 from tbr_deal_finder.config import Config
@@ -29,7 +30,7 @@ class Retailer(abc.ABC):
         raise NotImplementedError
 
     async def get_book(
-            self, target: Book, runtime: datetime, semaphore: asyncio.Semaphore
+            self, target: Book, semaphore: asyncio.Semaphore
     ) -> Book:
         """Get book information from the retailer.
 
@@ -53,3 +54,37 @@ class Retailer(abc.ABC):
     async def get_library(self, config: Config) -> list[Book]:
         raise NotImplementedError
 
+
+class AioHttpSession:
+
+    def __init__(self):
+        self._session = None
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        """Get or create the session."""
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession()
+        return self._session
+
+    async def close(self):
+        """Close the session when done."""
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+    async def __aenter__(self):
+        """Support async context manager."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Cleanup on context manager exit."""
+        await self.close()
+
+    def __del__(self):
+        """Attempt to close session on garbage collection."""
+        if self._session and not self._session.closed:
+            try:
+                asyncio.create_task(self._session.close())
+            except RuntimeError:
+                # Event loop might be closed
+                pass
+

tbr_deal_finder/retailer_deal.py

@@ -8,7 +8,6 @@ from tqdm.asyncio import tqdm_asyncio
 
 from tbr_deal_finder.book import Book, get_active_deals, BookFormat
 from tbr_deal_finder.config import Config
-from tbr_deal_finder.owned_books import get_owned_books
 from tbr_deal_finder.tracked_books import get_tbr_books
 from tbr_deal_finder.retailer import RETAILER_MAP
 from tbr_deal_finder.retailer.models import Retailer
@@ -22,9 +21,9 @@ def update_retailer_deal_table(config: Config, new_deals: list[Book]):
     :param new_deals:
     """
 
-    # This could be done using a temp table for the new deals, but that feels like overkill
-    # I can't imagine there's ever going to be more than 5,000 books in someone's TBR
-    # If it were any larger we'd have bigger problems.
+    # This could be done using a temp table for the new deals, but that feels like overkill.
+    # I can't imagine there's ever going to be more than 5,000 books in someone's TBR.
+    # If it were any larger, we'd have bigger problems.
     active_deal_map = {deal.deal_id: deal for deal in get_active_deals()}
     # Dirty trick to ensure uniqueness in request
     new_deals = list({nd.deal_id: nd for nd in new_deals}.values())
@@ -74,9 +73,13 @@ async def _get_books(config, retailer: Retailer, books: list[Book]) -> list[Book
     semaphore = asyncio.Semaphore(10)
     response = []
     unresolved_books = []
+    books = [copy.deepcopy(book) for book in books]
+    for book in books:
+        book.retailer = retailer.name
+        book.format = retailer.format
 
     tasks = [
-        retailer.get_book(copy.deepcopy(book), config.run_time, semaphore)
+        retailer.get_book(book, semaphore)
         for book in books
     ]
     results = await tqdm_asyncio.gather(*tasks, desc=f"Getting latest prices from {retailer.name}")
@@ -130,26 +133,19 @@ def _apply_proper_list_prices(books: list[Book]):
 def _get_retailer_relevant_tbr_books(
     retailer: Retailer,
     books: list[Book],
-    owned_book_title_map: dict[str, dict[BookFormat, Book]],
 ) -> list[Book]:
     """
     Don't check on deals in a specified format that does not match the format the retailer sells.
-    Also, don't check on deals for a book if a copy is already owned in that same format.
 
     :param retailer:
     :param books:
-    :param owned_book_title_map:
     :return:
     """
 
     response = []
 
     for book in books:
-        owned_versions = owned_book_title_map[book.full_title_str]
-        if (
-            (book.format == BookFormat.NA or book.format == retailer.format)
-            and retailer.format not in owned_versions
-        ):
+        if book.format == BookFormat.NA or book.format == retailer.format:
             response.append(book)
 
     return response
@@ -174,11 +170,6 @@ async def get_latest_deals(config: Config):
 
     books: list[Book] = []
     tbr_books = await get_tbr_books(config)
-    owned_books = await get_owned_books(config)
-
-    owned_book_title_map: dict[str, dict[BookFormat, Book]] = defaultdict(dict)
-    for book in owned_books:
-        owned_book_title_map[book.full_title_str][book.format] = book
 
     for retailer_str in config.tracked_retailers:
         retailer = RETAILER_MAP[retailer_str]()
@@ -187,7 +178,6 @@ async def get_latest_deals(config: Config):
         relevant_tbr_books = _get_retailer_relevant_tbr_books(
             retailer,
             tbr_books,
-            owned_book_title_map,
         )
 
         echo_info(f"Getting deals from {retailer.name}")