Merge 74bf4b5cfc into d3f64c1ba5

CHANGELOG.md

@@ -34,7 +34,6 @@
 - Early load alerts button
 - Preconnect dialog
 - Preconnect warnings/failsafes like filesize
-- Save filters per server context between sessions
 
 
 ## Changed

DEVELOPERS.md

@@ -1,14 +1,14 @@
 # TODO: link to here from sphinx docs
 
-# Installing dev dependencies
-uv pip install -e .[dev]
-
 # Setting up precommit hooks
 pre-commit install
 
 # Fetching submodules
 git submodule update --recursive --init
 
+# Installing dev dependencies
+uv pip install -e .[dev]
+
 # Building documentation
 sphinx-build -M html source build -a
 

dzgui/api/servers.py

@@ -472,7 +472,6 @@ def query_by_ip(addr: str) -> A2SInfo:
         return A2SInfo(Record("0", 0, 0), None)
     return query_by_record(record, update_gameport=True)
 
-
 def query_by_id(server_id: int, key: str) -> A2SInfo:
     """
     Used with numeric Battlemetrics IDs

dzgui/config/xdg.py

@@ -17,7 +17,6 @@ class Xdg:
     system: Path
     debug: Path
     ips: Path
-    filters: Path
 
 
 def is_writeable(path_str: str) -> bool:
@@ -64,6 +63,9 @@ def get_xdg_paths() -> dict:
 
 
 def parse_filepaths(xdg: dict) -> Xdg:
+    # cache = xdg["XDG_CACHE_HOME"]
+    # data = xdg["XDG_DATA_HOME"]
+
     config = xdg["XDG_CONFIG_HOME"]
     state = xdg["XDG_STATE_HOME"]
 
@@ -78,7 +80,6 @@ def parse_filepaths(xdg: dict) -> Xdg:
     history = state / "dzg.history"
     versions = state / "dzg.versions"
     ips = state / "ips.csv"
-    filters = state / "dzg.filters.json"
 
     return Xdg(
         config,
@@ -90,5 +91,4 @@ def parse_filepaths(xdg: dict) -> Xdg:
         system,
         debug,
         ips,
-        filters
     )

dzgui/controllers/emitter.py

@@ -12,7 +12,6 @@ if TYPE_CHECKING:
 
 # TODO: if servers fail to load, may leave dangling widgets waiting for a signal
 
-
 class Emitter(GObject.GObject):
     def __init__(self) -> None:
         super().__init__()
@@ -151,6 +150,3 @@ class Emitter(GObject.GObject):
     def keyword_set(self, keyword: str) -> None:
         pass
 
-    @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, arg_types=())
-    def lan_page_initialized(self) -> None:
-        pass

dzgui/controllers/mc.py

@@ -84,6 +84,7 @@ class Controller(GObject.GObject):
         self.emitter = Emitter()
         self.emitter.connect("map_selection_changed", self._on_map_selection_changed)
         self.emitter.connect("check_toggled", self._on_check_toggled)
+        self.emitter.connect("servers_loaded_init", self._on_servers_loaded_init)
 
         # NOTE: suppress requests until entire UI is loaded
         self.loaded = False
@@ -259,21 +260,6 @@ class Controller(GObject.GObject):
     def select_colorized(self) -> None:
         self.mod_man.select_colorized()
 
-    def get_all_tree_filters(self) -> dict[str, dict[str, bool]]:
-        servers = self.get_servers()
-        all_filters: dict[str, dict[str, bool]] = {}
-        trees = (
-            servers.get_browser(),
-            servers.get_saved(),
-            servers.get_recent(),
-            servers.get_lan(),
-        )
-        for tree in trees:
-            enum = str(tree.get_enum())
-            filters = tree.get_filter_man().get_filters()
-            all_filters[enum] = filters
-        return all_filters
-
     def get_filter_man(self) -> "FilterManager":
         """Each ServerTreeView has an atomic FilterManager"""
         return self.get_active_treeview().get_filter_man()
@@ -317,22 +303,8 @@ class Controller(GObject.GObject):
             self.emitter.emit("servers_loaded", tv.get_enum())
             return
         self.mediator.statusbar.set_by_context(tv.get_enum(), "")
-        self.mediator.filters.button_grid.block_toggles(True)
-        self.populate_filter_prefs()
-        self.mediator.filters.button_grid.block_toggles(False)
-        self.emitter.emit("lan_page_initialized")
         ServerModelManager(self, tv).load()
 
-    def populate_filter_prefs(self) -> None:
-        tv = self.get_active_treeview()
-        filters = self.config_man.get_filters(tv)
-        if filters is None:
-            return
-        filter_man = self.get_filter_man()
-        for filt, state in filters.items():
-            filter_man.set_filter(filt, state)
-        self.mediator.filters.set_filters(filters)
-
     def get_dist_cache(self) -> dict[str, "Haversine"]:
         return self.dist_cache
 
@@ -347,7 +319,16 @@ class Controller(GObject.GObject):
         filter_man = self.get_filter_man()
         return filter_man.get_filters()
 
-    # FIXME: wipe maps store when changing tabs if model is none
+    # TODO: rename
+    def _on_servers_loaded_init(self, emitter: "Emitter") -> None:
+        """Triggered after servers load but prior to maps loading"""
+        # FIXME: wipe maps store when changing tabs if model is none
+        # e.g. select recent, toggle map, then select lan -> not wiped
+        tv = self.get_active_treeview()
+        if tv.loaded is False:
+            return
+        store = self.get_map_store()
+        self.emitter.emit("load_maps", store)
 
     def has_server_model(self) -> bool:
         treeview = self.get_active_treeview()

dzgui/data/CHANGELOG.md

@@ -34,7 +34,6 @@
 - Early load alerts button
 - Preconnect dialog
 - Preconnect warnings/failsafes like filesize
-- Save filters per server context between sessions
 
 
 ## Changed

dzgui/init/migrate.py

@@ -1,7 +1,6 @@
 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.config.convert import rc2json
 from dzgui.util._json import read_json, write_json
@@ -18,28 +17,17 @@ def has_new_config(config: Path) -> bool:
     return config.exists()
 
 
-def convert_cols_file(res: Path) -> Any | None:
-    j = read_json(res)
-    cols = j["cols"]
-    # NOTE: implies prior conversion
-    if "View" in cols:
-        return None
-    # NOTE: user may not have changed these widths in API 6
-    try:
-        cols["View"] = cols.pop("Perspective")
-        cols["Max"] = cols.pop("Maximum")
-    except Exception:
-        pass
-    return j
-
-
 def migrate_cols_file(res: Path) -> None:
-    # NOTE: filename "dzg.columns.json" is API 7 spec
+    # NOTE: dzg.columns.json is API 7 spec
     old_res = Path.home() / LEGACY_COLS_PATH
     if old_res.is_file():
-        j = convert_cols_file(old_res)
+        j = read_json(old_res)
-        if j is not None:
+        cols = j["cols"]
-            write_json(j, res)
+        if "View" in cols:
+            return
+        cols["View"] = cols.pop("Perspective")
+        cols["Max"] = cols.pop("Maximum")
+        write_json(j, res)
 
 
 def copy_state_files(state_path: Path) -> None:

dzgui/main.py

@@ -121,6 +121,8 @@ def main() -> None:
     with open(XDG.debug, "w") as f:
         f.truncate(0)
 
+    latest_release = check_updates(version)
+
     if _is_steam_deck is False:
         # TODO: sudo escalation dialog
         # count = get_map_count()
@@ -128,22 +130,16 @@ def main() -> None:
         if has_steam_client() is False:
             EarlyAlertDialog(init.requires_steam)
 
-    is_dayz_installed(XDG.config)
-
-    # TODO: slow running procs here--needs dialog
     # NOTE: clears versions file of unlinked mods
     rebuild_symlinks(XDG.config)
     remove_stale_signatures(XDG.config, XDG.version)
 
+    is_dayz_installed(XDG.config)
     # TODO: handle IP DB failure and use coords fallback
-    # TODO: drop this after dialog is complete
-    print("Fetching geolocation data, may take some time...")
     get_ipdb(XDG.ips)
     local_coords = get_local_coords(XDG.ips)
     use_miles = lookup(XDG.config, Preferences.DIST)
 
-    latest_release = check_updates(version)
-
     prefs = UserPrefs(
         is_steam_deck=_is_steam_deck,
         is_game_mode=_is_game_mode,

dzgui/managers/config.py

@@ -159,9 +159,6 @@ class ConfigManager:
 
     def save_res_and_quit(self, tv: "ServerTreeView", window: "OuterWindow") -> None:
         columns = tv.get_columns()
-        filters = self.controller.get_all_tree_filters()
-        filters_file = self.prefs.paths.filters
-
         columns_file = self.prefs.paths.columns
         try:
             data = read_json(columns_file)
@@ -176,7 +173,6 @@ class ConfigManager:
 
         try:
             write_json(data, columns_file)
-            write_json(filters, filters_file)
         except Exception as e:
             logger.critical(e)
 
@@ -220,12 +216,3 @@ class ConfigManager:
             h = WINDOW_DEFAULT_Y
             logger.info(f"Using default window size {w},{h}")
             window.set_default_size(w, h)
-
-    def get_filters(self, tv: "ServerTreeView") -> Any | None:
-        filters = self.prefs.paths.filters
-        try:
-            enum = tv.get_enum()
-            filters = read_json(filters)
-            return filters[str(enum)]
-        except Exception:
-            return None

dzgui/managers/connection.py

@@ -161,7 +161,7 @@ class ConnectionManager:
                 if len(self.missing_mods) > 0:
                     required_size = sum(row[2] for row in self.missing_mods)
                     required_mib = format_mib(required_size)
-                    free_mib = format_mib(free)
+                    free_mib = format_mib(required_size)
 
         dayz_running = is_dayz_running()
 
@@ -222,8 +222,7 @@ class ConnectionManager:
     def query_modlist_and_present(self, record: Servers.Record) -> None:
         try:
             mods = self._query_modlist(record)
-        except Exception as e:
+        except Exception:
-            print(f"{type(e).__name__}: {e}")
             self.thread_man.set_cleanup_func(
                 StoredFunc(self._server_timeout), destroy_first=True
             )
@@ -280,13 +279,8 @@ class ConnectionManager:
 
         for title, mod, stamp, size in self.missing_mods:
             # TODO: check cancel and exit events
-            if self.controller.get_exit_event().is_set():
-                return
-            if self.controller.get_cancel_event().is_set():
-                self.controller.clear_cancel_event()
-                return
             enqueue_mod(mod, self.appid)
-            time.sleep(3)
+            time.sleep(2)
 
         if raise_window is True:
             logger.info("Bringing window to foreground")

dzgui/managers/update.py

@@ -1,67 +0,0 @@
-import logging
-import requests
-import shutil
-import subprocess
-import tarfile
-from typing import TYPE_CHECKING
-
-from dzgui.const.constants import (
-    APP_NAME,
-    TMP_EXE,
-    TMP_PATH,
-    TMP_TARBALL,
-)
-from dzgui.strings import dialogs
-from dzgui.managers.threading import call_on_thread, StoredFunc, ThreadingManager
-from dzgui.views.dialogs.generic import ExceptionDialog, QuitDialog
-
-import gi
-
-gi.require_version("Gtk", "3.0")
-from gi.repository import Gtk, GLib  # noqa E402
-
-if TYPE_CHECKING:
-    from dzgui.controllers.mc import Controller
-
-logger = logging.getLogger(APP_NAME)
-
-
-class UpdateManager:
-    def __init__(self, controller: "Controller") -> None:
-
-        self.thread_man = ThreadingManager(controller)
-        self.controller = controller
-
-    @call_on_thread(dialogs.fetching_update)
-    def update_version(self, exe_path: str, url: str) -> None:
-        try:
-            res = requests.get(url)
-            if res.status_code == 200:
-                with open(TMP_TARBALL, "wb") as file:
-                    file.write(res.content)
-                with tarfile.open(TMP_TARBALL) as tar:
-                    tar.extractall(TMP_PATH)
-
-                shutil.move(TMP_EXE, exe_path)
-
-                proc = subprocess.run([exe_path, "self", "restore"])
-                if proc.returncode == 0:
-                    func = StoredFunc(self._on_update_success)
-                    self.thread_man.set_cleanup_func(func, destroy_first=True)
-                else:
-                    msg = dialogs.failed_to_update
-                    func = StoredFunc(self._on_update_failure, msg)
-                    self.thread_man.set_cleanup_func(func, destroy_first=True)
-        except Exception as e:
-            func = StoredFunc(self._on_update_failure, e)
-            self.thread_man.set_cleanup_func(func, destroy_first=True)
-            logger.warning(e)
-
-    def _on_update_success(self) -> None:
-        msg = dialogs.update_success
-        dialog = QuitDialog(self.controller, msg)
-        dialog.run()
-
-    def _on_update_failure(self, msg: str) -> None:
-        dialog = ExceptionDialog(self.controller, msg)
-        dialog.run()

dzgui/model/servers.py

@@ -73,7 +73,6 @@ class ServerModelManager:
                 self._dump_history()
             case ServerTab.LAN:
                 # NOTE: LAN tab is only loaded on demand
-                self.emitter.emit("lan_page_initialized")
                 pass
             case _:
                 pass
@@ -124,10 +123,8 @@ class ServerModelManager:
         parsed = Servers.parse_json(servers)
         self._push_data(parsed)
 
-    @call_on_thread(dialog.scanning, show_cancel=True)
+    @call_on_thread(dialog.scanning)
     def dump_lan(self, port: int, early_abort: bool) -> None:
-        self.first_iteration = True
-
         servers = []
         ports = range(1, 256)
         failure_func = StoredFunc(self._cleanup_on_failure)
@@ -138,20 +135,19 @@ class ServerModelManager:
             for future in as_completed(futures):
                 try:
                     if self.controller.get_exit_event().is_set():
-                        event.set()
-                        return
-                    if self.controller.get_cancel_event().is_set():
-                        event.set()
-                        self.controller.clear_cancel_event()
                         return
                     res = future.result(timeout=LAN_TIMEOUT)
                     if res is None:
                         continue
-                    servers.append(res)
                     if early_abort is True:
                         # NOTE: on first non-empty hit, flag pending threads to close
                         event.set()
-                        break
+                        servers.append(res)
+                        self.thread_man.set_cleanup_func(
+                            StoredFunc(self._cleanup_on_success)
+                        )
+                        return
+                    servers.append(res)
                 except Exception as e:
                     logger.critical(e)
                     self.thread_man.set_cleanup_func(failure_func, destroy_first=True)
@@ -243,11 +239,9 @@ class ServerModelManager:
         filter_man = self.tv.get_filter_man()
         maps = self._get_new_maps()
         filter_man.set_unique_maps(maps)
-        store = filter_man.get_map_store()
 
         self.first_iteration = False
-        self.emitter.emit("load_maps", store)
+        self.emitter.emit("servers_loaded_init")
-        # self.emitter.emit("servers_loaded_init")
 
     def add_to_history(self, record: dict[str, Any]) -> None:
         proxy_man = self._get_proxy_man()
@@ -324,7 +318,6 @@ class ServerModelManager:
                 self.thread_man.set_cleanup_func(func)
                 return
             config_man.add_saved_server(fqip)
-
             # FIXME: this is valid if saved servers tab is already open,
             # but not if app was just booted; causes single row to appear prematurely
             if proxy_man.has_control_model() is False:
@@ -375,31 +368,30 @@ class ServerModelManager:
         proxy = self._get_proxy_man().get_proxy_model()
         self.tv.set_model(proxy)
 
-        if self.controller.get_active_treeview().get_enum == ServerTab.SAVED:
+        self.emitter.emit("servers_loaded", self.enum)
-            self.emitter.emit("servers_loaded", self.enum)
 
         filter_man = self.tv.get_filter_man()
         # NOTE: maps are set outside of thread because it triggers map changed signals
         maps = self._get_new_maps()
         filter_man.set_unique_maps(maps)
-        store = filter_man.get_map_store()
-        self.emitter.emit("load_maps", store)
 
         self.first_iteration = False
+        self.emitter.emit("servers_loaded_init")
         self.emitter.emit("saved_servers_changed")
 
     def _update_maps(self) -> None:
         filter_man = self.tv.get_filter_man()
         filter_man.set_unique_maps(self._get_new_maps())
-        store = filter_man.get_map_store()
+        self.emitter.emit("servers_loaded_init")
-        self.emitter.emit("load_maps", store)
         self.first_iteration = False
 
     def _cleanup_on_success(self) -> None:
         proxy = self._get_proxy_man().get_proxy_model()
         self.tv.set_model(proxy)
 
+        # TODO: servers_loaded vs servers_reloaded
         self.emitter.emit("servers_loaded", self.enum)
+
         if self.first_iteration:
             self._update_maps()
 

dzgui/util/_json.py

@@ -2,17 +2,19 @@ import json
 from pathlib import Path
 from typing import Any
 
-
 def read_json(path: Path) -> Any:
     try:
         with open(path, "r") as infile:
-            data = json.load(infile)
+            try:
-            return data
+                data = json.load(infile)
-    except Exception as e:
+                return data
+            except json.decoder.JSONDecodeError as e:
+                raise e
+    except OSError as e:
         raise e
 
 
-def write_json(data: dict[str, Any], path: Path) -> None:
+def write_json(data: dict, path: Path) -> None:
     try:
         j = json.dumps(data, indent=2)
         path.write_text(j)

dzgui/util/symlink.py

@@ -43,14 +43,11 @@ def clone_symlinks(steam_path: Path) -> None:
 
     # TODO: test these two operations
     # use less time intensive logic like the above
-    try:
+    for file in exp_path.iterdir():
-        for file in exp_path.iterdir():
+        if file.is_symlink():
-            if file.is_symlink():
+            file.unlink()
-                file.unlink()
 
-        for file in dayz_path.iterdir():
+    for file in dayz_path.iterdir():
-            if file.is_symlink():
+        if file.is_symlink():
-                uid = file.name
+            uid = file.name
-                Path(exp_path / uid).symlink_to(dayz_path / uid)
+            Path(exp_path / uid).symlink_to(dayz_path / uid)
-    except Exception as e:
-        logger.critical(e)

dzgui/views/components/buttons.py

@@ -94,11 +94,9 @@ class RefreshButton(IconTextButton):
             icon=REFRESH_ICON,
             label=atomic_buttons.refresh,
         )
-
         self.controller = controller
         emitter = self.controller.get_emitter()
         self.loading = False
-        self.is_clicked = False
 
         self.time = 30
 
@@ -112,21 +110,17 @@ class RefreshButton(IconTextButton):
 
     def _on_refresh_clicked(self, button: Self) -> None:
         """Spawned in a thread"""
-        self.is_clicked = True
+        self.loading = True
         self.controller.refresh_tree()
         # TODO: get server tab enum
         # if LAN tab, reload existing entries in place
 
     def start_decrement(self, emitter: "Emitter", tab: "ServerTab") -> None:
-        if self.is_clicked is False:
-            return
         if self.loading:
-            return
+            self.set_sensitive(False)
-        self.set_sensitive(False)
+            self.loading = False
-        self.loading = True
+            self.show_time(True)
-        self.is_clicked = False
+            GLib.timeout_add_seconds(1, self.decrement)
-        self.show_time(True)
-        GLib.timeout_add_seconds(1, self.decrement)
 
     def decrement(self) -> bool:
         self.time -= 1
@@ -134,7 +128,6 @@ class RefreshButton(IconTextButton):
             self.time = 30
             self.show_time(False)
             self.set_sensitive(True)
-            self.loading = False
             return False
         self.show_time(True)
         return True

dzgui/views/components/filter_panel.py

@@ -68,7 +68,6 @@ class ButtonGrid(Gtk.Grid):
             )
 
     def reload_filters(self) -> None:
-        # TODO: may be superfluous
         checkboxes = self.checks
         self.block_toggles(True)
         filters = self.controller.get_enabled_filters()
@@ -331,8 +330,3 @@ class FilterPanel(Gtk.Box):
             self.block_map_change_propagation = False
             return
         self.emitter.emit("map_selection_changed", name)
-
-    def set_filters(self, filters: dict[str, bool]) -> None:
-        for check in self.button_grid.checks:
-            label = check.get_label()
-            check.set_active(filters[label])

dzgui/views/components/right_panel.py

@@ -1,5 +1,9 @@
 import logging
 import os
+import requests
+import shutil
+import subprocess
+import tarfile
 
 from typing import Literal, TYPE_CHECKING
 
@@ -9,14 +13,20 @@ from dzgui.const.constants import (
     NO_FILL,
     FILL,
     NO_PADDING,
+    TMP_EXE,
+    TMP_PATH,
+    TMP_TARBALL,
 )
+from dzgui.const.update import ALLOW_UPDATES
 from dzgui.const.enum import ServerTab
-from dzgui.managers.update import UpdateManager
+from dzgui.managers.threading import call_on_thread, StoredFunc, ThreadingManager
+from dzgui.strings import dialogs
 from dzgui.util.clip import copy_clipboard
 from dzgui.views.components.buttonbox import ButtonBox
 from dzgui.views.components.filter_panel import FilterPanel
 from dzgui.views.components.mod_panel import ModSelectionPanel
 from dzgui.views.components.buttons import IconTextButton, RefreshButton, KeysButton
+from dzgui.views.dialogs.generic import ExceptionDialog, QuitDialog
 
 import gi
 
@@ -35,13 +45,13 @@ class RightPanel(Gtk.Box):
     def __init__(self, controller: "Controller"):
         super().__init__(spacing=6, orientation=Gtk.Orientation.VERTICAL)
 
+        self.thread_man = ThreadingManager(controller)
         self.controller = controller
         self.controller.register_widget("right_panel", self)
 
         emitter = controller.get_emitter()
         emitter.connect("servers_loaded", self._on_servers_loaded)
         emitter.connect("server_page_changed", self._on_server_page_changed)
-        emitter.connect("lan_page_initialized", self._on_lan_page_init)
 
         self.button_vbox = ButtonBox(controller)
         self.filters_vbox = FilterPanel(controller)
@@ -85,20 +95,54 @@ class RightPanel(Gtk.Box):
             valign=Gtk.Align.END,
             spacing=10,
         )
-        exe_path = os.getenv("PYAPP")
+        if ALLOW_UPDATES and update is not None:
-        if exe_path and update is not None:
             self.update_button.set_halign(Gtk.Align.END)
             self.gutter_box.add(self.update_button)
             self.update_button.connect(
-                "clicked", self._on_update_button_clicked, exe_path, update
+                "clicked", self._on_update_button_clicked, update
             )
         self.gutter_box.add(eb)
         self.pack_start(self.gutter_box, NO_EXPAND, FILL, NO_PADDING)
 
-    def _on_update_button_clicked(
+    def _on_update_success(self) -> None:
-        self, button: Gtk.Button, exe_path: str, url: str
+        msg = dialogs.update_success
-    ) -> None:
+        dialog = QuitDialog(self.controller, msg)
-        UpdateManager(self.controller).update_version(exe_path, url)
+        dialog.run()
+
+    def _on_update_failure(self, msg: str) -> None:
+        dialog = ExceptionDialog(self.controller, msg)
+        dialog.run()
+
+    @call_on_thread(dialogs.fetching_update)
+    def _on_update_button_clicked(self, button: Gtk.Button, url: str) -> None:
+        try:
+            res = requests.get(url)
+            if res.status_code == 200:
+                with open(TMP_TARBALL, "wb") as file:
+                    file.write(res.content)
+                with tarfile.open(TMP_TARBALL) as tar:
+                    tar.extractall(TMP_PATH)
+
+                exe_path = os.getenv("PYAPP")
+                if exe_path is None:
+                    msg = dialogs.failed_to_update
+                    func = StoredFunc(self._on_update_failure, msg)
+                    self.thread_man.set_cleanup_func(func, destroy_first=True)
+                    return
+                shutil.move(TMP_EXE, exe_path)
+
+                proc = subprocess.run([exe_path, "self", "restore"])
+                if proc.returncode == 0:
+                    func = StoredFunc(self._on_update_success)
+                    self.thread_man.set_cleanup_func(func, destroy_first=True)
+                else:
+                    msg = dialogs.failed_to_update
+                    func = StoredFunc(self._on_update_failure, msg)
+                    self.thread_man.set_cleanup_func(func, destroy_first=True)
+        except Exception as e:
+            func = StoredFunc(self._on_update_failure, e)
+            self.thread_man.set_cleanup_func(func, destroy_first=True)
+            logger.warning(e)
 
     def _on_server_page_changed(
         self, emitter: "Emitter", page: "ServerTreeView"
@@ -107,11 +151,6 @@ class RightPanel(Gtk.Box):
         if page.loaded is True:
             return
         self.filters_vbox.set_sensitive(False)
-        # TODO: unless it is lan page
-        #self.refresh_button.set_sensitive(False)
-
-    def _on_lan_page_init(self, emitter: "Emitter") -> None:
-        self.filters_vbox.set_sensitive(False)
 
     def _on_servers_loaded(self, emitter: "Emitter", context: "ServerTab") -> None:
         # TODO: similar logic on notebook page change

dzgui/views/components/scrollable.py

@@ -1,9 +0,0 @@
-import gi
-
-gi.require_version("Gtk", "3.0")
-from gi.repository import Gtk  # noqa
-
-
-class NoOverlayScrolledWindow(Gtk.ScrolledWindow):
-    def __init__(self) -> None:
-        super().__init__(overlay_scrolling=False)

dzgui/views/components/statusbar.py

@@ -111,9 +111,9 @@ class Statusbar(Gtk.Grid):
         context: Union["ServerTab", NotebookPage],
     ) -> None:
         self.spinner.stop()
-        # FIXME: CalcDist is being called when table is not loaded
+        # TODO: CalcDist is being called when table is not loaded
         if dist is None:
-            return
+            self.set_by_context(context, "")
         else:
             pretty = self.append_distance(dist)
             self.set_by_context(context, pretty)

dzgui/views/dialogs/early_alert.py

@@ -53,5 +53,3 @@ class EarlyIgnoreDialog(EarlyAlertDialog):
 
         # TODO: reverse order
         self.add_button("Ignore", Gtk.ResponseType.CANCEL)
-
-        # TODO: if exit, sys.exit(1), else pass

dzgui/views/mixins/mods_mixin.py

@@ -11,5 +11,5 @@ class ModsMixin:
         self, tree: TreeView, path: Gtk.TreePath, column: Gtk.TreeViewColumn
     ) -> None:
 
-        mod = self.get_value_at_index(2)  # type: ignore
+        mod = self.get_value_at_index(2)
         self.controller.open_workshop_page(mod)  # type: ignore

dzgui/views/pages/log.py

@@ -1,6 +1,5 @@
 from typing import TYPE_CHECKING
 from dzgui.const.constants import LOG_FILTERS
-from dzgui.views.components.scrollable import NoOverlayScrolledWindow
 from dzgui.views.mixins.cursor_mixin import CursorMixin
 from dzgui.views.mixins.help_menu_mixin import HelpMenuMixin
 from dzgui.views.trees.tree_log import LogTreeView
@@ -22,7 +21,7 @@ class Log(CursorMixin, HelpMenuMixin, Gtk.Box):  # type: ignore
         NOTE: LogTreeView is kept in a separate ScrolledWindow so that
         checkboxes will be flush on bottom
         """
