wowool-build 0.0.1__py3-none-any.whl

wowool/build/codeartifact.py

@@ -0,0 +1,195 @@
+from os import environ
+from sys import stderr
+from dataclasses import dataclass
+from typing import Optional, Union
+from pathlib import Path
+from subprocess import run
+import hashlib
+import json
+import re
+from exceptions import UploadError
+
+
+@dataclass
+class AwsCredentials:
+    """
+    Credentials to access AWS
+    """
+
+    domain: str
+    domain_owner: int
+    region: str
+
+    @staticmethod
+    def from_environment():
+        return AwsCredentials(
+            domain=environ["AWS_DOMAIN"],
+            domain_owner=int(environ["AWS_DOMAIN_OWNER"]),
+            region=environ["AWS_REGION"],
+        )
+
+
+@dataclass
+class CodeArtifactCredentials:
+    """
+    Credentials to access a CodeArtifact repository
+    """
+
+    repository: str
+
+    @staticmethod
+    def from_environment():
+        return CodeArtifactCredentials(repository=environ["AWS_CODEARTIFACT_REPOSITORY"])
+
+
+def _check_not_dirty(fn: Path):
+    if "dirty" in fn.name:
+        raise UploadError(f"Attempted to upload a dirty version: {fn}")
+
+
+def upload_pypi(fp: Path, expression: str = "*"):
+    """
+    Upload a Python package to AWS CodeArtifact
+    """
+    fp_dist = fp / "dist"
+    for fn in fp_dist.glob(expression):
+        _check_not_dirty(fn)
+        cmd = f"twine upload {fn} --repository codeartifact"
+        try:
+            run(cmd, shell=True, check=True, cwd=fp)
+        except Exception as error:
+            raise UploadError(f"AWS CodeArtifact Twine upload failed: {error}")
+
+
+def _sha256sum(fn: Path):
+    with open(fn, "rb", buffering=0) as ifs:
+        return hashlib.file_digest(ifs, "sha256").hexdigest()  # pyright: ignore
+
+
+def delete_raw(
+    package: str,
+    version: str,
+    namespace: str | None = None,
+    format: str = "generic",
+    aws: Optional[AwsCredentials] = None,
+    codeartifact: Optional[CodeArtifactCredentials] = None,
+):
+    aws = aws or AwsCredentials.from_environment()
+    codeartifact = codeartifact or CodeArtifactCredentials.from_environment()
+    options = f"--namespace {namespace}" if namespace != None else ""
+    options += f" --format {format}"
+    cmd = f"""aws codeartifact delete-package-versions --domain {aws.domain} --domain-owner {aws.domain_owner} --region {aws.region} --repository {codeartifact.repository}  {options} --package {package} --versions {version} """
+    result = run(cmd, shell=True, check=False, capture_output=True)
+    print(result.stdout.decode())
+    if result.returncode != 0:
+        print(result.stderr.decode(), file=stderr)
+        raise UploadError(f"AWS CodeArtifact generic upload failed {cmd=}")
+
+
+def upload_raw(
+    fn: Path,
+    namespace: str,
+    package: str,
+    version: str,
+    aws: Optional[AwsCredentials] = None,
+    codeartifact: Optional[CodeArtifactCredentials] = None,
+    overwrite=False,
+):
+    fn = Path(fn)
+    aws = aws or AwsCredentials.from_environment()
+    codeartifact = codeartifact or CodeArtifactCredentials.from_environment()
+
+    if overwrite:
+        try:
+            delete_raw(namespace=namespace, package=package, version=version)
+        except Exception as error:
+            print(f"AWS CodeArtifact generic delete failed: {error}", file=stderr)
+
+    try:
+        asset_hash = _sha256sum(fn)
+    except Exception as error:
+        raise UploadError(f"Could not produce sha256 hash for {fn}: {error}")
+    try:
+        cmd = f"""aws codeartifact publish-package-version --domain {aws.domain} --domain-owner {aws.domain_owner} --region {aws.region} --repository {codeartifact.repository} --format generic --namespace {namespace} --package {package} --package-version {version} --asset-content {fn} --asset-name {fn.name} --asset-sha256 '{asset_hash}' --unfinished"""
+        result = run(cmd, shell=True, check=False, capture_output=True)
+        print(result.stdout.decode())
+        if result.returncode != 0:
+            print(result.stderr.decode(), file=stderr)
+            raise UploadError(f"AWS CodeArtifact generic upload failed {cmd=}")
+    except Exception as error:
+        raise UploadError(f"AWS CodeArtifact generic upload failed: {error}")
+
+
+def run_codeartifact(
+    cmd: str,
+    aws: Optional[AwsCredentials] = None,
+    codeartifact: Optional[CodeArtifactCredentials] = None,
+):
+    aws = aws or AwsCredentials.from_environment()
+    codeartifact = codeartifact or CodeArtifactCredentials.from_environment()
+    try:
+        codeartifact_cmd = f"aws codeartifact {cmd}"
+        print(f"Running: {codeartifact_cmd}")
+        result = run(codeartifact_cmd, shell=True, check=False, capture_output=True)
+
+        if result.returncode != 0:
+            print(result.stderr.decode(), file=stderr)
+            raise UploadError(f"AWS CodeArtifact generic cmd failed {cmd=}")
+        else:
+            return result.stdout.decode()
+    except Exception as error:
+        raise UploadError(f"AWS CodeArtifact generic cmd failed: {error}")
+
+
+def download_raw(
+    output: Union[str, Path],
+    namespace: str,
+    package: str,
+    version: str,
+    aws: Optional[AwsCredentials] = None,
+    codeartifact: Optional[CodeArtifactCredentials] = None,
+):
+    output = Path(output)
+    aws = aws or AwsCredentials.from_environment()
+    codeartifact = codeartifact or CodeArtifactCredentials.from_environment()
+    try:
+        cmd = f"""aws codeartifact get-package-version-asset --package-version {version} --domain {aws.domain} --domain-owner {aws.domain_owner} --region {aws.region} --repository {codeartifact.repository} --format generic --namespace {namespace} --package {package} --asset {output.name} {output}"""
+        result = run(cmd, shell=True, check=False, capture_output=True)
+        print(result.stdout.decode())
+        if result.returncode != 0:
+            print(result.stderr.decode(), file=stderr)
+            raise UploadError(f"AWS CodeArtifact generic upload failed {cmd=}")
+    except Exception as error:
+        raise UploadError(f"AWS CodeArtifact generic upload failed: {error}")
+
+
+def iter_packages(expression=".*", aws: Optional[AwsCredentials] = None, codeartifact: Optional[CodeArtifactCredentials] = None):
+
+    exp_ = re.compile(expression)
+    cmd = "list-packages --domain wowool --repository wowool --max-items 1000 "
+    data = run_codeartifact(cmd, aws, codeartifact)
+    jo = json.loads(data)
+    for package in jo["packages"]:
+        if exp_.search(package["package"]):
+            yield package["package"]
+
+
+def list_package_info(
+    expression: str = ".*",
+    version_expression: str = ".*",
+    aws: Optional[AwsCredentials] = None,
+    codeartifact: Optional[CodeArtifactCredentials] = None,
+):
+
+    version_exp_ = re.compile(version_expression)
+    for name in iter_packages(expression, aws, codeartifact):
+        try:
+            cmd = f"list-package-versions --domain wowool --repository wowool --format pypi --package {name}"
+            jo_version = json.loads(run_codeartifact(cmd))
+            # print(jo_version)
+            # yield jo_version['defaultDisplayVersion']
+            for version in jo_version["versions"]:
+                if version_exp_.match(version["version"]):
+                    yield jo_version["namespace"], jo_version["package"], version["version"], jo_version["format"]
+        except UploadError as error:
+            print(f"Error: {error}", file=stderr)

