cs2tracker 2.1.12__py3-none-any.whl → 2.1.14__py3-none-any.whl

cs2tracker/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.1.12'
-__version_tuple__ = version_tuple = (2, 1, 12)
+__version__ = version = '2.1.14'
+__version_tuple__ = version_tuple = (2, 1, 14)

cs2tracker/app/application.py

@@ -15,6 +15,7 @@ from cs2tracker.app.scraper_frame import ScraperFrame
 from cs2tracker.constants import ICON_FILE, OS, OUTPUT_FILE, OSType
 from cs2tracker.scraper import BackgroundTask, Scraper
 from cs2tracker.util import PriceLogs
+from cs2tracker.util.validated_config import get_config
 
 APPLICATION_NAME = "CS2Tracker"
 WINDOW_SIZE = "630x335"
@@ -24,52 +25,89 @@ SCRAPER_WINDOW_TITLE = "CS2Tracker Scraper"
 SCRAPER_WINDOW_SIZE = "900x750"
 
 CONFIG_EDITOR_TITLE = "Config Editor"
-CONFIG_EDITOR_SIZE = "800x750"
+CONFIG_EDITOR_SIZE = "900x750"
+
+
+config = get_config()
 
 
 class Application:
     def __init__(self):
         self.scraper = Scraper()
-        self.application_window = None
 
     def run(self):
-        """Run the main application window with buttons for scraping prices, editing the
-        configuration, showing history in a chart, and editing the log file.
-        """
-        self.application_window = self._configure_window()
+        """Run the main application window."""
+        window = self._configure_window()
 
         if DARK_THEME:
             sv_ttk.use_dark_theme()
         else:
             sv_ttk.use_light_theme()
 
-        self.application_window.mainloop()
+        window.mainloop()
+
+    def _configure_window(self):
+        """Configure the main application window."""
+        window = tk.Tk()
+        window.title(APPLICATION_NAME)
+        window.geometry(WINDOW_SIZE)
+
+        if OS == OSType.WINDOWS:
+            app_id = "cs2tracker.unique.id"
+            ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(app_id)
+
+        icon = tk.PhotoImage(file=ICON_FILE)
+        window.wm_iconphoto(True, icon)
+
+        main_frame = MainFrame(window, self.scraper)
+        main_frame.pack(expand=True, fill="both")
+
+        return window
+
+
+class MainFrame(ttk.Frame):
+    # pylint: disable=too-many-instance-attributes,attribute-defined-outside-init
+    def __init__(self, parent, scraper):
+        super().__init__(parent, padding=15)
+        self.parent = parent
+        self.scraper = scraper
+        self._add_widgets()
 
-    def _add_button(self, frame, text, command, row):
+    def _add_widgets(self):
+        """Add widgets to the main frame."""
+        self.columnconfigure(0, weight=1)
+        self.columnconfigure(1, weight=1)
+        self.rowconfigure(0, weight=1)
+
+        self._configure_button_frame()
+        self.button_frame.grid(row=0, column=0, padx=10, pady=(7, 20), sticky="nsew")
+        self._configure_checkbox_frame()
+        self.checkbox_frame.grid(row=0, column=1, padx=10, pady=(0, 20), sticky="nsew")
+
+    def _add_button(self, text, command, row):
         """Create and style a button for the button frame."""
         grid_pos = {"row": row, "column": 0, "sticky": "ew", "padx": 10, "pady": 10}
-        button = ttk.Button(frame, text=text, command=command)
+        button = ttk.Button(self.button_frame, text=text, command=command)
         button.grid(**grid_pos)
 
-    def _configure_button_frame(self, main_frame):
+    def _configure_button_frame(self):
         """Configure the button frame of the application main frame."""
-        button_frame = ttk.Frame(main_frame, style="Card.TFrame", padding=15)
-        button_frame.columnconfigure(0, weight=1)
-        button_frame.grid(row=0, column=0, padx=10, pady=(7, 20), sticky="nsew")
+        self.button_frame = ttk.Frame(self, style="Card.TFrame", padding=15)
+        self.button_frame.columnconfigure(0, weight=1)
 
