zrb 0.0.85__py3-none-any.whl → 0.0.87__py3-none-any.whl

zrb/builtin/generator/fastapp_module/helper.py

@@ -0,0 +1,326 @@
+from typeguard import typechecked
+from typing import Any, List, Mapping
+from dotenv import dotenv_values
+from ....task.task import Task
+from ....helper.codemod.add_import_module import add_import_module
+from ....helper.codemod.add_function_call import add_function_call
+from ....helper.codemod.append_code_to_function import append_code_to_function
+from ....helper.docker_compose.file import add_services
+from ....helper.file.text import (
+    read_text_file_async, write_text_file_async, append_text_file_async
+)
+
+import asyncio
+import os
+import jsons
+
+
+@typechecked
+async def create_microservice_config(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    snake_app_name: str,
+    kebab_module_name: str,
+    snake_module_name: str,
+    upper_snake_module_name: str
+):
+    modules = await _create_automation_json_config(
+        task, project_dir, snake_app_name, snake_module_name
+    )
+    return await asyncio.gather(
+        asyncio.create_task(_add_docker_compose_service(
+            task, modules, project_dir, kebab_app_name,
+            snake_app_name, kebab_module_name, snake_module_name,
+            upper_snake_module_name
+        )),
+        asyncio.create_task(_append_compose_env(
+            task, modules, project_dir, kebab_app_name, upper_snake_module_name
+        ))
+    )
+
+
+@typechecked
+async def _add_docker_compose_service(
+    task: Task,
+    modules: List[str],
+    project_dir: str,
+    kebab_app_name: str,
+    snake_app_name: str,
+    kebab_module_name: str,
+    snake_module_name: str,
+    upper_snake_module_name: str
+):
+    module_app_port = 8080 + len(modules)
+    module_app_port_str = str(module_app_port)
+    docker_compose_file_path = os.path.join(
+        project_dir, 'src', kebab_app_name, 'docker-compose.yml'
+    )
+    app_container_port_env_name = f'APP_{upper_snake_module_name}_MODULE_PORT'
+    app_container_port_env = '${' + app_container_port_env_name + ':-' + module_app_port_str + '}' # noqa
+    app_host_port_env_name = f'APP_{upper_snake_module_name}_HOST_MODULE_PORT'
+    app_host_port_env = '${' + app_host_port_env_name + ':-' + module_app_port_str + '}' # noqa
+    service_definition = _get_new_docker_compose_service_definition(
+        kebab_app_name, snake_app_name, kebab_module_name, snake_module_name,
+        upper_snake_module_name, app_host_port_env, app_container_port_env
+    )
+    task.print_out(f'Add service at: {docker_compose_file_path}')
+    add_services(
+        file_name=docker_compose_file_path,
+        new_services=service_definition,
+    )
+
+
+@typechecked
+def _get_new_docker_compose_service_definition(
+    kebab_app_name: str,
+    snake_app_name: str,
+    kebab_module_name: str,
+    snake_module_name: str,
+    upper_snake_module_name: str,
+    app_host_port_env: str,
+    app_container_port_env: str
+) -> Mapping[str, Any]:
+    return {
+        f'{kebab_app_name}-{kebab_module_name}-service': {
+            'build': {
+                'dockerfile': 'Dockerfile',
+                'context': './src'
+            },
+            'image': '${IMAGE:-' + kebab_app_name + '}',
+            'container_name': '${CONTAINER_PREFIX:-my}-' + f'{kebab_app_name}-{kebab_module_name}-service', # noqa
+            'hostname': f'{kebab_app_name}-{kebab_module_name}-service',
+            'env_file': [
+                'src/template.env',
+                'all-module-disabled.env'
+            ],
+            'environment': {
+                'APP_NAME': '${APP_NAME:-' + kebab_app_name + '}-' + f'{kebab_module_name}-service', # noqa
+                'APP_PORT': app_container_port_env,
+                'APP_ENABLE_EVENT_HANDLER': 'true',
+                'APP_ENABLE_RPC_SERVER': 'true',
+                'APP_ENABLE_API': 'false',
+                'APP_ENABLE_FRONTEND': 'false',
+                f'APP_ENABLE_{upper_snake_module_name}_MODULE': 'true',
+            },
+            'ports': [
+                f'{app_host_port_env}:{app_container_port_env}'
+            ],
+            'restart': 'unless-stopped',
+            'profiles': [
+                'microservices'
+            ],
+            'healthcheck': {
+                'test': [
+                    'CMD-SHELL',
+                    'curl --fail http://localhost:' + app_container_port_env + '/readiness || exit 1' # noqa
+                ],
+                'interval': '5s',
+                'timeout': '3s',
+                'retries': 10
+            },
+            'networks': ['zrb']
+        }
+    }
+
+
+@typechecked
+async def _append_compose_env(
+    task: Task,
+    modules: List[str],
+    project_dir: str,
+    kebab_app_name: str,
+    upper_snake_module_name: str
+):
+    compose_template_env_path = os.path.join(
+        project_dir, 'src', kebab_app_name, 'docker-compose.env'
+    )
+    compose_env_map = dotenv_values(compose_template_env_path)
+    host_port = int(compose_env_map.get('APP_GATEWAY_HOST_PORT', '8080'))
+    module_app_port = host_port + len(modules)
+    new_env_str = '\n'.join([
+        f'APP_{upper_snake_module_name}_HOST_MODULE_PORT={module_app_port}',
+        f'APP_{upper_snake_module_name}_MODULE_PORT={module_app_port}',
+    ])
+    task.print_out(f'Add new environment to: {compose_template_env_path}')
+    await append_text_file_async(compose_template_env_path, new_env_str)
+
+
+@typechecked
+async def append_src_template_env(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    upper_snake_module_name: str
+):
+    src_template_env_path = os.path.join(
+        project_dir, 'src', kebab_app_name, 'src', 'template.env'
+    )
+    new_env_str = '\n'.join([
+        f'APP_ENABLE_{upper_snake_module_name}_MODULE=true',
+    ])
+    task.print_out(f'Add new environment to: {src_template_env_path}')
+    await append_text_file_async(src_template_env_path, new_env_str)
+
+
+@typechecked
+async def append_deployment_template_env(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    upper_snake_module_name: str
+):
+    deployment_template_env_path = os.path.join(
+        project_dir, 'src', kebab_app_name, 'deployment', 'template.env'
+    )
+    new_env_str = '\n'.join([
+        f'REPLICA_{upper_snake_module_name}_SERVICE=1',
+    ])
+    task.print_out(f'Add new environment to: {deployment_template_env_path}')
+    await append_text_file_async(deployment_template_env_path, new_env_str)
+
+
+@typechecked
+async def append_all_enabled_env(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    upper_snake_module_name: str
+):
+    all_enabled_env_path = os.path.join(
+        project_dir, 'src', kebab_app_name, 'all-module-enabled.env'
+    )
+    task.print_out(f'Add new environment to: {all_enabled_env_path}')
+    await append_text_file_async(
+        all_enabled_env_path,
+        f'APP_ENABLE_{upper_snake_module_name}_MODULE=true'
+    )
+
+
+@typechecked
+async def append_all_disabled_env(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    upper_snake_module_name: str
+):
+    all_disabled_env_path = os.path.join(
+        project_dir, 'src', kebab_app_name, 'all-module-disabled.env'
+    )
+    task.print_out(f'Add new environment to: {all_disabled_env_path}')
+    await append_text_file_async(
+        all_disabled_env_path,
+        f'APP_ENABLE_{upper_snake_module_name}_MODULE=false'
+    )
+
+
+@typechecked
+async def create_app_config(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    snake_module_name: str,
+    upper_snake_module_name: str
+):
+    config_file_path = os.path.join(
+        project_dir, 'src', kebab_app_name, 'src', 'config.py'
+    )
+    config_code = '\n'.join([
+        f'app_enable_{snake_module_name}_module = str_to_boolean(os.environ.get(',  # noqa
+        f"    'APP_ENABLE_{upper_snake_module_name}_MODULE', 'true'"
+        '))'
+    ])
+    task.print_out(f'Read config from: {config_file_path}')
+    code = await read_text_file_async(config_file_path)
+    code += '\n' + config_code
+    task.print_out(f'Write config to: {config_file_path}')
+    await write_text_file_async(config_file_path, code)
+
+
+@typechecked
+async def _create_automation_json_config(
+    task: Task,
+    project_dir: str,
+    snake_app_name: str,
+    snake_module_name: str,
+):
+    json_modules_file_path = os.path.join(
+        project_dir, '_automate', snake_app_name, 'config', 'modules.json'
+    )
+    task.print_out(f'Read json config from: {json_modules_file_path}')
+    json_str = await read_text_file_async(json_modules_file_path)
+    task.print_out(f'Add "{snake_module_name}" to json config')
+    modules: List[str] = jsons.loads(json_str)
+    modules.append(snake_module_name)
+    json_str = jsons.dumps(modules)
+    task.print_out(f'Write new json config to: {json_modules_file_path}')
+    await write_text_file_async(json_modules_file_path, json_str)
+    return modules
+
+
+@typechecked
+async def register_migration(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    snake_module_name: str
+):
+    app_migration_file_path = os.path.join(
+        project_dir, 'src', kebab_app_name, 'src', 'migrate.py'
+    )
+    import_module_path = '.'.join([
+        'module', snake_module_name, 'migrate'
+    ])
+    function_name = f'migrate_{snake_module_name}'
+    task.print_out(f'Read code from: {app_migration_file_path}')
+    code = await read_text_file_async(app_migration_file_path)
+    task.print_out(
+        f'Add import "{function_name}" from "{import_module_path}" to the code'
+    )
+    code = add_import_module(
+        code=code,
+        module_path=import_module_path,
+        resource=function_name
+    )
+    task.print_out(f'Add "{function_name}" call to the code')
+    code = append_code_to_function(
+        code=code,
+        function_name='migrate',
+        new_code=f'await {function_name}()'
+    )
+    task.print_out(f'Write modified code to: {app_migration_file_path}')
+    await write_text_file_async(app_migration_file_path, code)
+
+
+@typechecked
+async def register_module(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    snake_module_name: str
+):
+    app_main_file_path = os.path.join(
+        project_dir, 'src', kebab_app_name, 'src', 'main.py'
+    )
+    import_module_path = '.'.join([
+        'module', snake_module_name, 'register_module'
+    ])
+    function_name = f'register_{snake_module_name}'
+    task.print_out(f'Read code from: {app_main_file_path}')
+    code = await read_text_file_async(app_main_file_path)
+    task.print_out(
+        f'Add import "{function_name}" from "{import_module_path}" to the code'
+    )
+    code = add_import_module(
+        code=code,
+        module_path=import_module_path,
+        resource=function_name
+    )
+    task.print_out(f'Add "{function_name}" call to the code')
+    code = add_function_call(
+        code=code,
+        function_name=function_name,
+        parameters=[]
+    )
+    task.print_out(f'Write modified code to: {app_main_file_path}')
+    await write_text_file_async(app_main_file_path, code)

