Merge branch 'dzgui7' into fix/legacy-version-file

fix: restore missing route

dzgui/api/acf.py

@@ -111,7 +111,8 @@ class WorkshopACF(ACF):
     def __init__(self, file: Path) -> None:
         super().__init__(file)
 
-    def unpack(self, d: dict, lines: list[Any] = []) -> str:
+    def unpack(self, d: dict[str, Any], lines: list[Any] = []) -> str:
+        self.indent: int
         t1 = "AppWorkshop"
         t2 = ("WorkshopItemsInstalled", "WorkshopItemDetails")
         for k, v in d.items():

dzgui/api/mods.py

@@ -2,10 +2,10 @@ import hashlib
 import logging
 import re
 
-from concurrent.futures import wait
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ThreadPoolExecutor, wait
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Any
 
 from dzgui.api.steam import get_app_path
 from dzgui.api.servers import get_rules, fqip_to_record
@@ -18,8 +18,7 @@ from dzgui.const.constants import (
 
 from dzgui.config.query import lookup
 from dzgui.const.enum import Preferences
-
-from typing import Any
+from dzgui.init.migrate import clean_legacy_versions_file
 
 logger = logging.getLogger(APP_NAME)
 
@@ -106,10 +105,6 @@ def get_delimited_mods(steam_path: Path) -> list[Any]:
     return parse_mods(mods)
 
 
-def get_missing_mods(local: list, remote: list) -> list:
-    return [mod for mod in remote if mod not in local]
-
-
 def _hash(uid: str, use_custom: bool = False) -> str:
     md5 = hashlib.md5()
     md5.update(uid.encode("ascii"))
@@ -121,10 +116,12 @@ def remove_stale_signatures(
     config: Path, versions: Path, ids: list[int] | None = None
 ) -> None:
     if versions.is_file() is False:
-        logger.warning("Creating new version signatures file")
+        logger.debug("Creating new version signatures file")
         versions.touch()
         return
 
+    clean_legacy_versions_file(versions)
+
     path = lookup(config, Preferences.DEFAULT)
     steam_path = Path(path)
     if ids is None:
@@ -144,7 +141,7 @@ def remove_stale_signatures(
 
 
 def find_stale_mods(config: Path) -> list[int]:
-    def push_record(rec: str) -> list:
+    def push_record(rec: str) -> list[int]:
         record = fqip_to_record(rec)
         if record is None:
             return []

dzgui/api/servers.py

@@ -13,6 +13,7 @@ from typing import Any, Optional, TYPE_CHECKING, Union
 
 from dzgui.const.constants import APP_NAME, REQUEST_TIMEOUT
 from dzgui.const.endpoints import STEAM_SERVERS
+from dzgui.model.proxy_model import ServerRow
 from dzgui.util.format import format_exception
 from dzgui.util import strings
 
@@ -111,7 +112,7 @@ def get_netmask() -> str:
 
 
 # TODO: rename
-def test_ip(suffix: int, port: int, event: threading.Event) -> dict | None:
+def test_ip(suffix: int, port: int, event: threading.Event) -> dict[str, Any] | None:
     if event.is_set():
         return None
     netmask = get_netmask()
@@ -139,7 +140,9 @@ def sanitize(name: str) -> str:
     return name
 
 
-def parse_json(json: list) -> list:
+def parse_json(
+    json: list[dict[str, Any]],
+) -> list[ServerRow]:
     """
     Server metadata is underspecified and server operators
     tend to insert random garbage in the headers. In case
@@ -224,7 +227,7 @@ def parse_json(json: list) -> list:
         mapname = row["map"].lower()
         players = row["players"]
         max_players = row["max_players"]
-        raw = (
+        raw = ServerRow(
             name,
             mapname,
             view,
@@ -507,14 +510,14 @@ def record_to_fqip(record: Record) -> str:
     return f"{record.ip}:{record.gameport}:{record.qport}"
 
 
-def response_to_fqip(res: dict) -> str:
+def response_to_fqip(res: dict[str, Any]) -> str:
     ip = res["addr"].split(":")[0]
     gameport = res["gameport"]
     qport = res["addr"].split(":")[1]
     return f"{ip}:{gameport}:{qport}"
 
 
-def response_to_record(res: dict) -> Record:
+def response_to_record(res: dict[str, Any]) -> Record:
     ip = res["addr"].split(":")[0]
     gameport = res["gameport"]
     qport = res["addr"].split(":")[1]

dzgui/app_init.py

@@ -18,8 +18,8 @@ from dzgui.config.query import lookup
 from dzgui.config.userprefs import UserPrefs
 from dzgui.config.xdg import get_xdg_paths, parse_filepaths
 from dzgui.init.migrate import (
-    has_new_config,
     copy_state_files,
+    has_new_config,
     migrate_cols_file,
 )
 from dzgui.init.prereqs import has_flatpak_client, has_steam_client

dzgui/config/query.py

@@ -5,6 +5,7 @@ from dzgui.util._json import read_json
 
 from dzgui.const.enum import Preferences
 
+
 class ConfigFileError(Exception):
     pass
 
@@ -39,4 +40,4 @@ def get_favorites(path: Path) -> list[str]:
 
 
 def enum_to_key(enum: Preferences) -> str:
-    return str(enum.dict["key"])
+    return str(enum.key)

dzgui/config/userprefs.py

@@ -6,7 +6,8 @@ if TYPE_CHECKING:
     from dzgui.util.ip import Coords
 
 
-# NOTE: mutable dataclass, 'use_miles' key changes on demand
+# NOTE: mutable dataclass: 'use_miles' key changes on demand
+# 'frozen' cannot be True
 @dataclass(slots=True)
 class UserPrefs:
     is_steam_deck: bool

dzgui/config/xdg.py

@@ -51,7 +51,7 @@ def is_writeable(path_str: str) -> bool:
     return True
 
 
-def get_xdg_paths() -> dict:
+def get_xdg_paths() -> dict[str, Path]:
     home = Path.home()
     xdg_paths = {
         "XDG_CONFIG_HOME": home / ".config",
@@ -73,7 +73,7 @@ def get_xdg_paths() -> dict:
     return resolved_paths
 
 
-def parse_filepaths(xdg: dict) -> Xdg:
+def parse_filepaths(xdg: dict[str, Path]) -> Xdg:
     config = xdg["XDG_CONFIG_HOME"]
     state = xdg["XDG_STATE_HOME"]
     share = xdg["XDG_DATA_HOME"]

dzgui/const/enum.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Self
 
 from dzgui.util import strings
+from dzgui.strings import rows
 
 
 class Port(Enum):
@@ -46,125 +48,61 @@ class FilterMode(Enum):
     TOGGLE_ON = 3
 
 
-class EnumWithAttrs(Enum):
-    def __new__(cls, *args: Any, **kwargs: Any) -> Self:
-        value = len(cls.__members__) + 1
-        obj = object.__new__(cls)
-        obj._value_ = value
-        return obj
-
-    def __init__(self, d: dict):
-        self.dict = d
+@dataclass(slots=True, frozen=True)
+class ModButtonMeta:
+    label: str
+    tooltip: str
 
 
-class Preferences(EnumWithAttrs):
-    STEAM = {
-        "key": "steam_api",
-    }
-    CLIENT = {
-        "key": "client",
-    }
-    WINDOW = {
-        "key": "fullscreen",
-    }
-    DIST = {
-        "key": "use_miles",
-    }
-    NAME = {
-        "key": "name",
-    }
-    DEFAULT = {
-        "key": "default_steam_path",
-    }
-    FAV_LBL = {
-        "key": "fav_label",
-    }
-    FAV_SRV = {
-        "key": "fav_server",
-    }
-    IP_LIST = {
-        "key": "ip_list",
-    }
-    START_TAB = {
-        "key": "start_tab",
-    }
+@dataclass(slots=True, frozen=True)
+class ButtonTypeMeta:
+    label: str
+    tooltip: str
+    opens: NotebookPage | None
 
 
-class NotebookPage(EnumWithAttrs):
-    OFFLINE = {"crumbs": strings.crumbs.offline, "statusbar": True}
-    CHANGELOG = {"crumbs": strings.crumbs.changelog, "statusbar": True}
-    DEVELOPERS = {"crumbs": strings.crumbs.developers, "statusbar": False}
-    HELP = {"crumbs": strings.crumbs._help, "statusbar": True}
-    KEYS = {"crumbs": strings.crumbs.keys, "statusbar": True}
-    LOG = {"crumbs": strings.crumbs.log, "statusbar": True}
-    MODS = {"crumbs": strings.crumbs.mods, "statusbar": True}
-    OPTIONS = {"crumbs": strings.crumbs.options, "statusbar": False}
-    SERVERS = {"crumbs": strings.crumbs.servers, "statusbar": True}
-    THANKS = {"crumbs": strings.crumbs.thanks, "statusbar": True}
-    CONNECTION = {"crumbs": "Connect", "statusbar": True}
+@dataclass(slots=True, frozen=True)
+class ConfigKey:
+    key: str
 
 
-class RowType(EnumWithAttrs):
-    # TODO: strings
-    CHANGELOG = {
-        "label": "View changelog",
-        "tooltip": "Opens the DZGUI changelog",
-    }
-    SHOW_LOG = {
-        "label": "Show debug log",
-        "tooltip": "Read the DZGUI log generated since startup",
-    }
-    SEPARATOR = {
-        "label": "SEPARATOR",
-        "tooltip": "",
-    }
-    DUMP_LOG = {
-        "label": "Output system info to log file",
-        "tooltip": "Dump diagnostic data for troubleshooting",
-    }
-    DOCS = {
-        "label": "Documentation/help files (GitHub) ⧉",
-        "tooltip": "Open the DZGUI documentation in a browser",
-    }
-    DOCS_FALLBACK = {
-        "label": "Documentation/help files (Codeberg mirror) ⧉",
-        "tooltip": "Open the DZGUI documentation in a browser",
-    }
-    BUGS = {
-        "label": "Report a bug (GitHub) ⧉",
-        "tooltip": "Open the DZGUI issue tracker in a browser",
-    }
-    FORUM = {
-        "label": "DZGUI Subreddit ⧉",
-        "tooltip": "Open the DZGUI discussion forum in a browser",
-    }
-    SPONSOR = {
-        "label": "Sponsor (GitHub) ⧉",
-        "tooltip": "Sponsor development of the DZGUI project",
-    }
-    THANKS = {
-        "label": "Special thanks",
-        "tooltip": "A list of contributors, testers, and sponsors",
-    }
+@dataclass(slots=True, frozen=True)
+class NotebookMeta:
+    crumbs: str
+    has_statusbar: bool
 
 
-# TODO: rename to ContextMenuItem
-class ContextMenu(EnumWithAttrs):
-    ADD_NOTE = {"label": strings.add_note}
-    ADD_SERVER = {"label": strings.add}
-    CONNECT = {"label": strings.connect}
-    COPY_LOG_CLIPBOARD = {"label": strings.copy_log}
-    COPY_SERVER_IP = {"label": strings.copy_ip}
-    COPY_SERVER_NAME = {"label": strings.copy_name}
-    UNSUB_MOD = {"label": strings.unsub_mod}
-    VALIDATE_MOD = {"label": strings.validate_mod}
-    OPEN_WORKSHOP = {"label": strings.open_workshop}
-    REFRESH_PLAYERS = {"label": strings.refresh_players}
-    REMOVE_HISTORY = {"label": strings.remove_history}
-    REMOVE_SERVER = {"label": strings.remove}
-    SET_FAV = {"label": strings.add_fav}
-    SHOW_DETAILS = {"label": strings.show_details}
-    SHOW_MODS = {"label": strings.show_mods}
+@dataclass(slots=True, frozen=True)
+class RowMeta:
+    label: str
+    tooltip: str
+
+
+@dataclass(slots=True, frozen=True)
+class ContextMenuMeta:
+    label: str
+
+
+class ContextMenuItem(Enum):
+    ADD_NOTE = ContextMenuMeta(strings.add_note)
+    ADD_SERVER = ContextMenuMeta(strings.add)
+    CONNECT = ContextMenuMeta(strings.connect)
+    COPY_LOG_CLIPBOARD = ContextMenuMeta(strings.copy_log)
+    COPY_SERVER_IP = ContextMenuMeta(strings.copy_ip)
+    COPY_SERVER_NAME = ContextMenuMeta(strings.copy_name)
+    UNSUB_MOD = ContextMenuMeta(strings.unsub_mod)
+    VALIDATE_MOD = ContextMenuMeta(strings.validate_mod)
+    OPEN_WORKSHOP = ContextMenuMeta(strings.open_workshop)
+    REFRESH_PLAYERS = ContextMenuMeta(strings.refresh_players)
+    REMOVE_HISTORY = ContextMenuMeta(strings.remove_history)
+    REMOVE_SERVER = ContextMenuMeta(strings.remove)
+    SET_FAV = ContextMenuMeta(strings.add_fav)
+    SHOW_DETAILS = ContextMenuMeta(strings.show_details)
+    SHOW_MODS = ContextMenuMeta(strings.show_mods)
+
+    @property
+    def label(self) -> str:
+        return self.value.label
 
 
 class ContextMenuGroup(Enum):
@@ -172,113 +110,193 @@ class ContextMenuGroup(Enum):
     Groupings of context menu items
     """
 
-    SERVER_MOD = (ContextMenu.OPEN_WORKSHOP,)
-    MOD = (ContextMenu.OPEN_WORKSHOP, ContextMenu.UNSUB_MOD, ContextMenu.VALIDATE_MOD)
+    SERVER_MOD = (ContextMenuItem.OPEN_WORKSHOP,)
+    MOD = (
+        ContextMenuItem.OPEN_WORKSHOP,
+        ContextMenuItem.UNSUB_MOD,
+        ContextMenuItem.VALIDATE_MOD,
+    )
     MOD_OFFLINE = (None,)
-    LOG = (ContextMenu.COPY_LOG_CLIPBOARD,)
+    LOG = (ContextMenuItem.COPY_LOG_CLIPBOARD,)
     SERVER_BROWSER = (
-        ContextMenu.CONNECT,
-        ContextMenu.ADD_SERVER,
-        ContextMenu.SET_FAV,
-        ContextMenu.COPY_SERVER_NAME,
-        ContextMenu.COPY_SERVER_IP,
-        ContextMenu.ADD_NOTE,
-        ContextMenu.SHOW_MODS,
-        ContextMenu.SHOW_DETAILS,
-        ContextMenu.REFRESH_PLAYERS,
+        ContextMenuItem.CONNECT,
+        ContextMenuItem.ADD_SERVER,
+        ContextMenuItem.SET_FAV,
+        ContextMenuItem.COPY_SERVER_NAME,
+        ContextMenuItem.COPY_SERVER_IP,
+        ContextMenuItem.ADD_NOTE,
+        ContextMenuItem.SHOW_MODS,
+        ContextMenuItem.SHOW_DETAILS,
+        ContextMenuItem.REFRESH_PLAYERS,
     )
     SCAN_LAN = (
-        ContextMenu.CONNECT,
-        ContextMenu.SET_FAV,
-        ContextMenu.COPY_SERVER_NAME,
-        ContextMenu.COPY_SERVER_IP,
-        ContextMenu.ADD_NOTE,
-        ContextMenu.SHOW_MODS,
-        ContextMenu.SHOW_DETAILS,
-        ContextMenu.REFRESH_PLAYERS,
+        ContextMenuItem.CONNECT,
+        ContextMenuItem.SET_FAV,
+        ContextMenuItem.COPY_SERVER_NAME,
+        ContextMenuItem.COPY_SERVER_IP,
+        ContextMenuItem.ADD_NOTE,
+        ContextMenuItem.SHOW_MODS,
+        ContextMenuItem.SHOW_DETAILS,
+        ContextMenuItem.REFRESH_PLAYERS,
     )
     SAVED = (
-        ContextMenu.CONNECT,
-        ContextMenu.SET_FAV,
-        ContextMenu.REMOVE_SERVER,
-        ContextMenu.COPY_SERVER_NAME,
-        ContextMenu.COPY_SERVER_IP,
-        ContextMenu.ADD_NOTE,
-        ContextMenu.SHOW_MODS,
-        ContextMenu.SHOW_DETAILS,
-        ContextMenu.REFRESH_PLAYERS,
+        ContextMenuItem.CONNECT,
+        ContextMenuItem.SET_FAV,
+        ContextMenuItem.REMOVE_SERVER,
+        ContextMenuItem.COPY_SERVER_NAME,
+        ContextMenuItem.COPY_SERVER_IP,
+        ContextMenuItem.ADD_NOTE,
+        ContextMenuItem.SHOW_MODS,
+        ContextMenuItem.SHOW_DETAILS,
+        ContextMenuItem.REFRESH_PLAYERS,
     )
     RECENT = (
-        ContextMenu.CONNECT,
-        ContextMenu.ADD_SERVER,
-        ContextMenu.SET_FAV,
-        ContextMenu.REMOVE_HISTORY,
-        ContextMenu.COPY_SERVER_NAME,
-        ContextMenu.COPY_SERVER_IP,
-        ContextMenu.ADD_NOTE,
-        ContextMenu.SHOW_MODS,
-        ContextMenu.SHOW_DETAILS,
-        ContextMenu.REFRESH_PLAYERS,
+        ContextMenuItem.CONNECT,
+        ContextMenuItem.ADD_SERVER,
+        ContextMenuItem.SET_FAV,
+        ContextMenuItem.REMOVE_HISTORY,
+        ContextMenuItem.COPY_SERVER_NAME,
+        ContextMenuItem.COPY_SERVER_IP,
+        ContextMenuItem.ADD_NOTE,
+        ContextMenuItem.SHOW_MODS,
+        ContextMenuItem.SHOW_DETAILS,
+        ContextMenuItem.REFRESH_PLAYERS,
     )
 
 
-class ModButton(EnumWithAttrs):
-    SELECT_ALL = {
-        "label": strings.mod_panel.select_all,
-        "tooltip": strings.mod_panel.select_all_tooltip,
-    }
-    UNSELECT_ALL = {
-        "label": strings.mod_panel.unselect_all,
-        "tooltip": strings.mod_panel.unselect_all_tooltip,
-    }
-    HIGHLIGHT_STALE = {
-        "label": strings.mod_panel.highlight_stale,
-        "tooltip": strings.mod_panel.highlight_stale_tooltip,
-    }
-    UNHIGHLIGHT_STALE = {
-        "label": strings.mod_panel.unhighlight_stale,
-        "tooltip": strings.mod_panel.unhighlight_stale_tooltip,
-    }
-    UNSUB_SELECTED = {
-        "label": strings.mod_panel.unsub_selected,
-        "tooltip": strings.mod_panel.unsub_selected_tooltip,
-    }
-    SELECT_STALE = {
-        "label": strings.mod_panel.select_stale,
-        "tooltip": strings.mod_panel.select_stale_tooltip,
-    }
-    VALIDATE = {
-        "label": strings.mod_panel.validate,
-        "tooltip": strings.mod_panel.validate_tooltip,
-    }
+class Preferences(Enum):
+    STEAM = ConfigKey("steam_api")
+    CLIENT = ConfigKey("client")
+    WINDOW = ConfigKey("fullscreen")
+    DIST = ConfigKey("use_miles")
+    NAME = ConfigKey("name")
+    DEFAULT = ConfigKey("default_steam_path")
+    FAV_LBL = ConfigKey("fav_label")
+    FAV_SRV = ConfigKey("fav_server")
+    IP_LIST = ConfigKey("ip_list")
+    START_TAB = ConfigKey("start_tab")
+
+    @property
+    def key(self) -> str:
+        return self.value.key
 
 
-class ButtonType(EnumWithAttrs):
-    SERVERS = {
-        "label": strings.buttons.servers_label,
-        "tooltip": strings.buttons.servers_tooltip,
-        "opens": NotebookPage.SERVERS,
-    }
-    MODS = {
-        "label": strings.buttons.mods_label,
-        "tooltip": strings.buttons.mods_tooltip,
-        "opens": NotebookPage.MODS,
-    }
-    OPTIONS = {
-        "label": strings.buttons.options_label,
-        "tooltip": strings.buttons.options_tooltip,
-        "opens": NotebookPage.OPTIONS,
-    }
-    HELP = {
-        "label": strings.buttons.help_label,
-        "tooltip": strings.buttons.help_tooltip,
-        "opens": NotebookPage.HELP,
-    }
-    EXIT = {
-        "label": strings.buttons.exit_label,
-        "tooltip": strings.buttons.exit_tooltip,
-        "opens": None,
-    }
+class NotebookPage(Enum):
+    OFFLINE = NotebookMeta(strings.crumbs.offline, True)
+    CHANGELOG = NotebookMeta(strings.crumbs.changelog, True)
+    DEVELOPERS = NotebookMeta(strings.crumbs.developers, False)
+    HELP = NotebookMeta(strings.crumbs._help, True)
+    KEYS = NotebookMeta(strings.crumbs.keys, True)
+    LOG = NotebookMeta(strings.crumbs.log, True)
+    MODS = NotebookMeta(strings.crumbs.mods, True)
+    OPTIONS = NotebookMeta(strings.crumbs.options, False)
+    SERVERS = NotebookMeta(strings.crumbs.servers, True)
+    THANKS = NotebookMeta(strings.crumbs.thanks, True)
+    CONNECTION = NotebookMeta(strings.crumbs.connect, True)
+
+    @property
+    def crumbs(self) -> str:
+        return self.value.crumbs
+
+    @property
+    def has_statusbar(self) -> bool:
+        return self.value.has_statusbar
+
+
+class RowType(Enum):
+    CHANGELOG = RowMeta(rows.changelog_label, rows.changelog_status)
+    SHOW_LOG = RowMeta(rows.log_label, rows.log_status)
+    SEPARATOR = RowMeta(rows.separator_label, rows.separator_status)
+    DUMP_LOG = RowMeta(rows.system_log_label, rows.system_log_status)
+    DOCS = RowMeta(rows.docs_label, rows.docs_status)
+    DOCS_FALLBACK = RowMeta(rows.docs_fallback_label, rows.docs_fallback_status)
+    BUGS = RowMeta(rows.bugs_label, rows.bugs_status)
+    FORUM = RowMeta(rows.forum_label, rows.forum_status)
+    SPONSOR = RowMeta(rows.sponsor_label, rows.sponsor_status)
+    THANKS = RowMeta(rows.thanks_label, rows.thanks_status)
+
+    @property
+    def label(self) -> str:
+        return self.value.label
+
+    @property
+    def tooltip(self) -> str:
+        return self.value.tooltip
+
+
+class ModButton(Enum):
+    SELECT_ALL = ModButtonMeta(
+        strings.mod_panel.select_all, strings.mod_panel.select_all_tooltip
+    )
+    UNSELECT_ALL = ModButtonMeta(
+        strings.mod_panel.unselect_all, strings.mod_panel.unselect_all_tooltip
+    )
+    HIGHLIGHT_STALE = ModButtonMeta(
+        strings.mod_panel.highlight_stale, strings.mod_panel.highlight_stale_tooltip
+    )
+    UNHIGHLIGHT_STALE = ModButtonMeta(
+        strings.mod_panel.unhighlight_stale, strings.mod_panel.unhighlight_stale_tooltip
+    )
+    UNSUB_SELECTED = ModButtonMeta(
+        strings.mod_panel.unsub_selected,
+        strings.mod_panel.unsub_selected_tooltip,
+    )
+    SELECT_STALE = ModButtonMeta(
+        strings.mod_panel.select_stale,
+        strings.mod_panel.select_stale_tooltip,
+    )
+    VALIDATE = ModButtonMeta(
+        strings.mod_panel.validate,
+        strings.mod_panel.validate_tooltip,
+    )
+
+    @property
+    def label(self) -> str:
+        return self.value.label
+
+    @property
+    def tooltip(self) -> str:
+        return self.value.tooltip
+
+
+class ButtonType(Enum):
+    SERVERS = ButtonTypeMeta(
+        strings.buttons.servers_label,
+        strings.buttons.servers_tooltip,
+        NotebookPage.SERVERS,
+    )
+    MODS = ButtonTypeMeta(
+        strings.buttons.mods_label,
+        strings.buttons.mods_tooltip,
+        NotebookPage.MODS,
+    )
+    OPTIONS = ButtonTypeMeta(
+        strings.buttons.options_label,
+        strings.buttons.options_tooltip,
+        NotebookPage.OPTIONS,
+    )
+    HELP = ButtonTypeMeta(
+        strings.buttons.help_label,
+        strings.buttons.help_tooltip,
+        NotebookPage.HELP,
+    )
+    EXIT = ButtonTypeMeta(
+        strings.buttons.exit_label,
+        strings.buttons.exit_tooltip,
+        None,
+    )
+
+    @property
+    def label(self) -> str:
+        return self.value.label
+
+    @property
+    def tooltip(self) -> str:
+        return self.value.tooltip
+
+    @property
+    def opens(self) -> NotebookPage | None:
+        return self.value.opens
 
 
 HELP_MENU_ROWS = (

dzgui/controllers/mc.py

@@ -8,7 +8,7 @@ import dzgui.util._json as JSON  # noqa
 
 from dzgui.const.enum import (
     ButtonType,
-    ContextMenu,
+    ContextMenuItem,
     FilterMode,
     NotebookPage,
     Preferences,
@@ -77,7 +77,7 @@ class AppNavigation:
 
 class Controller(GObject.GObject):
     def __init__(self) -> None:
-        self.dist_cache: dict[str, "Haversine"] = {}
+        self.dist_cache: dict[str, "Haversine" | None] = {}
         self.mediator = AppNavigation()
 
         self.prefs: UserPrefs
@@ -196,7 +196,9 @@ class Controller(GObject.GObject):
     def show_developers_page(self) -> None:
         self.open_page(NotebookPage.DEVELOPERS)
 
-    def open_page(self, page: NotebookPage) -> None:
+    def open_page(self, page: NotebookPage | None) -> None:
+        if page is None:
+            return
         self.mediator.grid.notebook.set_page_by_enum(page)
 
     def open_page_by_button(self, button: "ContextualButton") -> None:
@@ -262,7 +264,7 @@ class Controller(GObject.GObject):
             logger.critical(e)
             return
 
-    def menu_action(self, action: ContextMenu, tree: "ServerTreeView") -> None:
+    def menu_action(self, action: ContextMenuItem, tree: "ServerTreeView") -> None:
         context_man = ContextMenuManager(tree, self)
         context_man.process(action)
 
@@ -274,7 +276,7 @@ class Controller(GObject.GObject):
         except Exception as e:
             dialog = ExceptionDialog(self, str(e))
             dialog.show_all()
-            dialog.run()
+            dialog.run()  # type: ignore[no-untyped-call]
 
     def select_colorized(self) -> None:
         mod_man = self.mediator.modtreeview.get_mod_man()
@@ -308,7 +310,7 @@ class Controller(GObject.GObject):
             except Exception as e:
                 dialog = ExceptionDialog(self, str(e))
                 dialog.show_all()
-                dialog.run()
+                dialog.run()  # type: ignore[no-untyped-call]
 
     def update_steam_api_key(self, text: str) -> None:
         self.config_man.update_steam_api_key(text)
@@ -355,22 +357,21 @@ class Controller(GObject.GObject):
             filter_man.set_filter(filt, state)
         self.mediator.filters.set_filters(filters)
 
-    def get_dist_cache(self) -> dict[str, "Haversine"]:
+    def get_dist_cache(self) -> dict[str, Union["Haversine", None]]:
         return self.dist_cache
 
-    def set_dist_cache(self, addr: str, haversine: "Haversine") -> None:
+    def set_dist_cache(self, addr: str, haversine: Union["Haversine", None]) -> None:
         self.dist_cache[addr] = haversine
 
     def get_map_store(self) -> Gtk.ListStore:
         filter_man = self.get_filter_man()
         return filter_man.get_map_store()
 
-    def get_enabled_filters(self) -> dict:
+    def get_enabled_filters(self) -> dict[str, bool]:
         filter_man = self.get_filter_man()
         return filter_man.get_filters()
 
     # FIXME: wipe maps store when changing tabs if model is none
-
     def has_server_model(self) -> bool:
         treeview = self.get_active_treeview()
         proxy_man = treeview.get_proxy_man()

dzgui/init/migrate.py

@@ -1,12 +1,21 @@
 import json
+import logging
+import re
 import shutil
 
 from pathlib import Path
 from typing import Any
-from dzgui.const.constants import LEGACY_CONFIG_PATH, LEGACY_COLS_PATH, LEGACY_IPS_PATH
+from dzgui.const.constants import (
+    APP_NAME,
+    LEGACY_CONFIG_PATH,
+    LEGACY_COLS_PATH,
+    LEGACY_IPS_PATH,
+)
 from dzgui.config.convert import rc2json
 from dzgui.util._json import read_json, write_json
 
+logger = logging.getLogger(APP_NAME)
+
 
 def migrate_legacy_conf(config: Path) -> Any:
     old_conf = Path.home() / LEGACY_CONFIG_PATH
@@ -70,3 +79,15 @@ def copy_ipdb(ips_path: Path) -> None:
         return
     # TODO: ensure that month file is copied
     shutil.copy(legacy, ips_path)
+
+
+def clean_legacy_versions_file(versions: Path) -> None:
+    # NOTE: handling for #523
+    try:
+        pat = r"^(\d+),(\d+)$"
+        lines = versions.read_text().splitlines()
+        clean = [line for line in lines if re.match(pat, line)]
+        concat = "\n".join(clean)
+        versions.write_text(concat)
+    except Exception as e:
+        logger.warning(e)

dzgui/managers/config.py

@@ -46,6 +46,15 @@ class ConfigManager:
         ips.append(record)
         self.update_config(Preferences.IP_LIST, ips)
 
+    def remove_from_history_file(self, fqip: str) -> None:
+        try:
+            history = self.prefs.paths.history
+            ips = [line.rstrip() for line in history.read_text().splitlines()]
+            ips.remove(fqip)
+            history.write_text("\n".join(ips))
+        except Exception as e:
+            logger.critical(e)
+
     def update_history_file(self, fqip: str) -> None:
         try:
             with open(self.prefs.paths.history, "r") as f:
@@ -124,7 +133,7 @@ class ConfigManager:
         return False
 
     def enum_to_key(self, enum: Preferences) -> str:
-        return str(enum.dict["key"])
+        return str(enum.key)
 
     def toggle_config(self, key: Preferences) -> None:
         try:
@@ -162,7 +171,7 @@ class ConfigManager:
             trace = traceback.format_exc()
             dialog = ExceptionDialog(self.controller, trace)
             dialog.show_all()
-            dialog.run()
+            dialog.run()  # type: ignore[no-untyped-call]
 
     def save_res_and_quit(self, tv: "ServerTreeView", window: "OuterWindow") -> None:
         columns = tv.get_columns()

dzgui/managers/connection.py

@@ -291,22 +291,22 @@ class ConnectionManager:
 
     def _present_modlist_dialog(self, mods: list[list[str]]) -> None:
         dialog = ServerModDialog(self.controller, mods)
-        dialog.run()
+        dialog.run()  # type: ignore[no-untyped-call]
 
     def _present_details_dialog(self, details: Servers.Details) -> None:
         dialog = ServerDetailsDialog(self.controller, details)
-        dialog.run()
+        dialog.run()  # type: ignore[no-untyped-call]
 
     def _workshop_timeout(self, msg: str) -> None:
         dialog = ExceptionDialog(self.controller, msg)
         dialog.show_all()
-        dialog.run()
+        dialog.run()  # type: ignore[no-untyped-call]
 
     def _server_timeout(self) -> None:
         dialog = ExceptionDialog(self.controller, server_timeout)
         dialog.set_details_buffer(kb.DZG_006)
         dialog.show_all()
-        dialog.run()
+        dialog.run()  # type: ignore[no-untyped-call]
 
     def get_debug_args(self) -> str:
         addr = f"{self.record.ip}:{self.record.gameport}"

dzgui/managers/contextmenu.py

@@ -2,7 +2,7 @@ import logging
 from typing import TYPE_CHECKING
 
 from dzgui.const.constants import APP_NAME
-from dzgui.const.enum import ContextMenu, Preferences
+from dzgui.const.enum import ContextMenuItem, Preferences
 from dzgui.util.clip import copy_clipboard
 from dzgui.util.open_links import open_workshop_page
 
@@ -34,7 +34,7 @@ class ContextMenuManager:
         self.controller = controller
         self.treeview = treeview
 
-    def process(self, action: ContextMenu) -> None:
+    def process(self, action: ContextMenuItem) -> None:
         if isinstance(self.treeview, ServerTreeView):
             record = self.treeview.get_record()
             if record is None:
@@ -42,14 +42,14 @@ class ContextMenuManager:
 
             match action:
                 # UNTHREADED
-                case ContextMenu.ADD_NOTE:
+                case ContextMenuItem.ADD_NOTE:
                     dialog = NoteDialog(self.controller)
-                    dialog.run()
-                case ContextMenu.COPY_SERVER_IP:
+                    dialog.run()  # type: ignore[no-untyped-call]
+                case ContextMenuItem.COPY_SERVER_IP:
                     self.copy_server_ip()
-                case ContextMenu.COPY_SERVER_NAME:
+                case ContextMenuItem.COPY_SERVER_NAME:
                     self.copy_server_name()
-                case ContextMenu.SET_FAV:
+                case ContextMenuItem.SET_FAV:
                     name = self.treeview.get_value_at_index(0)
                     # NOTE: fully qualified ip
                     fqip = self.treeview.get_record_string()
@@ -58,40 +58,40 @@ class ContextMenuManager:
                     self.controller.set_fav(name, fqip, simple)
 
                 # THREADED
-                case ContextMenu.ADD_SERVER:
+                case ContextMenuItem.ADD_SERVER:
                     self.controller.add_by_record(record)
-                case ContextMenu.CONNECT:
+                case ContextMenuItem.CONNECT:
                     self.controller.connect_by_record(record)
-                case ContextMenu.REFRESH_PLAYERS:
+                case ContextMenuItem.REFRESH_PLAYERS:
                     self.controller.refresh_players(record)
-                case ContextMenu.REMOVE_HISTORY:
+                case ContextMenuItem.REMOVE_HISTORY:
                     self.controller.remove_from_history(record)
-                case ContextMenu.REMOVE_SERVER:
+                case ContextMenuItem.REMOVE_SERVER:
                     self.controller.remove_by_record(record)
-                case ContextMenu.SHOW_DETAILS:
+                case ContextMenuItem.SHOW_DETAILS:
                     self.controller.get_details(record)
-                case ContextMenu.SHOW_MODS:
+                case ContextMenuItem.SHOW_MODS:
                     self.controller.get_modlist(record)
 
         if isinstance(self.treeview, (ModTreeView, OfflineModTreeView)):
             match action:
-                case ContextMenu.OPEN_WORKSHOP:
+                case ContextMenuItem.OPEN_WORKSHOP:
                     self.open_mod_page()
-                case ContextMenu.UNSUB_MOD:
+                case ContextMenuItem.UNSUB_MOD:
                     self.controller.unsub_mods(self.treeview)
-                case ContextMenu.VALIDATE_MOD:
+                case ContextMenuItem.VALIDATE_MOD:
                     self.controller.validate_mods(self.treeview)
                 case _:
                     pass
 
         if isinstance(self.treeview, LogTreeView):
             match action:
-                case ContextMenu.COPY_LOG_CLIPBOARD:
+                case ContextMenuItem.COPY_LOG_CLIPBOARD:
                     self.copy_log()
 
         if isinstance(self.treeview, ServerModTreeView):
             match action:
-                case ContextMenu.OPEN_WORKSHOP:
+                case ContextMenuItem.OPEN_WORKSHOP:
                     self.open_mod_page()
 
     def copy_server_ip(self) -> None:

dzgui/managers/filter.py

@@ -51,7 +51,6 @@ class FilterManager:
         self.active_map = (0, all_maps)
         self.prior_map = all_maps
 
-        self.filters: list
         self.enabled_filters = dict(self.default_filters)
 
     def get_tooltips(self) -> dict[str, str]:
@@ -75,11 +74,11 @@ class FilterManager:
     def set_active_keyword(self, word: str) -> None:
         self.active_keyword = word
 
-    def get_default_filters(self) -> dict:
+    def get_default_filters(self) -> dict[str, bool]:
         """Deep copy of defaults"""
         return dict(self.default_filters)
 
-    def get_filters(self) -> dict:
+    def get_filters(self) -> dict[str, bool]:
         return self.enabled_filters
 
     def set_filter(self, label: str, state: bool) -> None:
@@ -110,7 +109,7 @@ class FilterManager:
         for m in clean:
             self.append_map([m])
 
-    def get_all_filters(self) -> tuple:
+    def get_all_filters(self) -> tuple[str, ...]:
         map_name = self.get_active_map_name()
         enabled = self.get_filters()
         kw = self.get_active_keyword()

dzgui/managers/mods.py

@@ -221,7 +221,7 @@ class ModManager:
             total_size += mod[3]
         return total_mods, total_size
 
-    def _on_stale_mods_found(self, stale_mods: list) -> None:
+    def _on_stale_mods_found(self, stale_mods: list[int]) -> None:
         """Manipulates attached ListStore in the main event loop"""
         model = self.treeview.get_model()
         if model is None:

dzgui/managers/offline.py

@@ -52,7 +52,7 @@ class OfflineManager:
         is_valid = is_mission(folder)
         self.emitter.emit("custom_mission_loaded", str(folder), is_valid)
 
-    def find_custom_mods(self, callback: Callable) -> None:
+    def find_custom_mods(self, callback: Callable[[], None]) -> None:
         folder = self.open_folderpicker(dialogs.custom_mod_dialog)
         window = self.controller.get_window()
         window.set_sensitive(False)

dzgui/managers/threading.py

@@ -22,8 +22,8 @@ logger = logging.getLogger(APP_NAME)
 
 def call_on_thread(
     dialog_str: str, show_dialog: bool = True, show_cancel: bool = False
-) -> Callable:
-    def decorator(func: Callable) -> Callable:
+) -> Callable[..., Any]:
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
         @wraps(func)
         def wrapper(*args: Any, **kwargs: Any) -> None:
             self = args[0]
@@ -42,7 +42,7 @@ def call_on_thread(
 
 
 class StoredFunc:
-    def __init__(self, func: Callable, *args: Any, **kwargs: Any) -> None:
+    def __init__(self, func: Callable[..., Any], *args: Any, **kwargs: Any) -> None:
         sig = inspect.signature(func)
         self.func = func
         self.bindings = sig.bind(*args, **kwargs)

dzgui/managers/update.py

@@ -55,9 +55,9 @@ class UpdateManager:
     def _on_update_success(self) -> None:
         msg = dialogs.update_success
         dialog = QuitDialog(self.controller, msg)
-        dialog.run()
+        dialog.run()  # type: ignore[no-untyped-call]
 
     def _on_update_failure(self, msg: str) -> None:
         dialog = ExceptionDialog(self.controller, msg)
         dialog.show_all()
-        dialog.run()
+        dialog.run()  # type: ignore[no-untyped-call]

dzgui/model/model_factory.py

@@ -11,7 +11,7 @@ from gi.repository.Gtk import ListStore, TreeIter
 from gi.repository import GObject
 
 GTYPE_TO_PYTHON = {
-    GObject.type_from_name(GObject.type_name(ptype)): ptype
+    GObject.type_from_name(GObject.type_name(ptype)): ptype  # type: ignore[no-untyped-call]
     for ptype in (int, float, str, bool, object)
 }
 
@@ -147,7 +147,7 @@ class ModelFactory:
 
     def make_help_store(self) -> FastInsertListStore:
         store = self.new_model_from_class(MenuCols)
-        rows = [[row.dict["label"], row] for row in HELP_MENU_ROWS]
+        rows = [[row.label, row] for row in HELP_MENU_ROWS]
         store.extend(rows)
         return store
 

dzgui/model/proxy_model.py

@@ -1,6 +1,8 @@
 import re
 
-from typing import Any, TYPE_CHECKING, Union
+from dataclasses import dataclass, fields
+from operator import attrgetter
+from typing import TYPE_CHECKING
 
 from dzgui.const.enum import FilterMode
 from dzgui.model.model_factory import ModelFactory
@@ -17,6 +19,116 @@ DAY_REG = r"([0][6-9]|[1][0-7])"
 NIGHT_REG = r"([0][0-5]|[1][8-9]|[2][0-3])"
 
 
+@dataclass(slots=True, frozen=True)
+class ServerRow:
+    name: str
+    mapname: str
+    view: str
+    time: str
+    players: int
+    max_players: int
+    queue: int
+    ip: str
+    qport: int
+    ping: str
+    provider: str
+    modded: bool
+
+    # NOTE: construct getter once for fast lookup in lieu of field introspection
+    _to_tuple = attrgetter(
+        "name",
+        "mapname",
+        "view",
+        "time",
+        "players",
+        "max_players",
+        "queue",
+        "ip",
+        "qport",
+        "ping",
+        "provider",
+        "modded",
+    )
+
+    @classmethod
+    def marshal_rows(
+        cls, rows: list["ServerRow"]
+    ) -> list[tuple[str, str, str, str, int, int, int, str, int, str, str, bool]]:
+        """Marshals data before passing into FastInsertListStore's extend() method"""
+        getter = cls._to_tuple
+        return [getter(row) for row in rows]
+
+
+class FiltrationManager:
+    def __init__(self) -> None:
+
+        self.filter_map = {
+            strings.filter_3pp: self.filter_3pp,
+            strings.filter_1pp: self.filter_1pp,
+            strings.filter_official: self.filter_official,
+            strings.filter_unofficial: self.filter_unofficial,
+            strings.filter_empty: self.filter_empty,
+            strings.filter_full: self.filter_full,
+            strings.filter_duplicate: self.filter_duplicate,
+            strings.filter_day: self.filter_day,
+            strings.filter_night: self.filter_night,
+            strings.filter_nonascii: self.filter_nonascii,
+            strings.filter_lowpop: self.filter_lowpop,
+            strings.filter_modded: self.filter_modded,
+            strings.filter_unmodded: self.filter_unmodded,
+        }
+
+    def filter_3pp(self, rows: list[ServerRow]) -> list[ServerRow]:
+        return [row for row in rows if row.view != strings.filter_3pp]
+
+    def filter_1pp(self, rows: list[ServerRow]) -> list[ServerRow]:
+        return [row for row in rows if row.view != strings.filter_1pp]
+
+    def filter_official(self, rows: list[ServerRow]) -> list[ServerRow]:
+        return [row for row in rows if row.provider != strings.filter_official]
+
+    def filter_unofficial(self, rows: list[ServerRow]) -> list[ServerRow]:
+        return [row for row in rows if row.provider != strings.filter_unofficial]
+
+    def filter_empty(self, rows: list[ServerRow]) -> list[ServerRow]:
+        return [row for row in rows if row.players != 0]
+
+    def filter_full(self, rows: list[ServerRow]) -> list[ServerRow]:
+        return [row for row in rows if row.players != row.max_players]
+
+    def filter_duplicate(self, rows: list[ServerRow]) -> list[ServerRow]:
+        seen = set()
+        final = []
+        for row in rows:
+            if row.name not in seen:
+                seen.add(row.name)
+                final.append(row)
+        rows = final
+        return rows
+
+    def filter_day(self, rows: list[ServerRow]) -> list[ServerRow]:
+        return [row for row in rows if not re.match(DAY_REG, row.time)]
+
+    def filter_night(self, rows: list[ServerRow]) -> list[ServerRow]:
+        return [row for row in rows if not re.match(NIGHT_REG, row.time)]
+
+    def filter_nonascii(self, rows: list[ServerRow]) -> list[ServerRow]:
+        return [row for row in rows if row.name.isascii()]
+
+    def filter_lowpop(self, rows: list[ServerRow]) -> list[ServerRow]:
+        return [row for row in rows if (row.players / row.max_players * 100) > 30]
+
+    def filter_modded(self, rows: list[ServerRow]) -> list[ServerRow]:
+        return [row for row in rows if not row.modded]
+
+    def filter_unmodded(self, rows: list[ServerRow]) -> list[ServerRow]:
+        return [row for row in rows if row.modded]
+
+    def filter(self, filter_type: str, rows: list[ServerRow]) -> list[ServerRow]:
+        func = self.filter_map[filter_type]
+        return func(rows)
+
+
 class ProxyModelManager:
     """
     Manages access to cached FastInsertListStore resources and
@@ -31,20 +143,16 @@ class ProxyModelManager:
 
     def __init__(self, filter_man: "FilterManager") -> None:
         self.filter_cache: dict[
-            tuple[str],
-            list[tuple[str, str, str, str, int, int, int, str, int, int, str, bool]],
+            tuple[str, ...],
+            list[ServerRow],
         ] = {}
 
         self.proxy_model: "FastInsertListStore"
         self.filter_man = filter_man
+        self.filtration_manager = FiltrationManager()
 
-        self.control_model: (
-            list[tuple[str, str, str, str, int, int, int, str, int, int, str, bool]]
-            | None
-        ) = None
-        self.filtered: list[
-            tuple[str, str, str, str, int, int, int, str, int, int, str, bool]
-        ] = []
+        self.control_model: list[ServerRow] | None = None
+        self.filtered: list[ServerRow] = []
         self.success = True
 
     def has_control_model(self) -> bool:
@@ -52,12 +160,7 @@ class ProxyModelManager:
             return False
         return True
 
-    def append_row(self, row: list) -> None:
-        self.proxy_model.append(row)
-
-    def append_row_to_control(
-        self, row: tuple[str, str, str, str, int, int, int, str, int, int, str, bool]
-    ) -> None:
+    def append_row_to_control(self, row: ServerRow) -> None:
         if self.control_model is None:
             raise AttributeError("Trying to add rows to a non-existent model")
         self.control_model.append(row)
@@ -65,22 +168,24 @@ class ProxyModelManager:
 
     def update_playercount(self, playercount: "NewPlayerCount") -> None:
         treeiter = playercount.treeiter
-        self.proxy_model[treeiter][4] = playercount.players
-        self.proxy_model[treeiter][6] = playercount.queue
+        field = [f.name for f in fields(ServerRow)]
+        index_players = field.index("players")
+        index_queue = field.index("queue")
+        self.proxy_model[treeiter][index_players] = playercount.players
+        self.proxy_model[treeiter][index_queue] = playercount.queue
 
-    # TODO: use dataclass for record rows
     def append_row_to_history(
         self,
-        history: tuple[str, str, str, str, int, int, int, str, int, int, str, bool],
+        history: ServerRow,
     ) -> None:
-        addr = history[7]
-        qport = history[8]
+        addr = history.ip
+        qport = history.qport
 
         if self.control_model is None:
             raise AttributeError("Trying to append row to empty model")
         found = False
         for i, row in enumerate(self.control_model):
-            if addr == row[7] and qport == row[8]:
+            if addr == row.ip and qport == row.qport:
                 item = self.control_model.pop(i)
                 self.control_model.append(item)
                 found = True
@@ -89,6 +194,7 @@ class ProxyModelManager:
         if found is False:
             self.control_model.append(history)
 
+        # NOTE: truncate history to 10 records max
         if len(self.control_model) == 11:
             del self.control_model[0]
 
@@ -100,7 +206,7 @@ class ProxyModelManager:
         addr = f"{record.ip}:{record.gameport}"
         qport = record.qport
         for row in self.control_model:
-            if addr == row[7] and qport == row[8]:
+            if addr == row.ip and qport == row.qport:
                 self.control_model.remove(row)
                 break
         self.wipe_cache()
@@ -109,19 +215,22 @@ class ProxyModelManager:
     def clear_proxy_model(self) -> None:
         self.proxy_model.clear()
 
-    def get_proxy_model(self) -> Union["FastInsertListStore", None]:
+    def get_proxy_model(self) -> "FastInsertListStore | None":
         if hasattr(self, "proxy_model"):
             return self.proxy_model
         return None
 
     def filter(
         self, mode: FilterMode, skip_cache: bool = False
-    ) -> Union["FastInsertListStore", None]:
+    ) -> "FastInsertListStore | None":
         """
         Native Gtk.TreeView.refilter() method was not performant enough
         when running in the main loop with 40k+ records
 
         skip_cache: used when updating a record on Saved Servers/History and forcing a refilter
+
+        NOTE: data must be marshalled from ServerRow format before constructing list stores
+        The "clone" is the proxy model (list of tuples) actually fed into Gtk.TreeView
         """
         # TODO: filter cache: return a dataclass object with clearly enumerated map, keyword, and filter values
         # instead of just a serial list of strings
@@ -130,8 +239,9 @@ class ProxyModelManager:
         if skip_cache is False:
             if filters in self.filter_cache:
                 cached_rows = self.filter_cache[filters]
+                marshalled_rows = ServerRow.marshal_rows(cached_rows)
                 clone = ModelFactory().make_server_store()
-                clone.extend(cached_rows)
+                clone.extend(marshalled_rows)
                 self.set_proxy_model(clone)
                 self.set_filtered(cached_rows)
                 return None
@@ -150,17 +260,18 @@ class ProxyModelManager:
         clone = ModelFactory().make_server_store()
         if len(rows) > 0:
             rows = self.sort_rows(rows)
-            clone.extend(rows)
+            marshalled_rows = ServerRow.marshal_rows(rows)
+            clone.extend(marshalled_rows)
 
         self.set_cache(filters, rows)
         self.set_proxy_model(clone)
         return clone
 
-    def sort_rows(self, rows: list) -> list:
-        rows.sort(key=lambda x: re.sub(r"[^A-Za-z0-9]+", "", x[0].lower()))
+    def sort_rows(self, rows: list[ServerRow]) -> list[ServerRow]:
+        rows.sort(key=lambda x: re.sub(r"[^A-Za-z0-9]+", "", x.name.lower()))
         return rows
 
-    def filter_initial(self, filters: tuple) -> list:
+    def filter_initial(self, filters: tuple[str, ...]) -> list[ServerRow]:
         """
         Simply culls the control model of any disabled filters
         """
@@ -169,7 +280,7 @@ class ProxyModelManager:
             self.set_filtered(self.filter_toggle_off(filters, f))
         return self.filtered
 
-    def filter_map(self, filters: tuple) -> list:
+    def filter_map(self, filters: tuple[str, ...]) -> list[ServerRow]:
         """
         Multi-filtration for any context starts by narrowing by map
         """
@@ -179,10 +290,10 @@ class ProxyModelManager:
         if sel_map == str_filters.all_maps:
             return rows
 
-        rows = [row for row in rows if row[1] == sel_map]
+        rows = [row for row in rows if row.mapname == sel_map]
         return rows
 
-    def filter_keyword(self, filters: tuple) -> list:
+    def filter_keyword(self, filters: tuple[str, ...]) -> list[ServerRow]:
         keyword = self.filter_man.get_active_keyword()
         rows = self.filtered
 
@@ -192,13 +303,15 @@ class ProxyModelManager:
         filtered = [
             row
             for row in rows
-            if keyword in row[0].lower()
-            or keyword in row[1].lower()
-            or keyword in row[7].lower()
+            if keyword in row.name.lower()
+            or keyword in row.mapname.lower()
+            or keyword in row.ip.lower()
         ]
         return filtered
 
-    def filter_toggle_off(self, filters: tuple, filter_type: str) -> list:
+    def filter_toggle_off(
+        self, filters: tuple[str, ...], filter_type: str
+    ) -> list[ServerRow]:
         """
         Sub-filtration of the current model
         """
@@ -212,43 +325,11 @@ class ProxyModelManager:
                 self.set_filtered(None)
                 return []
 
-        rows = self.filtered
-        match filter_type:
-            case strings.filter_3pp:
-                rows = [row for row in rows if row[2] != strings.filter_3pp]
-            case strings.filter_1pp:
-                rows = [row for row in rows if row[2] != strings.filter_1pp]
-            case strings.filter_official:
-                rows = [row for row in rows if row[10] != strings.filter_official]
-            case strings.filter_unofficial:
-                rows = [row for row in rows if row[10] != strings.filter_unofficial]
-            case strings.filter_empty:
-                rows = [row for row in rows if row[4] != 0]
-            case strings.filter_full:
-                rows = [row for row in rows if row[4] != row[5]]
-            case strings.filter_duplicate:
-                seen = set()
-                final = []
-                for row in rows:
-                    if row[0] not in seen:
-                        seen.add(row[0])
-                        final.append(row)
-                rows = final
-            case strings.filter_day:
-                rows = [row for row in rows if not re.match(DAY_REG, row[3])]
-            case strings.filter_night:
-                rows = [row for row in rows if not re.match(NIGHT_REG, row[3])]
-            case strings.filter_nonascii:
-                rows = [row for row in rows if row[0].isascii()]
-            case strings.filter_lowpop:
-                rows = [row for row in rows if (row[4] / row[5] * 100) > 30]
-            case strings.filter_modded:
-                rows = [row for row in rows if not row[11]]
-            case strings.filter_unmodded:
-                rows = [row for row in rows if row[11]]
+        # TODO: pack filter type enum in filter checkbox, rather than stringwise comparison
+        rows = self.filtration_manager.filter(filter_type, self.filtered)
         return rows
 
-    def filter_toggle_on(self, filters: tuple[str]) -> list:
+    def filter_toggle_on(self, filters: tuple[str, ...]) -> list[ServerRow]:
         """Effectively applies all filters"""
         self.set_filtered(self.control_model)
         self.set_filtered(self.filter_map(filters))
@@ -259,31 +340,36 @@ class ProxyModelManager:
             self.set_filtered(self.filter_toggle_off(filters, f))
         return self.filtered
 
-    def set_cache(self, filters: tuple[str], filtered_rows: list[tuple]) -> None:
+    def set_cache(
+        self, filters: tuple[str, ...], filtered_rows: list[ServerRow]
+    ) -> None:
         self.filter_cache[filters] = filtered_rows
 
-    def set_filtered(self, rows: list | None) -> None:
+    def set_filtered(self, rows: list[ServerRow] | None) -> None:
         if rows is None:
             self.filtered = []
         else:
             self.filtered = rows
 
-    def get_filtered(self) -> list:
+    def get_filtered(self) -> list[ServerRow]:
         return self.filtered
 
     def set_proxy_model(self, model: "FastInsertListStore") -> None:
         """
         FastInsertListStore representation of the raw model after filtration
+
+        This attribute is saved from within a thread so that it later be retrieved
+        and safely packed into the TreeView in the main loop, cf. get_proxy_model()
         """
         self.proxy_model = model
 
-    def set_control(self, rows: list) -> None:
+    def set_control(self, rows: list[ServerRow]) -> None:
         """
         Raw data model prior to filtration
         """
         self.control_model = rows
 
-    def get_control(self) -> list[Any]:
+    def get_control(self) -> list[ServerRow]:
         if self.control_model is None:
             raise AttributeError(
                 "Expected a populated control model, but it is Nonetype"
@@ -294,7 +380,7 @@ class ProxyModelManager:
         self.filtered = []
         self.filter_cache = {}
 
-    def push(self, data: list[Any]) -> None:
+    def push(self, data: list[ServerRow]) -> None:
         self.wipe_cache()
         self.set_control(data)
         cur_keyword = self.filter_man.get_active_keyword()

dzgui/model/servers.py

@@ -26,7 +26,7 @@ from gi.repository import Gtk, GLib
 if TYPE_CHECKING:
     from dzgui.api.servers import A2SInfo, Record
     from dzgui.controllers.mc import Controller
-    from dzgui.model.proxy_model import ProxyModelManager
+    from dzgui.model.proxy_model import ProxyModelManager, ServerRow
     from dzgui.views.trees.tree_servers import ServerTreeView
 
 logger = logging.getLogger(APP_NAME)
@@ -241,10 +241,7 @@ class ServerModelManager:
 
     def update_history(
         self,
-        rows: (
-            list[tuple[str, str, str, str, int, int, int, str, int, int, str, bool]]
-            | None
-        ) = None,
+        rows: list["ServerRow"] | None = None,
     ) -> None:
         proxy_man = self._get_proxy_man()
         if rows is not None:
@@ -267,7 +264,6 @@ class ServerModelManager:
         self.first_iteration = False
         self.emitter.emit("load_maps", store)
 
-    # TODO: dataclass for record rows; check for other dict annotations
     def add_to_history(self, data: tuple[dict[str, Any], "Record"]) -> None:
         row, record = data
         proxy_man = self._get_proxy_man()
@@ -285,6 +281,10 @@ class ServerModelManager:
     def remove_from_history(self, record: Servers.Record) -> None:
         proxy_man = self._get_proxy_man()
         proxy_man.remove_row_from_control(record)
+
+        fqip = Servers.record_to_fqip(record)
+        config_man = self.controller.get_config_man()
+        config_man.remove_from_history_file(fqip)
         self.update_history()
 
     @call_on_thread(dialog.querying)
@@ -432,7 +432,7 @@ class ServerModelManager:
         if show_dialog:
             dialog = ExceptionDialog(self.controller, dialogs.load_error_lan)
             dialog.show_all()
-            dialog.run()
+            dialog.run()  # type: ignore[no-untyped-call]
 
     def _cleanup_on_failure(self, show_dialog: bool = True) -> None:
         # TODO: disable map, keyword, and filter widgets if model is None
@@ -451,15 +451,15 @@ class ServerModelManager:
             dialog = ExceptionDialog(self.controller, server_timeout)
             dialog.set_details_buffer(kb.DZG_006)
             dialog.show_all()
-            dialog.run()
+            dialog.run()  # type: ignore[no-untyped-call]
 
-    def _push_data(self, data: list[Any]) -> None:
+    def _push_data(self, data: list["ServerRow"]) -> None:
         self._get_proxy_man().push(data)
         self._sort_unique_maps(data)
         self.thread_man.set_cleanup_func(StoredFunc(self._cleanup_on_success))
 
-    def _sort_unique_maps(self, data: list) -> None:
-        u_maps = set([row[1] for row in data])
+    def _sort_unique_maps(self, data: list[Any]) -> None:
+        u_maps = set([row.mapname for row in data])
         self._set_new_maps(sorted(u_maps))
 
     def _set_new_maps(self, maps: list[str]) -> None:
@@ -473,7 +473,6 @@ class ServerModelManager:
 
     @call_on_thread(dialog.filtering)
     def refilter(self, mode: FilterMode) -> None:
-        # FIXME: causes two wait dialogs when map selection change signal emits after loading servers
         self.first_iteration = False
         proxy_man = self._get_proxy_man()
         proxy_man.filter(mode)

dzgui/strings/rows.py

@@ -0,0 +1,29 @@
+changelog_label = "View changelog"
+changelog_status = "Opens the DZGUI changelog"
+
+log_label = "Show debug log"
+log_status = "Read the DZGUI log generated since startup"
+
+separator_label = "SEPARATOR"
+separator_status = ""
+
+system_log_label = "Output system info to log file"
+system_log_status = "Dump diagnostic data for troubleshooting"
+
+docs_label = "Documentation/help files (GitHub) ⧉"
+docs_status = "Open the DZGUI documentation in a browser"
+
+docs_fallback_label = "Documentation/help files (Codeberg mirror) ⧉"
+docs_fallback_status = "Open the DZGUI documentation in a browser"
+
+bugs_label = "Report a bug (GitHub) ⧉"
+bugs_status = "Open the DZGUI issue tracker in a browser"
+
+forum_label = "DZGUI Subreddit ⧉"
+forum_status = "Open the DZGUI discussion forum in a browser"
+
+sponsor_label = "Sponsor (GitHub) ⧉"
+sponsor_status = "Sponsor development of the DZGUI project"
+
+thanks_label = "Special thanks"
+thanks_status = "A list of contributors, testers, and sponsors"

dzgui/util/diag.py

@@ -11,6 +11,7 @@ from dzgui.const.enum import Preferences
 from dzgui.config.query import lookup
 from dzgui.init.prefix import get_version
 from dzgui.util.redact import redact_home
+from dzgui.util.strings import unknown
 
 logger = logging.getLogger(APP_NAME)
 
@@ -27,28 +28,22 @@ def get_cpu_model() -> str:
 
 
 def print_servers(servers: list[str]) -> str:
-    s = ""
-    for server in servers:
-        s += server + "\n"
-    return s
+    return "\n".join(servers)
 
 
 def print_mods(mods: list[int]) -> str:
-    s = ""
-    for mod in mods:
-        s += str(mod) + "\n"
-    return s
+    return "\n".join(map(str, mods))
 
 
 def write_diagnostic(config: Path, outfile: Path) -> None:
     date = datetime.now().isoformat()
 
     try:
-        # FIXME: ID_LIKE not available on CachyOS
+        # NOTE: ID_LIKE not available on CachyOS
         distro = platform.freedesktop_os_release()["ID_LIKE"]
     except Exception as e:
         logger.warn(e)
-        distro = "Unknown"
+        distro = unknown
 
     kernel = os.uname().release
     cpu = get_cpu_model()
@@ -68,7 +63,6 @@ def write_diagnostic(config: Path, outfile: Path) -> None:
     servers = lookup(config, Preferences.IP_LIST)
     servers_pretty = print_servers(servers)
 
-    # FIXME: extraneous newlines in lists of mods
     template = f"""\
     {APP_NAME} version {version}
     Date: {date}
@@ -82,6 +76,7 @@ def write_diagnostic(config: Path, outfile: Path) -> None:
 
     Mods:
     {mods_pretty}
+
     Servers:
     {servers_pretty}
     """

dzgui/util/dist.py

@@ -54,7 +54,7 @@ class CalcDist:
         self,
         addr: str,
         enum: "ServerTab",
-        result_queue: "Queue",
+        result_queue: "Queue[tuple[str, Haversine | None, ServerTab]]",
         controller: "Controller",
         cache: dict[str, Haversine],
     ) -> None:
@@ -67,7 +67,7 @@ class CalcDist:
         self.ip = self.addr
 
         dist = self.compare(self.ip)
-        self.result_queue.put([self.addr, dist, self.enum])
+        self.result_queue.put((self.addr, dist, self.enum))
 
     def compare(self, remote_ip: str) -> Haversine | None:
         prefs = self.controller.get_prefs()

dzgui/util/flatpak.py

@@ -1,12 +1,16 @@
 import logging
 import subprocess
 
+from typing import TYPE_CHECKING
 from dzgui.const.constants import APP_NAME, FLATPAK_APPID, GTK_APP_ID, TMP_PATH
 
 logger = logging.getLogger(APP_NAME)
 
+if TYPE_CHECKING:
+    from pathlib import Path
 
-def apply_overrides(xdg: dict[str, str]) -> None:
+
+def apply_overrides(xdg: dict[str, "Path"]) -> None:
     try:
         # NOTE: D-Bus registration required for sandbox
         args = [
@@ -19,7 +23,7 @@ def apply_overrides(xdg: dict[str, str]) -> None:
         subprocess.run([*args], capture_output=True)
 
         paths: list[str] = []
-        paths.extend([*xdg.values()])
+        paths.extend([str(path) for path in xdg.values()])
         paths.append(TMP_PATH)
 
         for path in paths:

dzgui/util/format.py

@@ -1,4 +1,5 @@
 import re
+from typing import Any
 
 from dzgui.util.localize import number
 from dzgui.strings.generic import selectable_tree
@@ -60,7 +61,7 @@ def format_server_mods(mods: int) -> str:
     return f"Found {mods:n} {plural}. {workshop}"
 
 
-def format_player_count(model: Gtk.TreeModel | None, control: list) -> str:
+def format_player_count(model: Gtk.TreeModel | None, control: list[Any]) -> str:
     players = 0
     hits: int
     status: str

dzgui/util/ip.py

@@ -31,7 +31,7 @@ class ReservedIPError(Exception):
     pass
 
 
-def ip2list(ip: str) -> list:
+def ip2list(ip: str) -> list[int]:
     return [int(digit) for digit in ip.split(".")]
 
 

dzgui/util/strings.py

@@ -118,6 +118,7 @@ servers = {
     "0": "toggle filter 10",
     "Minus": "toggle filter 11",
     "Backslash": "toggle filter 12",
+    "Apostrophe": "toggle filter 13",
 }
 vim = {
     "j": "Move down a row/scroll up",
@@ -249,6 +250,7 @@ class Crumbs:
     developers: str
     default: str
     offline: str
+    connect: str
 
 
 @dataclass(slots=True, frozen=True)
@@ -436,6 +438,7 @@ crumbs = Crumbs(
     developers="Options > Developers",
     default="Servers > ",
     offline="Mods > Play offline",
+    connect="Connect",
 )
 
 no_mods = "No local mods found."

dzgui/views/components/buttonbox.py

@@ -19,7 +19,11 @@ if TYPE_CHECKING:
 
 class ContextualButton(Gtk.Button):
     def __init__(
-        self, label: str, opens: "NotebookPage", tooltip: str, context: ButtonType
+        self,
+        label: str,
+        opens: "NotebookPage | None",
+        tooltip: str,
+        context: ButtonType,
     ) -> None:
         super().__init__(
             label=label,
@@ -51,9 +55,9 @@ class ButtonBox(Gtk.Box):
 
         for side_button in ButtonType:
             button = ContextualButton(
-                label=side_button.dict["label"],
-                opens=side_button.dict["opens"],
-                tooltip=side_button.dict["tooltip"],
+                label=side_button.label,
+                opens=side_button.opens,
+                tooltip=side_button.tooltip,
                 context=side_button,
             )
 

dzgui/views/components/buttons.py

@@ -1,10 +1,8 @@
-from typing import Callable, Literal, Self, TYPE_CHECKING, Union
+from typing import Callable, Literal, Self, TYPE_CHECKING
 
 from dzgui.util.clip import copy_clipboard
-from dzgui.util.format import pluralize
 from dzgui.strings import buttons
 from dzgui.util.strings import (
-    alert_button_tooltip,
     atomic_buttons,
 )
 from dzgui.const.icons import (
@@ -14,7 +12,6 @@ from dzgui.const.icons import (
     ICON_LIST_ADD,
     ICON_REFRESH,
     ICON_STEAM,
-    ICON_WARNING,
     ICON_WEB_BROWSER,
 )
 from dzgui.strings import connect_panel
@@ -64,7 +61,7 @@ class IconButton(Gtk.Button):
         self.icon = Icon(icon, margin_start=margin_start, margin_end=margin_end)
         self.set_image(self.icon)
         self.set_image_position(position)
-        self.set_focus_on_click(False)
+        self.set_focus_on_click(False)  # type: ignore[no-untyped-call]
         self.set_always_show_image(True)
 
     def swap_icon(self, icon: str) -> None:
@@ -101,14 +98,13 @@ class LargeIconTextButton(IconButton):
 
 
 class ClipboardButton(IconTextButton):
-    def __init__(self, controller: Union["Controller", None], func: Callable) -> None:
+    def __init__(self, func: Callable[[], str]) -> None:
         super().__init__(ICON_CLIPBOARD, atomic_buttons.copy)
-        self.controller = controller
         self.connect("clicked", self._on_button_clicked, func)
 
         self.set_tooltip_text(buttons.clipboard_button)
 
-    def _on_button_clicked(self, button: Self, func: Callable) -> None:
+    def _on_button_clicked(self, button: Self, func: Callable[[], str]) -> None:
         def revert() -> Literal[False]:
             self.revert_icon()
             return False
@@ -119,10 +115,9 @@ class ClipboardButton(IconTextButton):
         GLib.timeout_add(600, revert)
 
 
-# TODO: determine when controller would be passed to this button or drop
 class CopyIpButton(ClipboardButton):
-    def __init__(self, controller: Union["Controller", None], func: Callable) -> None:
-        super().__init__(controller, func)
+    def __init__(self, func: Callable[[], str]) -> None:
+        super().__init__(func)
 
         self.set_tooltip_text(buttons.clipboard_ip_button)
 
@@ -249,30 +244,6 @@ class AddButton(IconTextButton):
         self.set_tooltip_text(connect_panel.add_tooltip)
 
 
-# TODO: drop
-class LoggerAlertsButton(IconTextButton):
-    def __init__(self, warnings: int, errors: int) -> None:
-        warnings_text = ""
-        errors_text = ""
-        separator = ""
-        if warnings > 0:
-            warnings_plural = pluralize("warnings", warnings)
-            warnings_text = f"{warnings} {warnings_plural}"
-        if errors > 0:
-            errors_plural = pluralize("errors", errors)
-            errors_text = f" {errors} {errors_plural}"
-        if warnings + errors > 1:
-            separator = ","
-        concat = warnings_text + separator + errors_text
-        super().__init__(
-            icon=ICON_WARNING,
-            label=f"Loaded with{concat}",
-        )
-        self.set_halign(Gtk.Align.END)
-        self.set_hexpand(True)
-        self.set_tooltip_text(alert_button_tooltip)
-
-
 class SpinnerButton(Gtk.Button):
     def __init__(self, label: str) -> None:
         super().__init__()

dzgui/views/components/connect_panel.py

@@ -189,7 +189,7 @@ class FavPanel(Gtk.Frame):
 
         self.fav_button = SteamConnectButton()
         self.fav_button.connect("clicked", self._on_connect_clicked)
-        self.copy_button = CopyIpButton(self.controller, self.get_fav_ip)
+        self.copy_button = CopyIpButton(self.get_fav_ip)
 
         self.unset_button = CloseButton(unset_button_label)
         self.unset_button.connect("clicked", self._on_unset_clicked)

dzgui/views/components/crumbs.py

@@ -43,7 +43,7 @@ class Breadcrumbs(Gtk.Label):
             label = page.get_current_tab_text()
             self.set_server_crumbs(label)
         else:
-            crumbs = enum.dict["crumbs"]
+            crumbs = enum.crumbs
             self.set_crumbs(crumbs)
 
     def set_server_crumbs(self, suffix: str) -> None:

dzgui/views/components/entry.py

@@ -39,7 +39,7 @@ class ValidatedEntry(Gtk.Entry):
     def __init__(
         self,
         controller: "Controller",
-        func: Callable,
+        func: Callable[[str], bool],
         placeholder_text: str = "",
         tooltip_text: str = "",
     ) -> None:
@@ -47,7 +47,6 @@ class ValidatedEntry(Gtk.Entry):
             hexpand=True, placeholder_text=placeholder_text, tooltip_text=tooltip_text
         )
 
-        self.func: Callable
         self.set_validation_func(func)
         self.controller = controller
 
@@ -73,7 +72,7 @@ class ValidatedEntry(Gtk.Entry):
         self.emit("string_validated", False)
         remove_class(self, self.classname)
 
-    def set_validation_func(self, func: Callable) -> None:
+    def set_validation_func(self, func: Callable[[str], bool]) -> None:
         self.func = func
 
     def insert_icon(self) -> None:
@@ -142,7 +141,7 @@ class APIEntry(Gtk.Box):
     def __init__(self) -> None:
         super().__init__(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
 
-        self.func: Callable | None = None
+        self.func: Callable[[str], None] | None = None
 
         self.entry = Gtk.Entry(
             width_chars=60, hexpand=True, placeholder_text=api_placeholder
@@ -221,7 +220,7 @@ class APIEntry(Gtk.Box):
         res = self.func(text)
         return res
 
-    def set_validation_func(self, func: Callable | None) -> None:
+    def set_validation_func(self, func: Callable[[str], None] | None) -> None:
         self.func = func
 
     def disable_button(self) -> None:

dzgui/views/components/filter_panel.py

@@ -31,7 +31,7 @@ class ButtonGrid(Gtk.Grid):
     def __init__(
         self,
         controller: "Controller",
-        defaults: dict[str, str],
+        defaults: dict[str, bool],
         tooltips: dict[str, str],
     ) -> None:
         super().__init__(
@@ -97,7 +97,7 @@ class ButtonGrid(Gtk.Grid):
         logger.info(f"User toggled button '{label}' to {state}")
         self.emitter.emit("check_toggled", label, state)
 
-    def get_checkboxes(self) -> list:
+    def get_checkboxes(self) -> list[Gtk.CheckButton]:
         return self.checks
 
 
@@ -306,6 +306,7 @@ class FilterPanel(Gtk.Box):
             Gdk.KEY_0: 9,
             Gdk.KEY_minus: 10,
             Gdk.KEY_backslash: 11,
+            Gdk.KEY_apostrophe: 12,
         }
         if keyval not in mappings:
             return False

dzgui/views/components/mod_panel.py

@@ -19,8 +19,8 @@ class EnumeratedModButton(Gtk.Button):
         super().__init__(margin_start=10, margin_end=10, focus_on_click=False)
 
         self.enum = enum
-        self.set_label(enum.dict["label"])
-        self.set_tooltip_text(enum.dict["tooltip"])
+        self.set_label(enum.label)
+        self.set_tooltip_text(enum.tooltip)
 
 
 class ModPanelButton(EnumeratedModButton):

dzgui/views/components/statusbar.py

@@ -2,7 +2,6 @@ from typing import Self, Union, TYPE_CHECKING
 
 from dzgui.const.enum import NotebookPage, ServerTab
 from dzgui.util.strings import esc_to_return, question_to_return
-from dzgui.views.components.buttons import LoggerAlertsButton
 
 import gi
 
@@ -47,9 +46,6 @@ class Statusbar(Gtk.Grid):
         self.emitter.connect("servers_loaded", self._on_servers_loaded)
         self.emitter.connect("mods_updated", self._on_mods_updated)
 
-    def _on_alerts_clicked(self, button: LoggerAlertsButton) -> None:
-        self.controller.populate_log()
-
     def _on_mods_updated(self, emitter: "Emitter", msg: str, mods: int) -> None:
         self.set_by_context(NotebookPage.MODS, msg)
 
@@ -60,7 +56,7 @@ class Statusbar(Gtk.Grid):
             return
 
         enum = notebook.get_page_by_enum()
-        show_statusbar = enum.dict["statusbar"]
+        show_statusbar = enum.has_statusbar
 
         if show_statusbar is False:
             self.set_by_context(enum, "")
@@ -152,5 +148,5 @@ class Statusbar(Gtk.Grid):
         row = tree.get_value_at_index(1)
         if self.controller.loaded is False:
             return
-        tooltip = row.dict["tooltip"]
+        tooltip = row.tooltip
         self.set_by_context(NotebookPage.HELP, tooltip)

dzgui/views/dialogs/boot.py

@@ -104,7 +104,7 @@ class BootDialog(ColorAwareApp, Gtk.Dialog):  # type: ignore
         self.error_label = Gtk.Label(margin_start=15, margin_end=15)
 
         # TODO: abstract class
-        self.copy_button = ClipboardButton(None, lambda: self.error_label.get_text())
+        self.copy_button = ClipboardButton(self.error_label.get_text)
         self.button_hbox = Gtk.Box(
             orientation=Gtk.Orientation.HORIZONTAL, halign=Gtk.Align.CENTER, spacing=10
         )

dzgui/views/dialogs/early_alert.py

@@ -46,7 +46,7 @@ class AbortDialog(ColorAwareApp, Gtk.MessageDialog):  # type: ignore
 
         self.connect("response", self._on_response)
 
-        self.run()
+        self.run()  # type: ignore[no-untyped-call]
         self.destroy()
 
     def _on_response(self, dialog: Self, response: Gtk.ResponseType) -> None:

dzgui/views/dialogs/filepicker.py

@@ -16,14 +16,14 @@ class FilePicker(Gtk.FileChooserDialog):
             transient_for=parent,
             resizable=True,
         )
-        self.add_buttons("_Cancel", Gtk.ResponseType.CANCEL)
-        self.add_buttons("_Save", Gtk.ResponseType.OK)
+        self.add_buttons("_Cancel", Gtk.ResponseType.CANCEL)  # type: ignore[no-untyped-call]
+        self.add_buttons("_Save", Gtk.ResponseType.OK)  # type: ignore[no-untyped-call]
         self.set_default_response(Gtk.ResponseType.OK)
 
         self.set_current_name(picker.placeholder)
 
     def pick_file(self) -> Path | None:
-        res = self.run()
+        res = self.run()  # type: ignore[no-untyped-call]
         if res in (Gtk.ResponseType.CANCEL, Gtk.ResponseType.DELETE_EVENT):
             self.destroy()
             return None
@@ -43,12 +43,12 @@ class FolderPicker(Gtk.FileChooserDialog):
             parent=parent,
             resizable=True,
         )
-        self.add_buttons("_Cancel", Gtk.ResponseType.CANCEL)
-        self.add_buttons("_OK", Gtk.ResponseType.OK)
+        self.add_buttons("_Cancel", Gtk.ResponseType.CANCEL)  # type: ignore[no-untyped-call]
+        self.add_buttons("_OK", Gtk.ResponseType.OK)  # type: ignore[no-untyped-call]
         self.set_default_response(Gtk.ResponseType.OK)
 
     def pick_folder(self) -> Path | None:
-        res = self.run()
+        res = self.run()  # type: ignore[no-untyped-call]
         if res in (Gtk.ResponseType.CANCEL, Gtk.ResponseType.DELETE_EVENT):
             self.destroy()
             return None

dzgui/views/dialogs/generic.py

@@ -185,7 +185,7 @@ class TextBufferDialog(GenericDialog):
             secondary=secondary,
         )
         self.text = text
-        copy_button = ClipboardButton(controller, self.get_text)
+        copy_button = ClipboardButton(self.get_text)
         self.add_action_widget(copy_button, Gtk.ResponseType.NONE)
         self.add_button("OK", Gtk.ResponseType.OK)
         self.connect("response", self._on_response)

dzgui/views/dialogs/uninstall.py

@@ -22,7 +22,7 @@ from gi.repository import Gtk, GLib, Pango
 
 
 class Assistant(Gtk.Assistant):
-    def __init__(self, is_deck: bool, paths: dict[str, str]):
+    def __init__(self, is_deck: bool, paths: dict[str, Path]):
         super().__init__()
         if is_deck:
             # NOTE: deemed to be "safe" dimensions that exclude taskbar size
@@ -63,7 +63,7 @@ class Assistant(Gtk.Assistant):
 
 
 class Window(Gtk.Window):
-    def __init__(self, is_deck: bool, paths: dict[str, str]) -> None:
+    def __init__(self, is_deck: bool, paths: dict[str, Path]) -> None:
         super().__init__(title=APP_NAME, icon_name=APP_NAME)
         self.assistant = Assistant(is_deck, paths)
 
@@ -121,7 +121,7 @@ class CheckboxWithPath(CheckboxWithLabel):
 
 
 class UninstallPage(ScrolledWizardPage):
-    def __init__(self, paths: dict[str, str], pyapp: str | None):
+    def __init__(self, paths: dict[str, Path], pyapp: str | None):
         super().__init__(heading=uninstall.pg1_heading, description=uninstall.pg1_blurb)
 
         self.pyapp = pyapp
@@ -219,7 +219,7 @@ class UninstallPage(ScrolledWizardPage):
 
 
 class UninstallWizard(ColorAwareApp, Gtk.Application):  # type: ignore
-    def __init__(self, is_deck: bool, paths: dict[str, str]) -> None:
+    def __init__(self, is_deck: bool, paths: dict[str, Path]) -> None:
         super().__init__()
         config = Path(paths["XDG_CONFIG_HOME"])
         if not config.is_dir() or not config.joinpath("config.json").is_file():

dzgui/views/dialogs/wizard.py

@@ -168,7 +168,12 @@ class NotificationFrame(Gtk.Frame):
 
 class APIValidationPage(EnumeratedWizardPage):
     def __init__(
-        self, enum: PageNum, heading: str, description: str, link: str, func: Callable
+        self,
+        enum: PageNum,
+        heading: str,
+        description: str,
+        link: str,
+        func: Callable[[str], None],
     ) -> None:
         super().__init__(
             enum=enum,
@@ -421,7 +426,7 @@ class PreferencesPage(EnumeratedWizardPage):
 
 
 class FlatpakOverridePage(EnumeratedWizardPage):
-    def __init__(self, xdg_paths: dict[str, str]) -> None:
+    def __init__(self, xdg_paths: dict[str, Path]) -> None:
         super().__init__(
             enum=PageNum.FLATPAK,
             heading=wizard.heading_flatpak,
@@ -471,7 +476,7 @@ class CompletionPage(EnumeratedWizardPage):
 
 
 class Assistant(Gtk.Assistant):
-    def __init__(self, is_deck: bool, XDG: "Xdg", xdg_paths: dict[str, str]):
+    def __init__(self, is_deck: bool, XDG: "Xdg", xdg_paths: dict[str, Path]):
         super().__init__()
         if is_deck:
             # NOTE: deemed to be "safe" dimensions that exclude taskbar size
@@ -776,7 +781,7 @@ class SteamPathPage(EnumeratedWizardPage):
 
 
 class SetupWizard(ColorAwareApp, Gtk.Application):  # type: ignore
-    def __init__(self, is_deck: bool, XDG: "Xdg", xdg_paths: dict[str, str]) -> None:
+    def __init__(self, is_deck: bool, XDG: "Xdg", xdg_paths: dict[str, Path]) -> None:
         super().__init__()
         GLib.set_prgname(APP_NAME)
         self.win = Window(is_deck, XDG, xdg_paths)
@@ -787,7 +792,7 @@ class SetupWizard(ColorAwareApp, Gtk.Application):  # type: ignore
 
 
 class Window(Gtk.Window):
-    def __init__(self, is_deck: bool, XDG: "Xdg", xdg_paths: dict[str, str]) -> None:
+    def __init__(self, is_deck: bool, XDG: "Xdg", xdg_paths: dict[str, Path]) -> None:
         super().__init__(title=APP_NAME, icon_name=APP_NAME)
         self.assistant = Assistant(is_deck, XDG, xdg_paths)
 

dzgui/views/mixins/context_mixin.py

@@ -1,7 +1,7 @@
 import logging
 
 from dzgui.const.constants import APP_NAME
-from dzgui.const.enum import ContextMenu
+from dzgui.const.enum import ContextMenuItem
 from dzgui.util.keys import is_ctrl_mask, is_navkey
 from dzgui.util.strings import edit_note
 from dzgui.views.trees.tree_base import TreeView
@@ -15,9 +15,7 @@ logger = logging.getLogger(APP_NAME)
 
 
 class ContextMixin(TreeView):
-    def present_menu(
-        self, widget: Gtk.Widget, event: Gdk.Event
-    ) -> bool:
+    def present_menu(self, widget: Gtk.Widget, event: Gdk.Event) -> bool:
 
         if self.menu is None:
             return False
@@ -26,7 +24,7 @@ class ContextMixin(TreeView):
 
         match event.type:
             case Gdk.EventType.BUTTON_PRESS:
-                if event.button != 3:
+                if event.button != Gdk.BUTTON_SECONDARY:  # type: ignore[comparison-overlap]
                     return False
                 self._process_button_event(event)  # type: ignore
             case Gdk.EventType.KEY_PRESS:
@@ -60,17 +58,17 @@ class ContextMixin(TreeView):
         self.context_menu.select_first(False)
         return True
 
-    def _process_dynamic_row(self, row: ContextMenu) -> Gtk.MenuItem:
-        if row == ContextMenu.ADD_SERVER and self.is_in_favs():  # type: ignore
-            row = ContextMenu.REMOVE_SERVER
+    def _process_dynamic_row(self, row: ContextMenuItem) -> Gtk.MenuItem:
+        if row == ContextMenuItem.ADD_SERVER and self.is_in_favs():  # type: ignore
+            row = ContextMenuItem.REMOVE_SERVER
 
-        item = Gtk.MenuItem(label=row.dict["label"])
+        item = Gtk.MenuItem(label=row.label)
         item.connect("activate", self._on_menu_click, row)
 
-        if row == ContextMenu.SHOW_MODS:
+        if row == ContextMenuItem.SHOW_MODS:
             item.set_sensitive(self.is_modded())  # type: ignore
 
-        if row == ContextMenu.ADD_NOTE:
+        if row == ContextMenuItem.ADD_NOTE:
             if self.controller.has_note():
                 item.set_label(edit_note)
 
@@ -94,7 +92,7 @@ class ContextMixin(TreeView):
         except AttributeError:
             return False
 
-    def _on_menu_click(self, widget: Gtk.MenuItem, enum: ContextMenu) -> None:
+    def _on_menu_click(self, widget: Gtk.MenuItem, enum: ContextMenuItem) -> None:
         self.controller.menu_action(enum, self)  # type: ignore
 
     def _on_key(self, menu: Gtk.Menu, event: Gdk.EventKey) -> bool | None:

dzgui/views/pages/keys.py

@@ -13,6 +13,7 @@ if TYPE_CHECKING:
     from dzgui.controllers.mc import Controller
 
 
+# TODO: refactor into autopopulated ListStores
 class Keybindings(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
     """
     Notebook page holding a prearranged grid
@@ -35,7 +36,7 @@ class Keybindings(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
 
         self.connect("key-press-event", self._on_keypress)
 
-    def build_keys(self, items: list) -> Gtk.Grid:
+    def build_keys(self, items: list[dict[str, str]]) -> Gtk.Grid:
         grid = Gtk.Grid(row_spacing=10, column_homogeneous=True)
         grid.set_halign(Gtk.Align.START)
         row, col = 1, 0
@@ -72,7 +73,7 @@ class Keybindings(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
             row += 1
         return grid
 
-    def build_sidebar(self, categories: list) -> Gtk.Grid:
+    def build_sidebar(self, categories: list[str]) -> Gtk.Grid:
         row, col = 0, 0
         w, h = 1, 1
         sidebar = Gtk.Grid(row_homogeneous=True, orientation=Gtk.Orientation.VERTICAL)
@@ -83,7 +84,7 @@ class Keybindings(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
             sidebar.attach(label, col, row, w, h)
         return sidebar
 
-    def build_grid(self, items: list) -> Gtk.Grid:
+    def build_grid(self, items: list[dict[str, str]]) -> Gtk.Grid:
         grid = Gtk.Grid(
             row_spacing=20,
             halign=Gtk.Align.CENTER,

dzgui/views/pages/options.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Callable, TYPE_CHECKING
+from typing import Any, Callable, TYPE_CHECKING
 
 from dzgui.api import pefile as PeFile
 from dzgui.api.steam import get_last_updated
@@ -51,7 +51,7 @@ class SubmitField(Gtk.Box):
     ) -> None:
         super().__init__(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
 
-        self.callback: Callable
+        self.callback: Callable[[], None]
         self.controller = controller
         self.context = context
 
@@ -139,7 +139,7 @@ class SubmitField(Gtk.Box):
             return
         self.save_option()
 
-    def set_callback(self, callback: Callable) -> None:
+    def set_callback(self, callback: Callable[[], None]) -> None:
         self.callback = callback
 
     def save_option(self) -> None:
@@ -206,7 +206,7 @@ class NameSubmitField(SubmitField):
             Preferences.NAME,
             private=False,
         )
-        self.entry.set_width_chars(30)  # type: ignore
+        self.entry.set_width_chars(30)
         self.set_callback(self.save_player_name)
 
     def save_player_name(self) -> None:
@@ -402,7 +402,8 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
     def _on_link_button_clicked(self, button: Gtk.Button, url: str) -> None:
         open_links.open_link_by_url(url)
 
-    def _make_grid(self, rows: list) -> Gtk.Grid:
+    # TODO: use FlowBox
+    def _make_grid(self, rows: list[list[Any]]) -> Gtk.Grid:
         grid = Gtk.Grid(
             orientation=Gtk.Orientation.VERTICAL,
             column_spacing=10,
@@ -435,7 +436,7 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
         if prefs.paths.config.is_file() is False:
             dialog = ExceptionDialog(self.controller, strings.config_not_found)
             dialog.show_all()
-            dialog.run()
+            dialog.run()  # type: ignore[no-untyped-call]
             raise OSError(f"Config file '{prefs.paths.config}' not found")
 
         config = query.get_config(prefs.paths.config)

dzgui/views/pages/preconnect.py

@@ -231,7 +231,7 @@ class PreConnectionAssistant(Gtk.Box):
         args = self.controller.get_debug_args()
         d = DebugDialog(self.controller, args)
         d.show_all()
-        d.run()
+        d.run()  # type: ignore[no-untyped-call]
 
     def _on_ok_clicked(self, button: Gtk.Button) -> None:
         self.controller.update_and_connect()

dzgui/views/trees/tree_base.py

@@ -79,11 +79,6 @@ class TreeView(CursorMixin, Gtk.TreeView):  # type: ignore
         index = path.get_indices()[0]
         return index
 
-    def get_selected_records(self) -> list:
-        sel = self.get_selection()
-        model, rows = sel.get_selected_rows()
-        return [model[row] for row in rows]
-
     def _on_keypress(self, treeview: Gtk.TreeView, event: Gdk.EventKey) -> bool:
         from dzgui.views.trees.tree_servers import ServerTreeView
 
@@ -145,9 +140,11 @@ class TreeView(CursorMixin, Gtk.TreeView):  # type: ignore
         self.set_cursor(path)
 
     def get_value_at_index(self, index: int) -> Any:
-        (model, pathlist) = self.get_model_and_pathlist()
+        model, pathlist = self.get_model_and_pathlist()
         if len(pathlist) < 1:
             return ""
+        if model is None:
+            return ""
         path = pathlist[0]
         tree_iter = model.get_iter(path)
         value = model.get_value(tree_iter, index)
@@ -161,20 +158,16 @@ class TreeView(CursorMixin, Gtk.TreeView):  # type: ignore
         sel = self.get_selection()
         self._on_tree_selection_changed(sel)
 
-    def get_model_and_pathlist(self) -> tuple:
+    def get_model_and_pathlist(
+        self,
+    ) -> tuple[Gtk.TreeModel | None, list[Gtk.TreePath]]:
         select = self.get_selection()
         sels = select.get_selected_rows()
-        (model, pathlist) = sels
+        model: Gtk.TreeModel | None
+        pathlist: list[Gtk.TreePath]
+        model, pathlist = sels
         return (model, pathlist)
 
-    # @deprecated("Currently unused")
-    # def get_mpath(self) -> Optional[Gtk.TreePath]:
-    #    (model, pathlist) = self.get_model_and_pathlist()
-    #    if len(pathlist) < 1:
-    #        return None
-    #    path = pathlist[0]
-    #    return path
-
     def _on_row_activated(
         self,
         treeview: Gtk.TreeView,
@@ -189,15 +182,6 @@ class TreeView(CursorMixin, Gtk.TreeView):  # type: ignore
             return True
         return False
 
-    # @deprecated("unused")
-    # def get_selected_row(self) -> Optional[Gtk.TreeModelRow]:
-    #    ind = self.get_selected_row_index()
-    #    model = self.get_model()
-    #    if model is None:
-    #        return None
-    #    row = model[ind]
-    #    return row
-
     def get_col_value_by_path_index(self, path: Gtk.TreePath, index: int) -> Any:
         model = self.get_model()
         if model is None:

dzgui/views/trees/tree_menu.py

@@ -77,4 +77,4 @@ class MenuTreeView(TreeView):
             raise ValueError("Trying to call a method on non-existent model")
         _iter = self.get_focused_row_iter()
         rowtype = model.get_value(_iter, 1)
-        return str(rowtype.dict["tooltip"])
+        return str(rowtype.tooltip)

dzgui/views/trees/tree_servers.py

@@ -7,7 +7,7 @@ from warnings import deprecated
 
 from dzgui.api.servers import ping, Record
 from dzgui.const.constants import APP_NAME
-from dzgui.const.enum import ContextMenu, ContextMenuGroup, ServerTab
+from dzgui.const.enum import ContextMenuItem, ContextMenuGroup, ServerTab
 from dzgui.managers.filter import FilterManager
 from dzgui.model.proxy_model import ProxyModelManager
 from dzgui.util import strings
@@ -32,6 +32,7 @@ if TYPE_CHECKING:
     from dzgui.controllers.mc import Controller
     from dzgui.controllers.emitter import Emitter
     from dzgui.model.model_factory import FastInsertListStore
+    from dzgui.util.dist import Haversine
 
 QUEUE_CHECK_DELAY = 200
 
@@ -64,7 +65,7 @@ class ServerTreeView(ContextMixin, TreeView):  # type: ignore
 
         self.queue_id: int
         self.handler_id: int
-        self.queue: Queue = Queue()
+        self.queue: Queue[tuple[str, "Haversine" | None, ServerTab]] = Queue()
 
         self.seen_cache: list[Record] = []
 
@@ -250,9 +251,9 @@ class ServerTreeView(ContextMixin, TreeView):  # type: ignore
                     if self.enum is ServerTab.LAN:
                         self.emitter.emit("request_custom_port_focus")
                 case Gdk.KEY_c:
-                    self.controller.menu_action(ContextMenu.COPY_SERVER_IP, self)
+                    self.controller.menu_action(ContextMenuItem.COPY_SERVER_IP, self)
                 case Gdk.KEY_r:
-                    self.controller.menu_action(ContextMenu.REFRESH_PLAYERS, self)
+                    self.controller.menu_action(ContextMenuItem.REFRESH_PLAYERS, self)
         else:
             match event.keyval:
                 case Gdk.KEY_l | Gdk.KEY_Right:
@@ -406,11 +407,15 @@ class ServerTreeView(ContextMixin, TreeView):  # type: ignore
         path = model.get_path(it)
         row_index = path.get_indices()[0]
         try:
-            start, end = self.get_visible_range()
+            start, end = self.get_visible_range()  # type: ignore[no-untyped-call]
         except Exception:
             return
         if row_index >= start[0] <= end[0]:
             # NOTE: fetch raw data rows
             real_model = self.proxy_man.get_control()
-            value = real_model[row_index][col_index]
+            from dataclasses import fields
+            from dzgui.model.proxy_model import ServerRow
+            key = fields(ServerRow)[col_index].name
+
+            value = getattr(real_model[row_index], key)
             cell.set_property("text", str(value))

pyproject.toml

@@ -105,7 +105,7 @@ python-a2s = { path = "./dzgui/lib/a2s", editable = true }
 dayzquery = { path = "./dzgui/lib/dayzquery", editable = true }
 
 [tool.uv]
-config-settings-package = { pygobject-stubs = { config = "Gtk3,Gdk3,Soup2" } }
+config-settings-package = { pygobject-stubs = { config = "Gtk3,Gdk3" } }
 
 [tool.pytest.ini_options]
 markers = [

tests/test_legacy_version_file.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING
+
+from dzgui.init.migrate import clean_legacy_versions_file
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_null_signature_stripping(tmp_path: "Path") -> None:
+    tmp = tmp_path.joinpath("dzg.versions")
+    lines = [
+        "1111,2222",
+        "3333,4444",
+        "5555,null",
+        "foo",
+        ",4555",
+        "1111",
+        " ",
+        ",,,",
+        "-1",
+    ]
+    expect = ["1111,2222", "3333,4444"]
+    tmp.write_text("\n".join(lines))
+    clean_legacy_versions_file(tmp)
+    assert expect == tmp.read_text().splitlines()

tests/test_row_marshalling.py

@@ -0,0 +1,26 @@
+from dzgui.model.model_factory import ModelFactory
+from dzgui.model.proxy_model import ServerRow
+
+
+def test_row_conversion() -> None:
+    """Converted FastInsertListStore is expected to have identical elements"""
+    data = [
+        "Test Server",
+        "chernarusplus",
+        "1PP",
+        "05:00",
+        10,
+        10,
+        0,
+        "127.0.0.0:27016",
+        27017,
+        99,
+        "Unofficial",
+        False,
+    ]
+    rows = [ServerRow(*data)]
+    marshalled = ServerRow.marshal_rows(rows)
+    store = ModelFactory().make_server_store()
+    store.extend(marshalled)
+    converted = [[el for el in row] for row in store]
+    assert data == converted[0]