vjer 30.0.0__py3-none-any.whl

vjer/__init__.py

@@ -0,0 +1,26 @@
+"""Vjer CI/CD module.
+
+This module provides utilities for making it easier to write CI/CD automations.
+
+"""
+
+__all__ = ('__title__', '__summary__', '__uri__',
+           '__version__', '__build_name__', '__build_date__',
+           '__author__', '__email__',
+           '__license__', '__copyright__')
+
+__title__ = 'Vjer'
+__summary__ = 'CI/CD Toolkit'
+__uri__ = 'https://github.com/tardis4500/vjer/'
+
+__version__ = '30.0.0'
+__build_name__ = '{var:build_name}'
+__build_date__ = '{var:build_date}'
+
+__author__ = 'Jeffery G. Smith'
+__email__ = 'web@pobox.com'
+
+__license__ = 'MIT'
+__copyright__ = 'Copyright (c) 2024 Jeffery G. Smith'
+
+# cSpell:ignore vjer

vjer/build.py

@@ -0,0 +1,117 @@
+"""This module provides build actions."""
+
+# Import standard modules
+from os import getenv
+from pathlib import Path
+from shutil import copyfile
+from tempfile import mkdtemp
+from typing import cast, Optional
+
+# Import third-party modules
+from batcave.fileutil import pack
+from batcave.lang import str_to_pythonval
+from batcave.sysutil import rmpath
+from docker.errors import BuildError as DockerBuildError
+
+# Import project modules
+from .utils import VJER_ENV, VjerAction, VjerStep, helm
+
+
+class BuildStep(VjerStep):
+    """This class provides build support.
+
+        Build processing flow:
+          pre:
+              remove an old artifact directory
+              create the artifact directory
+              update the version files
+          execute:
+              run the inheriting build() method for the project type
+          post:
+              revert the version files
+    """
+    def pre(self) -> None:
+        """This method is run at the start of the build."""
+        super().pre()
+        if self.step_info.is_first_step:
+            self.log_message('Preparing artifact directory', True)
+            if Path(self.project.artifacts_dir).exists():
+                self.log_message(f'Removing stale artifact directory: {self.project.artifacts_dir}')
+                rmpath(self.project.artifacts_dir)
+            if not Path(self.project.artifacts_dir).exists():
+                self.log_message(f'Creating clean artifact directory: {self.project.artifacts_dir}')
+                Path(self.project.artifacts_dir).mkdir(parents=True)
+        self.update_version_files()
+
+    def post(self) -> None:
+        """This method is run at the end of the build."""
+        super().post()
+        self.log_message('Build Completed Successfully', True)
+
+    def always_post(self) -> None:
+        """This method is always run at the end of the build."""
+        super().always_post()
+        self.update_version_files(reset=True)
+
+    def create_archive(self, name: str, what: list, /, *, location: Optional[str] = None, arc_type: Optional[str] = None, use_tmpdir: bool = False) -> None:  # pylint: disable=too-many-arguments
+        """Helper function to create an archive. When complete, the archive is copied to the project build artifact directory.
+
+        Args:
+            name: The archive file name.
+            what: The files to include in the archive.
+            location (optional, default=None): The location of the files to archive. If None, the current directory is used.
+            arc_type (optional, default=None): The type of the archive. If None, is inferred from the file extension.
+            use_tmpdir (optional, default=False): If True, create the archive in a temporary directory.
+
+        Returns:
+            Nothing.
+        """
+        package_dir = Path(mkdtemp()) if use_tmpdir else self.project.artifacts_dir
+        package = package_dir / name
+        try:
+            self.log_message(f'Creating "{package}" archive from: {",".join(what)}', True)
+            pack(package, what, item_location=location, archive_type=str(arc_type), ignore_empty=False)
+            copyfile(package, self.project.artifacts_dir / name)
+        finally:
+            if use_tmpdir:
+                rmpath(package_dir)
+
+    def build_docker(self) -> None:
+        """Run a Docker build."""
+        push_image = str_to_pythonval(getenv('VJER_DOCKER_PUSH', str(not VJER_ENV == 'local')))
+        self._docker_init(push_image)
+        self.log_message(f'Building docker image: {self.image_tag}', True)
+        build_args = {'VERSION': self.project.version,
+                      'BUILD_VERSION': self.build.build_version} | self.step_info.build_args
+        platform_arg = {'platform': platform} if (platform := getenv('DOCKER_DEFAULT_PLATFORM', '')) else {}
+        try:
+            log = self.docker_client.client.images.build(rm=True, pull=True, tag=self.image_tag,
+                                                         dockerfile=(self.dockerfile),
+                                                         buildargs=build_args.toDict(),
+                                                         path=str(self.project.project_root),
+                                                         **platform_arg)[1]
+            error = None
+        except DockerBuildError as err:
+            error = err
+            log = err.build_log
+        for line in log:
+            if ('stream' in line) and (line['stream'] != '\n'):
+                self.log_message(line['stream'].strip())
+        if error:
+            raise error
+        if push_image:
+            self.log_message('Pushing image to registry', True)
+            self.registry_client.get_image(self.image_tag).push()
+
+    def build_helm(self) -> None:
+        """Build method for Helm charts."""
+        helm('dependency', 'build', self.helm_chart_root)
+        helm('package', self.helm_chart_root)
+        self.copy_artifact(self.helm_package.name)
+
+
+def build() -> None:
+    """This is the main entry point."""
+    VjerAction('build', cast(VjerStep, BuildStep)).execute()
+
+# cSpell:ignore batcave fileutil pythonval buildargs vjer

vjer/deploy.py

@@ -0,0 +1,34 @@
+"""This module provides deployment actions."""
+
+# Import standard module
+from typing import cast
+
+# Import project modules
+from .utils import helm, VjerAction, VjerStep
+
+
+class DeployStep(VjerStep):
+    """This class provides deployment support."""
+
+    def deploy_helm(self) -> None:
+        """Deploy method for Helm charts."""
+        chart_name = self.step_info.chart_name if self.step_info.chart_name else self.project.product.lower()
+        release_name = self.step_info.release_name.lower() if self.step_info.release_name else chart_name
+        helm_args = self.helm_args
+        is_remote = self.step_info.remote is not False
+        if is_remote:
+            helm_chart = f'{self.helm_repo.name}/{chart_name}'
+            if 'version' not in helm_args:
+                helm_args['version'] = self.project.version
+        else:
+            helm_chart = self.helm_package
+        if is_remote:
+            helm('repo', 'update')
+        helm('upgrade', release_name, helm_chart, install=True, atomic=True, wait=True, **helm_args)
+
+
+def deploy() -> None:
+    """This is the main entry point."""
+    VjerAction('deploy', cast(VjerStep, DeployStep)).execute()
+
+# cSpell:ignore vjer

