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

tbr_deal_finder/book.py

@@ -26,7 +26,11 @@ class Book:
     current_price: float
     timepoint: datetime
     format: Union[BookFormat, str]
+
+    # Metadata really only used for tracked books.
+    # See get_tbr_books for more context
     audiobook_isbn: str = None
+    audiobook_list_price: float = 0
 
     deleted: bool = False
 
@@ -35,16 +39,16 @@ class Book:
     normalized_authors: list[str] = None
 
     def __post_init__(self):
+        self.current_price = round(self.current_price, 2)
+        self.list_price = round(self.list_price, 2)
+        self.normalized_authors = get_normalized_authors(self.authors)
+
         if not self.deal_id:
-            self.deal_id = f"{self.title}__{self.normalized_authors}__{self.retailer}__{self.format}"
+            self.deal_id = f"{self.title}__{self.normalized_authors}__{self.format}__{self.retailer}"
 
         if isinstance(self.format, str):
             self.format = BookFormat(self.format)
 
-        self.current_price = round(self.current_price, 2)
-        self.list_price = round(self.list_price, 2)
-        self.normalized_authors = get_normalized_authors(self.authors)
-
     def discount(self) -> int:
         return int((self.list_price/self.current_price - 1) * 100)
 
@@ -56,6 +60,10 @@ class Book:
     def title_id(self) -> str:
         return f"{self.title}__{self.normalized_authors}__{self.format}"
 
+    @property
+    def full_title_str(self) -> str:
+        return f"{self.title}__{self.normalized_authors}"
+
     def list_price_string(self):
         return self.price_to_string(self.list_price)
 
@@ -74,6 +82,7 @@ class Book:
         response = dataclasses.asdict(self)
         response["format"] = self.format.value
         del response["audiobook_isbn"]
+        del response["audiobook_list_price"]
         del response["exists"]
         del response["normalized_authors"]
 
@@ -114,3 +123,7 @@ def get_normalized_authors(authors: Union[str, list[str]]) -> list[str]:
         authors = [i for i in authors.split(",")]
 
     return sorted([_AUTHOR_RE.sub('', unidecode(author)).lower() for author in authors])
+
+
+def get_title_id(title: str, authors: Union[list, str], book_format: BookFormat) -> str:
+    return f"{title}__{get_normalized_authors(authors)}__{book_format.value}"

tbr_deal_finder/cli.py

@@ -1,5 +1,6 @@
 import asyncio
 import os
+import sys
 from datetime import timedelta
 from textwrap import dedent
 from typing import Union
@@ -8,12 +9,19 @@ import click
 import questionary
 
 from tbr_deal_finder.config import Config
-from tbr_deal_finder.library_exports import maybe_set_library_export_audiobook_isbn
+from tbr_deal_finder.library_exports import maybe_enrich_library_exports
 from tbr_deal_finder.migrations import make_migrations
 from tbr_deal_finder.book import get_deals_found_at, print_books, get_active_deals
 from tbr_deal_finder.retailer import RETAILER_MAP
 from tbr_deal_finder.retailer_deal import get_latest_deals
-from tbr_deal_finder.utils import get_duckdb_conn, get_query_by_name, execute_query
+from tbr_deal_finder.utils import (
+    echo_err,
+    echo_info,
+    echo_success,
+    execute_query,
+    get_duckdb_conn,
+    get_query_by_name
+)
 
 
 @click.group()
@@ -31,12 +39,12 @@ def _add_path(existing_paths: list[str]) -> Union[str, None]:
     try:
         new_path = os.path.expanduser(click.prompt("What is the new path"))
         if new_path in existing_paths:
-            click.echo(f"{new_path} is already being tracked.\n")
+            echo_info(f"{new_path} is already being tracked.\n")
             return None
         elif os.path.exists(new_path):
             return new_path
         else:
-            click.echo(f"Could not find {new_path}. Please try again.\n")
+            echo_err(f"Could not find {new_path}. Please try again.\n")
             return _add_path(existing_paths)
     except (KeyError, KeyboardInterrupt, TypeError):
         return None
@@ -116,14 +124,26 @@ def _set_locale(config: Config):
 
 
 def _set_tracked_retailers(config: Config):
