builddrone 0.1.0__py3-none-any.whl

builddrone/__main__.py

@@ -0,0 +1,6 @@
+"""Builddrone module entry point."""
+
+from builddrone.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

builddrone/base_module.py

@@ -0,0 +1,19 @@
+"""Base module definition for builddrone modules."""
+
+from abc import ABC, abstractmethod
+
+from builddrone.runner import Runner
+
+
+class BaseModule(ABC):  # pylint: disable=too-few-public-methods
+    """Base class for all builddrone modules."""
+
+    @abstractmethod
+    def run(self, runner: Runner, args: dict) -> None:
+        """Execute the module.
+
+        Args:
+            runner: Runner instance used to execute commands.
+            args: Module configuration arguments.
+        """
+        raise NotImplementedError

builddrone/cli.py

@@ -0,0 +1,30 @@
+"""Command line interface for Builddrone."""
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+
+from builddrone.drone_exception import DroneException
+from builddrone.execution_engine import ExecutionEngine
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Create the Builddrone CLI parser."""
+    parser = argparse.ArgumentParser(prog="python -m builddrone")
+    parser.add_argument("stage", help="Pipeline stage to execute")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run the Builddrone CLI."""
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        engine = ExecutionEngine({})
+        engine.run(args.stage)
+    except DroneException as exc:
+        parser.exit(1, f"{parser.prog}: error: {exc}\n")
+
+    return 0

builddrone/drone_exception.py

@@ -0,0 +1,10 @@
+"""Custom exceptions for the Builddrone package."""
+
+
+class DroneException(Exception):
+    """Base exception raised by Builddrone-specific runtime errors.
+
+    Use this exception as the common parent for errors that originate from
+    the Builddrone domain, so callers can catch framework-level failures in a
+    single place while still allowing more specific exception types later.
+    """

builddrone/execution_engine.py

@@ -0,0 +1,89 @@
+"""Execution engine for running builddrone pipeline stages."""
+
+import json
+from pathlib import Path
+
+from builddrone.base_module import BaseModule
+from builddrone.drone_exception import DroneException
+from builddrone.module.filesystem.cleanup_module import (
+    CleanupModule as FilesystemCleanupModule,
+)
+from builddrone.module.filesystem.copy_module import FilesystemCopyModule
+from builddrone.module.python.build_module import PythonBuildModule
+from builddrone.module.python.install_module import PythonInstallModule
+from builddrone.module.python.pylint_module import PylintModule
+from builddrone.module.python.run_module import PythonRunModule
+from builddrone.module.python.venv_module import PythonVirtualEnvironmentModule
+from builddrone.module.robotframework.rebot_module import RobotframeworkRebotModule
+from builddrone.module.robotframework.test_module import RobotframeworkTestModule
+from builddrone.runner import Runner
+
+
+class ExecutionEngine:  # pylint: disable=too-few-public-methods
+    """Execute configured builddrone stages."""
+
+    def __init__(self, modules: dict[str, BaseModule]):
+        """Initialize the execution engine.
+
+        Args:
+            modules: Registered builddrone modules.
+        """
+        self._modules = modules
+        self._config_path = Path("blueprint.json")
+        self._register_module("filesystem.cleanup", FilesystemCleanupModule())
+        self._register_module("filesystem.copy", FilesystemCopyModule())
+        self._register_module("python.build", PythonBuildModule())
+        self._register_module("python.install", PythonInstallModule())
+        self._register_module("python.run", PythonRunModule())
+        self._register_module("python.venv", PythonVirtualEnvironmentModule())
+        self._register_module("python.pylint", PylintModule())
+        self._register_module("robotframework.test", RobotframeworkTestModule())
+        self._register_module("robotframework.rebot", RobotframeworkRebotModule())
+        self._runner = Runner()
+
+    def run(self, stage: str) -> None:
+        """Execute a build stage from a configuration file."""
+        config_path = self._config_path
+        config_file = config_path.resolve()
+        self._runner.set_base_path(config_file.parent)
+        config = self._load_config(str(config_path))
+
+        if stage not in config:
+            raise DroneException(f"Stage '{stage}' not found in config")
+
+        steps = config[stage]
+
+        if not isinstance(steps, list):
+            raise DroneException(f"Stage '{stage}' must be a list of steps")
+
+        for step in steps:
+            self._execute_step(step)
+
+    def _execute_step(self, step: dict) -> None:
+        """Execute a single build step."""
+        if not isinstance(step, dict):
+            raise DroneException("Pipeline step must be an object")
+
+        module_name = step.get("module")
+
+        if module_name is None or not isinstance(module_name, str):
+            raise DroneException("Unknown module name")
+
+        args = step.get("args", {})
+        module = self._modules.get(module_name)
+
+        if module is None:
+            raise DroneException(f"Unknown module: {module_name}")
+
+        module.run(self._runner, args)
+
+    def _register_module(self, name: str, module: BaseModule) -> None:
+        """Register a single build module."""
+        if name not in self._modules:
+            self._modules[name] = module
+
+    @staticmethod
+    def _load_config(path: str) -> dict:
+        """Load build configuration from JSON."""
+        with open(path, encoding="utf-8") as file:
+            return json.load(file)

