a2qlinux 0.2.0__py3-none-any.whl

a2qlinux/__init__.py

@@ -0,0 +1,6 @@
+"""A2Qlinux: Questlog Desktop for AION 2 on Linux under Proton, with live game traffic."""
+
+try:
+    from ._version import __version__
+except ImportError:           # a source checkout that was never built or installed
+    __version__ = "0+unknown"

a2qlinux/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
+
+__commit_id__ = commit_id = None

a2qlinux/config.py

@@ -0,0 +1,148 @@
+"""User settings: ~/.config/a2qlinux/config.toml.
+
+Which value wins, highest first:
+    1. a command-line option        (--interface, --close-with-game, --no-auto-update, --exe)
+    2. an environment variable      (QUESTLOG_DIR)
+    3. this file
+    4. the default in SETTINGS
+
+Only behaviour a user may want to change is here. Values that follow from
+how Questlog or Wine work (how long Questlog needs to save, wait limits) are
+named constants in the code, documented in docs/ARCHITECTURE.md.
+
+Nothing wrong in the file is ignored silently: load() returns each problem
+(file, line, what is wrong) next to the settings, using the default for that
+setting; the launcher shows them in its window and as a notification.
+"""
+
+from dataclasses import dataclass
+import os
+from pathlib import Path
+import re
+import tomllib
+
+CONFIG_PATH = Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config") / "a2qlinux" / "config.toml"
+# Closing Questlog after the game does not wait for it to save, so the delay
+# must cover the time Questlog takes to save game data (see launcher.SAVE_WAIT).
+MIN_AFTER_GAME_DELAY = 10.5
+
+
+@dataclass(frozen=True)
+class Setting:
+    default: object
+    kind: type
+    help: str
+    choices: tuple = ()
+    minimum: float = None
+
+
+SETTINGS = {
+    "questlog_dir": Setting("~/Games/Questlog", str,
+                            "Folder with Questlog.exe (the QUESTLOG_DIR environment variable overrides it)."),
+    "interface": Setting("", str,
+                         "Network interface carrying the game's traffic; empty: the only one besides lo."),
+    "after_game": Setting("keep", str,
+                          '"keep": Questlog stays open after the game, and Steam sees the game as closed; '
+                          '"close": Questlog closes with the game.',
+                          choices=("keep", "close")),
+    "after_game_delay": Setting(15, (int, float),
+                                'With after_game = "close": seconds after the game exits before Questlog closes '
+                                f"(a game restarted sooner keeps it open). At least {MIN_AFTER_GAME_DELAY:g}.",
+                                minimum=MIN_AFTER_GAME_DELAY),
+    "auto_update": Setting(True, bool, "Download new Questlog versions in the background and install them "
+                                       "at the next start."),
+    "update_check_hours": Setting(6, (int, float), "Hours between checks for a new Questlog.", minimum=0.25),
+}
+
+
+@dataclass(frozen=True)
+class Settings:
+    questlog_dir: Path
+    interface: str
+    after_game: str
+    after_game_delay: float
+    auto_update: bool
+    update_check_hours: float
+
+
+def _line_of(text, key):
+    for number, line in enumerate(text.splitlines(), 1):
+        if re.match(rf"\s*{re.escape(key)}\s*=", line):
+            return number
+    return None
+
+
+def load(path=CONFIG_PATH):
+    """(Settings, problems). A missing file is no problem: all defaults."""
+    values = {name: spec.default for name, spec in SETTINGS.items()}
+    problems = []
+    path = Path(path)
+    try:
+        text = path.read_text()
+        data = tomllib.loads(text)
+    except FileNotFoundError:
+        text, data = "", {}
+    except (OSError, UnicodeDecodeError) as error:
+        text, data = "", {}
+        problems.append(f"{path}: cannot be read ({error}); using the defaults.")
+    except tomllib.TOMLDecodeError as error:
+        text, data = "", {}
+        problems.append(f"{path}: not valid TOML ({error}); using the defaults.")
+    for name, value in data.items():
+        where = f"{path}, line {_line_of(text, name) or '?'}"
+        spec = SETTINGS.get(name)
+        if spec is None:
+            problems.append(f"{where}: unknown setting '{name}' (known: {', '.join(SETTINGS)}); ignored.")
+            continue
+        wrong_type = not isinstance(value, spec.kind) or (spec.kind is not bool and isinstance(value, bool))
+        if wrong_type:
+            problems.append(f"{where}: '{name}' must be {_kind_name(spec.kind)}, not {value!r}; "
+                            f"using {spec.default!r}.")
+            continue
+        if spec.choices and value not in spec.choices:
+            problems.append(f"{where}: '{name}' must be one of {', '.join(map(repr, spec.choices))}, "
+                            f"not {value!r}; using {spec.default!r}.")
+            continue
+        if spec.minimum is not None and value < spec.minimum:
+            problems.append(f"{where}: '{name}' must be at least {spec.minimum:g}, not {value!r}; "
+                            f"using {spec.default!r}.")
+            continue
+        values[name] = value
+    env_dir = os.environ.get("QUESTLOG_DIR")
+    values["questlog_dir"] = Path(env_dir or values["questlog_dir"]).expanduser()
+    values["after_game_delay"] = float(values["after_game_delay"])
+    values["update_check_hours"] = float(values["update_check_hours"])
+    return Settings(**values), problems
+
+
+def _kind_name(kind):
+    if kind is bool:
+        return "true or false"
+    if kind is str:
+        return "a quoted text"
+    return "a number"
+
+
+def questlog_dir():
+    """Where Questlog is, for the parts that need only that (the menu entry, the Steam wrapper)."""
+    return load()[0].questlog_dir
+
+
+def template(questlog_dir=None):
+    """The file a2qlinux-setup writes when there is none: every setting, at its default, explained."""
+    lines = ["# A2Qlinux settings. Delete a line to get its default back.",
+             "# A command-line option or the QUESTLOG_DIR variable overrides the value here.", ""]
+    for name, spec in SETTINGS.items():
+        value = str(questlog_dir) if name == "questlog_dir" and questlog_dir else spec.default
+        lines.append(f"# {spec.help}")
+        lines.append(f"{name} = {_toml(value)}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def _toml(value):
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, str):
+        return '"' + value.replace("\\", "\\\\").replace('"', '\\"') + '"'
+    return repr(value)

