mpd-kit 0.0.1__tar.gz

mpd_kit-0.0.1/PKG-INFO

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: mpd_kit
+Version: 0.0.1

mpd_kit-0.0.1/README.md

@@ -0,0 +1,28 @@
+# MPD-Kit
+
+Welcome to MPD-Kit official repository!
+
+MPD stands for "Multi-Platform Development" and solves a lot of problems that can happen while you're compiling your application.
+
+This program is on development stage right now. If you want to support development, please give this project a star :)
+
+## Quick overview
+
+MPD-Kit is useful tool to automate compiling Python code with `pyinstaller`. Compilation process looks like using Meson, CMake and tools like these.
+
+First, MPD-Kit will create a virtual environment for project build and install required libraries from requirements.txt.
+After installation is done, builder starts the `pyinstaller` command for files that you specified in your config file.
+
+The latest step is copying binary files from cache to `dist` - and process is done!
+
+## About MPD-Clicks
+
+MPD-Clicks is the GUI application that allows you to use the same functions as from MPD-CLI with more intuitive way than MPD-CLI.
+You can look at this project at https://github.com/VladosNX/MPD-Clicks
+
+## Future features
+
+### 1. Cross-compiling
+
+Since `pyinstaller` can't cross-compile applications, MPD-Kit will solve this problem with simple and minimalistic virtual machines.
+Program will copy your project source files into required VM and start cross compilers there and copy files to certain folder.

mpd_kit-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mpd_kit-0.0.1/setup.py

@@ -0,0 +1,14 @@
+from setuptools import setup, find_packages
+from src.mpd_kit.vars import VERSION
+
+setup(
+    name="mpd_kit",
+    version=VERSION,
+    packages=find_packages(where='src'),
+    package_dir={'': 'src'},
+    entry_points={
+        "console_scripts": [
+            "mpd-cli=mpd_kit.cli:main"
+        ]
+    }
+)

mpd_kit-0.0.1/src/mpd_kit/argparser/argconditions.py

@@ -0,0 +1,2 @@
+def isModeRequired(args):
+    return not args['help']

mpd_kit-0.0.1/src/mpd_kit/argparser/argparse.py