builddrone/module/filesystem/cleanup_module.py

@@ -0,0 +1,70 @@
+"""Filesystem cleanup module."""
+
+import os
+import shutil
+from pathlib import Path
+
+from builddrone.base_module import BaseModule
+from builddrone.drone_exception import DroneException
+from builddrone.runner import Runner
+
+
+class CleanupModule(BaseModule):  # pylint: disable=too-few-public-methods
+    """A module responsible for cleanup operations.
+
+    This module handles cleanup, such as removing temporary files or folders.
+
+    Blueprint configuration arguments:
+        "files": ["List of files to delete"]
+        "folders": ["List of folders to delete"]
+    """
+
+    def run(self, runner: Runner, args: dict) -> None:
+        runner.logger.info("Cleaning up...")
+        base_path = Path(runner.get_base_path())
+        self._delete_files(runner, args.get("files", []), base_path)
+        self._delete_folders(runner, args.get("folders", []), base_path)
+
+    @staticmethod
+    def _delete_files(runner: Runner, files: list, base_path: Path):
+        for file in files:
+            resolved_file = Path(file)
+            if not os.path.isabs(file):
+                resolved_file = base_path / file
+
+            if not os.path.exists(resolved_file):
+                # If file not exists, nothing to delete
+                continue
+
+            try:
+                if os.path.isfile(resolved_file):
+                    os.remove(resolved_file)
+                    runner.logger.info(f"Deleted file: {resolved_file}")
+                else:
+                    raise DroneException(f"Is not a file: {resolved_file}")
+            except OSError as e:
+                msg = f"Error deleting file {resolved_file} : {e}"
+                runner.logger.error(msg)
+                raise DroneException(msg) from e
+
+    @staticmethod
+    def _delete_folders(runner: Runner, folders: list, base_path: Path):
+        for folder in folders:
+            resolved_folder = Path(folder)
+            if not os.path.isabs(folder):
+                resolved_folder = base_path / folder
+
+            if not os.path.exists(resolved_folder):
+                # If folder not exists, nothing to delete
+                continue
+
+            try:
+                if os.path.isdir(resolved_folder):
+                    shutil.rmtree(resolved_folder)
+                    runner.logger.info(f"Deleted folder: {resolved_folder}")
+                else:
+                    raise DroneException(f"Is not a folder: {resolved_folder}")
+            except OSError as e:
+                msg = f"Error deleting folder {resolved_folder} : {e}"
+                runner.logger.error(msg)
+                raise DroneException(msg) from e

builddrone/module/filesystem/copy_module.py