wowool/build/exceptions.py

@@ -0,0 +1,2 @@
+class UploadError(RuntimeError):
+    pass

wowool/build/git.py

@@ -0,0 +1,88 @@
+from logging import getLogger
+from os import getcwd
+from pathlib import Path
+from subprocess import run, CalledProcessError
+from typing import Optional, Union
+from os import environ
+
+logger = getLogger(__name__)
+
+
+def _get_repository_path(fp_repo: Optional[Union[str, Path]] = None) -> Path:
+    if fp_repo is None:
+        return Path(getcwd())
+    else:
+        return Path(fp_repo).parent if Path(fp_repo).is_file() else Path(fp_repo)
+
+
+def increment_version(version: str) -> str:
+    try:
+        parts = version.split(".")
+        parts[-1] = str(int(parts[-1]) + 1)
+        return ".".join(parts)
+    except ValueError:
+        return version
+
+
+def make_version(tag: str, nr_commits: int, has_changes: bool):
+    postfix = environ.get("WOWOOL_VERSION_POSTFIX", f".dev{nr_commits}+dirty")
+    if "dev0" in tag:
+        tag = tag.replace(".dev0", "")
+        version = f"{tag}.dev{nr_commits}" if has_changes == 0 else f"{tag}{postfix}"
+        return version
+    else:
+        if has_changes == 0:
+            if nr_commits == 0:
+                return tag
+            else:
+                tag = increment_version(tag)
+                if "WOWOOL_VERSION_POSTFIX" not in environ:
+                    version = f"{tag}.dev{nr_commits}"
+                else:
+                    version = f"{tag}{postfix}"
+                return version
+        else:
+            tag = increment_version(tag)
+            version = f"{tag}{postfix}"
+            return version
+
+
+def run_safe(cmd: str, capture_output: bool = True, cwd: Optional[Union[str, Path]] = None) -> str:
+    try:
+        res = run(cmd, shell=True, check=True, cwd=cwd, capture_output=capture_output)
+        return res.stdout.decode("utf-8").strip()
+    except CalledProcessError as ex:
+        logger.error(f"Error running command: {cmd}")
+        logger.error(ex)
+        print(ex.stderr.decode("utf-8"))
+        print(ex.stderr.decode("utf-8"))
+        raise ex
+
+
+def get_version_info(fp_repo: Optional[Union[str, Path]] = None) -> dict:
+    tag = run_safe("git describe --tags --abbrev=0", cwd=fp_repo)
+    nr_commits_result = run_safe(f"git log {tag}..HEAD --oneline", cwd=fp_repo)
+    nr_commits = len(nr_commits_result.splitlines())
+    has_changes = run("git diff --quiet --exit-code HEAD", shell=True).returncode != 0
+    return {"tag": tag, "nr_commits": nr_commits, "has_changes": has_changes}
+
+
+def get_version(fp_repo: Optional[Union[str, Path]] = None) -> str:
+    """
+    Get the version from the git history of the given repository folder
+
+    :param fp_repo: Optional repository folder. If not provided, the current
+                    working directory is used
+    """
+
+    fp_repo = _get_repository_path(fp_repo)
+
+    _git_info = get_version_info(fp_repo)
+    return make_version(_git_info["tag"], _git_info["nr_commits"], _git_info["has_changes"])
+
+
+def git_hash(fp_repo: Optional[Union[str, Path]] = None) -> str:
+    fp_repo = _get_repository_path(fp_repo)
+    result = run("git rev-parse HEAD", capture_output=True, shell=True, check=True, cwd=fp_repo)
+    git_hash_rev = result.stdout.decode().strip()
+    return git_hash_rev

