chore: update placeholder appid

fix: dword parse

dzgui/api/pefile.py

@@ -255,16 +255,28 @@ class PeFileError(Exception):
 
     pass
 
+
 def parse_version_number(data: BinaryIO) -> FileVersion:
     # https://learn.microsoft.com/en-us/windows/win32/api/verrsrc/ns-verrsrc-vs_fixedfileinfo
-    minor = struct.unpack("<L", data.read(4))[0] >> 16 & 0xFFFF
-    major = struct.unpack("<L", data.read(4))[0] >> 0 & 0xFFFF
-    build = struct.unpack("<L", data.read(4))[0] >> 0 & 0xFFFF
-    # NOTE: 0-pad revision number
-    revision = str(struct.unpack("<L", data.read(4))[0] >> 16 & 0xFFFF)
-    offset = 3 - len(revision)
-    padded = "0" * offset + revision
-    return FileVersion(major, minor, build, padded)
+    """
+    Note: structure differs from standard VS_FIXEDFILEINFO
+    Major: lower 16 bits of first DWORD
+    Minor: upper 16 bits of first DWORD
+    Build: lower 16 bits of third DWORD
+    Revision: upper 16 bits of second DWORD, zero-padded
+    Lower 16 bits of revision DWORD appear unused.
+    """
+    major_minor = struct.unpack("<I", data.read(4))[0]
+    revision_pair = struct.unpack("<I", data.read(4))[0]
+    build_dword = struct.unpack("<I", data.read(4))[0]
+
+    major = major_minor & 0xFFFF
+    minor = (major_minor >> 16) & 0xFFFF
+    build = build_dword & 0xFFFF
+    revision = (revision_pair >> 16) & 0xFFFF
+    revision = f"{revision:03d}"
+
+    return FileVersion(major, minor, build, revision)
 
 
 def seek_to_hex(address: str, data: BinaryIO) -> None:

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 3:
+            case 4:
                 dlc = strings.dlc_badlands
             case _:
                 dlc = strings.unspecified

dzgui/api/steam.py

@@ -1,13 +1,14 @@
 import logging
 import os
 import psutil
+import re
 import requests
 import subprocess
 import vdf  # type: ignore
 
 from pathlib import Path
 from requests.exceptions import HTTPError
-from typing import Any, Union
+from typing import Any, Generator, Union
 from warnings import deprecated
 
 from dzgui.api.acf import ACF
@@ -20,6 +21,7 @@ from dzgui.const.constants import (
     DAYZ_LAUNCHER,
     DEBIAN_STEAM_PATH,
     DEFAULT_STEAM_PATH,
+    DOWNLOADS_PATH,
     FLATPAK_STEAM_PATH,
     LIBRARYFOLDERS_PATH,
     UBUNTU_STEAM_PATH,
@@ -265,12 +267,12 @@ def find_user_id_32(path: Path) -> int:
 
 
 class SteamAPIKeyError(Exception):
-    def __init__(self, msg=None):
+    def __init__(self, msg: str | None = None):
         super().__init__(msg or api_validation_error)
 
 
 class SteamWorkshopEndpointError(Exception):
-    def __init__(self, msg=None):
+    def __init__(self, msg: str | None = None):
         super().__init__(msg or workshop_endpoint_error)
 
 
@@ -439,6 +441,22 @@ def is_dayz_running() -> bool:
     return any(s in item for sublist in procs for item in sublist for s in substring)
 
 
+def get_pending_downloads(steam_path: Path, appid: int) -> Generator[Path, None, None]:
+    root_path = get_app_path(steam_path, appid)
+    downloads_dir = root_path / DOWNLOADS_PATH
+    files = downloads_dir.iterdir()
+    return files
+
+
+def is_dayz_downloading(steam_path: Path, appid: int) -> bool:
+    files = get_pending_downloads(steam_path, appid)
+    reg = re.compile(rf"^state_(?:{APPID_DAYZ_EXP}|{APPID_DAYZ})_.*\.patch$")
+    pending = [f for f in files if reg.match(f.name)]
+    if len(pending) > 0:
+        return True
+    return False
+
+
 def get_app_path(folders_path: Path, appid: int) -> Path:
     app_path = None
 

dzgui/const/constants.py

@@ -15,6 +15,7 @@ DAYZ_BINARY = "DayZ_x64.exe"
 DAYZ_LAUNCHER = "DayZLauncher.exe"
 
 LIBRARYFOLDERS_PATH = "steamapps/libraryfolders.vdf"
+DOWNLOADS_PATH = "steamapps/downloading"
 WORKSHOP_PATH = "steamapps/workshop/content/" + str(APPID_DAYZ)
 
 STEAM_CMD = "steam"

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) -> str:
-        return self.mediator.options.get_client_name()
+    def get_steam_client_name(self, cmd: str) -> str:
+        return self.mediator.options.get_client_name(cmd)
 
     def present_window(self) -> None:
         self.mediator.window.present_with_time(Gdk.CURRENT_TIME)

dzgui/init/proc.py

@@ -16,12 +16,15 @@ logger = logging.getLogger(APP_NAME)
 
 
 def is_steam_running(cmd: str) -> bool:
-    if cmd == STEAM_CMD:
+    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 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")
 
@@ -31,7 +34,9 @@ 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"], text=True)
+    proc = subprocess.check_output(
+        [FLATPAK_CMD, "ps", "--columns=application"], text=True
+    )
     lines = proc.splitlines()
     if FLATPAK_APPID in lines:
         return True

dzgui/managers/connection.py

