kkpy-cli 0.1.1__py3-none-any.whl

kkpy/poetry/install.sh

@@ -0,0 +1,22 @@
+# !/bin/bash
+export HRER="$(cd "`dirname "$0"`"; pwd)"
+
+echo "========================= [Install Poetry] ========================="
+INPUT_POETRY_VERSION=$1
+INPUT_POETRY_HOME=$2
+
+echo "> Install poetry(v${INPUT_POETRY_VERSION})."
+echo "> Located at: ${INPUT_POETRY_HOME}"
+export POETRY_HOME=${INPUT_POETRY_HOME}
+
+python3 ${HRER}/install-poetry.py --version ${INPUT_POETRY_VERSION}
+
+# check execution result
+if [ $? -eq 0 ] ;then
+    echo "> Successfully."
+else
+    echo "> Failed."
+    exit 1
+fi
+
+echo "===================================================================="

kkpy/template.py

@@ -0,0 +1,227 @@
+import distutils
+import logging
+import os
+import platform
+import subprocess
+import uuid
+from distutils import dir_util
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+TEMPLATE_VENV_NAME = '.venv'
+
+
+class Template:
+
+    LOG_DIR = 'logs'
+
+    def __init__(self, template_home):
+        self.template_home = template_home
+        self._init_basic_folder()
+
+    def _init_basic_folder(self):
+        # log directory
+        log_dir = os.path.join(self.template_home, self.LOG_DIR)
+        if not os.path.exists(log_dir):
+            logging.info(f"make new directory: {log_dir}")
+            os.makedirs(log_dir, exist_ok=True)
+
+    def generate(self):
+        logging.info(f"start to copy template files from template to {self.template_home}")
+        distutils.dir_util.copy_tree(f'{here}/templates', f"{self.template_home}")
+
+
+class TemplateEnv:
+
+    TEMPLATE_ENV_NAME = '.env'
+
+    def __init__(self, template_home):
+        self.template_home = template_home
+
+    @property
+    def project_home(self):
+        return self.template_home
+
+    @property
+    def project_name(self):
+        return os.path.basename(self.project_home)
+
+    @property
+    def env_path(self):
+        return os.path.join(self.template_home, self.TEMPLATE_ENV_NAME)
+
+    @property
+    def venv_conf_path(self):
+        return os.path.join(self.template_home, TEMPLATE_VENV_NAME)
+
+    @property
+    def env(self):
+        return self._env
+
+    @env.setter
+    def env(self, value):
+        self._env = value
+
+    @property
+    def py_ver(self):
+        return self._py_ver
+
+    @py_ver.setter
+    def py_ver(self, value):
+        self._py_ver = value
+
+    @property
+    def venv_path(self):
+        return self._venv_path
+
+    @venv_path.setter
+    def venv_path(self, value):
+        self._venv_path = value
+
+    @staticmethod
+    def check_is_exist(env_directory):
+        if os.path.isfile(os.path.join(env_directory, TemplateEnv.TEMPLATE_ENV_NAME)):
+            return True
+
+        return False
+
+    def create(self):
+        with open(self.env_path, 'w') as text_file:
+            text_file.write('# It is automatically generated at init time, please do not edit it. \n')
+
+            logging.info(f'write args in {self.env_path}')
+
+            logging.info(f'write {self.project_home} to arg: KKPY_PROJECT_HOME.')
+            text_file.write(f'KKPY_PROJECT_HOME=\"{self.project_home}\"\n')
+
+            logging.info(f'write {self.project_name} to arg: KKPY_PROJECT_NAME.')
+            text_file.write(f'KKPY_PROJECT_NAME=\"{self.project_name}\"\n')
+
+            logging.info(f'write {self.env_path} to arg: KKPY_ENV_PATH.')
+            text_file.write(f'KKPY_ENV_PATH=\"{self.env_path}\"\n')
+
+            logging.info(f'write {self.env} to arg: KKPY_ENV.')
+            text_file.write(f'KKPY_ENV=\"{self.env}\"\n')
+
+            logging.info(f'write {self.py_ver} to arg: KKPY_PYTHON_VERSION.')
+            text_file.write(f'KKPY_PYTHON_VERSION=\"{self.py_ver}\"\n')
+
+            logging.info(f'write {self.venv_conf_path} to arg: KKPY_VIRTUALENV_CONF_PATH.')
+            text_file.write(f'KKPY_VIRTUALENV_CONF_PATH=\"{self.venv_conf_path}\"\n')
+
+            logging.info(f'write {self.venv_path} to arg: KKPY_VIRTUALENV_PATH.')
+            text_file.write(f'KKPY_VIRTUALENV_PATH=\"{self.venv_path}\"\n')
+
+    def load_to_env_vars(self):
+        import dotenv
+        dotenv.load_dotenv(self.env_path)
+
+
+class TemplateVirtualEnv:
+
+    # template requirement
+    TEMPLATE_REQUIREMENTS = '.requirements-template.txt'
+    TEMPLATE_VENV_REQUIREMENTS = 'requirements.txt'
+    # pyenv
+    PYENV_CONF_NAME = '.python-version'
+    BUILD_PYENV_CONF_NAME = 'build-python-version'
+    # poetry
+    POETRY_COMMAND = '$HOME/.poetry/bin/poetry'
+
+    def __init__(self, template_home, python_version=None):
+        self.template_home = template_home
+        self.py_ver = python_version
+
+    @property
+    def path(self):
+        return subprocess.getoutput(f'cd {os.path.join(self.template_home, TEMPLATE_VENV_NAME)}; {self.POETRY_COMMAND} env info -p')
+
+    @property
+    def py_ver(self):
+        return self._py_ver
+
+    @py_ver.setter
+    def py_ver(self, value):
+        if value:
+            self._py_ver = value
+        else:
+            # check build-python-version
+            python_version_path = os.path.join(self.template_home, self.BUILD_PYENV_CONF_NAME)
+            if os.path.isfile(python_version_path):
+                # use existing build-python-version setting
+                with open(python_version_path, 'r') as f:
+                    self._py_ver = f.read().replace('\n', '')
+            else:
+                # default: system python version
+                self._py_ver = platform.python_version()
+
+        self._install_python_in_pyenv()
+
+        # write python version for pyenv
+        if not os.path.isdir(os.path.join(self.template_home, TEMPLATE_VENV_NAME)):
+            os.mkdir(os.path.join(self.template_home, TEMPLATE_VENV_NAME))
+
+        with open(os.path.join(self.template_home, TEMPLATE_VENV_NAME, self.PYENV_CONF_NAME), 'w') as text_file:
+            text_file.write(f'{self._py_ver}')
+
+        with open(os.path.join(self.template_home, self.BUILD_PYENV_CONF_NAME), 'w') as text_file:
+            text_file.write(f'{self._py_ver}')
+
+    def _install_python_in_pyenv(self):
+        logging.info(f'installing python {self.py_ver} via pyenv, please wait...')
+
+        command = f'pyenv install -s {self.py_ver}'
+        try:
+            logging.info(f'exec command: {command}')
+            subprocess.run([command], shell=True, check=True)
+        except Exception as e:
+            logging.error(e)
+            exit(-1)
+
+    def build(self):
+        base_build_command = f'cd {os.path.join(self.template_home, TEMPLATE_VENV_NAME)};'
+
+        # poetry init
+        init_command = f'{base_build_command} {self.POETRY_COMMAND} init --python {self._py_ver} -n'
+        logging.info(f'exec command: {init_command}')
+        os.system(init_command)
+
+        # set virtualenvs.in-project=true by project
+        set_command = f'{base_build_command} {self.POETRY_COMMAND} config virtualenvs.in-project true --local'
+        logging.info(f'exec command: {set_command}')
+        os.system(set_command)
+
+        # create virtualenv via specific python version (from .python-version)
+        venv_command = f'{base_build_command} {self.POETRY_COMMAND} env use $(pyenv which python)'
+        logging.info(f'exec command: {venv_command}')
+        os.system(venv_command)
+
+        # poetry install
+        install_command = f'{base_build_command} {self.POETRY_COMMAND} install'
+        logging.info(f'exec command: {install_command}')
+        os.system(install_command)
+
+        # poetry add
+        full_template_requirement_path = os.path.join(self.template_home, self.TEMPLATE_REQUIREMENTS)
+        add_command = f'{base_build_command} if [ -s {full_template_requirement_path} ] ; then cat {full_template_requirement_path} | xargs {self.POETRY_COMMAND} add ; fi'
+        logging.info(f'exec command: {add_command}')
+        os.system(add_command)
+
+        logging.info(f'create python ({self.py_ver}) venv at: {self.path}')
+
+    def install(self):
+        logging.info(f"install python packages ({self.TEMPLATE_VENV_REQUIREMENTS}) in virtualenv")
+
+        if self.path:
+            # poetry add
+            full_template_venv_requirement_path = os.path.join(self.template_home, 'src', self.TEMPLATE_VENV_REQUIREMENTS)
+            add_command = f'cd {os.path.join(self.template_home, TEMPLATE_VENV_NAME)}; if [ -s {full_template_venv_requirement_path} ] ; then cat {full_template_venv_requirement_path} | xargs {self.POETRY_COMMAND} add ; fi'
+            logging.info(f'exec command: {add_command}')
+            os.system(add_command)
+        else:
+            # pip install
+            install_command = f'pip install -r {self.template_home}/{self.TEMPLATE_VENV_REQUIREMENTS}'
+            logging.info(f'exec command: {install_command}')
+            os.system(install_command)
+
+        logging.info('install finished.')