wowool/build/logging.py

@@ -0,0 +1,156 @@
+from contextlib import contextmanager
+from dataclasses import dataclass
+from logging import (
+    CRITICAL,
+    DEBUG,
+    ERROR,
+    Formatter as StandardFormatter,
+    INFO,
+    Logger,
+    StreamHandler,
+    WARNING,
+    basicConfig,
+    getLogger as _getLogger,
+)
+from os import getcwd
+from pathlib import Path
+from tomllib import TOMLDecodeError, loads
+from typing import Any, Union
+
+_pyproject_tool_id = "wowool_build_logging"
+_default_loggers_names = ["root", "wowool"]
+_pyproject_toml_filename = "pyproject.toml"
+
+
+def _get_fn_pyproject_toml_from_identifier(identifier: Union[str, Path, None] = None) -> Path:
+    if identifier is None:
+        identifier = getcwd()
+    if isinstance(identifier, str):
+        identifier = Path(identifier).parent.resolve()
+    fn = identifier if identifier.is_file() else identifier / _pyproject_toml_filename
+    if not fn.exists() or not fn.is_file():
+        raise LoggingConfigError(f"Expected {fn} to be an existing file")
+    return fn
+
+
+# TODO: Once supoport for Python<3.11 is dropped, the imports can be moved to global scope
+def _parse_pyproject_toml(fn_pyproject_toml: Path) -> dict:
+    try:
+        return loads(fn_pyproject_toml.read_text())
+    except TOMLDecodeError as error:
+        raise LoggingConfigError(f"Configuration error in {fn_pyproject_toml}: {error}")
+
+
+class LoggingConfigError(RuntimeError):
+    pass
+
+
+@dataclass
+class LoggerConfig:
+    level: Union[str, int]
+    format: str
+    colored: bool
+
+
+def configure_logger(logger_name: str, config: LoggerConfig):
+    logger = _getLogger(logger_name)
+    logger.propagate = False
+    logger.handlers.clear()
+    logger.setLevel(config.level)
+
+    handler = StreamHandler()
+    Formatter = ColoredFormatter if config.colored else StandardFormatter
+    formatter = Formatter(config.format)
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
+
+def default_config():
+    return LoggerConfig(
+        level="INFO",
+        format="%(levelname)-8s %(name)s: %(message)s",
+        colored=False,
+    )
+
+
+def read_config(config_raw: dict) -> LoggerConfig:
+    if not isinstance(config_raw, dict):
+        raise LoggingConfigError(f"Incorrect logging configuration, most likely no logger was specified")
+
+    def get_parameter(key: str, default_value: Any) -> Any:
+        return config_raw[key] if key in config_raw else default_value
+
+    defaults = default_config()
+    return LoggerConfig(
+        level=get_parameter("level", defaults.level),
+        format=get_parameter("format", defaults.format),
+        colored=get_parameter("colored", defaults.colored),
+    )
+
+
+class ColoredFormatter(StandardFormatter):
+    def __init__(self, format: str):
+        grey = "\x1b[0;30m"
+        blue = "\x1b[0;34m"
+        red = "\x1b[31;20m"
+        red_bold = "\x1b[31;1m"
+        yellow = "\x1b[33;20m"
+
+        reset = "\x1b[0m"
+        formats = {
+            DEBUG: grey + format + reset,
+            INFO: blue + format + reset,
+            WARNING: yellow + format + reset,
+            ERROR: red + format + reset,
+            CRITICAL: red_bold + format + reset,
+        }
+        self.formatter = {level: StandardFormatter(config) for level, config in formats.items()}
+
+    def format(self, record):
+        return self.formatter[record.levelno].format(record)
+
+
+def init_logging(configuration_path_identifier: Union[str, Path, None] = None, name: str = ""):
+    fn_pyproject_toml = _get_fn_pyproject_toml_from_identifier(configuration_path_identifier)
+    pyproject = _parse_pyproject_toml(fn_pyproject_toml)
+    if not "tool" in pyproject or not _pyproject_tool_id in pyproject["tool"]:
+        basicConfig(level="DEBUG")
+    else:
+        wowool_build_logging = pyproject["tool"][_pyproject_tool_id]
+        logger_names = list(wowool_build_logging.keys())
+        logger_names.extend(_default_loggers_names)
+        logger_names = set(logger_names)
+        for logger_name in logger_names:
+            config = read_config(wowool_build_logging[logger_name]) if logger_name in wowool_build_logging else default_config()
+            configure_logger(logger_name, config)
+
+    if name:
+        return _getLogger(name)
+
+
+def get_logger(name: str, configuration_path_identifier: Union[str, Path, None] = None) -> Logger:
+    if configuration_path_identifier is not None:
+        init_logging(configuration_path_identifier)
+    return _getLogger(name)
+
+
+def getLogger(*args, **kwargs):
+    return get_logger(*args, **kwargs)
+
+
+@contextmanager
+def set_logger_level(logger: Union[Logger, str], level):  # pyright: ignore
+    if isinstance(logger, str):
+        logger = _getLogger(logger)
+    level_previous = logger.level
+    try:
+        logger.debug(f"Switching logger level to {level}")
+        logger.setLevel(level)
+        yield
+    finally:
+        logger.debug(f"Switching logger level to {level_previous}")
+        logger.setLevel(level_previous)
+
+
+def silence_logger(logger: Union[Logger, str], level=100):
+    return set_logger_level(logger, level)

