cs2tracker 2.1.11__py3-none-any.whl → 2.1.13__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.11'
-__version_tuple__ = version_tuple = (2, 1, 11)
+__version__ = version = '2.1.13'
+__version_tuple__ = version_tuple = (2, 1, 13)

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,7 +25,10 @@ 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:
@@ -92,9 +96,7 @@ class Application:
         )
 
         discord_webhook_checkbox_value = tk.BooleanVar(
-            value=self.scraper.config.getboolean(
-                "App Settings", "discord_notifications", fallback=False
-            )
+            value=config.getboolean("App Settings", "discord_notifications", fallback=False)
         )
         self._add_checkbox(
             checkbox_frame,
@@ -107,7 +109,7 @@ class Application:
         )
 
         use_proxy_checkbox_value = tk.BooleanVar(
-            value=self.scraper.config.getboolean("App Settings", "use_proxy", fallback=False)
+            value=config.getboolean("App Settings", "use_proxy", fallback=False)
         )
         self._add_checkbox(
             checkbox_frame,
@@ -181,7 +183,7 @@ class Application:
         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,7 +230,7 @@ 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",
@@ -236,14 +238,12 @@ class Application:
             )
             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",
@@ -251,5 +251,5 @@ class Application:
             )
             return False
 
-        self.scraper.toggle_discord_webhook(enabled)
+        config.toggle_discord_webhook(enabled)
         return True

cs2tracker/app/editor_frame.py

@@ -1,42 +1,44 @@
 import tkinter as tk
+from queue import Empty, Queue
 from shutil import copy
+from subprocess import PIPE, STDOUT
+from threading import Thread
 from tkinter import messagebox, ttk
+from urllib.parse import unquote
 
-from cs2tracker.constants import CONFIG_FILE, CONFIG_FILE_BACKUP
+from nodejs import node
+from ttk_text import ThemedText
 
-# from tksheet import Sheet
+from cs2tracker.constants import (
+    CONFIG_FILE,
+    CONFIG_FILE_BACKUP,
+    INVENTORY_IMPORT_FILE,
+    INVENTORY_IMPORT_SCRIPT,
+)
+from cs2tracker.util import get_config
 
-NEW_CUSTOM_ITEM_TITLE = "Add Custom Item"
-NEW_CUSTOM_ITEM_SIZE = "500x200"
+ADD_CUSTOM_ITEM_TITLE = "Add Custom Item"
+ADD_CUSTOM_ITEM_SIZE = "500x220"
+
+IMPORT_INVENTORY_TITLE = "Import Steam Inventory"
+IMPORT_INVENTORY_SIZE = "500x450"
+
+IMPORT_INVENTORY_PROCESS_TITLE = "Importing Steam Inventory..."
+IMPORT_INVENTORY_PROCESS_SIZE = "700x500"
+
+config = get_config()
 
 
 class ConfigEditorFrame(ttk.Frame):
-    def __init__(self, parent, scraper):
+    def __init__(self, parent):
         """Initialize the configuration editor frame that allows users to view and edit
         the configuration options.
         """
-
-        super().__init__(parent, style="Card.TFrame", padding=15)
+        super().__init__(parent, padding=15)
 
         self.parent = parent
-        self.scraper = scraper
         self._add_widgets()
 