kkpy/templates/.editorconfig

@@ -0,0 +1,23 @@
+root = true
+
+[*]
+indent_style = space
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_size = 2
+
+[*.py]
+indent_size = 4
+
+[*.sh]
+indent_size = 4
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.rst]
+indent_size = 3
+
+

kkpy/templates/.gitignore

@@ -0,0 +1,54 @@
+# Compiled source #
+###################
+*.pyc
+
+# Logs and databases #
+######################
+*.log
+*.log.*
+*/logs
+
+# OS generated files #
+######################
+.DS_Store*
+
+# Editor Files #
+################
+*~
+*.swp
+
+# Build output directies #
+##########################
+build
+.eggs
+*.egg-info
+dist
+
+# virtual env #
+###############
+.venv
+.tox
+
+# IDE Files #
+#############
+.vscode/
+
+# Cache #
+#########
+__pycache__
+.pytest_cache
+.cache
+
+# coverage output #
+###################
+.coverage
+htmlcov
+
+# Temp #
+########
+tmp
+temp
+
+# Template #
+.env
+src/configs/vars

kkpy/templates/.requirements-template.txt

@@ -0,0 +1,4 @@
+click==8.0.1
+configparser==5.0.2
+tox==3.23.1
+Jinja2==2.11.3

kkpy/templates/.requirements-test.txt

