housekeeping (L10nCommand)

[pmachines.git] / setup.py

'''e.g. python setup.py bdist_apps --cores=1 --nowindows=1'''


from ya2.utils.log import LogManagerBase
LogManagerBase.pre_init_logging()
from os import system
from sys import argv, executable
from subprocess import Popen
from setuptools import setup, Command
from setuptools.command.develop import develop
from multiprocessing import cpu_count
from direct.dist.commands import bdist_apps
from p3d_appimage import AppImageBuilder
from ya2.build.build import _branch, find_file_names, _version, FindFileNamesInfo
from ya2.build.models import ModelsBuilder
from ya2.build.images import build_images
from ya2.build.screenshots import build_screenshots
from ya2.build.lang import LanguageBuilder
from pmachines.app import Pmachines


app_name = long_name = 'pmachines'



assets_creation_message = '''NOTE: please be sure that you've already created the assets with:
    * python setup.py images models lang'''


class SetupDevelopmentCommand(develop):

    def run(self):
        develop.run(self)
        Popen([executable, __file__, 'lang']).communicate()
        Popen([executable, __file__, 'models']).communicate()
        Popen([executable, __file__, 'images']).communicate()


class BaseCommand(Command):

    user_options = [('cores=', None, '#cores')]
    cores = cpu_count()

    def initialize_options(self):
        for a in argv[:]: self.__process_argument(a)

    def __process_argument(self, argument):
        if argument.startswith('--cores='):
            BaseCommand.cores = int(argument.split('=')[1])

    def finalize_options(self):  # must override
        pass


class ModelsCommand(BaseCommand):

    def run(self):
        ModelsBuilder().build('assets/models', int(BaseCommand.cores))


class ImagesCommand(BaseCommand):

    def run(self):
        build_screenshots(Pmachines.scenes)
        find_info = FindFileNamesInfo(
            ['jpg', 'png'],
            ['models', 'gltf', 'bam'],
            ['_png.png'])
        images = find_file_names(find_info)
        build_images(images, int(BaseCommand.cores))


class L10nCommand(BaseCommand):

    l10n_path = 'assets/locale/'

    def run(self):
        self.__language_builder = LanguageBuilder(app_name, 'assets/locale/po/', 'assets/locale/')
        self.__language_builder.build_pot()
        for l in ['it_IT']: self.__process_language(l)

    def __process_language(self, language_code):
        self.__language_builder.merge(language_code)
        self.__language_builder.build_mo(language_code)


class BDistAppsCommand(bdist_apps):

    user_options = bdist_apps.user_options + [
        ('cores', None, '#cores'),
        ('nowindows=', None, "don't build for windows"),
        ('nolinux=', None, "don't build for linux")]

    def initialize_options(self):
        bdist_apps.initialize_options(self)
        self.nowindows, self.nolinux = None, None

    def run(self):
        print(assets_creation_message)
        self.__patch_commands_py()
        bdist_apps.run(self)
        self.__eventually_build_appimage()

    def __patch_commands_py(self):
        command = 'patch --forward ' + \
              '../venv/lib/python3.7/site-packages/direct/dist/commands.py' + \
              ' ya2/build/commands.patch'
        system(command)

    def __eventually_build_appimage(self):
        if not self.nolinux:
            hbranch = {'master': 'alpha', 'rc': 'rc', 'stable': ''}[_branch()]
            AppImageBuilder(self).build(long_name, hbranch,
                                        'https://www.ya2.it/downloads/')


def platform_list():
    platforms = []
    if all('--nowindows' not in a for a in argv):
        platforms += ['win_amd64']
    if all('--nolinux' not in a for a in argv):
        platforms += ['manylinux2010_x86_64']
    return platforms


def installers_dictionary():
    installers = {}
    if all('--nowindows' not in a for a in argv):
        installers['win_amd64'] = ['nsis']
    if all('--nolinux' not in a for a in argv):
        installers['manylinux2010_x86_64'] = []
    return installers


if __name__ == '__main__':
    setup(
        name=app_name,
        version=_version(),
        cmdclass={
            'develop': SetupDevelopmentCommand,
            'models': ModelsCommand,
            'images': ImagesCommand,
            'lang': L10nCommand,
            'bdist_apps': BDistAppsCommand},
        install_requires=['panda3d'],
        options={
            'build_apps': {
                'exclude_patterns': [
                    'build/*', 'built/*', 'setup.py', 'requirements.txt',
                    'venv/*', '.git*', '*.pyc', 'options.ini', '__pycache__',
                    'assets/models/gltf/*', 'assets/models/**/*.blend',
                    'assets/models/**/models/*.png',
                    'assets/models/**/models/*.jpg'],
                'log_filename_strftime': True,
                'log_filename': '$USER_APPDATA/pmachines/logs/%Y/%B/%d/%H_%M_%S.log',
                'plugins': ['pandagl', 'p3openal_audio', 'pandadx9'],
                'gui_apps': {app_name: 'main.py'},
                'package_data_dirs': {'simplepbr': [('simplepbr/shaders*', '', {})]},
                'icons': {
                    app_name: [
                        'assets/images/icon/icon256.png',
                        'assets/images/icon/icon128.png',
                        'assets/images/icon/icon48.png',
                        'assets/images/icon/icon32.png',
                        'assets/images/icon/icon16.png']},
                'include_patterns': [
                    '**/ya2/licenses/*',
                    '**/licenses/*',
                    '**/*.bam',
                    '**/*.dds',
                    '**/*.bin',
                    #'**/*.png',
                    #'**/*.jpg',
                    '**/*.ico',
                    '**/*.json',
                    '**/track_tr.py',
                    '**/*.txt',
                    '**/*.ttf',
                    '**/*.vert',
                    '**/*.frag',
                    '**/*.ogg',
                    '**/*.wav',
                    '**/*.mo'],
                'platforms': platform_list(),
                'include_modules': {'*': ['encodings.hex_codec']}},
            'bdist_apps': {'installers': installers_dictionary()}})