Merge ac286f4a72 into 5014402e39

CHANGELOG.md

@@ -52,7 +52,6 @@
 - Filter button tooltips
 - Expand/collapse changelog versions
 - Support local light/dark mode changes on system theme
-- Server time calculator
 
 ### Changed
 - Conform to PEP 440 versioning for beta versions

dzgui/api/servers.py

@@ -346,7 +346,7 @@ def get_details(record: Record) -> Details | None:
                 dlc = strings.dlc_none
             case 2:
                 dlc = strings.dlc_frostline
-            case 4:
+            case 3:
                 dlc = strings.dlc_badlands
             case _:
                 dlc = strings.unspecified

dzgui/api/steam.py

@@ -6,7 +6,6 @@ import subprocess
 import vdf  # type: ignore
 
 from pathlib import Path
-from requests.exceptions import HTTPError
 from typing import Any, Union
 from warnings import deprecated
 
@@ -33,7 +32,6 @@ from dzgui.const.endpoints import (
     UNSUB_ENDPOINT,
 )
 from dzgui.strings import wizard
-from dzgui.strings.errors import api_validation_error, workshop_endpoint_error
 from dzgui.util.bash import concat_bash_args
 
 logger = logging.getLogger(APP_NAME)
@@ -264,16 +262,6 @@ def find_user_id_32(path: Path) -> int:
     return int(uid) & 0xFFFFFFFF
 
 