-        self._add_button(button_frame, "Run!", self.scrape_prices, 0)
-        self._add_button(button_frame, "Edit Config", self._edit_config, 1)
-        self._add_button(button_frame, "Show History", self._draw_plot, 2)
-        self._add_button(button_frame, "Export History", self._export_log_file, 3)
-        self._add_button(button_frame, "Import History", self._import_log_file, 4)
+        self._add_button("Run!", self.scrape_prices, 0)
+        self._add_button("Edit Config", self._edit_config, 1)
+        self._add_button("Show History", self._draw_plot, 2)
+        self._add_button("Export History", self._export_log_file, 3)
+        self._add_button("Import History", self._import_log_file, 4)
 
     def _add_checkbox(
-        self, frame, text, variable, command, row
-    ):  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self, text, variable, command, row
+    ):  # pylint: disable=too-many-arguments,too-many-positional-arguments,attribute-defined-outside-init
         """Create and style a checkbox for the checkbox frame."""
         grid_pos = {"row": row, "column": 0, "sticky": "w", "padx": (10, 0), "pady": 5}
         checkbox = ttk.Checkbutton(
-            frame,
+            self.checkbox_frame,
             text=text,
             variable=variable,
             command=command,
@@ -77,92 +115,50 @@ class Application:
         )
         checkbox.grid(**grid_pos)
 
-    def _configure_checkbox_frame(self, main_frame):
+    def _configure_checkbox_frame(self):
         """Configure the checkbox frame for background tasks and settings."""
-        checkbox_frame = ttk.LabelFrame(main_frame, text="Settings", padding=15)
-        checkbox_frame.grid(row=0, column=1, padx=10, pady=(0, 20), sticky="nsew")
+        self.checkbox_frame = ttk.LabelFrame(self, text="Settings", padding=15)
 
-        background_checkbox_value = tk.BooleanVar(value=BackgroundTask.identify())
+        self.background_checkbox_value = tk.BooleanVar(value=BackgroundTask.identify())
         self._add_checkbox(
-            checkbox_frame,
             "Background Task",
-            background_checkbox_value,
-            lambda: self._toggle_background_task(background_checkbox_value.get()),
+            self.background_checkbox_value,
+            lambda: self._toggle_background_task(self.background_checkbox_value.get()),
             0,
         )
 
