tbr-deal-finder 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

tbr_deal_finder/retailer/chirp.py

@@ -2,6 +2,7 @@ import asyncio
 import json
 import os
 from datetime import datetime, timedelta
+from textwrap import dedent
 
 import aiohttp
 import click
@@ -9,7 +10,7 @@ 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
+from tbr_deal_finder.book import Book, BookFormat, get_normalized_authors, is_matching_authors
 from tbr_deal_finder.utils import currency_to_float, echo_err
 
 
@@ -83,10 +84,9 @@ class Chirp(Retailer):
             json.dump(response, f)
 
     async def get_book(
-        self, target: Book, runtime: datetime, semaphore: asyncio.Semaphore
+        self, target: Book, semaphore: asyncio.Semaphore
     ) -> Book:
         title = target.title
-        authors = target.authors
         async with semaphore:
             async with aiohttp.ClientSession() as http_client:
                 response = await http_client.request(
@@ -102,16 +102,8 @@ class Chirp(Retailer):
 
             audiobooks = response_body["data"]["audiobooks"]["objects"]
             if not audiobooks:
-                return Book(
-                    retailer=self.name,
-                    title=title,
-                    authors=authors,
-                    list_price=0,
-                    current_price=0,
-                    timepoint=runtime,
-                    format=BookFormat.AUDIOBOOK,
-                    exists=False,
-                )
+                target.exists = False
+                return target
 
             for book in audiobooks:
                 if not book["currentProduct"]:
@@ -120,28 +112,14 @@ class Chirp(Retailer):
                 normalized_authors = get_normalized_authors([author["name"] for author in book["allAuthors"]])
                 if (
                     book["displayTitle"] == title
-                    and any(author in normalized_authors for author in target.normalized_authors)
+                    and is_matching_authors(target.normalized_authors, normalized_authors)
                 ):
-                    return Book(
-                        retailer=self.name,
-                        title=title,
-                        authors=authors,
-                        list_price=currency_to_float(book["currentProduct"]["listingPrice"]),
-                        current_price=currency_to_float(book["currentProduct"]["discountPrice"]),
-                        timepoint=runtime,
-                        format=BookFormat.AUDIOBOOK,
-                    )
+                    target.list_price = currency_to_float(book["currentProduct"]["listingPrice"])
+                    target.current_price = currency_to_float(book["currentProduct"]["discountPrice"])
+                    return target
 
-            return Book(
-                retailer=self.name,
-                title=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 = []
@@ -180,3 +158,61 @@ class Chirp(Retailer):
                 )
 
             page += 1
+
+    async def get_library(self, config: Config) -> list[Book]:
+        library_books = []
+        page = 1
+        query = dedent("""
+            query AndroidCurrentUserAudiobooks($page: Int!, $pageSize: Int!) {
+                currentUserAudiobooks(page: $page, pageSize: $pageSize, sort: TITLE_A_Z, clientCapabilities: [CHIRP_AUDIO]) {
+                    audiobook {
+                        id
+                        allAuthors{name}
+                        displayTitle
+                        displayAuthors
+                        displayNarrators
+                        durationMs
+                        description
+                        publisher
+                    }
+                    archived
+                    playable
+                    finishedAt
+                    currentOverallOffsetMs
+                }
+            }
+        """)
+
+        while True:
+            response = await self.make_request(
+                "POST",
+                json={
+                    "query": query,
+                    "variables": {"page": page, "pageSize": 15},
+                    "operationName": "AndroidCurrentUserAudiobooks"
+                }
+            )
+
+            audiobooks = response.get(
+                "data", {}
+            ).get("currentUserAudiobooks", [])
+
+            if not audiobooks:
+                return library_books
+
+            for book in audiobooks:
+                audiobook = book["audiobook"]
+                authors = [author["name"] for author in audiobook["allAuthors"]]
+                library_books.append(
+                    Book(
+                        retailer=self.name,
+                        title=audiobook["displayTitle"],
+                        authors=", ".join(authors),
+                        list_price=1,
+                        current_price=1,
+                        timepoint=config.run_time,
+                        format=self.format,
+                    )
+                )
+
+            page += 1

tbr_deal_finder/retailer/librofm.py

@@ -10,7 +10,7 @@ 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
+from tbr_deal_finder.book import Book, BookFormat, get_normalized_authors, is_matching_authors
 from tbr_deal_finder.utils import currency_to_float
 
 
@@ -76,11 +76,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
@@ -101,7 +101,7 @@ class LibroFM(Retailer):
 
             if (
                 title == b["title"]
-                and any(author in normalized_authors for author in book.normalized_authors)
+                and is_matching_authors(book.normalized_authors, normalized_authors)
             ):
                 book.audiobook_isbn = b["isbn"]
                 break
@@ -109,24 +109,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 +122,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 = []
@@ -165,7 +138,7 @@ class LibroFM(Retailer):
             response = await self.make_request(
                 f"api/v10/explore/wishlist",
                 "GET",
-                params=dict(page=2)
+                params=dict(page=page)
             )
             wishlist = response.get("data", {}).get("wishlist", {})
             if not wishlist:
@@ -189,3 +162,34 @@ class LibroFM(Retailer):
             total_pages = wishlist["total_pages"]
 
         return wishlist_books
+
+    async def get_library(self, config: Config) -> list[Book]:
+        library_books = []
+
+        page = 1
+        total_pages = 1
+        while page <= total_pages:
+            response = await self.make_request(
+                f"api/v10/library",
+                "GET",
+                params=dict(page=page)
+            )
+
+            for book in response.get("audiobooks", []):
+                library_books.append(
+                    Book(
+                        retailer=self.name,
+                        title=book["title"],
+                        authors=", ".join(book["authors"]),
+                        list_price=1,
+                        current_price=1,
+                        timepoint=config.run_time,
+                        format=self.format,
+                        audiobook_isbn=book["isbn"],
+                    )
+                )
+
+            page += 1
+            total_pages = response["total_pages"]
+
+        return library_books

tbr_deal_finder/retailer/models.py

@@ -1,6 +1,5 @@
 import abc
 import asyncio
-from datetime import datetime
 
 from tbr_deal_finder.book import Book, BookFormat
 from tbr_deal_finder.config import Config
@@ -29,7 +28,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.
 
@@ -50,4 +49,6 @@ class Retailer(abc.ABC):
     async def get_wishlist(self, config: Config) -> list[Book]:
         raise NotImplementedError
 
+    async def get_library(self, config: Config) -> list[Book]:
+        raise NotImplementedError
 

tbr_deal_finder/retailer_deal.py

@@ -21,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())
@@ -41,7 +41,7 @@ def update_retailer_deal_table(config: Config, new_deals: list[Book]):
     # Any remaining values in active_deal_map mean that
     # it wasn't found and should be marked for deletion
     for deal in active_deal_map.values():
