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

tbr_deal_finder/__init__.py

@@ -1,9 +1,5 @@
-import os
 from pathlib import Path
 
-__VERSION__ = "0.1.0"
+__VERSION__ = "0.3.1"
 
 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/__main__.py

@@ -0,0 +1,7 @@
+"""
+Entry point for the TBR Deal Finder package when run in the flet app distro.
+"""
+from tbr_deal_finder.gui.main import main
+
+if __name__ == "__main__":
+    main()

tbr_deal_finder/book.py

@@ -8,7 +8,7 @@ from Levenshtein import ratio
 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, echo_info
+from tbr_deal_finder.utils import get_duckdb_conn, execute_query, get_query_by_name, echo_info, float_to_currency
 
 _AUTHOR_RE = re.compile(r'[^a-zA-Z0-9]')
 
@@ -55,11 +55,10 @@ class Book:
         self.format = format
 
     def discount(self) -> int:
-        return int((self.list_price/self.current_price - 1) * 100)
+        if not self.current_price:
+            return 100
 
-    @staticmethod
-    def price_to_string(price: float) -> str:
-        return f"{Config.currency_symbol()}{price:.2f}"
+        return int((1 - self.current_price/self.list_price) * 100)
 
     @property
     def deal_id(self) -> str:
@@ -90,10 +89,10 @@ class Book:
         self._list_price = round(price, 2)
 
     def list_price_string(self):
-        return self.price_to_string(self.list_price)
+        return float_to_currency(self.list_price)
 
     def current_price_string(self):
-        return self.price_to_string(self.current_price)
+        return float_to_currency(self.current_price)
 
     def __str__(self) -> str:
         price = self.current_price_string()
@@ -127,6 +126,15 @@ class Book:
             "book_id": self.title_id,
         }
 
+    def unknown_book_dict(self):
+        return {
+            "retailer": self.retailer,
+            "title": self.title,
+            "authors": self.authors,
+            "format": self.format.value,
+            "book_id": self.deal_id,
+        }
+
 
 def get_deals_found_at(timepoint: datetime) -> list[Book]:
     db_conn = get_duckdb_conn()
@@ -147,7 +155,11 @@ def get_active_deals() -> list[Book]:
     return [Book(**book) for book in query_response]
 
 
-def print_books(books: list[Book]):
+def is_qualifying_deal(config: Config, book: Book) -> bool:
+    return book.current_price <= config.max_price and book.discount() >= config.min_discount
+
+
+def print_books(config: Config, books: list[Book]):
     audiobooks = [book for book in books if book.format == BookFormat.AUDIOBOOK]
     audiobooks = sorted(audiobooks, key=lambda book: book.deal_id)
 
@@ -159,10 +171,16 @@ def print_books(books: list[Book]):
             continue
 
         init_book = books_in_format[0]
+        if not any(is_qualifying_deal(config, book) for book in books_in_format):
+            continue
+
         echo_info(f"\n\n{init_book.format.value} Deals:")
 
         prior_title_id = init_book.title_id
         for book in books_in_format:
+            if not is_qualifying_deal(config, book):
+                continue
+
             if prior_title_id != book.title_id:
                 prior_title_id = book.title_id
                 click.echo()
@@ -171,10 +189,12 @@ def print_books(books: list[Book]):
 
 
 def get_full_title_str(title: str, authors: Union[list, str]) -> str:
+    title = get_normalized_title(title)
     return f"{title}__{get_normalized_authors(authors)}"
 
 
 def get_title_id(title: str, authors: Union[list, str], book_format: BookFormat) -> str:
+    title = get_normalized_title(title)
     return f"{title}__{get_normalized_authors(authors)}__{book_format.value}"
 
 

tbr_deal_finder/cli.py

@@ -13,19 +13,20 @@ 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.tracked_books import reprocess_incomplete_tbr_books, clear_unknown_books
 from tbr_deal_finder.utils import (
     echo_err,
     echo_info,
     echo_success,
-    execute_query,
     get_duckdb_conn,
-    get_query_by_name
+    get_latest_deal_last_ran
 )
+from tbr_deal_finder.version_check import notify_if_outdated
 
 
 @click.group()
 def cli():
+    notify_if_outdated()
     make_migrations()
 
 
@@ -183,6 +184,7 @@ def setup():
     # Retailers may have changed causing some books to need reprocessing
     config = Config.load()
     reprocess_incomplete_tbr_books(config)
+    clear_unknown_books()
 
 
 @cli.command()
@@ -194,34 +196,13 @@ def latest_deals():
         config = _set_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"]
+    last_ran = get_latest_deal_last_ran(db_conn)
     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}"
-            echo_err(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]
-        )
-
+        ran_successfully = asyncio.run(get_latest_deals(config))
         if not ran_successfully:
-            # Gracefully exit on Exception raised by get_latest_deals
             return
