tbr-deal-finder 0.1.0__py3-none-any.whl

tbr_deal_finder/migrations.py

@@ -0,0 +1,125 @@
+from dataclasses import dataclass
+from typing import List, Dict
+from collections import defaultdict
+
+import click
+import duckdb
+
+from tbr_deal_finder.utils import get_duckdb_conn
+
+
+@dataclass
+class TableMigration:
+    version: int
+    table_name: str
+    sql: str
+
+
+_MIGRATIONS = [
+    TableMigration(
+        version=1,
+        table_name="retailer_deal",
+        sql="""
+            CREATE TABLE retailer_deal
+            (
+                retailer          VARCHAR,
+                title           VARCHAR,
+                authors         VARCHAR,
+                list_price      FLOAT,
+                current_price   FLOAT,
+                timepoint       TIMESTAMP_NS,
+                format          VARCHAR,
+                deleted         BOOLEAN,
+                deal_id         VARCHAR
+            );
+            """
+    ),
+    TableMigration(
+        version=1,
+        table_name="latest_deal_run_history",
+        sql="""
+            CREATE TABLE latest_deal_run_history
+            (
+                timepoint           TIMESTAMP_NS,
+                ran_successfully    BOOLEAN,
+                details             VARCHAR
+            );
+            """
+    ),
+]
+
+
+def apply_migration(migration: TableMigration, cursor: duckdb.DuckDBPyConnection) -> None:
+    """Apply a single migration to the database."""
+    click.echo(
+        f"Applying migration - version: {migration.version}, table: {migration.table_name}"
+    )
+
+    try:
+        # Execute the migration SQL
+        cursor.execute(migration.sql)
+
+        # Update schema_versions table
+        cursor.execute("""
+                       INSERT INTO schema_versions (table_name, version)
+                       VALUES (?, ?) ON CONFLICT(table_name) DO
+                       UPDATE SET version = EXCLUDED.version
+                       """, (migration.table_name, migration.version))
+
+        click.echo(
+            f"Migration applied successfully - version: {migration.version}, table: {migration.table_name}"
+        )
+
+    except duckdb.Error as e:
+        raise RuntimeError(
+            f"Failed to apply migration {migration.version} to {migration.table_name}: {e}"
+        )
+
+
+def make_migrations():
+    db_conn = get_duckdb_conn()
+
+    try:
+        # Create schema_versions table if it doesn't exist
+        db_conn.execute("""
+        CREATE TABLE IF NOT EXISTS schema_versions
+        (
+          table_name
+          VARCHAR
+          PRIMARY
+          KEY,
+          version
+          INTEGER
+        );
+        """)
+
+        # Group migrations by table name
+        table_migration_map: Dict[str, List[TableMigration]] = defaultdict(list)
+        for migration in _MIGRATIONS:
+            table_migration_map[migration.table_name].append(migration)
+
+        # Begin transaction
+        with db_conn:
+            cursor = db_conn.cursor()
+
+            for table_name, table_migrations in table_migration_map.items():
+                # Sort migrations by version
+                table_migrations.sort(key=lambda m: m.version)
+
+                # Get current version for this table
+                cursor.execute("""
+                               SELECT COALESCE(MAX(version), 0)
+                               FROM schema_versions
+                               WHERE table_name = ?
+                               """, (table_name,))
+
+                result = cursor.fetchone()
+                current_version = result[0] if result else 0
+
+                # Apply pending migrations
+                for migration in table_migrations:
+                    if migration.version > current_version:
+                        apply_migration(migration, cursor)
+
+    except duckdb.Error as e:
+        raise RuntimeError(f"Failed to apply migrations: {e}")

tbr_deal_finder/queries/get_active_deals.sql

@@ -0,0 +1,4 @@
+SELECT *
+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

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

tbr_deal_finder/queries/latest_deal_last_ran_most_recent_success.sql

@@ -0,0 +1,5 @@
+SELECT timepoint
+FROM latest_deal_run_history
+WHERE ran_successfully = TRUE
+ORDER BY timepoint DESC
+LIMIT 1

tbr_deal_finder/retailer/__init__.py

@@ -0,0 +1,9 @@
+from tbr_deal_finder.retailer.audible import Audible
+from tbr_deal_finder.retailer.chirp import Chirp
+from tbr_deal_finder.retailer.librofm import LibroFM
+
+RETAILER_MAP = {
+    "Audible": Audible,
+    "Chirp": Chirp,
+    "Libro.FM": LibroFM,
+}

tbr_deal_finder/retailer/audible.py