vjer/freeze.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""This module creates a Python freeze file for the project.
+
+Attributes:
+    PROJECT_ROOT (Path): The root directory of the project.
+    FREEZE_FILE_EXT (str): The extension for the frozen requirements file.
+    REQUIREMENTS_FILE (Path): The full path of the frozen requirements file.
+    FREEZE_FILE_BASE (str): The base name of the frozen requirements file.
+    LINUX_MODULES (list): A list of modules that should be limited to the linux platform.
+    WINDOWS_MODULES (list): A list of modules that should be limited to the Windows platform.
+"""
+
+# Import standard modules
+import os
+from pathlib import Path
+from sys import argv
+from tempfile import mkdtemp
+from venv import EnvBuilder
+
+# Import BatCave modules
+from batcave.fileutil import slurp, spew
+from batcave.lang import WIN32
+from batcave.sysutil import rmpath, syscmd, SysCmdRunner
+
+from .utils import DEFAULT_ENCODING
+
+PROJECT_ROOT = Path.cwd()
+FREEZE_FILE_EXT = '.txt'
+REQUIREMENTS_FILE = (PROJECT_ROOT / 'requirements').with_suffix(FREEZE_FILE_EXT)
+FREEZE_FILE_BASE = 'requirements-frozen'
+LINUX_MODULES: list = []
+WINDOWS_MODULES = ['WMI']
+
+pip = SysCmdRunner('pip', show_cmd=False, show_stdout=False, syscmd_args={'ignore_stderr': True}).run
+
+
+def freeze() -> None:
+    """Create the requirement-freeze.txt file leaving out the development tools and adding platform specifiers."""
+    freeze_file = (PROJECT_ROOT / (FREEZE_FILE_BASE + (f'-{argv[2]}' if (len(argv) > 2) else ''))).with_suffix(FREEZE_FILE_EXT)
+    print('Creating virtual environment in:', venv_dir := Path(mkdtemp()))
+    EnvBuilder(with_pip=True).create(venv_dir)
+    python = ((venv_bin := venv_dir / ('Scripts' if WIN32 else 'bin')) / 'python').with_suffix('.exe' if WIN32 else '')
+    os.environ['PATH'] = os.path.pathsep.join((str(venv_bin), os.environ['PATH']))
+    print('Upgrading pip')
+    syscmd(str(python), '-m', 'pip', 'install', '-qqq', '--upgrade', 'pip')
+    print('Updating pip install tools')
+    pip('install', '-qqq', 'setuptools', 'wheel', upgrade=True)
+    print('Installing modules from', REQUIREMENTS_FILE)
+    pip('install', '-qqq', upgrade=True, requirement=REQUIREMENTS_FILE)
+    print('Creating frozen requirements file:', freeze_file)
+    spew(freeze_file, pip('freeze', requirement=REQUIREMENTS_FILE))
+    freeze_file_contents = [line.strip() for line in slurp(freeze_file)]
+    with open(freeze_file, 'w', encoding=DEFAULT_ENCODING) as freeze_file_stream:
+        for line in freeze_file_contents:
+            module = line.split('==')[0]
+            if ('win32' in module) or (module in WINDOWS_MODULES):
+                line += "; sys_platform == 'win32'"
+            if ('ansible' in module) or (module in LINUX_MODULES):
+                line += "; sys_platform != 'win32'"
+            print(line, file=freeze_file_stream)
+    rmpath(venv_dir)
+
+# cSpell:ignore batcave fileutil syscmd

vjer/pre_release.py

@@ -0,0 +1,42 @@
+"""This module provides pre-release actions."""
+
+# Import standard modules
+from typing import cast
+
+# Import project modules
+from .release import ReleaseStep
+from .utils import VjerAction, VjerStep, helm
+
+
+class PreReleaseStep(ReleaseStep):
+    """Provide pre_release support.
+
+    Attributes:
+        is_pre_release: Specifies to the ReleaseStep parent class that this is a pre-release action.
+    """
+    is_pre_release = True
+
+    def __init__(self):
+        """Sets the project version to a pre-release value."""
+        super().__init__()
+        self.project.version = f'{self.project.version}-{self.pre_release_num}'
+
+    def release_helm(self) -> None:
+        """Pre-release a Helm chart."""
+        if self.helm_repo.type == 'oci':
+            self.update_version_files()
+            try:
+                helm('package', self.helm_chart_root)
+                self.copy_artifact(self.helm_package.name)
+            finally:
+                self.update_version_files(reset=True)
+        else:
+            list(self.project.artifacts_dir.glob('*.tgz'))[0].rename(self.helm_package)
+        super().release_helm()
+
+
+def pre_release() -> None:
+    """This is the main entry point."""
+    VjerAction('release', cast(VjerStep, PreReleaseStep)).execute()
+
+# cSpell:ignore batcave vjer

vjer/release.py

@@ -0,0 +1,70 @@
+"""This module provides release actions."""
+
+# Import standard modules
+from typing import cast
+
+# Import third-party modules
+from batcave.cloudmgr import gcloud
+
+# Import project modules
+from .utils import helm, VjerAction, VjerStep
+
+
+class ReleaseStep(VjerStep):
+    """Provide release support.
+
+    Attributes:
+        is_pre_release: Specifies that this is not a pre-release action.
+    """
+    is_pre_release = False
+
+    def release_docker(self) -> None:
+        """Perform a release of a Docker image by tagging."""
+        self._docker_init()
+        if (registry := self.container_registry).type not in ('gcp', 'jfrog'):
+            (image := self.registry_client.get_image(self.image_tag)).pull()
+        default_tags = [self.version_tag.lower()]
+        if not self.is_pre_release:
+            default_tags.append(f'{self.image_name}:latest'.lower())
+        for tag in self.step_info.tags if self.step_info.tags else default_tags:
+            self.log_message(f'Tagging image: {tag}')
+            match registry.type:
+                case 'gcp':
+                    gcloud('container', 'images', 'add-tag', self.image_tag, tag, syscmd_args={'ignore_stderr': True})
+                case  _:
+                    image.tag(tag)
+                    image.push()
+
+    def release_helm(self) -> None:
+        """Perform a release of a Helm chart."""
+        helm('push', self.helm_package, self.helm_repo.name, **self.helm_repo.push_args)
+
+    def release_increment_release(self) -> None:
+        """Increment the project release version."""
+        if self.is_pre_release:
+            self.log_message('Skipping on pre-release')
+            return
+        if hasattr(self.project, 'version_service'):
+            self.log_message('Incrementing version service not supported...skipping')
+            return
+        version_tuple = self.project.version.split('.')
+        version_tuple[len(version_tuple) - 1] = str(int(version_tuple[-1]) + 1)
+        new_version = '.'.join(version_tuple)
+        use_branch = self.step_info.increment_branch if self.step_info.increment_branch else self.git_client.CI_COMMIT_REF_NAME
+        self.project.version = new_version
+        self.log_message(f'Incrementing release to {new_version} on branch {use_branch}')
+        self.commit_files('Automated pipeline version update check-in [skip ci]', use_branch, self.config.filename, file_updater=self.config.write)
+
+    def release_tag_source(self) -> None:
+        """Tag the source in Git with a release tag."""
+        if self.is_pre_release:
+            self.log_message('Skipping on pre-release')
+            return
+        self.tag_source(self.release.release_tag, f'Release {self.release.release_tag}')
+
+
+def release() -> None:
+    """This is the main entry point."""
+    VjerAction('release', cast(VjerStep, ReleaseStep)).execute()
+
+# cSpell:ignore syscmd batcave cloudmgr vjer

vjer/rollback.py

@@ -0,0 +1,25 @@
+"""This module provides deployment rollback actions."""
+
+# Import standard module
+from typing import cast
+
+# Import project modules
+from .utils import VjerAction, VjerStep, helm
+
+
+class RollbackStep(VjerStep):
+    """This class provides rollback support."""
+
+    def rollback_helm(self) -> None:
+        """Rollback method for Helm charts."""
+        chart_name = self.step_info.chart_name if self.step_info.chart_name else self.project.product.lower()
+        helm('rollback',
+             self.step_info.release_name.lower() if self.step_info.release_name else chart_name,
+             wait=True, **self.helm_args)
+
+
+def rollback() -> None:
+    """This is the main entry point."""
+    VjerAction('rollback', cast(VjerStep, RollbackStep)).execute()
+
+# cSpell:ignore vjer

vjer/test.py

@@ -0,0 +1,52 @@
+"""This module provides test actions."""
+
+# Import standard modules
+from pathlib import Path
+from typing import cast
+
+# Import third-party-modules
+from batcave.fileutil import slurp
+from batcave.sysutil import rmpath, syscmd
+from yaml import full_load as yaml_load
+
+# Import project modules
+from .utils import DEFAULT_ENCODING, VjerAction, VjerStep, helm
+
+
+class TestStep(VjerStep):
+    """This class provides test support."""
+
+    def pre(self) -> None:
+        """Prepare for testing on first run."""
+        super().pre()
+        if self.step_info.is_first_step:
+            self.log_message('Preparing test results directory', True)
+            if Path(self.project.test_results_dir).exists():
+                self.log_message(f'Removing test results directory: {self.project.test_results_dir}')
+                rmpath(self.project.test_results_dir)
+            if not Path(self.project.test_results_dir).exists():
+                self.log_message(f'Creating clean test results directory: {self.project.test_results_dir}')
+                Path(self.project.test_results_dir).mkdir(parents=True)
+
+    def test_docker(self) -> None:
+        """Lint method for Docker dockerfiles."""
+        dockerfile = slurp(self.dockerfile)
+        syscmd('docker', 'run', '--interactive', '--rm', 'hadolint/hadolint', input_lines=dockerfile, ignore_stderr=True)
+        if self.step_info.build_test_stage:
+            self.docker_build(target=self.step_info.build_test_stage)
+
+    def test_helm(self) -> None:
+        """Lint method for Helm charts."""
+        helm('dependency', 'build', self.helm_chart_root)
+        helm('lint', self.helm_chart_root, **self.helm_args)
+        with open(self.helm_chart_root / 'Chart.yaml', encoding=DEFAULT_ENCODING) as yaml_stream:
+            helm_info = yaml_load(yaml_stream)
+        if helm_info['type'] != 'library':
+            helm('template', self.helm_chart_root, **self.helm_args)
+
+
+def test() -> None:
+    """This is the main entry point."""
+    VjerAction('test', cast(VjerStep, TestStep)).execute()
+
+# cSpell:ignore batcave fileutil syscmd hadolint dockerfiles vjer

vjer/tool_reporter.py

@@ -0,0 +1,85 @@
+"""This program prints the tool information.
+
+Attributes:
+    PRODUCTS (list): This list of products on which to report.
+"""
+
+# Import standard modules
+from re import compile as re_compile
+
+# Import third-party modules
+from batcave.lang import CommandResult
+from batcave.sysutil import syscmd, CMDError
+from dotmap import DotMap
+
+PRODUCTS = [DotMap(name='Docker', regex=re_compile('Docker version (.+)')),
+            DotMap(name='Helm', args=['version'], regex=re_compile(r'Version:"v([\d\.]+)"'))]
+
+
+def tool_reporter() -> dict:
+    """Construct the tool report.
+
+    Returns:
+        A dictionary representing the report. There are three members in the dictionary:
+            tool_versions: a dictionary of the tools with their versions.
+            helm_plugins: a list of the helm plugins.
+            helm_repos: a list of the helm repositories.
+    """
+    tool_info = DotMap(tool_versions={})
+    for product in PRODUCTS:
+        tool_info.tool_versions[product.name] = get_version(product)
+
+    tool_info.helm_plugins = get_helm_info('plugin')
+    tool_info.helm_repos = get_helm_info('repo')
+    return tool_info.toDict()
+
+
+def get_version(product: DotMap) -> str | list:
+    """Determine the version for the specified product.
+
+    Args:
+        product: The product for which the version should be returned.
+
+    Returns:
+        The version of the specified product.
+    """
+    version_command = product.command if product.command else product.name.lower()
+    version_args = product.args if product.args else ['--version']
+    version_info: CommandResult = []
+    try:
+        version_info = syscmd(version_command, *version_args, ignore_stderr=True, append_stderr=True)
+    except FileNotFoundError:
+        pass
+    except CMDError as err:
+        if not (('not found' in str(err)) or ('not be found' in str(err)) or ('command could not be loaded' in str(err))):
+            raise
+    if product.raw:
+        return version_info
+    return version[1] if (version := product.regex.search(' '.join([line.strip() for line in version_info]))) else 'Not Found'
+
+
+def get_helm_info(info_type: str) -> dict:
+    """Return the requested Helm info.
+
+    Args:
+        info_type: The type of helm info to return.
+
+    Returns:
+        A dictionary of the requested info.
+    """
+    helm_info = {}
+    try:
+        for line in syscmd('helm', info_type, 'list', ignore_stderr=True):
+            if line.startswith('NAME'):
+                continue
+            (name, url) = line.split()[0:2]
+            helm_info[name] = url
+    except FileNotFoundError:
+        helm_info['Helm'] = 'not installed'
+    except CMDError as err:
+        if 'no repositories to show' not in ''.join(err.vars['err_lines']):
+            raise
+        helm_info['found'] = 'none'
+    return helm_info if helm_info else {'found': 'none'}
+
+# cSpell:ignore batcave syscmd dotmap

vjer/utils.py

@@ -0,0 +1,575 @@
+"""Module to hold common values and utility functions for CI/CD support scripts.
+
+Attributes:
+    PROJECT_CFG_FILE (str): The name of the project config file.
+    TOOL_REPORT (Path): The path of the tool report.
+
+    RELEASE_PRE_STEPS (list): The list of release steps to perform before the ones specified for the project.
+    RELEASE_POST_STEPS (list): The list of release steps to perform before the ones specified for the project.
+
+    There are several tool runners defined for simplified usage: git, helm.
+"""
+# Import standard modules
+from copy import deepcopy as copy_object
+from datetime import datetime
+from os import getenv
+from pathlib import Path
+from random import randint
+from shutil import copy, copyfile, copytree
+from stat import S_IWUSR
+from string import Template
+from sys import exit as sys_exit, stderr
+from typing import Callable, cast, Optional
+
+# Import third-party modules
+from batcave.automation import Action
+from batcave.cloudmgr import Cloud, CloudType
+from batcave.cms import Client, ClientType
+from batcave.expander import Expander, file_expander
+from batcave.lang import BatCaveError, BatCaveException, PathName, DEFAULT_ENCODING, WIN32, yaml_to_dotmap
+from batcave.platarch import Platform
+from batcave.sysutil import CMDError, SysCmdRunner, syscmd
+from dotmap import DotMap
+from yaml import safe_dump as yaml_dump, safe_load as yaml_load
+
+# Import project modules
+from . import __title__, __version__, __build_name__, __build_date__
+from .tool_reporter import tool_reporter
+
+_CONFIG_SECTIONS = ('project', 'test', 'build', 'deploy', 'rollback', 'release')
+_PROJECT_DEFAULTS = DotMap(build_artifacts='artifacts',
+                           build_num_var='VJER_BUILD_NUM',
+                           chart_root='helm-chart',
+                           container_registry=DotMap(type='local', name=''),
+                           dockerfile='Dockerfile',
+                           gcp_artifact_region='us',
+                           test_results='test_results')
+_VALID_SCHEMAS = [1]
+
+PROJECT_CFG_FILE = getenv('VJER_CFG', 'vjer.yml')
+TOOL_REPORT = Path(__file__).parent.absolute() / 'tool_report.yml'
+
+HELM_CHART_FILE = 'Chart.yaml'
+DEFAULT_VERSION_FILES = {'helm': [HELM_CHART_FILE, 'values.yaml']}
+
+RELEASE_PRE_STEPS = ['tag_source']
+RELEASE_POST_STEPS = ['increment_release']
+
+VJER_ENV = getenv('VJER_ENV', 'local')
+REMOTE_REF = 'vjer_origin'
+
+apt = SysCmdRunner('apt-get', '-y').run
+apt_install = SysCmdRunner('apt-get', '-y', 'install', no_install_recommends=True).run
+git = SysCmdRunner('git').run
+helm = SysCmdRunner('helm', syscmd_args={'ignore_stderr': True}).run
+pip_install = SysCmdRunner('pip', 'install', quiet=True, no_cache_dir=True, upgrade=True).run
+
+
+class ConfigurationError(BatCaveException):
+    """Configuration errors.
+
+    Attributes:
+        BAD_FORMAT: The format of the configuration file is bad.
+        CONFIG_FILE_NOT_FOUND: The config file was not found.
+        INVALID_SCHEMA: The schema of the configuration file is not supported.
+    """
+    BAD_FORMAT = BatCaveError(1, Template('Invalid format for configuration file: $file'))
+    CONFIG_FILE_NOT_FOUND = BatCaveError(2, Template('Configuration file not found: $file'))
+    INVALID_SCHEMA = BatCaveError(3, Template('Invalid configuration schema: found=$found, expected=$expected'))
+
+
+class StepError(BatCaveException):
+    """Step errors.
+
+    Attributes:
+        UNKNOWN_OBJECT: The specified object is of an unknown type.
+    """
+    UNKNOWN_OBJECT = BatCaveError(1, Template('Unknown $type: $name'))
+
+
+class Environment:  # pylint: disable=too-few-public-methods
+    """Provides an interface to the environment variables."""
+
+    def __getattr__(self, attr: str):
+        value = getenv(attr)
+        if value is None:
+            raise AttributeError(f'Environment variable not found: {attr}')
+        return value
+
+
+class GitClient(Environment):
+    """Provides an interface to the Git server environment and API."""
+
+    def __init__(self, project_id: Optional[str] = None, client_root: Optional[PathName] = None, branch: Optional[str] = None):
+        """
+        Args:
+            project_id (optional, default=None): The ID of the Git project.
+            client_root (optional, default=None): The root directory of the project.
+            branch (optional, default=None): The branch to use for the Git client.
+
+        Attributes:
+            CI_REMOTE_REF: The full git reference to the project.
+            branch: The value of the branch argument.
+            client: The git client for the project.
+            project_id: The value of the project_id argument.
+        """
+        self.project_id = project_id
+        self.client = Client(ClientType.git, 'vjer', connect_info=str(client_root), create=False) if (client_root and (Path(client_root) / '.git').exists()) else None
+        self.branch = branch if branch else getattr(self, 'CI_COMMIT_BRANCH', '')
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_unused_exc_info):
+        return False
+
+
+class ConfigSection():
+    """Base class to manage configuration sections."""
+
+    def __init__(self, **defaults):
+        """
+        Args:
+            **defaults: The default items for the configuration.
+
+        Attributes:
+            _default_property_holders: A list of property holders for defaults.
+            _defaults: The configuration defaults.
+            _expander: The expander to use for variable replacement.
+            _values: The configuration values.
+        """
+        self._values = DotMap()
+        self._defaults = DotMap(**defaults)
+        self._default_property_holders = [Environment()]
+        self._expander = None
+        self.update_expander(property_holders=self._default_property_holders)
+
+    def __getattr__(self, attr: str):
+        for config in (self._values, self._defaults):
+            if attr in config:
+                value = getattr(config, attr)
+                if isinstance(value, list):
+                    return [self._expander.expand(v) for v in value]
+                if isinstance(value, dict):
+                    return DotMap({k: self._expander.expand(v) for (k, v) in value.items()})
+                if isinstance(value, str):
+                    return self._expander.expand(value)
+                return value
+        raise AttributeError(f'No configuration value found: {attr}')
+
+    def __setattr__(self, attr: str, value: str):
+        if attr.startswith('_'):
+            super().__setattr__(attr, value)
+            return
+        setattr(self._values, attr, value)
+
+    values = property(lambda s: s._values.toDict(), doc='A read-only property which returns the configuration values.')
+
+    def update_expander(self, *, property_holders: Optional[list] = None, property_dict: Optional[dict] = None) -> None:
+        """Set the expander property holders.
+
+        Args:
+            property_holders (optional, default=None): A list of property holders from which to read values.
+            property_dict (optional, default=None): A dictionary from which to read values.
+
+        Returns:
+            Nothing.
+        """
+        if property_holders:
+            self._expander = Expander(var_props=property_holders + self._default_property_holders)
+        if property_dict:
+            self._expander.var_dict |= property_dict
+
+    def update(self, values: dict | DotMap, /) -> None:
+        """Update the configuration section values.
+
+        Args:
+            values: Update the configuration values from the provided dictionary.
+
+        Returns:
+            Nothing.
+        """
+        self._values |= values
+
+    def update_defaults(self, values: dict | DotMap, /) -> None:
+        """Updates the configuration section default values.
+
+        Args:
+            values: Update the defaults with the provided dictionary.
+
+        Returns:
+            Nothing.
+        """
+        self._defaults |= values
+
+
+class ProjectConfig():
+    """Stores project related configuration items."""
+
+    def __init__(self):
+        """
+        Attributes:
+            _config_file: The config file for the project configuration.
+            _sections: A list of the sections in the project configuration.
+            schema: The schema version of the project configuration.
+            use_steps: A dictionary of steps by section.
+        """
+        project_root = Path.cwd()
+        self._sections = {'project': ConfigSection(**(DotMap(project_root=project_root) | _PROJECT_DEFAULTS)),
+                          'test': ConfigSection(),
+                          'deploy': ConfigSection(clean=True),
+                          'rollback': ConfigSection(clean=True),
+                          'release': ConfigSection()}
+        self._sections['build'] = ConfigSection(source_dir=self.project.project_root / 'src',
+                                                version_files=[],
+                                                artifacts={},
+                                                build_date=str(datetime.now()),
+                                                platform=Platform().bart)
+        self._config_file = self.project.project_root / PROJECT_CFG_FILE
+        self._load_config()
+        self._set_defaults()
+        self._set_version()
+
+        for section in _CONFIG_SECTIONS:
+            self._sections[section].update_expander(property_holders=list(self._sections.values()))
+
+        release_steps = [self._get_phase_step('release', s) for s in RELEASE_PRE_STEPS]
+        if hasattr(self.release, 'steps'):
+            release_steps += [copy_object(s) for s in self.release.steps if s.get('type') not in RELEASE_PRE_STEPS + RELEASE_POST_STEPS]
+        release_steps += [self._get_phase_step('release', s) for s in RELEASE_POST_STEPS]
+        self.use_steps = {'release': release_steps}
+
+    def __getattr__(self, attr: str):
+        if attr not in self._sections:
+            raise AttributeError(f'Configuration section not found: {attr}')
+        return self._sections[attr]
+
+    def _get_phase_step(self, phase: str, step_type: str) -> DotMap:
+        """Get the specified step type for the specified phase.
+
+        Args:
+            phase: The phase for which to return the step.
+            step_type: The step type to return from the phase.
+
+        Returns:
+            A DotMap for the step.
+        """
+        if hasattr(phase_ref := getattr(self, phase), 'steps'):
+            for step in phase_ref.steps:
+                if step.get('type') == step_type:
+                    return copy_object(step)
+        return DotMap(type=step_type)
+
+    def _load_config(self) -> None:
+        if not self._config_file.exists():
+            raise ConfigurationError(ConfigurationError.CONFIG_FILE_NOT_FOUND, file=self._config_file)
+        yaml_as_dict = DotMap(schema=0)
+        with open(self._config_file, encoding=DEFAULT_ENCODING) as config_file:
+            yaml_as_dict |= DotMap(yaml_load(config_file))
+        if not yaml_as_dict:
+            raise ConfigurationError(ConfigurationError.BAD_FORMAT, file=self._config_file)
+        if yaml_as_dict.schema not in _VALID_SCHEMAS:
+            raise ConfigurationError(ConfigurationError.INVALID_SCHEMA, found=yaml_as_dict.schema, expected=_VALID_SCHEMAS)
+        self.schema = yaml_as_dict.schema
+        for section in _CONFIG_SECTIONS:
+            if section in yaml_as_dict:
+                self._sections[section].update(yaml_as_dict[section])
+
+    def _set_defaults(self) -> None:
+        self.project.update_defaults(DotMap(artifacts_dir=self.project.project_root / self.project.build_artifacts,
+                                            test_results_dir=self.project.project_root / self.project.test_results))
+        if hasattr(self.project, 'artifact_repo'):
+            if hasattr(self.project, 'docker_repo'):
+                self.project.update_defaults(DotMap(container_registry=DotMap(type='local',
+                                                                              name=f'{self.project.gcp_artifact_region}-docker.pkg.dev/{self.project.artifact_repo}/{self.project.docker_repo}')))
+            if hasattr(self.project, 'helm_repo'):
+                self.project.update_defaults(DotMap(chart_repo=DotMap(type='oci',
+                                                                      name=f'oci://{self.project.gcp_artifact_region}-docker.pkg.dev/{self.project.artifact_repo}/{self.project.helm_repo}')))
+
+    def _set_version(self) -> None:
+        if hasattr(self.project, 'version_service'):
+            self._set_version_from_service()
+        build_num = getenv(self.project.build_num_var, '0')
+        build_version = f'{self.project.version}-{build_num}'
+        self.build.update_defaults(DotMap(build_num=build_num,
+                                          build_version=build_version,
+                                          build_version_msbuild=f'{self.project.version}.{build_num}',
+                                          build_name=f'{self.project.product}_{build_version}'))
+        self.release.update_defaults(DotMap(release_tag=f'v{self.project.version}'))
+        for (piece, index) in {'major': 0, 'minor': 1, 'patch': 2}.items():
+            self.project.update_defaults({f'{piece}': self.project.version.split('.', 2)[index]})
+
+    def _set_version_from_service(self) -> None:
+        version_service = DotMap(self.project.version_service)
+        match version_service.type:
+            case 'environment':
+                self.project.version = getenv(version_service.variable, '').rstrip('.')
+            case 'semver':
+                self.project.version = version_service.value
+            case _:
+                print('Unknown version service:', version_service.type, file=stderr)
+                sys_exit(1)
+
+    filename = property(lambda s: s._config_file, doc='A read-only property which returns the configuration file name.')
+
+    def write(self) -> None:
+        """Writes out the project configuration.
+
+        Returns:
+            Nothing.
+        """
+        with open(self._config_file, 'w', encoding=DEFAULT_ENCODING) as config_file:
+            yaml_dump({'schema': self.schema} | {s: c.values for (s, c) in self._sections.items() if c.values},
+                      config_file, indent=2)
+
+
+class VjerStep(Action):  # pylint: disable=too-many-instance-attributes
+    """ Class to represent a single Action step."""
+
+    def __init__(self):
+        """
+        Attributes:
+            build: The project build configuration.
+            config: The project configuration.
+            docker_client: The Docker client.
+            git_client: The Git repository for the project.
+            image_name: The Docker image name.
+            image_tag: The Docker image tag.
+            pre_release_num: The pre-release suffix for the project.
+            project: The project name.
+            registry_client: The Docker image registry.
+            release: The release configuration.
+            step_info: The step information.
+            version_tag: The Docker image version.
+        """
+        super().__init__()
+        self.config = ProjectConfig()
+        self.project = self.config.project
+        self.build = self.config.build
+        self.release = self.config.release
+        self.git_client = GitClient(client_root=self.project.project_root)
+        self.step_info = DotMap()
+        self.pre_release_num = self.build.build_num
+        # Used by Docker builds
+        self.registry_client = None
+        self.docker_client = None
+        self.image_name = ''
+        self.version_tag = ''
+        self.image_tag = ''
+
+    def __getattr__(self, attr: str):
+        if not hasattr(self.project, attr):
+            raise AttributeError(f'No such attribute: {attr}')
+        return getattr(self.step_info, attr) if getattr(self.step_info, attr) else getattr(self.project, attr)
+
+    def _docker_init(self, login: bool = True) -> None:
+        """Perform Docker initialization.
+
+        Args:
+            login (optional, default=True): If True, login to the Docker image registry.
+            mode (optional, default='pull'): The mode for which this initialization will be used.
+
+        Returns:
+            Nothing.
+        """
+        self.registry_client = Cloud(CloudType[self.container_registry.type], login=login)
+        self.docker_client = Cloud(CloudType.local)
+        registry_name_path = f'{self.container_registry.name}/' if login else ''
+        self.image_name = f'{registry_name_path}{self.step_info.image if self.step_info.image else self.project.product}'
+        self.version_tag = f'{self.image_name}:{self.project.version}'
+        self.image_tag = f'{self.version_tag}-{self.build.build_num}'.lower()
+
+    def _execute(self) -> None:
+        """This method is called by the Action super class when this class's execute method is called."""
+        class_name = type(self).__name__.lower().removeprefix('pre').removesuffix('step')
+        action_method = f'{class_name}_{self.step_info.type}'
+        if not hasattr(self, action_method):
+            print(f'No method defined for action type {self.step_info.type} on {class_name}', file=stderr)
+            sys_exit(1)
+        getattr(self, action_method)()
+
+    helm_chart_root = property(lambda s: Path(s.chart_root), doc='A read-only property which returns the helm chart root.')
+    helm_package = property(lambda s: s.project.artifacts_dir / (s.pkg_name.lower() + '.tgz'), doc='A read-only property which returns the helm chart package name.')
+    pkg_name = property(lambda s: f'{s.step_info.pkg_name if s.step_info.pkg_name else s.project.product}-{s.project.version}',
+                        doc='A read-only property which returns the release package name.')
+
+    @property
+    def helm_args(self) -> dict:
+        """A read-only property which returns the Helm command arguments."""
+        helm_args = self.step_info.helm_args if self.step_info.helm_args else {}
+        if self.step_info.values_files:
+            helm_args['values'] = ','.join([str(self.project.artifacts_dir / v) for v in self.step_info.values_files])
+        if self.step_info.helm_variables:
+            helm_args['set'] = ','.join([f'{k}={v}' for (k, v) in self.step_info.helm_variables.items()])
+        return helm_args
+
+    @property
+    def helm_repo(self) -> DotMap:
+        """A read-only property which returns the Helm repo name with a randomized suffix."""
+        if (self.chart_repo.type != 'oci') and self.chart_repo.url and not self.chart_repo.name:
+            repo_name = f'vjer-{randint(0, 100)}'
+            helm('repo', 'add', repo_name, self.chart_repo.url)
+            helm('repo', 'update')
+            self.chart_repo.name = repo_name
+        return self.chart_repo
+
+    def commit_files(self, message: str, branch: str, *files, file_updater: Optional[Callable] = None) -> None:
+        """Checkin files during to the source repository."""
+        self.git_client.client.add_remote_ref(remote_ref := REMOTE_REF, self.git_client.CI_REMOTE_REF, exists_ok=True)
+        git('fetch', all=True, syscmd_args={'ignore_stderr': True})
+        git('remote', 'update', remote_ref, prune=True, syscmd_args={'ignore_stderr': True})
+        git('checkout', '-B', branch, '--track', f'{remote_ref}/{branch}', syscmd_args={'ignore_stderr': True})
+        git('pull', remote_ref, branch, syscmd_args={'ignore_stderr': True})
+        if file_updater:
+            file_updater()
+        self.git_client.client.add_files(*files)
+        self.git_client.client.checkin_files(message, remote=remote_ref, all_branches=False)
+
+    def copy_artifact(self, src: PathName, dest: Optional[str] = None, /) -> None:
+        """Helper method to copy artifacts to the location expected by the continuous integration tool.
+
+        Args:
+            src: The source of the artifact to copy.
+            dest (optional, default=None): The directory to which to copy the artifact.
+                                            If not absolute, this will be a subdirectory of the project archive directory.
+
+        Returns:
+            Nothing.
+        """
+        use_dest = self.project.artifacts_dir
+        if dest:
+            if Path(dest).is_absolute():
+                use_dest = Path(dest)
+            else:
+                use_dest /= dest
+        self.log_message(f'Copying "{src}" to "{use_dest}"')
+        if not Path(src).is_dir():
+            copy(src, use_dest)
+            return
+
+        if WIN32:
+            try:
+                syscmd('robocopy', str(src), str(use_dest), '/S', '/DCOPY:D', '/COPY:D', '/MT', '/R:3', '/W:30', '/TBD', '/NP', '/NFL', show_stdout=True, ignore_stderr=True, append_stderr=True)
+            except CMDError as err:
+                if err.vars['returncode'] != 1:
+                    raise
+            return
+
+        copytree(str(src), str(use_dest), dirs_exist_ok=True)
+
+    def tag_source(self, tag: str, label: Optional[str] = None) -> None:
+        """Tag the source in Git.
+
+        Args:
+            tag: The label which which to tag the source.
+            label (optional, default=None): The annotation to apply to the tag.
+
+        Returns:
+            Nothing.
+        """
+        self.log_message('Removing local tags and adding remote')
+        for local_tag in [t.strip() for t in git('tag', list=True)]:
+            git('tag', local_tag, delete=True)
+        self.git_client.client.add_remote_ref(REMOTE_REF, self.git_client.CI_REMOTE_REF, exists_ok=True)
+        self.log_message(f'Tagging the source with {tag}')
+        self.git_client.client.add_label(tag, label, exists_ok=True)
+        self.git_client.client.checkin_files('Automated pipeline tag check-in [skip ci]', remote=REMOTE_REF, tags=True, all_branches=False)
+
+    def update_version_files(self, *, reset: bool = False) -> None:  # pylint: disable=too-many-branches
+        """Updates the version files for the project.
+
+        Args:
+            reset (optional, default=False): If True, reset the files.
+
+        Returns:
+            Nothing.
+        """
+        verb = 'Resetting' if reset else 'Updating'
+
+        if not self.step_info.version_files:
+            self.step_info.version_files = []
+
+        match self.step_info.type:
+            case 'helm':
+                prefix = self.helm_chart_root
+            case 'python_module':
+                prefix = self.python_module_source
+            case _:
+                prefix = Path('.')
+
+        if self.step_info.type in DEFAULT_VERSION_FILES:
+            self.step_info.version_files += [prefix / v for v in DEFAULT_VERSION_FILES[self.step_info.type] if (prefix / v).exists()]
+
+        if not self.step_info.version_files:
+            return
+
+        self.log_message(f'{verb} version files', True)
+        for file_name in self.step_info.version_files:
+            file_path = Path(file_name)
+            msg = f'{verb}: {file_path}'
+            file_orig = Path(str(file_path) + '.orig')
+            if reset:
+                if file_orig.exists():
+                    self.log_message(msg)
+                    if file_path.exists():
+                        file_path.unlink()
+                    file_orig.rename(file_path)
+            else:
+                self.log_message(msg)
+                file_path.chmod(file_path.stat().st_mode | S_IWUSR)
+                copyfile(file_path, file_orig)
+                file_expander(file_orig, file_path, var_props=(self.project, self.build, self.step_info))
+                if file_path.name == HELM_CHART_FILE:
+                    with open(file_path, encoding=DEFAULT_ENCODING) as yaml_stream:
+                        helm_info = yaml_load(yaml_stream)
+                    helm_info['version'] = self.project.version
+                    if self.step_info.set_app_version:
+                        helm_info['appVersion'] = self.project.version
+                    with open(file_path, 'w', encoding=DEFAULT_ENCODING) as yaml_stream:
+                        yaml_dump(helm_info, yaml_stream)
+
+
+class VjerAction:  # pylint: disable=too-few-public-methods
+    """This is a base class to build CI/CD support scripts using the BatCave automation module Action class."""
+    def __init__(self, action_type: str, action_step_class: VjerStep):
+        """
+        Args:
+            action_type: The action type.
+            action_step_class: The Class to use for the action.
+
+        Attributes:
+            action_step_class: The value of the action_step_class argument.
+            action_type: The value of the action_type argument.
+            config: The project configuration.
+        """
+        self.config = ProjectConfig()
+        self.action_type = action_type
+        self.action_step_class = action_step_class
+
+    def execute(self) -> None:
+        """Run the action."""
+        VjerStep().log_message(f'Starting {__title__} version {__version__} ({__build_name__}) [{__build_date__}]', True)
+        for (category, info) in (yaml_to_dotmap(TOOL_REPORT) if TOOL_REPORT.exists() else tool_reporter()).items():
+            VjerStep().log_message(category.replace('_', ' ').title(), True)
+            for (name, data) in info.items():
+                VjerStep().log_message(f'  {name}: {data}')
+        steps = []
+        if self.action_type in self.config.use_steps:
+            steps = self.config.use_steps[self.action_type]
+        elif hasattr(action_def := getattr(self.config, self.action_type), 'steps'):
+            steps = action_def.steps
+        if not steps:
+            return
+
+        is_first_step = True
+        for step in [DotMap(s) for s in steps]:
+            step.is_first_step = is_first_step
+            verb = 'Skipping' if step.ignore else 'Executing'
+            VjerStep().log_message(f'{verb} {self.action_type} step: {step.type if (not step.name) else step.name}', True)
+            if step.ignore:
+                continue
+            (executor := cast(Callable, self.action_step_class)()).step_info = step
+            executor.execute()
+            is_first_step = False
+
+# cSpell:ignore batcave cloudmgr dotmap platarch syscmd vjer checkin

