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

tbr_deal_finder/gui/pages/settings.py

@@ -0,0 +1,389 @@
+from pathlib import Path
+
+import flet as ft
+
+from tbr_deal_finder.config import Config
+from tbr_deal_finder.retailer import RETAILER_MAP
+from tbr_deal_finder.tracked_books import reprocess_incomplete_tbr_books, clear_unknown_books
+
+
+class SettingsPage:
+    def __init__(self, app):
+        self.app = app
+        self.config = None
+        self.library_paths = []
+        self.tracked_retailers = []
+        self.max_price = 8.0
+        self.min_discount = 30
+        self.locale = "us"
+        
+        # Create file picker once and add to page overlay
+        self.file_picker = ft.FilePicker(on_result=self.on_file_picker_result)
+        
+        self.load_current_config()
+
+    def load_current_config(self):
+        """Load current configuration or set defaults"""
+        try:
+            self.config = Config.load()
+            self.library_paths = self.config.library_export_paths.copy()
+            self.tracked_retailers = self.config.tracked_retailers.copy()
+            self.max_price = self.config.max_price
+            self.min_discount = self.config.min_discount
+            self.locale = self.config.locale
+        except FileNotFoundError:
+            self.library_paths = []
+            self.tracked_retailers = list(RETAILER_MAP.keys())
+
+    def build(self):
+        """Build the settings page content"""
+        
+        # Add file picker to page overlay if not already added
+        if self.file_picker not in self.app.page.overlay:
+            self.app.page.overlay.append(self.file_picker)
+            self.app.page.update()  # Important: update page after adding to overlay
+        
+        # Library Export Paths Section
+        self.library_paths_list = ft.ListView(
+            height=150,
+            spacing=5
+        )
+        self.update_library_paths_list()
+        
+        library_section = ft.Container(
+            content=ft.Column([
+                ft.Text("Library Export Paths", size=18, weight=ft.FontWeight.BOLD),
+                ft.Text("Add your StoryGraph or Goodreads export files", color=ft.Colors.GREY_600),
+                self.library_paths_list,
+                ft.Row([
+                    ft.ElevatedButton(
+                        "Browse Files",
+                        icon=ft.Icons.FOLDER_OPEN,
+                        on_click=self.add_library_path
+                    ),
+                    ft.ElevatedButton(
+                        "Enter Path Manually",
+                        icon=ft.Icons.EDIT,
+                        on_click=lambda e: self.show_text_input_dialog()
+                    ),
+                    ft.OutlinedButton(
+                        "Remove Selected",
+                        icon=ft.Icons.REMOVE,
+                        on_click=self.remove_library_path
+                    )
+                ], wrap=True)
+            ], spacing=10),
+            padding=20,
+            border=ft.border.all(1, ft.Colors.OUTLINE),
+            border_radius=8
+        )
+
+        # Tracked Retailers Section
+        retailer_checkboxes = []
+        for retailer in RETAILER_MAP.keys():
+            checkbox = ft.Checkbox(
+                label=retailer,
+                value=retailer in self.tracked_retailers,
+                on_change=lambda e, r=retailer: self.toggle_retailer(r, e.control.value)
+            )
+            retailer_checkboxes.append(checkbox)
+
+        retailers_section = ft.Container(
+            content=ft.Column([
+                ft.Text("Tracked Retailers", size=18, weight=ft.FontWeight.BOLD),
+                ft.Text("Select retailers to check for deals", color=ft.Colors.GREY_600),
+                ft.Column(retailer_checkboxes, spacing=5)
+            ], spacing=10),
+            padding=20,
+            border=ft.border.all(1, ft.Colors.OUTLINE),
+            border_radius=8
+        )
+
+        # Locale Selection
+        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"
+        }
+        
+        current_locale_name = [k for k, v in locale_options.items() if v == self.locale][0]
+        
+        self.locale_dropdown = ft.Dropdown(
+            value=current_locale_name,
+            options=[ft.dropdown.Option(k) for k in locale_options.keys()],
+            on_change=lambda e: setattr(self, 'locale', locale_options[e.control.value])
+        )
+
+        # Price and Discount Settings
+        self.max_price_field = ft.TextField(
+            label="Maximum Price",
+            value=str(self.max_price),
+            keyboard_type=ft.KeyboardType.NUMBER,
+            on_change=self.update_max_price
+        )
+        
+        self.min_discount_field = ft.TextField(
+            label="Minimum Discount %",
+            value=str(self.min_discount),
+            keyboard_type=ft.KeyboardType.NUMBER,
+            on_change=self.update_min_discount
+        )
+
+        price_section = ft.Container(
+            content=ft.Column([
+                ft.Text("Deal Criteria", size=18, weight=ft.FontWeight.BOLD),
+                ft.Row([
+                    self.max_price_field,
+                    self.min_discount_field
+                ], spacing=20),
+                ft.Text("Locale", size=16, weight=ft.FontWeight.BOLD),
+                self.locale_dropdown
+            ], spacing=10),
+            padding=20,
+            border=ft.border.all(1, ft.Colors.OUTLINE),
+            border_radius=8
+        )
+
+        # Save and Cancel buttons
+        button_row = ft.Row([
+            ft.ElevatedButton(
+                "Save Configuration",
+                icon=ft.Icons.SAVE,
+                on_click=self.save_config
+            ),
+            ft.OutlinedButton(
+                "Cancel",
+                on_click=self.cancel_changes
+            )
+        ], spacing=10)
+        
+        # Update check section
+        update_section = ft.Container(
+            content=ft.Column([
+                ft.Text("Application Updates", size=16, weight=ft.FontWeight.BOLD),
+                ft.Text("Check for the latest version", color=ft.Colors.GREY_600),
+                ft.ElevatedButton(
+                    "Check for Updates",
+                    icon=ft.Icons.SYSTEM_UPDATE,
+                    on_click=lambda e: self.app.check_for_updates_button(),
+                    style=ft.ButtonStyle(bgcolor=ft.Colors.BLUE_600),
+                )
+            ], spacing=10),
+            padding=20,
+        )
+
+        # Main settings content
+        main_content = ft.ListView([
+            ft.Text("Settings", size=24, weight=ft.FontWeight.BOLD),
+            library_section,
+            retailers_section,
+            price_section,
+            button_row
+        ], spacing=20, padding=ft.padding.all(20), expand=True)
+        
+        # Create layout with main content on left and update section on right
+        return ft.Row([
+            main_content,
+            ft.Container(
+                content=update_section,
+                width=300,
+                alignment=ft.alignment.top_left
+            )
+        ], spacing=20, expand=True)
+
+    def update_library_paths_list(self):
+        """Update the library paths list view"""
+        self.library_paths_list.controls.clear()
+        for i, path in enumerate(self.library_paths):
+            item = ft.ListTile(
+                title=ft.Text(path),
+                trailing=ft.Checkbox(value=False),
+                dense=True
+            )
+            self.library_paths_list.controls.append(item)
+        self.app.page.update()
+
+    def add_library_path(self, e):
+        """Add a new library export path"""
+        def on_result(e: ft.FilePickerResultEvent):
+            if e.files and len(e.files) > 0:
+                new_path = e.files[0].path
+                if new_path not in self.library_paths:
+                    self.library_paths.append(new_path)
+                    self.update_library_paths_list()
+
+        # Create a file picker for this operation
+        file_picker = ft.FilePicker(on_result=on_result)
+        
+        # Add to overlay
+        self.app.page.overlay.append(file_picker)
+        self.app.page.update()
+
+        # Open the file picker
+        file_picker.pick_files(
+            dialog_title="Select Library Export File",
+            file_type=ft.FilePickerFileType.CUSTOM,
+            initial_directory=str(Path.home()),
+            allowed_extensions=["csv"]
+        )
+
+    def on_file_picker_result(self, e: ft.FilePickerResultEvent):
+        """Handle file picker result (legacy method - not used with new implementation)"""
+        if e.files:
+            for f in e.files:
+                new_path = f.path
+                if new_path not in self.library_paths:
+                    self.library_paths.append(new_path)
+                    self.update_library_paths_list()
+
+    def remove_library_path(self, e):
+        """Remove selected library paths"""
+        to_remove = []
+        for i, control in enumerate(self.library_paths_list.controls):
+            if control.trailing.value:  # If checkbox is checked
+                to_remove.append(i)
+        
+        # Remove in reverse order to maintain indices
+        for i in reversed(to_remove):
+            self.library_paths.pop(i)
+        
+        self.update_library_paths_list()
+
+    def toggle_retailer(self, retailer: str, is_checked: bool):
+        """Toggle retailer tracking"""
+        if is_checked and retailer not in self.tracked_retailers:
+            self.tracked_retailers.append(retailer)
+        elif not is_checked and retailer in self.tracked_retailers:
+            self.tracked_retailers.remove(retailer)
+
+    def update_max_price(self, e):
+        """Update max price value"""
+        try:
+            self.max_price = float(e.control.value)
+        except ValueError:
+            pass
+
+    def update_min_discount(self, e):
+        """Update min discount value"""
+        try:
+            self.min_discount = int(e.control.value)
+        except ValueError:
+            pass
+
+    def save_config(self, e):
+        """Save the configuration"""
+        if not self.tracked_retailers:
+            self.show_error("You must track at least one retailer.")
+            return
+
+        try:
+            if self.config:
+                # Update existing config
+                self.config.library_export_paths = self.library_paths
+                self.config.tracked_retailers = self.tracked_retailers
+                self.config.max_price = self.max_price
+                self.config.min_discount = self.min_discount
+                self.config.set_locale(self.locale)
+            else:
+                # Create new config
+                self.config = Config(
+                    library_export_paths=self.library_paths,
+                    tracked_retailers=self.tracked_retailers,
+                    max_price=self.max_price,
+                    min_discount=self.min_discount
+                )
+                self.config.set_locale(self.locale)
+
+            self.config.save()
+            
+            # Reprocess books if retailers changed
+            reprocess_incomplete_tbr_books(self.config)
+            clear_unknown_books()
+            
+            self.show_success("Configuration saved successfully!")
+            self.app.config_updated(self.config)
+            
+        except Exception as ex:
+            self.show_error(f"Error saving configuration: {str(ex)}")
+
+    def cancel_changes(self, e):
+        """Cancel changes and return to main view"""
+        self.load_current_config()
+        if self.app.config:
+            self.app.current_page = "all_deals"
+            self.app.nav_rail.selected_index = 0
+        else:
+            self.app.current_page = "all_deals"
+        self.app.update_content()
+
+    def show_error(self, message: str):
+        """Show error dialog"""
+        dlg = ft.AlertDialog(
+            title=ft.Text("Error"),
+            content=ft.Text(message),
+            actions=[ft.TextButton("OK", on_click=lambda e: self.close_dialog(dlg))]
+        )
+        self.app.page.overlay.append(dlg)
+        dlg.open = True
+        self.app.page.update()
+
+    def show_success(self, message: str):
+        """Show success dialog"""
+        dlg = ft.AlertDialog(
+            title=ft.Text("Success"),
+            content=ft.Text(message),
+            actions=[ft.TextButton("OK", on_click=lambda e: self.close_dialog(dlg))]
+        )
+        self.app.page.overlay.append(dlg)
+        dlg.open = True
+        self.app.page.update()
+
+    def show_text_input_dialog(self):
+        """Fallback: Show text input dialog for manual path entry"""
+        self.path_input = ft.TextField(
+            label="Enter full path to CSV file",
+            hint_text="/path/to/your/export.csv",
+            expand=True
+        )
+        
+        def add_manual_path(e):
+            path = self.path_input.value.strip()
+            if path and path not in self.library_paths:
+                import os
+                if os.path.exists(path) and path.endswith('.csv'):
+                    self.library_paths.append(path)
+                    self.update_library_paths_list()
+                    self.close_dialog(path_dialog)
+                else:
+                    self.show_error("File does not exist or is not a CSV file")
+            else:
+                self.show_error("Please enter a valid path")
+        
+        path_dialog = ft.AlertDialog(
+            title=ft.Text("Enter File Path"),
+            content=ft.Column([
+                ft.Text("File picker not available. Please enter the full path to your library export CSV file:"),
+                self.path_input
+            ], tight=True),
+            actions=[
+                ft.TextButton("Cancel", on_click=lambda e: self.close_dialog(path_dialog)),
+                ft.ElevatedButton("Add Path", on_click=add_manual_path)
+            ]
+        )
+        
+        self.app.page.overlay.append(path_dialog)
+        path_dialog.open = True
+        self.app.page.update()
+
+    def close_dialog(self, dialog):
+        """Close dialog"""
+        dialog.open = False
+        self.app.page.update()

