removed GameObject

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

from logging import basicConfig, info, INFO, DEBUG, getLogger
from configparser import ConfigParser
from sys import platform, argv
from platform import system
from pathlib import Path
from glob import glob
# from datetime import datetime
from pprint import pprint
from os import getcwd, environ
from os.path import exists
from traceback import print_stack
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, GraphicsWindow, PandaSystem
from panda3d.bullet import get_bullet_version
from ya2.p3d.p3d import LibP3d


lev = INFO
opt_path = ''
if platform in ['win32', 'linux'] and not exists('main.py'):
    # it is the deployed version for windows
    opt_path = str(Filename.get_user_appdata_directory()) + '/pmachines'
opath = LibP3d.fixpath(opt_path + '/options.ini') if opt_path else \
        'options.ini'
if exists(opath):
    with open(opath) as json_file:
        # optfile = load(json_file)
        optfile = ConfigParser()
        optfile.read(opath)
        # optfile['development']['verbose']
        # and int(optfile['development']['verbose']) or \
        if optfile['development']['verbose_log'] and \
                int(optfile['development']['verbose_log']):
            lev = DEBUG

basicConfig(level=lev, format='%(asctime)s %(message)s', datefmt='%H:%M:%S')
getLogger().setLevel(lev)  # it doesn't work otherwise


class LogMgrBase:  # headless log manager

    @staticmethod
    def init_cls():
        return LogMgr if base.win else LogMgrBase

    def __init__(self):
        self.log_cfg()

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

    @property
    def is_appimage(self):
        par_path = str(Path(__file__).parent.absolute())
        is_appimage = par_path.startswith('/tmp/.mount_Pmachi')
        return is_appimage and par_path.endswith('/usr/bin')

    # @property
    # def curr_path(self):
    #     # this is different from the music's one since it does not work
    #     # with the version in windows
    #     if sys.platform == 'darwin':
    #         return dirname(__file__) + '/../Resources/'
    #     # return dirname(__file__)
    #     par_path = str(Path(__file__).parent.absolute())
    #     if self.is_appimage:
    #         return str(Path(par_path).absolute())
    #     is_snap = par_path.startswith('/snap/')
    #     is_snap = is_snap and par_path.endswith('/x1')
    #     if is_snap:
    #         return str(Path(par_path).absolute())
    #     #return getcwd()
    #     #curr_path = dirname(__file__)
    #     curr_path = str(Path(__file__).parent.parent.parent.absolute())
    #     info('current path: %s' % curr_path)
    #     return curr_path

    @property
    def curr_path(self):
        if system() == 'Windows':
            return ''
        if exists('main.py'):
            return ''
        else:
            par_path = str(Path(__file__).parent.absolute())
        if self.is_appimage:
            par_path = str(Path(par_path).absolute())
        par_path += '/'
        return par_path

    @property
    def build_version(self):
        appimg_mnt = glob('/tmp/.mount_Pmachi*')
        if appimg_mnt:
            # with open(
            #     appimg_mnt[0] + '/usr/bin/appimage_version.txt') as fver:
            with open(self.curr_path + 'assets/bld_version.txt') as fver:
                return fver.read().strip()
        try:
            with open(self.curr_path + 'assets/bld_version.txt') as fver:
                return fver.read().strip()
        except FileNotFoundError:
            info('not found ' + self.curr_path + 'assets/bld_version.txt')
            return 'notfound'

    def log_cfg(self):
        if '--version' in argv:
            path = str(Filename.get_user_appdata_directory())
            home = '/home/flavio'  # we must force this for wine
            if path.startswith('/c/users/') and exists(home + '/.wine/'):
                path = home + '/.wine/drive_' + path[1:]
            info('writing %s' % path + '/pmachines/obs_version.txt')
            with open(path + '/pmachines/obs_version.txt', 'w') as f:
                # f.write(self.eng.logic.version)
                f.write(self.build_version)
            if not platform.startswith('win'):
                from os import ttyname
                # here because it doesn't work on windows
                import sys
                try:
                    with open(ttyname(0), 'w') as fout:
                        sys.stdout = fout
                        print('version: ' + self.build_version)
                        # self.eng.logic.version)
                except OSError:  # it doesn't work with crontab
                    print('version: ' + self.build_version)
        messages = ['version: ' + self.build_version]
        # self.eng.logic.version]
        messages += ['argv[0]: %s' % argv[0]]
        messages += ['getcwd: %s' % getcwd()]
        messages += ['__file__: %s' % __file__]
        for elm in environ.items():
            messages += ['env::%s: %s' % elm]
        # 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()
        try:
            import psutil
            mem = psutil.virtual_memory().total / 1000000000.0
            messages += ['memory: %s GB' % round(mem, 2)]
        except ImportError:
            info("can't import psutil")  # windows
        lib_commit = PandaSystem.get_git_commit()
        py_ver = [str(elm) for elm in version_info[:3]]
        messages += ['python version: %s' % '.'.join(py_ver)]
        messages += ['panda version: %s %s' % (lib_ver, lib_commit)]
        messages += ['bullet version: ' + str(get_bullet_version())]
        messages += ['appdata: ' + str(Filename.get_user_appdata_directory())]
        if base.win and isinstance(base.win, GraphicsWindow):
            # not headless
            print(base.win.get_keyboard_map())
        list(map(self.log, messages))

    @staticmethod
    def log_tasks():
        info('tasks: %s' % taskMgr.getAllTasks())
        info('do-laters: %s' % taskMgr.getDoLaters())

    @staticmethod
    def plog(obj):
        print('\n\n')
        print_stack()
        pprint(obj)
        print('\n\n')


class LogMgr(LogMgrBase):

    def log_cfg(self):
        LogMgrBase.log_cfg(self)
        messages = [base.win.get_gsg().get_driver_vendor()]
        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()
        messages += ['shader: {maj}.{min}'.format(maj=shad_maj, min=shad_min)]
        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}'
        messages += [drv.format(maj=drv_maj, min=drv_min)]
        fullscreen = None
        if isinstance(base.win, GraphicsWindow):
            fullscreen = base.win.get_properties().get_fullscreen()
        messages += ['fullscreen: ' + str(fullscreen)]

        def resolution():
            if not isinstance(base.win, GraphicsWindow):
                return 800, 600
            win_prop = base.win.get_properties()
            return win_prop.get_x_size(), win_prop.get_y_size()
        res_x, res_y = resolution()
        res_tmpl = 'resolution: {res_x}x{res_y}'
        messages += [res_tmpl.format(res_x=res_x, res_y=res_y)]
        list(map(self.log, messages))