@@ -0,0 +1,97 @@
+import sys
+import mpd_kit.argparser.argvars as argvars
+import mpd_kit.argparser.argconditions as argconditions
+
+# Input dictionary has information about all available options.
+# Options are stored in order like:
+#  [ type: int, id: str, required: bool|function, short: str|None, has_value: bool, order: int|None ]
+# If you specified a function to 'required' field, it will be executed after arguments parsing is done to check if argument should be required based on context
+# long and short options aren't required if you didn't set type to '1'
+# order is used for ordinal arguments
+
+inputs = [
+    [ argvars.TYPE_ORDINAL, 'mode', argconditions.isModeRequired, None, True, 0 ],
+    [ argvars.TYPE_DOUBLEDASH, 'help', False, None, False, None ],
+    [ argvars.TYPE_DOUBLEDASH, 'verbose', False, 'v', False, None ],
+    [ argvars.TYPE_DOUBLEDASH, 'pythoncmd', False, 'p', True, None ]
+]
+
+def _findByDoubleDash(value: str):
+    for option in inputs:
+        if option[argvars.ARG_TYPE] != argvars.TYPE_DOUBLEDASH: continue
+        if value.lstrip('-') == option[argvars.ARG_ID]: return option
+
+    return None
+
+def _findBySingleDash(value: str):
+    for option in inputs:
+        if option[argvars.ARG_TYPE] != argvars.TYPE_DOUBLEDASH: continue
+        if value.lstrip('-') == option[argvars.ARG_SHORT]: return option
+
+    return None
+
+def _findByOrdinal(index: int):
+    for option in inputs:
+        if option[argvars.ARG_TYPE] != argvars.TYPE_ORDINAL: continue
+        if index == option[argvars.ARG_ORDER]: return option
+
+    return None
+
+def _findById(arg_id: str):
+    for option in inputs:
+        if option[argvars.ARG_ID] == arg_id: return option
+
+    return None
+
+def parse(args):
+    ordinalIndex = 0
+    options = {}
+    # Filling options dictionary with zero-values
+    for option in inputs:
+        options[option[argvars.ARG_ID]] = None
+
+    assignNextTo = None
+    for arg in args[1:]:
+        if len(arg) == 0: continue
+        optionSignature = None
+
+        if assignNextTo:
+            options[assignNextTo] = arg
+            assignNextTo = None
+            continue
+
+        if arg[0] == '-':
+            if arg[1] == '-':
+                # user specified double-dash argument
+                optionSignature = _findByDoubleDash(arg)
+            else:
+                # user specified single-dash argument
+                optionSignature = _findBySingleDash(arg)
+        else:
+            # user specified ordinal argument
+            optionSignature = _findByOrdinal(ordinalIndex)
+            ordinalIndex += 1
+
+        if not optionSignature:
+            print('Incorrect argument :( See --help', file=sys.stderr)
+            sys.exit(1)
+        elif optionSignature[argvars.ARG_TYPE] == argvars.TYPE_ORDINAL:
+            options[optionSignature[argvars.ARG_ID]] = arg
+        elif optionSignature[argvars.ARG_HAS_VALUE]:
+            assignNextTo = optionSignature[argvars.ARG_ID]
+        else:
+            options[optionSignature[argvars.ARG_ID]] = True
+
+    for option in inputs:
+        if options[option[argvars.ARG_ID]] is None:
+            required = False
+            if option[argvars.ARG_REQUIRED] is bool and option[argvars.ARG_REQUIRED]:
+                required = True
+            elif callable(option[argvars.ARG_REQUIRED]):
+                required = option[argvars.ARG_REQUIRED](options)
+
+            if required:
+                print(f'You skipped required argument called {option[argvars.ARG_ID]}!', file=sys.stderr)
+                sys.exit(1)
+
+    return options

mpd_kit-0.0.1/src/mpd_kit/argparser/argvars.py

@@ -0,0 +1,10 @@
+TYPE_ORDINAL = 0
+TYPE_DOUBLEDASH = 1
+
+ARG_TYPE = 0
+ARG_ID = 1
+ARG_REQUIRED = 2
+ARG_SHORT = 3
+ARG_HAS_VALUE = 4
+ARG_ORDER = 5
+

mpd_kit-0.0.1/src/mpd_kit/classes/BuildArguments.py

@@ -0,0 +1,5 @@
+class BuildArguments:
+    python_cmd = None
+
+    def __init__(self):
+        pass

mpd_kit-0.0.1/src/mpd_kit/classes/Configuration.py

@@ -0,0 +1,58 @@
+from mpd_kit.classes.exceptions.SecondNonRecurringValue import SecondNonRecurringValue
+from mpd_kit.classes.exceptions.UnknownValue import UnknownValue
+from mpd_kit.classes.exceptions.SkippedRequiredValue import SkipperRequiredValue
+from mpd_kit.classes.ValueSignature import ValueSignature
+
+ARG_KEY = 0
+ARG_VALUE = 1
+
+class Configuration:
+    values = []
+
+    value_signatures = [
+        ValueSignature('PRETTY', 'Pretty Name', False, True),
+        ValueSignature('VERSION', 'Version', False, True),
+        ValueSignature('BRIEF', 'Description', False, True),
+        ValueSignature('ENTRY', 'Entry File', True, True),
+        ValueSignature('BASEFLAGS', 'Base Compiler Flags', False, False),
+    ]
+
+    def getValueSignature(self, key: str):
+        for item in self.value_signatures:
+            if item.key == key:
+                return item
+
+        return None
+
+    def getValue(self, key: str):
+        for value in self.values:
+            if value[ARG_KEY] == key:
+                return value[ARG_VALUE]
+
+        return None
+
+    def getRecurringValues(self, key):
+        result = []
+
+        for item in self.values:
+            if item[ARG_KEY] == key:
+                result.append(item[ARG_VALUE])
+
+        return result
+
+    def setValue(self, key: str, value: str):
+        signature = self.getValueSignature(key)
+
+        if not signature.recurring:
+            if self.getValue(key):
+                raise SecondNonRecurringValue(key)
+
+        if not signature:
+            raise UnknownValue(key)
+
+        self.values.append([key, value])
+
+    def validateRequired(self):
+        for signature in self.value_signatures:
+            if signature.required and not self.getValue(signature.key):
+                raise SkipperRequiredValue(signature.key)