vjer/vjer.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""This is the bootstrap program for running the Vjer actions.
+Since this program can be called before the requirements are install, it can only import standard modules.
+"""
+
+# Import standard modules
+from importlib import import_module
+import os
+from os import getenv
+from platform import uname
+from sys import exit as sys_exit, stderr, version as python_version
+
+# Import third-party modules
+from batcave.commander import Argument, Commander
+from batcave.fileutil import slurp
+from batcave.sysutil import syscmd
+
+# Import local modules
+from .utils import apt, apt_install, VJER_ENV, pip_install, ProjectConfig, ConfigurationError, PROJECT_CFG_FILE
+
+ACTIONS = ['test', 'build', 'deploy', 'rollback', 'pre_release', 'release', 'freeze']
+
+
+def main() -> None:
+    """The main entrypoint."""
+    args = Commander('Vjer CI/CD Automation Tool', [Argument('actions', choices=ACTIONS, nargs='+')]).parse_args()
+    _setup_environment()
+
+    match uname().system:
+        case 'Darwin':
+            syscmd('sw_vers', show_stdout=True)
+        case 'Linux':
+            print(slurp('/etc/os-release'))
+        case _:
+            print('Unknown OS:', uname().system, file=stderr)
+            sys_exit(1)
+    print(f'Python version: {python_version}')
+
+    _sys_initialize()
+    for action in args.actions:
+        action_module = import_module(f'vjer.{action}')
+        action_module.__dict__[action]()
+
+
+def _pip_setup() -> None:
+    pip_install('pip')
+    pip_install('setuptools', 'wheel')
+
+
+def _setup_environment() -> None:
+    try:
+        config = ProjectConfig()
+    except ConfigurationError as err:
+        if err.code != ConfigurationError.CONFIG_FILE_NOT_FOUND.code:
+            raise
+        print('The Vjer configuration file was not found:', PROJECT_CFG_FILE, file=stderr)
+        sys_exit(1)
+    if (VJER_ENV == 'local') and not getenv('VIRTUAL_ENV', ''):
+        print('Vjer must be run from a virtual environment.', file=stderr)
+        sys_exit(1)
+    if hasattr((config := ProjectConfig()).project, 'environment'):
+        for (var, val) in config.project.environment.items():
+            print(f'setting {var}={val}')
+            os.environ[var] = val  # putenv doesn't work because the values are needed for this process.
+
+
+def _sys_initialize() -> None:
+    if pkg_installs := getenv('VJER_PKG_INSTALLS', ''):
+        apt('update')
+        apt_install(pkg_installs)
+
+    if (pip_installs := getenv('VJER_PIP_INSTALLS', '')) or (pip_file := getenv('VJER_PIP_INSTALL_FILE', '')):
+        _pip_setup()
+        if pip_installs:
+            pip_install(pip_installs)
+        if pip_file:
+            pip_install(requirement=pip_file)
+
+
+if __name__ == '__main__':
+    main()
+
+# cSpell:ignore batcave vjer fileutil syscmd putenv

vjer-30.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Jeffery G. Smith
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vjer-30.0.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: vjer
+Version: 30.0.0
+Summary: Vjer CI/CD module.
+Keywords: python,programming,utilities
+Author-email: "Jeffery G. Smith" <web@pobox.com>
+Requires-Python: ~=3.11
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development
+Classifier: Natural Language :: English
+Requires-Dist: BatCave~=43.0
+Requires-Dist: flit ; extra == "dev"
+Requires-Dist: twine ; extra == "dev"
+Requires-Dist: bumpver ; extra == "dev"
+Requires-Dist: flake8 ; extra == "test"
+Requires-Dist: flake8-annotations ; extra == "test"
+Requires-Dist: flake8-pyproject ; extra == "test"
+Requires-Dist: mypy ; extra == "test"
+Requires-Dist: pylint ; extra == "test"
+Requires-Dist: types-PyYAML ; extra == "test"
+Requires-Dist: types-requests ; extra == "test"
+Project-URL: changelog, https://github.com/tardis4500/vjer/blob/main/CHANGELOG.md
+Project-URL: documentation, https://vjer.readthedocs.io
+Project-URL: homepage, https://github.com/tardis4500/vjer/
+Project-URL: repository, https://github.com/tardis4500/vjer/
+Provides-Extra: dev
+Provides-Extra: test
+
+# Vjer Python Module
+
+A module for supporting CI/CD actions.
+

vjer-30.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+vjer/__init__.py,sha256=FrXoaBnL5D8B1mMZc8Jgjqvsp8ZfuZuDrOYuzGVVY8Q,654
+vjer/build.py,sha256=854HRKHQ_mp0e_vYDyhM1qX0-4zdzX5ZIYunlXsKkdo,5108
+vjer/deploy.py,sha256=LhIGI0thrPnLMw3cz2L_V55Msy6G7eb8PjL8UiPvlrI,1188
+vjer/freeze.py,sha256=ZdkMi_jd94SW2fQVpBJh4vzZFOmrHsjMyOafFrQYWfk,2875
+vjer/pre_release.py,sha256=3Gp_xLnUx2oa_p3C5bTBhhg_VlxeBFh0kQ9xaRVoPv0,1287
+vjer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vjer/release.py,sha256=INWn5abLc3MQJegV295PbDD8__XcOX9Y7Tvvc5SBU0o,2874
+vjer/rollback.py,sha256=Q5cKzPw1N1e7dgHVcTWJeEyqrR3kbVwzpqjQJi84GYU,772
+vjer/test.py,sha256=yGG20CV6rqyxyIAIPpApqRWwQqHa6hcW2yprbVTPK2M,2106
+vjer/tool_reporter.py,sha256=zhHoIC9k9K6GWFDruxNIYJmeyNQTLqipeyFCrsjadGs,2946
+vjer/utils.py,sha256=bIRH4AyLcW4_JgpzxOSzsyShfl7aqh9EcdJD3fSnXRI,25994
+vjer/vjer.py,sha256=xs1fcuC2sJ6iHpa4k63CMlY4aAGkQr_Pa7P5qA1RSjA,2760
+vjer-30.0.0.dist-info/entry_points.txt,sha256=3clcPT0_-UMmTL5ByOMNWsdREutds6SOWp2rIJoIrtk,39
+vjer-30.0.0.dist-info/LICENSE,sha256=X5r54-6S0TyVYhMGqPxqC6FK-WVFXfXqbO_8iR51HRg,1072
+vjer-30.0.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+vjer-30.0.0.dist-info/METADATA,sha256=Cr3l30DjxmCYFQhyN_EB5e1qAFHSyj_RB4-wR5v4ddU,1380
+vjer-30.0.0.dist-info/RECORD,,

vjer-30.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

vjer-30.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+vjer=vjer.vjer:main
+