zrb/builtin/generator/pip_package/add.py

@@ -0,0 +1,84 @@
+from typing import Any
+from ..common.task_input import (
+    project_dir_input, package_name_input, package_description_input,
+    package_homepage_input, package_bug_tracker_input,
+    package_author_name_input, package_author_email_input
+)
+from ..common.helper import (
+    validate_existing_project_dir, validate_inexisting_automation
+)
+from ..common.task_factory import create_register_module
+from ...group import project_add_group
+from ....task.decorator import python_task
+from ....task.task import Task
+from ....task.resource_maker import ResourceMaker
+from ....runner import runner
+
+import os
+
+CURRENT_DIR = os.path.dirname(__file__)
+
+
+###############################################################################
+# Task Definitions
+###############################################################################
+
+
+@python_task(
+    name='validate',
+    inputs=[
+        project_dir_input,
+        package_name_input
+    ]
+)
+async def validate(*args: Any, **kwargs: Any):
+    project_dir = kwargs.get('project_dir')
+    validate_existing_project_dir(project_dir)
+    package_name = kwargs.get('package_name')
+    validate_inexisting_automation(project_dir, package_name)
+
+
+copy_resource = ResourceMaker(
+    name='copy-resource',
+    inputs=[
+        project_dir_input,
+        package_name_input,
+        package_description_input,
+        package_homepage_input,
+        package_bug_tracker_input,
+        package_author_name_input,
+        package_author_email_input
+    ],
+    upstreams=[validate],
+    replacements={
+        'zrbPackageName': '{{input.package_name}}',
+        'zrbPackageDescription': '{{input.package_description}}',
+        'zrbPackageHomepage': '{{input.package_homepage}}',
+        'zrbPackageBugTracker': '{{input.package_bug_tracker}}',
+        'zrbPackageAuthorName': '{{input.package_author_name}}',
+        'zrbPackageAuthorEmail': '{{input.package_author_email}}'
+    },
+    template_path=os.path.join(CURRENT_DIR, 'template'),
+    destination_path='{{ input.project_dir }}',
+    excludes=[
+        '*/__pycache__',
+    ]
+)
+
+register_module = create_register_module(
+    module_path='_automate.{{util.to_snake_case(input.package_name)}}.local',
+    alias='{{util.to_snake_case(input.package_name)}}_local',
+    inputs=[package_name_input],
+    upstreams=[copy_resource]
+)
+
+
+@python_task(
+    name='pip-package',
+    group=project_add_group,
+    upstreams=[register_module],
+    runner=runner
+)
+async def add_python_task(*args: Any, **kwargs: Any):
+    task: Task = kwargs.get('_task')
+    task.print_out('Success')