-    def reload_config_into_tree(self):
-        """Reload the configuration options into the treeview for display and
-        editing.
-        """
-        for item in self.tree.get_children():
-            self.tree.delete(item)
-
-        for section in self.scraper.config.sections():
-            if section == "App Settings":
-                continue
-            section_level = self.tree.insert("", "end", iid=section, text=section)
-            for config_option, value in self.scraper.config.items(section):
-                title_option = config_option.replace("_", " ").title()
-                self.tree.insert(section_level, "end", text=title_option, values=[value])
-
     def _add_widgets(self):
         """Configure the main editor frame which displays the configuration options in a
         structured way.
@@ -44,12 +46,14 @@ class ConfigEditorFrame(ttk.Frame):
         self._configure_treeview()
         self.tree.pack(expand=True, fill="both")
 
-        button_frame = ConfigEditorButtonFrame(self, self.scraper, self.tree)
+        button_frame = ConfigEditorButtonFrame(self, self.tree)
         button_frame.pack(side="bottom", padx=10, pady=(0, 10))
 
     def _set_cell_value(self, event):
-        """Set the value of a cell in the treeview to be editable when double-
-        clicked.
+        """
+        Set the value of a cell in the treeview to be editable when double- clicked.
+
+        Source: https://stackoverflow.com/questions/75787251/create-an-editable-tkinter-treeview-with-keyword-connection
         """
 
         def save_edit(event):
@@ -63,7 +67,7 @@ class ConfigEditorFrame(ttk.Frame):
             if item_text.strip() == "":
                 left_item_text = self.tree.item(row, "text")
                 # Don't allow editing of section headers
-                if any(left_item_text == section for section in self.scraper.config.sections()):
+                if any(left_item_text == section for section in config.sections()):
                     return
             x, y, w, h = self.tree.bbox(row, column)
             entryedit = ttk.Entry(self)
@@ -89,11 +93,8 @@ class ConfigEditorFrame(ttk.Frame):
             event.widget.destroy()
 
     def _make_tree_editable(self):
