chore: drop old comments

Prerelease/7.0.0b30

CHANGELOG.md

@@ -53,6 +53,10 @@
 - Expand/collapse changelog versions
 - Support local light/dark mode changes on system theme
 - Server time calculator
+- Add "Unmodded" filter to servers
+- List timestamp of last DayZ client update
+- Validate mods via Mod page to pull in updates
+- Support for Nasdara (Badlands) DLC
 
 ### Changed
 - Conform to PEP 440 versioning for beta versions
@@ -74,6 +78,7 @@
 - Enable LAN page Empty/Full filters on first run of app
 - Propagate subscribed mods to Steam client
 - Make j/k keys in context menus follow same wraparound logic as down arrow/up arrow
+- Use SQLite DB for geolocation records
 
 ### Dropped
 - Battlemetrics API support
@@ -92,6 +97,8 @@
 - Moved dialogs out of threads
 - History table not being in lock-step with state file
 - Current keyword filter not being applied when refreshing table
+- Steam Flatpak cannot run DZGUI as a non-Steam game
+- Collisions between native Steam and Steam Flatpak clients
 
 ### Unreleased
 - Load offline mods

dzgui/api/acf.py

@@ -1,15 +1,18 @@
 import logging
 import re
 
-from collections.abc import Iterator
+from datetime import datetime
 from pathlib import Path
-from typing import Any
+from typing import Any, TYPE_CHECKING
 from warnings import deprecated
 
 from dzgui.const.constants import APP_NAME
 
 logger = logging.getLogger(APP_NAME)
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
 
 class ACF:
     def __init__(self, file: Path) -> None:
@@ -42,7 +45,7 @@ class ACF:
     def dequote(cls, s: str) -> str:
         return s.rstrip('"').lstrip('"')
 
-    def parse(self, lines: Iterator[list[str]]) -> dict[str, str]:
+    def parse(self, lines: "Iterator[list[str]]") -> dict[str, str]:
         acf: dict[str, Any] = {}
         try:
             while True:
@@ -69,6 +72,28 @@ class ACF:
         except StopIteration:
             return acf
 
+    def search_key(self, key: str) -> str:
+        return str(self.dict["AppState"][key])
+
+    def date_to_str(self, epoch: int) -> str | None:
+        if epoch == 0:
+            return None
+        return datetime.fromtimestamp(epoch).isoformat(" ")
+
+    def get_date_by_key(self, key: str) -> str | None:
+        try:
+            stamp = int(self.search_key(key))
+            return self.date_to_str(stamp)
+        except Exception as e:
+            logger.critical(e)
+            return None
+
+    def get_last_updated(self) -> str | None:
+        return self.get_date_by_key("LastUpdated")
+
+    def get_last_played(self) -> str | None:
+        return self.get_date_by_key("LastPlayed")
+
     def get_allows_downloads(self) -> int | None:
         try:
             # TODO: consider coercing strs to ints on initial import

dzgui/api/mods.py

@@ -24,14 +24,6 @@ from typing import Any
 logger = logging.getLogger(APP_NAME)
 
 
-@dataclass
-class ModMeta:
-    protocol: str
-    published_id: str
-    name: str
-    timestamp: str
-
-
 def get_local_mod_ids(steam_path: Path) -> list[int]:
     workshop_path = get_local_mod_path(steam_path)
     mods = get_local_mods(workshop_path)

dzgui/api/steam.py

@@ -12,6 +12,7 @@ from typing import Any, Generator, Union
 from warnings import deprecated
 
 from dzgui.api.acf import ACF
+from dzgui.const.endpoints import VALIDATE
 from dzgui.init.prereqs import has_any_client
 from dzgui.init.prereqs import has_flatpak_client, has_steam_client
 from dzgui.const.constants import (
@@ -316,10 +317,9 @@ def unsubscribe(key: str, mod: int) -> None:
     update_workshop(key, mod, UNSUB_ENDPOINT)
 
 
-@deprecated("Use subscribe()")
-def enqueue_mod(client: str, mod: str, appid: int) -> None:
+def validate_mod(client: str, mod: str) -> None:
     client_args = concat_bash_args(client)
-    subprocess.Popen([*client_args, "+workshop_download_item", str(appid), mod])
+    subprocess.Popen([*client_args, "+workshop_download_item", str(APPID_DAYZ), mod])
 
 
 @deprecated("Cf. https://github.com/ValveSoftware/steam-for-linux/issues/9672")
@@ -389,6 +389,26 @@ def get_running_app() -> int | None:
     return None
 
 
+def get_last_updated(path: Path, appid: int) -> str | None:
+    root_path = get_app_path(path, appid)
+    acf = root_path.joinpath(f"steamapps/appmanifest_{appid}.acf")
+    try:
+        return ACF(acf).get_last_updated()
+    except Exception as e:
+        logger.critical(e)
+        return None
+
+
+def get_last_played(path: Path, appid: int) -> str | None:
+    root_path = get_app_path(path, appid)
+    acf = root_path.joinpath(f"steamapps/appmanifest_{appid}.acf")
+    try:
+        return ACF(acf).get_last_played()
+    except Exception as e:
+        logger.critical(e)
+        return None
+
+
 def get_app_allows_downloads(path: Path, appid: int) -> bool:
     try:
         root_path = get_app_path(path, appid)
@@ -500,3 +520,10 @@ def get_app_name(appid: int) -> str | None:
     except Exception as e:
         logger.debug(e)
         return None
+
+
+@deprecated("Currently unused")
+def validate_dayz(client: str) -> None:
+    client_args = concat_bash_args(client)
+    uri = VALIDATE + str(APPID_DAYZ)
+    subprocess.Popen([*client_args, uri])

dzgui/app_init.py

@@ -121,7 +121,7 @@ def load_steam_icon() -> None:
         logger.critical(e)
 
 
-def load_gui(version: str, is_debug: bool) -> None:
+def build_gui(version: str, is_debug: bool) -> App | None:
     lock = lock_acquire()  # noqa
 
     set_locale()
@@ -151,16 +151,13 @@ def load_gui(version: str, is_debug: bool) -> None:
         wizard = SetupWizard(_is_steam_deck, XDG, xdg_paths)
 
         if not wizard.is_setup_complete():
-            return
+            return None
 
     setup_logger(XDG.debug)
     with open(XDG.debug, "w") as f:
         f.truncate(0)
 
     if _is_steam_deck is False:
-        # TODO: sudo escalation dialog
-        # count = get_map_count()
-        # TODO: move into module
         if FLATPAK_ROOT_PATH in lookup(XDG.config, Preferences.DEFAULT):
             has_client = has_flatpak_client()
         else:
@@ -186,4 +183,4 @@ def load_gui(version: str, is_debug: bool) -> None:
     print(boot.all_ok)
     load_steam_icon()
     app = App(prefs)
-    app.run(None)
+    return app

dzgui/config/ipdb.py

@@ -3,6 +3,9 @@ import logging
 import re
 import requests
 import shutil
+import socket
+import sqlite3
+import time
 
 from pathlib import Path
 
@@ -22,15 +25,16 @@ def find_download_url(url: str) -> str | None:
     return str(urls[0])
 
 
-def get_ipdb(ips_path: Path) -> None:
+def get_ipdb(db_path: Path) -> None:
     try:
         url = find_download_url(DB_IP)
         if url is None:
             return
 
+        ips_path = db_path.with_suffix(".csv")
+        month_file = db_path.parent / ".month"
         date = find_date(url)
-        month_file = ips_path.parent / ".month"
-        if ips_path.exists() and month_file.exists():
+        if db_path.exists() and month_file.exists():
             old_date = month_file.read_text().rstrip("\n")
             if old_date == date:
                 logger.info(f"IP DB date matches: {date}")
@@ -45,6 +49,9 @@ def get_ipdb(ips_path: Path) -> None:
         logger.info("Stripping IPv6 records")
         strip_ipv6(ips_path)
 
+        create_table(db_path, ips_path)
+        ips_path.unlink()
+
         with open(month_file, "w") as f:
             f.write(date)
         logger.info(f"Wrote {date} to {month_file}")
@@ -108,3 +115,95 @@ def strip_ipv6(path: Path) -> None:
             out.write(merged)
     path.unlink()
     alt_path.rename(path)
+
+
+def ip_to_int(ip: str) -> int:
+    return int.from_bytes(socket.inet_aton(ip), "big")
+
+
+def marshal_rows(ip_file: Path) -> list[tuple[int, int, str, str]]:
+    YIELD = 0.003
+    SLEEP = 0.001
+    with open(ip_file, "r") as f:
+        rows: list[tuple[int, int, str, str]] = []
+        # NOTE: yield to GIL periodically to reduce load on spinner
+        last_yield = time.monotonic()
+        for row in f:
+            start, end, lat, lon = row.rstrip("\n").split(",")
+            int_start = ip_to_int(start)
+            int_end = ip_to_int(end)
+            rows.append((int_start, int_end, lat, lon))
+
+            now = time.monotonic()
+            if (now - last_yield) >= YIELD:
+                time.sleep(SLEEP)
+                last_yield = time.monotonic()
+    return rows
+
+
+def create_table(db_file: Path, ip_file: Path) -> None:
+    create = """
+    CREATE TABLE IF NOT EXISTS ips (
+    start_range INTEGER PRIMARY KEY,
+    end_range INTEGER,
+    latitude REAL,
+    longitude REAL
+    ) WITHOUT ROWID;
+    """
+    insert = """
+        INSERT INTO ips
+        (start_range, end_range, latitude, longitude)
+        values(?, ?, ?, ?)
+    """
+
+    if db_file.exists():
+        db_file.unlink()
+
+    conn = sqlite3.connect(":memory:")
+    c = conn.cursor()
+
+    try:
+        c.execute(create)
+        rows = marshal_rows(ip_file)
+        c.executemany(insert, rows)
+        logger.info(f"Inserted {len(rows)} IP records into database")
+        conn.commit()
+        with sqlite3.connect(db_file) as dest:
+            conn.backup(dest)
+        logger.info(f"Serialized IP records to database: '{db_file}'")
+        conn.close()
+    except Exception as e:
+        logger.critical(e)
+
+
+def read_from_table(db_path: Path, ip: str) -> tuple[float, float]:
+    if not db_path.exists():
+        raise FileNotFoundError(f"No file found at the location '{db_path}")
+
+    conn = sqlite3.connect(db_path)
+    c = conn.cursor()
+
+    int_ip = ip_to_int(ip)
+
+    query = """
+    SELECT end_range, latitude, longitude
+    FROM ips
+    WHERE start_range <= ?
+    ORDER BY start_range DESC
+    LIMIT 1
+    """
+    index = """
+    CREATE INDEX IF NOT EXISTS start_index
+    ON ips(start_range);
+    """
+    try:
+        c.execute(index)
+        conn.commit()
+        c.execute(query, (int_ip,))
+        row = c.fetchone()
+        end, lat, lon = row
+        conn.close()
+        return lat, lon
+    except Exception as e:
+        logger.critical(e)
+        raise e

dzgui/config/xdg.py

@@ -22,7 +22,7 @@ class Xdg:
     version: Path
     system: Path
     debug: Path
-    ips: Path
+    db: Path
     filters: Path
     shortcut: Path
 
@@ -88,7 +88,7 @@ def parse_filepaths(xdg: dict) -> Xdg:
     resolution = state / "dzg.res.json"
     history = state / "dzg.history"
     versions = state / "dzg.versions"
-    ips = state / "ips.csv"
+    db = state / "ips.db"
     filters = state / "dzg.filters.json"
 
     shortcut = share / APP_NAME_LOWER
@@ -102,7 +102,7 @@ def parse_filepaths(xdg: dict) -> Xdg:
         versions,
         system,
         debug,
-        ips,
+        db,
         filters,
         shortcut,
     )