wowool/build/platform.py

@@ -0,0 +1,33 @@
+import platform
+import sys
+from typing import Optional
+
+
+def _get_system_name() -> Optional[str]:
+    platform_name = platform.system()
+    if "Linux" == platform_name:
+        return (
+            f"{platform.system()}-{platform.machine()}-{platform.libc_ver()[0]}"
+        )
+    elif "Darwin" == platform_name:
+        return f"{platform.system()}-{platform.machine()}"
+    elif "Windows" == platform_name:
+        return f"{platform.system()}-{platform.machine()}-{platform.win32_ver()[0]}"
+
+
+def _get_os_name():
+    platforms = {
+        "linux1": "linux",
+        "linux2": "linux",
+        "darwin": "macos",
+        "win32": "windows",
+    }
+    return (
+        platforms[sys.platform] if sys.platform in platforms else sys.platform
+    )
+
+
+SYSTEM_NAME = _get_system_name()
+OS_NAME = _get_os_name()
+IS_PTY = sys.stdout.isatty() if OS_NAME != "windows" else False
+IS_POSIX = OS_NAME != "win32"

wowool/build/pydist.py

@@ -0,0 +1,119 @@
+from logging import getLogger, DEBUG
+from os import chmod, getcwd, stat
+from pathlib import Path
+from shutil import rmtree
+from stat import S_IEXEC
+from subprocess import run
+from sys import path as sys_path, prefix
+from typing import Optional
+
+logger = getLogger(__name__)
+logger_cmd = getLogger("wowool.cmd")
+
+
+def make_environment_entry_points(fp: Path):
+    """
+    Create the console scripts from the entry points defined in setup.py
+
+    :param fp: Path to the folder holding setup.py
+    """
+    egg_dirs = [fp for fp in fp.glob("*.egg-info")]
+    if not egg_dirs:
+        raise RuntimeError("Missing *.egg-info directories")
+    for egg_dir in egg_dirs:
+        entry_points = egg_dir / "entry_points.txt"
+        from configparser import ConfigParser
+
+        configur = ConfigParser()
+        configur.read(entry_points)
+        try:
+            console_scripts = configur["console_scripts"]
+        except KeyError:
+            raise RuntimeError("No console scripts defined in setup.py")
+        for cs in console_scripts:
+            fn_cs = Path(f"{prefix}/bin/{cs}")
+            print(f"Added entry point {cs} as alias to {fn_cs}")
+            (imp, func) = console_scripts[cs].split(":")
+            sys_path.append(f"{Path(__file__).parent.parent.resolve()}/core-build-py")
+            template = rf"""#!{prefix}/bin/python
+import re
+import sys
+sys.path.append("{fp}")
+for p in {sys_path}:
+    sys.path.append(p)
+from {imp} import {func}
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit({func}())
+"""
+            with open(fn_cs, "w") as fh:
+                fh.write(template)
+            st = stat(fn_cs)
+            chmod(fn_cs, st.st_mode | S_IEXEC)
+
+
+def get_install_requires(fp: Optional[Path] = None):
+    """
+    Return the contents of the install_requires*.txt files in the given path
+
+    :param fp: Path containing the install_requires*.txt files. If not set, the
+               current working directory is used
+    """
+
+    def is_valid(requirement: str) -> bool:
+        return len(requirement) != 0 and not requirement.startswith("#")
+
+    fp = fp if fp is not None else Path(getcwd())
+    install_requires = []
+    for fn in fp.glob("install_requires*.txt"):
+        requirements = filter(is_valid, [line.strip() for line in open(fn).readlines()])
+        install_requires.extend(requirements)
+    return install_requires
+
+
+def resolve_template(template, __globals, __locals):
+    return eval("f'''" + template + "'''", __globals, __locals)
+
+
+def build_wheel_package(fp: Path, no_deps: bool = True, build_isolation: bool = False):
+    """
+    Build a wheel package
+
+    :param fp: Folder holding the requirement files
+    """
+    template_pyproject_fn = fp / "pyproject_template.toml"
+    if template_pyproject_fn.exists():
+        from wowool.build.git import get_version
+
+        pyproject_fn = fp / "pyproject.toml"
+        data = template_pyproject_fn.read_text()
+        version = get_version(fp)
+        dependencies = get_install_requires(fp)
+        package_name: str = fp.name
+        if package_name.startswith("comp-"):
+            package_name = package_name[5:]
+        if package_name.endswith("-py"):
+            package_name = package_name[:-3]
+        print(f"Package name is {package_name}")
+        resolve_data = resolve_template(data, globals(), locals())
+        pyproject_fn.write_text(resolve_data)
+
+    options = []
+    if not build_isolation:
+        options.append("--no-isolation")
+    # cmd = f"python -m pip wheel {' '.join(options)} -w dist ."
+    cmd = f"python -m build --wheel {' '.join(options)} ."
+    print(f"CMD: {cmd}")
+    run(cmd, shell=True, check=True, cwd=fp)
+
+
+def clean_package_build(fp: Path):
+    """
+    Clean the package build
+    """
+    for dir in [
+        "build",
+        "dist",
+        "var",
+    ] + list(fp.glob("*.egg-info")):
+        rmtree(fp / dir, ignore_errors=True)