@@ -0,0 +1,3 @@
+pytest==6.2.2
+pytest-cov==2.11.1
+mock==4.0.3

kkpy/templates/bin/start.py

@@ -0,0 +1,33 @@
+import click
+import logging
+import time
+import traceback
+
+from src.main import Main
+from utils.utils import get_configs_path, get_config_by_env
+
+@click.command()
+def receive(**kwargs):
+    try:
+        logging.info('======== Receive running request ========')
+        start = time.time()
+
+        # load configs
+        configs_path = get_configs_path()
+        configs = get_config_by_env(configs_path)
+
+        # trigger main task
+        main = Main(config=configs, input_args=kwargs)
+        main.run()
+
+        end = time.time()
+        execution_time = end - start
+
+        logging.info(f'======== Successfully! Execution time: {execution_time} sec ========')
+    except Exception:
+        error_msg = traceback.format_exc()
+        logging.exception(error_msg)
+        exit(-1)
+
+if __name__ == '__main__':
+    receive()

kkpy/templates/bin/start.sh

@@ -0,0 +1,9 @@
+# !/bin/bash
+export APP_HOME="$(cd "`dirname "$0"`"/..; pwd)"
+export PYTHONPATH=${APP_HOME}/src:$PYTHONPATH
+
+. "${APP_HOME}/.env"
+
+cd ${APP_HOME}
+
+python ${APP_HOME}/bin/start.py $@

kkpy/templates/src/__init__.py

@@ -0,0 +1,11 @@
+import os
+import sys
+import logging
+from logging import config
+
+if hasattr(sys, '_called_from_test'):
+    # called from within a test run
+    pass
+else:
+    logging.logfilename = os.environ.get('KKPY_PROJECT_NAME', 'app')
+    config.fileConfig('src/configs/logging_config.ini')

kkpy/templates/src/configs/app.ini

@@ -0,0 +1,9 @@
+[prod]
+
+[stage]
+
+[sit]
+
+[dev]
+test_config=This Is Test
+set_from_vars_file={{ user_name }}

kkpy/templates/src/configs/db.ini

@@ -0,0 +1,5 @@
+[database]
+host = {{ db_host }}
+user = {{ db_user }}
+password = {{ db_password }}
+dbname = {{ db_name }}

kkpy/templates/src/configs/logging_config.ini