-        self.scrolled = NoOverlayScrolledWindow()
+        self.scrolled = Gtk.ScrolledWindow()
         self.treeview = LogTreeView(controller)
         self.scrolled.add(self.treeview)
 

dzgui/views/pages/mods.py

@@ -1,5 +1,4 @@
 from typing import Self, TYPE_CHECKING
-from dzgui.views.components.scrollable import NoOverlayScrolledWindow
 from dzgui.views.trees.tree_mods import ModTreeView
 
 import gi
@@ -11,8 +10,7 @@ if TYPE_CHECKING:
     from dzgui.controllers.mc import Controller
 
 
-
+class Mods(Gtk.ScrolledWindow):
-class Mods(NoOverlayScrolledWindow):
     def __init__(self, controller: "Controller") -> None:
         super().__init__()
 

dzgui/views/pages/servers.py

@@ -162,6 +162,19 @@ class ServerNotebook(Gtk.ScrolledWindow):
                 return tv
         raise ValueError("No treeview set")
 
+    def add_notification(self) -> None:
+        saved = self.notebook.get_nth_page(1)
+        if saved is None:
+            return
+        text = self.notebook.get_tab_label_text(saved)
+        if text is None:
+            return
+        # TODO: strings
+        if "*" in text:
+            return
+        text += "*"
+        self.notebook.set_tab_label_text(saved, text)
+
     def update_tab_widths(self, col: Gtk.TreeViewColumn) -> None:
         # TODO: may cause pixel offsets when application is maximized
         width = col.get_width()

