gettext: --no-location

[pmachines.git] / ya2 / utils / log.py

from logging import basicConfig, info, INFO, DEBUG, getLogger
from configparser import ConfigParser
from sys import platform, argv
from glob import glob
from os import getcwd, environ
from os.path import exists
from sys import version_info
# from platform import system, release, architecture, platform, processor, \
#     version, machine
# from multiprocessing import cpu_count
from panda3d.core import Filename, PandaSystem
from panda3d.bullet import get_bullet_version
from ya2.utils.logics import LogicsTools, class_property
import sys


class LogManager:

    @staticmethod
    def before_init_setup(app_name):
        LogManager.__app_name = app_name
        o = LogManager.option_file_path
        LogManager.__set_level(o)

    @class_property
    def option_file_path(cls):
        r = 'options.ini'
        path = ''
        if LogicsTools.in_build:
            path = str(Filename.get_user_appdata_directory()) + '/pmachines'
        if path:
            r = LogicsTools.platform_specific_path(path + '/options.ini')
        return r

    @staticmethod
    def __set_level(options_file_path):
        l = LogManager.__set_level_from_settings(options_file_path)
        basicConfig(level=l, format='%(asctime)s %(message)s', datefmt='%H:%M:%S')
        getLogger().setLevel(l)

    @staticmethod
    def __set_level_from_settings(options_file_path):
        l = INFO
        if exists(options_file_path):
            with open(options_file_path):
                o = ConfigParser()
                o.read(options_file_path)
                v = o['development']['verbose_log']
                if v and int(v):
                    l = DEBUG
        return l

    @class_property
    def init_cls(cls):
        return WindowedLogManager if base.win else LogManager

    def __init__(self):
        self.log_configuration()

    def log(self, message, verbose=False):
        if verbose and not self.eng.cfg.dev_cfg.verbose_log: return
        info(message)

    @property
    def build_version(self):
        appimage_version = self.__build_version_appimage()
        if appimage_version: return appimage_version
        return self.__build_version_from_file

    def __build_version_appimage(self):
        appimage_mounted = glob(f'{LogicsTools.appimage_path(self.__app_name)}*')
        if appimage_mounted:
            with open(LogicsTools.current_path(self.__app_name) + 'assets/build_version.txt') as f:
                return f.read().strip()

    @property
    def __build_version_from_file(self):
        try: return self.__load_version_from_file()
        except FileNotFoundError:
            info('not found ' + LogicsTools.current_path(self.__app_name) + 'assets/build_version.txt')
            return 'notfound'

    def __load_version_from_file(self):
        with open(LogicsTools.current_path(self.__app_name) + 'assets/build_version.txt') as f:
            return f.read().strip()

    def log_configuration(self):
        if '--version' in argv:
            self.__write_observed_version()
            self.__print_version()
        self.__messages = [f'version: {self.build_version}',
                    f'argv[0]: {argv[0]}',
                    f'getcwd: {getcwd()}',
                    f'__file__: {__file__}']
        for e in environ.items():
            self.__messages += [f'env::{e[0]}: {e[1]}']
        # os_info = (system(), release(), version())
        # messages += ['operative system: %s %s %s' % os_info]
        # messages += ['architecture: ' + str(architecture())]
        # messages += ['machine: ' + machine()]
        # messages += ['platform: ' + platform()]
        # messages += ['processor: ' + processor()]
        # try:
        #     messages += ['cores: ' + str(cpu_count())]
        # except NotImplementedError:  # on Windows
        #     messages += ['cores: not implemented']
        lib_ver = PandaSystem.get_version_string()
        self.__log_system_memory()
        lib_commit = PandaSystem.get_git_commit()
        py_ver = [str(e) for e in version_info[:3]]
        self.__messages += [f'python version: {".".join(py_ver)}',
                     f'panda version: {lib_ver} {lib_commit}',
                     f'bullet version: {str(get_bullet_version())}',
                     f'appdata: {str(Filename.get_user_appdata_directory())}']
        if LogicsTools.windowed:
            # not headless
            print(base.win.get_keyboard_map())
        list(map(self.log, self.__messages))

    def __write_observed_version(self):
        info(f'writing {LogicsTools.appdata_path}/{self.__app_name}/observed_version.txt')
        with open(LogicsTools.appdata_path + '/pmachines/observed_version.txt', 'w') as f:
            f.write(self.build_version)

    def __print_version(self):
        if not platform.startswith('win'):
            from os import ttyname  # here because it doesn't work on windows
            try:
                with open(ttyname(0), 'w') as f:
                    sys.stdout = f
                    print(f'version: {self.build_version}')
            except OSError:  # it doesn't work with crontab
                print('version: ' + self.build_version)

    def __log_system_memory(self):
        try:
            import psutil
            mem = psutil.virtual_memory().total / 1000000000
            self.__messages += [f'memory: {round(mem, 2)} GB']
        except ImportError:
            info("can't import psutil")  # windows


class WindowedLogManager(LogManager):

    def log_configuration(self):
        super().log_configuration()
        self.__messages = [base.win.get_gsg().get_driver_vendor()]
        self.__messages += [base.win.get_gsg().get_driver_renderer()]
        shad_maj = base.win.get_gsg().\
            get_driver_shader_version_major()
        shad_min = base.win.get_gsg().\
            get_driver_shader_version_minor()
        self.__messages += ['shader: {maj}.{min}'.format(maj=shad_maj, min=shad_min)]
        self.__messages += [base.win.get_gsg().get_driver_version()]
        drv_maj = base.win.get_gsg().get_driver_version_major()
        drv_min = base.win.get_gsg().get_driver_version_minor()
        drv = 'driver version: {maj}.{min}'
        self.__messages += [drv.format(maj=drv_maj, min=drv_min)]
        self.__log_fullscreen()
        self.__log_resolution()
        list(map(self.log, self.__messages))

    def __log_fullscreen(self):
        fullscreen = None
        if LogicsTools.windowed:
            fullscreen = base.win.get_properties().get_fullscreen()
        self.__messages += ['fullscreen: ' + str(fullscreen)]

    def __log_resolution(self):
        def resolution():
            if not LogicsTools.windowed:
                return 800, 600
            w = base.win.get_properties()
            return w.get_x_size(), w.get_y_size()
        self.__messages += [f'resolution: {(r := resolution())[0]}x{r[1]}']