@@ -0,0 +1,72 @@
+"""Filesystem copy module."""
+
+import os
+import shutil
+from pathlib import Path
+
+from builddrone.base_module import BaseModule
+from builddrone.drone_exception import DroneException
+from builddrone.runner import Runner
+
+
+class FilesystemCopyModule(BaseModule):  # pylint: disable=too-few-public-methods
+    """A module responsible for copying files from one folder to another.
+
+    Blueprint configuration arguments:
+        "source": "Source directory to copy from"
+        "destination": "Destination directory to copy to"
+    """
+
+    def run(self, runner: Runner, args: dict) -> None:
+        """Copy all files from a source directory into a destination directory."""
+        runner.logger.info("Copying files...")
+        source = args.get("source")
+        destination = args.get("destination")
+        base_path = Path(runner.get_base_path())
+
+        if not isinstance(source, str) or not source:
+            raise DroneException("No source provided for copy")
+
+        if not isinstance(destination, str) or not destination:
+            raise DroneException("No destination provided for copy")
+
+        self._copy_tree(runner, source, destination, base_path)
+
+    @staticmethod
+    def _copy_tree(
+        runner: Runner, source: str, destination: str, base_path: Path
+    ) -> None:
+        """Copy a directory tree preserving relative paths."""
+        source_path = Path(source)
+        destination_path = Path(destination)
+
+        if not os.path.isabs(source):
+            source_path = base_path / source_path
+
+        if not os.path.isabs(destination):
+            destination_path = base_path / destination_path
+
+        if not os.path.isdir(source_path):
+            raise DroneException(f"Source is not a directory: {source_path}")
+
+        os.makedirs(destination_path, exist_ok=True)
+
+        for root, _, files in os.walk(source_path):
+            relative_root = os.path.relpath(root, source_path)
+            target_root = (
+                destination_path
+                if relative_root == "."
+                else os.path.join(destination_path, relative_root)
+            )
+            os.makedirs(target_root, exist_ok=True)
+
+            for file_name in files:
+                source_file = os.path.join(root, file_name)
+                destination_file = os.path.join(target_root, file_name)
+                try:
+                    shutil.copy2(source_file, destination_file)
+                    runner.logger.info("Copied file: %s", source_file)
+                except OSError as exc:
+                    msg = f"Error copying file {source_file} : {exc}"
+                    runner.logger.error(msg)
+                    raise DroneException(msg) from exc

builddrone/module/python/build_module.py

@@ -0,0 +1,26 @@
+"""Python build module."""
+
+from builddrone.base_module import BaseModule
+from builddrone.drone_exception import DroneException
+from builddrone.runner import Runner
+
+
+class PythonBuildModule(BaseModule):  # pylint: disable=too-few-public-methods
+    """A module responsible for building the project.
+
+    Blueprint configuration arguments:
+        None
+    """
+
+    def run(self, runner: Runner, _args: dict) -> None:
+        """Build the project with ``python -m build``.
+
+        Args:
+            runner: Runner instance used to execute commands.
+            _args: Module configuration arguments. Unused.
+        """
+        runner.logger.info("Building...")
+        exit_code = runner.run(["-m", "build"], cwd=str(runner.get_base_path()))
+
+        if exit_code != 0:
+            raise DroneException(f"Build failed with exit code {exit_code}")

builddrone/module/python/install_module.py

@@ -0,0 +1,40 @@
+"""Python install module."""
+
+from builddrone.base_module import BaseModule
+from builddrone.drone_exception import DroneException
+from builddrone.runner import Runner
+
+
+class PythonInstallModule(BaseModule):  # pylint: disable=too-few-public-methods
+    """A module responsible for installing Python packages.
+
+    Blueprint configuration arguments:
+        "source": "Package source to install"
+        "requirements": "Requirements file to install"
+    """
+
+    def run(self, runner: Runner, args: dict) -> None:
+        """Install a package source with ``python -m pip install``.
+
+        Args:
+            runner: Runner instance used to execute commands.
+            args: Module configuration arguments.
+        """
+        runner.logger.info("Installing...")
+        source = args.get("source")
+        requirements = args.get("requirements")
+
+        if isinstance(requirements, str) and requirements:
+            install_args = ["-r", requirements]
+        elif isinstance(source, str) and source:
+            install_args = [source]
+        else:
+            raise DroneException("No source or requirements provided for install")
+
+        exit_code = runner.run(
+            ["-m", "pip", "install", *install_args],
+            cwd=str(runner.get_base_path()),
+        )
+
+        if exit_code != 0:
+            raise DroneException(f"Install failed with exit code {exit_code}")

builddrone/module/python/pylint_module.py