@@ -0,0 +1,115 @@
+import asyncio
+import os.path
+from datetime import datetime
+from textwrap import dedent
+import readline  # type: ignore
+
+
+import audible
+import click
+from audible.login import playwright_external_login_url_callback
+
+from tbr_deal_finder import TBR_DEALS_PATH
+from tbr_deal_finder.config import Config
+from tbr_deal_finder.retailer.models import Retailer
+from tbr_deal_finder.book import Book, BookFormat
+
+_AUTH_PATH = TBR_DEALS_PATH.joinpath("audible.json")
+
+
+def login_url_callback(url: str) -> str:
+    """Helper function for login with external browsers."""
+    try:
+        return playwright_external_login_url_callback(url)
+    except ImportError:
+        pass
+
+    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
+
+    @property
+    def name(self) -> str:
+        return "Audible"
+
+    async def get_book(
+        self,
+        target: Book,
+        runtime: datetime,
+        semaphore: asyncio.Semaphore
+    ) -> Book:
+        title = target.title
+        authors = target.authors
+
+        async with semaphore:
+            match = await self._client.get(
+                "1.0/catalog/products",
+                num_results=50,
+                author=authors,
+                title=title,
+                response_groups=[
+                    "contributors, media, price, product_attrs, product_desc, product_extended_attrs, product_plan_details, product_plans"
+                ]
+            )
+
+            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"]:
+                if product["title"] != title:
+                    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,
+            )
+
+    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/chirp.py

@@ -0,0 +1,79 @@
+import asyncio
+from datetime import datetime
+
+import aiohttp
+
+from tbr_deal_finder.retailer.models import Retailer
+from tbr_deal_finder.book import Book, BookFormat, get_normalized_authors
+from tbr_deal_finder.utils import currency_to_float
+
+
+class Chirp(Retailer):
+    # Static because url for other locales just redirects to .com
+    _url: str = "https://www.chirpbooks.com/api/graphql"
+
+    @property
+    def name(self) -> str:
+        return "Chirp"
+
+    async def get_book(
+        self, target: Book, runtime: datetime, semaphore: asyncio.Semaphore
+    ) -> Book:
+        title = target.title
+        authors = target.authors
+
+        async with aiohttp.ClientSession() as http_client:
+            response = await http_client.request(
+                "POST",
+                self._url,
+                json={
+                    "query": "fragment audiobookFields on Audiobook{id averageRating coverUrl displayAuthors displayTitle ratingsCount url allAuthors{name slug url}} fragment audiobookWithShoppingCartAndUserAudiobookFields on Audiobook{...audiobookFields currentUserShoppingCartItem{id}currentUserWishlistItem{id}currentUserUserAudiobook{id}currentUserHasAuthorFollow{id}} fragment productFields on Product{discountPrice id isFreeListing listingPrice purchaseUrl savingsPercent showListingPrice timeLeft bannerType} query AudiobookSearch($query:String!,$promotionFilter:String,$filter:String,$page:Int,$pageSize:Int){audiobooks(query:$query,promotionFilter:$promotionFilter,filter:$filter,page:$page,pageSize:$pageSize){totalCount objects(page:$page,pageSize:$pageSize){... on Audiobook{...audiobookWithShoppingCartAndUserAudiobookFields futureSaleDate currentProduct{...productFields}}}}}",
+                    "variables": {"query": title, "filter": "all", "page": 1, "promotionFilter": "default"},
+                    "operationName": "AudiobookSearch"
+                }
+            )
+            response_body = await response.json()
+            audiobooks = response_body["data"]["audiobooks"]["objects"]
+            if not audiobooks:
+                return Book(
+                    retailer=self.name,
+                    title=title,
+                    authors=authors,
+                    list_price=0,
+                    current_price=0,
+                    timepoint=runtime,
+                    format=BookFormat.AUDIOBOOK,
+                    exists=False,
+                )
+
+            for book in audiobooks:
+                if not book["currentProduct"]:
+                    continue
+
+                if (
+                    book["displayTitle"] == title
+                    and get_normalized_authors(book["displayAuthors"]) == target.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,
+                    )
+
+            return Book(
+                retailer=self.name,
+                title=title,
+                authors=target.authors,
+                list_price=0,
+                current_price=0,
+                timepoint=runtime,
+                format=BookFormat.AUDIOBOOK,
+                exists=False,
+            )
+
+    async def set_auth(self):
+        return

tbr_deal_finder/retailer/librofm.py

