chore: update tests

dzgui/api/steam.py

@@ -12,7 +12,6 @@ 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 (
@@ -317,9 +316,10 @@ def unsubscribe(key: str, mod: int) -> None:
     update_workshop(key, mod, UNSUB_ENDPOINT)
 
 
-def validate_mod(client: str, mod: str) -> None:
+@deprecated("Use subscribe()")
+def enqueue_mod(client: str, mod: str, appid: int) -> None:
     client_args = concat_bash_args(client)
-    subprocess.Popen([*client_args, "+workshop_download_item", str(APPID_DAYZ), mod])
+    subprocess.Popen([*client_args, "+workshop_download_item", str(appid), mod])
 
 
 @deprecated("Cf. https://github.com/ValveSoftware/steam-for-linux/issues/9672")
@@ -500,10 +500,3 @@ 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/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 db_path.exists() and month_file.exists():
-        if ips_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,7 +18,6 @@ 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,7 +157,6 @@ 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}
@@ -173,7 +172,7 @@ class ContextMenuGroup(Enum):
     """
 
     SERVER_MOD = (ContextMenu.OPEN_WORKSHOP,)
-    MOD = (ContextMenu.OPEN_WORKSHOP, ContextMenu.UNSUB_MOD, ContextMenu.VALIDATE_MOD)
+    MOD = (ContextMenu.OPEN_WORKSHOP, ContextMenu.UNSUB_MOD)
     MOD_OFFLINE = (None,)
     LOG = (ContextMenu.COPY_LOG_CLIPBOARD,)
     SERVER_BROWSER = (
@@ -247,10 +246,6 @@ 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,16 +102,6 @@ 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/managers/contextmenu.py

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

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, validate_mod
+from dzgui.api.steam import unsubscribe
 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 get_selected_mods(self) -> list[tuple[str, Gtk.TreeIter]]:
+    def unsub_mods(self) -> None:
         sel = self.treeview.get_selection()
         model, pathlist = sel.get_selected_rows()
         # NOTE: reverse when multiple selection
@@ -96,15 +96,6 @@ 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)
 
@@ -118,21 +109,6 @@ 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/strings/dialogs.py

@@ -9,7 +9,6 @@ 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"
 

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)
+            remote = get_coords(prefs.paths.db, remote_ip)
-        except Exception:
+        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_usable(ip: str) -> bool:
-def is_reserved(digits: list) -> bool:
+    address = ip_address(ip)
-    reserved = [0, 10, 127]
+    if address.is_reserved or address.is_private:
-
+        return False
-    if digits[0] in reserved:
+    return True
-        return True
-    if digits[0] == 192 and digits[1] == 168:
-        return True
-    return False
 
 
-def get_coords(ips: "Path", ip: str) -> Coords:
+def get_coords(db_path: "Path", ip: str) -> Coords:
-    split = ip2list(ip)
+    if not is_usable(ip):
-
-    if is_reserved(split):
         raise ReservedIPError(f"{ip} is a reserved IP address.")
-
+    try:
-    prefix = f"^{split[0]}.{split[1]}."
+        lat, lon = read_from_table(db_path, ip)
-
+        return Coords(lat, lon)
-    if shutil.which("rg") is not None:
+    except Exception:
-        args = ["/usr/bin/rg", prefix, str(ips)]
+        raise GeolocationError("No matching records found")
-    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")
 
 
 def get_local_ip() -> str:

dzgui/util/strings.py

@@ -31,7 +31,6 @@ 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"
@@ -201,8 +200,6 @@ class ModPanelStrings:
     clear_highlights: str
     select_stale: str
     select_stale_tooltip: str
-    validate: str
-    validate_tooltip: str
 
 
 @dataclass(slots=True, frozen=True)
@@ -322,8 +319,6 @@ 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/components/mod_panel.py

@@ -50,7 +50,6 @@ class ModSelectionPanel(Gtk.Box):
             ModButton.SELECT_ALL,
             ModButton.UNSELECT_ALL,
             ModButton.UNSUB_SELECTED,
-            ModButton.VALIDATE,
         )
         for button in buttons:
             b = EnumeratedModButton(button)
@@ -115,5 +114,3 @@ 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/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] = []

tests/test_config.py

@@ -36,6 +36,7 @@ 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_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():
+def test_stripping(csv):
-    d = tempfile.TemporaryDirectory()
+    with open(csv, "rb") as f:
-    path = Path(d.name).joinpath("ips.csv")
-    get_ipdb(path)
-    with open(path, "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