mpd_kit-0.0.1/src/mpd_kit/classes/Project.py

@@ -0,0 +1,102 @@
+from mpd_kit.classes.Configuration import Configuration
+from mpd_kit.classes.exceptions.SystemCommandFailed import SystemCommandFailed
+from mpd_kit.classes.BuildArguments import BuildArguments
+import mpd_kit.corelibs.configparse.parser as configparser
+import mpd_kit.corelibs.build_functions as build_functions
+import mpd_kit.vars as vars
+import os
+import shutil
+
+class Project:
+    path = ''
+    config = Configuration()
+
+    def __init__(self, path):
+        self.path = path
+
+        config = configparser.parse_config(self.path)
+
+    def build(self, log, next_step, arguments: BuildArguments):
+        # progress_funcs should accept 2 arguments - category and info
+        # category is a type of information - info, warn, done, error, cmd
+        log('info', f'Running MPD-Kit {vars.VERSION}, task: letsgo')
+        python_cmd = 'python3' if arguments.python_cmd is None else arguments.python_cmd
+        venv_path = 'mpd-venv'
+        log('info', f'Using {python_cmd} as Python executable')
+        log('info', f'Using {venv_path} as Python virtual environment')
+
+        # Step 1: Creating virtual environment
+        next_step(1, 'Creating virtual environment')
+        try:
+            build_functions.run_command(f"{python_cmd} -m venv {venv_path}")
+        except SystemCommandFailed:
+            log('error', f'Failed to create a virtual environment')
+            return False
+        log('done', 'Virtual environment created successfully')
+
+        old_path = os.environ['PATH']
+        log('info', f'Old PATH: {old_path}')
+        new_path = f"{os.path.abspath(self.path)}/{venv_path}/bin:{old_path}" # TODO: make this program working with absolute venv_path correctly
+        os.environ['PATH'] = new_path
+        log('info', f'New PATH: {new_path}')
+        log('done', f'Switched to virtual environment')
+
+        # Step 2: Installing libraries
+        next_step(2, 'Installing libraries')
+        if os.path.exists(f'{os.path.abspath(self.path)}/requirements.txt'):
+            try:
+                build_functions.run_command('pip install -r requirements.txt')
+            except SystemCommandFailed:
+                log('error', 'Failed to install libraries from requirements.txt')
+                return False
+        else:
+            log('warn', 'There is no requirements.txt, skipping libraries installation')
+
+        log('info', 'Installing pyinstaller')
+        try:
+            build_functions.run_command('pip install pyinstaller')
+        except SystemCommandFailed:
+            log('error', 'Failed to install pyinstaller')
+            return False
+
+        log('done', 'All libraries installed successfully')
+
+        # Step 3: Compiling
+        next_step(3, 'Compiling')
+        builddir = os.path.join(os.path.abspath(self.path), 'mpd-files')
+        build_functions.recreate_dir(builddir)
+        log('done', f'Created directory "{builddir}"')
+
+        entries = self.config.getRecurringValues('ENTRY')
+        for file in entries:
+            log('info', f'Compiling {file}')
+            baseflags = self.config.getValue("BASEFLAGS")
+            baseflags = '' if not baseflags else baseflags
+            installation_command = f'cd {builddir} && pyinstaller -F {baseflags} ../{file}'
+            log('cmd', installation_command)
+            try:
+                build_functions.run_command(installation_command)
+            except SystemCommandFailed:
+                log('error', f'Failed to compile {file}')
+                return False
+            log('done', f'{file} compiled successfully')
+
+        # Step 4: Copying and cleaning
+        next_step(4, 'Copying and cleaning')
+        result_dir = os.path.join(os.path.abspath(self.path), 'mpd-dist')
+        log('info', f'Copying dist directory to {result_dir}')
+        build_functions.clear_dir(result_dir)
+        shutil.copytree(f'{builddir}/dist', result_dir)
+        log('done', f'dist directory copied')
+
+
+        shutil.rmtree(builddir)
+        shutil.rmtree(venv_path)
+
+        log('done', 'Compilation done!')
+
+        # at the end of executing
+        log('info', 'Switching back to old PATH')
+        os.environ['PATH'] = old_path
+
+        return True

