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

tbr_deal_finder/__init__.py

@@ -0,0 +1,9 @@
+import os
+from pathlib import Path
+
+__VERSION__ = "0.1.0"
+
+QUERY_PATH = Path(__file__).parent.joinpath("queries")
+
+TBR_DEALS_PATH = Path.home() / ".tbr_deal_finder"
+os.makedirs(TBR_DEALS_PATH, exist_ok=True)

tbr_deal_finder/book.py

@@ -0,0 +1,116 @@
+import dataclasses
+import re
+from datetime import datetime
+from enum import Enum
+from typing import Optional, Union
+
+import click
+from unidecode import unidecode
+
+from tbr_deal_finder.config import Config
+from tbr_deal_finder.utils import get_duckdb_conn, execute_query, get_query_by_name
+
+_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]
+    audiobook_isbn: str = None
+
+    deleted: bool = False
+
+    deal_id: Optional[str] = None
+    exists: bool = True
+    normalized_authors: list[str] = None
+
+    def __post_init__(self):
+        if not self.deal_id:
+            self.deal_id = f"{self.title}__{self.normalized_authors}__{self.retailer}__{self.format}"
+
+        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)
+
+    @staticmethod
+    def price_to_string(price: float) -> str:
+        return f"{Config.currency_symbol()}{price:.2f}"
+
+    @property
+    def title_id(self) -> str:
+        return f"{self.title}__{self.normalized_authors}__{self.format}"
+
+    def list_price_string(self):
+        return self.price_to_string(self.list_price)
+
+    def current_price_string(self):
+        return self.price_to_string(self.current_price)
+
+    def __str__(self) -> str:
+        price = self.current_price_string()
+        book_format = self.format.value
+        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}"
+
+    def dict(self):
+        response = dataclasses.asdict(self)
+        response["format"] = self.format.value
+        del response["audiobook_isbn"]
+        del response["exists"]
+        del response["normalized_authors"]
+
+        return response
+
+
+def get_deals_found_at(timepoint: datetime) -> list[Book]:
+    db_conn = get_duckdb_conn()
+    query_response = execute_query(
+        db_conn,
+        get_query_by_name("get_deals_found_at.sql"),
+        {"timepoint": timepoint}
+    )
+    return [Book(**book) for book in query_response]
+
+
+def get_active_deals() -> list[Book]:
+    db_conn = get_duckdb_conn()
+    query_response = execute_query(
+        db_conn,
+        get_query_by_name("get_active_deals.sql")
+    )
+    return [Book(**book) for book in query_response]
+
+
+def print_books(books: list[Book]):
+    prior_title_id = books[0].title_id
+    for book in books:
+        if prior_title_id != book.title_id:
+            prior_title_id = book.title_id
+            click.echo()
+
+        click.echo(str(book))
+
+
+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])

tbr_deal_finder/config.py

@@ -0,0 +1,104 @@
+import configparser
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Union
+
+from tbr_deal_finder import TBR_DEALS_PATH
+
+_CONFIG_PATH = TBR_DEALS_PATH.joinpath("config.ini")
+
+_LOCALE_CURRENCY_MAP = {
+    "us": "$",
+    "ca": "$",
+    "au": "$",
+    "uk": "£",
+    "fr": "€",
+    "de": "€",
+    "es": "€",
+    "it": "€",
+    "jp": "¥",
+    "in": "₹",
+    "br": "R$",
+}
+
+@dataclass
+class Config:
+    library_export_paths: list[str]
+    tracked_retailers: list[str]
+    max_price: float = 8.0
+    min_discount: int = 35
+    run_time: datetime = datetime.now()
+    
+    locale: str = "us"  # This will be set as a class attribute below
+
+    def __post_init__(self):
+        if isinstance(self.library_export_paths, str):
+            self.set_library_export_paths(
+                self.library_export_paths.split(",")
+            )
+
+        if isinstance(self.tracked_retailers, str):
+            self.set_tracked_retailers(
+                self.tracked_retailers.split(",")
+            )
+
+    @classmethod
+    def currency_symbol(cls) -> str:
+        return _LOCALE_CURRENCY_MAP.get(cls.locale, "$")
+
+    @classmethod
+    def set_locale(cls, code: str):
+        cls.locale = code
+
+    @classmethod
+    def load(cls) -> "Config":
+        """Load configuration from file or return defaults."""
+        if not _CONFIG_PATH.exists():
+            raise FileNotFoundError(f"Config file not found at {_CONFIG_PATH}")
+        
+        parser = configparser.ConfigParser()
+        parser.read(_CONFIG_PATH)
+        export_paths_str = parser.get('DEFAULT', 'library_export_paths')
+        tracked_retailers_str = parser.get('DEFAULT', 'tracked_retailers')
+        locale = parser.get('DEFAULT', 'locale', fallback="us")
+        cls.set_locale(locale)
+        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(",")],
+            tracked_retailers=[i.strip() for i in tracked_retailers_str.split(",")]
+        )
+
+    @property
+    def library_export_paths_str(self) -> str:
+        return ", ".join(self.library_export_paths)
+
+    @property
+    def tracked_retailers_str(self) -> str:
+        return ", ".join(self.tracked_retailers)
+
+    def set_library_export_paths(self, library_export_paths: Union[str, list[str]]):
+        if 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
+
+    def set_tracked_retailers(self, tracked_retailers: Union[str, list[str]]):
+        if isinstance(tracked_retailers, str):
+            self.tracked_retailers = [i.strip() for i in tracked_retailers.split(",")]
+        else:
+            self.tracked_retailers = tracked_retailers
+
+    def save(self):
+        """Save configuration to file."""
+        parser = configparser.ConfigParser()
+        parser['DEFAULT'] = {
+            'max_price': str(self.max_price),
+            'min_discount': str(self.min_discount),
+            'locale': type(self).locale,
+            'library_export_paths': self.library_export_paths_str,
+            'tracked_retailers': self.tracked_retailers_str
+        }
+        
+        with open(_CONFIG_PATH, 'w') as f:
+            parser.write(f)