@@ -0,0 +1,49 @@
+"""Python linting module."""
+
+from builddrone.base_module import BaseModule
+from builddrone.drone_exception import DroneException
+from builddrone.runner import Runner
+
+
+class PylintModule(BaseModule):  # pylint: disable=too-few-public-methods
+    """A module responsible for running pylint.
+
+    Blueprint configuration arguments:
+        "paths": ["List of paths to lint"]
+        "files": ["Optional list of individual Python files to lint"]
+        "ignore": ["Optional list of file or directory base names to skip"]
+    """
+
+    def run(self, runner: Runner, args: dict) -> None:
+        runner.logger.info("Pylint...")
+        paths = args.get("paths", [])
+        files = args.get("files", [])
+        ignore = args.get("ignore", [])
+
+        if not isinstance(paths, list) or not all(
+            isinstance(item, str) and item for item in paths
+        ):
+            raise DroneException("Paths must be a list of non-empty strings")
+
+        if not isinstance(files, list) or not all(
+            isinstance(item, str) and item for item in files
+        ):
+            raise DroneException("Files must be a list of non-empty strings")
+
+        if not paths and not files:
+            raise DroneException("No paths or files provided for pylint")
+
+        if not isinstance(ignore, list) or not all(
+            isinstance(item, str) and item for item in ignore
+        ):
+            raise DroneException("Ignore must be a list of non-empty strings")
+
+        command = ["-m", "pylint"]
+        if ignore:
+            command.extend(["--ignore", ",".join(ignore)])
+        command.extend([*paths, *files])
+
+        exit_code = runner.run(command, cwd=str(runner.get_base_path()))
+
+        if exit_code != 0:
+            raise DroneException(f"Pylint failed with exit code {exit_code}")

builddrone/module/python/run_module.py

@@ -0,0 +1,31 @@
+"""Python run module."""
+
+from builddrone.base_module import BaseModule
+from builddrone.drone_exception import DroneException
+from builddrone.runner import Runner
+
+
+class PythonRunModule(BaseModule):  # pylint: disable=too-few-public-methods
+    """A module responsible for running Python source files.
+
+    Blueprint configuration arguments:
+        "source": "Python file to execute"
+    """
+
+    def run(self, runner: Runner, args: dict) -> None:
+        """Run a Python source file with the configured interpreter.
+
+        Args:
+            runner: Runner instance used to execute commands.
+            args: Module configuration arguments.
+        """
+        runner.logger.info("Running...")
+        source = args.get("source")
+
+        if not isinstance(source, str) or not source:
+            raise DroneException("No source provided for run")
+
+        exit_code = runner.run([source], cwd=str(runner.get_base_path()))
+
+        if exit_code != 0:
+            raise DroneException(f"Run failed with exit code {exit_code}")

builddrone/module/python/venv_module.py

@@ -0,0 +1,68 @@
+"""Python virtual environment module."""
+
+import subprocess
+import venv
+from pathlib import Path
+
+from builddrone.base_module import BaseModule
+from builddrone.drone_exception import DroneException
+from builddrone.runner import Runner
+
+
+class PythonVirtualEnvironmentModule(
+    BaseModule
+):  # pylint: disable=too-few-public-methods
+    """A module responsible for configuring a Python virtual environment.
+
+    Blueprint configuration arguments:
+        "source": "Virtual environment root path to use; empty string resets the runner"
+    """
+
+    def run(self, runner: Runner, args: dict) -> None:
+        """Configure the runner to use a virtual environment interpreter."""
+        source = args.get("source")
+
+        if source == "":
+            runner.logger.info("Resetting runner to the current Python interpreter...")
+            runner.reset_runner()
+            return
+
+        if not isinstance(source, str) or not source:
+            raise DroneException("No source provided for virtual environment")
+
+        venv_path = Path(source)
+        if not venv_path.is_absolute():
+            venv_path = Path(runner.get_base_path()) / venv_path
+
+        python_executable = self._resolve_python_executable(venv_path)
+
+        if python_executable is None:
+            runner.logger.info("Creating virtual environment: %s", venv_path)
+            try:
+                venv.create(venv_path, with_pip=True)
+            except (OSError, RuntimeError, subprocess.CalledProcessError) as exception:
+                raise DroneException(
+                    f"Could not create virtual environment: {venv_path}"
+                ) from exception
+
+            python_executable = self._resolve_python_executable(venv_path)
+
+        if python_executable is None:
+            raise DroneException(f"Invalid virtual environment path: {venv_path}")
+
+        runner.logger.info("Using virtual environment: %s", venv_path)
+        runner.set_runner(str(python_executable))
+
+    @staticmethod
+    def _resolve_python_executable(venv_path: Path) -> Path | None:
+        """Resolve the interpreter path inside the virtual environment."""
+        candidate_paths = (
+            venv_path / "Scripts" / "python.exe",
+            venv_path / "bin" / "python",
+        )
+
+        for candidate in candidate_paths:
+            if candidate.is_file():
+                return candidate
+
+        return None

