added window with the database statistics

.gitignore

@@ -4,3 +4,9 @@ __pycache__/
 anime_tracker.log
 todo.txt
 *.csv
+anime_backlog.db.bk
+*.db-wal
+*.db-shm
+dist/
+build/
+anime_env/

backend.py

@@ -1,6 +1,7 @@
 import sqlite3
 import csv
 import logging
+import html
 
 # Set up logging
 logging.basicConfig(filename='anime_tracker.log', level=logging.ERROR, 
@@ -8,7 +9,8 @@ logging.basicConfig(filename='anime_tracker.log', level=logging.ERROR,
 
 class AnimeBackend:
     def __init__(self):
-        self.db = sqlite3.connect('anime_backlog.db')
+        self.db = sqlite3.connect('anime_backlog.db', isolation_level=None)  # Autocommit mode to prevent locks
+        self.db.execute('PRAGMA journal_mode=WAL')  # Use WAL mode for better concurrency
         self.create_table()
 
     def create_table(self):
@@ -30,28 +32,10 @@ class AnimeBackend:
         except Exception as e:
             logging.error(f"Error creating table: {e}")
 
-    def get_pre_2010_entries(self, status_filter=None, type_filter=None, search=None, year_filter=None):
+    def get_pre_2010_entries(self):
         try:
             cursor = self.db.cursor()
-            sql = "SELECT * FROM anime WHERE year < 2010"
-            add_where = []
-            params = []
-            if year_filter is not None:
-                add_where.append("year = ?")
-                params.append(year_filter)
-            if status_filter is not None:
-                add_where.append("status = ?")
-                params.append(status_filter)
-            if type_filter is not None:
-                add_where.append("type = ?")
-                params.append(type_filter)
-            if search is not None:
-                add_where.append("(name LIKE ? OR comment LIKE ?)")
-                params.append(f"%{search}%")
-                params.append(f"%{search}%")
-            where_clause = " AND " + " AND ".join(add_where) if add_where else ""
-            sql += where_clause + " ORDER BY year DESC, name"
-            cursor.execute(sql, params)
+            cursor.execute("SELECT * FROM anime WHERE year < 2010 ORDER BY year DESC, name")
             return cursor.fetchall()
         except Exception as e:
             logging.error(f"Error getting pre-2010 entries: {e}")
@@ -66,25 +50,10 @@ class AnimeBackend:
             logging.error(f"Error getting years: {e}")
             return []
 
-    def get_entries_for_season(self, year, season, status_filter=None, type_filter=None, search=None):
+    def get_entries_for_season(self, year, season):
         try:
             cursor = self.db.cursor()
-            sql = "SELECT * FROM anime WHERE year = ? AND season = ?"
-            params = [year, season]
-            add_where = []
-            if status_filter is not None:
-                add_where.append("status = ?")
-                params.append(status_filter)
-            if type_filter is not None:
-                add_where.append("type = ?")
-                params.append(type_filter)
-            if search is not None:
-                add_where.append("(name LIKE ? OR comment LIKE ?)")
-                params.append(f"%{search}%")
-                params.append(f"%{search}%")
-            where_clause = " AND " + " AND ".join(add_where) if add_where else ""
-            sql += where_clause + " ORDER BY name"
-            cursor.execute(sql, params)
+            cursor.execute("SELECT * FROM anime WHERE year = ? AND season = ? ORDER BY name", (year, season))
             return cursor.fetchall()
         except Exception as e:
             logging.error(f"Error getting entries for season {season} in year {year}: {e}")
@@ -101,25 +70,64 @@ class AnimeBackend:
 
     def add_anime(self, data):
         try:
+            # Sanitize string inputs
+            sanitized_data = {
+                'name': html.escape(data['name'].strip()) if data['name'] else '',
+                'year': data['year'],
+                'season': data['season'].strip() if data['season'] else '',
+                'status': data['status'].strip() if data['status'] else 'unwatched',
+                'type': data['type'].strip() if data['type'] else '',
+                'comment': html.escape(data['comment'].strip()) if data['comment'] else '',
+                'url': data['url'].strip() if data['url'] else ''
+            }
             cursor = self.db.cursor()
             cursor.execute(
                 "INSERT INTO anime (name, year, season, status, type, comment, url) VALUES (?, ?, ?, ?, ?, ?, ?)",
-                (data['name'], data['year'], data['season'], data['status'], data['type'], data['comment'], data['url'])
+                (
+                    sanitized_data['name'],
+                    sanitized_data['year'],
+                    sanitized_data['season'],
+                    sanitized_data['status'],
+                    sanitized_data['type'],
+                    sanitized_data['comment'],
+                    sanitized_data['url']
+                )
             )
             self.db.commit()
         except Exception as e:
             logging.error(f"Error adding anime: {e}")
+            self.db.rollback()
 
     def edit_anime(self, anime_id, data):
         try:
+            # Sanitize string inputs
+            sanitized_data = {
+                'name': html.escape(data['name'].strip()) if data['name'] else '',
+                'year': data['year'],
+                'season': data['season'].strip() if data['season'] else '',
+                'status': data['status'].strip() if data['status'] else 'unwatched',
+                'type': data['type'].strip() if data['type'] else '',
+                'comment': html.escape(data['comment'].strip()) if data['comment'] else '',
+                'url': data['url'].strip() if data['url'] else ''
+            }
             cursor = self.db.cursor()
             cursor.execute(
                 "UPDATE anime SET name=?, year=?, season=?, status=?, type=?, comment=?, url=? WHERE id=?",
-                (data['name'], data['year'], data['season'], data['status'], data['type'], data['comment'], data['url'], anime_id)
+                (
+                    sanitized_data['name'],
+                    sanitized_data['year'],
+                    sanitized_data['season'],
+                    sanitized_data['status'],
+                    sanitized_data['type'],
+                    sanitized_data['comment'],
+                    sanitized_data['url'],
+                    anime_id
+                )
             )
             self.db.commit()
         except Exception as e:
             logging.error(f"Error editing anime id {anime_id}: {e}")
+            self.db.rollback()
 
     def delete_anime(self, anime_id):
         try:
@@ -128,6 +136,7 @@ class AnimeBackend:
             self.db.commit()
         except Exception as e:
             logging.error(f"Error deleting anime id {anime_id}: {e}")
+            self.db.rollback()
 
     def change_status(self, anime_id, new_status):
         try:
@@ -136,6 +145,7 @@ class AnimeBackend:
             self.db.commit()
         except Exception as e:
             logging.error(f"Error changing status for anime id {anime_id}: {e}")
+            self.db.rollback()
 
     def add_placeholders_for_year(self, year):
         try:
@@ -148,6 +158,7 @@ class AnimeBackend:
             self.db.commit()
         except Exception as e:
             logging.error(f"Error adding placeholders for year {year}: {e}")
+            self.db.rollback()
 
     def import_from_csv(self, file_name):
         try:
@@ -167,6 +178,13 @@ class AnimeBackend:
                             year = int(year_str)
                         except ValueError:
                             continue
+                        # Sanitize CSV inputs
+                        name = html.escape(name.strip()) if name else ''
+                        season = season.strip() if season else ''
+                        status = status.strip() if status else 'unwatched'
+                        type_ = type_.strip() if type_ else ''
+                        comment = html.escape(comment.strip()) if comment else ''
+                        url = url.strip() if url else ''
                         cursor.execute(
                             "SELECT id FROM anime WHERE name = ? AND year = ? AND season = ?",
                             (name, year, season)
@@ -179,6 +197,7 @@ class AnimeBackend:
                     self.db.commit()
         except Exception as e:
             logging.error(f"Error importing from CSV {file_name}: {e}")
+            self.db.rollback()
 
     def export_to_csv(self, file_name):
         try:
@@ -186,7 +205,7 @@ class AnimeBackend:
             cursor.execute("SELECT * FROM anime")
             rows = cursor.fetchall()
             with open(file_name, 'w', newline='') as f:
-                writer = csv.writer(f)
+                writer = csv.writer(f, quoting=csv.QUOTE_MINIMAL)
                 writer.writerow(['id', 'name', 'year', 'season', 'status', 'type', 'comment', 'url'])
                 writer.writerows(rows)
         except Exception as e:
@@ -198,4 +217,32 @@ class AnimeBackend:
             cursor.execute("DELETE FROM anime WHERE year = ?", (year,))
             self.db.commit()
         except Exception as e:
-            logging.error(f"Error deleting year {year}: {e}")
+            logging.error(f"Error deleting year {year}: {e}")
+            self.db.rollback()
+
+    def get_total_entries(self):
+        try:
+            cursor = self.db.cursor()
+            cursor.execute("SELECT COUNT(*) FROM anime")
+            return cursor.fetchone()[0]
+        except Exception as e:
+            logging.error(f"Error getting total entries: {e}")
+            return 0
+
+    def get_completed_entries(self):
+        try:
+            cursor = self.db.cursor()
+            cursor.execute("SELECT COUNT(*) FROM anime WHERE status = 'completed'")
+            return cursor.fetchone()[0]
+        except Exception as e:
+            logging.error(f"Error getting completed entries: {e}")
+            return 0
+
+    def get_entries_by_type(self):
+        try:
+            cursor = self.db.cursor()
+            cursor.execute("SELECT type, COUNT(*) FROM anime GROUP BY type ORDER BY 2 DESC")
+            return cursor.fetchall()  # Returns list of tuples: (type, count)
+        except Exception as e:
+            logging.error(f"Error getting entries by type: {e}")
+            return []

build.spec

@@ -0,0 +1,55 @@
+# -*- mode: python -*-
+from PyInstaller.utils.hooks import collect_data_files, collect_submodules
+
+block_cipher = None
+
+a = Analysis(
+    ['frontend.py'],
+    pathex=[],
+    binaries=[],
+    datas=[
+        ('icons', 'icons'),
+        ('anime_backlog.db', '.')
+    ],
+    hiddenimports=[
+        'backend',
+        'sqlite3',
+        *collect_submodules('PyQt5')
+    ],
+    hookspath=['.'],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False
+)
+
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    [],
+    exclude_binaries=True,
+    name='AnimeTracker',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    console=False,
+    disable_windowed_tracker=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+    icon='icons/anime-app-icon.png'
+)
+
+coll = COLLECT(
+    exe,
+    a.binaries,
+    a.zipfiles,
+    a.datas,
+    strip=False,
+    upx=True,
+    name='AnimeTracker',
+)

frontend.py

@@ -9,7 +9,7 @@ from PyQt5.QtWidgets import (
     QMainWindow, QTabWidget, QScrollArea, QWidget, QVBoxLayout, QTableWidget, QTableWidgetItem,
     QLabel, QToolButton, QHBoxLayout, QDialog, QFormLayout, QLineEdit, QSpinBox,
     QComboBox, QTextEdit, QDialogButtonBox, QAction, QFileDialog, QMessageBox,
-    QInputDialog, QApplication, QAbstractItemView, QSizePolicy, QHeaderView, QPushButton
+    QInputDialog, QApplication, QAbstractItemView, QSizePolicy, QHeaderView
 )
 from PyQt5.QtCore import Qt, QSettings
 from PyQt5.QtGui import QColor, QIcon, QFont
@@ -25,6 +25,7 @@ class AnimeDialog(QDialog):
         self.setWindowTitle("Add Anime" if entry is None else "Edit Anime")
         layout = QFormLayout(self)
         self.name_edit = QLineEdit()
+        self.name_edit.setMaxLength(255)  # Prevent overly long inputs
         layout.addRow("Name", self.name_edit)
         self.year_spin = QSpinBox()
         self.year_spin.setRange(1900, 2100)
@@ -39,20 +40,23 @@ class AnimeDialog(QDialog):
         self.status_combo.addItems(['unwatched', 'watching', 'completed'])
         layout.addRow("Status", self.status_combo)
         self.comment_edit = QTextEdit()
+        self.comment_edit.setAcceptRichText(False)  # Prevent HTML injection
         layout.addRow("Comment", self.comment_edit)
         self.url_edit = QLineEdit()
+        self.url_edit.setMaxLength(2048)  # Reasonable limit for URLs
         layout.addRow("MAL URL", self.url_edit)
         buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
         buttons.accepted.connect(self.accept)
         buttons.rejected.connect(self.reject)
         layout.addRow(buttons)
         if entry:
-            self.name_edit.setText(entry[1])
+            # Unescape for display in input fields
+            self.name_edit.setText(html.unescape(entry[1]))
             self.year_spin.setValue(entry[2])
             self.season_combo.setCurrentText(entry[3])
             self.status_combo.setCurrentText(entry[4])
             self.type_combo.setCurrentText(entry[5] or '')
-            self.comment_edit.setText(entry[6] or '')
+            self.comment_edit.setPlainText(html.unescape(entry[6] or ''))
             self.url_edit.setText(entry[7] or '')
         else:
             if default_year is not None:
@@ -70,14 +74,15 @@ class AnimeDialog(QDialog):
             self.season_combo.setEnabled(True)
 
     def get_data(self):
+        # Sanitize inputs by escaping special characters
         return {
-            'name': self.name_edit.text(),
+            'name': html.escape(self.name_edit.text().strip()),
             'year': self.year_spin.value(),
-            'season': self.season_combo.currentText(),
-            'status': self.status_combo.currentText(),
-            'type': self.type_combo.currentText(),
-            'comment': self.comment_edit.toPlainText(),
-            'url': self.url_edit.text()
+            'season': html.escape(self.season_combo.currentText().strip()),
+            'status': html.escape(self.status_combo.currentText().strip()),
+            'type': html.escape(self.type_combo.currentText().strip()),
+            'comment': html.escape(self.comment_edit.toPlainText().strip()),
+            'url': html.escape(self.url_edit.text().strip())
         }
 
 class ShortcutsDialog(QDialog):
@@ -92,7 +97,7 @@ Global Shortcuts:
 - A: Add an anime
 - Page Down: Next tab
 - Page Up: Previous tab
-- Q: Quit the program
+- Ctrl + Q: Quit the program
 - R: Pick random anime
 - Ctrl + + : Increase table scale
 - Ctrl + - : Decrease table scale
@@ -145,7 +150,12 @@ class AnimeTracker(QMainWindow):
     def __init__(self):
         super().__init__()
         self.settings = QSettings("xAI", "AnimeBacklogTracker")
+        self.last_used_season = self.settings.value("lastUsedSeason", "winter")
         self.setWindowTitle("Anime Backlog Tracker")
+        # Add application icon
+        icon_path = os.path.join(os.path.dirname(__file__), './icons/anime-app-icon.png')
+        if os.path.exists(icon_path):
+            self.setWindowIcon(QIcon(icon_path))
         self.resize(800, 600)
         self.backend = AnimeBackend()
         self.tab_widget = QTabWidget()
@@ -153,45 +163,18 @@ class AnimeTracker(QMainWindow):
         central_layout = QVBoxLayout(self.central_widget)
         self.filter_bar = QWidget()
         filter_layout = QHBoxLayout(self.filter_bar)
-        label_year = QLabel("Year:")
-        self.year_spin = QSpinBox()
-        self.year_spin.setRange(0, 2100)
-        self.year_spin.setValue(0)
-        self.year_spin.setSpecialValueText("All")
-        filter_layout.addWidget(label_year)
-        filter_layout.addWidget(self.year_spin)
-        label_season = QLabel("Season:")
-        self.season_combo = QComboBox()
-        self.season_combo.addItems(['All', 'winter', 'spring', 'summer', 'fall', 'Other'])
-        filter_layout.addWidget(label_season)
-        filter_layout.addWidget(self.season_combo)
-        label_status = QLabel("Status:")
-        self.status_combo = QComboBox()
-        self.status_combo.addItems(['All', 'unwatched', 'watching', 'completed'])
-        filter_layout.addWidget(label_status)
-        filter_layout.addWidget(self.status_combo)
-        label_type = QLabel("Type:")
-        self.type_combo = QComboBox()
-        self.type_combo.addItems(['All', 'TV', 'Movie', 'OVA', 'Special', 'Short TV', 'Other'])
-        filter_layout.addWidget(label_type)
-        filter_layout.addWidget(self.type_combo)
         label_search = QLabel("Search:")
         self.search_edit = QLineEdit()
-        self.search_edit.setPlaceholderText("Search name or comment")
+        self.search_edit.setPlaceholderText("Search name")
+        self.search_edit.textChanged.connect(self.filter_tables)
         filter_layout.addWidget(label_search)
         filter_layout.addWidget(self.search_edit)
-        apply_btn = QPushButton("Apply")
-        apply_btn.clicked.connect(self.apply_filters)
-        filter_layout.addWidget(apply_btn)
         central_layout.addWidget(self.filter_bar)
         central_layout.addWidget(self.tab_widget)
         self.setCentralWidget(self.central_widget)
-        self.year_filter = None
-        self.season_filter = None
-        self.status_filter = None
-        self.type_filter = None
-        self.search_text = None
+        self.search_text = ''
         self.table_scale = self.settings.value("tableScale", 1.0, type=float)
+        self.tables = []
         self.create_menu()
         self.load_tabs()
         self.restoreGeometry(self.settings.value("geometry", self.saveGeometry()))
@@ -200,18 +183,14 @@ class AnimeTracker(QMainWindow):
             self.set_current_tab_by_identifier(last_tab)
         self.tab_widget.setFocus()
 
-    def apply_filters(self):
-        year_val = self.year_spin.value()
-        self.year_filter = year_val if year_val > 0 else None
-        season_val = self.season_combo.currentText()
-        self.season_filter = None if season_val == 'All' else ('' if season_val == 'Other' else season_val)
-        status_val = self.status_combo.currentText()
-        self.status_filter = None if status_val == 'All' else status_val
-        type_val = self.type_combo.currentText()
-        self.type_filter = None if type_val == 'All' else type_val
-        search_val = self.search_edit.text().strip()
-        self.search_text = search_val if search_val else None
-        self.load_tabs()
+    def filter_tables(self, text):
+        self.search_text = text.strip().lower()
+        for table in self.tables:
+            for row in range(table.rowCount()):
+                name_col = 2 if table.is_pre else 1
+                name_text = table.cellWidget(row, name_col).text()
+                clean_name = re.sub(r'<[^>]+>', '', name_text).lower()
+                table.setRowHidden(row, self.search_text not in clean_name if self.search_text else False)
 
     def closeEvent(self, event):
         self.settings.setValue("geometry", self.saveGeometry())
@@ -242,6 +221,9 @@ class AnimeTracker(QMainWindow):
         random_act = QAction('Random Pick', self)
         random_act.triggered.connect(self.random_pick)
         tools_menu.addAction(random_act)
+        statistics_act = QAction('Statistics', self)
+        statistics_act.triggered.connect(self.show_statistics)
+        tools_menu.addAction(statistics_act)
         help_menu = menubar.addMenu('Help')
         shortcuts_act = QAction('Shortcuts', self)
         shortcuts_act.triggered.connect(self.show_shortcuts)
@@ -281,143 +263,148 @@ class AnimeTracker(QMainWindow):
 
     def load_tabs(self):
         self.tab_widget.clear()
-        show_pre = True
-        if self.season_filter is not None and self.season_filter != '':
-            show_pre = False
-        if self.year_filter is not None and self.year_filter >= 2010:
-            show_pre = False
-        if show_pre:
-            pre_entries = self.backend.get_pre_2010_entries(self.status_filter, self.type_filter, self.search_text, self.year_filter if self.year_filter and self.year_filter < 2010 else None)
-            pre_tab = QScrollArea()
-            pre_tab.setWidgetResizable(True)
-            pre_content = QWidget()
-            pre_layout = QVBoxLayout(pre_content)
-            if pre_entries:
-                table = CustomTableWidget(self, is_pre=True)
-                table.setRowCount(len(pre_entries))
-                table.setColumnCount(7)
-                headers = ['ID', 'Year', 'Name', 'Type', 'Status', 'Comment', 'Actions']
-                table.setHorizontalHeaderLabels(headers)
-                table.setColumnHidden(0, True)
-                table.setAlternatingRowColors(True)
-                table.setShowGrid(True)
-                header = table.horizontalHeader()
-                header.setStretchLastSection(False)
-                table.setSelectionBehavior(QAbstractItemView.SelectRows)
-                table.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
-                table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
-                header.setSectionResizeMode(0, QHeaderView.Fixed)  # ID hidden
-                header.setSectionResizeMode(1, QHeaderView.ResizeToContents)  # Year
-                header.setSectionResizeMode(2, QHeaderView.Stretch)  # Name
-                header.setSectionResizeMode(3, QHeaderView.ResizeToContents)  # Type
-                header.setSectionResizeMode(4, QHeaderView.ResizeToContents)  # Status
-                header.setSectionResizeMode(5, QHeaderView.Stretch)  # Comment
-                header.setSectionResizeMode(6, QHeaderView.ResizeToContents)  # Actions
-                table.setColumnWidth(0, 0)  # Set ID column width to 0 to ensure it's hidden
-                font = QFont()
-                font.setPointSize(int(10 * self.table_scale))
-                header_font = QFont()
-                header_font.setPointSize(int(10 * self.table_scale))
-                header_font.setBold(True)
-                table.setFont(font)
-                table.horizontalHeader().setFont(header_font)
-                table.verticalHeader().setFont(font)
-                for row, entry in enumerate(pre_entries):
-                    col = 0
-                    # ID
-                    id_item = QTableWidgetItem(str(entry[0]))
-                    table.setItem(row, col, id_item)
-                    col += 1
-                    # Year
-                    year_item = QTableWidgetItem(str(entry[2]))
-                    year_item.setFont(font)
-                    table.setItem(row, col, year_item)
-                    col += 1
-                    # Name
-                    name = entry[1]
-                    url = entry[7]
-                    name_label = QLabel()
-                    name_font = QFont(font)
-                    if entry[4] == 'watching':
-                        name_font.setItalic(True)
-                    elif entry[4] == 'completed':
-                        name_font.setStrikeOut(True)
-                    name_label.setFont(name_font)
-                    if url:
-                        name_escaped = html.escape(name)
-                        name_label.setText(f'<a href="{url}" style="color: #0000FF; text-decoration: none;">{name_escaped}</a>')
-                        name_label.setOpenExternalLinks(True)
-                    else:
-                        name_label.setText(html.escape(name))
-                    name_label.setStyleSheet("padding-left: 10px;")
-                    table.setCellWidget(row, col, name_label)
-                    col += 1
-                    # Type
-                    type_item = QTableWidgetItem(entry[5] or '')
-                    type_item.setFont(font)
-                    table.setItem(row, col, type_item)
-                    col += 1
-                    # Status
-                    status_item = QTableWidgetItem(entry[4])
-                    status_item.setFont(font)
-                    table.setItem(row, col, status_item)
-                    col += 1
-                    # Comment
-                    comment_item = QTableWidgetItem(entry[6] or '')
-                    comment_item.setFont(font)
-                    table.setItem(row, col, comment_item)
-                    col += 1
-                    # Actions
-                    actions_widget = self.create_actions_widget(entry[0], entry[4])
-                    for child in actions_widget.findChildren(QToolButton):
-                        child.setFont(font)
-                    table.setCellWidget(row, col, actions_widget)
-                table.resizeColumnsToContents()
-                table.resizeRowsToContents()
-                # Calculate fixed height
-                height = table.horizontalHeader().height() + 2  # small margin
-                for i in range(table.rowCount()):
-                    height += table.rowHeight(i)
-                table.setFixedHeight(height)
-                # Apply status colors
-                status_col = 4
-                for r in range(table.rowCount()):
-                    status = table.item(r, status_col).text()
-                    if status == 'unwatched':
-                        color = QColor(255, 255, 255)
-                    elif status == 'watching':
-                        color = QColor(255, 255, 0)
-                    elif status == 'completed':
-                        color = QColor(0, 255, 0)
-                    else:
-                        color = QColor(255, 255, 255)
-                    for c in range(table.columnCount()):
-                        if c == 0:
-                            continue  # skip hidden id
-                        item = table.item(r, c)
-                        if item:
-                            item.setBackground(color)
-                        widget = table.cellWidget(r, c)
-                        if widget:
-                            widget.setStyleSheet(f"background-color: {color.name()};")
-                pre_layout.addWidget(table)
-            pre_tab.setWidget(pre_content)
-            tab_text = "Pre-2010"
-            completed = False
-            total = len(pre_entries)
-            if total > 0:
-                comp = sum(1 for e in pre_entries if e[4] == 'completed')
-                perc = (comp / total * 100)
-                tab_text += f" ({perc:.0f}%)"
-                if comp == total:
-                    completed = True
-            index = self.tab_widget.addTab(pre_tab, tab_text)
-            if completed:
-                self.tab_widget.tabBar().setTabTextColor(index, QColor('gray'))
+        self.tables = []
+        # Pre-2010 tab
+        pre_entries = self.backend.get_pre_2010_entries()
+        pre_tab = QScrollArea()
+        pre_tab.setWidgetResizable(True)
+        pre_content = QWidget()
+        pre_layout = QVBoxLayout(pre_content)
+        if pre_entries:
+            table = CustomTableWidget(self, is_pre=True)
+            table.is_pre = True
+            self.tables.append(table)
+            table.setRowCount(len(pre_entries))
+            table.setColumnCount(7)
+            headers = ['ID', 'Year', 'Name', 'Type', 'Status', 'Comment', 'Actions']
+            table.setHorizontalHeaderLabels(headers)
+            table.setColumnHidden(4, True)  # Hide Status column
+            table.setColumnHidden(0, True)
+            table.setAlternatingRowColors(True)
+            table.setShowGrid(True)
+            header = table.horizontalHeader()
+            header.setStretchLastSection(False)
+            table.setSelectionBehavior(QAbstractItemView.SelectRows)
+            table.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+            table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+            header.setSectionResizeMode(0, QHeaderView.Fixed)  # ID hidden
+            header.setSectionResizeMode(1, QHeaderView.ResizeToContents)  # Year
+            header.setSectionResizeMode(2, QHeaderView.Stretch)  # Name
+            header.setSectionResizeMode(3, QHeaderView.ResizeToContents)  # Type
+            header.setSectionResizeMode(4, QHeaderView.ResizeToContents)  # Status
+            header.setSectionResizeMode(5, QHeaderView.Stretch)  # Comment
+            header.setSectionResizeMode(6, QHeaderView.ResizeToContents)  # Actions
+            table.setColumnWidth(0, 0)  # Set ID column width to 0 to ensure it's hidden
+            font = QFont()
+            font.setPointSize(int(10 * self.table_scale))
+            header_font = QFont()
+            header_font.setPointSize(int(10 * self.table_scale))
+            header_font.setBold(True)
+            table.setFont(font)
+            table.horizontalHeader().setFont(header_font)
+            table.verticalHeader().setFont(font)
+            # Add vertical header styling for index numbers
+            vheader = table.verticalHeader()
+            vheader.setDefaultAlignment(Qt.AlignCenter)
+            vheader.setStyleSheet("""
+                QHeaderView::section {
+                    padding-left: 5px;
+                    padding-right: 5px;
+                }
+            """)
+            for row, entry in enumerate(pre_entries):
+                col = 0
+                # ID
+                id_item = QTableWidgetItem(str(entry[0]))
+                table.setItem(row, col, id_item)
+                col += 1
+                # Year
+                year_item = QTableWidgetItem(str(entry[2]))
+                year_item.setFont(font)
+                table.setItem(row, col, year_item)
+                col += 1
+                # Name
+                name = entry[1]
+                url = entry[7]
+                name_label = QLabel()
+                name_font = QFont(font)
+                if entry[4] == 'watching':
+                    name_font.setItalic(True)
+                elif entry[4] == 'completed':
+                    name_font.setStrikeOut(True)
+                name_label.setFont(name_font)
+                if url:
+                    name_escaped = html.escape(name)
+                    name_label.setText(f' <a href="{url}" style="color: #0000FF; text-decoration: none;">{name_escaped}</a>')
+                    name_label.setOpenExternalLinks(True)
+                else:
+                    name_label.setText(html.escape(name))
+                table.setCellWidget(row, col, name_label)
+                col += 1
+                # Type
+                type_item = QTableWidgetItem(entry[5] or '')
+                type_item.setFont(font)
+                table.setItem(row, col, type_item)
+                col += 1
+                # Status
+                status_item = QTableWidgetItem(entry[4])
+                status_item.setFont(font)
+                table.setItem(row, col, status_item)
+                col += 1
+                # Comment
+                comment_item = QTableWidgetItem(entry[6] or '')
+                comment_item.setFont(font)
+                table.setItem(row, col, comment_item)
+                col += 1
+                # Actions
+                actions_widget = self.create_actions_widget(entry[0], entry[4])
+                for child in actions_widget.findChildren(QToolButton):
+                    child.setFont(font)
+                table.setCellWidget(row, col, actions_widget)
+            table.resizeColumnsToContents()
+            table.resizeRowsToContents()
+            # Calculate fixed height
+            height = table.horizontalHeader().height() + 2  # small margin
+            for i in range(table.rowCount()):
+                height += table.rowHeight(i)
+            table.setFixedHeight(height)
+            # Apply status colors
+            status_col = 4
+            for r in range(table.rowCount()):
+                status = table.item(r, status_col).text()
+                if status == 'unwatched':
+                    color = QColor(255, 255, 255)
+                elif status == 'watching':
+                    color = QColor(255, 255, 0)
+                elif status == 'completed':
+                    color = QColor(0, 255, 0)
+                else:
+                    color = QColor(255, 255, 255)
+                for c in range(table.columnCount()):
+                    if c == 0:
+                        continue  # skip hidden id
+                    item = table.item(r, c)
+                    if item:
+                        item.setBackground(color)
+                    widget = table.cellWidget(r, c)
+                    if widget:
+                        widget.setStyleSheet(f"padding-left: 2px;background-color: {color.name()};")
+            pre_layout.addWidget(table)
+        pre_tab.setWidget(pre_content)
+        tab_text = "Pre-2010"
+        completed = False
+        total = len(pre_entries)
+        if total > 0:
+            comp = sum(1 for e in pre_entries if e[4] == 'completed')
+            perc = (comp / total * 100)
+            tab_text += f" ({perc:.0f}%)"
+            if comp == total:
+                completed = True
+        index = self.tab_widget.addTab(pre_tab, tab_text)
+        if completed:
+            self.tab_widget.tabBar().setTabTextColor(index, QColor('gray'))
         # Years >= 2010
         years = self.backend.get_years()
-        if self.year_filter is not None:
-            years = [self.year_filter] if self.year_filter in years else []
         for year in years:
             year_tab = QScrollArea()
             year_tab.setWidgetResizable(True)
@@ -426,132 +413,167 @@ class AnimeTracker(QMainWindow):
             total_entries = 0
             comp_entries = 0
             for season in ['winter', 'spring', 'summer', 'fall', '']:
-                show_section = True
-                if self.season_filter is not None:
-                    if season != self.season_filter:
-                        show_section = False
-                if show_section:
-                    entries = self.backend.get_entries_for_season(year, season, self.status_filter, self.type_filter, self.search_text)
-                    if entries:
-                        s_name = season.capitalize() if season else 'Other'
-                        label = QLabel(s_name)
-                        season_font = QFont()
-                        season_font.setPointSize(int(12 * self.table_scale))
-                        season_font.setBold(True)
-                        label.setFont(season_font)
-                        layout.addWidget(label)
-                        table = CustomTableWidget(self, is_pre=False)
-                        table.setRowCount(len(entries))
-                        table.setColumnCount(6)
-                        headers = ['ID', 'Name', 'Type', 'Status', 'Comment', 'Actions']
-                        table.setHorizontalHeaderLabels(headers)
-                        table.setColumnHidden(0, True)
-                        table.setAlternatingRowColors(True)
-                        table.setShowGrid(True)
-                        header = table.horizontalHeader()
-                        header.setStretchLastSection(False)
-                        table.setSelectionBehavior(QAbstractItemView.SelectRows)
-                        table.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
-                        table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
-                        header.setSectionResizeMode(0, QHeaderView.Fixed)  # ID hidden
-                        header.setSectionResizeMode(1, QHeaderView.Stretch)  # Name
-                        header.setSectionResizeMode(2, QHeaderView.ResizeToContents)  # Type
-                        header.setSectionResizeMode(3, QHeaderView.ResizeToContents)  # Status
-                        header.setSectionResizeMode(4, QHeaderView.Stretch)  # Comment
-                        header.setSectionResizeMode(5, QHeaderView.ResizeToContents)  # Actions
-                        table.setColumnWidth(0, 0)  # Set ID column width to 0 to ensure it's hidden
-                        font = QFont()
-                        font.setPointSize(int(10 * self.table_scale))
-                        header_font = QFont()
-                        header_font.setPointSize(int(10 * self.table_scale))
-                        header_font.setBold(True)
-                        table.setFont(font)
-                        table.horizontalHeader().setFont(header_font)
-                        table.verticalHeader().setFont(font)
-                        for row, entry in enumerate(entries):
-                            col = 0
-                            # ID
-                            id_item = QTableWidgetItem(str(entry[0]))
-                            table.setItem(row, col, id_item)
-                            col += 1
-                            # Name
-                            name = entry[1]
-                            url = entry[7]
-                            name_label = QLabel()
-                            name_font = QFont(font)
-                            if entry[4] == 'watching':
-                                name_font.setItalic(True)
-                            elif entry[4] == 'completed':
-                                name_font.setStrikeOut(True)
-                            name_label.setFont(name_font)
-                            if url:
-                                name_escaped = html.escape(name)
-                                name_label.setText(f'<a href="{url}" style="color: #0000FF; text-decoration: none;">{name_escaped}</a>')
-                                name_label.setOpenExternalLinks(True)
-                            else:
-                                name_label.setText(html.escape(name))
-                            name_label.setStyleSheet("padding-left: 10px;")
-                            table.setCellWidget(row, col, name_label)
-                            col += 1
-                            # Type
-                            type_item = QTableWidgetItem(entry[5] or '')
-                            type_item.setFont(font)
-                            table.setItem(row, col, type_item)
-                            col += 1
-                            # Status
-                            status_item = QTableWidgetItem(entry[4])
-                            status_item.setFont(font)
-                            table.setItem(row, col, status_item)
-                            col += 1
-                            # Comment
-                            comment_item = QTableWidgetItem(entry[6] or '')
-                            comment_item.setFont(font)
-                            table.setItem(row, col, comment_item)
-                            col += 1
-                            # Actions
-                            actions_widget = self.create_actions_widget(entry[0], entry[4])
-                            for child in actions_widget.findChildren(QToolButton):
-                                child.setFont(font)
-                            table.setCellWidget(row, col, actions_widget)
-                        table.resizeColumnsToContents()
-                        table.resizeRowsToContents()
-                        # Calculate fixed height
-                        height = table.horizontalHeader().height() + 2  # small margin
-                        for i in range(table.rowCount()):
-                            height += table.rowHeight(i)
-                        table.setFixedHeight(height)
-                        # Apply status colors
-                        status_col = 3
-                        for r in range(table.rowCount()):
-                            status = table.item(r, status_col).text()
-                            if status == 'unwatched':
-                                color = QColor(255, 255, 255)
-                            elif status == 'watching':
-                                color = QColor(255, 255, 0)
-                            elif status == 'completed':
-                                color = QColor(0, 255, 0)
-                            else:
-                                color = QColor(255, 255, 255)
-                            for c in range(table.columnCount()):
-                                if c == 0:
-                                    continue  # skip hidden id
-                                item = table.item(r, c)
-                                if item:
-                                    item.setBackground(color)
-                                widget = table.cellWidget(r, c)
-                                if widget:
-                                    widget.setStyleSheet(f"background-color: {color.name()};")
-                        layout.addWidget(table)
-                    total_entries += len(entries)
-                    comp_entries += sum(1 for e in entries if e[4] == 'completed')
+                entries = self.backend.get_entries_for_season(year, season)
+                # Database schema order:
+                # 0: id
+                # 1: name  
+                # 2: year
+                # 3: season
+                # 4: status
+                # 5: type
+                # 6: comment
+                # 7: url
+                if entries:
+                    # Season title
+                    s_name = season.capitalize() if season else 'Other'
+                    label = QLabel()
+                    season_font = QFont()
+                    season_font.setPointSize(int(12 * self.table_scale))
+                    season_font.setBold(True)
+                    label.setFont(season_font)
+                    if season:  # Only create links for actual seasons, not 'Other'
+                        mal_url = f"https://myanimelist.net/anime/season/{year}/{season}"
+                        label.setText(f'<a href="{mal_url}" style="color: #0000FF; text-decoration: none; font-weight: bold;">{s_name}</a>')
+                        label.setTextFormat(Qt.RichText)
+                        label.setOpenExternalLinks(True)  # This makes the link clickable and open in browser
+                    else:
+                        label.setText(s_name)  # No link for 'Other' section
+
+                    layout.addWidget(label)
+
+                    # Season's stats
+                    total_anime = len(entries)
+                    completed_anime = sum(1 for entry in entries if entry[4] == 'completed')
+                    completion_percentage = (completed_anime / total_anime * 100) if total_anime > 0 else 0
+                    s_stat = QLabel(f"Completed: <b>{completed_anime}/{total_anime} ({completion_percentage:.0f}%)</b>")
+                    s_stat_font = QFont()
+                    s_stat_font.setPointSize(int(10 * self.table_scale))  # Slightly smaller than season label
+                    s_stat.setFont(s_stat_font)
+                    layout.addWidget(s_stat)
+                    table = CustomTableWidget(self, is_pre=False)
+                    table.is_pre = False
+                    self.tables.append(table)
+                    table.setRowCount(len(entries))
+                    table.setColumnCount(6)
+                    headers = ['ID', 'Name', 'Type', 'Status', 'Comment', 'Actions']
+                    table.setHorizontalHeaderLabels(headers)
+                    table.setColumnHidden(3, True)  # Hide Status column
+                    table.setColumnHidden(0, True)
+                    table.setAlternatingRowColors(True)
+                    table.setShowGrid(True)
+                    header = table.horizontalHeader()
+                    header.setStretchLastSection(False)
+                    table.setSelectionBehavior(QAbstractItemView.SelectRows)
+                    table.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+                    table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+                    header.setSectionResizeMode(0, QHeaderView.Fixed)  # ID hidden
+                    header.setSectionResizeMode(1, QHeaderView.Stretch)  # Name
+                    header.setSectionResizeMode(2, QHeaderView.ResizeToContents)  # Type
+                    header.setSectionResizeMode(3, QHeaderView.ResizeToContents)  # Status
+                    header.setSectionResizeMode(4, QHeaderView.Stretch)  # Comment
+                    header.setSectionResizeMode(5, QHeaderView.ResizeToContents)  # Actions
+                    table.setColumnWidth(0, 0)  # Set ID column width to 0 to ensure it's hidden
+                    font = QFont()
+                    font.setPointSize(int(10 * self.table_scale))
+                    header_font = QFont()
+                    header_font.setPointSize(int(10 * self.table_scale))
+                    header_font.setBold(True)
+                    table.setFont(font)
+                    table.horizontalHeader().setFont(header_font)
+                    table.verticalHeader().setFont(font)
+                    # Add vertical header styling for index numbers
+                    vheader = table.verticalHeader()
+                    vheader.setDefaultAlignment(Qt.AlignCenter)
+                    vheader.setStyleSheet("""
+                        QHeaderView::section {
+                            padding-left: 5px;
+                            padding-right: 5px;
+                        }
+                    """)
+                    for row, entry in enumerate(entries):
+                        col = 0
+                        # ID
+                        id_item = QTableWidgetItem(str(entry[0]))
+                        table.setItem(row, col, id_item)
+                        col += 1
+                        # Name
+                        name = entry[1]
+                        url = entry[7]
+                        name_label = QLabel()
+                        name_font = QFont(font)
+                        if entry[4] == 'watching':
+                            name_font.setItalic(True)
+                        elif entry[4] == 'completed':
+                            name_font.setStrikeOut(True)
+                        name_label.setFont(name_font)
+                        if url:
+                            name_escaped = html.escape(name)
+                            name_label.setText(f' <a href="{url}" style="color: #0000FF; text-decoration: none;">{name_escaped}</a>')
+                            name_label.setOpenExternalLinks(True)
+                        else:
+                            name_label.setText(html.escape(name))
+                        table.setCellWidget(row, col, name_label)
+                        col += 1
+                        # Type
+                        type_item = QTableWidgetItem(entry[5] or '')
+                        type_item.setFont(font)
+                        table.setItem(row, col, type_item)
+                        col += 1
+                        # Status
+                        status_item = QTableWidgetItem(entry[4])
+                        status_item.setFont(font)
+                        table.setItem(row, col, status_item)
+                        col += 1
+                        # Comment
+                        comment_item = QTableWidgetItem(entry[6] or '')
+                        comment_item.setFont(font)
+                        table.setItem(row, col, comment_item)
+                        col += 1
+                        # Actions
+                        actions_widget = self.create_actions_widget(entry[0], entry[4])
+                        for child in actions_widget.findChildren(QToolButton):
+                            child.setFont(font)
+                        table.setCellWidget(row, col, actions_widget)
+                    table.resizeColumnsToContents()
+                    table.resizeRowsToContents()
+                    # Calculate fixed height
+                    height = table.horizontalHeader().height() + 2  # small margin
+                    for i in range(table.rowCount()):
+                        height += table.rowHeight(i)
+                    table.setFixedHeight(height)
+                    # Apply status colors
+                    status_col = 3
+                    for r in range(table.rowCount()):
+                        status = table.item(r, status_col).text()
+                        if status == 'unwatched':
+                            color = QColor(255, 255, 255)
+                        elif status == 'watching':
+                            color = QColor(255, 255, 0)
+                        elif status == 'completed':
+                            color = QColor(0, 255, 0)
+                        else:
+                            color = QColor(255, 255, 255)
+                        for c in range(table.columnCount()):
+                            if c == 0:
+                                continue  # skip hidden id
+                            item = table.item(r, c)
+                            if item:
+                                item.setBackground(color)
+                            widget = table.cellWidget(r, c)
+                            if widget:
+                                widget.setStyleSheet(f"padding-left: 2px; background-color: {color.name()};")
+                    layout.addWidget(table)
+                total_entries += len(entries)
+                comp_entries += sum(1 for e in entries if e[4] == 'completed')
             year_tab.setWidget(content)
-            if total_entries > 0 or (self.year_filter == year):
+            if total_entries > 0:
                 perc = (comp_entries / total_entries * 100) if total_entries > 0 else 0
                 tab_text = f"{year} ({perc:.0f}%)"
                 completed = (comp_entries == total_entries)
                 index = self.tab_widget.addTab(year_tab, tab_text)
                 if completed:
                     self.tab_widget.tabBar().setTabTextColor(index, QColor('gray'))
+        self.filter_tables(self.search_text)  # Apply search filter after loading tabs
 
     def create_actions_widget(self, anime_id, status):
         widget = QWidget()
@@ -606,10 +628,16 @@ class AnimeTracker(QMainWindow):
                 parts = tab_text.split(' (')
                 default_year = int(parts[0])
                 default_season = ''
-        dialog = AnimeDialog(self, None, default_year, default_season)
+        dialog = AnimeDialog(self, None, default_year, self.last_used_season)
         if dialog.exec_() == QDialog.Accepted:
             current_id = self.get_current_tab_identifier()
             data = dialog.get_data()
+            if data['season']:
+                self.last_used_season = data['season']
+                self.settings.setValue("lastUsedSeason", self.last_used_season)
+            if not data['name']:
+                QMessageBox.warning(self, "Error", "Anime name cannot be empty.")
+                return
             self.backend.add_anime(data)
             self.load_tabs()
             self.set_current_tab_by_identifier(current_id)
@@ -620,7 +648,11 @@ class AnimeTracker(QMainWindow):
             current_id = self.get_current_tab_identifier()
             dialog = AnimeDialog(self, entry)
             if dialog.exec_() == QDialog.Accepted:
+                current_id = self.get_current_tab_identifier()
                 data = dialog.get_data()
+                if not data['name']:
+                    QMessageBox.warning(self, "Error", "Anime name cannot be empty.")
+                    return
                 self.backend.edit_anime(anime_id, data)
                 self.load_tabs()
                 self.set_current_tab_by_identifier(current_id)
@@ -684,6 +716,41 @@ class AnimeTracker(QMainWindow):
         else:
             QMessageBox.information(self, "Random Pick", "No unwatched anime in this tab.")
 
+    def show_statistics(self):
+        dialog = QDialog(self)
+        dialog.setWindowTitle("Anime Statistics")
+        layout = QVBoxLayout(dialog)
+
+        total = self.backend.get_total_entries()
+        completed = self.backend.get_completed_entries()
+        percentage = (completed / total * 100) if total > 0 else 0
+
+        layout.addWidget(QLabel(f"Total anime entries: <b>{total}</b>"))
+        layout.addWidget(QLabel(f"Total completed entries: <b>{completed}</b>"))
+        layout.addWidget(QLabel(f"Percentage of completed entries: <b>{percentage:.2f}%</b>"))
+
+        layout.addWidget(QLabel("Number of anime entries by type:"))
+        types_data = self.backend.get_entries_by_type()
+        if types_data:
+            for typ, count in types_data:
+                display_type = typ if typ else "None"  # Handle empty type as 'None'
+                layout.addWidget(QLabel(f"  {display_type}: <b>{count}</b>"))
+        else:
+            layout.addWidget(QLabel("  No data available"))
+
+        db_path = 'anime_backlog.db'
+        if os.path.exists(db_path):
+            db_size_kb = os.path.getsize(db_path) / 1024
+            layout.addWidget(QLabel(f"Size of the database: <b>{db_size_kb:.2f} Kb</b>"))
+        else:
+            layout.addWidget(QLabel("Size of the database: N/A (database file not found)"))
+
+        buttons = QDialogButtonBox(QDialogButtonBox.Ok)
+        buttons.accepted.connect(dialog.accept)
+        layout.addWidget(buttons)
+
+        dialog.exec_()
+
     def import_csv(self):
         file_name, _ = QFileDialog.getOpenFileName(self, "Import CSV", "", "CSV Files (*.csv)")
         if file_name:
@@ -711,10 +778,11 @@ class AnimeTracker(QMainWindow):
                 current = self.tab_widget.currentIndex()
                 if current > 0:
                     self.tab_widget.setCurrentIndex(current - 1)
-            elif key == Qt.Key_Q:
-                self.close()
             elif key == Qt.Key_R:
                 self.random_pick()
+            elif key == Qt.Key_Q: 
+                self.close()
+                
         elif modifiers == Qt.ControlModifier:
             if key == Qt.Key_Plus or key == Qt.Key_Equal:
                 current_id = self.get_current_tab_identifier()
@@ -726,6 +794,9 @@ class AnimeTracker(QMainWindow):
                 self.table_scale = max(self.table_scale - 0.1, 0.5)
                 self.load_tabs()
                 self.set_current_tab_by_identifier(current_id)
+            elif key == Qt.Key_Q: 
+                self.close()
+
         super().keyPressEvent(event)
 
 if __name__ == '__main__':

readme.md

@@ -0,0 +1,8 @@
+# How to build this app: 
+`python -m venv anime_env`
+`source anime_env/bin/activate`
+`pip install pyinstaller`
+`pyinstaller build.spec --clean`
+
+# How to run this app without building: 
+`python frontend.py`

requirements.txt

@@ -0,0 +1 @@
+PyQt5==5.15.10