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

tbr_deal_finder/book.py

@@ -1,8 +1,7 @@
-import dataclasses
 import re
 from datetime import datetime
 from enum import Enum
-from typing import Optional, Union
+from typing import Union
 
 import click
 from Levenshtein import ratio
@@ -15,44 +14,45 @@ _AUTHOR_RE = re.compile(r'[^a-zA-Z0-9]')
 
 class BookFormat(Enum):
     AUDIOBOOK = "Audiobook"
-    NA = "N/A"  # When format does not matter
-
-
-@dataclasses.dataclass
-class Book:    
-    retailer: str
-    title: str
-    authors: str
-    list_price: float
-    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
-
-    deal_id: Optional[str] = None
-    exists: bool = True
-    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.format}__{self.retailer}"
-
-        if isinstance(self.format, str):
-            self.format = BookFormat(self.format)
+    EBOOK = "E-Book"
+    NA = "N/A"  # When the format doesn't matter
+
+
+class Book:
+
+    def __init__(
+        self,
+        retailer: str,
+        title: str,
+        authors: str,
+        timepoint: datetime,
+        format: Union[BookFormat, str],
+        list_price: float = 0,
+        current_price: float = 0,
+        ebook_asin: str = None,
+        audiobook_isbn: str = None,
+        audiobook_list_price: float = 0,
+        deleted: bool = False,
+        exists: bool = True,
+    ):
+        self.retailer = retailer
+        self.title = title.split(":")[0].split("(")[0].strip()
+        self.authors = authors
+        self.timepoint = timepoint
+
+        self.ebook_asin = ebook_asin
+        self.audiobook_isbn = audiobook_isbn
+        self.audiobook_list_price = audiobook_list_price
+        self.deleted = deleted
+        self.exists = exists
+
+        self.list_price = list_price
+        self.current_price = current_price
+        self.normalized_authors = get_normalized_authors(authors)
+
+        if isinstance(format, str):
+            format = BookFormat(format)
+        self.format = format
 
     def discount(self) -> int:
         return int((self.list_price/self.current_price - 1) * 100)
@@ -61,6 +61,10 @@ class Book:
     def price_to_string(price: float) -> str:
         return f"{Config.currency_symbol()}{price:.2f}"
 
+    @property
+    def deal_id(self) -> str:
+        return f"{self.title}__{self.normalized_authors}__{self.format}__{self.retailer}"
+
     @property
     def title_id(self) -> str:
         return f"{self.title}__{self.normalized_authors}__{self.format}"
@@ -69,6 +73,22 @@ class Book:
     def full_title_str(self) -> str:
         return f"{self.title}__{self.normalized_authors}"
 
+    @property
+    def current_price(self) -> float:
+        return self._current_price
+
+    @current_price.setter
+    def current_price(self, price: float):
+        self._current_price = round(price, 2)
+
+    @property
+    def list_price(self) -> float:
+        return self._list_price
+
+    @list_price.setter
+    def list_price(self, price: float):
+        self._list_price = round(price, 2)
+
     def list_price_string(self):
         return self.price_to_string(self.list_price)
 
@@ -81,17 +101,31 @@ class Book:
         title = self.title
         if len(self.title) > 75:
             title = f"{title[:75]}..."
-        return f"{title} by {self.authors} - {price} - {self.discount()}% Off at {self.retailer} - {book_format}"
+        return f"{title} by {self.authors} - {price} - {self.discount()}% Off at {self.retailer}"
 
     def dict(self):
-        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"]
-
-        return response
+        return {
+            "retailer": self.retailer,
+            "title": self.title,
+            "authors": self.authors,
+            "list_price": self.list_price,
+            "current_price": self.current_price,
+            "timepoint": self.timepoint,
+            "format": self.format.value,
+            "deleted": self.deleted,
+            "deal_id": self.deal_id,
+        }
+
+    def tbr_dict(self):
+        return {
+            "title": self.title,
+            "authors": self.authors,
+            "format": self.format.value,
+            "ebook_asin": self.ebook_asin,
+            "audiobook_isbn": self.audiobook_isbn,
+            "audiobook_list_price": self.audiobook_list_price,
+            "book_id": self.title_id,
+        }
 
 
 def get_deals_found_at(timepoint: datetime) -> list[Book]:

tbr_deal_finder/cli.py

@@ -9,11 +9,11 @@ import click
 import questionary
 
 from tbr_deal_finder.config import Config