wowool/build/pypi.py

@@ -0,0 +1,28 @@
+from os import environ
+from pathlib import Path
+from subprocess import run
+
+
+from wowool.build.exceptions import UploadError
+
+
+def _check_not_dirty(fn: Path):
+    if "dirty" in fn.name:
+        raise UploadError(f"Attempted to upload a dirty version: {fn}")
+
+
+def upload_pypi(fp: Path, expression: str = "*", repository: str | None = None):
+    """
+    Upload a Python package to pypi
+    """
+    fp_dist = fp / "dist"
+    for fn in fp_dist.glob(expression):
+        _check_not_dirty(fn)
+        repository = environ.get("TWINE_REPOSITORY", None)
+        repository_option = f"--repository-url {repository}" if repository else ""
+        cmd = f"python -m twine upload {repository_option} dist/*"
+        try:
+            print(f"cmd: {cmd} {fn=} {fp_dist=}")
+            run(cmd, shell=True, check=True, cwd=str(fp))
+        except Exception as error:
+            raise UploadError(f"PyPi Twine upload failed: {error}")

wowool/build/pytask.py

@@ -0,0 +1,110 @@
+from os import getcwd
+from pathlib import Path
+from typing import Union
+
+from invoke.collection import Collection
+from invoke.tasks import task
+
+
+def create_py_tasks(fp_root: Union[str, Path, None] = None) -> Collection:
+    fp_root = Path(fp_root) if fp_root is not None else Path(getcwd())
+    if fp_root.is_file():
+        fp_root = fp_root.parent
+
+    @task
+    def version(_):
+        """
+        Print the version from Git
+        """
+        from wowool.build.git import get_version
+
+        print(get_version(fp_root))
+
+    @task
+    def test(
+        _,
+        verbosity: int = 2,
+        failfast: bool = True,
+        list: bool = False,
+        expression: str = "",
+        xclude: str = "",
+    ):
+        """
+        Run the Python unit-tests
+        """
+        from wowool.build.pytest import list_unittest_tests, run_unittest_tests
+
+        (
+            list_unittest_tests(
+                fp_root,
+                pattern_include=expression,
+                pattern_exclude=xclude,
+            )
+            if list
+            else run_unittest_tests(
+                fp_root,
+                verbosity=verbosity,
+                failfast=failfast,
+                pattern_include=expression,
+                pattern_exclude=xclude,
+            )
+        )
+
+    @task
+    def clean(_):
+        """
+        Clean the Python package build
+        """
+        from wowool.build.pydist import clean_package_build
+
+        clean_package_build(fp_root)
+
+    @task(pre=[clean])
+    def build(_, no_deps: bool = True):
+        """
+        Build the Python package
+        """
+        from wowool.build.pydist import build_wheel_package
+
+        build_wheel_package(fp_root, no_deps)
+
+    @task(aliases=("mep",))
+    def make_entry_points(_):
+        """
+        Make entry points to the Python CLIs
+        """
+        from wowool.build.pydist import make_environment_entry_points
+
+        make_environment_entry_points(fp_root)
+
+    @task
+    def upload(_, expression="wowool*"):
+        """
+        Upload the Python package to AWS CodeArtifact
+        """
+        from wowool.build.codeartifact import upload_pypi
+
+        upload_pypi(fp_root, expression=expression)
+
+    @task
+    def upload_raw(_, fn: Path, namespace: str, package: str, version: str):
+        """
+        Upload the raw package to AWS CodeArtifact
+        """
+        from wowool.build.codeartifact import upload_raw
+
+        upload_raw(fn, namespace, package, version)
+
+    @task
+    def upload_pypi(_, expression="wowool*"):
+        """Uploading the Python package to pypi"""
+        from wowool.build.pypi import upload_pypi
+
+        upload_pypi(fp_root, expression=expression)
+
+    return Collection(version, test, clean, build, make_entry_points, upload, upload_raw, upload_pypi)
+
+
+# Allow both default Invoke namespaces to be available for import
+ns = create_py_tasks()
+namespace = ns