zrb/builtin/generator/pip_package/template/_automate/snake_zrb_package_name/cmd/build.sh

@@ -0,0 +1,12 @@
+PYTHONUNBUFFERED=1
+echo "Activate virtual environment"
+source .venv/bin/activate
+
+echo "Git add"
+git add . -A
+
+echo "Remove dist"
+rm -Rf dist
+
+echo "Build"
+flit build

zrb/builtin/generator/{fastapp/template/_automate/snake_zrb_app_name/cmd/start.sh → pip_package/template/_automate/snake_zrb_package_name/cmd/install-symlink.sh}

@@ -2,5 +2,5 @@ PYTHONUNBUFFERED=1
 echo "Activate virtual environment"
 source .venv/bin/activate
 
-echo "Run start.sh"
-./start.sh
+echo "Install symlink"
+flit install --symlink

zrb/builtin/generator/pip_package/template/_automate/snake_zrb_package_name/cmd/publish.sh

@@ -0,0 +1,6 @@
+PYTHONUNBUFFERED=1
+echo "Activate virtual environment"
+source .venv/bin/activate
+
+echo "Publish"
+flit publish --repository {{input.snake_zrb_package_name_repo}}

zrb/builtin/generator/pip_package/template/_automate/snake_zrb_package_name/local.py