-
     else:
         echo_info(dedent("""
         To prevent abuse lastest deals can only be pulled every 8 hours.
@@ -230,7 +211,7 @@ def latest_deals():
         config.run_time = last_ran
 
     if books := get_deals_found_at(config.run_time):
-        print_books(books)
+        print_books(config, books)
     else:
         echo_info("No new deals found.")
 
@@ -238,11 +219,17 @@ def latest_deals():
 @cli.command()
 def active_deals():
     """Get all active deals."""
+    try:
+        config = Config.load()
+    except FileNotFoundError:
+        config = _set_config()
+
     if books := get_active_deals():
-        print_books(books)
+        print_books(config, books)
     else:
         echo_info("No deals found.")
 
 
 if __name__ == '__main__':
+    os.environ.setdefault("ENTRYPOINT", "CLI")
     cli()

tbr_deal_finder/config.py

@@ -3,9 +3,9 @@ from dataclasses import dataclass
 from datetime import datetime
 from typing import Union
 
-from tbr_deal_finder import TBR_DEALS_PATH
+from tbr_deal_finder.utils import get_data_dir
 
-_CONFIG_PATH = TBR_DEALS_PATH.joinpath("config.ini")
+_CONFIG_PATH = get_data_dir().joinpath("config.ini")
 
 _LOCALE_CURRENCY_MAP = {
     "us": "$",
@@ -26,7 +26,7 @@ class Config:
     library_export_paths: list[str]
     tracked_retailers: list[str]
     max_price: float = 8.0
-    min_discount: int = 35
+    min_discount: int = 30
     run_time: datetime = datetime.now()
     
     locale: str = "us"  # This will be set as a class attribute below

tbr_deal_finder/desktop_updater.py

@@ -0,0 +1,147 @@
+"""
+Desktop application update checker and handler.
+For packaged desktop applications (.dmg/.exe).
+"""
+import json
+import logging
+import os
+import platform
+import subprocess
+import tempfile
+import webbrowser
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+import requests
+from packaging import version
+
+from tbr_deal_finder import __VERSION__
+
+logger = logging.getLogger(__name__)
+
+class DesktopUpdater:
+    """Handle updates for packaged desktop applications."""
+    
+    def __init__(self, github_repo: str = "WillNye/tbr-deal-finder"):
+        self.github_repo = github_repo
+        self.current_version = __VERSION__
+        self.platform = platform.system().lower()
+        
+    def check_for_updates(self) -> Optional[Dict[str, Any]]:
+        """
+        Check GitHub releases for newer versions.
+        Returns dict with update info or None if no update available.
+        """
+        try:
+            # Check GitHub releases API
+            response = requests.get(
+                f"https://api.github.com/repos/{self.github_repo}/releases/latest",
+                timeout=5
+            )
+            response.raise_for_status()
+            
+            release_data = response.json()
+            latest_version = release_data["tag_name"].lstrip("v")
+            if version.parse(latest_version) > version.parse(self.current_version):
+                release_url = release_data["html_url"]
+                return {
+                    "version": latest_version,
+                    "download_url": release_url,
+                    "release_notes": release_data.get("body", ""),
+                    "release_url": release_url
+                }
+                
+            return None
+            
+        except Exception as e:
+            logger.error(f"Failed to check updates for {self.github_repo}: {e}")
+            return None
+    
+    def download_update(self, download_url: str, progress_callback=None) -> Optional[Path]:
+        """
+        Download the update file.
+        Returns path to downloaded file or None if failed.
+        """
+        try:
+            response = requests.get(download_url, stream=True, timeout=30)
+            response.raise_for_status()
+            
+            # Determine file extension
+            filename = download_url.split("/")[-1]
+            temp_file = Path(tempfile.gettempdir()) / filename
+            
+            total_size = int(response.headers.get('content-length', 0))
+            downloaded = 0
+            
+            with open(temp_file, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        
+                        if progress_callback and total_size > 0:
+                            progress = (downloaded / total_size) * 100
+                            progress_callback(progress)
+            
+            return temp_file
+            
+        except Exception as e:
+            logger.error(f"Failed to download update: {e}")
+            return None
+    
+    def install_update(self, update_file: Path) -> bool:
+        """
+        Install the downloaded update.
+        Platform-specific installation logic.
+        """
+        if self.platform == "darwin":
+            return self._install_macos_update(update_file)
+        elif self.platform == "windows":
+            return self._install_windows_update(update_file)
+        elif self.platform == "linux":
+            return self._install_linux_update(update_file)
+        else:
+            return False
+    
+    def _install_macos_update(self, dmg_file: Path) -> bool:
+        """Install .dmg update on macOS."""
+        try:
+            # Open the DMG file - user will need to drag to Applications
+            subprocess.run(["open", str(dmg_file)], check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+    
+    def _install_windows_update(self, exe_file: Path) -> bool:
+        """Install .exe update on Windows."""
+        try:
+            # Run the installer
+            subprocess.run([str(exe_file)], check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+    
+    def _install_linux_update(self, appimage_file: Path) -> bool:
+        """Install AppImage update on Linux."""
+        try:
+            # Make executable and offer to replace current installation
+            os.chmod(appimage_file, 0o755)
+            
+            # For AppImage, we'd typically replace the current file
+            # This is more complex and might require user permission
+            return True
+        except Exception:
+            return False
+    
+    def open_download_page(self, release_url: str):
+        """Open the GitHub release page in browser."""
+        webbrowser.open(release_url)
+
+
+# Global instance
+desktop_updater = DesktopUpdater()
+
+
+def check_for_desktop_updates() -> Optional[Dict[str, Any]]:
+    """Convenience function to check for updates."""
+    return desktop_updater.check_for_updates()