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

tbr_deal_finder/book.py

@@ -5,6 +5,7 @@ from enum import Enum
 from typing import Optional, Union
 
 import click
+from Levenshtein import ratio
 from unidecode import unidecode
 
 from tbr_deal_finder.config import Config
@@ -26,7 +27,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 +40,20 @@ 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)
+
+        # Strip the title down to its most basic repr
+        # Improves hit rate on retailers
+        self.title = self.title.split(":")[0].split("(")[0].strip()
+
         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 +65,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 +87,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"]
 
@@ -109,8 +123,33 @@ def print_books(books: list[Book]):
         click.echo(str(book))
 
 
+def get_full_title_str(title: str, authors: Union[list, str]) -> str:
+    return f"{title}__{get_normalized_authors(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}"
+
+
 def get_normalized_authors(authors: Union[str, list[str]]) -> list[str]:
     if isinstance(authors, str):
         authors = [i for i in authors.split(",")]
 
     return sorted([_AUTHOR_RE.sub('', unidecode(author)).lower() for author in authors])
+
+
+def is_matching_authors(a1: list[str], a2: list[str]) -> bool:
+    """Checks if two normalized authors are matching.
+    Matching here means that they are at least 80% similar using levenshtein distance.
+
+    Score is calculated as follows:
+        1 - (distance / (len1 + len2))
+
+    :param a1:
+    :param a2:
+    :return:
+    """
+    return any(
+        any(ratio(author1, author2, score_cutoff=.8) for author2 in a2)
+        for author1 in a1
+    )

tbr_deal_finder/cli.py

@@ -9,7 +9,7 @@ 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
@@ -28,12 +28,6 @@ from tbr_deal_finder.utils import (
 def cli():
     make_migrations()
 
-    # Check that the config exists for all commands ran
-    try:
-        Config.load()
-    except FileNotFoundError:
-        _set_config()
-
 
 def _add_path(existing_paths: list[str]) -> Union[str, None]:
     try:
@@ -68,24 +62,26 @@ def _set_library_export_paths(config: Config):
     Ensures that only valid, unique paths are added. Updates the config in-place.
     """
     while True:
-        if config.library_export_paths:
-            if len(config.library_export_paths) > 1:
-                choices = ["Add new path", "Remove path", "Done"]
-            else:
-                choices = ["Add new path", "Done"]
-
-            try:
-                user_selection = questionary.select(
-                    "What change would you like to make to your library export paths",
-                    choices=choices,
-                ).ask()
-            except (KeyError, KeyboardInterrupt, TypeError):
-                return
+        if len(config.library_export_paths) > 0:
+            choices = ["Add new path", "Remove path", "Done"]
         else:
-            click.echo("Add your library export path.")
-            user_selection = "Add new path"
+            choices = ["Add new path", "Done"]
+
+        try:
+            user_selection = questionary.select(
+                "What change would you like to make to your library export paths",
+                choices=choices,
+            ).ask()
+        except (KeyError, KeyboardInterrupt, TypeError):
+            return
 
         if user_selection == "Done":
+            if not config.library_export_paths:
+                if not click.confirm(
+                    "Don't add a GoodReads or StoryGraph export and use wishlist entirely? "
+                    "Note: Wishlist checks will still work even if you add your StoryGraph/GoodReads export."
+                ):
+                    continue
             return
         elif user_selection == "Add new path":
             if new_path := _add_path(config.library_export_paths):
@@ -124,15 +120,20 @@ def _set_locale(config: Config):
 
 
 def _set_tracked_retailers(config: Config):
+    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"
-            "Tip: Chirp doesn't have a subscription and can have good deals. I'd recommend checking it.\n",
+            "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()
-        if len(user_response) > 1:
+        if len(user_response) > 0:
             break
         else:
             echo_err("You must track deals for at least one retailer.")
@@ -183,9 +184,12 @@ def setup():
 @cli.command()
 def latest_deals():
     """Find book deals from your Library export."""
-    config = Config.load()
+    try:
+        config = Config.load()
+    except FileNotFoundError:
+        config = _set_config()
 
-    asyncio.run(maybe_set_library_export_audiobook_isbn(config))
+    asyncio.run(maybe_enrich_library_exports(config))
 
     db_conn = get_duckdb_conn()
     results = execute_query(

tbr_deal_finder/config.py

@@ -62,10 +62,16 @@ class Config:
         tracked_retailers_str = parser.get('DEFAULT', 'tracked_retailers')
         locale = parser.get('DEFAULT', 'locale', fallback="us")
         cls.set_locale(locale)
+
+        if export_paths_str:
+            library_export_paths = [i.strip() for i in export_paths_str.split(",")]
+        else:
+            library_export_paths = []
+
         return cls(
             max_price=parser.getfloat('DEFAULT', 'max_price', fallback=8.0),  
             min_discount=parser.getint('DEFAULT', 'min_discount', fallback=35),
-            library_export_paths=[i.strip() for i in export_paths_str.split(",")],
+            library_export_paths=library_export_paths,
             tracked_retailers=[i.strip() for i in tracked_retailers_str.split(",")]
         )
 
@@ -78,7 +84,9 @@ class Config:
         return ", ".join(self.tracked_retailers)
 
     def set_library_export_paths(self, library_export_paths: Union[str, list[str]]):
-        if isinstance(library_export_paths, str):
+        if not library_export_paths:
+            self.library_export_paths = []
+        elif isinstance(library_export_paths, str):
             self.library_export_paths = [i.strip() for i in library_export_paths.split(",")]
         else:
             self.library_export_paths = library_export_paths

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_full_title_str
 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,59 @@ 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:
+    if not config.library_export_paths:
         return
 
-    books_requiring_check_map = dict()
-    book_to_isbn_map = dict()
+    if not column_name:
+        column_name = attr_name
 
+    books_requiring_check_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 = get_full_title_str(title, 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 +101,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 +136,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 = get_full_title_str(title, 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/owned_books.py

@@ -0,0 +1,18 @@
+from tbr_deal_finder.book import Book
+from tbr_deal_finder.config import Config
+from tbr_deal_finder.retailer import RETAILER_MAP
+from tbr_deal_finder.retailer.models import Retailer
+
+
+async def get_owned_books(config: Config) -> list[Book]:
+    owned_books = []
+
+    for retailer_str in config.tracked_retailers:
+        retailer: Retailer = RETAILER_MAP[retailer_str]()
+        await retailer.set_auth()
+
+        owned_books.extend(
+            await retailer.get_library(config)
+        )
+
+    return owned_books

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,74 @@ 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
+
+    async def get_library(self, config: Config) -> list[Book]:
+        library_books = []
+
+        page = 1
+        total_pages = 1
+        page_size = 1000
+        while page <= total_pages:
+            response = await self._client.get(
+                "1.0/library",
+                num_results=page_size,
+                page=page,
+                response_groups=[
+                    "contributors, product_attrs, product_desc, product_extended_attrs"
+                ]
+            )
+
+            for audiobook in response.get("items", []):
+                authors = [author["name"] for author in audiobook["authors"]]
+                library_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"],
+                    )
+                )
+
+            page += 1
+            total_pages = math.ceil(int(response.get("total_results", 1))/page_size)
+
+        return library_books