a2qlinux/desktop.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""Desktop and menu entry point: open the launcher (a2qlinux.launcher) in a terminal, once.
+
+Arguments are passed on to the launcher (a2qlinux.launcher), e.g. --close-with-game.
+
+If the launcher (a2qlinux.launcher) is already running (its lock is held), no second one is
+started; the running one is asked instead, by a signal to the PID in its lock
+file:
+  - from the icon or menu: SIGUSR1, "open Questlog's window" - which also calls
+    off a quit chosen in our tray icon a moment before;
+  - from the Steam launch option (--for-game; the game is starting):
+    SIGUSR2, "keep Questlog running" - calls off such a quit, opens nothing.
+If the launcher was just ending, it lets go of the lock instead of answering;
+a new one is then started here.
+"""
+
+import fcntl
+import os
+from pathlib import Path
+import shutil
+import signal
+import subprocess
+import sys
+import time
+
+from .config import questlog_dir
+
+LOCK = questlog_dir() / "proton-stream" / ".lock"
+
+# Terminals the status window can open in, first found wins, each with the
+# option after which it takes a program and its arguments as separate words
+# (from each one's manual). x-terminal-emulator is Debian's alternative for
+# whichever terminal is installed; Debian policy requires it to take -e so.
+TERMINALS = (
+    ("konsole", ["-e"]),
+    ("gnome-terminal", ["--"]),
+    ("ptyxis", ["--"]),
+    ("xfce4-terminal", ["-x"]),
+    ("mate-terminal", ["-x"]),
+    ("x-terminal-emulator", ["-e"]),
+    ("xterm", ["-e"]),
+)
+
+
+def terminal_command(program, which=shutil.which):
+    """The command that runs `program` (a list of words) in a new terminal window; None without a terminal."""
+    for name, option in TERMINALS:
+        found = which(name)
+        if found:
+            return [found, *option, *program]
+    return None
+
+
+def launcher_running():
+    """True if the launcher (a2qlinux.launcher) holds its lock right now."""
+    try:
+        fd = os.open(LOCK, os.O_RDWR | os.O_CLOEXEC)
+    except FileNotFoundError:
+        return False
+    try:
+        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except BlockingIOError:
+        return True
+    finally:
+        os.close(fd)
+    return False
+
+
+HANDOVER_WAIT = 10   # s for a launcher that was ending to let go of its lock
+
+
+def launcher_pid():
+    """PID of the running the launcher (a2qlinux.launcher), from its lock file; None if it cannot be told.
+
+    Checked against the process's command line, so a stale or reused PID is
+    never signalled.
+    """
+    try:
+        pid = int(LOCK.read_text().strip())
+        command = Path(f"/proc/{pid}/cmdline").read_bytes().split(b"\0")
+    except (OSError, ValueError):
+        return None
+    return pid if b"a2qlinux.launcher" in command else None
+
+
+def ask_running_launcher(game_starting):
+    """Signal the running launcher. True if it answers, False if it has just ended."""
+    pid = launcher_pid()
+    if pid is None:
+        notify("Already running - use its open terminal window.")
+        return True
+    try:
+        os.kill(pid, signal.SIGUSR2 if game_starting else signal.SIGUSR1)
+    except ProcessLookupError:
+        pass
+    deadline = time.monotonic() + HANDOVER_WAIT
+    while time.monotonic() < deadline:
+        if not launcher_running():
+            return False
+        time.sleep(0.2)
+    return True
+
+
+def notify(text):
+    subprocess.run(["notify-send", "--app-name=Questlog (AION 2)",
+                    "--icon=" + str(Path.home() / ".local/share/icons/questlog-aion2.png"),
+                    "Questlog (AION 2)", text], check=False)
+
+
+def main():
+    try:
+        from .setup_desktop import refresh_entries
+        refresh_entries(lambda text: print(f"a2qlinux: {text}", file=sys.stderr))
+    except (OSError, RuntimeError) as error:   # never in the way of starting Questlog
+        print(f"a2qlinux: could not check the menu entry: {error}", file=sys.stderr)
+    # --for-game only tells who is asking; the launcher starts Questlog at once either way.
+    for_game = "--for-game" in sys.argv[1:]
+    options = [arg for arg in sys.argv[1:] if arg != "--for-game"]
+    if launcher_running() and ask_running_launcher(for_game):
+        return 0
+    # The window closes by itself when the launcher ends normally (Questlog
+    # closed after the game); on an error it stays open until Enter, so the
+    # message can be read.
+    # Any arguments (e.g. --close-with-game) are passed on to the launcher (a2qlinux.launcher).
+    script = ('"$0" "$@"; code=$?; if [ $code -ne 0 ]; then echo; '
+              'read -rp "A2Qlinux ended with code $code - press Enter to close. "; fi')
+    command = terminal_command(["bash", "-c", script, sys.executable, "-m", "a2qlinux.launcher", *options])
+    if command is None:
+        message = ("No terminal for the status window was found. Install one of: "
+                   + ", ".join(name for name, _ in TERMINALS) + ".")
+        print(f"a2qlinux: {message}", file=sys.stderr)
+        notify(message)
+        return 1
+    os.execv(command[0], command)
+
+
+if __name__ == "__main__":
+    sys.exit(main())