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

tbr_deal_finder/retailer/chirp.py

@@ -1,21 +1,88 @@
 import asyncio
-from datetime import datetime
+import json
+import os
+from datetime import datetime, timedelta
+from textwrap import dedent
 
 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
-from tbr_deal_finder.utils import currency_to_float
+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
 
 
 class Chirp(Retailer):
     # Static because url for other locales just redirects to .com
-    _url: str = "https://www.chirpbooks.com/api/graphql"
+    _url: str = "https://api.chirpbooks.com/api/graphql"
+    USER_AGENT = "ChirpBooks/5.13.9 (Android)"
+
+    def __init__(self):
+        self.auth_token = None
 
     @property
     def name(self) -> str:
         return "Chirp"
 
+    @property
+    def format(self) -> BookFormat:
+        return BookFormat.AUDIOBOOK
+
+    async def make_request(self, request_type: str, **kwargs) -> dict:
+        headers = kwargs.pop("headers", {})
+        headers["Accept"] = "application/json"
+        headers["Content-Type"] = "application/json"
+        headers["User-Agent"] = self.USER_AGENT
+        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(),
+                self._url,
+                headers=headers,
+                **kwargs
+            )
+            if response.ok:
+                return await response.json()
+            else:
+                return {}
+
+    async def set_auth(self):
+        auth_path = TBR_DEALS_PATH.joinpath("chirp.json")
+        if os.path.exists(auth_path):
+            with open(auth_path, "r") as f:
+                auth_info = json.load(f)
+                if auth_info:
+                    token_created_at = datetime.fromtimestamp(auth_info["created_at"])
+                    max_token_age = datetime.now() - timedelta(days=5)
+                    if token_created_at > max_token_age:
+                        self.auth_token = auth_info["data"]["signIn"]["user"]["token"]
+                        return
+
+        response = await self.make_request(
+            "POST",
+            json={
+                "query": "mutation signIn($email: String!, $password: String!) { signIn(email: $email, password: $password) { user { id token webToken email } } }",
+                "variables": {
+                    "email": click.prompt("Chirp account email"),
+                    "password": click.prompt("Chirp Password", hide_input=True),
+                }
+            }
+        )
+        if not response:
+            echo_err("Chirp login failed, please try again.")
+            await self.set_auth()
+
+        # Set token for future requests during the current execution
+        self.auth_token = response["data"]["signIn"]["user"]["token"]
+
+        response["created_at"] = datetime.now().timestamp()
+        with open(auth_path, "w") as f:
+            json.dump(response, f)
+
     async def get_book(
         self, target: Book, runtime: datetime, semaphore: asyncio.Semaphore
     ) -> Book:
@@ -51,9 +118,10 @@ class Chirp(Retailer):
                 if not book["currentProduct"]:
                     continue
 
+                normalized_authors = get_normalized_authors([author["name"] for author in book["allAuthors"]])
                 if (
                     book["displayTitle"] == title
-                    and get_normalized_authors(book["displayAuthors"]) == target.normalized_authors
+                    and is_matching_authors(target.normalized_authors, normalized_authors)
                 ):
                     return Book(
                         retailer=self.name,
@@ -76,5 +144,98 @@ class Chirp(Retailer):
                 exists=False,
             )
 
-    async def set_auth(self):
-        return
+    async def get_wishlist(self, config: Config) -> list[Book]:
+        wishlist_books = []
+        page = 1
+
+        while True:
+            response = await self.make_request(
+                "POST",
+                json={
+                    "query": "fragment audiobookFields on Audiobook{id averageRating coverUrl displayAuthors displayTitle ratingsCount url allAuthors{name slug url}} fragment productFields on Product{discountPrice id isFreeListing listingPrice purchaseUrl savingsPercent showListingPrice timeLeft bannerType} query FetchWishlistDealAudiobooks($page:Int,$pageSize:Int){currentUserWishlist{paginatedItems(filter:\"currently_promoted\",sort:\"promotion_end_date\",salability:current_or_future){totalCount objects(page:$page,pageSize:$pageSize){... on WishlistItem{id audiobook{...audiobookFields currentProduct{...productFields}}}}}}}",
+                    "variables": {"page": page, "pageSize": 15},
+                    "operationName": "FetchWishlistDealAudiobooks"
+                }
+            )
+
+            audiobooks = response.get(
+                "data", {}
+            ).get("currentUserWishlist", {}).get("paginatedItems", {}).get("objects", [])
+
+            if not audiobooks:
+                return wishlist_books
+
+            for book in audiobooks:
+                audiobook = book["audiobook"]
+                authors = [author["name"] for author in audiobook["allAuthors"]]
+                wishlist_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
+
+    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

