110 lines
4.5 KiB
Python
110 lines
4.5 KiB
Python
"""
|
|
Shared controller resources module
|
|
|
|
Each of the objects in this module should be instantiated ONCE
|
|
and only ONCE!
|
|
"""
|
|
|
|
import configparser
|
|
import logging
|
|
import os
|
|
from argparse import Namespace
|
|
from typing import Optional, Union
|
|
|
|
from rare.lgndr.core import LegendaryCore
|
|
from rare.models.apiresults import ApiResults
|
|
from rare.models.signals import GlobalSignals
|
|
|
|
logger = logging.getLogger("Singleton")
|
|
|
|
_legendary_core_singleton: Optional[LegendaryCore] = None
|
|
_global_signals_singleton: Optional[GlobalSignals] = None
|
|
_arguments_singleton: Optional[Namespace] = None
|
|
_api_results_singleton: Optional[ApiResults] = None
|
|
|
|
|
|
def LegendaryCoreSingleton(init: bool = False) -> LegendaryCore:
|
|
global _legendary_core_singleton
|
|
if _legendary_core_singleton is None and not init:
|
|
raise RuntimeError("Uninitialized use of LegendaryCoreSingleton")
|
|
if _legendary_core_singleton is not None and init:
|
|
raise RuntimeError("LegendaryCore already initialized")
|
|
if init:
|
|
try:
|
|
_legendary_core_singleton = LegendaryCore()
|
|
except configparser.MissingSectionHeaderError as e:
|
|
logger.warning(f"Config is corrupt: {e}")
|
|
if config_path := os.environ.get("XDG_CONFIG_HOME"):
|
|
path = os.path.join(config_path, "legendary")
|
|
else:
|
|
path = os.path.expanduser("~/.config/legendary")
|
|
with open(os.path.join(path, "config.ini"), "w") as config_file:
|
|
config_file.write("[Legendary]")
|
|
_legendary_core_singleton = LegendaryCore()
|
|
if "Legendary" not in _legendary_core_singleton.lgd.config.sections():
|
|
_legendary_core_singleton.lgd.config.add_section("Legendary")
|
|
_legendary_core_singleton.lgd.save_config()
|
|
# workaround if egl sync enabled, but no programdata_path
|
|
# programdata_path might be unset if logging in through the browser
|
|
if _legendary_core_singleton.egl_sync_enabled:
|
|
if _legendary_core_singleton.egl.programdata_path is None:
|
|
_legendary_core_singleton.lgd.config.remove_option("Legendary", "egl_sync")
|
|
_legendary_core_singleton.lgd.save_config()
|
|
else:
|
|
if not os.path.exists(_legendary_core_singleton.egl.programdata_path):
|
|
_legendary_core_singleton.lgd.config.remove_option("Legendary", "egl_sync")
|
|
_legendary_core_singleton.lgd.save_config()
|
|
return _legendary_core_singleton
|
|
|
|
|
|
def GlobalSignalsSingleton(init: bool = False) -> GlobalSignals:
|
|
global _global_signals_singleton
|
|
if _global_signals_singleton is None and not init:
|
|
raise RuntimeError("Uninitialized use of GlobalSignalsSingleton")
|
|
if _global_signals_singleton is not None and init:
|
|
raise RuntimeError("GlobalSignals already initialized")
|
|
if init:
|
|
_global_signals_singleton = GlobalSignals()
|
|
return _global_signals_singleton
|
|
|
|
|
|
def ArgumentsSingleton(args: Namespace = None) -> Optional[Namespace]:
|
|
global _arguments_singleton
|
|
if _arguments_singleton is None and args is None:
|
|
raise RuntimeError("Uninitialized use of ArgumentsSingleton")
|
|
if _arguments_singleton is not None and args is not None:
|
|
raise RuntimeError("Arguments already initialized")
|
|
if args is not None:
|
|
_arguments_singleton = args
|
|
return _arguments_singleton
|
|
|
|
|
|
def ApiResultsSingleton(res: ApiResults = None) -> Optional[ApiResults]:
|
|
global _api_results_singleton
|
|
if _api_results_singleton is None and res is None:
|
|
raise RuntimeError("Uninitialized use of ApiResultsSingleton")
|
|
if _api_results_singleton is not None and res is not None:
|
|
raise RuntimeError("ApiResults already initialized")
|
|
if res is not None:
|
|
_api_results_singleton = res
|
|
return _api_results_singleton
|
|
|
|
|
|
def clear_singleton_instance(instance: Union[LegendaryCore, GlobalSignals, Namespace, ApiResults]):
|
|
global _legendary_core_singleton, _global_signals_singleton, _arguments_singleton, _api_results_singleton
|
|
if isinstance(instance, LegendaryCore):
|
|
del instance
|
|
_legendary_core_singleton = None
|
|
elif isinstance(instance, GlobalSignals):
|
|
instance.deleteLater()
|
|
del instance
|
|
_global_signals_singleton = None
|
|
elif isinstance(instance, Namespace):
|
|
del instance
|
|
_arguments_singleton = None
|
|
elif isinstance(instance, ApiResults):
|
|
del instance
|
|
_api_results_singleton = None
|
|
else:
|
|
raise RuntimeError(f"Instance is of unknown type \"{type(instance)}\"")
|