dzgui/const/endpoints.py

@@ -18,6 +18,7 @@ COORDS_API = "http://ip-api.com/json"
 # steam URIs
 WORKSHOP = "steam://url/CommunityFilePage/"
 OPEN_URL = "steam://openurl/"
+VALIDATE = "steam://validate/"
 
 # user facing
 GITHUB_PAGES = "https://aclist.github.io/dzgui/index"

dzgui/const/enum.py

@@ -157,6 +157,7 @@ class ContextMenu(EnumWithAttrs):
     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}
@@ -172,7 +173,7 @@ class ContextMenuGroup(Enum):
     """
 
     SERVER_MOD = (ContextMenu.OPEN_WORKSHOP,)
-    MOD = (ContextMenu.OPEN_WORKSHOP, ContextMenu.UNSUB_MOD)
+    MOD = (ContextMenu.OPEN_WORKSHOP, ContextMenu.UNSUB_MOD, ContextMenu.VALIDATE_MOD)
     MOD_OFFLINE = (None,)
     LOG = (ContextMenu.COPY_LOG_CLIPBOARD,)
     SERVER_BROWSER = (
@@ -246,6 +247,10 @@ class ModButton(EnumWithAttrs):
         "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 ButtonType(EnumWithAttrs):

dzgui/controllers/mc.py

@@ -102,6 +102,16 @@ class Controller(GObject.GObject):
         except AttributeError:
             logger.critical(f"{attr} is not a valid AppNavigation attribute.")
 
+    def validate_mods(
+        self, treeview: Union["ModTreeView", "OfflineModTreeView", None] = None
+    ) -> None:
+        if treeview is None:
+            view = self.mediator.modtreeview
+        else:
+            view = treeview
+        mod_man = view.get_mod_man()
+        mod_man.validate_mods()
+
     def get_prefs(self) -> UserPrefs:
         return self.prefs
 

dzgui/init/coords.py

@@ -10,10 +10,10 @@ if TYPE_CHECKING:
 logger = logging.getLogger(APP_NAME)
 
 
-def get_local_coords(path: "Path") -> Coords | None:
+def get_local_coords(db_path: "Path") -> Coords | None:
     try:
         my_ip = get_local_ip()
-        return get_coords(path, my_ip)
+        return get_coords(db_path, my_ip)
     except Exception as e:
         logger.warn(e)
         return None

dzgui/main.py

@@ -42,6 +42,9 @@ def main() -> None:
     test_libgi_missing()
 
     # NOTE: only import ligbirepository modules after the above check
-    from dzgui.app_init import load_gui
+    from dzgui.app_init import build_gui
 
-    load_gui(version, args.debug)
+    app = build_gui(version, args.debug)
+    if app is None:
+        sys.exit(0)
+    app.run(None)

dzgui/managers/connection.py

@@ -48,7 +48,7 @@ from dzgui.strings.dialogs import (
     waiting_for_directories,
 )
 from dzgui.strings import kb
-from dzgui.strings.server_mods import checkmark, resync
+from dzgui.strings.server_mods import checkmark, resync, invalid_mod
 from dzgui.util.format import format_exception, format_mib
 from dzgui.util.strings import dialog, server_timeout
 from dzgui.util.symlink import rebuild_symlinks
@@ -197,9 +197,8 @@ class ConnectionManager:
 
         is_last = self.is_last_server()
 
-        # TODO: strings
         invalid_mods = [
-            (mod[0], mod[1]) for mod in remote_mods if mod[2] == "Invalid mod"
+            (mod[0], mod[1]) for mod in remote_mods if mod[2] == invalid_mod
         ]
 
         prereqs = Prerequisites(
@@ -277,8 +276,7 @@ class ConnectionManager:
         for mod in alpha_mods:
             # NOTE: if the mod is neither synched or out of date, it is a malformed mod
             if mod[2] == "":
-                # TODO: strings
-                mod[2] = "Invalid mod"
+                mod[2] = invalid_mod
 
         return alpha_mods, missing_mods
 

dzgui/managers/contextmenu.py

@@ -75,10 +75,14 @@ class ContextMenuManager:
 
         if isinstance(self.treeview, (ModTreeView, OfflineModTreeView)):
             match action:
-                case ContextMenu.UNSUB_MOD:
-                    self.controller.unsub_mods(self.treeview)
                 case ContextMenu.OPEN_WORKSHOP:
                     self.open_mod_page()
+                case ContextMenu.UNSUB_MOD:
+                    self.controller.unsub_mods(self.treeview)
+                case ContextMenu.VALIDATE_MOD:
+                    self.controller.validate_mods(self.treeview)
+                case _:
+                    pass
 
         if isinstance(self.treeview, LogTreeView):
             match action:

dzgui/managers/filter.py

@@ -2,7 +2,7 @@ from typing import TYPE_CHECKING
 
 from dzgui.model.model_factory import ModelFactory
 from dzgui.util import strings
-from dzgui.util.strings import all_maps
+from dzgui.strings.filters import all_maps
 
 if TYPE_CHECKING:
     from dzgui.model.model_factory import FastInsertListStore
@@ -106,16 +106,10 @@ class FilterManager:
 
         self.reinit_map_store()
         maps.sort()
-        for m in maps:
-            # TODO: strings
-            if m == "All maps":
-                continue
+        clean = [m for m in maps if m != all_maps]
+        for m in clean:
             self.append_map([m])
 
-    # TODO: currently unused
-    def get_unique_maps(self) -> list[str]:
-        return [row[0] for row in self.map_store if row[0] != "All maps"]
-
     def get_all_filters(self) -> tuple:
         map_name = self.get_active_map_name()
         enabled = self.get_filters()

dzgui/managers/mods.py

@@ -4,7 +4,7 @@ import time
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from dzgui.api.steam import unsubscribe
+from dzgui.api.steam import unsubscribe, validate_mod
 from dzgui.api.mods import (
     get_delimited_mods,
     find_stale_mods,
@@ -85,7 +85,7 @@ class ModManager:
         total_mods = len(self.store)
         self.emitter.emit("mods_updated", msg, total_mods)
 
-    def unsub_mods(self) -> None:
+    def get_selected_mods(self) -> list[tuple[str, Gtk.TreeIter]]:
         sel = self.treeview.get_selection()
         model, pathlist = sel.get_selected_rows()
         # NOTE: reverse when multiple selection
@@ -96,6 +96,15 @@ class ModManager:
                 continue
             mod, _iter = res
             mods.append((mod, _iter))
+        return mods
+
+    def validate_mods(self) -> None:
+        mods = self.get_selected_mods()
+        self.thread_man.set_job_count(len(mods))
+        self.validate_all_mods(mods)
+
+    def unsub_mods(self) -> None:
+        mods = self.get_selected_mods()
         self.thread_man.set_job_count(len(mods))
         self.unsub_all_mods(mods)
 
@@ -109,6 +118,21 @@ class ModManager:
         mod = model.get_value(tree_iter, 2)
         return mod, tree_iter
 
+    def validate_atomic_mod(self, mod: str) -> None:
+        # NOTE: propagation to dayz exp will happen during
+        # subsequent symlink phase on connect
+        client = self.controller.query_config(Preferences.CLIENT)
+        validate_mod(client, mod)
+
+    @call_on_thread(dialogs.validating_mods)
+    def validate_all_mods(self, mods: list[tuple[str, Gtk.TreeIter]]) -> None:
+        for mod, _iter in mods:
+            self.validate_atomic_mod(mod)
+            self.thread_man.increment_dialog()
+            time.sleep(API_RATE_LIMIT)
+        func = StoredFunc(lambda: None)
+        self.thread_man.set_cleanup_func(func)
+
     @call_on_thread(dialogs.deleting_mods)
     def unsub_all_mods(self, mods: list[tuple[str, Gtk.TreeIter]]) -> None:
         for mod, _iter in mods:

dzgui/model/proxy_model.py

@@ -5,6 +5,7 @@ from typing import Any, TYPE_CHECKING, Union
 from dzgui.const.enum import FilterMode
 from dzgui.model.model_factory import ModelFactory
 from dzgui.util import strings
+from dzgui.strings import filters as str_filters
 
 if TYPE_CHECKING:
     from dzgui.managers.filter import FilterManager
@@ -175,7 +176,7 @@ class ProxyModelManager:
         rows = self.filtered
         sel_map = self.filter_man.get_active_map_name()
 
-        if sel_map == strings.all_maps:
+        if sel_map == str_filters.all_maps:
             return rows
 
         rows = [row for row in rows if row[1] == sel_map]

dzgui/model/servers.py

@@ -201,19 +201,43 @@ class ServerModelManager:
 
     @call_on_thread(dialog.querying)
     def add_by_ip(self, addr: str) -> None:
-        res = Servers.query_by_ip(addr)
-        self._parse_single_record(res)
+        self.preserve_on_fail = True
+        try:
+            res = Servers.query_by_ip(addr)
+            self._parse_single_record(res)
+        except Exception as e:
+            logger.warning(e)
+            self.thread_man.set_cleanup_func(
+                StoredFunc(self._cleanup_on_failure), destroy_first=True
+            )
+            return
 
     @call_on_thread(dialog.querying)
     def add_by_record(self, record: Servers.Record) -> None:
+        self.preserve_on_fail = True
         # NOTE: rationale: a raw Record as shown in server browser may resolve to a different IP
-        res = Servers.query_by_record(record)
-        self._parse_single_record(res)
+        try:
+            res = Servers.query_by_record(record)
+            self._parse_single_record(res)
+        except Exception as e:
+            logger.warning(e)
+            self.thread_man.set_cleanup_func(
+                StoredFunc(self._cleanup_on_failure), destroy_first=True
+            )
+            return
 
     @call_on_thread(dialog.querying)
     def remove_by_record(self, record: Servers.Record) -> None:
-        res = Servers.query_by_record(record)
-        self._parse_single_record(res, delete=True)
+        self.preserve_on_fail = True
+        try:
+            res = Servers.query_by_record(record)
+            self._parse_single_record(res, delete=True)
+        except Exception as e:
+            logger.warning(e)
+            self.thread_man.set_cleanup_func(
+                StoredFunc(self._cleanup_on_failure), destroy_first=True
+            )
+            return
 
     def update_history(
         self,
@@ -280,7 +304,6 @@ class ServerModelManager:
         proxy_man.update_playercount(self.playercount)
 
     def _parse_single_record(self, response: "A2SInfo", delete: bool = False) -> None:
-        self.preserve_on_fail = True
         try:
             row = response.as_row()
         except Exception as e:

dzgui/strings/buttons.py

@@ -1,2 +1,16 @@
+clipboard_button = "Copy to clipboard"
+clipboard_ip_button = "Copy IP to clipboard"
+
+dock_button_collapse = "Collapse the connection panel"
+dock_button_expand = "Expand the connection panel"
+
 workshop = "Steam Workshop"
 workshop_tooltip = "Open your Workshop subscriptions"
+
+version_notifier = "Copied!"
+version_tooltip = "Click to copy to clipboard"
+
+update_button = "Updates available"
+
+unset_button_label = "Unset"
+unset_button_tooltip = "Unset this server as favorite"

dzgui/strings/dialogs.py

@@ -9,6 +9,7 @@ update_success = "Updated successfully. Please exit and relaunch."
 load_error_lan = "Failed to find any servers on your network.\nCheck the server query port or your firewall settings."
 fetching_mods = "Fetching mod metadata"
 deleting_mods = "Unsubscribing mods"
+validating_mods = "Validating mods"
 scanning_mods = "Scanning mods"
 parsing_mods = "Parsing mods"
 
@@ -28,3 +29,5 @@ toggle_calc = "Toggle calculator"
 
 server_details = "Server details"
 server_message = "Server message"
+
+caught_cancel_signal = "Caught cancel signal, cleaning up"

dzgui/strings/filters.py

@@ -0,0 +1,4 @@
+all_maps = "All maps"
+filters_heading = "Filters"
+keyword_placeholder = "Filter by keyword"
+map_placeholder = "Filter by map"

dzgui/strings/generic.py

@@ -1 +1,2 @@
+tab_changed_label = "*"
 selectable_tree = "Ctrl-click to select multiple; Shift-click to select a range."

dzgui/strings/notes.py

@@ -0,0 +1,5 @@
+dialog_title = "Add a short note/reminder"
+dialog_subtitle = "Limit 30 chars"
+delete_button = "Delete note"
+ok_button = "Update note"
+current_note = "Current note: '{0}'"

dzgui/strings/options.py

@@ -16,7 +16,9 @@ lan_combo = "LAN"
 fullscreen_eventbox = "This option is not available on Steam Deck."
 save_button = "Save"
 
+api_placeholder = "Enter API key"
 api_failed = "API validation failed"
+api_validate = "Validate"
 
 flatpak_label = "Flatpak client"
 flatpak_standard = "Standard"

dzgui/strings/server_mods.py

@@ -3,4 +3,5 @@ mod_id = "ID"
 up_to_date = "Up to date"
 modlist = "Modlist"
 checkmark = "✓"
-resync="⟳"
+resync = "⟳"
+invalid_mod = "Invalid mod"

dzgui/util/dist.py

@@ -80,8 +80,9 @@ class CalcDist:
         if local is None:
             return None
         try:
-            remote = get_coords(prefs.paths.ips, remote_ip)
-        except Exception:
+            remote = get_coords(prefs.paths.db, remote_ip)
+        except Exception as e:
+            logger.critical(e)
             return None
 
         haversine = Haversine(local.lat, local.lon, remote.lat, remote.lon)

dzgui/util/ip.py

@@ -1,4 +1,5 @@
 import a2s
+from ipaddress import ip_address
 import requests
 import shutil
 import subprocess
@@ -7,6 +8,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from dzgui.api.servers import Record
+from dzgui.config.ipdb import read_from_table
 from dzgui.const.constants import REQUEST_TIMEOUT
 from dzgui.const.endpoints import IP_ECHO
 
@@ -33,54 +35,21 @@ def ip2list(ip: str) -> list:
     return [int(digit) for digit in ip.split(".")]
 
 
-# TODO: tests
-def is_reserved(digits: list) -> bool:
-    reserved = [0, 10, 127]
-
-    if digits[0] in reserved:
-        return True
-    if digits[0] == 192 and digits[1] == 168:
-        return True
-    return False
+def is_usable(ip: str) -> bool:
+    address = ip_address(ip)
+    if address.is_reserved or address.is_private:
+        return False
+    return True
 
 
-def get_coords(ips: "Path", ip: str) -> Coords:
-    split = ip2list(ip)
-
-    if is_reserved(split):
+def get_coords(db_path: "Path", ip: str) -> Coords:
+    if not is_usable(ip):
         raise ReservedIPError(f"{ip} is a reserved IP address.")
-
-    prefix = f"^{split[0]}.{split[1]}."
-
-    if shutil.which("rg") is not None:
-        args = ["/usr/bin/rg", prefix, str(ips)]
-    else:
-        args = ["/usr/bin/grep", "-E", prefix, str(ips)]
-    proc = subprocess.run(args, capture_output=True, text=True)
-
-    if proc.returncode != 0:
-        raise GeolocationError("Failed to split records")
-
-    ip_list = proc.stdout.splitlines()
-
-    for address in ip_list:
-        fields = address.split(",")
-        upper = fields[1]
-
-        upper_digits = ip2list(upper)
-        if ip == upper:
-            return Coords(float(fields[-2]), float(fields[-1]))
-
-        if split[2] > upper_digits[2]:
-            continue
-
-        if split[2] == upper_digits[2]:
-            if split[3] > upper_digits[3]:
-                continue
-
-        if split[2] <= upper_digits[2]:
-            return Coords(float(fields[-2]), float(fields[-1]))
-    raise GeolocationError("No matching records found")
+    try:
+        lat, lon = read_from_table(db_path, ip)
+        return Coords(lat, lon)
+    except Exception:
+        raise GeolocationError("No matching records found")
 
 
 def get_local_ip() -> str:

dzgui/util/save_screenshot.py

@@ -0,0 +1,80 @@
+from pathlib import Path
+from typing import cast, TYPE_CHECKING
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, Gdk, GLib  # noqa E402
+
+if TYPE_CHECKING:
+    from dzgui.controllers.mc import Controller
+    from dzgui.views.base import OuterWindow
+    from dzgui.views.mixins.context_mixin import ContextMixin
+    from gi.repository import GdkPixbuf
+
+# TODO: randomize/mock PII distance values
+
+
+class IdleScreenshot:
+    def __init__(
+        self, controller: "Controller", window: "OuterWindow", scrot_path: Path
+    ) -> None:
+        self.window = window
+        self.controller = controller
+        self.scrot_path = scrot_path
+
+        clock = window.get_frame_clock()
+        if clock is None:
+            raise TypeError("Widget not realized, FrameClock not initialized")
+        clock.connect("after-paint", self.callback)
+
+    def callback(self, clock: Gdk.FrameClock) -> None:
+        GLib.timeout_add(1000, self.check_idle)
+
+    def check_idle(self) -> bool:
+        tv = self.controller.get_active_treeview()
+        loaded = tv.is_loaded()
+        if loaded is True:
+            self.emit_key_press(tv)
+            GLib.timeout_add(1000, self.save_and_quit)
+            return True
+        return False
+
+    def emit_key_press(self, widget: "ContextMixin") -> None:
+        window = widget.get_parent_window()
+        if window is None:
+            raise TypeError(f"Failed to find a valid parent window for {widget}")
+        event = Gdk.EventKey.new(Gdk.EventType.KEY_PRESS)
+        # NOTE: GTK introspection returns Gdk.Event type
+        event_key = cast(Gdk.EventKey, event)
+        event_key.keyval = Gdk.KEY_l
+        event_key.state = Gdk.ModifierType.CONTROL_MASK
+        event_key.window = window
+        event_key.time = Gdk.CURRENT_TIME
+        event_key.send_event = True
+        # TODO: suppress errors from synthetic key events
+        widget.present_menu(widget, event)
+
+    def save_and_quit(self) -> None:
+        self.save_pixbuf()
+        self.controller.save_res_and_quit()
+
+    def save_pixbuf(self) -> None:
+        pixbuf = self.capture_application()
+        if pixbuf:
+            pixbuf.savev(str(self.scrot_path), "png", [], [])
+
+    def capture_application(self) -> "GdkPixbuf.Pixbuf":
+        # NOTE: composited context menu over X11 window
+        root = Gdk.get_default_root_window()
+
+        xwindow = self.window.get_window()
+        if xwindow is None:
+            raise ValueError("Failed to get a valid X11 window")
+        index, x, y = xwindow.get_origin()
+        width, height = self.window.get_size()
+
+        application = Gdk.pixbuf_get_from_window(root, x, y, width, height)
+        if application is None:
+            raise ValueError("Failed to get a valid GdkPixbuf")
+        return application

dzgui/util/strings.py

@@ -31,6 +31,7 @@ show_details = "Show server details"
 refresh_players = "Refresh player count"
 open_workshop = "Open in Steam Workshop"
 unsub_mod = "Unsubscribe mod"
+validate_mod = "Validate mod"
 copy_name = "Copy name to clipboard"
 copy_ip = "Copy IP to clipboard"
 copy_log = "Copy record(s) to clipboard"
@@ -158,9 +159,6 @@ filter_unofficial = "Unofficial"
 filter_modded = "Modded"
 filter_unmodded = "Unmodded"
 
-# maps
-all_maps = "All maps"
-
 # state
 unknown = "Unknown"
 none_provided = "None provided"
@@ -200,6 +198,8 @@ class ModPanelStrings:
     clear_highlights: str
     select_stale: str
     select_stale_tooltip: str
+    validate: str
+    validate_tooltip: str
 
 
 @dataclass(slots=True, frozen=True)
@@ -319,6 +319,8 @@ mod_panel = ModPanelStrings(
     clear_highlights="Clears highlights and reverts the table to a default state",
     select_stale="Select stale",
     select_stale_tooltip="Only selects highlighted stale mods",
+    validate="Validate selected",
+    validate_tooltip="Validates selected mods and updates them if necessary",
 )
 
 

dzgui/views/base.py

@@ -1,7 +1,7 @@
 import logging
 import signal
 
-from typing import TYPE_CHECKING, Literal, Self
+from typing import Any, Literal, Self, TYPE_CHECKING
 
 from dzgui.const.constants import (
     APP_NAME,
@@ -47,7 +47,7 @@ logger = logging.getLogger(APP_NAME)
 
 
 class OuterWindow(Gtk.ApplicationWindow):
-    def __init__(self, app: Gtk.Application) -> None:
+    def __init__(self, app: "App") -> None:
         super().__init__(
             application=app, title=APP_NAME, border_width=10, icon_name=APP_NAME_LOWER
         )
@@ -78,6 +78,15 @@ class OuterWindow(Gtk.ApplicationWindow):
         MainController.loaded = True
         MainController.populate_model(MainController.get_active_treeview())
 
+        try:
+            from dzgui.util.save_screenshot import IdleScreenshot
+
+            scrot = app.get_automation_param("screenshot_path")
+            self.fullscreen()
+            IdleScreenshot(MainController, self, scrot)
+        except KeyError:
+            pass
+
     def _on_delete_event(self, window: "OuterWindow", event: Gdk.EventKey) -> None:
         self.halt_proc_and_quit()
 
@@ -291,6 +300,14 @@ class App(ColorAwareApp, Gtk.Application):  # type: ignore
         self._setup_signals()
         self.connect("activate", self._on_activate)
 
+        self.automation_params: dict[str, Any] = {}
+
+    def get_automation_param(self, key: str) -> Any:
+        return self.automation_params[key]
+
+    def set_automation_param(self, key: str, value: Any) -> None:
+        self.automation_params[key] = value
+
     def _on_activate(self, app: Self) -> None:
         self.win = OuterWindow(app)
 
@@ -331,4 +348,5 @@ class App(ColorAwareApp, Gtk.Application):  # type: ignore
     ) -> None:
         self.win.halt_proc_and_quit()
 
+
 MainController = Controller()

dzgui/views/components/buttons.py

@@ -106,8 +106,7 @@ class ClipboardButton(IconTextButton):
         self.controller = controller
         self.connect("clicked", self._on_button_clicked, func)
 
-        # TODO: strings
-        self.set_tooltip_text("Copy to clipboard")
+        self.set_tooltip_text(buttons.clipboard_button)
 
     def _on_button_clicked(self, button: Self, func: Callable) -> None:
         def revert() -> Literal[False]:
@@ -125,16 +124,14 @@ class CopyIpButton(ClipboardButton):
     def __init__(self, controller: Union["Controller", None], func: Callable) -> None:
         super().__init__(controller, func)
 
-        # TODO: strings
-        self.set_tooltip_text("Copy IP to clipboard")
+        self.set_tooltip_text(buttons.clipboard_ip_button)
 
 
 class CloseButton(IconTextButton):
     def __init__(self, label: str) -> None:
         super().__init__(icon=CLOSE, label=label)
 
-        # TODO: strings
-        self.set_tooltip_text("Unset this server as favorite")
+        self.set_tooltip_text(buttons.unset_button_tooltip)
 
 
 class WebButton(IconTextButton):
@@ -252,6 +249,7 @@ 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 = ""

dzgui/views/components/connect_panel.py

@@ -3,6 +3,11 @@ from typing import Self, TYPE_CHECKING
 from dzgui.const.constants import CARET_DOWN, CARET_UP, UDP_PORT
 from dzgui.model.servers import ServerModelManager
 from dzgui.strings import connect_panel
+from dzgui.strings.buttons import (
+    dock_button_collapse,
+    dock_button_expand,
+    unset_button_label,
+)
 from dzgui.util.keys import is_ctrl_mask
 from dzgui.views.components.buttons import (
     AddButton,
@@ -36,21 +41,18 @@ class DockButton(IconButton):
         self.child = child
         self.connect("clicked", self._on_click)
 
-        self.collapse_text = "Collapse the connection panel"
-        self.expand_text = "Expand the connection panel"
-
         self.set_margin_top(10)
-        self.set_tooltip_text(self.collapse_text)
+        self.set_tooltip_text(dock_button_collapse)
 
     def collapse(self) -> None:
         self.set_image(Icon(CARET_UP))
         self.child.hide()
-        self.set_tooltip_text(self.expand_text)
+        self.set_tooltip_text(dock_button_expand)
 
     def expand(self) -> None:
         self.set_image(Icon(CARET_DOWN))
         self.child.show()
-        self.set_tooltip_text(self.collapse_text)
+        self.set_tooltip_text(dock_button_collapse)
 
     def _on_click(self, button: Self) -> None:
         if self.expanded:
@@ -81,7 +83,6 @@ class LanPanel(Gtk.Frame):
         self.scan = Gtk.Button(label=connect_panel.lan_scan_button)
         self.scan.connect("clicked", self._on_scan_clicked)
 
-        # TODO: strings
         self.early_abort = Gtk.CheckButton(label=connect_panel.lan_checkbox)
         self.early_abort.set_active(True)
         self.early_abort.set_tooltip_text(connect_panel.lan_abort_tooltip)
@@ -189,8 +190,7 @@ class FavPanel(Gtk.Frame):
         self.fav_button.connect("clicked", self._on_connect_clicked)
         self.copy_button = CopyIpButton(self.controller, self.get_fav_ip)
 
-        # TODO: strings
-        self.unset_button = CloseButton("Unset")
+        self.unset_button = CloseButton(unset_button_label)
         self.unset_button.connect("clicked", self._on_unset_clicked)
 
         if favorite is None:

dzgui/views/components/entry.py

@@ -4,6 +4,7 @@ from dzgui.api.servers import validate_ip
 from dzgui.const.constants import VIEW_CONCEAL, VIEW_REVEAL
 from dzgui.util.css import add_class, remove_class
 from dzgui.strings import connect_panel
+from dzgui.strings.options import api_placeholder, api_validate
 from dzgui.strings.errors import api_popover
 
 import gi
@@ -143,9 +144,8 @@ class APIEntry(Gtk.Box):
 
         self.func: Callable | None = None
 
-        # TODO: strings
         self.entry = Gtk.Entry(
-            width_chars=60, hexpand=True, placeholder_text="Enter API key"
+            width_chars=60, hexpand=True, placeholder_text=api_placeholder
         )
         self.entry.set_icon_from_icon_name(Gtk.EntryIconPosition.SECONDARY, VIEW_REVEAL)
         self.entry.set_icon_activatable(Gtk.EntryIconPosition.SECONDARY, True)
@@ -154,8 +154,7 @@ class APIEntry(Gtk.Box):
         self.entry.connect("icon-release", self._on_icon_release)
         self.entry.connect("activate", self._on_field_activated)
 
-        # TODO: strings
-        self.submit = Gtk.Button(label="Validate")
+        self.submit = Gtk.Button(label=api_validate)
         self.submit.set_sensitive(False)
         self.submit.connect("clicked", self._on_submit)
 

dzgui/views/components/filter_panel.py

@@ -10,7 +10,12 @@ from dzgui.const.constants import (
     SEARCH_ICON,
 )
 from dzgui.util.format import format_exception
-from dzgui.util.strings import all_maps
+from dzgui.strings.filters import (
+    all_maps,
+    filters_heading,
+    keyword_placeholder,
+    map_placeholder,
+)
 from dzgui.views.components.maps_combo import MapsCombo
 from dzgui.views.components.labels import BoldLabel
 
@@ -42,7 +47,10 @@ class ButtonGrid(Gtk.Grid):
         self.checks: list[Gtk.CheckButton] = []
 
         flowbox = Gtk.FlowBox(
-            halign=Gtk.Align.CENTER, min_children_per_line=3, max_children_per_line=3, selection_mode=Gtk.SelectionMode.NONE
+            halign=Gtk.Align.CENTER,
+            min_children_per_line=3,
+            max_children_per_line=3,
+            selection_mode=Gtk.SelectionMode.NONE,
         )
 
         for check in defaults.keys():
@@ -99,8 +107,7 @@ class ButtonGrid(Gtk.Grid):
 
 class KeywordEntry(Gtk.Entry):
     def __init__(self, controller: "Controller") -> None:
-        # TODO :strings
-        super().__init__(placeholder_text="Filter by keyword")
+        super().__init__(placeholder_text=keyword_placeholder)
 
         self.keyword = ""
         self.controller = controller
@@ -174,8 +181,7 @@ class FilterPanel(Gtk.Box):
         self.keyword_entry = KeywordEntry(self.controller)
         self.button_grid = ButtonGrid(self.controller, defaults, tooltips)
 
-        # TODO: strings
-        self.filters_label = BoldLabel("Filters")
+        self.filters_label = BoldLabel(filters_heading)
 
         self.emitter.connect(
             "request_keyword_focus", lambda _: self.keyword_entry.grab_focus()
@@ -195,8 +201,7 @@ class FilterPanel(Gtk.Box):
 
         self.maps_entry: Gtk.Entry = self.maps_combo.get_child()  # type: ignore
         self.maps_entry.set_completion(completion)
-        # TODO: strings
-        self.maps_entry.set_placeholder_text("Filter by map")
+        self.maps_entry.set_placeholder_text(map_placeholder)
         self.maps_entry.connect("changed", self._on_map_completion, True)
         self.maps_entry.connect("key-press-event", self._on_map_entry_keypress)
         self.maps_entry.connect("activate", self._on_maps_activated)
@@ -313,6 +318,8 @@ class FilterPanel(Gtk.Box):
         return True
 
     def toggle_check(self, digit: int) -> None:
+        if not self.button_grid.is_sensitive():
+            return
         checks = self.button_grid.get_checkboxes()
         check = checks[digit]
         state = check.get_active()

dzgui/views/components/mod_panel.py

@@ -50,6 +50,7 @@ class ModSelectionPanel(Gtk.Box):
             ModButton.SELECT_ALL,
             ModButton.UNSELECT_ALL,
             ModButton.UNSUB_SELECTED,
+            ModButton.VALIDATE,
         )
         for button in buttons:
             b = EnumeratedModButton(button)
@@ -114,3 +115,5 @@ class ModSelectionPanel(Gtk.Box):
                 self.swap_sensitive(False)
             case ModButton.SELECT_STALE:
                 self.controller.select_colorized()
+            case ModButton.VALIDATE:
+                self.controller.validate_mods()

dzgui/views/components/right_panel.py

@@ -13,6 +13,7 @@ from dzgui.const.constants import (
 )
 from dzgui.const.enum import ServerTab
 from dzgui.managers.update import UpdateManager
+from dzgui.strings.buttons import update_button, version_notifier, version_tooltip
 from dzgui.util.clip import copy_clipboard
 from dzgui.util.file import is_writeable
 from dzgui.views.components.buttonbox import ButtonBox
@@ -65,8 +66,7 @@ class RightPanel(Gtk.Box):
             vexpand=True,
             halign=Gtk.Align.END,
             valign=Gtk.Align.END,
-            # TODO: strings
-            tooltip_text="Click to copy to clipboard",
+            tooltip_text=version_tooltip,
         )
         eb = Gtk.EventBox(halign=Gtk.Align.END, valign=Gtk.Align.END)
         eb.add(self.version_label)
@@ -78,7 +78,7 @@ class RightPanel(Gtk.Box):
         self.pack_start(self.sel_panel, NO_EXPAND, NO_FILL, NO_PADDING)
 
         self.update_button = IconTextButton(
-            "dialog-information-symbolic", label="Updates available"
+            "dialog-information-symbolic", label=update_button
         )
 
         self.gutter_box = Gtk.Box(
@@ -131,7 +131,6 @@ class RightPanel(Gtk.Box):
             return
         self.copying = True
         version = self.version_label.get_text()
-        # TODO: strings
-        self.version_label.set_text("Copied!")
+        self.version_label.set_text(version_notifier)
         copy_clipboard(version)
         GLib.timeout_add_seconds(1, revert)

dzgui/views/dialogs/boot.py

@@ -132,9 +132,9 @@ class BootDialog(ColorAwareApp, Gtk.Dialog):  # type: ignore
                 preboot.signatures,
                 False,
             ),
-            (StoredFunc(get_ipdb, self.xdg.ips), preboot.geo, False),
+            (StoredFunc(get_ipdb, self.xdg.db), preboot.geo, False),
             # TODO: handle IP DB failure and use coords fallback
-            (StoredFunc(get_local_coords, self.xdg.ips), preboot.coords, True),
+            (StoredFunc(get_local_coords, self.xdg.db), preboot.coords, True),
             (StoredFunc(check_updates, self.version), preboot.updates, True),
         ]
         self.results: list[Any] = []

dzgui/views/dialogs/generic.py

@@ -140,8 +140,7 @@ class WaitDialog(GenericDialog):
         self.cur_job += 1
 
     def _on_cancel_clicked(self, button: Gtk.Button) -> None:
-        # TODO: strings
-        GLib.idle_add(self.update_text, "Caught cancel signal, cleaning up")
+        GLib.idle_add(self.update_text, dialogs.caught_cancel_signal)
         self.controller.set_cancel_event()
 
     def show_cancel(self, state: bool) -> None:

dzgui/views/dialogs/note.py

@@ -1,12 +1,13 @@
 from typing import Self, TYPE_CHECKING
 
+from dzgui.strings import notes
 from dzgui.views.components.entry import ValidatedEntry
 from dzgui.views.dialogs.generic import GenericDialog
 
-import gi  # noqa E402
+import gi
 
 gi.require_version("Gtk", "3.0")
-from gi.repository import Gdk, Gtk  # noqa E402
+from gi.repository import Gtk
 
 if TYPE_CHECKING:
     from dzgui.controllers.mc import Controller
@@ -14,23 +15,20 @@ if TYPE_CHECKING:
 
 class NoteDialog(GenericDialog):
     def __init__(self, controller: "Controller"):
-        # TODO: add to strings
-        title = "Add a short note/reminder."
-        secondary = "Limit 30 chars"
         super().__init__(
             controller=controller,
-            text=title,
+            text=notes.dialog_title,
             buttons=Gtk.ButtonsType.NONE,
             mtype=Gtk.MessageType.INFO,
-            secondary=secondary,
+            secondary=notes.dialog_subtitle,
         )
 
         self.controller = controller
 
-        delete_button = Gtk.Button(label="Delete note")
+        delete_button = Gtk.Button(label=notes.delete_button)
         delete_button.set_sensitive(False)
         self.add_action_widget(delete_button, Gtk.ResponseType.CANCEL)
-        self.ok = self.add_button("Update note", Gtk.ResponseType.OK)
+        self.ok = self.add_button(notes.ok_button, Gtk.ResponseType.OK)
         self.ok.grab_default()
 
         self.entry = ValidatedEntry(controller, self.validate)
@@ -42,7 +40,7 @@ class NoteDialog(GenericDialog):
         self.entry.set_text(note)
         if len(note) > 0:
             delete_button.set_sensitive(True)
-            self.format_secondary_text(f"Current note: '{note}'")
+            self.format_secondary_text(notes.current_note.format(note))
         elif len(note) == 0:
             self.ok.set_sensitive(False)
 
@@ -55,9 +53,6 @@ class NoteDialog(GenericDialog):
         self.entry.connect("changed", self._on_text_changed)
 
     def _on_text_changed(self, entry: Gtk.Entry) -> None:
-        """
-        Called in conjunction with signal callback in the parent class
-        """
         if len(entry.get_text()) == 0:
             self.ok.set_sensitive(False)
 
@@ -71,14 +66,11 @@ class NoteDialog(GenericDialog):
 
     def _on_response(self, dialog: Self, response: Gtk.ResponseType) -> None:
         match response:
-            case Gtk.ResponseType.DELETE_EVENT:
-                self.destroy()
             case Gtk.ResponseType.OK:
                 note = self.entry.get_text()
                 self.controller.add_note(note)
-                self.destroy()
             case Gtk.ResponseType.CANCEL:
                 self.controller.delete_note()
-                self.destroy()
-            case Gtk.ResponseType.CANCEL | Gtk.ResponseType.CLOSE:
-                self.destroy()
+            case _:
+                pass
+        self.destroy()

dzgui/views/dialogs/wizard.py

@@ -14,7 +14,7 @@ from dzgui.const.constants import (
     HERO_PATH,
     FLATPAK_ROOT_PATH,
     LEGACY_CONFIG_PATH,
-    TMP_PATH
+    TMP_PATH,
 )
 from dzgui.const.boilerplate import config_boilerplate
 from dzgui.const.endpoints import STEAM_API_SETUP

dzgui/views/mixins/context_mixin.py

@@ -16,9 +16,7 @@ logger = logging.getLogger(APP_NAME)
 
 class ContextMixin(TreeView):
     def present_menu(
-        self,
-        widget: Gtk.Widget,
-        event: Gdk.EventButton | Gdk.EventKey,
+        self, widget: Gtk.Widget, event: Gdk.Event
     ) -> bool:
 
         if self.menu is None:

dzgui/views/pages/options.py

@@ -2,6 +2,7 @@ from pathlib import Path
 from typing import Callable, TYPE_CHECKING
 
 from dzgui.api import pefile as PeFile
+from dzgui.api.steam import get_last_updated
 
 from dzgui.config import query
 from dzgui.const.constants import (
@@ -340,8 +341,10 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
                 [LeftLabel(options.flatpak_label), self.flatpak_toggle],
             )
 
-        self.dayz_version_label = Gtk.Label(label=strings.null)
-        self.dayz_exp_version_label = Gtk.Label(label=strings.null)
+        self.dayz_version_label = Gtk.Label(label=strings.null, halign=Gtk.Align.START)
+        self.dayz_exp_version_label = Gtk.Label(
+            label=strings.null, halign=Gtk.Align.START
+        )
 
         version_rows = [
             [LeftLabel(APPNAME_DAYZ), self.dayz_version_label],
@@ -467,10 +470,18 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
         dayz_version = PeFile.get_pretty_version(steam_path, APPID_DAYZ)
         if dayz_version is None:
             dayz_version = strings.null
+        else:
+            last_updated = get_last_updated(steam_path, APPID_DAYZ)
+            if last_updated is not None:
+                dayz_version += f" (updated at {last_updated})"
 
         dayz_exp_version = PeFile.get_pretty_version(steam_path, APPID_DAYZ_EXP)
         if dayz_exp_version is None:
             dayz_exp_version = strings.null
+        else:
+            last_updated = get_last_updated(steam_path, APPID_DAYZ_EXP)
+            if last_updated is not None:
+                dayz_exp_version += f" (updated at {last_updated})"
 
         self.dayz_version_label.set_text(dayz_version)
         self.dayz_exp_version_label.set_text(dayz_exp_version)

dzgui/views/pages/servers.py

@@ -5,6 +5,7 @@ from typing import Self, TYPE_CHECKING
 from dzgui.const.constants import APP_NAME
 from dzgui.const.enum import ContextMenuGroup, ServerTab
 from dzgui.views.trees.tree_servers import ServerTreeView
+from dzgui.strings.generic import tab_changed_label
 from dzgui.util.strings import server_labels
 
 import gi
@@ -147,8 +148,7 @@ class ServerNotebook(Gtk.ScrolledWindow):
 
         label = self.notebook.get_tab_label_text(child)
         if label is not None:
-            # TODO: strings
-            text = label.strip("*")
+            text = label.strip(tab_changed_label)
             self.notebook.set_tab_label_text(child, text)
 
         tree = child.get_tree()

dzgui/views/trees/tree_base.py

@@ -108,14 +108,9 @@ class TreeView(CursorMixin, Gtk.TreeView):  # type: ignore
 
     def _on_key_release(self, treeview: Gtk.TreeView, event: Gdk.EventKey) -> None:
         """