@@ -0,0 +1,136 @@
+import asyncio
+import json
+import os
+import urllib.parse
+from datetime import datetime, timedelta
+from typing import Union
+
+import aiohttp
+import click
+
+from tbr_deal_finder import TBR_DEALS_PATH
+from tbr_deal_finder.retailer.models import Retailer
+from tbr_deal_finder.book import Book, BookFormat, get_normalized_authors
+from tbr_deal_finder.utils import currency_to_float
+
+
+class LibroFM(Retailer):
+    BASE_URL = "https://libro.fm"
+    USER_AGENT = "okhttp/3.14.9"
+    USER_AGENT_DOWNLOAD = (
+        "AndroidDownloadManager/11 (Linux; U; Android 11; "
+        "Android SDK built for x86_64 Build/RSR1.210722.013.A2)"
+    )
+    CLIENT_VERSION = (
+        "Android: Libro.fm 7.6.1 Build: 194 Device: Android SDK built for x86_64 "
+        "(unknown sdk_phone_x86_64) AndroidOS: 11 SDK: 30"
+    )
+
+    def __init__(self):
+        self.auth_token = None
+
+    @property
+    def name(self) -> str:
+        return "Libro.FM"
+
+    async def make_request(self, url_path: str, request_type: str, **kwargs) -> dict:
+        url = urllib.parse.urljoin(self.BASE_URL, url_path)
+        headers = kwargs.pop("headers", {})
+        headers["User-Agent"] = self.USER_AGENT
+        headers["authorization"] = f"Bearer {self.auth_token}"
+
+        async with aiohttp.ClientSession() as http_client:
+            response = await http_client.request(
+                request_type.upper(),
+                url,
+                headers=headers,
+                **kwargs
+            )
+            if response.ok:
+                return await response.json()
+            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:
+                auth_info = json.load(f)
+                token_created_at = datetime.fromtimestamp(auth_info["created_at"])
+                max_token_age = datetime.now() - timedelta(days=5)
+                if token_created_at > max_token_age:
+                    self.auth_token = auth_info["access_token"]
+                    return
+
+        response = await self.make_request(
+            "/oauth/token",
+            "POST",
+            json={
+                "grant_type": "password",
+                "username": click.prompt("Libro FM Username"),
+                "password": click.prompt("Libro FM Password", hide_input=True),
+            }
+        )
+        self.auth_token = response
+        with open(auth_path, "w") as f:
+            json.dump(response, f)
+
+    async def get_book_isbn(self, book: Book, semaphore: asyncio.Semaphore) -> Union[str, None]:
+        title = book.title
+        response = await self.make_request(
+            f"api/v10/explore/search",
+            "GET",
+            params={
+                "q": title,
+                "searchby": "titles",
+                "sortby": "relevance#results",
+            },
+        )
+
+        for b in response["audiobook_collection"]["audiobooks"]:
+            if title == b["title"] and book.normalized_authors == get_normalized_authors(b["authors"]):
+                book.audiobook_isbn = b["isbn"]
+                return book.audiobook_isbn
+
+        return None
+
+    async def get_book(
+        self, target: Book, runtime: datetime, semaphore: asyncio.Semaphore
+    ) -> Book:
+        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,
+            )
+        response = await self.make_request(
+            f"api/v10/explore/audiobook_details/{target.audiobook_isbn}",
+            "GET"
+        )
+
+        if response:
+            return Book(
+                retailer=self.name,
+                title=target.title,
+                authors=target.authors,
+                list_price=0,
+                current_price=currency_to_float(response["data"]["purchase_info"]["price"]),
+                timepoint=runtime,
+                format=BookFormat.AUDIOBOOK,
+            )
+
+        return Book(
+            retailer=self.name,
+            title=target.title,
+            authors=target.authors,
+            list_price=0,
+            current_price=0,
+            timepoint=runtime,
+            format=BookFormat.AUDIOBOOK,
+            exists=False,
+        )

tbr_deal_finder/retailer/models.py

@@ -0,0 +1,37 @@
+import abc
+import asyncio
+from datetime import datetime
+
+from tbr_deal_finder.book import Book
+
+
+class Retailer(abc.ABC):
+    """Abstract base class for retailers."""
+
+    @property
+    def name(self) -> str:
+        raise NotImplementedError
+
+    async def get_book(
+            self, target: Book, runtime: datetime, semaphore: asyncio.Semaphore
+    ) -> Book:
+        """Get book information from the retailer.
+
+        - Uses Audible's product API to fetch book details
+        - Respects rate limiting through the provided semaphore
+        - Returns a Book with exists=False if the book is not found
+
+        Args:
+            target: Book object containing search criteria
+            runtime: Timestamp for when the search was initiated
+            semaphore: Semaphore to control concurrent requests
+
+        Returns:
+            Book: Updated book object with pricing and availability
+            """
+        raise NotImplementedError
+
+    async def set_auth(self):
+        raise NotImplementedError
+
+