mpd_kit-0.0.1/src/mpd_kit/classes/ValueSignature.py

@@ -0,0 +1,11 @@
+class ValueSignature:
+    key = None
+    pretty_name = None
+    recurring = None
+    required = False
+
+    def __init__(self, key: str, pretty_name: str, recurring: bool, required: bool):
+        self.key = key
+        self.pretty_name = pretty_name
+        self.recurring = recurring
+        self.required = required

mpd_kit-0.0.1/src/mpd_kit/classes/exceptions/SecondNonRecurringValue.py

@@ -0,0 +1 @@
+class SecondNonRecurringValue(Exception): pass

mpd_kit-0.0.1/src/mpd_kit/classes/exceptions/SkippedRequiredValue.py

@@ -0,0 +1 @@
+class SkipperRequiredValue(Exception): pass

mpd_kit-0.0.1/src/mpd_kit/classes/exceptions/SystemCommandFailed.py

@@ -0,0 +1 @@
+class SystemCommandFailed(Exception): pass

mpd_kit-0.0.1/src/mpd_kit/classes/exceptions/UnknownValue.py

@@ -0,0 +1 @@
+class UnknownValue(Exception): pass

mpd_kit-0.0.1/src/mpd_kit/cli.py

@@ -0,0 +1,60 @@
+import mpd_kit.vars as vars
+import sys
+import mpd_kit.argparser.argparse as argparse
+from mpd_kit.classes.Project import Project
+from mpd_kit.classes.BuildArguments import BuildArguments
+
+def show_log(category, info):
+    colors = {
+        'info': 4,
+        'warn': 3,
+        'error': 1,
+        'done': 2,
+        'cmd': 5
+    }
+
+    print(f"[\x1b[3{colors[category]}m{category.ljust(5)}\x1b[0m] {info}")
+
+def show_step(step, title):
+    print(f'+===== STEP {step}')
+    print(f'| {title}')
+    print(f'+===========')
+
+def main():
+    arguments = argparse.parse(sys.argv)
+
+    if arguments['help']:
+        print(f"MPD-Kit {vars.VERSION}")
+        print("")
+        print("Made by VladosNX. Follow me on my GitHub! https://github.com/VladosNX")
+        print("")
+        print("Basic usage:")
+        print("  mpd-cli <mode> [--help] [--verbose / -v]")
+        print("")
+        print("mode: Which action MPD-Cli has to do")
+        print("--help: Show this message")
+        print("--verbose or -v: Show more information about current task")
+        print("")
+        print("Available modes:")
+        print("")
+        print("letsgo: Start compiling process with default configuration")
+        print("validate: Check is your config file correct and show information about this project")
+        print("")
+        print("If you have some problems with MPD-CLI, please consider creating an issue on GitHub:")
+        print("  https://github.com/VladosNX/MPD-Kit/issues")
+        print("or consider using MPD-Clicks instead if you prefer GUI:")
+        print("  https://github.com/VladosNX/MPD-Clicks")
+        sys.exit()
+
+    project = Project('.')
+
+    if arguments['mode'] == 'validate':
+        for item in project.config.values:
+            print(f"{project.config.getValueSignature(item[0]).pretty_name}: {item[1]}")
+    elif arguments['mode'] == 'letsgo':
+        build_arguments = BuildArguments()
+        build_arguments.python_cmd = arguments['pythoncmd']
+        project.build(show_log, show_step, build_arguments)
+
+if __name__ == '__main__':
+    main()