-        Suppresses spamming on keydown
-        TODO: explain this better
+        Adds debounce to key press/release events to prevent spamming
+        when rapidly navigating through records
         """
-        # TODO: multisel
-        # if event.keyval is Gdk.KEY_space:
-        #    it = self.get_focused_row_iter()
-        #    self.get_selection().select_iter(it)
-        #    return True
 
         model = self.get_model()
         if model is None:

pyproject.toml

@@ -4,7 +4,7 @@ description = "DayZ server browser and mod manager for Linux"
 authors = [
     {name = "aclist"}
 ]
-version = "7.0.0b29"
+version = "7.0.0b30"
 license = "GPL-3.0-or-later"
 license-files = ["LICENSE"]
 readme = "README.md"

scripts/parse_toml.py

@@ -3,6 +3,7 @@ from pathlib import Path
 
 root = Path(__file__).resolve().parents[1]
 
+
 def get_entrypoint() -> None:
     p = root.joinpath("pyproject.toml")
     with open(p, "rb") as f:

scripts/scrot.py

@@ -0,0 +1,23 @@
+import subprocess
+from pathlib import Path
+
+from dzgui.app_init import build_gui
+
+
+def get_git_root() -> Path:
+    proc = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"], capture_output=True, text=True
+    )
+    if proc.returncode != 0:
+        raise OSError("Failed to parse git root")
+    return Path(proc.stdout.rstrip())
+
+
+def get_image_path() -> Path:
+    return get_git_root().joinpath("dzgui/data/images/example.png")
+
+
+p = get_image_path()
+app = build_gui("", False)
+app.set_automation_param("screenshot_path", p)
+app.run(None)

tests/fixtures/api/steamapps/appmanifest_444.acf

@@ -0,0 +1,53 @@
+"AppState"
+{
+	"appid"		"444"
+	"Universe"		"1"
+	"name"		"TEST APP"
+	"StateFlags"		"4"
+	"installdir"		"TESTAPP"
+	"LastUpdated"		"1792595373"
+	"LastPlayed"		"0"
+	"SizeOnDisk"		"0"
+	"StagingSize"		"0"
+	"buildid"		"0"
+	"LastOwner"		"0"
+	"DownloadType"		"2"
+	"UpdateResult"		"0"
+	"BytesToDownload"		"0"
+	"BytesDownloaded"		"0"
+	"BytesToStage"		"0"
+	"BytesStaged"		"0"
+	"TargetBuildID"		"0"
+	"AutoUpdateBehavior"		"0"
+	"AllowOtherDownloadsWhileRunning"		"0"
+	"ScheduledAutoUpdate"		"0"
+	"FullValidateAfterNextUpdate"		"1"
+	"InstalledDepots"
+	{
+		"3330"
+		{
+			"manifest"		"0"
+			"size"		"0"
+		}
+	}
+	"SharedDepots"
+	{
+		"228983"		"228980"
+		"228985"		"228980"
+		"228988"		"228980"
+		"228990"		"228980"
+		"229004"		"228980"
+	}
+	"UserConfig"
+	{
+		"language"		"english"
+		"platform_override_dest"		"linux"
+		"platform_override_source"		"windows"
+	}
+	"MountedConfig"
+	{
+		"language"		"english"
+		"platform_override_dest"		"linux"
+		"platform_override_source"		"windows"
+	}
+}

tests/fixtures/api/steamapps/appmanifest_555.acf

@@ -0,0 +1,53 @@
+"AppState"
+{
+	"appid"		"555"
+	"Universe"		"1"
+	"name"		"TEST APP"
+	"StateFlags"		"4"
+	"installdir"		"TESTAPP"
+	"LastUpdated"		"0"
+	"LastPlayed"		"0"
+	"SizeOnDisk"		"0"
+	"StagingSize"		"0"
+	"buildid"		"0"
+	"LastOwner"		"0"
+	"DownloadType"		"2"
+	"UpdateResult"		"0"
+	"BytesToDownload"		"0"
+	"BytesDownloaded"		"0"
+	"BytesToStage"		"0"
+	"BytesStaged"		"0"
+	"TargetBuildID"		"0"
+	"AutoUpdateBehavior"		"0"
+	"AllowOtherDownloadsWhileRunning"		"0"
+	"ScheduledAutoUpdate"		"0"
+	"FullValidateAfterNextUpdate"		"1"
+	"InstalledDepots"
+	{
+		"3330"
+		{
+			"manifest"		"0"
+			"size"		"0"
+		}
+	}
+	"SharedDepots"
+	{
+		"228983"		"228980"
+		"228985"		"228980"
+		"228988"		"228980"
+		"228990"		"228980"
+		"229004"		"228980"
+	}
+	"UserConfig"
+	{
+		"language"		"english"
+		"platform_override_dest"		"linux"
+		"platform_override_source"		"windows"
+	}
+	"MountedConfig"
+	{
+		"language"		"english"
+		"platform_override_dest"		"linux"
+		"platform_override_source"		"windows"
+	}
+}

tests/test_app_download_settings.py

@@ -3,7 +3,7 @@ import pytest
 from _pytest.monkeypatch import MonkeyPatch
 from pathlib import Path
 
-from dzgui.api.steam import get_app_allows_downloads
+from dzgui.api.steam import get_app_allows_downloads, get_last_updated
 from tests.fixtures import fixture_path
 
 pytestmark = pytest.mark.apitest
@@ -43,6 +43,14 @@ def patch_api() -> None:
     mp.undo()
 
 
+def test_no_last_update(steam_path) -> None:
+    assert get_last_updated(steam_path, 555) is None
+
+
+def test_last_update(steam_path) -> None:
+    assert get_last_updated(steam_path, 444) == "2026-10-22 00:09:33"
+
+
 def test_app_allows_downloads(steam_path) -> None:
     assert get_app_allows_downloads(steam_path, 111) is True
 

tests/test_config.py

@@ -36,7 +36,6 @@ def keys():
 
 # TODO: use a static fixture instead of system config
 @pytest.fixture
-@pytest.mark.realconfig
 def config():
     paths = get_xdg_paths()
     xdg = parse_filepaths(paths)

tests/test_flatpak_override.py

@@ -1,7 +1,7 @@
 import configparser
 import pytest
 
-from dzgui.const.constants import FLATPAK_APPID, GTK_APP_ID
+from dzgui.const.constants import FLATPAK_APPID, GTK_APP_ID, TMP_PATH
 from dzgui.config.xdg import get_xdg_paths
 from dzgui.util.flatpak import apply_overrides
 
@@ -38,6 +38,8 @@ def test_session_bus(override, config) -> None:
 
 
 def test_paths(override, xdg_paths, config) -> None:
-    expect = xdg_paths
+    expect: list[str] = []
+    expect.append(TMP_PATH)
+    expect.extend([*xdg_paths.values()])
     paths = config[PATHS_KEY][PATHS_SUBKEY].split(";")
-    assert all(str(path) in paths for path in expect.values())
+    assert all(str(path) in paths for path in expect)

tests/test_geo_file.py

@@ -1,16 +1,40 @@
-from dzgui.config.ipdb import get_ipdb
-from pathlib import Path
 import os
+import sqlite3
 import pytest
 import tempfile
 
+from pathlib import Path
+
+from dzgui.const.endpoints import DB_IP
+from dzgui.config.ipdb import (
+    create_table,
+    find_download_url,
+    serialize,
+    strip_ipv6,
+    unzip,
+)
+
+
+def get_db_len(path: Path) -> int:
+    conn = sqlite3.connect(path)
+    c = conn.cursor()
+    c.execute("SELECT COUNT(*) from ips")
+    db_len = c.fetchone()[0]
+    return db_len
+
+
+@pytest.fixture
+def csv() -> Path:
+    csv = Path(tempfile.NamedTemporaryFile().name)
+    url = find_download_url(DB_IP)
+    tmp = serialize(url)
+    unzip(tmp, csv)
+    strip_ipv6(csv)
+    return csv
 
 @pytest.mark.slow
-def test_stripping():
-    d = tempfile.TemporaryDirectory()
-    path = Path(d.name).joinpath("ips.csv")
-    get_ipdb(path)
-    with open(path, "rb") as f:
+def test_stripping(csv):
+    with open(csv, "rb") as f:
         first = f.readline().decode().rstrip()
         try:
             f.seek(-2, os.SEEK_END)
@@ -25,3 +49,16 @@ def test_stripping():
 
         assert first_els[0] == "0.0.0.0"
         assert last_els[0] == "224.0.0.0"
+
+
+@pytest.mark.slow
+def test_row_parity(csv) -> None:
+    rows = csv.read_text().splitlines()
+
+    db = Path(tempfile.NamedTemporaryFile().name)
+    create_table(db, csv)
+
+    csv_len = len(rows)
+    db_len = get_db_len(db)
+
+    assert csv_len == db_len

tests/test_list_store.py

@@ -0,0 +1,47 @@
+import pytest
+
+from dzgui.model.model_factory import FastInsertListStore
+
+
+@pytest.fixture
+def heterogeneous_list() -> None:
+    return [["a", 0, True], ["b", 1, False]]
+
+
+@pytest.fixture
+def mismatched_length_list() -> None:
+    return [["a", 0, True], ["b", 1, False, 0]]
+
+
+@pytest.fixture
+def extended_list(heterogeneous_list) -> None:
+    fs = FastInsertListStore(str, int, bool)
+    fs.extend(heterogeneous_list)
+    return fs
+
+
+@pytest.fixture
+def appended_list(heterogeneous_list) -> None:
+    fs = FastInsertListStore(str, int, bool)
+    for row in heterogeneous_list:
+        fs.append(row)
+    return fs
+
+
+@pytest.mark.parametrize("target", ["extended_list", "appended_list"])
+def test_list_parity(heterogeneous_list, request, target) -> None:
+    target = request.getfixturevalue(target)
+    extracted = [[el for el in row] for row in target]
+    assert heterogeneous_list == extracted
+
+
+def test_type_disparity(heterogeneous_list) -> None:
+    with pytest.raises(TypeError):
+        fs = FastInsertListStore(str, bool, bool)
+        fs.extend(heterogeneous_list)
+
+
+def test_length_disparity(mismatched_length_list) -> None:
+    with pytest.raises(ValueError):
+        fs = FastInsertListStore(str, int, bool)
+        fs.extend(mismatched_length_list)