-class SteamAPIKeyError(Exception):
-    def __init__(self, msg: str | None = None):
-        super().__init__(msg or api_validation_error)
-
-
-class SteamWorkshopEndpointError(Exception):
-    def __init__(self, msg: str | None = None):
-        super().__init__(msg or workshop_endpoint_error)
-
-
 def update_workshop(key: str, mod: int, endpoint: str) -> None:
     payload: dict[str, Union[int, str]] = {
         "publishedfileid": mod,
@@ -285,19 +273,8 @@ def update_workshop(key: str, mod: int, endpoint: str) -> None:
     try:
         res = requests.post(endpoint, params=payload, timeout=REQUEST_TIMEOUT)
         res.raise_for_status()
-    except HTTPError as e:
-        logger.critical(e)
-        match res.status_code:
-            case 403:
-                raise SteamAPIKeyError()
-            case 404:
-                raise SteamWorkshopEndpointError()
-            case _:
-                # TODO: apply redaction filter
-                raise e
     except Exception as e:
         logger.critical(e)
-        raise e
 
 
 def subscribe(key: str, mod: int) -> None:

dzgui/const/constants.py

@@ -36,7 +36,7 @@ HEX_GREEN = "#32CD32"
 HEX_RED = "#FF0000"
 HEX_ORANGE = "#FFAC1C"
 
-# TODO: normalize icon names
+# FIXME: normalize icon names
 CALCULATOR = "accessories-calculator-symbolic"
 CARET_DOWN = "go-down-symbolic"
 CARET_UP = "go-up-symbolic"
@@ -55,8 +55,6 @@ VIEW_CONCEAL = "view-conceal-symbolic"
 VIEW_REVEAL = "view-reveal-symbolic"
 WARNING = "dialog-warning-symbolic"
 WEB_BROWSER = "web-browser-symbolic"
-DAY_ICON = "weather-clear-symbolic"
-NIGHT_ICON = "weather-clear-night-symbolic"
 
 SEPARATOR = "SEPARATOR"
 

dzgui/controllers/mc.py

@@ -541,8 +541,8 @@ class Controller(GObject.GObject):
     def update_status(self) -> None:
         self.mediator.preconnect.mark_finished()
 
-    def get_steam_client_name(self, cmd: str) -> str:
-        return self.mediator.options.get_client_name(cmd)
+    def get_steam_client_name(self) -> str:
+        return self.mediator.options.get_client_name()
 
     def present_window(self) -> None:
         self.mediator.window.present_with_time(Gdk.CURRENT_TIME)

dzgui/data/CHANGELOG.md

@@ -52,7 +52,6 @@
 - Filter button tooltips
 - Expand/collapse changelog versions
 - Support local light/dark mode changes on system theme
-- Server time calculator
 
 ### Changed
 - Conform to PEP 440 versioning for beta versions

dzgui/init/dayz.py

@@ -4,24 +4,17 @@ from pathlib import Path
 
 from dzgui.api.steam import get_app_path
 from dzgui.config.query import lookup
-from dzgui.const.constants import APPID_DAYZ, APP_NAME, APPNAME_DAYZ
+from dzgui.const.constants import APPID_DAYZ, APP_NAME
 from dzgui.const.enum import Preferences
 
-from dzgui.strings.preconnect import resync
-
 
 logger = logging.getLogger(APP_NAME)
 
 
-class VDFSyncError(Exception):
-    pass
-
-
 def is_dayz_installed(config: Path) -> None:
     try:
         path = lookup(config, Preferences.DEFAULT)
         get_app_path(Path(path), APPID_DAYZ)
     except Exception as e:
         logger.critical(e)
-        msg = resync.format(APPNAME_DAYZ)
-        raise VDFSyncError(msg)
+        raise e

dzgui/init/proc.py

@@ -16,15 +16,12 @@ logger = logging.getLogger(APP_NAME)
 
 
 def is_steam_running(cmd: str) -> bool:
-    is_flatpak_running = is_flatpak_steam_running()
-    if cmd in (FLATPAK_RUN_CMD, FLATPAK_SANDBOX):
-        return is_flatpak_running
-    elif cmd == STEAM_CMD:
-        if is_flatpak_running:
-            return False
+    if cmd == STEAM_CMD:
         if has_cmd(STEAM_CMD) is False:
             return False
         return is_running(STEAM_CMD)
+    elif cmd == FLATPAK_RUN_CMD or FLATPAK_SANDBOX:
+        return is_flatpak_steam_running()
     else:
         raise TypeError("Not a valid Steam client selection")
 
@@ -34,9 +31,7 @@ def is_steam_running(cmd: str) -> bool:
 def is_flatpak_steam_running() -> bool:
     if has_cmd(FLATPAK_CMD) is False:
         return False
-    proc = subprocess.check_output(
-        [FLATPAK_CMD, "ps", "--columns=application"], text=True
-    )
+    proc = subprocess.check_output([FLATPAK_CMD, "ps"], text=True)
     lines = proc.splitlines()
     if FLATPAK_APPID in lines:
         return True

dzgui/managers/connection.py

@@ -48,7 +48,7 @@ from dzgui.strings.dialogs import (
 )
 from dzgui.strings import kb
 from dzgui.strings.server_mods import checkmark, resync
-from dzgui.util.format import format_exception, format_mib
+from dzgui.util.format import format_mib
 from dzgui.util.strings import dialog, server_timeout
 from dzgui.util.symlink import rebuild_symlinks
 from dzgui.views.dialogs.generic import ExceptionDialog
@@ -184,8 +184,8 @@ class ConnectionManager:
         else:
             allows_downloads = (True, "")
 
+        client_name = self.controller.get_steam_client_name()
         client = self.controller.query_config(Preferences.CLIENT)
-        client_name = self.controller.get_steam_client_name(client)
         running = is_steam_running(client)
         steam_proc = SteamProcess(client_name, running)
         self.client = client
@@ -300,11 +300,6 @@ class ConnectionManager:
         dialog = ServerDetailsDialog(self.controller, details)
         dialog.run()
 
-    def _workshop_timeout(self, msg: str) -> None:
-        dialog = ExceptionDialog(self.controller, msg)
-        dialog.show_all()
-        dialog.run()
-
     def _server_timeout(self) -> None:
         dialog = ExceptionDialog(self.controller, server_timeout)
         dialog.set_details_buffer(kb.DZG_006)
@@ -356,14 +351,8 @@ class ConnectionManager:
         for title, mod, stamp, size in self.missing_mods:
             if self.controller.is_cancel_pending():
                 return
-            try:
-                subscribe(key, int(mod))
-                time.sleep(API_RATE_LIMIT)
-            except Exception as e:
-                msg = format_exception(e)
-                func = StoredFunc(self._workshop_timeout, msg)
-                self.thread_man.set_cleanup_func(func, destroy_first=True)
-                return
+            subscribe(key, int(mod))
+            time.sleep(API_RATE_LIMIT)
 
         self.thread_man.update_dialog(waiting_for_directories)
         for title, mod, stamp, size in self.missing_mods:

dzgui/managers/mods.py

@@ -122,11 +122,7 @@ class ModManager:
     def unsub_atomic_mod(self, mod: str) -> None:
         config_man = self.controller.get_config_man()
         key = config_man.lookup(Preferences.STEAM)
-        try:
-            unsubscribe(key, int(mod))
-        except Exception as e:
-            logger.critical(e)
-            return
+        unsubscribe(key, int(mod))
 
         steam_path = Path(self.path)
         app_path = PeFile.get_nested_app_path(steam_path, APPID_DAYZ)

dzgui/strings/connect_panel.py

@@ -1,22 +1,20 @@
-from dzgui.const.constants import UDP_PORT
-
-add_button = "Add"
-add_con_heading = "Add/connect"
+add_button="Add"
+add_con_heading="Add/connect"
 add_popover = "This address is already in your Saved Servers"
-add_tooltip = "Add to Saved Servers"
-connect_button = "Connect"
-connect_tooltip = "Connect to this server"
-connect_entry_placeholder = f"Enter IP:Query port (e.g., 192.168.1.1:{UDP_PORT})"
+add_tooltip="Add to Saved Servers"
+connect_button="Connect"
+connect_tooltip="Connect to this server"
+connect_entry_placeholder="Enter IP:Query port (e.g., 192.168.1.1:27016)"
 
-fav_heading = "Favorite server"
-favs_empty = "None set. Right click a server and select 'Set favorite' to set."
+fav_heading="Favorite server"
+favs_empty="None set. Right click a server and select 'Set favorite' to set."
 
-lan_heading = "LAN query port"
-lan_default_button = f"Default port ({UDP_PORT})"
-lan_custom_button = "Custom port"
-lan_scan_button = "Scan"
+lan_heading="LAN query port"
+lan_default_button="Default port (27016)"
+lan_custom_button="Custom port"
+lan_scan_button="Scan"
 lan_abort_tooltip = "Unless you have multiple DayZ servers on your LAN,\nleave this checked to get results faster"
 lan_checkbox = "Stop scanning on first hit"
-lan_entry_placeholder = "Enter the query port (1-65535)"
-lan_entry_tooltip = "Specify the port to search for DayZ servers on the local network"
-lan_scan_tooltip = "Scan for servers"
+lan_entry_placeholder="Enter the query port (1-65535)"
+lan_entry_tooltip="Specify the port to search for DayZ servers on the local network"
+lan_scan_tooltip="Scan for servers"

dzgui/strings/errors.py

@@ -4,4 +4,3 @@ api_validation_error = (
 
 api_popover = "API key validation failed."
 dayz_not_found = "Could not find a valid DayZ installation."
-workshop_endpoint_error = "Steam Workshop service unavailable, try again later."

dzgui/strings/preconnect.py

@@ -11,6 +11,8 @@ mods = "Mods"
 total_mods = "Total mods: "
 up_to_date = "All mods are up to date."
 all_updated = "All mods updated."
+"If you recently installed {build} or moved it to a different drive, "
+"restart Steam to allow these changes to synchronize, then try again."
 required_space = " Need to download {0} MiB of mod updates."
 
 placeholder_no_mods = "This server has no mods."
@@ -34,7 +36,6 @@ steam_not_running = "'{0}' is set as the default Steam client, but it is either
 use_desktop_mode = "Use Desktop Mode to download mods on Steam Deck."
 version_mismatch = "Local client version '{0}' does not match remote version '{1}'."
 version_missing = "Remote server is running the build '{0}', but it is not installed."
-no_errors = "No errors."
 
 
 # Warnings

dzgui/strings/uninstall.py

@@ -30,8 +30,7 @@ path_remove_prefix = "The following path will be removed:"
 not_installed = "It looks like DZGUI was not previously set up; nothing to uninstall."
 standalone_uninstall = (
     "It looks like you are running the standalone version of DZGUI.\n"
-    "To finalize the uninstall process, invoke './dzgui self remove',\n"
-    "then remove the 'dzgui' file."
+    "To finalize the uninstall process, you can remove the 'dzgui' file."
 )
 system_uninstall = (
     "It looks like DZGUI was installed via your system package manager or directly from source code.\n"

dzgui/util/symlink.py

@@ -2,12 +2,7 @@ import logging
 from pathlib import Path
 
 from dzgui.api.mods import get_local_mod_path, get_local_mod_ids, _hash
-from dzgui.const.constants import (
-    APPID_DAYZ,
-    APPID_DAYZ_EXP,
-    APP_NAME,
-    DAYZ_COMMUNITY_ROOT,
-)
+from dzgui.const.constants import APPID_DAYZ, APPID_DAYZ_EXP, APP_NAME, DAYZ_COMMUNITY_ROOT
 from dzgui.const.enum import Preferences
 from dzgui.config.query import lookup
 
@@ -25,7 +20,6 @@ def expunge_link(file: Path) -> None:
     if str(file.stem)[:2] == "@C":
         file.unlink()
 
-
 def rebuild_symlinks(config: Path) -> None:
     # TODO: pass direct path as argument
     path = lookup(config, Preferences.DEFAULT)
@@ -69,9 +63,10 @@ def symlink_mission(steam_path: Path, target: str) -> str:
     stem = path.name
     parent = path.parent
     source = dayz_path.joinpath(DAYZ_COMMUNITY_ROOT)
-    if source.exists():
-        source.unlink()
-    source.symlink_to(parent)
+    try:
+        source.symlink_to(parent)
+    except Exception:
+        return ""
     return f"{DAYZ_COMMUNITY_ROOT}/{stem}"
 
 

dzgui/views/base.py

@@ -1,5 +1,6 @@
 import logging
 import signal
+import warnings
 
 from typing import TYPE_CHECKING, Literal, Self
 
@@ -46,6 +47,10 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(APP_NAME)
 
+# TODO: drop
+# https://bugzilla.gnome.org/show_bug.cgi?id=708676
+warnings.filterwarnings("ignore", ".*g_value_get_int", Warning)
+
 
 class OuterWindow(Gtk.ApplicationWindow):
     def __init__(self, app: Gtk.Application) -> None:
@@ -339,6 +344,8 @@ try:
     theme = Gtk.IconTheme.get_default()
     icons = theme.list_icons(None)
     if STEAM_ICON not in icons:
-        logger.warning(strings.steam_icon_missing)
+        logger.warn(strings.steam_icon_missing)
+        warnings.warn(strings.steam_icon_missing, stacklevel=2)
 except Exception as e:
     logger.warning(e)
+    warnings.warn(strings.gtk_theme_missing, stacklevel=2)

dzgui/views/components/icon.py

@@ -9,6 +9,3 @@ class Icon(Gtk.Image):
         super().__init__(
             icon_name=name, icon_size=Gtk.IconSize.BUTTON, margin_start=l_margin
         )
-
-    def set_icon_name(self, name: str) -> None:
-        super().set_from_icon_name(name, Gtk.IconSize.BUTTON)

dzgui/views/components/misc.py

@@ -15,7 +15,7 @@ class ClientCombo(Gtk.ComboBox):
         super().__init__()
 
         self.client_store = Gtk.ListStore(str, str)
-        self.clients = (
+        clients = (
             (
                 options.steam_combo,
                 STEAM_CMD,
@@ -29,7 +29,7 @@ class ClientCombo(Gtk.ComboBox):
                 FLATPAK_SANDBOX,
             ),
         )
-        for client in self.clients:
+        for client in clients:
             self.client_store.append(client)
         self.set_model(self.client_store)
         renderer_text = Gtk.CellRendererText()
@@ -37,13 +37,6 @@ class ClientCombo(Gtk.ComboBox):
         self.add_attribute(renderer_text, "text", 0)
         self.set_active(0)
 
-    def get_client_human_readable(self, cmd: str) -> str:
-        for client in self.clients:
-            human, command = client
-            if command == cmd:
-                return human
-        raise TypeError("Not a valid Steam client selection")
-
 class ErrorPopover(Gtk.Popover):
     def __init__(self, relative_to: Gtk.Widget, position: Gtk.PositionType) -> None:
         super().__init__(relative_to=relative_to, position=position)

dzgui/views/dialogs/boot.py

@@ -102,7 +102,7 @@ class BootDialog(ColorAwareApp, Gtk.Dialog):  # type: ignore
             margin_top=30,
             margin_bottom=30,
         )
-        self.error_label = Gtk.Label(margin_start=15, margin_end=15)
+        self.error_label = Gtk.Label()
 
         # TODO: abstract class
         self.copy_button = ClipboardButton(None, lambda: self.error_label.get_text())

dzgui/views/dialogs/calc.py

@@ -3,19 +3,17 @@ from dataclasses import dataclass
 from datetime import datetime, time, timedelta
 from typing import Literal
 
-from dzgui.const.constants import DAY_ICON, NIGHT_ICON
-from dzgui.strings import calc
-from dzgui.views.components.icon import Icon
 from dzgui.views.components.labels import BoldLabel
-from dzgui.views.components.box import VBox, HBox
+from dzgui.strings import calc
+from dzgui.views.components.box import VBox
 
 gi.require_version("Gtk", "3.0")
 from gi.repository import Gtk, GLib, GObject  # type: ignore  # noqa E402
 
 DAY_START_TIME = time(hour=6, minute=0, second=0)
-DAY_END_TIME = time(hour=18, minute=0, second=0)
+DAY_END_TIME = time(hour=17, minute=59, second=59)
 NIGHT_START_TIME = time(hour=18, minute=0, second=0)
-NIGHT_END_TIME = time(hour=6, minute=0, second=0)
+NIGHT_END_TIME = time(hour=5, minute=59, second=59)
 EXTENDED_TIME_FORMAT = "%H:%M:%S"
 
 
@@ -46,10 +44,6 @@ class Emitter(GObject.GObject):
     def target_time_changed(self, time: timedelta) -> None:
         pass
 
-    @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, arg_types=(object,))
-    def target_time_reset(self, time: timedelta) -> None:
-        pass
-
     @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, arg_types=(object,))
     def remaining_time_changed(self, time: datetime) -> None:
         pass
@@ -63,7 +57,6 @@ class LocalClock:
     def __init__(self, emitter: Emitter) -> None:
         self.emitter = emitter
         self.start_time = datetime.now()
-        # NOTE: highest theoretical accel interval is 24 * 64
         GLib.timeout_add(500, self.check_time)
 
     def get_time(self) -> str:
@@ -94,80 +87,131 @@ class ServerClock:
         self.start_time = datetime.combine(datetime.today(), time(hour, minute))
         self.cur_time = datetime.combine(datetime.today(), time(hour, minute))
 
-        self._last_elapsed = self.local_clock.get_elapsed_time()
-        self.emitter.connect("local_time_incremented", self._on_local_time_incremented)
+        # NOTE: at highest possible accel interval (64 * 64), real time is 0.876 seconds
+        if self.is_night():
+            GLib.timeout_add(500, self.increment_night)
+        else:
+            GLib.timeout_add(500, self.increment_day)
 
     @staticmethod
     def split_time(server_time: Time) -> tuple[int, int]:
         split = server_time.time.split(":")
         return int(split[0]), int(split[1])
 
-    def is_day(self) -> bool:
-        if DAY_START_TIME <= self.cur_time.time() <= DAY_END_TIME:
-            return True
-        return False
-
-    def _on_local_time_incremented(
-        self,
-        emitter: Emitter,
-        time: datetime,
-        elapsed: timedelta,
-    ) -> Literal[True]:
-        delta = elapsed - self._last_elapsed
-        self._last_elapsed = elapsed
-        factor = self.get_accel_factor(self.cur_time)
-        self.cur_time += delta * factor
+    def _increment_with_offset(self, offset: float) -> None:
+        elapsed = self.local_clock.get_elapsed_time()
+        virtual_elapsed = elapsed * offset
+        self.cur_time = self.start_time + virtual_elapsed
         self.emitter.emit("server_time_incremented", self.cur_time)
+
+    def increment_day(self) -> bool:
+        if self.is_night():
+            GLib.timeout_add(500, self.increment_night)
+            return False
+        offset = self.day_accel
+        self._increment_with_offset(offset)
         return True
 
-    def get_accel_factor(self, dt: datetime) -> float:
+    def increment_night(self) -> bool:
+        if not self.is_night():
+            GLib.timeout_add(500, self.increment_day)
+            return False
+        offset = self.night_accel * self.day_accel
+        self._increment_with_offset(offset)
+        return True
+
+    def is_night(self) -> bool:
         return (
-            self.day_accel
-            if DAY_START_TIME <= dt.time() < DAY_END_TIME
-            else (self.night_accel * self.day_accel)
+            self.cur_time.time() >= NIGHT_START_TIME
+            or self.cur_time.time() <= NIGHT_END_TIME
         )
 
     def get_values(self) -> tuple[int, int]:
         return self.cur_time.hour, self.cur_time.minute
 
-    def get_datetime(self) -> datetime:
-        return self.cur_time
-
     def get_time(self) -> time:
         return self.cur_time.time()
 
-    def calc_delta(self, end_time: datetime) -> timedelta:
-        total = 0.0
-        current_time = self.cur_time
+    def get_cycle_remainder(self, accel: bool = True) -> float:
+        # NOTE: calc from cycle start time to current point
+        if self.is_night():
+            cutoff = DAY_START_TIME
+            offset = self.day_accel * self.night_accel
+        else:
+            cutoff = NIGHT_START_TIME
+            offset = self.day_accel
+        start = datetime.combine(self.cur_time, cutoff)
 
-        if current_time > end_time:
-            end_time += timedelta(days=1)
+        if accel is False:
+            offset = 1
+        return (start - self.cur_time).total_seconds() / offset
 
-        while current_time < end_time:
-            factor = self.get_accel_factor(current_time)
-            day_start = datetime.combine(current_time.date(), DAY_START_TIME)
-            day_end = datetime.combine(current_time.date(), DAY_END_TIME)
+    def get_full_cycle(self, end_time: time, start_time: time) -> float:
+        end = datetime.combine(self.cur_time, end_time)
+        start = datetime.combine(self.cur_time, start_time)
+        if start > end:
+            end += timedelta(days=1)
+        return (end - start).total_seconds()
 
-            if current_time.time() < DAY_START_TIME:
-                edge = day_start
-            elif current_time.time() < DAY_END_TIME:
-                edge = day_end
+    def get_day_cycle(self) -> float:
+        return self.get_full_cycle(DAY_END_TIME, DAY_START_TIME)
+
+    def get_night_cycle(self) -> float:
+        return self.get_full_cycle(NIGHT_END_TIME, NIGHT_START_TIME)
+
+    def get_delta(self, picker_time: time, start_time: time) -> float:
+        start = datetime.combine(self.cur_time, start_time)
+        picker_date = datetime.combine(self.cur_time, picker_time)
+        if start > picker_date:
+            picker_date += timedelta(days=1)
+        delta = (picker_date - start).total_seconds()
+        return delta
+
+    def get_next_cycle(self) -> float:
+        if self.is_night():
+            return self.get_day_cycle() / self.day_accel
+        else:
+            return self.get_night_cycle() / (self.day_accel * self.night_accel)
+
+    def get_remaining_delta(self, picker_time: time, is_night: bool) -> float:
+        if is_night:
+            start_time = NIGHT_START_TIME
+            offset = self.day_accel * self.night_accel
+        else:
+            start_time = DAY_START_TIME
+            offset = self.day_accel
+        return self.get_delta(picker_time, start_time) / offset
+
+    def calc_delta(self, picker_time: time, is_night: bool) -> timedelta:
+        # NOTE: time spans two full cycles
+        if self.get_time() > picker_time:
+            to_end = self.get_cycle_remainder()
+            next_cycle = self.get_next_cycle()
+            delta = self.get_remaining_delta(picker_time, is_night)
+            total = to_end + next_cycle + delta
+        else:
+            picker_date = datetime.combine(self.cur_time, picker_time)
+            # NOTE: strip sub-minute values
+            new = self.cur_time.replace(second=0, microsecond=0)
+            delta = (picker_date - new).total_seconds()
+            remainder_till_cycle_end = self.get_cycle_remainder(accel=False)
+            if delta <= remainder_till_cycle_end:
+                if self.is_night():
+                    total = delta / (self.day_accel * self.night_accel)
+                else:
+                    total = delta / self.day_accel
             else:
-                edge = datetime.combine(
-                    current_time.date() + timedelta(days=1), DAY_START_TIME
-                )
+                total = self.get_remaining_delta(picker_time, is_night)
 
-            chunk_end = min(end_time, edge)
-            total += (chunk_end - current_time).total_seconds() / factor
-            current_time = chunk_end
-        return timedelta(seconds=total)
+        total = round(total)
+        td = timedelta(seconds=total)
+        return td
 
 
 class RemainderClock:
     def __init__(self, emitter: Emitter) -> None:
         self.emitter = emitter
         self.emitter.connect("target_time_changed", self._on_target_time_changed)
-        self.emitter.connect("target_time_reset", self._on_target_time_reset)
         self.emitter.connect("local_time_incremented", self._on_local_time_incremented)
         self.reset_time(True)
 
@@ -194,14 +238,8 @@ class RemainderClock:
         self.previous = elapsed
         self.emitter.emit("remaining_time_changed", self.time)
 
-    def _on_target_time_reset(self, emitter: Emitter, time: timedelta) -> None:
-        self.reset_time(True)
-        self.emitter.emit("remaining_time_changed", self.time)
-        # NOTE: restore adjusted time to current time
-        self.emitter.emit("adjusted_local_time_changed", datetime.now())
-
     def _on_target_time_changed(self, emitter: Emitter, time: timedelta) -> None:
-        self.reset_time(True)
+        self.reset_time()
         self.time += time
         self.emitter.emit("remaining_time_changed", self.time)
 
@@ -283,29 +321,23 @@ class TimePicker(Gtk.Box):
     def get_minute(self) -> int:
         return int(self.minute_spin.get_adjustment().get_value())
 
-    def get_time(self) -> datetime:
-        """
-        NOTE: interpolating seconds/microseconds from the current time
-        may prevent abrupt visual changes when setting a new TimePicker time
-        while a clock tick is updating the local remainder label.
-        However, this can introduce false negatives when running tests due to microsecond drift.
-        Ideally, tests should be decoupled from this logic.
-        """
+    def get_time(self) -> time:
         d = datetime.now()
-        return datetime.combine(
-            d,
-            time(
-                hour=self.get_hour(),
-                minute=self.get_minute(),
-                second=0,
-                microsecond=0,
-            ),
+        return time(
+            hour=self.get_hour(),
+            minute=self.get_minute(),
+            second=d.second,
+            microsecond=d.microsecond,
         )
 
     def set_time(self, hour: int, minute: int) -> None:
         self.hour_spin.get_adjustment().set_value(hour)
         self.minute_spin.get_adjustment().set_value(minute)
 
+    def is_night(self) -> bool:
+        t = self.get_time()
+        return t >= NIGHT_START_TIME or t <= NIGHT_END_TIME
+
 
 class AdjustedTimeFrame(Gtk.Frame):
     def __init__(self, emitter: Emitter) -> None:
@@ -385,13 +417,6 @@ class TimePickerFrame(Gtk.Frame):
         h1 = BoldLabel(calc.heading_server_time)
         h2 = BoldLabel(calc.heading_target_time)
 
-        self.icon_indicator = Icon(DAY_ICON)
-        self.update_server_icon()
-
-        server_time_box = HBox(10)
-        server_time_box.set_halign(Gtk.Align.CENTER)
-        server_time_box.extend([self.server_timelabel, self.icon_indicator])
-
         flowbox = Gtk.FlowBox(
             row_spacing=10,
             column_spacing=50,
@@ -405,19 +430,14 @@ class TimePickerFrame(Gtk.Frame):
         flowbox.add(h1)
         flowbox.add(h2)
         flowbox.add(self.local_timelabel)
-        flowbox.add(server_time_box)
+        flowbox.add(self.server_timelabel)
         flowbox.add(self.picker)
 
         self.add(flowbox)
 
-    def update_server_icon(self) -> None:
-        icon = DAY_ICON if self.server_time.is_day() else NIGHT_ICON
-        self.icon_indicator.set_icon_name(icon)
-
     def _on_server_clock_increment(self, emitter: Emitter, time_now: datetime) -> None:
         t = time_now.time().strftime("%H:%M")
         self.server_timelabel.set_text(t)
-        self.update_server_icon()
 
     def _on_local_clock_increment(
         self, emitter: Emitter, time_now: datetime, elapsed: timedelta
@@ -428,11 +448,11 @@ class TimePickerFrame(Gtk.Frame):
     def _on_calculate_button_clicked(self, button: Gtk.Button) -> None:
         if (self.picker.get_values()) == (self.server_time.get_values()):
             total_time = timedelta(seconds=0)
-            self.emitter.emit("target_time_reset", total_time)
         else:
             picker_time = self.picker.get_time()
-            total_time = self.server_time.calc_delta(picker_time)
-            self.emitter.emit("target_time_changed", total_time)
+            is_night = self.picker.is_night()
+            total_time = self.server_time.calc_delta(picker_time, is_night)
+        self.emitter.emit("target_time_changed", total_time)
 
 
 class ServerTimeCalculator(Gtk.ScrolledWindow):

dzgui/views/pages/options.py

@@ -76,7 +76,7 @@ class SubmitField(Gtk.Box):
             self.button = Gtk.Button(label=options.save_button)
 
         self.button.connect("clicked", self._on_save_clicked)
-        self.entry.connect("changed", self._on_text_typed)
+        self.entry.connect("insert-text", self._on_text_typed)
         self.entry.connect("activate", self._on_field_activated)
         self.entry.get_property("buffer").connect("deleted-text", self._on_text_deleted)
 
@@ -113,9 +113,13 @@ class SubmitField(Gtk.Box):
     def _on_text_typed(
         self,
         entry: Gtk.Entry,
+        text: str,
+        length: int,
+        pos: int,
     ) -> None:
 
-        text = entry.get_text()
+        buffer = entry.get_property("buffer")
+        text = buffer.get_text() + text
         state = self._is_valid_text(text)
         self.button.set_sensitive(state)
 
@@ -367,8 +371,10 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
 
         self.connect("key-press-event", self._on_keypress)
 
-    def get_client_name(self, cmd: str) -> str:
-        return self.client_combo.get_client_human_readable(cmd)
+    def get_client_name(self) -> str:
+        model = self.client_combo.get_model()
+        ind = self.client_combo.get_active()
+        return str(model[ind][0])
 
     def block_text_entry(self) -> None:
         self.steam_box.block_text_entry()

dzgui/views/pages/preconnect.py

@@ -176,7 +176,8 @@ class PreConnectionAssistant(Gtk.Box):
 
         self.error_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
         self.error_tree = MaskedTree(ERROR)
-        self.error_placeholder = Placeholder(preconnect.no_errors)
+        # TODO: strings
+        self.error_placeholder = Placeholder("No errors.")
         self.error_box.add(self.error_tree)
         self.error_box.add(self.error_placeholder)
         self.error_frame = HeadingFrame.new_with_widget_and_label(

dzgui/views/trees/tree_servers.py

@@ -252,6 +252,7 @@ class ServerTreeView(ContextMixin, TreeView):  # type: ignore
                 case Gdk.KEY_c:
                     self.controller.menu_action(ContextMenu.COPY_SERVER_IP, self)
                 case Gdk.KEY_r:
+                    # TODO: unimplemented, needs threading
                     self.controller.menu_action(ContextMenu.REFRESH_PLAYERS, self)
         else:
             match event.keyval:

pyproject.toml

@@ -4,7 +4,7 @@ description = "DayZ server browser and mod manager for Linux"
 authors = [
     {name = "aclist"}
 ]
-version = "7.0.0b27"
+version = "7.0.0b23"
 license = "GPL-3.0-or-later"
 license-files = ["LICENSE"]
 readme = "README.md"
@@ -47,7 +47,6 @@ docs = [
 ]
 test = [
     "black==25.1.0",
-    "hypothesis==6.167.1",
     "pre-commit==4.4.0",
     "pytest==8.4.2",
     "pytest-cov==7.0.0",

tests/test_html_escaping.py

@@ -22,14 +22,9 @@ class MockController:
 
 
 def test_html_escaping() -> None:
-    name = "Test server"
-    desc = "<Server description> Game & mods"
-    gametime = "05:30"
-    day_accel = 5.0
-    night_accel = 1.0
-    details = Details([["0", "1"]], name, desc, gametime, day_accel, night_accel)
+    text = "<Server description> Game & mods"
+    details = Details([["0", "1"]], text, True)
     controller = MockController()
     dialog = ServerDetailsDialog(controller, details)
-    dialog.destroy()
 
-    assert dialog.description.get_text() == desc
+    assert dialog.description.get_text() == text

tests/test_process_detection.py

@@ -1,61 +0,0 @@
-import unittest
-from unittest.mock import patch
-
-from dzgui.const.constants import (
-    FLATPAK_APPID,
-    FLATPAK_RUN_CMD,
-    FLATPAK_SANDBOX,
-    STEAM_CMD,
-)
-from dzgui.init import proc
-
-
-class TestSteamDetection(unittest.TestCase):
-    def test_flatpak_detection_with_multiple_running_apps(self):
-        def flatpak_output(args, *, text):
-            # Default `flatpak ps` includes instance, PID, app and runtime columns.
-            if args == ["flatpak", "ps", "--columns=application"]:
-                return f"com.spotify.Client\n{FLATPAK_APPID}\n{FLATPAK_APPID}\n"
-            return f"3904921611\t1257689\t{FLATPAK_APPID}\torg.freedesktop.Platform\n"
-
-        with (
-            patch.object(proc, "has_cmd", return_value=True),
-            patch.object(proc.subprocess, "check_output", side_effect=flatpak_output),
-        ):
-            for client in (FLATPAK_RUN_CMD, FLATPAK_SANDBOX):
-                with self.subTest(client=client):
-                    self.assertTrue(proc.is_steam_running(client))
-
-    def test_flatpak_not_running(self):
-        with patch.object(proc, "has_cmd", return_value=True):
-            for output in ("", "com.spotify.Client\n", f"{FLATPAK_APPID}Helper\n"):
-                with (
-                    self.subTest(output=output),
-                    patch.object(proc.subprocess, "check_output", return_value=output),
-                ):
-                    self.assertFalse(proc.is_flatpak_steam_running())
-
-    def test_flatpak_not_installed(self):
-        with (
-            patch.object(proc, "has_cmd", return_value=False),
-            patch.object(proc.subprocess, "check_output") as check_output,
-        ):
-            self.assertFalse(proc.is_flatpak_steam_running())
-            check_output.assert_not_called()
-
-    def test_native_steam(self):
-        with patch.object(proc, "has_cmd", return_value=True):
-            for running in (True, False):
-                with (
-                    self.subTest(running=running),
-                    patch.object(proc, "is_running", return_value=running),
-                ):
-                    self.assertEqual(proc.is_steam_running(STEAM_CMD), running)
-
-    def test_native_steam_while_flatpak_is_running(self):
-        with patch.object(proc, "is_flatpak_steam_running", return_value=True):
-            self.assertEqual(proc.is_steam_running(STEAM_CMD), False)
-
-    def test_invalid_client(self):
-        with self.assertRaises(TypeError):
-            proc.is_steam_running("invalid-client")

tests/test_server_time.py

@@ -1,112 +0,0 @@
-import pytest
-
-from hypothesis import given, strategies as st
-from datetime import datetime, timedelta
-
-from dzgui.views.dialogs.calc import (
-    LocalClock,
-    ServerClock,
-    Time,
-    TimePicker,
-    DAY_START_TIME,
-    DAY_END_TIME,
-)
-
-
-class DummyEmitter:
-    def __init__(self) -> None:
-        pass
-
-    def connect(self, _, __) -> None:
-        pass
-
-
-@pytest.fixture(params=[("05:00", 10.0), ("15:30", 5.0)])
-def accel_server_clock(request) -> None:
-    clock_time, expect = request.param
-    cur_time = Time(clock_time, 5.0, 2.0)
-    emitter = DummyEmitter()
-    local_clock = LocalClock(emitter)
-    server_clock = ServerClock(cur_time, emitter, local_clock)
-    return expect, server_clock
-
-
-def test_accel_factor(accel_server_clock) -> None:
-    """Static test checking times at known boundaries"""
-    expect, clock = accel_server_clock
-    assert clock.get_accel_factor(clock.cur_time) == expect
-
-
-def reference_calc(start, end, day_factor, night_factor):
-    """
-    Reference implementation to test validity of UI-side calculator
-    Aggregates total seconds and applies accel factors after
-    """
-    day_start = datetime.combine(start.date(), DAY_START_TIME)
-    day_end = datetime.combine(start.date(), DAY_END_TIME)
-    night_factor = day_factor * night_factor
-
-    if end < start:
-        end += timedelta(days=1)
-
-    day_max = max(start, day_start)
-    day_min = min(end, day_end)
-
-    next_day_start = datetime.combine(end.date(), DAY_START_TIME)
-    next_day_end = datetime.combine(end.date(), DAY_END_TIME)
-
-    range1 = (day_end - day_max).total_seconds()
-    range2 = (min(end, next_day_end) - next_day_start).total_seconds()
-
-    if end.date() > start.date():
-        day_seconds = max(0, range1) + max(0, range2)
-    else:
-        day_seconds = max(0, (day_min - day_max).total_seconds())
-
-    total_seconds = (end - start).total_seconds()
-    night_seconds = (total_seconds - day_seconds) / night_factor
-    day_seconds = day_seconds / day_factor
-    total = night_seconds + day_seconds
-
-    return timedelta(seconds=total)
-
-
-day_accel = st.floats(
-    min_value=1.0, max_value=24.0, allow_nan=False, allow_infinity=False
-)
-night_accel = st.floats(
-    min_value=1.0, max_value=64.0, allow_nan=False, allow_infinity=False
-)
-
-
-@st.composite
-def time_ranges(draw):
-    start_time = draw(st.times())
-    deltas = st.timedeltas(min_value=timedelta(0), max_value=timedelta(days=1))
-    duration = draw(deltas)
-
-    start = datetime.combine(datetime.now(), start_time)
-    end = start + duration
-    return start, end
-
-
-@given(span=time_ranges(), day_factor=day_accel, night_factor=night_accel)
-def test_time_aggregation(span, day_factor, night_factor) -> None:
-    start, end = span
-
-    strtime = start.strftime("%H:%M")
-    t = Time(strtime, day_factor, night_factor)
-    emitter = DummyEmitter()
-    local_clock = LocalClock(emitter)
-    server_clock = ServerClock(t, emitter, local_clock)
-    h = end.time().hour
-    m = end.time().minute
-    picker = TimePicker(h, m)
-
-    # NOTE: truncates microseconds to mimic widget HH:MM selection behavior
-    start = server_clock.get_datetime()
-    end = picker.get_time()
-    actual = server_clock.calc_delta(end)
-    expect = reference_calc(start, end, day_factor, night_factor)
-
-    assert actual == expect

tests/test_time.py

@@ -1,6 +1,9 @@
 import re
 
 from dzgui.model.proxy_model import DAY_REG, NIGHT_REG
+import pytest
+
+pytestmark = pytest.mark.FOO
 
 def iterate(h: str, r: str) -> None:
     for m in range(60):