-        echo_warning(f"{str(deal)} is no longer active")
+        echo_warning(f"{str(deal)} is no longer active\n")
         deal.timepoint = config.run_time
         deal.deleted = True
         df_data.append(deal.dict())
@@ -55,21 +55,6 @@ def update_retailer_deal_table(config: Config, new_deals: list[Book]):
         db_conn.unregister("_df")
 
 
-def _retry_books(found_books: list[Book], all_books: list[Book]) -> list[Book]:
-    response = []
-    found_book_set = {f'{b.title} - {b.authors}' for b in found_books}
-    for book in all_books:
-        if ":" not in book.title:
-            continue
-
-        if f'{book.title} - {book.authors}' not in found_book_set:
-            alt_book = copy.deepcopy(book)
-            alt_book.title = alt_book.title.split(":")[0]
-            response.append(alt_book)
-
-    return response
-
-
 async def _get_books(config, retailer: Retailer, books: list[Book]) -> list[Book]:
     """Get Books with limited concurrency.
 
@@ -88,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}")
@@ -100,13 +89,9 @@ async def _get_books(config, retailer: Retailer, books: list[Book]) -> list[Book
         elif not book.exists:
             unresolved_books.append(book)
 
-    if retry_books := _retry_books(response, books):
-        echo_info("Attempting to find missing books with alternate title")
-        response.extend(await _get_books(config, retailer, retry_books))
-    elif unresolved_books:
-        click.echo()
-        for book in unresolved_books:
-            echo_info(f"{book.title} by {book.authors} not found")
+    click.echo()
+    for book in unresolved_books:
+        echo_info(f"{book.title} by {book.authors} not found")
 
     return response
 
@@ -145,6 +130,27 @@ def _apply_proper_list_prices(books: list[Book]):
             book.list_price = max(book.current_price, list_price)
 
 
+def _get_retailer_relevant_tbr_books(
+    retailer: Retailer,
+    books: list[Book],
+) -> list[Book]:
+    """
+    Don't check on deals in a specified format that does not match the format the retailer sells.
+
+    :param retailer:
+    :param books:
+    :return:
+    """
+
+    response = []
+
+    for book in books:
+        if book.format == BookFormat.NA or book.format == retailer.format:
+            response.append(book)
+
+    return response
+
+
 async def get_latest_deals(config: Config):
     """
     Fetches the latest book deals from all tracked retailers for the user's TBR list.
@@ -169,13 +175,10 @@ async def get_latest_deals(config: Config):
         retailer = RETAILER_MAP[retailer_str]()
         await retailer.set_auth()
 
-        # Don't check on deals in a specified format
-        #   that does not match the format the retailer sells
-        relevant_tbr_books = [
-            book
-            for book in tbr_books
-            if book.format == BookFormat.NA or book.format == retailer.format
-        ]
+        relevant_tbr_books = _get_retailer_relevant_tbr_books(
+            retailer,
+            tbr_books,
+        )
 
         echo_info(f"Getting deals from {retailer.name}")
         click.echo("\n---------------")