builddrone/module/robotframework/rebot_module.py

@@ -0,0 +1,20 @@
+"""Robot Framework rebot module."""
+
+from builddrone.module.robotframework.robotframework_base_module import (
+    RobotframeworkBaseModule,
+)
+
+
+class RobotframeworkRebotModule(  # pylint: disable=too-few-public-methods
+    RobotframeworkBaseModule
+):
+    """A module responsible for running Robot Framework's rebot command.
+
+    Blueprint configuration arguments:
+        "arguments": "Dictionary of CLI arguments to pass to rebot"
+        "cwd": "Optional working directory to run rebot from"
+    """
+
+    command_prefix = ["-m", "robot.rebot"]
+    log_message = "Rebot..."
+    failure_label = "Rebot"

builddrone/module/robotframework/robotframework_base_module.py

@@ -0,0 +1,70 @@
+"""Shared helpers for Robot Framework modules."""
+
+from abc import ABC
+from pathlib import Path
+
+from builddrone.base_module import BaseModule
+from builddrone.drone_exception import DroneException
+from builddrone.runner import Runner
+
+
+class RobotframeworkBaseModule(
+    BaseModule, ABC
+):  # pylint: disable=too-few-public-methods
+    """Common behavior for Robot Framework command modules."""
+
+    command_prefix: list[str] = []
+    log_message: str = ""
+    failure_label: str = ""
+
+    def run(self, runner: Runner, args: dict) -> None:
+        """Run a Robot Framework command with expanded CLI arguments."""
+        runner.logger.info(self.log_message)
+        arguments = args.get("arguments", {})
+        cwd = args.get("cwd")
+
+        if not isinstance(arguments, dict):
+            raise DroneException("Arguments must be a dictionary")
+
+        if cwd is not None and not isinstance(cwd, (str, Path)):
+            raise DroneException("Cwd must be a path or string")
+
+        working_directory = Path(runner.get_base_path())
+        if cwd is not None:
+            configured_cwd = Path(cwd)
+            working_directory = (
+                configured_cwd
+                if configured_cwd.is_absolute()
+                else working_directory / configured_cwd
+            )
+
+        command = self._build_command(arguments)
+        exit_code = runner.run(command, cwd=str(working_directory))
+
+        if exit_code != 0:
+            raise DroneException(
+                f"{self.failure_label} failed with exit code {exit_code}"
+            )
+
+    def _build_command(self, arguments: dict) -> list[str]:
+        """Convert a dictionary of CLI options into a Robot Framework command."""
+        command: list[str] = list(self.command_prefix)
+
+        for key, value in arguments.items():
+            if isinstance(value, bool):
+                if value:
+                    command.append(str(key))
+                continue
+
+            if isinstance(value, (list, tuple)):
+                command.append(str(key))
+                command.extend(str(item) for item in value)
+                continue
+
+            if value is None:
+                command.append(str(key))
+                continue
+
+            command.extend([str(key), str(value)])
+
+        return command

builddrone/module/robotframework/test_module.py

@@ -0,0 +1,20 @@
+"""Robot Framework test module."""
+
+from builddrone.module.robotframework.robotframework_base_module import (
+    RobotframeworkBaseModule,
+)
+
+
+class RobotframeworkTestModule(  # pylint: disable=too-few-public-methods
+    RobotframeworkBaseModule
+):
+    """A module responsible for running Robot Framework test suites.
+
+    Blueprint configuration arguments:
+        "arguments": "Dictionary of CLI arguments to pass to robot"
+        "cwd": "Optional working directory to run robot from"
+    """
+
+    command_prefix = ["-m", "robot"]
+    log_message = "Robot..."
+    failure_label = "Robot"

builddrone/runner.py