@@ -0,0 +1,27 @@
+[loggers]
+keys=root
+
+[handlers]
+keys=stdout,filelog
+
+[formatters]
+keys=default
+
+[logger_root]
+level=INFO
+handlers=filelog,stdout
+
+[handler_stdout]
+class=StreamHandler
+level=DEBUG
+formatter=default
+args=(sys.stdout,)
+
+[handler_filelog]
+class=handlers.RotatingFileHandler
+level=DEBUG
+args=('logs/'+logfilename+'.log', 'a', 10000000, 10)
+formatter=default
+
+[formatter_default]
+format=%(asctime)s-[%(threadName)s][%(thread)x]-%(filename)-8s-%(name)-8s-%(funcName)-10s-%(levelname)-5s-%(lineno)d: %(message)s

kkpy/templates/src/main.py

@@ -0,0 +1,27 @@
+import logging
+import os
+import sys
+
+logger = logging.getLogger(__name__)
+
+
+class Main(object):
+
+    def __init__(self, config, **kwargs):
+        self.config = config
+        self.args = kwargs.get('input_args')
+
+    def run(self):
+        try:
+            logger.info('>>> run')
+            logger.info(f'config(app): {self.config["app"]}')
+            logger.info(f'input args: {self.args}')
+
+            # TODO Let's start coding for the project !
+
+        except Exception:
+            raise
+
+# ===== Just for testing test feature =====
+def just_test_fun():
+    return True

kkpy/templates/src/utils/utils.py

@@ -0,0 +1,63 @@
+import logging
+import os
+from configparser import ConfigParser
+
+from jinja2 import Environment, FileSystemLoader
+
+logger = logging.getLogger(__name__)
+
+CONF_BASE_PATH = 'src/configs'
+EXTRA_VAR_FILE_NAME = 'vars'
+
+jinja_env = Environment(loader=FileSystemLoader('.'))
+
+def get_configs_path():
+    exclude_list = ['logging_config.ini']
+    return [f'{CONF_BASE_PATH}/{f}'
+                for f in os.listdir(CONF_BASE_PATH) if f.endswith('.ini') and f not in exclude_list]
+
+def _load_vars_from_file():
+    extra_var_file_path = os.path.join(CONF_BASE_PATH, EXTRA_VAR_FILE_NAME)
+
+    udf_vars = {}
+    if os.path.exists(extra_var_file_path):
+        with open(extra_var_file_path, 'r') as f:
+            for line in f:
+                line = line.rstrip('\n')
+                if line != '':
+                    k, v = line.split('=', 1)
+                    udf_vars[k.strip()] = v.strip()
+
+    return udf_vars
+
+def get_config_by_env(configs_path):
+    try:
+        current_env = os.environ.get('KKPY_ENV', 'dev')
+
+        # load vars from vars file
+        udf_vars = _load_vars_from_file()
+
+        configs_by_file_name = {}
+        for path in configs_path:
+
+            file_name = os.path.basename(path).rstrip('.ini')
+
+            # load .ini as a template
+            conf_template = jinja_env.get_template(f'{CONF_BASE_PATH}/{file_name}.ini')
+
+            parser = ConfigParser()
+            parser.read_string(conf_template.render(**udf_vars)) # render vars to config template(.ini)
+
+            options = {}
+            if file_name == 'app' \
+                and parser.has_section(current_env): # load runtime env section (dev|sit|stage|prod) in app.ini
+                options = dict(parser.items(current_env))
+            else: # load all sections in other .ini files
+                for section_key in parser.sections():
+                    options[section_key] = dict(parser.items(section_key))
+
+            configs_by_file_name[file_name] = options
+    except Exception:
+        raise
+    else:
+        return configs_by_file_name

kkpy/templates/tests/conftest.py

@@ -0,0 +1,9 @@
+import sys
+
+def pytest_configure(config):
+
+    sys._called_from_test = True
+
+def pytest_unconfigure(config):
+
+    del sys._called_from_test

kkpy/templates/tests/test_sample.py

@@ -0,0 +1,4 @@
+from src.main import just_test_fun
+
+def test_fun():
+    assert just_test_fun()

kkpy/templates/tox.ini

@@ -0,0 +1,27 @@
+[tox]
+skipsdist = True
+
+[testenv]
+setenv =
+    PYTHONPATH = {toxinidir}/src
+    PYTHONDONTWRITEBYTECODE = 1
+
+deps =
+    -r{toxinidir}/src/requirements.txt
+    -r{toxinidir}/.requirements-test.txt
+    -r{toxinidir}/.requirements-template.txt
+
+commands =
+    - pytest \
+     --cov-config {toxinidir}/tox.ini \
+     --color yes \
+     --cov {toxinidir}/src \
+     -vvv
+
+[coverage:run]
+omit =
+    */__init__.py
+
+[pytest]
+filterwarnings =
+    ignore:: DeprecationWarning