@@ -3,14 +3,14 @@ import json
 import os
 import urllib.parse
 from datetime import datetime, timedelta
-from typing import Union
 
 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
+from tbr_deal_finder.book import Book, BookFormat, get_normalized_authors, is_matching_authors
 from tbr_deal_finder.utils import currency_to_float
 
 
@@ -33,11 +33,16 @@ class LibroFM(Retailer):
     def name(self) -> str:
         return "Libro.FM"
 
+    @property
+    def format(self) -> BookFormat:
+        return BookFormat.AUDIOBOOK
+
     async def make_request(self, url_path: str, request_type: str, **kwargs) -> dict:
         url = urllib.parse.urljoin(self.BASE_URL, url_path)
         headers = kwargs.pop("headers", {})
         headers["User-Agent"] = self.USER_AGENT
-        headers["authorization"] = f"Bearer {self.auth_token}"
+        if self.auth_token:
+            headers["authorization"] = f"Bearer {self.auth_token}"
 
         async with aiohttp.ClientSession() as http_client:
             response = await http_client.request(
@@ -75,7 +80,9 @@ class LibroFM(Retailer):
         with open(auth_path, "w") as f:
             json.dump(response, f)
 
-    async def get_book_isbn(self, book: Book, semaphore: asyncio.Semaphore) -> Union[str, None]:
+    async def get_book_isbn(self, book: Book, runtime: datetime, semaphore: asyncio.Semaphore) -> Book:
+        # runtime isn't used but get_book_isbn must follow the get_book method signature.
+
         title = book.title
 
         async with semaphore:
@@ -90,15 +97,25 @@ class LibroFM(Retailer):
             )
 
         for b in response["audiobook_collection"]["audiobooks"]:
-            if title == b["title"] and book.normalized_authors == get_normalized_authors(b["authors"]):
+            normalized_authors = get_normalized_authors(b["authors"])
+
+            if (
+                title == b["title"]
+                and is_matching_authors(book.normalized_authors, normalized_authors)
+            ):
                 book.audiobook_isbn = b["isbn"]
-                return book.audiobook_isbn
+                break
 
-        return None
+        return book
 
     async def get_book(
         self, target: Book, runtime: datetime, 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,
@@ -122,7 +139,7 @@ class LibroFM(Retailer):
                 retailer=self.name,
                 title=target.title,
                 authors=target.authors,
-                list_price=0,
+                list_price=target.audiobook_list_price,
                 current_price=currency_to_float(response["data"]["purchase_info"]["price"]),
                 timepoint=runtime,
                 format=BookFormat.AUDIOBOOK,
@@ -138,3 +155,68 @@ class LibroFM(Retailer):
             format=BookFormat.AUDIOBOOK,
             exists=False,
         )
+
+    async def get_wishlist(self, config: Config) -> list[Book]:
+        wishlist_books = []
+
+        page = 1
+        total_pages = 1
+        while page <= total_pages:
+            response = await self.make_request(
+                f"api/v10/explore/wishlist",
+                "GET",
+                params=dict(page=page)
+            )
+            wishlist = response.get("data", {}).get("wishlist", {})
+            if not wishlist:
+                return []
+
+            for book in wishlist.get("audiobooks", []):
+                wishlist_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 = 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

@@ -2,7 +2,8 @@ import abc
 import asyncio
 from datetime import datetime
 
-from tbr_deal_finder.book import Book
+from tbr_deal_finder.book import Book, BookFormat
+from tbr_deal_finder.config import Config
 
 
 class Retailer(abc.ABC):
@@ -12,6 +13,21 @@ class Retailer(abc.ABC):
     def name(self) -> str:
         raise NotImplementedError
 