@@ -0,0 +1,52 @@
+"""Runner module for executing build commands."""
+
+import logging
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from builddrone.drone_exception import DroneException
+
+
+class Runner:
+    """Execute build commands using a configured Python interpreter."""
+
+    def __init__(self):
+        """Initialize the runner."""
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+
+        self._python_path = sys.executable
+        self._base_path: Path | None = None
+        if not self._python_path:
+            raise DroneException("Python executable not found")
+
+    def set_runner(self, python_path):
+        """Set the Python executable used for command execution."""
+        if os.path.exists(python_path) and os.path.isfile(python_path):
+            self._python_path = python_path
+
+    def reset_runner(self):
+        """Reset the runner to use the current Python interpreter."""
+        self._python_path = sys.executable
+        if not self._python_path:
+            raise DroneException("Python executable not found")
+
+    def set_base_path(self, base_path: str | Path | None) -> None:
+        """Set the base directory used for relative paths."""
+        self._base_path = None if base_path is None else Path(base_path)
+
+    def get_base_path(self) -> Path:
+        """Return the base directory used for relative paths."""
+        return self._base_path or Path.cwd()
+
+    def run(self, cmd, cwd=None) -> int:
+        """Execute a Python command and return the exit code."""
+        full_cmd = [self._python_path] + cmd
+        result = subprocess.run(
+            full_cmd,
+            cwd=cwd,
+            check=False,
+        )
+        return result.returncode

builddrone-0.1.0.dist-info/METADATA

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: builddrone
+Version: 0.1.0
+Summary: Modular build framework
+Author: Andreas Sekulski
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+
+# Builddrone
+
+![Builddrone](logo.png)
+
+Builddrone is a JSON-driven build orchestration framework and command-line
+interface for Python projects. A pipeline is made up of named stages, and each
+stage executes an ordered list of registered modules.
+
+## Installation
+
+Install the project and its development tools from the repository root:
+
+```bash
+python -m pip install -e ".[dev]"
+```
+
+Builddrone requires Python 3.10 or newer.
+
+## Blueprint format
+
+Builddrone loads `blueprint.json` from the current working directory. The
+top-level keys are stage names, and each stage contains module steps:
+
+```json
+{
+  "build": [
+    {
+      "module": "python.venv",
+      "args": {"source": ".venv"}
+    },
+    {
+      "module": "python.install",
+      "args": {"requirements": "requirements.txt"}
+    },
+    {
+      "module": "python.run",
+      "args": {"source": "main.py"}
+    }
+  ]
+}
+```
+
+Relative paths are resolved from the directory containing `blueprint.json`.
+Each step runs only after the preceding step succeeds.
+
+## Command-line usage
+
+Run a stage from the directory containing its blueprint:
+
+```bash
+cd example/python
+python -m builddrone build
+python -m builddrone cleanup
+```
+
+The Python example creates `.venv` automatically, installs its requirements,
+lints and runs `main.py`, and builds a wheel and source distribution with
+`python -m build`. The separate `cleanup` stage removes the temporary
+environment and generated build artifacts.
+
+The Robot Framework example runs similarly:
+
+```bash
+cd example/robotframework
+python -m builddrone test
+python -m builddrone cleanup
+```
+
+Its `robotframework.test` step writes `results/output.xml`, and
+`robotframework.rebot` converts that result into reports under
+`results/rebot`.
+
+## Built-in modules
+
+### Filesystem
+
+| Module | Arguments | Purpose |
+| --- | --- | --- |
+| `filesystem.copy` | `source`, `destination` | Copy a directory tree. |
+| `filesystem.cleanup` | `files`, `folders` | Remove listed files and folders. |
+
+### Python
+
+| Module | Arguments | Purpose |
+| --- | --- | --- |
+| `python.venv` | `source` | Select an environment, creating it with pip if needed. An empty source resets the runner. |
+| `python.install` | `requirements` or `source` | Install requirements or a package with pip. |
+| `python.run` | `source` | Run a Python source file. |
+| `python.build` | none | Run `python -m build`. |
+| `python.pylint` | `paths`, `files`, `ignore` | Run Pylint against paths or individual files. |
+
+### Robot Framework
+
+Both Robot Framework modules accept an `arguments` dictionary and an optional
+`cwd`:
+
+| Module | Purpose |
+| --- | --- |
+| `robotframework.test` | Run `python -m robot`. |
+| `robotframework.rebot` | Run `python -m robot.rebot` to post-process results. |
+
+Dictionary values are converted to command-line arguments. A `null` value is a
+flag or positional argument, a string receives a following value, and a list
+receives multiple values:
+
+```json
+{
+  "module": "robotframework.test",
+  "args": {
+    "arguments": {
+      "--outputdir": "results",
+      "tests": null
+    }
+  }
+}
+```
+
+## Using Builddrone as a framework
+
+Built-in modules are registered by `ExecutionEngine`. Custom modules can be
+added by passing them to the constructor:
+
+```python
+from builddrone.base_module import BaseModule
+from builddrone.execution_engine import ExecutionEngine
+
+
+class GreetingModule(BaseModule):
+    def run(self, runner, args):
+        runner.logger.info("Hello from %s", args.get("name", "Builddrone"))
+
+
+engine = ExecutionEngine({"custom.greeting": GreetingModule()})
+engine.run("build")
+```
+
+The custom module can then be used in `blueprint.json`:
+
+```json
+{
+  "build": [
+    {
+      "module": "custom.greeting",
+      "args": {"name": "Builddrone"}
+    }
+  ]
+}
+```
+
+Every module receives a `Runner` and a dictionary of arguments. The runner
+executes commands with the currently selected Python interpreter and exposes
+the blueprint's base directory for relative paths.
+
+## Execution flow
+
+```text
+python -m builddrone <stage>
+        |
+        v
+load blueprint.json -> select stage -> execute steps -> report failures
+```
+
+Any non-zero command exit code raises `DroneException` and stops the stage.
+
+## License
+
+MIT License