@@ -0,0 +1,60 @@
+from zrb import CmdTask, runner, StrInput
+from zrb.builtin.group import project_group
+
+import os
+
+CURRENT_DIR = os.path.dirname(__file__)
+PROJECT_DIR = os.path.abspath(os.path.join(CURRENT_DIR, '..', '..'))
+RESOURCE_DIR = os.path.join(PROJECT_DIR, 'src', 'kebab-zrb-package-name')
+PACKAGE_DIR = os.path.join(RESOURCE_DIR, 'src')
+
+###############################################################################
+# Task Definitions
+###############################################################################
+
+prepare_snake_zrb_package_name = CmdTask(
+    name='prepare-kebab-zrb-package-name',
+    description='Prepare venv for human readable zrb package name',
+    group=project_group,
+    cwd=RESOURCE_DIR,
+    cmd_path=os.path.join(CURRENT_DIR, 'cmd', 'prepare-venv.sh'),
+)
+runner.register(prepare_snake_zrb_package_name)
+
+build_snake_zrb_package_name = CmdTask(
+    name='build-kebab-zrb-package-name',
+    description='Build human readable zrb package name',
+    group=project_group,
+    upstreams=[prepare_snake_zrb_package_name],
+    cwd=RESOURCE_DIR,
+    cmd_path=os.path.join(CURRENT_DIR, 'cmd', 'build.sh'),
+)
+runner.register(build_snake_zrb_package_name)
+
+publish_snake_zrb_package_name = CmdTask(
+    name='publish-kebab-zrb-package-name',
+    description='Publish human readable zrb package name',
+    group=project_group,
+    inputs=[
+        StrInput(
+            name='kebab-zrb-package-name-repo',
+            prompt='Pypi repository for human readable zrb package name',
+            description='Pypi repository for human readalbe zrb package name',
+            default='pypi',
+        )
+    ],
+    upstreams=[build_snake_zrb_package_name],
+    cwd=RESOURCE_DIR,
+    cmd_path=os.path.join(CURRENT_DIR, 'cmd', 'publish.sh'),
+)
+runner.register(publish_snake_zrb_package_name)
+
+install_snake_zrb_package_name_symlink = CmdTask(
+    name='install-kebab-zrb-package-name-symlink',
+    description='Install human readable zrb package name as symlink',
+    group=project_group,
+    upstreams=[build_snake_zrb_package_name],
+    cwd=RESOURCE_DIR,
+    cmd_path=os.path.join(CURRENT_DIR, 'cmd', 'install-symlink.sh'),
+)
+runner.register(install_snake_zrb_package_name_symlink)

