tbr-deal-finder 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

tbr_deal_finder/retailer/kindle.py

@@ -1,6 +1,6 @@
 import asyncio
 import json
-import readline  # type: ignore
+from typing import Union
 
 from tbr_deal_finder.config import Config
 from tbr_deal_finder.retailer.amazon import Amazon, AUTH_PATH
@@ -20,6 +20,10 @@ class Kindle(Amazon):
     def format(self) -> BookFormat:
         return BookFormat.EBOOK
 
+    @property
+    def max_concurrency(self) -> int:
+        return 3
+
     def _get_base_url(self) -> str:
         return f"https://www.amazon.{self._auth.locale.domain}"
 
@@ -73,7 +77,7 @@ class Kindle(Amazon):
         self,
         target: Book,
         semaphore: asyncio.Semaphore
-    ) -> Book:
+    ) -> Union[Book, None]:
         target.exists = False
 
         if not target.ebook_asin:
@@ -81,26 +85,34 @@ class Kindle(Amazon):
 
         asin = target.ebook_asin
         async with semaphore:
-            match = await self._client.get(
-                f"{self._get_base_url()}/api/bifrost/offers/batch/v1/{asin}?ref_=KindleDeepLinkOffers",
-                headers={"x-client-id": "kindle-android-deeplink"},
-            )
-            products = match.get("resources", [])
-            if not products:
-                return target
+            for i in range(10):
+                match = await self._client.get(
+                    f"{self._get_base_url()}/api/bifrost/offers/batch/v1/{asin}?ref_=KindleDeepLinkOffers",
+                    headers={"x-client-id": "kindle-android-deeplink"},
+                )
+                products = match.get("resources", [])
+                if not products:
+                    await asyncio.sleep(1)
+                    continue
 
-            actions = products[0].get("personalizedActionOutput", {}).get("personalizedActions", [])
-            if not actions:
-                return target
+                actions = products[0].get("personalizedActionOutput", {}).get("personalizedActions", [])
+                if not actions:
+                    await asyncio.sleep(1)
+                    continue
 
-            for action in actions:
-                if "printListPrice" in action["offer"]:
-                    target.list_price = action["offer"]["printListPrice"]["value"]
-                    target.current_price = action["offer"]["digitalPrice"]["value"]
-                    target.exists = True
-                    break
+                for action in actions:
+                    if "printListPrice" in action["offer"]:
+                        target.list_price = action["offer"]["printListPrice"]["value"]
+                        target.current_price = action["offer"]["digitalPrice"]["value"]
+                        target.exists = True
+                        break
 