builddrone-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+builddrone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+builddrone/__main__.py,sha256=ywngXh63RbvJp9nA2PJmI8n3Cqh044yywZe4_NG2P3s,127
+builddrone/base_module.py,sha256=qFOM19wOY-RidGMiEzsrS5-G2aHHQYZRzr2bG3gctEc,524
+builddrone/cli.py,sha256=mmC7f2dvkJ_2JzSmBNgMxgaQIkkpeQGKf4ETduQypJM,824
+builddrone/drone_exception.py,sha256=Hb8FW7nnX3l1U5BbfNToulMuzhEv2sOJlKWX269U_8Q,392
+builddrone/execution_engine.py,sha256=xrBAvyNynIJm3j5gy2LCMLW6BIf2v2Btwz6omXj6kYw,3597
+builddrone/runner.py,sha256=rM3cvaNJrJEDfZ3S_LF2LflZV-mti0uhRqV4PTyR_yU,1730
+builddrone/module/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+builddrone/module/filesystem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+builddrone/module/filesystem/cleanup_module.py,sha256=7BfH1Z9W5bgSahGYatrRp6KUTLLiidePgp-c-oJVneA,2602
+builddrone/module/filesystem/copy_module.py,sha256=yH8lwtRBnWbxFeQkrlbcZaufc3ywyQOX73jz-9h46UY,2688
+builddrone/module/python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+builddrone/module/python/build_module.py,sha256=lSPzzME9HsaZgyYVsXVjLtvdw1xQexQuyCafdPGFHjg,849
+builddrone/module/python/install_module.py,sha256=r5-FMbfpIu8uwKzilEZnAK-VT5D3k0pRzGwt-booeIw,1391
+builddrone/module/python/pylint_module.py,sha256=pKs8WlP7IzHxjbimfuNxXxyGJ7gaifhfX5nrAVZPm1U,1795
+builddrone/module/python/run_module.py,sha256=W55SGS4NtkD2U5oa5u--Mwa0iAuktJCE0xZCKCMJVoY,1034
+builddrone/module/python/venv_module.py,sha256=P6QIMsCQ3OssBXCXulMbIwm9JPAKqjrYoRYjW-7aOTI,2392
+builddrone/module/robotframework/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+builddrone/module/robotframework/rebot_module.py,sha256=EszcfKSR_TT7rmCBkXel-wZQEadlCUCC2ul2hDfYgnk,607
+builddrone/module/robotframework/robotframework_base_module.py,sha256=v1KWtBaAgnLX4SAqJBmWpAqxDF4F79OMOgdkret18rw,2287
+builddrone/module/robotframework/test_module.py,sha256=4md-kQMXI3D4I8zvM2AvesU0WqY0AMoJ_W-lHkY5P7Y,595
+builddrone-0.1.0.dist-info/METADATA,sha256=1yrHfgdkcynN4m3lmmIUZNhxAJfYPDRdwev4mDjQpVY,4624
+builddrone-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+builddrone-0.1.0.dist-info/top_level.txt,sha256=gUWOrFMfu2uJaRS6sDDChaoIsMOVkzqKU_SPDMkKRQ8,11
+builddrone-0.1.0.dist-info/RECORD,,

builddrone-0.1.0.dist-info/WHEEL

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

builddrone-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+builddrone