-        """
-        Add a binding to the treeview that allows double-clicking on a cell to edit its
-        value.
-
-        Source: https://stackoverflow.com/questions/75787251/create-an-editable-tkinter-treeview-with-keyword-connection
+        """Add a binding to the treeview that allows double-clicking on a cell to edit
+        its value.
         """
         self.tree.bind("<Double-1>", self._set_cell_value)
         self.parent.bind("<MouseWheel>", self._destroy_entries)  # type: ignore
@@ -101,13 +102,25 @@ class ConfigEditorFrame(ttk.Frame):
 
     def _load_config_into_tree(self):
         """Load the configuration options into the treeview for display and editing."""
-        for section in self.scraper.config.sections():
+        for section in config.sections():
             if section == "App Settings":
                 continue
             section_level = self.tree.insert("", "end", iid=section, text=section)
-            for config_option, value in self.scraper.config.items(section):
-                title_option = config_option.replace("_", " ").title()
-                self.tree.insert(section_level, "end", text=title_option, values=[value])
+            for config_option, value in config.items(section):
+                if section == "Custom Items":
+                    custom_item_name = unquote(config_option.split("/")[-1])
+                    self.tree.insert(section_level, "end", text=custom_item_name, values=[value])
+                else:
+                    option_name = config_option.replace("_", " ").title()
+                    self.tree.insert(section_level, "end", text=option_name, values=[value])
+
+    def reload_config_into_tree(self):
+        """Reload the configuration options into the treeview for display and
+        editing.
+        """
+        for item in self.tree.get_children():
+            self.tree.delete(item)
+        self._load_config_into_tree()
 
     def _configure_treeview(self):
         """Configure a treeview to display and edit configuration options."""
@@ -124,7 +137,7 @@ class ConfigEditorFrame(ttk.Frame):
         scrollbar.config(command=self.tree.yview)
 
         self.tree.column("#0", anchor="w", width=200)
-        self.tree.column(1, anchor="w", width=25)
+        self.tree.column(1, anchor="center", width=25)
         self.tree.heading("#0", text="Option")
         self.tree.heading(1, text="Value")
 
@@ -133,15 +146,13 @@ class ConfigEditorFrame(ttk.Frame):
 
 
 class ConfigEditorButtonFrame(ttk.Frame):
-    def __init__(self, parent, scraper, tree):
+    def __init__(self, parent, tree):
         """Initialize the button frame that contains buttons for saving the updated
         configuration and adding custom items.
         """
-
         super().__init__(parent, padding=10)
 
         self.parent = parent
-        self.scraper = scraper
         self.tree = tree
         self.custom_item_dialog = None
 
@@ -157,11 +168,14 @@ class ConfigEditorButtonFrame(ttk.Frame):
         reset_button = ttk.Button(self, text="Reset", command=self._reset_config)
         reset_button.pack(side="left", expand=True, padx=5)
 
-        custom_item_button = ttk.Button(
-            self, text="Add Custom Item", command=self._open_custom_item_dialog
-        )
+        custom_item_button = ttk.Button(self, text="Add Custom Item", command=self._add_custom_item)
         custom_item_button.pack(side="left", expand=True, padx=5)
 
+        import_inventory_button = ttk.Button(
+            self, text="Import Steam Inventory", command=self._import_steam_inventory
+        )
+        import_inventory_button.pack(side="left", expand=True, padx=5)
+
     def _save_config(self):
         """Save the current configuration from the treeview to the config file."""
         for child in self.tree.get_children():
@@ -174,15 +188,17 @@ class ConfigEditorButtonFrame(ttk.Frame):
                 if section_name == "Custom Items":
                     # custom items are already saved upon creation (Saving them again would result in duplicates)
                     continue
-                self.scraper.config.set(section_name, config_option, value)
+                config.set(section_name, config_option, value)
 
-        self.scraper.config.write_to_file()
-        if self.scraper.config.valid:
+        config.write_to_file()
+        if config.valid:
             messagebox.showinfo("Config Saved", "The configuration has been saved successfully.")
         else:
+            config.load()
+            self.parent.reload_config_into_tree()
             messagebox.showerror(
                 "Config Error",
-                f"The configuration is invalid. ({self.scraper.config.last_error})",
+                f"The configuration is invalid. ({config.last_error})",
             )
 
     def _reset_config(self):
@@ -192,15 +208,59 @@ class ConfigEditorButtonFrame(ttk.Frame):
         )
         if confirm:
             copy(CONFIG_FILE_BACKUP, CONFIG_FILE)
-            self.scraper.load_config()
+            config.load()
             self.parent.reload_config_into_tree()
 
+    def _add_custom_item(self):
+        """Open a window to add a new custom item."""
+        custom_item_window = tk.Toplevel(self.parent)
+        custom_item_window.title(ADD_CUSTOM_ITEM_TITLE)
+        custom_item_window.geometry(ADD_CUSTOM_ITEM_SIZE)
+
+        custom_item_frame = CustomItemFrame(custom_item_window, self.parent, self.tree)
+        custom_item_frame.pack(expand=True, fill="both", padx=15, pady=15)
+
+    def _import_steam_inventory(self):
+        """Open a window to import the user's Steam inventory."""
+        steam_inventory_window = tk.Toplevel(self.parent)
+        steam_inventory_window.title(IMPORT_INVENTORY_TITLE)
+        steam_inventory_window.geometry(IMPORT_INVENTORY_SIZE)
+
+        steam_inventory_frame = InventoryImportFrame(steam_inventory_window, self)
+        steam_inventory_frame.pack(expand=True, fill="both", padx=15, pady=15)
+
+
+class CustomItemFrame(ttk.Frame):
+    def __init__(self, parent, grandparent, tree):
+        """Initialize the custom item frame that allows users to add custom items."""
+        super().__init__(parent, style="Card.TFrame", padding=15)
+        self.parent = parent
+        self.grandparent = grandparent
+        self.tree = tree
+        self._add_widgets()
+
+    def _add_widgets(self):
+        """Add widgets to the custom item frame for entering item details."""
+        ttk.Label(self, text="Item URL:").pack(pady=5)
+        item_url_entry = ttk.Entry(self)
+        item_url_entry.pack(fill="x", padx=10)
+
+        ttk.Label(self, text="Owned Count:").pack(pady=5)
+        item_owned_entry = ttk.Entry(self)
+        item_owned_entry.pack(fill="x", padx=10)
+
+        add_button = ttk.Button(
+            self,
+            text="Add",
+            command=lambda: self._add_custom_item(item_url_entry.get(), item_owned_entry.get()),
+        )
+        add_button.pack(pady=10)
+
     def _add_custom_item(self, item_url, item_owned):
         """Add a custom item to the configuration."""
         if not item_url or not item_owned:
             messagebox.showerror("Input Error", "All fields must be filled out.")
             return
