From 887667af074ef019a14f944f7495568b4b82ee4b Mon Sep 17 00:00:00 2001 From: bionickatana Date: Sat, 10 Oct 2026 15:28:56 -0600 Subject: [PATCH] Working on fixing crashing --- src/decode/party_memory.py | 11 ++++++- src/decode/world.py | 21 +++++++++---- src/environment.py | 42 ++++++++++++++++++++++++- src/gui/app.py | 32 ++++++++++++++++++- src/gui/modules/views/list_view/list.py | 5 --- tests/test_decode.py | 23 ++++++++++++-- 6 files changed, 118 insertions(+), 16 deletions(-) diff --git a/src/decode/party_memory.py b/src/decode/party_memory.py index c02dae4..d426dc9 100644 --- a/src/decode/party_memory.py +++ b/src/decode/party_memory.py @@ -1,10 +1,12 @@ import json +import logging import os from typing import List from ..utils import platform_utils FILE_NAME = 'last-party.json' +logger = logging.getLogger(__name__) def memory_path() -> str: @@ -19,11 +21,15 @@ def load_last_party() -> List[str]: with open(memory_path(), 'r') as party_file: data = json.load(party_file) except (OSError, json.JSONDecodeError): + logger.debug("no readable remembered party at %s", memory_path()) return [] names = data.get('player_names') if isinstance(data, dict) else None if not isinstance(names, list): + logger.debug("remembered party file has no player_names: %s", memory_path()) return [] - return _clean_names(names) + clean_names = _clean_names(names) + logger.debug("loaded remembered party from %s: %s", memory_path(), clean_names) + return clean_names def save_last_party(names: List[str]): @@ -37,6 +43,7 @@ def save_last_party(names: List[str]): os.makedirs(directory, exist_ok=True) with open(path, 'w') as party_file: json.dump({'player_names': clean_names}, party_file) + logger.debug("saved remembered party to %s: %s", path, clean_names) def clear_last_party(): @@ -46,6 +53,8 @@ def clear_last_party(): pass except OSError: pass + else: + logger.debug("cleared remembered party at %s", memory_path()) def _clean_names(names: List[str]) -> List[str]: diff --git a/src/decode/world.py b/src/decode/world.py index c8f7142..ba04a35 100644 --- a/src/decode/world.py +++ b/src/decode/world.py @@ -1,3 +1,4 @@ +import logging from typing import Dict, List, Optional from .. import environment @@ -9,6 +10,7 @@ from .translate import GameMessage FIX_POINT = 10000.0 FAME_MIN_TOTAL = 1000000 # albion-lens sanity filter for UpdateFame events SILVER_SOURCE_LOOTED = 54 +logger = logging.getLogger(__name__) class IdCache: @@ -150,6 +152,11 @@ class World: else remember_last_party) self._remembered_party_names = (party_memory.load_last_party() if self._remember_last_party else []) + if self._remember_last_party: + logger.debug("remember_last_party enabled; loaded names: %s", + self._remembered_party_names) + else: + logger.debug("remember_last_party disabled; saved party will not autoload") self._zone_candidate_names: List[str] = [] self._explicit_party_seen = False self._party_inferred = False @@ -421,14 +428,16 @@ class World: return self._party_event(event) def _remember_party_event(self, event: Optional[dict]): - if not self._remember_last_party or event is None: + if event is None: return names = event.get('value', {}).get('player_names', []) - self._remembered_party_names = _unique_names(names) - if self._remembered_party_names: - party_memory.save_last_party(self._remembered_party_names) - else: - party_memory.clear_last_party() + remembered_names = _unique_names(names) + if remembered_names: + self._remembered_party_names = remembered_names + party_memory.save_last_party(remembered_names) + elif self._remember_last_party: + self._remembered_party_names = [] + logger.debug("empty party event cleared in-memory party only") def _reset_zone_party_inference(self): self._zone_candidate_names = [] diff --git a/src/environment.py b/src/environment.py index dcc57b3..cdd2c1b 100644 --- a/src/environment.py +++ b/src/environment.py @@ -1,5 +1,7 @@ +import faulthandler import logging import os +import signal import sys from typing import List, Optional @@ -33,6 +35,8 @@ REMEMBER_LAST_PARTY = bool( '--remember-last-party' in sys.argv ) +_fault_file = None + def is_verbose(): return VERBOSE @@ -46,6 +50,12 @@ def remember_last_party(): return REMEMBER_LAST_PARTY +def app_log_path() -> Optional[str]: + if not DISCOVERY_LOG_PATH: + return None + return DISCOVERY_LOG_PATH + '.app.log' + + def qt_args(argv: List[str]) -> List[str]: """Return argv with app-specific options removed before Qt sees them.""" result = [] @@ -83,7 +93,7 @@ def setup_logging(): log_dir = os.path.dirname(DISCOVERY_LOG_PATH) if log_dir: os.makedirs(log_dir, exist_ok=True) - handlers.append(logging.FileHandler(DISCOVERY_LOG_PATH + '.app.log')) + handlers.append(logging.FileHandler(app_log_path())) logging.basicConfig( level=logging.DEBUG, @@ -91,6 +101,36 @@ def setup_logging(): datefmt='%H:%M:%S', handlers=handlers) + _install_crash_diagnostics() + + +def _install_crash_diagnostics(): + global _fault_file + log_path = app_log_path() + _fault_file = None + if log_path: + _fault_file = open(log_path, 'a') + faulthandler.enable(file=_fault_file, all_threads=True) + else: + faulthandler.enable(all_threads=True) + + for sig_name in ('SIGSEGV', 'SIGABRT', 'SIGBUS', 'SIGFPE'): + sig = getattr(signal, sig_name, None) + if sig is None: + continue + try: + faulthandler.register(sig, file=_fault_file, all_threads=True, + chain=True) + except (RuntimeError, ValueError, OSError): + pass + + def excepthook(exc_type, exc, tb): + logging.getLogger(__name__).critical( + "unhandled exception", exc_info=(exc_type, exc, tb)) + sys.__excepthook__(exc_type, exc, tb) + + sys.excepthook = excepthook + class TestType: Simple = 'simple' diff --git a/src/gui/app.py b/src/gui/app.py index 357549a..ebfa200 100644 --- a/src/gui/app.py +++ b/src/gui/app.py @@ -4,6 +4,11 @@ import subprocess import sys import requests +try: + import resource +except ImportError: # pragma: no cover - Windows fallback + resource = None + from PySide6 import QtCore # type: ignore from PySide6.QtCore import Qt # type: ignore from PySide6 import QtGui # type: ignore @@ -14,7 +19,7 @@ from PySide6.QtWidgets import QPushButton # type: ignore from ..engine import InitializationResult from ..engine import initialize from ..utils.config import config -from ..environment import qt_args, setup_logging +from ..environment import is_verbose, qt_args, remember_last_party, setup_logging from .modules.main import MainWidget from .styling import style @@ -30,6 +35,26 @@ sys.path.append(os.path.dirname(os.path.abspath('__file__'))) logger = logging.getLogger(__name__) +def _qt_message_handler(mode, context, message): + logger.debug("qt message[%s] %s:%s %s", mode, context.file, + context.line, message) + + +def _install_heartbeat(app): + if not is_verbose(): + return + timer = QtCore.QTimer(app) + + def heartbeat(): + rss_kb = (resource.getrusage(resource.RUSAGE_SELF).ru_maxrss + if resource else None) + logger.debug("heartbeat pid=%s rss_kb=%s", os.getpid(), rss_kb) + + timer.timeout.connect(heartbeat) + timer.start(10000) + app._aostats_heartbeat_timer = timer + + def fix_network(): script_name = platform_utils.repair_script() if not script_name: @@ -51,6 +76,9 @@ def run(): app_argv = qt_args(sys.argv) logger.info("Albion Online Stats v%s starting", get_current_version()) + logger.debug("pid: %s", os.getpid()) + logger.debug("argv: %s", sys.argv) + logger.debug("remember_last_party: %s", remember_last_party()) logger.debug("python: %s (%s)", sys.executable, sys.version) logger.debug("platform: %s", platform_utils.system()) @@ -69,6 +97,8 @@ def run(): logger.debug("capture permissions probe: %s", perms_ok) app = QApplication(app_argv) + QtCore.qInstallMessageHandler(_qt_message_handler) + _install_heartbeat(app) app.setStyleSheet(style) diff --git a/src/gui/modules/views/list_view/list.py b/src/gui/modules/views/list_view/list.py index 1afdedc..99d2017 100644 --- a/src/gui/modules/views/list_view/list.py +++ b/src/gui/modules/views/list_view/list.py @@ -23,8 +23,6 @@ from .....utils import assets from .....utils import names from .....utils import weapon -from .icon import get_weapon_icon as player_icon - Style = collections.namedtuple('Style', ['bg', 'fg']) enchant_re = re.compile(r"(.*)@(\d+)") @@ -114,11 +112,8 @@ class ListItemView(QListView): player_style(self.player.items).fg)) self.setForeground(brush_fg) - icon = player_icon(self.player.items['weapon']) self.setToolTip('\n'.join( [f'{k}: {map_name(v)}' for (k, v) in self.player.items.items() if v])) - if icon: - self.setIcon(icon) class SortProxyModel(QtCore.QSortFilterProxyModel): def lessThan(self, left, right): diff --git a/tests/test_decode.py b/tests/test_decode.py index cda8b28..84069e1 100644 --- a/tests/test_decode.py +++ b/tests/test_decode.py @@ -444,7 +444,25 @@ def test_party_inference_grows_during_zone_load(monkeypatch, tmp_path): 'rainbowShade', 'bionicKatana', 'fatbrick', 'Froedrick712'] -def test_party_disband_clears_remembered_party(monkeypatch, tmp_path): +def test_party_roster_saves_even_when_autoload_disabled(monkeypatch, tmp_path): + monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path)) + world = World(remember_last_party=False) + + world.transform(game('PartyRoster', { + 9: ['bionicKatana', 'rainbowShade', 'fatbrick', 'Froedrick712'], + })) + + assert party_memory.load_last_party() == [ + 'bionicKatana', 'rainbowShade', 'fatbrick', 'Froedrick712'] + + restarted = World(remember_last_party=True) + events = restarted.transform(game('Join', {0: 98, 2: 'bionicKatana'})) + + assert events[-1]['value']['player_names'] == [ + 'bionicKatana', 'rainbowShade', 'fatbrick', 'Froedrick712'] + + +def test_party_disband_preserves_remembered_party(monkeypatch, tmp_path): monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path)) world = World(remember_last_party=True) @@ -455,7 +473,8 @@ def test_party_disband_clears_remembered_party(monkeypatch, tmp_path): world.transform(game('PartyDisbanded')) - assert party_memory.load_last_party() == [] + assert party_memory.load_last_party() == ['bionicKatana', 'fatbrick'] + assert world.party.last_names == [] def _last_party_names(events):