-    config.set_tracked_retailers(
-        questionary.checkbox(
-            "Select the retailers you want to check deals for. "
-            "Tip: Chirp doesn't have a subscription and can have good deals. I'd recommend checking it.",
+    if not config.tracked_retailers:
+        echo_info(
+            "If you haven't heard of it, Chirp doesn't charge a subscription and has some great deals. \n"
+            "Note: I don't work for Chirp and this isn't a paid plug."
+        )
+
+    while True:
+        user_response = questionary.checkbox(
+            "Select the retailers you want to check deals for.\n",
             choices=[
                 questionary.Choice(retailer, checked=retailer in config.tracked_retailers)
                 for retailer in RETAILER_MAP.keys()
-            ]).ask()
+        ]).ask()
+        if len(user_response) > 0:
+            break
+        else:
+            echo_err("You must track deals for at least one retailer.")
+
+    config.set_tracked_retailers(
+        user_response
     )
 
 
@@ -133,10 +153,14 @@ def _set_config() -> Config:
     except FileNotFoundError:
         config = Config(library_export_paths=[], tracked_retailers=list(RETAILER_MAP.keys()))
 
-    # Setting these config values are a little more involved,
-    #   so they're broken out into their own functions
-    _set_library_export_paths(config)
-    _set_tracked_retailers(config)
+    try:
+        # Config attrs that requires a user provided value
+        _set_library_export_paths(config)
+        _set_tracked_retailers(config)
+    except (KeyError, KeyboardInterrupt, TypeError):
+        echo_err("Config setup cancelled.")
+        sys.exit(0)
+
     _set_locale(config)
 
     config.max_price = click.prompt(
@@ -151,7 +175,7 @@ def _set_config() -> Config:
     )
 
     config.save()
-    click.echo("Configuration saved!")
+    echo_success("Configuration saved!")
 
     return config
 
@@ -166,7 +190,7 @@ def latest_deals():
     """Find book deals from your Library export."""
     config = Config.load()
 