-
         try:
             if int(item_owned) < 0:
                 raise ValueError("Owned count must be a non-negative integer.")
@@ -208,40 +268,207 @@ class ConfigEditorButtonFrame(ttk.Frame):
             messagebox.showerror("Input Error", f"Invalid owned count: {error}")
             return
 
-        self.scraper.config.set("Custom Items", item_url, item_owned)
-        self.scraper.config.write_to_file()
-        if self.scraper.config.valid:
-            self.tree.insert("Custom Items", "end", text=item_url, values=(item_owned,))
-            if self.custom_item_dialog:
-                self.custom_item_dialog.destroy()
-                self.custom_item_dialog = None
+        config.set("Custom Items", item_url, item_owned)
+        config.write_to_file()
+        if config.valid:
+            config.load()
+            self.grandparent.reload_config_into_tree()
+            self.parent.destroy()
         else:
-            self.scraper.config.remove_option("Custom Items", item_url)
+            config.remove_option("Custom Items", item_url)
             messagebox.showerror(
                 "Config Error",
-                f"The configuration is invalid. ({self.scraper.config.last_error})",
+                f"The configuration is invalid. ({config.last_error})",
             )
 
-    def _open_custom_item_dialog(self):
-        """Open a dialog to enter custom item details."""
-        self.custom_item_dialog = tk.Toplevel(self.parent)
-        self.custom_item_dialog.title(NEW_CUSTOM_ITEM_TITLE)
-        self.custom_item_dialog.geometry(NEW_CUSTOM_ITEM_SIZE)
 
-        dialog_frame = ttk.Frame(self.custom_item_dialog, padding=10)
-        dialog_frame.pack(expand=True, fill="both")
+class InventoryImportFrame(ttk.Frame):
+    # pylint: disable=too-many-instance-attributes
+    def __init__(self, parent, grandparent):
+        """Initialize the inventory import frame that allows users to import their Steam
+        inventory.
+        """
+        super().__init__(parent, style="Card.TFrame", padding=10)
+        self.parent = parent
+        self.grandparent = grandparent
+        self._add_widgets()
 
-        ttk.Label(dialog_frame, text="Item URL:").pack(pady=5)
-        item_url_entry = ttk.Entry(dialog_frame)
-        item_url_entry.pack(fill="x", padx=10)
+    def _add_widgets(self):
+        """Add widgets to the inventory import frame."""
+        self._configure_checkboxes()
+        self.import_cases_checkbox.pack(anchor="w", padx=10, pady=5)
+        self.import_sticker_capsules_checkbox.pack(anchor="w", padx=10, pady=5)
+        self.import_stickers_checkbox.pack(anchor="w", padx=10, pady=5)
+        self.import_others_checkbox.pack(anchor="w", padx=10, pady=5)
+
+        self._configure_entries()
+        self.user_name_label.pack(pady=10)
+        self.user_name_entry.pack(fill="x", padx=50)
+        self.password_label.pack(pady=10)
+        self.password_entry.pack(fill="x", padx=50)
+        self.two_factor_label.pack(pady=10)
+        self.two_factor_entry.pack(fill="x", padx=50)
+
+        self.import_button = ttk.Button(self, text="Import", command=self._import_inventory)
+        self.import_button.pack(pady=10)
+
+    def _configure_checkboxes(self):
+        # pylint: disable=attribute-defined-outside-init
+        """Configure the checkboxes for selecting what to import from the Steam
+        inventory.
+        """
+        self.import_cases_value = tk.BooleanVar(value=True)
+        self.import_cases_checkbox = ttk.Checkbutton(
+            self, text="Import Cases", variable=self.import_cases_value, style="Switch.TCheckbutton"
+        )
 