+    @property
+    def format(self) -> BookFormat:
+        """The format of the books they sell.
+
+        For example,
+        Audible would be audiobooks
+        Kindle would be ebooks
+
+        :return:
+        """
+        raise NotImplementedError
+
+    async def set_auth(self):
+        raise NotImplementedError
+
     async def get_book(
             self, target: Book, runtime: datetime, semaphore: asyncio.Semaphore
     ) -> Book:
@@ -31,7 +47,9 @@ class Retailer(abc.ABC):
             """
         raise NotImplementedError
 
-    async def set_auth(self):
+    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

@@ -6,9 +6,10 @@ import click
 import pandas as pd
 from tqdm.asyncio import tqdm_asyncio
 
-from tbr_deal_finder.book import Book, get_active_deals
+from tbr_deal_finder.book import Book, get_active_deals, BookFormat
 from tbr_deal_finder.config import Config
-from tbr_deal_finder.library_exports import get_tbr_books
+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
 from tbr_deal_finder.utils import get_duckdb_conn, echo_warning, echo_info
@@ -41,7 +42,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,25 +56,10 @@ 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.
 
-    - Creates a semaphore to limit concurrent requests.
+    - Creates semaphore to limit concurrent requests.
     - Creates a list to store the response.
     - Creates a list to store unresolved books.
 
@@ -100,13 +86,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 +127,34 @@ 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],
+    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
+        ):
+            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.
@@ -163,14 +173,26 @@ async def get_latest_deals(config: Config):
     """
 
     books: list[Book] = []
-    tbr_books = get_tbr_books(config)
+    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]()
         await retailer.set_auth()
 
+        relevant_tbr_books = _get_retailer_relevant_tbr_books(
+            retailer,
+            tbr_books,
+            owned_book_title_map,
+        )
+
         echo_info(f"Getting deals from {retailer.name}")
         click.echo("\n---------------")
-        books.extend(await _get_books(config, retailer, tbr_books))
+        books.extend(await _get_books(config, retailer, relevant_tbr_books))
         click.echo("---------------\n")
 
     _apply_proper_list_prices(books)

tbr_deal_finder/tracked_books.py