-            return target
+                # The sleep is a pre-emptive backoff
+                # Concurrency is already low, but this endpoint loves to throttle
+                await asyncio.sleep(.25)
+                return target
+
+            return None
 
     async def get_wishlist(self, config: Config) -> list[Book]:
         """Not currently supported

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 click
 
-from tbr_deal_finder import TBR_DEALS_PATH
 from tbr_deal_finder.config import Config
-from tbr_deal_finder.retailer.models import AioHttpSession, Retailer
+from tbr_deal_finder.retailer.models import AioHttpSession, Retailer, GuiAuthContext
 from tbr_deal_finder.book import Book, BookFormat, get_normalized_authors, is_matching_authors, get_normalized_title
 from tbr_deal_finder.utils import currency_to_float, echo_err
 
@@ -57,16 +57,21 @@ class LibroFM(AioHttpSession, Retailer):
         else:
             return {}
 
-    async def set_auth(self):
-        auth_path = TBR_DEALS_PATH.joinpath("libro_fm.json")
-        if os.path.exists(auth_path):
-            with open(auth_path, "r") as f:
+    def user_is_authed(self) -> bool:
+        if os.path.exists(self.auth_path):
+            with open(self.auth_path, "r") as f:
                 auth_info = json.load(f)
                 token_created_at = datetime.fromtimestamp(auth_info["created_at"])
-                max_token_age = datetime.now() - timedelta(days=5)
+                max_token_age = datetime.now() - timedelta(days=7)
                 if token_created_at > max_token_age:
                     self.auth_token = auth_info["access_token"]
-                    return
+                    return True
+
+        return False
+
+    async def set_auth(self):
+        if self.user_is_authed():
+            return
 
         response = await self.make_request(
             "/oauth/token",
@@ -82,9 +87,37 @@ class LibroFM(AioHttpSession, Retailer):
             await self.set_auth()
 
         self.auth_token = response["access_token"]
-        with open(auth_path, "w") as f:
+        with open(self.auth_path, "w") as f:
             json.dump(response, f)
 
+    @property
+    def gui_auth_context(self) -> GuiAuthContext:
+        return GuiAuthContext(
+            title="Login to Libro.FM",
+            fields=[
+                {"name": "username", "label": "Username", "type": "text"},
+                {"name": "password", "label": "Password", "type": "password"}
+            ]
+        )
+
+    async def gui_auth(self, form_data: dict) -> bool:
+        response = await self.make_request(
+            "/oauth/token",
+            "POST",
+            json={
+                "grant_type": "password",
+                "username": form_data["username"],
+                "password": form_data["password"],
+            }
+        )
+        if "access_token" not in response:
+            return False
+
+        self.auth_token = response["access_token"]
+        with open(self.auth_path, "w") as f:
+            json.dump(response, f)
+        return True
+
     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.
 
@@ -115,24 +148,24 @@ class LibroFM(AioHttpSession, Retailer):
 
     async def get_book(
         self, target: Book, semaphore: asyncio.Semaphore
-    ) -> Book:
+    ) -> Union[Book, None]:
         if not target.audiobook_isbn:
             target.exists = False
             return target
 
         async with semaphore:
-            response = await self.make_request(
-                f"api/v10/explore/audiobook_details/{target.audiobook_isbn}",
-                "GET"
-            )
+            for _ in range(10):
+                response = await self.make_request(
+                    f"api/v10/explore/audiobook_details/{target.audiobook_isbn}",
+                    "GET"
+                )
 
-        if response:
-            target.list_price = target.audiobook_list_price
-            target.current_price = currency_to_float(response["data"]["purchase_info"]["price"])
-            return target
+                if response:
+                    target.list_price = target.audiobook_list_price
+                    target.current_price = currency_to_float(response["data"]["purchase_info"]["price"])
+                    return target
 
-        target.exists = False
-        return target
+        return None
 
     async def get_wishlist(self, config: Config) -> list[Book]:
         wishlist_books = []

tbr_deal_finder/retailer/models.py

@@ -1,10 +1,23 @@
 import abc
 import asyncio
+import dataclasses
+from pathlib import Path
+from typing import Optional, Union
 
 import aiohttp
 
 from tbr_deal_finder.book import Book, BookFormat
 from tbr_deal_finder.config import Config
+from tbr_deal_finder.utils import get_data_dir
+
+
+@dataclasses.dataclass
+class GuiAuthContext:
+    title: str
+    fields: list[dict]
+    message: Optional[str] = None
+    user_copy_context: Optional[str] = None
+    pop_up_type: Optional[str] = "form"
 
 
 class Retailer(abc.ABC):
@@ -26,12 +39,29 @@ class Retailer(abc.ABC):
         """
         raise NotImplementedError
 
+    @property
+    def auth_path(self) -> Path:
+        name = self.name.replace(".", "").lower()
+        return get_data_dir().joinpath(f"{name}.json")
+
+    @property
+    def gui_auth_context(self) -> GuiAuthContext:
+        raise NotImplementedError
+
+    @property
+    def max_concurrency(self) -> int:
+        # The max number of simultaneous requests to send to this retailer
+        return 10
+
     async def set_auth(self):
         raise NotImplementedError
 
+    async def gui_auth(self, form_data: dict) -> bool:
+        raise NotImplementedError
+
     async def get_book(
             self, target: Book, semaphore: asyncio.Semaphore
-    ) -> Book:
+    ) -> Union[Book, None]:
         """Get book information from the retailer.
 
         - Uses Audible's product API to fetch book details

tbr_deal_finder/retailer_deal.py

@@ -11,7 +11,7 @@ from tbr_deal_finder.config import Config
 from tbr_deal_finder.tracked_books import get_tbr_books, get_unknown_books, set_unknown_books
 from tbr_deal_finder.retailer import RETAILER_MAP
 from tbr_deal_finder.retailer.models import Retailer
-from tbr_deal_finder.utils import get_duckdb_conn, echo_warning, echo_info
+from tbr_deal_finder.utils import get_duckdb_conn, echo_info, echo_err, is_gui_env
 
 
 def update_retailer_deal_table(config: Config, new_deals: list[Book]):
@@ -38,14 +38,6 @@ def update_retailer_deal_table(config: Config, new_deals: list[Book]):
         else:
             df_data.append(deal.dict())
 
-    # Any remaining values in active_deal_map mean that
-    # it wasn't found and should be marked for deletion
-    for deal in active_deal_map.values():
-        echo_warning(f"{str(deal)} is no longer active\n")
-        deal.timepoint = config.run_time
-        deal.deleted = True
-        df_data.append(deal.dict())
-
     if df_data:
         df = pd.DataFrame(df_data)
 
@@ -75,7 +67,7 @@ async def _get_books(
     Returns:
         List of Book objects with updated pricing and availability
     """