wowool/build/pytest.py

@@ -0,0 +1,149 @@
+import ast
+from difflib import unified_diff
+from logging import getLogger
+from os import environ, pathsep, sep
+from pathlib import Path
+import re
+from subprocess import check_output, run
+from typing import Callable, List, Optional
+from unittest import TestLoader, TestResult, TestSuite, TextTestRunner, skipIf
+
+from contextlib import contextmanager
+from importlib import reload
+from io import StringIO
+import sys
+from typing import Optional
+
+
+logger = getLogger(__name__)
+
+
+# Test environment
+def is_ci_environment():
+    return "CI" in environ and not environ["CI"].lower() in ("0", "false")
+
+
+# Unit-test skip decorators
+skipIfCI = skipIf(is_ci_environment(), "CI environment detected")
+skipIfNotCI = skipIf(not is_ci_environment(), "CI environment not detected")
+
+
+class UnittestError(RuntimeError):
+    def __init__(self, result: TestResult):
+        self.result = result
+        message = f"Unit-test(s) failed: {len(result.errors)} errors and {len(result.failures)} failures"
+        super(UnittestError, self).__init__(message)
+
+
+def get_unittest_names(
+    fp: Path,
+    pattern_include: str = "",
+    pattern_exclude: Optional[str] = "",
+):
+    names: List[str] = []
+    files = [fn for fn in fp.glob("tests/**/test_*.py")]
+    for filename in files:
+        node = ast.parse(filename.read_text())
+        offset = 0 if str(fp).endswith("/") else 1
+        module_name = str(filename.with_suffix(""))[len(str(fp)) + offset :].replace(sep, ".")
+        classes = [n for n in node.body if isinstance(n, ast.ClassDef)]
+
+        for class_ in classes:
+            methods = [n for n in class_.body if isinstance(n, ast.FunctionDef)]
+            for method in methods:
+                if method.name.startswith("test_"):
+                    names.append(f"{module_name}.{class_.name}.{method.name}")
+
+    matcher_include = re.compile(f".*{pattern_include}")
+    names = [name for name in names if matcher_include.match(name)]
+    if pattern_exclude:
+        matcher_exclude = re.compile(f".*{pattern_exclude}")
+        names = [name for name in names if not matcher_exclude.match(name)]
+    return sorted(names)
+
+
+def get_unittest_suite(
+    fp: Path,
+    pattern_include: str = "",
+    pattern_exclude: Optional[str] = "",
+) -> TestSuite:
+    tests = get_unittest_names(fp, pattern_include, pattern_exclude)
+    return TestLoader().loadTestsFromNames(tests)
+
+
+def list_unittest_tests(fp: Path, printer: Callable[[str], None] = print, pattern_include: str = "", pattern_exclude: Optional[str] = ""):
+    """
+    List the unit tests found in the given directory
+
+    :param fp: Search directory
+    :param printer: Printer function that accepts a string
+    """
+    printer("\n".join(get_unittest_names(fp, pattern_include, pattern_exclude)))
+
+
+def run_unittest_tests(
+    fp: Path, verbosity: int, failfast: bool, pattern_include: str = "", pattern_exclude: Optional[str] = "", exit_on_error: bool = True
+) -> TestResult:
+    """
+    Run the unittest tests found in the given directory
+
+    :param fp: Search directory
+    :param verbosity: Verbosity level
+    :param failfast: Fail on first error
+    :param pattern: Only run tests matching the given pattern
+    :param exit_on_error: Exit directly in case of a failure, otherwise raise an error
+    """
+
+    suite = get_unittest_suite(fp, pattern_include, pattern_exclude)
+    result = TextTestRunner(verbosity=verbosity, failfast=failfast).run(suite)
+    if not result.wasSuccessful():
+        if exit_on_error:
+            exit(1)
+        else:
+            raise UnittestError(result)
+    return result
+
+
+def run_unittest_samples(fp: Path, pattern: str = ""):
+    """
+    Check the samples
+    """
+    matcher = re.compile(f".*{pattern}")
+    pypath = f"{pathsep}{environ['PYTHONPATH']}" if "PYTHONPATH" in environ else ""
+    environ["PYTHONPATH"] = f"{str(fp)}{pypath}"
+    samples_dir = fp / "samples"
+    files = sorted([fn for fn in samples_dir.glob("**/*.py") if not (str(fn).endswith("_setup.py") or str(fn).endswith("_cleanup.py"))])
+    for fn in files:
+        if matcher.match(str(fn)):
+            logger.info(f"Running sample: {fn}")
+
+            fn_setup = Path(str(fn).replace(".py", "_setup.py"))
+            if fn_setup.exists():
+                run(f"python {fn_setup}", check=True, shell=True, cwd=fn.parent)
+
+            out_data = check_output(f"python {fn}", shell=True, cwd=fn.parent).decode().strip()
+            logger.debug(f"{fn} stdout:[{out_data}]")
+
+            fn_ref = Path(str(fn).replace(".py", "_output.txt"))
+            if fn_ref.exists():
+                expected_data = fn_ref.read_text().strip()
+                lines = [line for line in unified_diff(expected_data, out_data)]
+                if 0 != len(lines):
+                    raise RuntimeError(f"Unexpected output:\n[{expected_data}]\n!=\n[{out_data}]")
+
+            fn_cleanup = Path(str(fn).replace(".py", "_cleanup.py"))
+            if fn_cleanup.exists():
+                run(f"python {fn_cleanup}", check=True, shell=True, cwd=fn.parent)
+
+
+@contextmanager
+def capture_stream(stream: str = "stdout"):
+    stream_original = getattr(sys, stream)
+    stream_captured = StringIO()
+    setattr(sys, stream, stream_captured)
+    reload(sys)
+    try:
+        yield stream_captured
+    finally:
+        sys.stdout = stream_original
+        reload(sys)