tbr_deal_finder/migrations.py

@@ -62,6 +62,32 @@ _MIGRATIONS = [
             );
             """
     ),
+    TableMigration(
+        version=1,
+        table_name="unknown_book",
+        sql="""
+            CREATE TABLE unknown_book
+            (
+                retailer        VARCHAR,
+                title           VARCHAR,
+                authors         VARCHAR,
+                format          VARCHAR,
+                book_id         VARCHAR
+            );
+            """
+    ),
+    TableMigration(
+        version=1,
+        table_name="unknown_book_run_history",
+        sql="""
+            CREATE TABLE unknown_book_run_history
+            (
+                timepoint           TIMESTAMP_NS,
+                ran_successfully    BOOLEAN,
+                details             VARCHAR
+            );
+            """
+    ),
 ]
 
 

tbr_deal_finder/queries/latest_unknown_book_sync.sql

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

tbr_deal_finder/retailer/amazon.py

@@ -1,24 +1,30 @@
+import logging
 import sys
 import os.path
+from typing import Union
 
 import audible
 import click
 from audible.login import build_init_cookies
 from textwrap import dedent
 
+from tbr_deal_finder.retailer.amazon_custom_auth import CustomAuthenticator
+from tbr_deal_finder.utils import get_data_dir
+
 if sys.platform != 'win32':
     # Breaks Windows support but required for Mac
     # Untested on Linux
     import readline  # type: ignore
 
-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.models import Retailer, GuiAuthContext
+
+AUTH_PATH = get_data_dir().joinpath("audible.json")
 
-_AUTH_PATH = TBR_DEALS_PATH.joinpath("audible.json")
+logger = logging.getLogger(__name__)
 
 
-def login_url_callback(url: str) -> str:
+def default_login_url_callback(url: str) -> str:
     """Helper function for login with external browsers."""
 
     try:
@@ -67,19 +73,64 @@ def login_url_callback(url: str) -> str:
 
 
 class Amazon(Retailer):
-    _auth: audible.Authenticator = None
+    _auth: Union[audible.Authenticator, CustomAuthenticator] = None
     _client: audible.AsyncClient = None
 
+    def user_is_authed(self) -> bool:
+        if not os.path.exists(AUTH_PATH):
+            return False
+
+        self._auth = audible.Authenticator.from_file(AUTH_PATH)
+        self._client = audible.AsyncClient(auth=self._auth)
+        return True
+
     async def set_auth(self):
-        if not os.path.exists(_AUTH_PATH):
+        if not self.user_is_authed():
             auth = audible.Authenticator.from_login_external(
                 locale=Config.locale,
-                login_url_callback=login_url_callback
+                login_url_callback=default_login_url_callback
             )
 
             # Save credentials to file
-            auth.to_file(_AUTH_PATH)
+            auth.to_file(AUTH_PATH)
 
-        self._auth = audible.Authenticator.from_file(_AUTH_PATH)
+        self._auth = audible.Authenticator.from_file(AUTH_PATH)
         self._client = audible.AsyncClient(auth=self._auth)
 
+    @property
+    def gui_auth_context(self) -> GuiAuthContext:
+        if not self._auth:
+            self._auth = CustomAuthenticator.from_locale(Config.locale)
+
+        return GuiAuthContext(
+            title="Login to Amazon (Audible/Kindle)",
+            fields=[
+                {"name": "login_link", "label": "Link", "type": "text"}
+            ],
+            message=dedent(
+                """
+                Please copy the following url and insert it into a web browser of your choice to log into Amazon.
+                Once you have logged in, please insert the copied url.
+                Note: your browser will show you an error page (Page not found). This is expected.
+                """
+            ),
+            user_copy_context=self._auth.oauth_url
+        )
+
+
+    async def gui_auth(self, form_data: dict) -> bool:
+        if not self._auth:
+            if self.user_is_authed():
+                return True
+        try:
+            self._auth.external_login(form_data["login_link"])
+            # Save credentials to file
+            self._auth.to_file(AUTH_PATH)
+
+            self._auth = audible.Authenticator.from_file(AUTH_PATH)
+            self._client = audible.AsyncClient(auth=self._auth)
+            return True
+        except Exception as e:
+            logger.info(e)
+            return False
+

tbr_deal_finder/retailer/amazon_custom_auth.py

@@ -0,0 +1,79 @@
+import logging
+from typing import Optional, Any, Union
+from urllib.parse import parse_qs
+
+import audible
+import httpx
+from audible.login import create_code_verifier, build_oauth_url
+from audible.register import register as register_
+
+logger = logging.getLogger(__name__)
+
+
+def external_login(
+        response_url: str,
+        domain: str,
+        serial: str,
+        code_verifier: bytes,
+) -> dict[str, Any]:
+    response_url = httpx.URL(response_url)
+    parsed_url = parse_qs(response_url.query.decode())
+
+    authorization_code = parsed_url["openid.oa2.authorization_code"][0]
+
+    return {
+        "authorization_code": authorization_code,
+        "code_verifier": code_verifier,
+        "domain": domain,
+        "serial": serial
+    }
+
+
+class CustomAuthenticator(audible.Authenticator):
+    _with_username: Optional[bool] = False
+    _serial: Optional[str] = None
+    _code_verifier: Optional[bytes] = None
+    oauth_url: Optional[str] = None
+
+    @classmethod
+    def from_locale(
+        cls,
+        locale: Union[str, "Locale"],
+        serial: Optional[str] = None,
+        with_username: bool = False,
+    ):
+        auth = cls()
+        auth.locale = locale
+        auth._with_username = with_username
+        auth._code_verifier = create_code_verifier()
+        auth.oauth_url, auth._serial = build_oauth_url(
+            country_code=auth.locale.country_code,
+            domain=auth.locale.domain,
+            market_place_id=auth.locale.market_place_id,
+            code_verifier=auth._code_verifier,
+            serial=serial,
+            with_username=with_username
+        )
+
+        return auth
+
+    def external_login(self, response_url: str):
+
+        login_device = external_login(
+                response_url,
+                self.locale.domain,
+                self._serial,
+                self._code_verifier
+        )
+        logger.info("logged in to Audible.")
+
+        register_device = register_(
+            with_username=self._with_username,
+            **login_device
+        )
+
+        self._update_attrs(
+            with_username=self._with_username,
+            **register_device
+        )
+        logger.info("registered Audible device")

tbr_deal_finder/retailer/audible.py

@@ -1,5 +1,6 @@
 import asyncio
 import math
+from typing import Union
 
 from tbr_deal_finder.config import Config
 from tbr_deal_finder.retailer.amazon import Amazon
@@ -20,7 +21,7 @@ class Audible(Amazon):
         self,
         target: Book,
         semaphore: asyncio.Semaphore
-    ) -> Book:
+    ) -> Union[Book, None]:
         title = target.title
         authors = target.authors