@@ -14,6 +14,7 @@ from dzgui.api.shortcuts import Shortcuts
 from dzgui.api.steam import (
     connect,
     connect_debug,
+    is_dayz_downloading,
     get_app_allows_downloads,
     get_app_name,
     get_needs_update,
@@ -84,6 +85,7 @@ class Prerequisites:
     available_space: float
     passworded: bool
     dayz_running: bool
+    download_paused: bool
     steam_proc: SteamProcess
     mods: list[list[str]]
     game_mode: bool
@@ -169,6 +171,7 @@ class ConnectionManager:
                     free_mib = format_mib(free)
 
         dayz_running = is_dayz_running()
+        download_paused = is_dayz_downloading(steam_path, self.appid)
 
         running_app = get_running_app()
         if running_app is not None:
@@ -184,8 +187,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
@@ -210,6 +213,7 @@ class ConnectionManager:
             available_space=free_mib,
             passworded=info.password_protected,
             dayz_running=dayz_running,
+            download_paused=download_paused,
             steam_proc=steam_proc,
             mods=remote_mods,
             game_mode=game_mode,

dzgui/strings/preconnect.py

@@ -47,3 +47,7 @@ running_app = (
     "Either stop the game first, or update your global Steam settings or the game's local settings.\n"
     "Otherwise, mods may be queued for download but never update."
 )
+downloads_paused = (
+    "It looks like DayZ may have a pending update on Steam that was paused.\n"
+    "To enqueue mods for download, unpause any pending DayZ update and allow it to complete."
+)

dzgui/views/base.py

@@ -1,6 +1,5 @@
 import logging
 import signal
-import warnings
 
 from typing import TYPE_CHECKING, Literal, Self
 
@@ -47,10 +46,6 @@ 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:
@@ -344,8 +339,6 @@ try:
     theme = Gtk.IconTheme.get_default()
     icons = theme.list_icons(None)
     if STEAM_ICON not in icons:
-        logger.warn(strings.steam_icon_missing)
-        warnings.warn(strings.steam_icon_missing, stacklevel=2)
+        logger.warning(strings.steam_icon_missing)
 except Exception as e:
     logger.warning(e)
-    warnings.warn(strings.gtk_theme_missing, stacklevel=2)

dzgui/views/components/misc.py

@@ -15,7 +15,7 @@ class ClientCombo(Gtk.ComboBox):
         super().__init__()
 
         self.client_store = Gtk.ListStore(str, str)
-        clients = (
+        self.clients = (
             (
                 options.steam_combo,
                 STEAM_CMD,
@@ -29,7 +29,7 @@ class ClientCombo(Gtk.ComboBox):
                 FLATPAK_SANDBOX,
             ),
         )
-        for client in clients:
+        for client in self.clients:
             self.client_store.append(client)
         self.set_model(self.client_store)
         renderer_text = Gtk.CellRendererText()
@@ -37,6 +37,13 @@ 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/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("insert-text", self._on_text_typed)
+        self.entry.connect("changed", 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,13 +113,9 @@ class SubmitField(Gtk.Box):
     def _on_text_typed(
         self,
         entry: Gtk.Entry,
-        text: str,
-        length: int,
-        pos: int,
     ) -> None:
 
-        buffer = entry.get_property("buffer")
-        text = buffer.get_text() + text
+        text = entry.get_text()
         state = self._is_valid_text(text)
         self.button.set_sensitive(state)
 
@@ -371,10 +367,8 @@ class Options(ScrollableMixin, Gtk.ScrolledWindow):  # type: ignore
 
         self.connect("key-press-event", self._on_keypress)
 
-    def get_client_name(self) -> str:
-        model = self.client_combo.get_model()
-        ind = self.client_combo.get_active()
-        return str(model[ind][0])
+    def get_client_name(self, cmd: str) -> str:
+        return self.client_combo.get_client_human_readable(cmd)
 
     def block_text_entry(self) -> None:
         self.steam_box.block_text_entry()

dzgui/views/pages/preconnect.py

@@ -279,6 +279,8 @@ class PreConnectionAssistant(Gtk.Box):
             warnings.append(preconnect.protected_server)
         if prereqs.dayz_running is True:
             warnings.append(preconnect.dayz_running)
+        if len(prereqs.mods) > 0 and prereqs.download_paused:
+            warnings.append(preconnect.downloads_paused)
 
         allows_dl, running_app = prereqs.allows_downloads
         if len(prereqs.mods) > 0 and allows_dl is False:

pyproject.toml

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

tests/test_paused_downloads.py

@@ -0,0 +1,27 @@
+import pytest
+from pathlib import Path
+
+from dzgui.api.steam import is_dayz_downloading
+
+
+@pytest.mark.parametrize(
+    "file_list, expect",
+    [
+        (["state_221100_1111.patch"], True),
+        (["state_730_1111.patch"], False),
+        (["state_1024020_1111.patch"], True),
+        (["221100"], False),
+        (["221100", "state_221100_1111.patch"], True),
+        (["state_221100_1111.patch", "state_1024020_1111.patch"], True),
+        (["state_221100_1111"], False),
+    ],
+)
+def test_dayz_patch_pending(monkeypatch, file_list, expect) -> None:
+    def mock_get_pending_downloads(steam_path: Path, appid: int) -> None:
+        files = [Path(file) for file in file_list]
+        return files
+
+    monkeypatch.setattr(
+        "dzgui.api.steam.get_pending_downloads", mock_get_pending_downloads
+    )
+    assert is_dayz_downloading(Path("/tmp"), Path("/tmp")) == expect

tests/test_process_detection.py

@@ -0,0 +1,61 @@
+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

@@ -14,7 +14,11 @@ from dzgui.views.dialogs.calc import (
 
 
 class DummyEmitter:
-    pass
+    def __init__(self) -> None:
+        pass
+
+    def connect(self, _, __) -> None:
+        pass
 
 
 @pytest.fixture(params=[("05:00", 10.0), ("15:30", 5.0)])