tbr_deal_finder/library_exports.py

@@ -0,0 +1,155 @@
+import asyncio
+import csv
+import shutil
+import tempfile
+
+from tqdm.asyncio import tqdm_asyncio
+
+from tbr_deal_finder.book import Book, BookFormat
+from tbr_deal_finder.config import Config
+from tbr_deal_finder.retailer.librofm import LibroFM
+
+
+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 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())
+
+
+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.
+    """
+
+    if "Libro.FM" not in config.tracked_retailers:
+        return
+
+    books_requiring_check_map = dict()
+    book_to_isbn_map = dict()
+
+
+    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 "audiobook_isbn" in book_dict:
+                    book_to_isbn_map[key] = book_dict["audiobook_isbn"]
+                    books_requiring_check_map.pop(key, None)
+                elif key not in book_to_isbn_map:
+                    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:
+        return
+
+    libro_fm = LibroFM()
+    # Setting it lower to be a good user of libro on their more expensive search call
+    semaphore = asyncio.Semaphore(3)
+
+    # Set the audiobook isbn for Book instances in books_requiring_check_map
+    await tqdm_asyncio.gather(
+        *[
+            libro_fm.get_book_isbn(book, semaphore) for book in books_requiring_check_map.values()
+        ],
+        desc="Getting required audiobook ISBN info"
+    )
+
+    # Go back and now add the audiobook_isbn
+    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"]
+            file_content = [book_dict for book_dict in reader]
+            if not file_content or "audiobook_isbn" 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 = f'{title}__{authors}'
+
+                        if key in book_to_isbn_map:
+                            audiobook_isbn = book_to_isbn_map[key]
+                        else:
+                            book = books_requiring_check_map[key]
+                            audiobook_isbn = book.audiobook_isbn
+
+                        book_dict["audiobook_isbn"] = audiobook_isbn
+                    else:
+                        book_dict["audiobook_isbn"] = ""
+
+                    writer.writerow(book_dict)
+
+        shutil.move(temp_filename, library_export_path)
+

tbr_deal_finder/main.py

@@ -0,0 +1,223 @@
+import asyncio
+import os
+from datetime import timedelta
+from textwrap import dedent
+from typing import Union
+
+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.migrations import make_migrations
+from tbr_deal_finder.book import get_deals_found_at, print_books, get_active_deals
+from tbr_deal_finder.retailer import RETAILER_MAP
+from tbr_deal_finder.retailer_deal import get_latest_deals
+from tbr_deal_finder.utils import get_duckdb_conn, get_query_by_name, execute_query
+
+
+@click.group()
+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:
+        new_path = os.path.expanduser(click.prompt("What is the new path"))
+        if new_path in existing_paths:
+            click.echo(f"{new_path} is already being tracked.\n")
+            return None
+        elif os.path.exists(new_path):
+            return new_path
+        else:
+            click.echo(f"Could not find {new_path}. Please try again.\n")
+            return _add_path(existing_paths)
+    except (KeyError, KeyboardInterrupt, TypeError):
+        return None
+
+
+def _remove_path(existing_paths: list[str]) -> Union[str, None]:
+    try:
+        return questionary.select(
+            "Which path would you like to remove?",
+            choices=existing_paths,
+        ).ask()
+    except (KeyError, KeyboardInterrupt, TypeError):
+        return None
+
+
+def _set_library_export_paths(config: Config):
+    """
+    Interactively set the paths to the user's library export files.
+
+    Allows the user to add or remove paths to their StoryGraph, Goodreads, or custom CSV export files.
+    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
+        else:
+            click.echo("Add your library export path.")
+            user_selection = "Add new path"
+
+        if user_selection == "Done":
+            return
+        elif user_selection == "Add new path":
+            if new_path := _add_path(config.library_export_paths):
+                config.library_export_paths.append(new_path)
+        else:
+            if remove_path := _remove_path(config.library_export_paths):
+                config.library_export_paths.remove(remove_path)
+
+
+def _set_locale(config: Config):
+    locale_options = {
+        "US and all other countries not listed": "us",
+        "Canada": "ca",
+        "UK and Ireland": "uk",
+        "Australia and New Zealand": "au",
+        "France, Belgium, Switzerland": "fr",
+        "Germany, Austria, Switzerland": "de",
+        "Japan": "jp",
+        "Italy": "it",
+        "India": "in",
+        "Spain": "es",
+        "Brazil": "br"
+    }
+    default_locale = [k for k,v in locale_options.items() if v == config.locale][0]
+
+    try:
+        user_selection = questionary.select(
+            "What change would you like to make to your library export paths",
+            choices=list(locale_options.keys()),
+            default=default_locale
+        ).ask()
+    except (KeyError, KeyboardInterrupt, TypeError):
+        return
+
+    config.set_locale(locale_options[user_selection])
+
+
+def _set_tracked_retailers(config: Config):
+    config.set_tracked_retailers(
+        questionary.checkbox(
+            "Select the retailers you want to check deals for. "
+            "Tip: Chirp doesn't have a subscription and can have good deals. I'd recommend checking it.",
+            choices=[
+                questionary.Choice(retailer, checked=retailer in config.tracked_retailers)
+                for retailer in RETAILER_MAP.keys()
+            ]).ask()
+    )
+
+
+def _set_config() -> Config:
+    try:
+        config = Config.load()
+    except FileNotFoundError:
+        config = Config(library_export_paths=[], tracked_retailers=list(RETAILER_MAP.keys()))
+
+    # Setting these config values are a little more involved,
+    #   so they're broken out into their own functions
+    _set_library_export_paths(config)
+    _set_tracked_retailers(config)
+    _set_locale(config)
+
+    config.max_price = click.prompt(
+        "Enter maximum price for deals",
+        type=float,
+        default=config.max_price
+    )
+    config.min_discount = click.prompt(
+        "Enter minimum discount percentage",
+        type=int,
+        default=config.min_discount
+    )
+
+    config.save()
+    click.echo("Configuration saved!")
+
+    return config
+
+
+@cli.command()
+def setup():
+    _set_config()
+
+
+@cli.command()
+def latest_deals():
+    """Find book deals from your Library export."""
+    config = Config.load()
+
+    asyncio.run(maybe_set_library_export_audiobook_isbn(config))
+
+    db_conn = get_duckdb_conn()
+    results = execute_query(
+        db_conn,
+        get_query_by_name("get_active_deals.sql")
+    )
+    last_ran = None if not results else results[0]["timepoint"]
+    min_age = config.run_time - timedelta(hours=8)
+
+    if not last_ran or last_ran < min_age:
+        try:
+            asyncio.run(get_latest_deals(config))
+        except Exception as e:
+            ran_successfully = False
+            details = f"Error getting deals: {e}"
+            click.echo(details)
+        else:
+            ran_successfully = True
+            details = ""
+
+        # Save execution results
+        db_conn.execute(
+            "INSERT INTO latest_deal_run_history (timepoint, ran_successfully, details) VALUES (?, ?, ?)",
+            [config.run_time, ran_successfully, details]
+        )
+
+        if not ran_successfully:
+            # Gracefully exit on Exception raised by get_latest_deals
+            return
+
+    else:
+        click.echo(dedent("""
+        To prevent abuse lastest deals can only be pulled every 8 hours.
+        Fetching most recent deal results.\n
+        """))
+        config.run_time = last_ran
+
+    if books := get_deals_found_at(config.run_time):
+        print_books(books)
+    else:
+        click.echo("No new deals found.")
+
+
+@cli.command()
+def active_deals():
+    """Get all active deals."""
+    if books := get_active_deals():
+        print_books(books)
+    else:
+        click.echo("No deals found.")
+
+
+if __name__ == '__main__':
+    cli()