-    asyncio.run(maybe_set_library_export_audiobook_isbn(config))
+    asyncio.run(maybe_enrich_library_exports(config))
 
     db_conn = get_duckdb_conn()
     results = execute_query(
@@ -182,7 +206,7 @@ def latest_deals():
         except Exception as e:
             ran_successfully = False
             details = f"Error getting deals: {e}"
-            click.echo(details)
+            echo_err(details)
         else:
             ran_successfully = True
             details = ""
@@ -198,7 +222,7 @@ def latest_deals():
             return
 
     else:
-        click.echo(dedent("""
+        echo_info(dedent("""
         To prevent abuse lastest deals can only be pulled every 8 hours.
         Fetching most recent deal results.\n
         """))
@@ -207,7 +231,7 @@ def latest_deals():
     if books := get_deals_found_at(config.run_time):
         print_books(books)
     else:
-        click.echo("No new deals found.")
+        echo_info("No new deals found.")
 
 
 @cli.command()
@@ -216,7 +240,7 @@ def active_deals():
     if books := get_active_deals():
         print_books(books)
     else:
-        click.echo("No deals found.")
+        echo_info("No deals found.")
 
 
 if __name__ == '__main__':

tbr_deal_finder/library_exports.py

@@ -2,15 +2,17 @@ import asyncio
 import csv
 import shutil
 import tempfile
+from datetime import datetime
+from typing import Callable, Awaitable, Optional
 
 from tqdm.asyncio import tqdm_asyncio
 
-from tbr_deal_finder.book import Book, BookFormat
+from tbr_deal_finder.book import Book, BookFormat, get_normalized_authors
 from tbr_deal_finder.config import Config
-from tbr_deal_finder.retailer.librofm import LibroFM
+from tbr_deal_finder.retailer import LibroFM, Chirp
 
 
-def _get_book_authors(book: dict) -> str:
+def get_book_authors(book: dict) -> str:
     if authors := book.get('Authors'):
         return authors
 
@@ -21,12 +23,12 @@ def _get_book_authors(book: dict) -> str:
     return authors
 
 
-def _get_book_title(book: dict) -> str:
+def get_book_title(book: dict) -> str:
     title = book['Title']
     return title.split("(")[0].strip()
 
 
-def _is_tbr_book(book: dict) -> bool:
+def is_tbr_book(book: dict) -> bool:
     if "Read Status" in book:
         return book["Read Status"] == "to-read"
     elif "Bookshelves" in book:
@@ -35,65 +37,56 @@ def _is_tbr_book(book: dict) -> bool:
         return True
 
 
-def get_tbr_books(config: Config) -> list[Book]:
-    tbr_book_map: dict[str: Book] = {}
-    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 = f'{title}__{authors}'
-
-                if key in tbr_book_map:
-                    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["audiobook_isbn"],
-                )
-    return list(tbr_book_map.values())
-
+def requires_audiobook_list_price_default(config: Config) -> bool:
+    return bool(
+        "Libro.FM" in config.tracked_retailers
+        and "Audible" not in config.tracked_retailers
+        and "Chirp" not in config.tracked_retailers
+    )
 
-async def maybe_set_library_export_audiobook_isbn(config: Config):
-    """To get the price from Libro.fm for a book you need its ISBN
 
-    As opposed to trying to get that every time latest-deals is run
-        we're just updating the export csv once to include the ISBN.
+async def _maybe_set_column_for_library_exports(
+    config: Config,
+    attr_name: str,
+    get_book_callable: Callable[[Book, datetime, asyncio.Semaphore], Awaitable[Book]],
+    column_name: Optional[str] = None,
+):
+    """Adds a new column to all library exports that are missing it.
+    Uses get_book_callable to set the column value if a matching record couldn't be found
+    on that column in any other library export file.
+
+    :param config:
+    :param attr_name:
+    :param get_book_callable:
+    :param column_name:
+    :return:
     """
-
-    if "Libro.FM" not in config.tracked_retailers:
-        return
+    if not column_name:
+        column_name = attr_name
 
     books_requiring_check_map = dict()
-    book_to_isbn_map = dict()
-
+    book_to_col_val_map = dict()
 
+    # Iterate all library export paths
     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):
+                if not is_tbr_book(book_dict):
                     continue
 
-                title = _get_book_title(book_dict)
-                authors = _get_book_authors(book_dict)
-                key = f'{title}__{authors}'
+                title = get_book_title(book_dict)
+                authors = get_book_authors(book_dict)
+                key = f'{title}__{get_normalized_authors(authors)}'
 
-                if "audiobook_isbn" in book_dict:
-                    book_to_isbn_map[key] = book_dict["audiobook_isbn"]
+                if column_name in book_dict:
+                    # Keep state of value for this book/key
+                    # in the event another export has the same book but the value is not set
+                    book_to_col_val_map[key] = book_dict[column_name]
+                    # Value has been found so a check no longer needs to be performed
                     books_requiring_check_map.pop(key, None)
-                elif key not in book_to_isbn_map:
+                elif key not in book_to_col_val_map:
+                    # Not found, add the book to those requiring the column val to be set
                     books_requiring_check_map[key] = Book(
                         retailer="N/A",
                         title=title,
@@ -105,27 +98,33 @@ async def maybe_set_library_export_audiobook_isbn(config: Config):
                     )
 
     if not books_requiring_check_map:
+        # Everything was resolved, nothing else to do
         return
 
-    libro_fm = LibroFM()
-    # Setting it lower to be a good user of libro on their more expensive search call
-    semaphore = asyncio.Semaphore(3)
+    semaphore = asyncio.Semaphore(5)
+    human_readable_name = attr_name.replace("_", " ").title()
 
-    # Set the audiobook isbn for Book instances in books_requiring_check_map
-    await tqdm_asyncio.gather(
+    # Get books with the appropriate transform applied
+    # Responsibility is on the callable here
+    enriched_books = await tqdm_asyncio.gather(
         *[
-            libro_fm.get_book_isbn(book, semaphore) for book in books_requiring_check_map.values()
+            get_book_callable(book, config.run_time, semaphore) for book in books_requiring_check_map.values()
         ],
-        desc="Getting required audiobook ISBN info"
+        desc=f"Getting required {human_readable_name} info"
     )
+    updated_book_map = {
+        b.full_title_str: b
+        for b in enriched_books
+    }
+
 
-    # Go back and now add the audiobook_isbn
+    # Go back and now add the new column where it hasn't been set
     for library_export_path in config.library_export_paths:
         with open(library_export_path, 'r', newline='', encoding='utf-8') as file:
             reader = csv.DictReader(file)
-            field_names = list(reader.fieldnames) + ["audiobook_isbn"]
+            field_names = list(reader.fieldnames) + [column_name]
             file_content = [book_dict for book_dict in reader]
-            if not file_content or "audiobook_isbn" in file_content[0]:
+            if not file_content or column_name in file_content[0]:
                 continue
 
             with tempfile.NamedTemporaryFile(mode='w', delete=False, newline='') as temp_file:
@@ -134,22 +133,73 @@ async def maybe_set_library_export_audiobook_isbn(config: Config):
                 writer.writeheader()
 
                 for book_dict in file_content:
-                    if _is_tbr_book(book_dict):
-                        title = _get_book_title(book_dict)
-                        authors = _get_book_authors(book_dict)
-                        key = f'{title}__{authors}'
-
-                        if key in book_to_isbn_map:
-                            audiobook_isbn = book_to_isbn_map[key]
+                    if is_tbr_book(book_dict):
+                        title = get_book_title(book_dict)
+                        authors = get_book_authors(book_dict)
+                        key = f'{title}__{get_normalized_authors(authors)}'
+
+                        if key in book_to_col_val_map:
+                            col_val = book_to_col_val_map[key]
+                        elif key in updated_book_map:
+                            book = updated_book_map[key]
+                            col_val = getattr(book, attr_name)
                         else:
-                            book = books_requiring_check_map[key]
-                            audiobook_isbn = book.audiobook_isbn
+                            col_val = ""
 
-                        book_dict["audiobook_isbn"] = audiobook_isbn
+                        book_dict[column_name] = col_val
                     else:
-                        book_dict["audiobook_isbn"] = ""
+                        book_dict[column_name] = ""
 
                     writer.writerow(book_dict)
 
         shutil.move(temp_filename, library_export_path)
 
+
+async def _maybe_set_library_export_audiobook_isbn(config: Config):
+    """To get the price from Libro.fm for a book, you need its ISBN
+
+    As opposed to trying to get that every time latest-deals is run
+        we're just updating the export csv once to include the ISBN.
+
+    Unfortunately, we do have to get it at run time for wishlists.
+    """
+    if "Libro.FM" not in config.tracked_retailers:
+        return
+
+    libro_fm = LibroFM()
+    await libro_fm.set_auth()
+
+    await _maybe_set_column_for_library_exports(
+        config,
+        "audiobook_isbn",
+        libro_fm.get_book_isbn,
+    )
+
+
+async def _maybe_set_library_export_audiobook_list_price(config: Config):
+    """Set a default list price for audiobooks
+
+    Only set if not currently set and the only audiobook retailer is Libro.FM
+    Libro.FM doesn't include the actual default price in its response, so this grabs the price reported by Chirp.
+    Chirp doesn't require a login to get this price info making it ideal in this instance.
+
+    :param config:
+    :return:
+    """
+    if not requires_audiobook_list_price_default(config):
+        return
+
+    chirp = Chirp()
+    await chirp.set_auth()
+
+    await _maybe_set_column_for_library_exports(
+        config,
+        "list_price",
+        chirp.get_book,
+        "audiobook_list_price"
+    )
+
+
+async def maybe_enrich_library_exports(config: Config):
+    await _maybe_set_library_export_audiobook_isbn(config)
+    await _maybe_set_library_export_audiobook_list_price(config)

tbr_deal_finder/retailer/audible.py

@@ -1,4 +1,5 @@
 import asyncio
+import math
 import os.path
 from datetime import datetime
 from textwrap import dedent
@@ -22,11 +23,9 @@ def login_url_callback(url: str) -> str:
 
     try:
         from playwright.sync_api import sync_playwright  # type: ignore
-        use_playwright = True
     except ImportError:
-        use_playwright = False
-
-    if use_playwright:
+        pass
+    else:
         with sync_playwright() as p:
             iphone = p.devices["iPhone 12 Pro"]
             browser = p.webkit.launch(headless=False)
@@ -75,6 +74,23 @@ class Audible(Retailer):
     def name(self) -> str:
         return "Audible"
 
+    @property
+    def format(self) -> BookFormat:
+        return BookFormat.AUDIOBOOK
+
+    async def set_auth(self):
+        if not os.path.exists(_AUTH_PATH):
+            auth = audible.Authenticator.from_login_external(
+                locale=Config.locale,
+                login_url_callback=login_url_callback
+            )
+
+            # Save credentials to file
+            auth.to_file(_AUTH_PATH)
+
+        self._auth = audible.Authenticator.from_file(_AUTH_PATH)
+        self._client = audible.AsyncClient(auth=self._auth)
+
     async def get_book(
         self,
         target: Book,
@@ -95,19 +111,7 @@ class Audible(Retailer):
                 ]
             )
 
-            if not match["products"]:
-                return Book(
-                    retailer=self.name,
-                    title=title,
-                    authors=authors,
-                    list_price=0,
-                    current_price=0,
-                    timepoint=runtime,
-                    format=BookFormat.AUDIOBOOK,
-                    exists=False,
-                )
-
-            for product in match["products"]:
+            for product in match.get("products", []):
                 if product["title"] != title:
                     continue
 
@@ -132,15 +136,38 @@ class Audible(Retailer):
                 exists=False,
             )
 
-    async def set_auth(self):
-        if not os.path.exists(_AUTH_PATH):
-            auth = audible.Authenticator.from_login_external(
-                locale=Config.locale,
-                login_url_callback=login_url_callback
+    async def get_wishlist(self, config: Config) -> list[Book]:
+        wishlist_books = []
+
+        page = 0
+        total_pages = 1
+        page_size = 50
+        while page < total_pages:
+            response = await self._client.get(
+                "1.0/wishlist",
+                num_results=page_size,
+                page=page,
+                response_groups=[
+                    "contributors, product_attrs, product_desc, product_extended_attrs"
+                ]
             )
 
-            # Save credentials to file
-            auth.to_file(_AUTH_PATH)
+            for audiobook in response.get("products", []):
+                authors = [author["name"] for author in audiobook["authors"]]
+                wishlist_books.append(
+                    Book(
+                        retailer=self.name,
+                        title=audiobook["title"],
+                        authors=", ".join(authors),
+                        list_price=1,
+                        current_price=1,
+                        timepoint=config.run_time,
+                        format=self.format,
+                        audiobook_isbn=audiobook["isbn"],
+                    )
+                )
 
-        self._auth = audible.Authenticator.from_file(_AUTH_PATH)
-        self._client = audible.AsyncClient(auth=self._auth)
+            page += 1
+            total_pages = math.ceil(int(response.get("total_results", 1))/page_size)
+
+        return wishlist_books

tbr_deal_finder/retailer/chirp.py

@@ -1,38 +1,105 @@
 import asyncio
-from datetime import datetime
+import json
+import os
+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
-from tbr_deal_finder.utils import currency_to_float
+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:
         title = target.title
         authors = target.authors
+        async with semaphore:
+            async with aiohttp.ClientSession() as http_client:
+                response = await http_client.request(
+                    "POST",
+                    self._url,
+                    json={
+                        "query": "fragment audiobookFields on Audiobook{id averageRating coverUrl displayAuthors displayTitle ratingsCount url allAuthors{name slug url}} fragment audiobookWithShoppingCartAndUserAudiobookFields on Audiobook{...audiobookFields currentUserShoppingCartItem{id}currentUserWishlistItem{id}currentUserUserAudiobook{id}currentUserHasAuthorFollow{id}} fragment productFields on Product{discountPrice id isFreeListing listingPrice purchaseUrl savingsPercent showListingPrice timeLeft bannerType} query AudiobookSearch($query:String!,$promotionFilter:String,$filter:String,$page:Int,$pageSize:Int){audiobooks(query:$query,promotionFilter:$promotionFilter,filter:$filter,page:$page,pageSize:$pageSize){totalCount objects(page:$page,pageSize:$pageSize){... on Audiobook{...audiobookWithShoppingCartAndUserAudiobookFields futureSaleDate currentProduct{...productFields}}}}}",
+                        "variables": {"query": title, "filter": "all", "page": 1, "promotionFilter": "default"},
+                        "operationName": "AudiobookSearch"
+                    }
+                )
+                response_body = await response.json()
 
-        async with aiohttp.ClientSession() as http_client:
-            response = await http_client.request(
-                "POST",
-                self._url,
-                json={
-                    "query": "fragment audiobookFields on Audiobook{id averageRating coverUrl displayAuthors displayTitle ratingsCount url allAuthors{name slug url}} fragment audiobookWithShoppingCartAndUserAudiobookFields on Audiobook{...audiobookFields currentUserShoppingCartItem{id}currentUserWishlistItem{id}currentUserUserAudiobook{id}currentUserHasAuthorFollow{id}} fragment productFields on Product{discountPrice id isFreeListing listingPrice purchaseUrl savingsPercent showListingPrice timeLeft bannerType} query AudiobookSearch($query:String!,$promotionFilter:String,$filter:String,$page:Int,$pageSize:Int){audiobooks(query:$query,promotionFilter:$promotionFilter,filter:$filter,page:$page,pageSize:$pageSize){totalCount objects(page:$page,pageSize:$pageSize){... on Audiobook{...audiobookWithShoppingCartAndUserAudiobookFields futureSaleDate currentProduct{...productFields}}}}}",
-                    "variables": {"query": title, "filter": "all", "page": 1, "promotionFilter": "default"},
-                    "operationName": "AudiobookSearch"
-                }
-            )
-            response_body = await response.json()
             audiobooks = response_body["data"]["audiobooks"]["objects"]
             if not audiobooks:
                 return Book(
@@ -50,9 +117,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 any(author in normalized_authors for author in target.normalized_authors)
                 ):
                     return Book(
                         retailer=self.name,
@@ -75,5 +143,40 @@ 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

tbr_deal_finder/retailer/librofm.py

@@ -3,12 +3,12 @@ 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.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,28 +80,42 @@ 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
-        response = await self.make_request(
-            f"api/v10/explore/search",
-            "GET",
-            params={
-                "q": title,
-                "searchby": "titles",
-                "sortby": "relevance#results",
-            },
-        )
+
+        async with semaphore:
+            response = await self.make_request(
+                f"api/v10/explore/search",
+                "GET",
+                params={
+                    "q": title,
+                    "searchby": "titles",
+                    "sortby": "relevance#results",
+                },
+            )
 
         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 any(author in normalized_authors for author in book.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,
@@ -108,17 +127,19 @@ class LibroFM(Retailer):
                 format=BookFormat.AUDIOBOOK,
                 exists=False,
             )
-        response = await self.make_request(
-            f"api/v10/explore/audiobook_details/{target.audiobook_isbn}",
-            "GET"
-        )
+
+        async with semaphore:
+            response = await self.make_request(
+                f"api/v10/explore/audiobook_details/{target.audiobook_isbn}",
+                "GET"
+            )
 
         if response:
             return Book(
                 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,
@@ -134,3 +155,37 @@ 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=2)
+            )
+            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

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,7 @@ class Retailer(abc.ABC):
             """
         raise NotImplementedError
 
-    async def set_auth(self):
+    async def get_wishlist(self, config: Config) -> list[Book]:
         raise NotImplementedError
 
 

tbr_deal_finder/retailer_deal.py

@@ -6,12 +6,12 @@ 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.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
+from tbr_deal_finder.utils import get_duckdb_conn, echo_warning, echo_info
 
 
 def update_retailer_deal_table(config: Config, new_deals: list[Book]):
@@ -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():
-        click.echo(f"{str(deal)} is no longer active")
+        echo_warning(f"{str(deal)} is no longer active")
         deal.timepoint = config.run_time
         deal.deleted = True
         df_data.append(deal.dict())
@@ -73,7 +73,7 @@ def _retry_books(found_books: list[Book], all_books: list[Book]) -> list[Book]:
 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.
 
@@ -101,12 +101,12 @@ async def _get_books(config, retailer: Retailer, books: list[Book]) -> list[Book
             unresolved_books.append(book)
 
     if retry_books := _retry_books(response, books):
-        click.echo("Attempting to find missing books with alternate title")
+        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:
-            click.echo(f"{book.title} by {book.authors} not found")
+            echo_info(f"{book.title} by {book.authors} not found")
 
     return response
 
@@ -163,14 +163,23 @@ async def get_latest_deals(config: Config):
     """
 
     books: list[Book] = []
-    tbr_books = get_tbr_books(config)
+    tbr_books = await get_tbr_books(config)
+
     for retailer_str in config.tracked_retailers:
         retailer = RETAILER_MAP[retailer_str]()
         await retailer.set_auth()
 
-        click.echo(f"Getting deals from {retailer.name}")
+        # 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
+        ]
+
+        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/utils.py

@@ -1,6 +1,7 @@
 import re
 from typing import Optional
 
+import click
 import duckdb
 
 from tbr_deal_finder import TBR_DEALS_PATH, QUERY_PATH
@@ -38,3 +39,19 @@ def execute_query(
 
 def get_query_by_name(file_name: str) -> str:
     return QUERY_PATH.joinpath(file_name).read_text()
+
+
+def echo_err(message):
+    click.secho(f'\n❌  {message}\n', fg='red', bold=True)
+
+
+def echo_success(message):
+    click.secho(f'\n✅  {message}', fg='green', bold=True)
+
+
+def echo_warning(message):
+    click.secho(f'\n⚠️  {message}', fg='yellow')
+
+
+def echo_info(message):
+    click.secho(f'{message}', fg='blue')

{tbr_deal_finder-0.1.4.dist-info → tbr_deal_finder-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tbr-deal-finder
-Version: 0.1.4
+Version: 0.1.6
 Summary: Track price drops and find deals on books in your TBR list across audiobook and ebook formats.
 License: MIT
 License-File: LICENSE
@@ -21,7 +21,8 @@ Track price drops and find deals on books in your TBR (To Be Read) list across a
 
 ## Features
 - Uses your StoryGraph exports, Goodreads exports, and custom csvs (spreadsheet) to track book deals
-- Supports multiple of the library exports above 
+- 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
 - Simple CLI interface for setup and usage
@@ -32,7 +33,7 @@ Track price drops and find deals on books in your TBR (To Be Read) list across a
 ### Audiobooks
 * Audible
 * Chirp
-* Libro.fm (Work in progress)
+* Libro.fm
 
 ### Locales
 * US

tbr_deal_finder-0.1.6.dist-info/RECORD

@@ -0,0 +1,22 @@
+tbr_deal_finder/__init__.py,sha256=WCoj0GZrRiCQlrpkLTw1VUeJmX-RtBLdLqnFYn1Es_4,208
+tbr_deal_finder/book.py,sha256=ZnwuIU2-rP0UC12fSC_HiTXpmgBp5XrRiFe82OLQ-E0,3786
+tbr_deal_finder/cli.py,sha256=jIwzyESLGc77Wyxsv4XjEfMHZHjQI_PTmBLamc9tiV0,7284
+tbr_deal_finder/config.py,sha256=3fgN92sVsQbVqRBc58QK9w5t35zoPX6pP3k4nnJ_YTg,3441
+tbr_deal_finder/library_exports.py,sha256=Hupx3mJyhvqXEslR2R3ifG9ykSKxkOb-H3gGK_CRx68,7133
+tbr_deal_finder/migrations.py,sha256=6_WV55bm71UCFrcFrfJXlEX5uDrgnNTWZPq6vZTg18o,3733
+tbr_deal_finder/retailer_deal.py,sha256=wMziFXCvrJQ_i4IdsXVPlaXnUIeGTRPt_rwbPfqX2FE,6742
+tbr_deal_finder/tracked_books.py,sha256=EKecARSOMPPkmjSSWfWQw9B-TnoSd3-6AQepc2EYTz0,4031
+tbr_deal_finder/utils.py,sha256=_4wdGFDtqCdMyoMnwTDiHgCR4WQLAcQr8LlZZZUcq6E,1357
+tbr_deal_finder/queries/get_active_deals.sql,sha256=jILZK5UVNPLbbKWgqMW0brEZyCb9XBdQZJLHRULoQC4,195
+tbr_deal_finder/queries/get_deals_found_at.sql,sha256=1vAE8PsAvfFi0SbvoUw8pvLwRN9VGYTJ7AVI3rmxXEI,122
+tbr_deal_finder/queries/latest_deal_last_ran_most_recent_success.sql,sha256=W4cNMAHtcW2DzQyPL8SHHFcbVZQKVK2VfTzazxC3LJU,107
+tbr_deal_finder/retailer/__init__.py,sha256=WePMSN7vi4EL_uPiAH6ogNNE-kRQe4OHT4CYGTKvBSk,243
+tbr_deal_finder/retailer/audible.py,sha256=AY8jippIQe0XqCXk9iLb3CHADIYIG3orlctNQRSv2q8,5315
+tbr_deal_finder/retailer/chirp.py,sha256=BVtHsrM0nsMmT2fxDnUliXVWfY2xZY8TR3FWZzyaxIA,8042
+tbr_deal_finder/retailer/librofm.py,sha256=ZiowAIpDYnuH6KREdPK874t-Handlr0jZ9Mj0QMVGis,6428
+tbr_deal_finder/retailer/models.py,sha256=wAGZtp0BWz9vlZCcWZqll8gwXUP6-6oFtsWv3gCXEHM,1415
+tbr_deal_finder-0.1.6.dist-info/METADATA,sha256=CbRtsumWOcJ_VaabBoCqzGURzKjCOvvdk5koY11ukZE,4215
+tbr_deal_finder-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tbr_deal_finder-0.1.6.dist-info/entry_points.txt,sha256=y_KG1k8xVCY8gngSZ-na2bkK-tTLUdOc_qZ9Djwldv0,60
+tbr_deal_finder-0.1.6.dist-info/licenses/LICENSE,sha256=rNc0wNPn4d4HHu6ZheJzeUaz_FbJ4rj2Dr2FjAivkNg,1064
+tbr_deal_finder-0.1.6.dist-info/RECORD,,

tbr_deal_finder-0.1.4.dist-info/RECORD

@@ -1,21 +0,0 @@
-tbr_deal_finder/__init__.py,sha256=WCoj0GZrRiCQlrpkLTw1VUeJmX-RtBLdLqnFYn1Es_4,208
-tbr_deal_finder/book.py,sha256=2MQirkxDIVKdQQ07U56zwOw45rC8KH-5aC932_X9dhE,3333
-tbr_deal_finder/cli.py,sha256=8riqTK5QVPKyP3aUQ3hHjNbIuZ0ibF_WLiNFMBqddT4,6830
-tbr_deal_finder/config.py,sha256=3fgN92sVsQbVqRBc58QK9w5t35zoPX6pP3k4nnJ_YTg,3441
-tbr_deal_finder/library_exports.py,sha256=FJXBQV_9H5AI_cwNuGjvGQxgQ1RLlpldmDBwc_PsiK4,5474
-tbr_deal_finder/migrations.py,sha256=6_WV55bm71UCFrcFrfJXlEX5uDrgnNTWZPq6vZTg18o,3733
-tbr_deal_finder/retailer_deal.py,sha256=J3dGceB84wDQUV0FsW_0I0PLA5nU6LStzAx6sMNTo2c,6408
-tbr_deal_finder/utils.py,sha256=c_AfIpfE1IAewUBiaRhPHjBM2o-fvuVVcWfM7jPEOvk,1021
-tbr_deal_finder/queries/get_active_deals.sql,sha256=jILZK5UVNPLbbKWgqMW0brEZyCb9XBdQZJLHRULoQC4,195
-tbr_deal_finder/queries/get_deals_found_at.sql,sha256=1vAE8PsAvfFi0SbvoUw8pvLwRN9VGYTJ7AVI3rmxXEI,122
-tbr_deal_finder/queries/latest_deal_last_ran_most_recent_success.sql,sha256=W4cNMAHtcW2DzQyPL8SHHFcbVZQKVK2VfTzazxC3LJU,107
-tbr_deal_finder/retailer/__init__.py,sha256=WePMSN7vi4EL_uPiAH6ogNNE-kRQe4OHT4CYGTKvBSk,243
-tbr_deal_finder/retailer/audible.py,sha256=7z7rDQBcCwOhdATU4BJjsJ-QBP0HnxscMSGPmzN_K2k,4408
-tbr_deal_finder/retailer/chirp.py,sha256=mi2uIhiXHxMnlRgtd1BZULEZbpF_K2HzxWubV4v_vvc,3540
-tbr_deal_finder/retailer/librofm.py,sha256=M4WvGh3Gf3LVUE3KOCVtNKJB8koQasgybUFhKBvqBe0,4476
-tbr_deal_finder/retailer/models.py,sha256=zEwyM_0ildB8p38sxfpE6p2dIvtwAjeaul-GkJlk2Fo,1012
-tbr_deal_finder-0.1.4.dist-info/METADATA,sha256=oLSiX7Bb6Spb3DAAxB6cu0qMsWUfk8LnQgLtzGh76Ho,4157
-tbr_deal_finder-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tbr_deal_finder-0.1.4.dist-info/entry_points.txt,sha256=y_KG1k8xVCY8gngSZ-na2bkK-tTLUdOc_qZ9Djwldv0,60
-tbr_deal_finder-0.1.4.dist-info/licenses/LICENSE,sha256=rNc0wNPn4d4HHu6ZheJzeUaz_FbJ4rj2Dr2FjAivkNg,1064
-tbr_deal_finder-0.1.4.dist-info/RECORD,,