-        discord_webhook_checkbox_value = tk.BooleanVar(
-            value=self.scraper.config.getboolean(
-                "App Settings", "discord_notifications", fallback=False
-            )
+        self.discord_webhook_checkbox_value = tk.BooleanVar(
+            value=config.getboolean("App Settings", "discord_notifications", fallback=False)
         )
         self._add_checkbox(
-            checkbox_frame,
             "Discord Notifications",
-            discord_webhook_checkbox_value,
-            lambda: discord_webhook_checkbox_value.set(
-                self._toggle_discord_webhook(discord_webhook_checkbox_value.get())
+            self.discord_webhook_checkbox_value,
+            lambda: self.discord_webhook_checkbox_value.set(
+                self._toggle_discord_webhook(self.discord_webhook_checkbox_value.get())
             ),
             1,
         )
 
-        use_proxy_checkbox_value = tk.BooleanVar(
-            value=self.scraper.config.getboolean("App Settings", "use_proxy", fallback=False)
+        self.use_proxy_checkbox_value = tk.BooleanVar(
+            value=config.getboolean("App Settings", "use_proxy", fallback=False)
         )
         self._add_checkbox(
-            checkbox_frame,
             "Proxy Requests",
-            use_proxy_checkbox_value,
-            lambda: use_proxy_checkbox_value.set(
-                self._toggle_use_proxy(use_proxy_checkbox_value.get())
+            self.use_proxy_checkbox_value,
+            lambda: self.use_proxy_checkbox_value.set(
+                self._toggle_use_proxy(self.use_proxy_checkbox_value.get())
             ),
             2,
         )
 
-        # pylint: disable=attribute-defined-outside-init
         self.dark_theme_checkbox_value = tk.BooleanVar(value=DARK_THEME)
-        self._add_checkbox(
-            checkbox_frame, "Dark Theme", self.dark_theme_checkbox_value, sv_ttk.toggle_theme, 3
-        )
-
-    def _configure_main_frame(self, window):
-        """Configure the main frame of the application window with buttons and
-        checkboxes.
-        """
-        main_frame = ttk.Frame(window, padding=15)
-        main_frame.columnconfigure(0, weight=1)
-        main_frame.columnconfigure(1, weight=1)
-        main_frame.rowconfigure(0, weight=1)
-
-        self._configure_button_frame(main_frame)
-        self._configure_checkbox_frame(main_frame)
-
-        main_frame.pack(expand=True, fill="both")
-
-    def _configure_window(self):
-        """Configure the main application window UI and add buttons for the main
-        functionalities.
-        """
-        window = tk.Tk()
-        window.title(APPLICATION_NAME)
-        window.geometry(WINDOW_SIZE)
-
-        if OS == OSType.WINDOWS:
-            app_id = "cs2tracker.unique.id"
-            ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(app_id)
-
-        icon = tk.PhotoImage(file=ICON_FILE)
-        window.wm_iconphoto(True, icon)
-
-        self._configure_main_frame(window)
-
-        return window
+        self._add_checkbox("Dark Theme", self.dark_theme_checkbox_value, sv_ttk.toggle_theme, 3)
 
     def scrape_prices(self):
         """Scrape prices from the configured sources, print the total, and save the
         results to a file.
         """
-        scraper_window = tk.Toplevel(self.application_window)
+        scraper_window = tk.Toplevel(self.parent)
         scraper_window.geometry(SCRAPER_WINDOW_SIZE)
         scraper_window.title(SCRAPER_WINDOW_TITLE)
 
@@ -177,11 +173,11 @@ class Application:
 
     def _edit_config(self):
         """Open a new window with a config editor GUI."""
-        config_editor_window = tk.Toplevel(self.application_window)
+        config_editor_window = tk.Toplevel(self.parent)
         config_editor_window.geometry(CONFIG_EDITOR_SIZE)
         config_editor_window.title(CONFIG_EDITOR_TITLE)
 
-        editor_frame = ConfigEditorFrame(config_editor_window, self.scraper)
+        editor_frame = ConfigEditorFrame(config_editor_window)
         editor_frame.pack(expand=True, fill="both")
 
     def _draw_plot(self):
@@ -228,28 +224,28 @@ class Application:
 
     def _toggle_use_proxy(self, enabled: bool):
         """Toggle whether the scraper should use proxy servers for requests."""
-        proxy_api_key = self.scraper.config.get("User Settings", "proxy_api_key", fallback=None)
+        proxy_api_key = config.get("User Settings", "proxy_api_key", fallback=None)
         if not proxy_api_key and enabled:
             messagebox.showerror(
                 "Config Error",
                 "You need to enter a valid crawlbase API key into the configuration to use this feature.",
+                parent=self.parent,
             )
             return False
 
-        self.scraper.toggle_use_proxy(enabled)
+        config.toggle_use_proxy(enabled)
         return True
 
     def _toggle_discord_webhook(self, enabled: bool):
         """Toggle whether the scraper should send notifications to a Discord webhook."""
-        discord_webhook_url = self.scraper.config.get(
-            "User Settings", "discord_webhook_url", fallback=None
-        )
+        discord_webhook_url = config.get("User Settings", "discord_webhook_url", fallback=None)
         if not discord_webhook_url and enabled:
             messagebox.showerror(
                 "Config Error",
                 "You need to enter a valid Discord webhook URL into the configuration to use this feature.",
+                parent=self.parent,
             )
             return False
 
-        self.scraper.toggle_discord_webhook(enabled)
+        config.toggle_discord_webhook(enabled)
         return True