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

cs2tracker/app/__init__.py

@@ -0,0 +1,3 @@
+from cs2tracker.app.application import (  # noqa: F401 # pylint:disable=unused-import
+    Application,
+)

cs2tracker/app/application.py

@@ -0,0 +1,255 @@
+import ctypes
+import tkinter as tk
+from shutil import copy
+from tkinter import messagebox, ttk
+from tkinter.filedialog import askopenfilename, asksaveasfile
+from typing import cast
+
+import matplotlib.pyplot as plt
+import sv_ttk
+from matplotlib.axes import Axes
+from matplotlib.dates import DateFormatter
+
+from cs2tracker.app.editor_frame import ConfigEditorFrame
+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
+
+APPLICATION_NAME = "CS2Tracker"
+WINDOW_SIZE = "630x335"
+DARK_THEME = True
+
+SCRAPER_WINDOW_TITLE = "CS2Tracker Scraper"
+SCRAPER_WINDOW_SIZE = "900x750"
+
+CONFIG_EDITOR_TITLE = "Config Editor"
+CONFIG_EDITOR_SIZE = "800x750"
+
+
+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()
+
+        if DARK_THEME:
+            sv_ttk.use_dark_theme()
+        else:
+            sv_ttk.use_light_theme()
+
+        self.application_window.mainloop()
+
+    def _add_button(self, frame, 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.grid(**grid_pos)
+
+    def _configure_button_frame(self, main_frame):
+        """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._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)
+
+    def _add_checkbox(
+        self, frame, text, variable, command, row
+    ):  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        """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,
+            text=text,
+            variable=variable,
+            command=command,
+            style="Switch.TCheckbutton",
+        )
+        checkbox.grid(**grid_pos)
+
+    def _configure_checkbox_frame(self, main_frame):
+        """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")
+
+        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()),
+            0,
+        )
+
+        discord_webhook_checkbox_value = tk.BooleanVar(
+            value=self.scraper.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())
+            ),
+            1,
+        )
+
+        use_proxy_checkbox_value = tk.BooleanVar(
+            value=self.scraper.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())
+            ),
+            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
+
+    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.geometry(SCRAPER_WINDOW_SIZE)
+        scraper_window.title(SCRAPER_WINDOW_TITLE)
+
+        run_frame = ScraperFrame(
+            scraper_window,
+            self.scraper,
+            sheet_size=SCRAPER_WINDOW_SIZE,
+            dark_theme=self.dark_theme_checkbox_value.get(),
+        )
+        run_frame.pack(expand=True, fill="both")
+        run_frame.start()
+
+    def _edit_config(self):
+        """Open a new window with a config editor GUI."""
+        config_editor_window = tk.Toplevel(self.application_window)
+        config_editor_window.geometry(CONFIG_EDITOR_SIZE)
+        config_editor_window.title(CONFIG_EDITOR_TITLE)
+
+        editor_frame = ConfigEditorFrame(config_editor_window, self.scraper)
+        editor_frame.pack(expand=True, fill="both")
+
+    def _draw_plot(self):
+        """Draw a plot of the scraped prices over time."""
+        dates, usd_prices, eur_prices = PriceLogs.read()
+
+        fig, ax_raw = plt.subplots(figsize=(10, 8), num="CS2Tracker Price History")
+        fig.suptitle("CS2Tracker Price History", fontsize=16)
+        fig.autofmt_xdate()
+
+        ax = cast(Axes, ax_raw)
+        ax.plot(dates, usd_prices, label="Dollars")
+        ax.plot(dates, eur_prices, label="Euros")
+        ax.legend()
+        date_formatter = DateFormatter("%Y-%m-%d")
+        ax.xaxis.set_major_formatter(date_formatter)
+
+        plt.show()
+
+    def _export_log_file(self):
+        """Lets the user export the log file to a different location."""
+        export_path = asksaveasfile(
+            title="Export Log File",
+            defaultextension=".csv",
+            filetypes=[("CSV File", "*.csv")],
+        )
+        if export_path:
+            copy(OUTPUT_FILE, export_path.name)
+
+    def _import_log_file(self):
+        """Lets the user import a log file from a different location."""
+        import_path = askopenfilename(
+            title="Import Log File",
+            defaultextension=".csv",
+            filetypes=[("CSV files", "*.csv")],
+        )
+        if not PriceLogs.validate_file(import_path):
+            return
+        copy(import_path, OUTPUT_FILE)
+
+    def _toggle_background_task(self, enabled: bool):
+        """Toggle whether a daily price calculation should run in the background."""
+        BackgroundTask.toggle(enabled)
+
+    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)
+        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.",
+            )
+            return False
+
+        self.scraper.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
+        )
+        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.",
+            )
+            return False
+
+        self.scraper.toggle_discord_webhook(enabled)
+        return True

cs2tracker/app/editor_frame.py

@@ -0,0 +1,247 @@
+import tkinter as tk
+from shutil import copy
+from tkinter import messagebox, ttk
+
+from cs2tracker.constants import CONFIG_FILE, CONFIG_FILE_BACKUP
+
+# from tksheet import Sheet
+
+NEW_CUSTOM_ITEM_TITLE = "Add Custom Item"
+NEW_CUSTOM_ITEM_SIZE = "500x200"
+
+
+class ConfigEditorFrame(ttk.Frame):
+    def __init__(self, parent, scraper):
+        """Initialize the configuration editor frame that allows users to view and edit
+        the configuration options.
+        """
+
+        super().__init__(parent, style="Card.TFrame", 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.
+        """
+        self._configure_treeview()
+        self.tree.pack(expand=True, fill="both")
+
+        button_frame = ConfigEditorButtonFrame(self, self.scraper, 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.
+        """
+
+        def save_edit(event):
+            self.tree.set(row, column=column, value=event.widget.get())
+            event.widget.destroy()
+
+        try:
+            row = self.tree.identify_row(event.y)
+            column = self.tree.identify_column(event.x)
+            item_text = self.tree.set(row, column)
+            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()):
+                    return
+            x, y, w, h = self.tree.bbox(row, column)
+            entryedit = ttk.Entry(self)
+            entryedit.place(x=x, y=y, width=w, height=h + 3)  # type: ignore
+            entryedit.insert("end", item_text)
+            entryedit.bind("<Return>", save_edit)
+            entryedit.focus_set()
+            entryedit.grab_set()
+        except Exception:
+            pass
+
+    def _destroy_entries(self, _):
+        """Destroy any entry widgets in the treeview on an event, such as a mouse wheel
+        movement.
+        """
+        for widget in self.winfo_children():
+            if isinstance(widget, ttk.Entry):
+                widget.destroy()
+
+    def _destroy_entry(self, event):
+        """Destroy the entry widget on an even targeting it."""
+        if isinstance(event.widget, ttk.Entry):
+            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
+        """
+        self.tree.bind("<Double-1>", self._set_cell_value)
+        self.parent.bind("<MouseWheel>", self._destroy_entries)  # type: ignore
+        self.parent.bind("<Button-1>", self._destroy_entry)  # type: ignore
+
+    def _load_config_into_tree(self):
+        """Load the configuration options into the treeview for display and editing."""
+        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 _configure_treeview(self):
+        """Configure a treeview to display and edit configuration options."""
+        scrollbar = ttk.Scrollbar(self)
+        scrollbar.pack(side="right", fill="y", padx=(5, 0))
+
+        self.tree = ttk.Treeview(  # pylint: disable=attribute-defined-outside-init
+            self,
+            columns=(1,),
+            height=10,
+            selectmode="browse",
+            yscrollcommand=scrollbar.set,
+        )
+        scrollbar.config(command=self.tree.yview)
+
+        self.tree.column("#0", anchor="w", width=200)
+        self.tree.column(1, anchor="w", width=25)
+        self.tree.heading("#0", text="Option")
+        self.tree.heading(1, text="Value")
+
+        self._load_config_into_tree()
+        self._make_tree_editable()
+
+
+class ConfigEditorButtonFrame(ttk.Frame):
+    def __init__(self, parent, scraper, 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
+
+        self._add_widgets()
+
+    def _add_widgets(self):
+        """Add buttons to the button frame for saving the configuration and adding
+        custom items.
+        """
+        save_button = ttk.Button(self, text="Save", command=self._save_config)
+        save_button.pack(side="left", expand=True, padx=5)
+
+        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.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():
+            for item in self.tree.get_children(child):
+                title_option = self.tree.item(item, "text")
+                config_option = title_option.lower().replace(" ", "_")
+                value = self.tree.item(item, "values")[0]
+                section = self.tree.parent(item)
+                section_name = self.tree.item(section, "text")
+                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)
+
+        self.scraper.config.write_to_file()
+        if self.scraper.config.valid:
+            messagebox.showinfo("Config Saved", "The configuration has been saved successfully.")
+        else:
+            messagebox.showerror(
+                "Config Error",
+                f"The configuration is invalid. ({self.scraper.config.last_error})",
+            )
+
+    def _reset_config(self):
+        """Reset the configuration file to its default state."""
+        confirm = messagebox.askokcancel(
+            "Reset Config", "Are you sure you want to reset the configuration?"
+        )
+        if confirm:
+            copy(CONFIG_FILE_BACKUP, CONFIG_FILE)
+            self.scraper.load_config()
+            self.parent.reload_config_into_tree()
+
+    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.")
+        except ValueError as error:
+            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
+        else:
+            self.scraper.config.remove_option("Custom Items", item_url)
+            messagebox.showerror(
+                "Config Error",
+                f"The configuration is invalid. ({self.scraper.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")
+
+        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)
+
+        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)
+
+        add_button = ttk.Button(
+            dialog_frame,
+            text="Add",
+            command=lambda: self._add_custom_item(item_url_entry.get(), item_owned_entry.get()),
+        )
+        add_button.pack(pady=10)