-        ttk.Label(dialog_frame, text="Owned Count:").pack(pady=5)
-        item_owned_entry = ttk.Entry(dialog_frame)
-        item_owned_entry.pack(fill="x", padx=10)
+        self.import_sticker_capsules_value = tk.BooleanVar(value=True)
+        self.import_sticker_capsules_checkbox = ttk.Checkbutton(
+            self,
+            text="Import Sticker Capsules",
+            variable=self.import_sticker_capsules_value,
+            style="Switch.TCheckbutton",
+        )
 
-        add_button = ttk.Button(
-            dialog_frame,
-            text="Add",
-            command=lambda: self._add_custom_item(item_url_entry.get(), item_owned_entry.get()),
+        self.import_stickers_value = tk.BooleanVar(value=True)
+        self.import_stickers_checkbox = ttk.Checkbutton(
+            self,
+            text="Import Stickers",
+            variable=self.import_stickers_value,
+            style="Switch.TCheckbutton",
         )
-        add_button.pack(pady=10)
+
+        self.import_others_value = tk.BooleanVar(value=True)
+        self.import_others_checkbox = ttk.Checkbutton(
+            self,
+            text="Import Other Items",
+            variable=self.import_others_value,
+            style="Switch.TCheckbutton",
+        )
+
+    def _configure_entries(self):
+        # pylint: disable=attribute-defined-outside-init
+        """Configure the entry fields for Steam username, password, and two-factor
+        code.
+        """
+        self.user_name_label = ttk.Label(self, text="Steam Username:")
+        self.user_name_entry = ttk.Entry(self)
+
+        self.password_label = ttk.Label(self, text="Steam Password:")
+        self.password_entry = ttk.Entry(self, show="*")
+
+        self.two_factor_label = ttk.Label(self, text="Steam Guard Code (if enabled):")
+        self.two_factor_entry = ttk.Entry(self)
+
+    def _import_inventory(self):
+        """
+        Call the node.js script to import the user's Steam inventory.
+
+        This will also install the necessary npm packages if they are not already
+        installed.
+        """
+        import_cases = self.import_cases_value.get()
+        import_sticker_capsules = self.import_sticker_capsules_value.get()
+        import_stickers = self.import_stickers_value.get()
+        import_others = self.import_others_value.get()
+
+        username = self.user_name_entry.get().strip()
+        password = self.password_entry.get().strip()
+        two_factor_code = self.two_factor_entry.get().strip()
+
+        self._display_node_subprocess(
+            [
+                INVENTORY_IMPORT_SCRIPT,
+                INVENTORY_IMPORT_FILE,
+                str(import_cases),
+                str(import_sticker_capsules),
+                str(import_stickers),
+                str(import_others),
+                username,
+                password,
+                two_factor_code,
+            ]
+        )
+
+        self.parent.destroy()
+
+    def _display_node_subprocess(self, node_cmd):
+        text_window = tk.Toplevel(self.grandparent)
+        text_window.title(IMPORT_INVENTORY_PROCESS_TITLE)
+        text_window.geometry(IMPORT_INVENTORY_PROCESS_SIZE)
+
+        process_frame = InventoryImportProcessFrame(text_window)
+        process_frame.pack(expand=True, fill="both", padx=15, pady=15)
+        process_frame.start(node_cmd)
+        process_frame.console.focus_set()
+
+
+class InventoryImportProcessFrame(ttk.Frame):
+    # pylint: disable=attribute-defined-outside-init
+    # Source: https://stackoverflow.com/questions/27327886/issues-intercepting-subprocess-output-in-real-time
+    def __init__(self, parent):
+        """Initialize the frame that displays the output of the subprocess."""
+        super().__init__(parent)
+        self.parent = parent
+        self._add_widgets()
+
+    def _add_widgets(self):
+        """Add a text widget to display the output of the subprocess."""
+        self.scrollbar = ttk.Scrollbar(self)
+        self.scrollbar.pack(side="right", fill="y", padx=(5, 0))
+
+        self.console = ThemedText(self, wrap="word", yscrollcommand=self.scrollbar.set)
+        self.console.config(state="disabled")
+        self.console.pack(expand=True, fill="both", padx=10, pady=10)
+
+        self.scrollbar.config(command=self.console.yview)
+
+    def _read_lines(self, process, queue):
+        """Read lines from the subprocess output and put them in a queue."""
+        while process.poll() is None:
+            line = process.stdout.readline()
+            if line:
+                queue.put(line)
+
+    def start(self, cmd):
+        """Start the NodeJS subprocess with the given command and read its output."""
+        self.process = node.Popen(
+            cmd,
+            stdout=PIPE,
+            stdin=PIPE,
+            stderr=STDOUT,
+            text=True,
+            bufsize=1,
+            encoding="utf-8",
+        )
+        self.queue = Queue()
+        self.thread = Thread(target=self._read_lines, args=(self.process, self.queue), daemon=True)
+        self.thread.start()
+
+        self.after(100, self._update_lines)
+
+    def _update_lines(self):
+        """Update the text widget with lines from the subprocess output."""
+        try:
+            line = self.queue.get(block=False)
+            self.console.config(state="normal")
+            self.console.insert("end", line)
+            self.console.config(state="disabled")
+            self.console.yview("end")
+        except Empty:
+            pass
+
+        if self.process.poll() is None or not self.queue.empty():
+            self.after(100, self._update_lines)
+        else:
+            self._cleanup()
+
+    def _cleanup(self):
+        """Clean up the process and thread after completion and trigger a config update
+        from the newly written inventory file.
+        """
+        config.read_from_inventory_file()
+        self.parent.master.master.reload_config_into_tree()
+
+        self.process.wait()
+        self.thread.join()

cs2tracker/app/scraper_frame.py

@@ -1,5 +1,5 @@
 import csv
-from tkinter import ttk
+from tkinter import messagebox, ttk
 from tkinter.filedialog import asksaveasfilename
 
 from tksheet import Sheet
@@ -23,12 +23,23 @@ class ScraperFrame(ttk.Frame):
         self._configure_sheet()
         self.sheet.pack()
 
+    def _readjust_sheet_size_with_window_size(self, event):
+        """Ensures that the sheet resizes with the window."""
+        if event.widget == self.parent:
+            width, height = event.width, event.height
+            if width != self.sheet_width or height != self.sheet_height:
+                self.sheet_width = width
+                self.sheet_height = height
+                self.sheet.height_and_width(height, width)
+                self.parent.update()
+                self.parent.update_idletasks()
+
     def _configure_sheet(self):
         """Configure the sheet widget with initial data and settings."""
         self.sheet = Sheet(  # pylint: disable=attribute-defined-outside-init
             self,
             data=[],
-            theme="light" if self.dark_theme else "dark",
+            theme="light" if self.dark_theme else "dark",  # This is on purpose to add contrast
             height=self.sheet_height,
             width=self.sheet_width,
             auto_resize_columns=150,
@@ -44,6 +55,8 @@ class ScraperFrame(ttk.Frame):
         self.sheet.align_columns([1, 2, 3], "c")
         self.sheet.popup_menu_add_command("Save Sheet", self._save_sheet)
 
+        self.parent.bind("<Configure>", self._readjust_sheet_size_with_window_size)
+
     def _save_sheet(self):
         """Export the current sheet data to a CSV file."""
         filepath = asksaveasfilename(
@@ -74,3 +87,7 @@ class ScraperFrame(ttk.Frame):
         row_heights = self.sheet.get_row_heights()
         last_row_index = len(row_heights) - 1
         self.sheet.align_rows(last_row_index, "c")
+
+        if self.scraper.error_stack:
+            last_error = self.scraper.error_stack[-1]
+            messagebox.showerror("An Error Occurred", f"{last_error.message}")