dzgui/views/trees/tree_servers.py

@@ -72,7 +72,6 @@ class ServerTreeView(ContextMixin, TreeView):  # type: ignore
             logger.critical(e)
             valid_json = False
 
-        # NOTE: reasonable defaults for long columns
         width_map = {
             "Name": 800,
             "Map": 300,
@@ -97,9 +96,8 @@ class ServerTreeView(ContextMixin, TreeView):  # type: ignore
                 column.set_fixed_width(saved_size)
                 column.set_expand(True)
             else:
-                if column_title in width_map:
+                w = width_map[column_title]
-                    w = width_map[column_title]
+                column.set_fixed_width(w)
-                    column.set_fixed_width(w)
             if column_title == "Ping":
                 column.set_cell_data_func(renderer, self._get_ping)
 

pyproject.toml

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

scripts/prebuild.py

@@ -1,81 +0,0 @@
-import os
-import requests
-import subprocess
-import tarfile
-
-from pathlib import Path
-from urllib.parse import unquote
-
-BUILD = "3.13.9"
-DATE = "20251014"
-CPYTHON_BUILD = f"cpython-{BUILD}"
-
-root = Path(__file__).resolve().parents[1]
-build_dir = root.joinpath("build")
-cpython_dir = build_dir.joinpath(CPYTHON_BUILD)
-
-
-def fetch(url: str, destination: str) -> None:
-    print(f"Fetching URL '{url}'")
-    res = requests.get(url)
-    code = res.status_code
-    if code != 200:
-        raise Exception(f"URL '{url}' returned status code {code}")
-    with open(build_dir.joinpath(destination), "wb") as f:
-        f.write(res.content)
-
-
-def get_cpython() -> None:
-    source = f"https://github.com/astral-sh/python-build-standalone/releases/download/{DATE}/"
-    build = f"{CPYTHON_BUILD}%2B{DATE}-x86_64_v3-unknown-linux-gnu-install_only_stripped.tar.gz"
-    url = f"{source}{build}"
-    outfile = unquote(build)
-    fetch(url, outfile)
-    version = build.split("%")[0]
-    untar(outfile, "python", version)
-
-
-def get_pyapp() -> None:
-    url = "https://github.com/ofek/pyapp/releases/latest/download/source.tar.gz"
-    outfile = "pyapp-latest.tar.gz"
-    fetch(url, outfile)
-    untar(outfile, "pyapp-*", "pyapp-latest")
-
-
-def untar(file: str, glob: str, renamed: str) -> None:
-    full_path = build_dir.joinpath(file)
-    with tarfile.open(full_path, "r:gz") as tar:
-        tar.extractall(path=build_dir)
-    full_path.unlink()
-    for _dir in build_dir.glob(glob):
-        os.rename(_dir, build_dir.joinpath(renamed))
-
-
-def install_deps() -> None:
-    pip = build_dir.joinpath(f"{CPYTHON_BUILD}/bin/pip")
-    subprocess.run([pip, "install", root])
-
-
-def repackage() -> None:
-    print("Preparing tar archive...")
-    outfile = build_dir.joinpath("airgapped.tar.gz")
-    with tarfile.open(outfile, "w:gz") as tar:
-        tar.add(build_dir.joinpath(CPYTHON_BUILD), arcname="python")
-
-
-def rebuild_cpython() -> None:
-    if cpython_dir.is_dir() is False:
-        get_cpython()
-    install_deps()
-    repackage()
-    return get_packaged_version()
-
-
-def get_packaged_version() -> str:
-    proc = subprocess.run(
-        [cpython_dir.joinpath("bin/dzgui"), "-v"],
-        capture_output=True,
-        text=True,
-        check=True,
-    )
-    return proc.stdout.rstrip()

scripts/release.py

@@ -5,12 +5,11 @@ import tarfile
 
 from pathlib import Path
 
-from prebuild import get_pyapp, rebuild_cpython
-
-
 root = Path(__file__).resolve().parents[1]
 output = root.joinpath("dist")
-build_dir = root.joinpath("build")
+
+pyapp_dir = root.joinpath("pyapp-latest")
+cpython = root.joinpath("build/cpython/airgapped.tar.gz")
 
 builder = build.ProjectBuilder(root)
 wheel = builder.build("wheel", output_directory=output)
@@ -21,21 +20,15 @@ metadata = stem.split("-")
 appname = metadata[0]
 version = metadata[1]
 
-pyapp_dir = build_dir.joinpath("pyapp-latest")
-if pyapp_dir.is_dir() is False:
-    get_pyapp()
-
-packaged_version = rebuild_cpython()
-assert packaged_version == version
-cpython = build_dir.joinpath("airgapped.tar.gz")
-
 entrypoint = "dzgui.main:main"
+
 env = os.environ
 env["PYAPP_PROJECT_VERSION"] = version
 env["PYAPP_PROJECT_NAME"] = appname
 env["PYAPP_EXEC_SPEC"] = entrypoint
 env["PYAPP_PROJECT_PATH"] = wheel
 env["PYAPP_PASS_LOCATION"] = "true"
+# env["PYAPP_PYTHON_VERSION"] = "3.13"
 
 # NOTE: explicitly install all dependencies into distribution
 env["PYAPP_SKIP_INSTALL"] = "true"
@@ -46,16 +39,10 @@ env["PYAPP_DISTRIBUTION_PYTHON_PATH"] = "python/bin/python3"
 
 proc = subprocess.run(["cargo", "build", "--release"], env=env, cwd=pyapp_dir)
 if proc.returncode == 0:
-    output_exe = build_dir.joinpath("pyapp-latest/target/release/pyapp")
+    output_exe = root.joinpath("pyapp-latest/target/release/pyapp")
     release_exe = output.joinpath(appname)
     output_exe.rename(release_exe)
     tarpath = output.joinpath(tarname)
     with tarfile.open(tarpath, "w:gz") as tar:
         tar.add(release_exe, arcname=appname)
     print(f"Wrote tarfile to '{tarpath}'")
-
-proc = subprocess.run([release_exe, "-v"], capture_output=True, text=True)
-assert proc.stdout.rstrip() == version
-
-release_exe.unlink()
-Path(wheel).unlink()

tests/fixtures/columns_1

@@ -1,14 +0,0 @@
-{
-  "cols": {
-    "Name": 1,
-    "Map": 1,
-    "Gametime": 1,
-    "Players": 1,
-    "Queue": 1,
-    "IP": 1,
-    "Qport": 1,
-    "Ping": 1,
-    "Maximum": 1,
-    "Perspective": 1
-  }
-}

tests/fixtures/columns_2

@@ -1,12 +0,0 @@
-{
-  "cols": {
-    "Name": 398,
-    "Map": 181,
-    "Gametime": 151,
-    "Players": 119,
-    "Queue": 96,
-    "IP": 247,
-    "Qport": 94,
-    "Ping": 253
-  }
-}

tests/fixtures/columns_3

@@ -1,13 +0,0 @@
-{
-  "cols": {
-    "Name": 1,
-    "Map": 1,
-    "Gametime": 1,
-    "Players": 1,
-    "Queue": 1,
-    "IP": 1,
-    "Qport": 1,
-    "Ping": 1,
-    "View": 1
-  }
-}

tests/test_columns.py

@@ -1,33 +0,0 @@
-import pytest
-
-from dzgui.init.migrate import convert_cols_file
-from tests.fixtures import fixture_path
-
-@pytest.fixture
-def columns_with_perspective():
-    return fixture_path("columns_1")
-
-@pytest.fixture
-def columns_without_perspective():
-    return fixture_path("columns_2")
-
-@pytest.fixture
-def columns_with_view():
-    return fixture_path("columns_3")
-
-@pytest.mark.config
-def test_columns_with_perspective(columns_with_perspective):
-    j = convert_cols_file(columns_with_perspective)
-    assert "View" in j["cols"]
-    assert "Max" in j["cols"]
-
-@pytest.mark.config
-def test_columns_without_perspective(columns_without_perspective):
-    j = convert_cols_file(columns_without_perspective)
-    assert "View" not in j["cols"]
-    assert "Max" not in j["cols"]
-
-@pytest.mark.config
-def test_columns_with_view(columns_with_view):
-    j = convert_cols_file(columns_with_view)
-    assert j is None

tests/test_locale.py

@@ -2,14 +2,14 @@ from dzgui.util import localize
 
 
 def test_de(monkeypatch):
-    monkeypatch.setenv("LC_ALL", "de_DE.UTF-8")
+    monkeypatch.setenv("LC_CTYPE", "de_DE.UTF-8")
     localize.set_locale()
     assert localize.number(9900) == "9.900"
     assert localize.number(99.88) == "99,88"
 
 
 def test_en(monkeypatch):
-    monkeypatch.setenv("LC_ALL", "en_US.UTF-8")
+    monkeypatch.setenv("LC_CTYPE", "en_US.UTF-8")
     localize.set_locale()
     assert localize.number(9900) == "9,900"
     assert localize.number(99.88) == "99.88"
@@ -22,7 +22,7 @@ def test_none(monkeypatch):
 
 
 def test_empty(monkeypatch):
-    monkeypatch.setenv("LC_ALL", "")
+    monkeypatch.setenv("LC_CTYPE", "")
     localize.set_locale()
     assert localize.number(9900) == "9,900"
     assert localize.number(99.88) == "99.88"