cs2tracker/app/scraper_frame.py

@@ -0,0 +1,76 @@
+import csv
+from tkinter import ttk
+from tkinter.filedialog import asksaveasfilename
+
+from tksheet import Sheet
+
+
+class ScraperFrame(ttk.Frame):
+    def __init__(self, parent, scraper, sheet_size, dark_theme):
+        """Initialize the frame for running the scraper."""
+        super().__init__(parent)
+
+        self.parent = parent
+        self.scraper = scraper
+        self.sheet_width = sheet_size.split("x")[0]
+        self.sheet_height = sheet_size.split("x")[1]
+        self.dark_theme = dark_theme
+
+        self._add_widgets()
+
+    def _add_widgets(self):
+        """Add widgets to the frame."""
+        self._configure_sheet()
+        self.sheet.pack()
+
+    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",
+            height=self.sheet_height,
+            width=self.sheet_width,
+            auto_resize_columns=150,
+            sticky="nsew",
+        )
+        self.sheet.enable_bindings()
+        self.sheet.insert_row(
+            ["Item Name", "Item Owned", "Steam Market Price (USD)", "Total Value Owned (USD)"]
+        )
+        self.sheet.column_width(0, 220)
+        self.sheet.column_width(1, 20)
+        self.sheet.align_rows([0], "c")
+        self.sheet.align_columns([1, 2, 3], "c")
+        self.sheet.popup_menu_add_command("Save Sheet", self._save_sheet)
+
+    def _save_sheet(self):
+        """Export the current sheet data to a CSV file."""
+        filepath = asksaveasfilename(
+            title="Save Price Sheet",
+            filetypes=[("CSV File", ".csv")],
+            defaultextension=".csv",
+        )
+        if filepath:
+            with open(filepath, "w", newline="", encoding="utf-8") as sheet_file:
+                writer = csv.writer(sheet_file)
+                writer.writerows(self.sheet.data)
+
+    def start(self):
+        """Start the scraper and update the sheet with the latest price data in real-
+        time.
+        """
+
+        def update_sheet_callback(row):
+            """Callback for the scraper to insert the latest price data into the
+            sheet.
+            """
+            self.sheet.insert_row(row)
+            self.parent.update()
+            self.parent.update_idletasks()
+
+        self.scraper.scrape_prices(update_sheet_callback)
+
+        row_heights = self.sheet.get_row_heights()
+        last_row_index = len(row_heights) - 1
+        self.sheet.align_rows(last_row_index, "c")