wowool/build/utility.py

@@ -0,0 +1,37 @@
+from contextlib import contextmanager
+from os import chdir, getcwd
+from pathlib import Path
+from typing import Union
+
+
+def ask(question, default: bool = True) -> bool:
+    """
+    Ask a simple yes/no question
+
+    :param question: The question to present to the user
+    :param default: The default answer to assume if no valid answer is provided
+    """
+    postfix = "Y/n" if default else "y/N"
+    while True:
+        answer = input(question + " [{}] ".format(postfix)).lower()
+        if "" == answer:
+            return default
+        elif "y" == answer:
+            return True
+        elif "n" == answer:
+            return False
+
+
+@contextmanager
+def in_cwd(fp: Union[Path, str]):
+    """
+    Temporarily change the working directory
+
+    :param fp: The folder to change to
+    """
+    oldpwd = getcwd()
+    chdir(str(fp))
+    try:
+        yield
+    finally:
+        chdir(oldpwd)

wowool_build-0.0.1.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: wowool-build
+Version: 0.0.1
+Summary: Wowool Build System
+Home-page: https://www.wowool.com/
+Author: Wowool
+Author-email: info@wowool.com
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: invoke
+Requires-Dist: build
+Requires-Dist: wheel
+Requires-Dist: setuptools
+Requires-Dist: setuptools-scm
+