-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.tracked_books import reprocess_incomplete_tbr_books
 from tbr_deal_finder.utils import (
     echo_err,
     echo_info,
@@ -180,6 +180,10 @@ def _set_config() -> Config:
 def setup():
     _set_config()
 
+    # Retailers may have changed causing some books to need reprocessing
+    config = Config.load()
+    reprocess_incomplete_tbr_books(config)
+
 
 @cli.command()
 def latest_deals():
@@ -189,8 +193,6 @@ def latest_deals():
     except FileNotFoundError:
         config = _set_config()
 
-    asyncio.run(maybe_enrich_library_exports(config))
-
     db_conn = get_duckdb_conn()
     results = execute_query(
         db_conn,

tbr_deal_finder/config.py

@@ -83,6 +83,16 @@ class Config:
     def tracked_retailers_str(self) -> str:
         return ", ".join(self.tracked_retailers)
 
+    def is_tracking_format(self, book_format) -> bool:
+        from tbr_deal_finder.retailer import RETAILER_MAP
+
+        for retailer_str in self.tracked_retailers:
+            retailer = RETAILER_MAP[retailer_str]()
+            if retailer.format == book_format:
+                return True
+
+        return False
+
     def set_library_export_paths(self, library_export_paths: Union[str, list[str]]):
         if not library_export_paths:
             self.library_export_paths = []

tbr_deal_finder/migrations.py

@@ -46,6 +46,22 @@ _MIGRATIONS = [
             );
             """
     ),
+    TableMigration(
+        version=1,
+        table_name="tbr_book",
+        sql="""
+            CREATE TABLE tbr_book
+            (
+                title                VARCHAR,
+                authors              VARCHAR,
+                format               VARCHAR,
+                ebook_asin           VARCHAR,
+                audiobook_isbn       VARCHAR,
+                audiobook_list_price FLOAT,
+                book_id              VARCHAR
+            );
+            """
+    ),
 ]
 
 

tbr_deal_finder/queries/get_active_deals.sql

@@ -1,4 +1,4 @@
-SELECT *
+SELECT * exclude(deal_id)
 FROM retailer_deal
 QUALIFY	ROW_NUMBER() OVER (PARTITION BY title, authors, retailer, format ORDER BY timepoint DESC) = 1 AND deleted IS NOT TRUE
 ORDER BY title, authors, retailer, format

tbr_deal_finder/queries/get_deals_found_at.sql

@@ -1,4 +1,4 @@
-SELECT *
+SELECT * exclude(deal_id)
 FROM retailer_deal
 WHERE timepoint = $timepoint AND deleted IS NOT TRUE
 ORDER BY title, authors, retailer, format

tbr_deal_finder/retailer/amazon.py

@@ -0,0 +1,79 @@
+import os.path
+
+import audible
+import click
+from audible.login import build_init_cookies
+from textwrap import dedent
+
+from tbr_deal_finder import TBR_DEALS_PATH
+from tbr_deal_finder.config import Config
+from tbr_deal_finder.retailer.models import Retailer
+
+_AUTH_PATH = TBR_DEALS_PATH.joinpath("audible.json")
+
+
+def login_url_callback(url: str) -> str:
+    """Helper function for login with external browsers."""
+
+    try:
+        from playwright.sync_api import sync_playwright  # type: ignore
+    except ImportError:
+        pass
+    else:
+        with sync_playwright() as p:
+            iphone = p.devices["iPhone 12 Pro"]
+            browser = p.webkit.launch(headless=False)
+            context = browser.new_context(
+                **iphone
+            )
+            cookies = []
+            for name, value in build_init_cookies().items():
+                cookies.append(
+                    {
+                        "name": name,
+                        "value": value,
+                        "url": url
+                    }
+                )
+            context.add_cookies(cookies)
+            page = browser.new_page()
+            page.goto(url)
+
+            while True:
+                page.wait_for_timeout(600)
+                if "/ap/maplanding" in page.url:
+                    response_url = page.url
+                    break
+
+            browser.close()
+        return response_url
+
+    message = f"""\
+        Please copy the following url and insert it into a web browser of your choice to log into Amazon.
+        Note: your browser will show you an error page (Page not found). This is expected.
+        
+        {url}
+
+        Once you have logged in, please insert the copied url.
+    """
+    click.echo(dedent(message))
+    return input()
+
+
+class Amazon(Retailer):
+    _auth: audible.Authenticator = None
+    _client: audible.AsyncClient = None
+
+    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)
+

tbr_deal_finder/retailer/audible.py

@@ -1,74 +1,13 @@
 import asyncio
 import math
-import os.path
-from datetime import datetime
-from textwrap import dedent
 import readline  # type: ignore
 
-
-import audible
-import click
-from audible.login import build_init_cookies
-
-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.retailer.amazon import Amazon
 from tbr_deal_finder.book import Book, BookFormat
 
-_AUTH_PATH = TBR_DEALS_PATH.joinpath("audible.json")
-
-
-def login_url_callback(url: str) -> str:
-    """Helper function for login with external browsers."""
-
-    try:
-        from playwright.sync_api import sync_playwright  # type: ignore
-    except ImportError:
-        pass
-    else:
-        with sync_playwright() as p:
-            iphone = p.devices["iPhone 12 Pro"]
-            browser = p.webkit.launch(headless=False)
-            context = browser.new_context(
-                **iphone
-            )
-            cookies = []
-            for name, value in build_init_cookies().items():
-                cookies.append(
-                    {
-                        "name": name,
-                        "value": value,
-                        "url": url
-                    }
-                )
-            context.add_cookies(cookies)
-            page = browser.new_page()
-            page.goto(url)
-
-            while True:
-                page.wait_for_timeout(600)
-                if "/ap/maplanding" in page.url:
-                    response_url = page.url
-                    break
-
-            browser.close()
-        return response_url
-
-    message = f"""\
-        Please copy the following url and insert it into a web browser of your choice to log into Amazon.
-        Note: your browser will show you an error page (Page not found). This is expected.
-        
-        {url}
-
-        Once you have logged in, please insert the copied url.
-    """
-    click.echo(dedent(message))
-    return input()
 
-
-class Audible(Retailer):
-    _auth: audible.Authenticator = None
-    _client: audible.AsyncClient = None
+class Audible(Amazon):
 
     @property
     def name(self) -> str:
@@ -78,23 +17,9 @@ class Audible(Retailer):
     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,
-        runtime: datetime,
         semaphore: asyncio.Semaphore
     ) -> Book:
         title = target.title
@@ -114,27 +39,16 @@ class Audible(Retailer):
             for product in match.get("products", []):
                 if product["title"] != title:
                     continue
+                try:
+                    target.list_price = product["price"]["list_price"]["base"]
+                    target.current_price = product["price"]["lowest_price"]["base"]
+                    target.exists = True
+                    return target
+                except KeyError:
+                    continue
 
-                return Book(
-                    retailer=self.name,
-                    title=title,
-                    authors=authors,
-                    list_price=product["price"]["list_price"]["base"],
-                    current_price=product["price"]["lowest_price"]["base"],
-                    timepoint=runtime,
-                    format=BookFormat.AUDIOBOOK
-                )
-
-            return Book(
-                retailer=self.name,
-                title=title,
-                authors=authors,
-                list_price=0,
-                current_price=0,
-                timepoint=runtime,
-                format=BookFormat.AUDIOBOOK,
-                exists=False,
-            )
+            target.exists = False
+            return target
 
     async def get_wishlist(self, config: Config) -> list[Book]:
         wishlist_books = []

tbr_deal_finder/retailer/chirp.py

@@ -84,10 +84,9 @@ class Chirp(Retailer):
             json.dump(response, f)
 
     async def get_book(
-        self, target: Book, runtime: datetime, semaphore: asyncio.Semaphore
+        self, target: Book, semaphore: asyncio.Semaphore
     ) -> Book:
         title = target.title
-        authors = target.authors
         async with semaphore:
             async with aiohttp.ClientSession() as http_client:
                 response = await http_client.request(
@@ -103,16 +102,8 @@ class Chirp(Retailer):
 
             audiobooks = response_body["data"]["audiobooks"]["objects"]
             if not audiobooks:
-                return Book(
-                    retailer=self.name,
-                    title=title,
-                    authors=authors,
-                    list_price=0,
-                    current_price=0,
-                    timepoint=runtime,
-                    format=BookFormat.AUDIOBOOK,
-                    exists=False,
-                )
+                target.exists = False
+                return target
 
             for book in audiobooks:
                 if not book["currentProduct"]:
@@ -123,26 +114,12 @@ class Chirp(Retailer):
                     book["displayTitle"] == title
                     and is_matching_authors(target.normalized_authors, normalized_authors)
                 ):
-                    return Book(
-                        retailer=self.name,
-                        title=title,
-                        authors=authors,
-                        list_price=currency_to_float(book["currentProduct"]["listingPrice"]),
-                        current_price=currency_to_float(book["currentProduct"]["discountPrice"]),
-                        timepoint=runtime,
-                        format=BookFormat.AUDIOBOOK,
-                    )
+                    target.list_price = currency_to_float(book["currentProduct"]["listingPrice"])
+                    target.current_price = currency_to_float(book["currentProduct"]["discountPrice"])
+                    return target
 
-            return Book(
-                retailer=self.name,
-                title=title,
-                authors=target.authors,
-                list_price=0,
-                current_price=0,
-                timepoint=runtime,
-                format=BookFormat.AUDIOBOOK,
-                exists=False,
-            )
+            target.exists = False
+            return target
 
     async def get_wishlist(self, config: Config) -> list[Book]:
         wishlist_books = []

tbr_deal_finder/retailer/librofm.py

@@ -76,11 +76,11 @@ class LibroFM(Retailer):
                 "password": click.prompt("Libro FM Password", hide_input=True),
             }
         )
-        self.auth_token = response
+        self.auth_token = response["access_token"]
         with open(auth_path, "w") as f:
             json.dump(response, f)
 
-    async def get_book_isbn(self, book: Book, runtime: datetime, semaphore: asyncio.Semaphore) -> Book:
+    async def get_book_isbn(self, book: Book, semaphore: asyncio.Semaphore) -> Book:
         # runtime isn't used but get_book_isbn must follow the get_book method signature.
 
         title = book.title
@@ -109,24 +109,11 @@ class LibroFM(Retailer):
         return book
 
     async def get_book(
-        self, target: Book, runtime: datetime, semaphore: asyncio.Semaphore
+        self, target: Book, semaphore: asyncio.Semaphore
     ) -> Book:
-        if target.format == BookFormat.AUDIOBOOK and not target.audiobook_isbn:
-            # When "format" is AUDIOBOOK here that means the target was pulled from an audiobook retailer wishlist
-            # In this flow, there is no attempt to resolve the isbn ahead of time, so it's done here instead.
-            await self.get_book_isbn(target, runtime, semaphore)
-
         if not target.audiobook_isbn:
-            return Book(
-                retailer=self.name,
-                title=target.title,
-                authors=target.authors,
-                list_price=0,
-                current_price=0,
-                timepoint=runtime,
-                format=BookFormat.AUDIOBOOK,
-                exists=False,
-            )
+            target.exists = False
+            return target
 
         async with semaphore:
             response = await self.make_request(
@@ -135,26 +122,12 @@ class LibroFM(Retailer):
             )
 
         if response:
-            return Book(
-                retailer=self.name,
-                title=target.title,
-                authors=target.authors,
-                list_price=target.audiobook_list_price,
-                current_price=currency_to_float(response["data"]["purchase_info"]["price"]),
-                timepoint=runtime,
-                format=BookFormat.AUDIOBOOK,
-            )
+            target.list_price = target.audiobook_list_price
+            target.current_price = currency_to_float(response["data"]["purchase_info"]["price"])
+            return target
 
-        return Book(
-            retailer=self.name,
-            title=target.title,
-            authors=target.authors,
-            list_price=0,
-            current_price=0,
-            timepoint=runtime,
-            format=BookFormat.AUDIOBOOK,
-            exists=False,
-        )
+        target.exists = False
+        return target
 
     async def get_wishlist(self, config: Config) -> list[Book]:
         wishlist_books = []

tbr_deal_finder/retailer/models.py

@@ -1,6 +1,5 @@
 import abc
 import asyncio
-from datetime import datetime
 
 from tbr_deal_finder.book import Book, BookFormat
 from tbr_deal_finder.config import Config
@@ -29,7 +28,7 @@ class Retailer(abc.ABC):
         raise NotImplementedError
 
     async def get_book(
-            self, target: Book, runtime: datetime, semaphore: asyncio.Semaphore
+            self, target: Book, semaphore: asyncio.Semaphore
     ) -> Book:
         """Get book information from the retailer.
 

tbr_deal_finder/retailer_deal.py

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

tbr_deal_finder/tracked_books.py

@@ -1,19 +1,18 @@
 import asyncio
+import copy
 import csv
+from collections import defaultdict
+from typing import Callable, Awaitable, Optional
 
+import pandas as pd
 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.owned_books import get_owned_books
+from tbr_deal_finder.retailer import Chirp, RETAILER_MAP, LibroFM
 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
+from tbr_deal_finder.utils import execute_query, get_duckdb_conn
 
 
 def _library_export_tbr_books(config: Config, tbr_book_map: dict[str: Book]):
@@ -35,7 +34,7 @@ def _library_export_tbr_books(config: Config, tbr_book_map: dict[str: Book]):
                 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:
+                if key in tbr_book_map:
                     continue
 
                 tbr_book_map[key] = Book(
@@ -46,33 +45,9 @@ def _library_export_tbr_books(config: Config, tbr_book_map: dict[str: Book]):
                     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)
@@ -102,19 +77,244 @@ async def _retailer_wishlist(config: Config, tbr_book_map: dict[str: Book]):
 
             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_raw_tbr_books(config: Config) -> list[Book]:
+    """Gets books in any library export or tracked retailer wishlist
 
-async def get_tbr_books(config: Config) -> list[Book]:
-    tbr_book_map: dict[str: Book] = {}
+    Excludes books in the format they are owned.
+    Example: User owns Dungeon Crawler Carl Audiobook but it's on the user TBR.
+        Result - Deals will be tracked for the Dungeon Crawler Carl EBook (if tracking kindle deals)
+
+    :param config:
+    :return:
+    """
+
+    owned_books = await get_owned_books(config)
+    tracking_audiobooks = config.is_tracking_format(book_format=BookFormat.AUDIOBOOK)
+    tracking_ebooks = config.is_tracking_format(book_format=BookFormat.EBOOK)
 
+    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)
+    raw_tbr_books = list(tbr_book_map.values())
+
+    response: list[Book] = []
+
+    owned_book_title_map: dict[str, set] = defaultdict(set)
+    for book in owned_books:
+        owned_book_title_map[book.full_title_str].add(book.format)
+
+    for book in raw_tbr_books:
+        owned_formats = owned_book_title_map.get(book.full_title_str)
+        if not owned_formats:
+            response.append(book)
+        elif BookFormat.NA in owned_formats:
+            continue
+        elif tracking_audiobooks and BookFormat.AUDIOBOOK not in owned_formats:
+            book.format = BookFormat.AUDIOBOOK
+            response.append(book)
+        elif tracking_ebooks and BookFormat.EBOOK not in owned_formats:
+            book.format = BookFormat.EBOOK
+            response.append(book)
+
+    return response
+
+
+async def _set_tbr_book_attr(
+    tbr_books: list[Book],
+    target_attr: str,
+    get_book_callable: Callable[[Book, asyncio.Semaphore], Awaitable[Book]],
+    tbr_book_attr: Optional[str] = None
+):
+    if not tbr_books:
+        return
+
+    if not tbr_book_attr:
+        tbr_book_attr = target_attr
+
+    tbr_books_map = {b.full_title_str: b for b in tbr_books}
+    tbr_books_copy = copy.deepcopy(tbr_books)
+    semaphore = asyncio.Semaphore(5)
+    human_readable_name = target_attr.replace("_", " ").title()
+
+    # Get books with the appropriate transform applied
+    # Responsibility is on the callable here
+    enriched_books = await tqdm_asyncio.gather(
+        *[
+            get_book_callable(book, semaphore) for book in tbr_books_copy
+        ],
+        desc=f"Getting required {human_readable_name} info"
+    )
+    for enriched_book in enriched_books:
+        book = tbr_books_map[enriched_book.full_title_str]
+        setattr(
+            book,
+            tbr_book_attr,
+            getattr(enriched_book, target_attr)
+        )
+
+
+def _requires_audiobook_list_price(config: Config):
+    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_audiobook_list_price(config: Config, new_tbr_books: list[Book]):
+    """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(config):
+        return
+
+    chirp = Chirp()
+    relevant_tbr_books = [
+        book
+        for book in new_tbr_books
+        if book.format in [BookFormat.AUDIOBOOK, BookFormat.NA]
+    ]
+
+    await _set_tbr_book_attr(
+        relevant_tbr_books,
+        "list_price",
+        chirp.get_book,
+        "audiobook_list_price"
+    )
+
+
+async def _maybe_set_audiobook_isbn(config: Config, new_tbr_books: list[Book]):
+    """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.
+
+    """
+    if "Libro.FM" not in config.tracked_retailers:
+        return
+
+    libro_fm = LibroFM()
+    await libro_fm.set_auth()
+
+    relevant_tbr_books = [
+        book
+        for book in new_tbr_books
+        if book.format in [BookFormat.AUDIOBOOK, BookFormat.NA]
+    ]
+
+    await _set_tbr_book_attr(
+        relevant_tbr_books,
+        "audiobook_isbn",
+        libro_fm.get_book_isbn,
+    )
+
+
+def get_book_authors(book: dict) -> str:
+    if authors := book.get('Authors'):
+        return authors
+
+    authors = book['Author']
+    if additional_authors := book.get("Additional Authors"):
+        authors = f"{authors}, {additional_authors}"
+
+    return authors
+
+
+def get_book_title(book: dict) -> str:
+    title = book['Title']
+    return title.split("(")[0].strip()
+
+
+def is_tbr_book(book: dict) -> bool:
+    if "Read Status" in book:
+        return book["Read Status"] == "to-read"
+    elif "Bookshelves" in book:
+        return "to-read" in book["Bookshelves"]
+    else:
+        return True
 
-    return list(tbr_book_map.values())
 
+def reprocess_incomplete_tbr_books(config: Config):
+    db_conn = get_duckdb_conn()
+
+    if config.is_tracking_format(BookFormat.EBOOK):
+        # Replace any tbr_books missing required attr
+        db_conn.execute(
+            "DELETE FROM tbr_book WHERE ebook_asin IS NULL AND format != $book_format",
+            parameters=dict(book_format=BookFormat.AUDIOBOOK.value)
+        )
+
+    if LibroFM().name in config.tracked_retailers:
+        # Replace any tbr_books missing required attr
+        db_conn.execute(
+            "DELETE FROM tbr_book WHERE audiobook_isbn IS NULL AND format != $book_format",
+            parameters=dict(book_format=BookFormat.EBOOK.value)
+        )
+
+    if _requires_audiobook_list_price(config):
+        # Replace any tbr_books missing required attr
+        db_conn.execute(
+            "DELETE FROM tbr_book WHERE audiobook_list_price IS NULL AND format != $book_format",
+            parameters=dict(book_format=BookFormat.EBOOK.value)
+        )
+
+
+async def sync_tbr_books(config: Config):
+    raw_tbr_books = await _get_raw_tbr_books(config)
+    db_conn = get_duckdb_conn()
+
+    if not raw_tbr_books:
+        return
+
+    df = pd.DataFrame([book.tbr_dict() for book in raw_tbr_books])
+    db_conn.register("_df", df)
+    db_conn.execute("CREATE OR REPLACE TABLE _latest_tbr_book AS SELECT * FROM _df;")
+    db_conn.unregister("_df")
+
+    # Remove books no longer on user tbr
+    db_conn.execute(
+        "DELETE FROM tbr_book WHERE book_id NOT IN (SELECT book_id FROM _latest_tbr_book)"
+    )
+
+    # Remove books from _latest_tbr_book for further processing for books already in tbr_book
+    db_conn.execute(
+        "DELETE FROM _latest_tbr_book WHERE book_id IN (SELECT book_id FROM tbr_book)"
+    )
+
+    new_tbr_book_data = execute_query(
+        db_conn,
+        "SELECT * EXCLUDE(book_id) FROM _latest_tbr_book"
+    )
+
+    new_tbr_books = [Book(retailer="N/A", timepoint=config.run_time, **b) for b in new_tbr_book_data]
+    if not new_tbr_books:
+        return
+
+    await _maybe_set_audiobook_list_price(config, new_tbr_books)
+    await _maybe_set_audiobook_isbn(config, new_tbr_books)
+
+    df = pd.DataFrame([book.tbr_dict() for book in new_tbr_books])
+    db_conn.register("_df", df)
+    db_conn.execute("INSERT INTO tbr_book SELECT * FROM _df;")
+    db_conn.unregister("_df")
+
+
+async def get_tbr_books(config: Config) -> list[Book]:
+    await sync_tbr_books(config)
+
+    db_conn = get_duckdb_conn()
+    tbr_book_data = execute_query(
+        db_conn,
+        "SELECT * EXCLUDE(book_id) FROM tbr_book"
+    )
 
+    return [Book(retailer="N/A", timepoint=config.run_time, **b) for b in tbr_book_data]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tbr-deal-finder
-Version: 0.1.7
+Version: 0.1.8
 Summary: Track price drops and find deals on books in your TBR list across audiobook and ebook formats.
 License: MIT
 License-File: LICENSE
@@ -56,7 +56,7 @@ Track price drops and find deals on books in your TBR (To Be Read) and wishlist
 1. If it's not already on your computer, download Python https://www.python.org/downloads/
    1. tbr-deal-finder requires Python3.13 or higher
 2. Optional: Install and use virtualenv
-3. Open your Terminal/Commmand Prompt
+3. Open your Terminal/Command Prompt
 4. Run `pip3.13 install tbr-deal-finder`
 
 ### UV

tbr_deal_finder-0.1.8.dist-info/RECORD

@@ -0,0 +1,23 @@
+tbr_deal_finder/__init__.py,sha256=WCoj0GZrRiCQlrpkLTw1VUeJmX-RtBLdLqnFYn1Es_4,208
+tbr_deal_finder/book.py,sha256=MYdZ7WeSo9hWy9Af7T5U3-7zPgi5qdMPqlNtRYPMLck,5492
+tbr_deal_finder/cli.py,sha256=C4F2rbPrfYNqlmolx08ZHDCcFJuiPbkc4ECXUO25kmI,7446
+tbr_deal_finder/config.py,sha256=-TtZLv4kVBf56xPkgAdKXeVRV0qw8MZ53XHBQ1HnVX8,3978
+tbr_deal_finder/migrations.py,sha256=_ZxUXzGyEFYlPlpzMvViDVPZJc5BNOiixj150U8HRFc,4224
+tbr_deal_finder/owned_books.py,sha256=Cf1VeiSg7XBi_TXptJfy5sO1mEgMMQWbJ_P6SzAx0nQ,516
+tbr_deal_finder/retailer_deal.py,sha256=jv32WSOtxVxCkxTCLkOqSkcHGHhWfbD4nSxY42Cqk38,6422
+tbr_deal_finder/tracked_books.py,sha256=SOmygViADjr8fa3RiB4dn_bWjIpiAOBNQK37MHOu7nE,10407
+tbr_deal_finder/utils.py,sha256=_4wdGFDtqCdMyoMnwTDiHgCR4WQLAcQr8LlZZZUcq6E,1357
+tbr_deal_finder/queries/get_active_deals.sql,sha256=nh0F1lRV6YVrUV7gsQpjsgfXmN9R0peBeMHRifjgpUM,212
+tbr_deal_finder/queries/get_deals_found_at.sql,sha256=KqrtQk7FS4Hf74RyL1r-oD2D-RJz1urrxKxkwlvjAro,139
+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/amazon.py,sha256=-U28l3LmVCbOvK0SIXG6MAfYgoRUA--enNQJBxA_NHM,2322
+tbr_deal_finder/retailer/audible.py,sha256=1zM95teGth4UPyK5ZogLM9SIQxVd3kTgjTEiglnQKR8,3979
+tbr_deal_finder/retailer/chirp.py,sha256=s5aj3NwMA1GSymmTylnoWghQsqMp7hFcMdnoA1TRsv4,9241
+tbr_deal_finder/retailer/librofm.py,sha256=ARkUlxMS3OCgfKosX_XKVmMfLcIIDRPzqqmVp0V9IZA,6327
+tbr_deal_finder/retailer/models.py,sha256=I_U8VC5AOozGfPecW7FW8eRoTWEOxnMIHPNbuOJWcjw,1463
+tbr_deal_finder-0.1.8.dist-info/METADATA,sha256=4urAR2x-ABDN0OMscyowYP8Gqc_RXlVsYJoaRxpF7m8,4342
+tbr_deal_finder-0.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tbr_deal_finder-0.1.8.dist-info/entry_points.txt,sha256=y_KG1k8xVCY8gngSZ-na2bkK-tTLUdOc_qZ9Djwldv0,60
+tbr_deal_finder-0.1.8.dist-info/licenses/LICENSE,sha256=rNc0wNPn4d4HHu6ZheJzeUaz_FbJ4rj2Dr2FjAivkNg,1064
+tbr_deal_finder-0.1.8.dist-info/RECORD,,

tbr_deal_finder/library_exports.py

@@ -1,208 +0,0 @@
-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, get_full_title_str
-from tbr_deal_finder.config import Config
-from tbr_deal_finder.retailer import LibroFM, Chirp
-
-
-def get_book_authors(book: dict) -> str:
-    if authors := book.get('Authors'):
-        return authors
-
-    authors = book['Author']
-    if additional_authors := book.get("Additional Authors"):
-        authors = f"{authors}, {additional_authors}"
-
-    return authors
-
-
-def get_book_title(book: dict) -> str:
-    title = book['Title']
-    return title.split("(")[0].strip()
-
-
-def is_tbr_book(book: dict) -> bool:
-    if "Read Status" in book:
-        return book["Read Status"] == "to-read"
-    elif "Bookshelves" in book:
-        return "to-read" in book["Bookshelves"]
-    else:
-        return True
-
-
-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_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 not config.library_export_paths:
-        return
-
-    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):
-                    continue
-
-                title = get_book_title(book_dict)
-                authors = get_book_authors(book_dict)
-                key = get_full_title_str(title, authors)
-
-                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_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,
-                        authors=authors,
-                        list_price=0,
-                        current_price=0,
-                        timepoint=config.run_time,
-                        format=BookFormat.NA
-                    )
-
-    if not books_requiring_check_map:
-        # Everything was resolved, nothing else to do
-        return
-
-    semaphore = asyncio.Semaphore(5)
-    human_readable_name = attr_name.replace("_", " ").title()
-
-    # Get books with the appropriate transform applied
-    # Responsibility is on the callable here
-    enriched_books = await tqdm_asyncio.gather(
-        *[
-            get_book_callable(book, config.run_time, semaphore) for book in books_requiring_check_map.values()
-        ],
-        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 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) + [column_name]
-            file_content = [book_dict for book_dict in reader]
-            if not file_content or column_name in file_content[0]:
-                continue
-
-            with tempfile.NamedTemporaryFile(mode='w', delete=False, newline='') as temp_file:
-                temp_filename = temp_file.name
-                writer = csv.DictWriter(temp_file, fieldnames=field_names)
-                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 = 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:
-                            col_val = ""
-
-                        book_dict[column_name] = col_val
-                    else:
-                        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-0.1.7.dist-info/RECORD

@@ -1,23 +0,0 @@
-tbr_deal_finder/__init__.py,sha256=WCoj0GZrRiCQlrpkLTw1VUeJmX-RtBLdLqnFYn1Es_4,208
-tbr_deal_finder/book.py,sha256=JUhhDAV_vajhSyaD5begFvX_HPwEiZfojQ2x57qrf5M,4563
-tbr_deal_finder/cli.py,sha256=iwmbUxwqD6HtKppf2QlDMENFnYxTnPQWSK1WLUpyOW8,7357
-tbr_deal_finder/config.py,sha256=I69JruWIlnwxNiUMyOFq3K5sMmtXJKQxLKBU98DM008,3662
-tbr_deal_finder/library_exports.py,sha256=hs2_GE0HP78EQ8GL0Lmalq-ihSp88i1OL-3VLD0Djhk,7163
-tbr_deal_finder/migrations.py,sha256=6_WV55bm71UCFrcFrfJXlEX5uDrgnNTWZPq6vZTg18o,3733
-tbr_deal_finder/owned_books.py,sha256=Cf1VeiSg7XBi_TXptJfy5sO1mEgMMQWbJ_P6SzAx0nQ,516
-tbr_deal_finder/retailer_deal.py,sha256=UGVb8wxv98vEWy9wX6UM5ePhIa00xHPtzJCgngximHc,6949
-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=kgDNobu7uYV5IwReTDL_e0J731fMdOiJBipsno7Zv0A,6561
-tbr_deal_finder/retailer/chirp.py,sha256=8IaVVbUcY-bLV6cy4wKXhKmW2qJy6HksxxG1uLpqSeA,10063
-tbr_deal_finder/retailer/librofm.py,sha256=wN51UrDVaHb4XwoO0MY1_7ivhAE_BxoBWDavd7MpRxE,7413
-tbr_deal_finder/retailer/models.py,sha256=vomL99LDP_52r61W1CBE34yxAWteD_QE5NeqSATgnAE,1512
-tbr_deal_finder-0.1.7.dist-info/METADATA,sha256=nYxkGPCh7SOIg6RRktVidC7YpPfoxaWT6jZJ0JmpR_E,4343
-tbr_deal_finder-0.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tbr_deal_finder-0.1.7.dist-info/entry_points.txt,sha256=y_KG1k8xVCY8gngSZ-na2bkK-tTLUdOc_qZ9Djwldv0,60
-tbr_deal_finder-0.1.7.dist-info/licenses/LICENSE,sha256=rNc0wNPn4d4HHu6ZheJzeUaz_FbJ4rj2Dr2FjAivkNg,1064
-tbr_deal_finder-0.1.7.dist-info/RECORD,,