@@ -0,0 +1,120 @@
+import asyncio
+import csv
+
+from tqdm.asyncio import tqdm_asyncio
+
+from tbr_deal_finder.book import Book, BookFormat, get_title_id
+from tbr_deal_finder.retailer import Chirp, RETAILER_MAP
+from tbr_deal_finder.config import Config
+from tbr_deal_finder.library_exports import (
+    get_book_authors,
+    get_book_title,
+    is_tbr_book,
+    requires_audiobook_list_price_default
+)
+from tbr_deal_finder.retailer.models import Retailer
+from tbr_deal_finder.utils import currency_to_float
+
+
+def _library_export_tbr_books(config: Config, tbr_book_map: dict[str: Book]):
+    """Adds tbr books in the library export to the provided tbr_book_map
+
+    :param config:
+    :param tbr_book_map:
+    :return:
+    """
+    for library_export_path in config.library_export_paths:
+
+        with open(library_export_path, 'r', newline='', encoding='utf-8') as file:
+            # Use csv.DictReader to get dictionaries with column headers
+            for book_dict in csv.DictReader(file):
+                if not is_tbr_book(book_dict):
+                    continue
+
+                title = get_book_title(book_dict)
+                authors = get_book_authors(book_dict)
+
+                key = get_title_id(title, authors, BookFormat.NA)
+                if key in tbr_book_map and tbr_book_map[key].audiobook_isbn:
+                    continue
+
+                tbr_book_map[key] = Book(
+                    retailer="N/A",
+                    title=title,
+                    authors=authors,
+                    list_price=0,
+                    current_price=0,
+                    timepoint=config.run_time,
+                    format=BookFormat.NA,
+                    audiobook_isbn=book_dict.get("audiobook_isbn"),
+                    audiobook_list_price=currency_to_float(book_dict.get("audiobook_list_price") or 0),
+                )
+
+
+async def _apply_dynamic_audiobook_list_price(config: Config, tbr_book_map: dict[str: Book]):
+    target_books = [
+        book
+        for book in tbr_book_map.values()
+        if book.format == BookFormat.AUDIOBOOK
+    ]
+    if not target_books:
+        return
+
+    chirp = Chirp()
+    semaphore = asyncio.Semaphore(5)
+    books_with_pricing: list[Book] = await tqdm_asyncio.gather(
+        *[
+            chirp.get_book(book, config.run_time, semaphore)
+            for book in target_books
+        ],
+        desc=f"Getting list prices for Libro.FM wishlist"
+    )
+    for book in books_with_pricing:
+        tbr_book_map[book.title_id].audiobook_list_price = book.list_price
+
+
+async def _retailer_wishlist(config: Config, tbr_book_map: dict[str: Book]):
+    """Adds wishlist books in the library export to the provided tbr_book_map
+    Books added here has the format the retailer sells (e.g. Audiobook)
+    so deals are only checked for retailers with that type.
+
+    For example,
+    I as a user have Dune on my audible wishlist.
+    I want to see deals for it on Libro because it's an audiobook.
+    I don't want to see Kindle deals.
+
+    :param config:
+    :param tbr_book_map:
+    :return:
+    """
+    for retailer_str in config.tracked_retailers:
+        retailer: Retailer = RETAILER_MAP[retailer_str]()
+        await retailer.set_auth()
+
+        for book in (await retailer.get_wishlist(config)):
+            na_key = get_title_id(book.title, book.authors, BookFormat.NA)
+            if na_key in tbr_book_map:
+                continue
+
+            key = book.title_id
+            if key in tbr_book_map and tbr_book_map[key].audiobook_isbn:
+                continue
+
+            tbr_book_map[key] = book
+
+    if requires_audiobook_list_price_default(config):
+        await _apply_dynamic_audiobook_list_price(config, tbr_book_map)
+
+
+async def get_tbr_books(config: Config) -> list[Book]:
+    tbr_book_map: dict[str: Book] = {}
+
+    # Get TBRs specified in the user library (StoryGraph/GoodReads) export
+    _library_export_tbr_books(config, tbr_book_map)
+
+    # Pull wishlist from tracked retailers
+    await _retailer_wishlist(config, tbr_book_map)
+
+    return list(tbr_book_map.values())
+
+

{tbr_deal_finder-0.1.5.dist-info → tbr_deal_finder-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tbr-deal-finder
-Version: 0.1.5
+Version: 0.1.7
 Summary: Track price drops and find deals on books in your TBR list across audiobook and ebook formats.
 License: MIT
 License-File: LICENSE
@@ -9,6 +9,7 @@ Requires-Dist: aiohttp>=3.12.14
 Requires-Dist: audible==0.8.2
 Requires-Dist: click>=8.2.1
 Requires-Dist: duckdb>=1.3.2
+Requires-Dist: levenshtein>=0.27.1
 Requires-Dist: pandas>=2.3.1
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: tqdm>=4.67.1
@@ -17,15 +18,17 @@ Description-Content-Type: text/markdown
 
 # tbr-deal-finder
 
-Track price drops and find deals on books in your TBR (To Be Read) list across audiobook and ebook formats.
+Track price drops and find deals on books in your TBR (To Be Read) and wishlist across digital book retailers.
 
 ## Features
-- Uses your StoryGraph exports, Goodreads exports, and custom csvs (spreadsheet) to track book deals
-- Supports multiple of the library exports above 
+- Use your StoryGraph exports, Goodreads exports, and custom csvs (spreadsheet) to track book deals
+- Supports multiple of the library exports above
+- Tracks deals on the wishlist of all your configured retailers like audible 
 - Supports multiple locales and currencies
-- Finds the latest and active deals from supported sellers
+- Find the latest and active deals from supported sellers
 - Simple CLI interface for setup and usage
 - Only get notified for new deals or view all active deals 
+- Filters out books you already own to prevent purchasing the same book on multiple retailers
 
 ## Support
 
@@ -66,7 +69,7 @@ Track price drops and find deals on books in your TBR (To Be Read) list across a
    https://docs.astral.sh/uv/getting-started/installation/
 
 ## Configuration
-This tool relies on the csv generated by the app you use to track your TBRs.
+This tool can use the csv generated by the app you use to track your TBRs.
 Here are the steps to get your export.
 
 ### StoryGraph