wowool_build-0.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+wowool/build/codeartifact.py,sha256=m2YlJgzElY2yfMCBun_cdjabBYSKouHA4Zf80JUnFsc,7249
+wowool/build/exceptions.py,sha256=GFWI0F_nTEpDid8dMjMQCDQ66muzTvfLzRm-KSJ1-Uw,42
+wowool/build/git.py,sha256=oD9CB7MHOTYTO7HPZJ7NIuDOjO5ME_DIcUpcx02OM6w,3111
+wowool/build/logging.py,sha256=4ycT471N7V6vrEBXURF0-lho1hbmWA7PJyCHhfHVjeA,4988
+wowool/build/platform.py,sha256=dYEr4Pw0VyChQRnd0ZXwETXZsLVQ0tC9aC4Mu9KJZcc,901
+wowool/build/pydist.py,sha256=j_OiN2G-RVsQ8NwEv2gn19IBpJEcALIFUeYiDn_4NPY,3924
+wowool/build/pypi.py,sha256=fdPRdbPq2ZxWy3AdncL0qTWmUn_dA62NMWamwpC2Tto,921
+wowool/build/pytask.py,sha256=wlwnQGfVkEUiA_IcRYnz9_BM7hNmzpT_1turmwYHFEM,2879
+wowool/build/pytest.py,sha256=8F1ZklSvpTAnwODXZvzhF6qcND-MlDVbl-e4F1Pf3mI,5304
+wowool/build/utility.py,sha256=q5RwGFD5O9pewuIUxbYt5sA7lj6u1CjWi6PVWQwCxnQ,890
+wowool_build-0.0.1.dist-info/METADATA,sha256=_hkITQ5R0Eyx_y9OXgXgbfKhKxk0LafBQ-3BIlhFAXw,350
+wowool_build-0.0.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+wowool_build-0.0.1.dist-info/top_level.txt,sha256=zerqoDN-iHSHwsS1SN2h0q4H6RI1FOVeHW8fNQC9YdU,7
+wowool_build-0.0.1.dist-info/RECORD,,

wowool_build-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

wowool_build-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+wowool