zrb/builtin/generator/pip_package/template/src/kebab-zrb-package-name/.gitignore

@@ -0,0 +1 @@
+./dist

zrb/builtin/generator/pip_package/template/src/kebab-zrb-package-name/README.md

@@ -0,0 +1,79 @@
+# Human readable zrb package name
+
+kebab-zrb-package-name is a [pypi](https://pypi.org) package.
+
+You can install kebab-zrb-package-name by invoking:
+
+```
+pip install kebab-zrb-package-name
+```
+
+# For maintainers
+
+## Publish to pypi
+
+To publish kebab-zrb-package-name, you need to have a `Pypi` account:
+
+- Log in or register to [https://pypi.org/](https://pypi.org/)
+- Create an API token
+
+You can also create a `TestPypi` account:
+
+- Log in or register to [https://test.pypi.org/](https://test.pypi.org/)
+- Create an API token
+
+Once you have your API token, you need to create a `~/.pypirc` file:
+
+```
+[distutils]
+index-servers =
+   pypi
+   testpypi
+
+[pypi]
+  repository = https://upload.pypi.org/legacy/
+  username = __token__
+  password = pypi-xxx-xxx
+[testpypi]
+  repository = https://test.pypi.org/legacy/
+  username = __token__
+  password = pypi-xxx-xxx
+```
+
+To publish kebab-zrb-package-name, you can do the following command:
+
+```bash
+zrb project publish-kebab-zrb-package-name
+```
+
+## Updating version
+
+You can update kebab-zrb-package-name version by modifying the following section in `pyproject.toml`:
+
+```toml
+[project]
+version = "0.0.2"
+```
+
+## Adding dependencies
+
+To add kebab-zrb-package-name dependencies, you can edit the following section in `pyproject.toml`:
+
+```toml
+[project]
+dependencies = [
+    "Jinja2==3.1.2",
+    "jsons==1.6.3"
+]
+```
+
+## Adding script
+
+To make zrb-package-name executable, you can edit the following section in `pyproject.toml`:
+
+```toml
+[project-scripts]
+kebab-zrb-package-name = "kebab-zrb-package-name.__main__:hello"
+```
+
+This will look for `hello` callable inside of your `__main__.py` file

zrb/builtin/generator/pip_package/template/src/kebab-zrb-package-name/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["flit_core>=3.4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "kebab-zrb-package-name"
+version = "0.0.1"
+authors = [
+  { name="zrbPackageAuthorName", email="zrbPackageAuthorEmail" },
+]
+description = "zrbPackageDescription"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
+  "Operating System :: OS Independent",
+]
+dependencies = []
+ 
+
+[project.optional-dependencies]
+dev = []
+test = []
+
+[project.urls]
+"Homepage" = "zrbPackageHomepage"
+"Bug Tracker" = "zrbPackageBugTracker"
+
+[project.scripts]
+kebab-zrb-package-name = "snake_zrb_package_name.__main__:hello"
+
+[tool.pytest.ini_options]
+pythonpath = [
+  "src"
+]

zrb/builtin/generator/pip_package/template/src/kebab-zrb-package-name/requirements.txt

@@ -0,0 +1,4 @@
+# Build dependencies
+flit==3.9.0         # better builder
+twine==4.0.2        # pip package uploader
+keyring==24.2.0     # authenticator (used by twine)

zrb/builtin/generator/pip_package/template/src/kebab-zrb-package-name/src/snake_zrb_package_name/__init__.py

@@ -0,0 +1,2 @@
+from .util import hello
+assert hello

zrb/builtin/generator/pip_package/template/src/kebab-zrb-package-name/src/snake_zrb_package_name/__main__.py

@@ -0,0 +1,2 @@
+from .util import hello
+assert hello

zrb/builtin/generator/pip_package/template/src/kebab-zrb-package-name/src/snake_zrb_package_name/util.py

@@ -0,0 +1,2 @@
+def hello(name: str = 'World'):
+    return f'Hello {name}!'