mpd_kit-0.0.1/src/mpd_kit/corelibs/build_functions.py

@@ -0,0 +1,17 @@
+from mpd_kit.classes.exceptions.SystemCommandFailed import SystemCommandFailed
+import os
+import shutil
+
+def run_command(command: str):
+    status = os.system(command)
+    if status != 0:
+        raise SystemCommandFailed([command, status])
+
+def recreate_dir(name: str):
+    if os.path.exists(name):
+        shutil.rmtree(name)
+    os.mkdir(name)
+
+def clear_dir(name: str):
+    if os.path.exists(name):
+        shutil.rmtree(name)

mpd_kit-0.0.1/src/mpd_kit/corelibs/configparse/parser.py

@@ -0,0 +1,30 @@
+import os
+import sys
+from mpd_kit.classes.Configuration import Configuration
+
+def parse_config(project='.'):
+    dotmpd_file = f'{project}/DOTMPD'
+    if not os.path.exists(dotmpd_file):
+        print('There is no DOTMPD file in your project.', file=sys.stderr)
+        sys.exit(1)
+
+    file = open(dotmpd_file, mode='r', encoding='utf-8')
+    content = file.read()
+    file.close()
+
+    lines = content.split('\n')
+    if len(lines) < 1 or lines[0] != 'DOTMPD1':
+        print('Your DOTMPD file beginning is incorrect.', file=sys.stderr)
+        sys.exit(1)
+        # TODO: call exception instead of quitting program
+
+    result = Configuration()
+    for line_raw in lines[1:]:
+        line = line_raw.lstrip().rstrip()
+        if line == '': continue
+        if line[0] == '#': continue
+
+        key, value = line.split('>')
+        result.setValue(key, value)
+
+    result.validateRequired()

mpd_kit-0.0.1/src/mpd_kit/vars.py

@@ -0,0 +1 @@
+VERSION = '0.0.1'

mpd_kit-0.0.1/src/mpd_kit.egg-info/PKG-INFO

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: mpd_kit
+Version: 0.0.1

mpd_kit-0.0.1/src/mpd_kit.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+README.md
+setup.py
+src/mpd_kit/__init__.py
+src/mpd_kit/cli.py
+src/mpd_kit/vars.py
+src/mpd_kit.egg-info/PKG-INFO
+src/mpd_kit.egg-info/SOURCES.txt
+src/mpd_kit.egg-info/dependency_links.txt
+src/mpd_kit.egg-info/entry_points.txt
+src/mpd_kit.egg-info/top_level.txt
+src/mpd_kit/argparser/__init__.py
+src/mpd_kit/argparser/argconditions.py
+src/mpd_kit/argparser/argparse.py
+src/mpd_kit/argparser/argvars.py
+src/mpd_kit/classes/BuildArguments.py
+src/mpd_kit/classes/Configuration.py
+src/mpd_kit/classes/Project.py
+src/mpd_kit/classes/ValueSignature.py
+src/mpd_kit/classes/__init__.py
+src/mpd_kit/classes/exceptions/SecondNonRecurringValue.py
+src/mpd_kit/classes/exceptions/SkippedRequiredValue.py
+src/mpd_kit/classes/exceptions/SystemCommandFailed.py
+src/mpd_kit/classes/exceptions/UnknownValue.py
+src/mpd_kit/classes/exceptions/__init__.py
+src/mpd_kit/corelibs/__init__.py
+src/mpd_kit/corelibs/build_functions.py
+src/mpd_kit/corelibs/configparse/__init__.py
+src/mpd_kit/corelibs/configparse/parser.py

mpd_kit-0.0.1/src/mpd_kit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mpd_kit-0.0.1/src/mpd_kit.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mpd-cli = mpd_kit.cli:main

mpd_kit-0.0.1/src/mpd_kit.egg-info/top_level.txt

@@ -0,0 +1 @@
+mpd_kit