-    semaphore = asyncio.Semaphore(10)
+    semaphore = asyncio.Semaphore(retailer.max_concurrency)
     response = []
     unknown_books = []
     books = [copy.deepcopy(book) for book in books]
@@ -88,9 +80,21 @@ async def _get_books(
         for book in books
         if book.deal_id not in ignored_deal_ids
     ]
-    results = await tqdm_asyncio.gather(*tasks, desc=f"Getting latest prices from {retailer.name}")
+
+    if is_gui_env():
+        results = await asyncio.gather(*tasks)
+    else:
+        results = await tqdm_asyncio.gather(*tasks, desc=f"Getting latest prices from {retailer.name}")
+
     for book in results:
-        if book.exists:
+        if not book:
+            """Cases where we know the retailer has the book but it's not coming back.
+            We don't want to mark it as unknown it's more like we just got rate limited.
+
+            Kindle has been particularly bad about this. 
+            """
+            continue
+        elif book.exists:
             response.append(book)
         elif not book.exists:
             unknown_books.append(book)
@@ -157,7 +161,7 @@ def _get_retailer_relevant_tbr_books(
     return response
 
 
-async def get_latest_deals(config: Config):
+async def _get_latest_deals(config: Config):
     """
     Fetches the latest book deals from all tracked retailers for the user's TBR list.
 
@@ -206,8 +210,28 @@ async def get_latest_deals(config: Config):
     books = [
         book
         for book in books
-        if book.current_price <= config.max_price and book.discount() >= config.min_discount
     ]
 
     update_retailer_deal_table(config, books)
     set_unknown_books(config, unknown_books)
+
+
+async def get_latest_deals(config: Config) -> bool:
+    try:
+        await _get_latest_deals(config)
+    except Exception as e:
+        ran_successfully = False
+        details = f"Error getting deals: {e}"
+        echo_err(details)
+    else:
+        ran_successfully = True
+        details = ""
+
+    # Save execution results
+    db_conn = get_duckdb_conn()
+    db_conn.execute(
+        "INSERT INTO latest_deal_run_history (timepoint, ran_successfully, details) VALUES (?, ?, ?)",
+        [config.run_time, ran_successfully, details]
+    )
+
+    return ran_successfully

tbr_deal_finder/tracked_books.py

@@ -14,7 +14,7 @@ from tbr_deal_finder.owned_books import get_owned_books
 from tbr_deal_finder.retailer import Chirp, RETAILER_MAP, LibroFM, Kindle
 from tbr_deal_finder.config import Config
 from tbr_deal_finder.retailer.models import Retailer
-from tbr_deal_finder.utils import execute_query, get_duckdb_conn, get_query_by_name
+from tbr_deal_finder.utils import execute_query, get_duckdb_conn, get_query_by_name, is_gui_env
 
 
 def _library_export_tbr_books(config: Config, tbr_book_map: dict[str: Book]):
@@ -139,16 +139,20 @@ async def _set_tbr_book_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"
-    )
+    tasks = [
+        get_book_callable(book, semaphore) for book in tbr_books_copy
+    ]
+    if is_gui_env():
+        enriched_books = await asyncio.gather(*tasks)
+    else:
+        human_readable_name = target_attr.replace("_", " ").title()
+        enriched_books = await tqdm_asyncio.gather(
+            *tasks,
+            desc=f"Getting required {human_readable_name} info"
+        )
     for enriched_book in enriched_books:
         book = tbr_books_map[enriched_book.full_title_str]
         setattr(
@@ -241,20 +245,22 @@ def clear_unknown_books():
 
 
 def set_unknown_books(config: Config, unknown_books: list[Book]):
-    if not unknown_books_requires_sync():
+    if (not unknown_books_requires_sync()) and (not unknown_books):
         return
 
     db_conn = get_duckdb_conn()
-    db_conn.execute(
-        "INSERT INTO unknown_book_run_history (timepoint, ran_successfully, details) VALUES (?, ?, ?)",
-        [config.run_time, True, ""]
-    )
 
-    db_conn.execute(
-        "DELETE FROM unknown_book"
-    )
-    if not unknown_books:
-        return
+    if unknown_books_requires_sync():
+        db_conn.execute(
+            "INSERT INTO unknown_book_run_history (timepoint, ran_successfully, details) VALUES (?, ?, ?)",
+            [config.run_time, True, ""]
+        )
+
+        db_conn.execute(
+            "DELETE FROM unknown_book"
+        )
+        if not unknown_books:
+            return
 
     df = pd.DataFrame([book.unknown_book_dict() for book in unknown_books])
     db_conn = get_duckdb_conn()

tbr_deal_finder/utils.py

@@ -1,12 +1,56 @@
+import datetime
+import functools
+import os
 import re
+import sys
+from pathlib import Path
 from typing import Optional
 
 import click
 import duckdb
 
-from tbr_deal_finder import TBR_DEALS_PATH, QUERY_PATH
+from tbr_deal_finder import QUERY_PATH
 
 
+@functools.cache
+def is_gui_env() -> bool:
+    return os.environ.get("ENTRYPOINT", "GUI") == "GUI"
+
+
+@functools.cache
+def get_data_dir() -> Path:
+    """
+    Get the appropriate user data directory for each platform
+    following OS conventions
+    """
+    app_author = "WillNye"
+    app_name = "TBR Deal Finder"
+
+    if custom_path := os.getenv("TBR_DEAL_FINDER_CUSTOM_PATH"):
+        path = Path(custom_path)
+
+    elif not is_gui_env():
+        path = Path.home() / ".tbr_deal_finder"
+
+    elif sys.platform == "win32":
+        # Windows: C:\Users\Username\AppData\Local\AppAuthor\AppName
+        base = os.environ.get("LOCALAPPDATA", os.path.expanduser("~\\AppData\\Local"))
+        path = Path(base) / app_author / app_name
+
+    elif sys.platform == "darwin":
+        # macOS: ~/Library/Application Support/AppName
+        path = Path.home() / "Library" / "Application Support" / app_name
+
+    else:  # Linux and others
+        # Linux: ~/.local/share/appname (following XDG spec)
+        xdg_data_home = os.environ.get("XDG_DATA_HOME",
+                                       os.path.expanduser("~/.local/share"))
+        path = Path(xdg_data_home) / app_name.lower()
+
+    # Create directory if it doesn't exist
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
 def currency_to_float(price_str):
     """Parse various price formats to float."""
     if not price_str:
@@ -21,8 +65,13 @@ def currency_to_float(price_str):
         return 0.0
 
 
+def float_to_currency(val: float) -> str:
+    from tbr_deal_finder.config import Config
+    return f"{Config.currency_symbol()}{val:.2f}"
+
+
 def get_duckdb_conn():
-    return duckdb.connect(TBR_DEALS_PATH.joinpath("tbr_deal_finder.db"))
+    return duckdb.connect(get_data_dir().joinpath("tbr_deal_finder.db"))
 
 
 def execute_query(
@@ -37,6 +86,19 @@ def execute_query(
     return [dict(zip(column_names, row)) for row in rows]
 
 
+def get_latest_deal_last_ran(
+    db_conn: duckdb.DuckDBPyConnection
+) -> Optional[datetime.datetime]:
+
+    results = execute_query(
+        db_conn,
+        QUERY_PATH.joinpath("latest_deal_last_ran_most_recent_success.sql").read_text(),
+    )
+    if not results:
+        return None
+    return results[0]["timepoint"]
+
+
 def get_query_by_name(file_name: str) -> str:
     return QUERY_PATH.joinpath(file_name).read_text()
 

tbr_deal_finder/version_check.py

@@ -0,0 +1,40 @@
+import requests
+from packaging import version
+import warnings
+from tbr_deal_finder import __VERSION__
+
+_PACKAGE_NAME = "tbr-deal-finder"
+
+def check_for_updates():
+    """Check if a newer version is available on PyPI."""
+    current_version = __VERSION__
+
+    try:
+        response = requests.get(
+            f"https://pypi.org/pypi/{_PACKAGE_NAME}/json",
+            timeout=2  # Don't hang if PyPI is slow
+        )
+        response.raise_for_status()
+
+        latest_version = response.json()["info"]["version"]
+
+        if version.parse(latest_version) > version.parse(current_version):
+            return latest_version
+        return None
+
+    except Exception:
+        # Silently fail - don't break user's code over version check
+        return None
+
+
+def notify_if_outdated():
+    """Show a warning if package is outdated."""
+    latest = check_for_updates()
+    if latest:
+        warnings.warn(
+            f"A new version of {_PACKAGE_NAME} is available ({latest}). "
+            f"You have {__VERSION__}. Consider upgrading:\n"
+            f"pip install --upgrade {_PACKAGE_NAME}\nOr if you're running using uv:\ngit checkout main && git pull",
+            UserWarning,
+            stacklevel=2
+        )