werr 0.1.0__tar.gz

werr-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joe Jenne
+
+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

werr-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: werr
+Version: 0.1.0
+Summary: A python project task runner
+Project-URL: Homepage, https://github.com/jhjn/werr
+Project-URL: Repository, https://github.com/jhjn/werr
+Keywords: tasks,task-runner,makefile,checks,uv,automation,werr
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# werr
+
+A simple, opinionated, python project task runner.
+
+A task is a configured sequence of commands to run.
+
+```toml
+[project]
+name = "appletree"
+version = "0.1.0"
+dependencies = [
+    "pysunlight==24.1",
+]
+
+[tool.werr]
+# 'check' is the default task if `werr` is run with no arguments.
+task.check = [
+    "black --check {project}",
+    "isort --check {project}",
+    "ruff check {project}",
+    "mypy {project}",
+    "pytest",
+]
+task.fix = [
+    "black {project}",
+    "isort {project}",
+    "ruff fix {project}",
+]
+```
+
+Running `werr` executes each `check` command in sequence, printing which failed and how.
+The tool returns a non-zero exit code if any command fails.
+
+Running `werr fix` executes each `fix` command in sequence.
+
+NOTE: All commands are run using `uv` (the only dependency of this project).
+
+## Command Variables
+
+The following `{...}` variables are provided by `werr` to be used in task commands:
+
+- `{project}` - the absolute path to the directory containing the `pyproject.toml` file
+
+## Structured Output
+
+```bash
+werr         # interactive human readable output (default)
+werr --json  # emit lines of JSON representing the result of each command
+werr --xml   # print Junit XML for CI
+```
+
+## Custom Tasks
+
+Define a custom task with `task.<name> = [ ... ]`
+
+```toml
+[tool.werr]
+# ...
+task.docs = [
+    "sphinx-build -b html {project}",
+]
+```
+
+Running `werr docs` will build the documentation.
+
+## New Project
+
+A suggested workflow for creating a new project is:
+
+1. `uv init`
+2. `uv add --dev black ruff ty pytest`
+3. add tasks to `[tool.werr]`
+4. `uvx werr` or add to `dev` group and in venv just `werr`

werr-0.1.0/README.md

@@ -0,0 +1,73 @@
+# werr
+
+A simple, opinionated, python project task runner.
+
+A task is a configured sequence of commands to run.
+
+```toml
+[project]
+name = "appletree"
+version = "0.1.0"
+dependencies = [
+    "pysunlight==24.1",
+]
+
+[tool.werr]
+# 'check' is the default task if `werr` is run with no arguments.
+task.check = [
+    "black --check {project}",
+    "isort --check {project}",
+    "ruff check {project}",
+    "mypy {project}",
+    "pytest",
+]
+task.fix = [
+    "black {project}",
+    "isort {project}",
+    "ruff fix {project}",
+]
+```
+
+Running `werr` executes each `check` command in sequence, printing which failed and how.
+The tool returns a non-zero exit code if any command fails.
+
+Running `werr fix` executes each `fix` command in sequence.
+
+NOTE: All commands are run using `uv` (the only dependency of this project).
+
+## Command Variables
+
+The following `{...}` variables are provided by `werr` to be used in task commands:
+
+- `{project}` - the absolute path to the directory containing the `pyproject.toml` file
+
+## Structured Output
+
+```bash
+werr         # interactive human readable output (default)
+werr --json  # emit lines of JSON representing the result of each command
+werr --xml   # print Junit XML for CI
+```
+
+## Custom Tasks
+
+Define a custom task with `task.<name> = [ ... ]`
+
+```toml
+[tool.werr]
+# ...
+task.docs = [
+    "sphinx-build -b html {project}",
+]
+```
+
+Running `werr docs` will build the documentation.
+
+## New Project
+
+A suggested workflow for creating a new project is:
+
+1. `uv init`
+2. `uv add --dev black ruff ty pytest`
+3. add tasks to `[tool.werr]`
+4. `uvx werr` or add to `dev` group and in venv just `werr`

werr-0.1.0/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "werr"
+version = "0.1.0"
+description = "A python project task runner"
+readme = "README.md"
+requires-python = ">=3.14"
+scripts = { "werr" = "werrlib.main:console_entry" }
+urls = { "Homepage" = "https://github.com/jhjn/werr", "Repository" = "https://github.com/jhjn/werr" }
+keywords = ["tasks", "task-runner", "makefile", "checks", "uv", "automation", "werr"]
+classifiers = [
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python",
+  "Topic :: Software Development :: Build Tools",
+  "Topic :: Software Development :: Quality Assurance",
+  "Topic :: Software Development :: Testing"
+]
+dependencies = []
+
+[dependency-groups]
+dev = [
+    "black>=25.12.0",
+    "pytest>=9.0.2",
+    "ruff>=0.14.10",
+    "ty>=0.0.9",
+]
+
+[tool.uv]
+package = true
+
+[tool.werr]
+task.check = [
+    "black --check {project}/werrlib",
+    "ruff check {project}/werrlib",
+    "ty check {project}/werrlib",
+]
+task.fix = [
+    "black {project}/werrlib",
+    "ruff check --fix {project}/werrlib",
+]
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "COM812",  # Trailing comma missing
+    "D203",    # one-blank-line-before-class
+    "D205",    # 1 blank line required between summary line and description
+    "D213",    # Multi line summary on the second line
+    "D401",    # First line of docstring should be in imperative mood
+    "EM101",   # Exception must not use a string literal, assign to variable first
+    "EM102",   # Exception must not use an f-string literal, assign to variable first
+    "FIX002",  # Allow TODO comments for future enhancements
+    "S101",    # Use of `assert` detected
+    "S602",    # `subprocess` call with `shell=True` identified, security issue
+    "SIM108",  # Use ternary operator
+    "T201",    # `print` found
+    "TD002",   # Missing author in TODO; try: `# TODO(<author_name>): ...` or `# TODO @<author_name>: ...`
+    "TD003",   # Missing issue link for this TODO
+    "TRY003",  # Avoid specifying long messages outside the exception class
+]

werr-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

werr-0.1.0/werr.egg-info/.gitignore

@@ -0,0 +1 @@
+*

werr-0.1.0/werr.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: werr
+Version: 0.1.0
+Summary: A python project task runner
+Project-URL: Homepage, https://github.com/jhjn/werr
+Project-URL: Repository, https://github.com/jhjn/werr
+Keywords: tasks,task-runner,makefile,checks,uv,automation,werr
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# werr
+
+A simple, opinionated, python project task runner.
+
+A task is a configured sequence of commands to run.
+
+```toml
+[project]
+name = "appletree"
+version = "0.1.0"
+dependencies = [
+    "pysunlight==24.1",
+]
+
+[tool.werr]
+# 'check' is the default task if `werr` is run with no arguments.
+task.check = [
+    "black --check {project}",
+    "isort --check {project}",
+    "ruff check {project}",
+    "mypy {project}",
+    "pytest",
+]
+task.fix = [
+    "black {project}",
+    "isort {project}",
+    "ruff fix {project}",
+]
+```
+
+Running `werr` executes each `check` command in sequence, printing which failed and how.
+The tool returns a non-zero exit code if any command fails.
+
+Running `werr fix` executes each `fix` command in sequence.
+
+NOTE: All commands are run using `uv` (the only dependency of this project).
+
+## Command Variables
+
+The following `{...}` variables are provided by `werr` to be used in task commands:
+
+- `{project}` - the absolute path to the directory containing the `pyproject.toml` file
+
+## Structured Output
+
+```bash
+werr         # interactive human readable output (default)
+werr --json  # emit lines of JSON representing the result of each command
+werr --xml   # print Junit XML for CI
+```
+
+## Custom Tasks
+
+Define a custom task with `task.<name> = [ ... ]`
+
+```toml
+[tool.werr]
+# ...
+task.docs = [
+    "sphinx-build -b html {project}",
+]
+```
+
+Running `werr docs` will build the documentation.
+
+## New Project
+
+A suggested workflow for creating a new project is:
+
+1. `uv init`
+2. `uv add --dev black ruff ty pytest`
+3. add tasks to `[tool.werr]`
+4. `uvx werr` or add to `dev` group and in venv just `werr`

werr-0.1.0/werr.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+werr.egg-info/.gitignore
+werr.egg-info/PKG-INFO
+werr.egg-info/SOURCES.txt
+werr.egg-info/dependency_links.txt
+werr.egg-info/entry_points.txt
+werr.egg-info/top_level.txt
+werrlib/__init__.py
+werrlib/cli.py
+werrlib/cmd.py
+werrlib/config.py
+werrlib/main.py
+werrlib/report.py
+werrlib/task.py
+werrlib/xml.py

werr-0.1.0/werr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

werr-0.1.0/werr.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+werr = werrlib.main:console_entry

werr-0.1.0/werr.egg-info/top_level.txt

@@ -0,0 +1 @@
+werrlib

werr-0.1.0/werrlib/__init__.py

@@ -0,0 +1 @@
+"""werrlib - the python project task runner library."""

werr-0.1.0/werrlib/cli.py

@@ -0,0 +1,96 @@
+"""The command line interface for the werr tool."""
+
+import _colorize  # ty: ignore[unresolved-import]
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+from . import report, task
+
+log = logging.getLogger("cli")
+
+_colorize.set_theme(
+    _colorize.Theme(
+        argparse=_colorize.Argparse(
+            usage=_colorize.ANSIColors.BOLD_GREEN,
+            prog=_colorize.ANSIColors.BOLD_CYAN,
+            heading=_colorize.ANSIColors.BOLD_GREEN,
+            summary_long_option=_colorize.ANSIColors.CYAN,
+            summary_short_option=_colorize.ANSIColors.CYAN,
+            summary_label=_colorize.ANSIColors.CYAN,
+            summary_action=_colorize.ANSIColors.CYAN,
+            long_option=_colorize.ANSIColors.BOLD_CYAN,
+            short_option=_colorize.ANSIColors.BOLD_CYAN,
+            label=_colorize.ANSIColors.CYAN,
+            action=_colorize.ANSIColors.BOLD_CYAN,
+        )
+    )
+)
+
+
+def _get_parser() -> argparse.ArgumentParser:
+    """Create a parser for the saturn CLI."""
+    parser = argparse.ArgumentParser(
+        prog="werr",
+        description="A simple python project task runner",
+    )
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose logging")
+
+    parser.add_argument(
+        "-p",
+        "--project",
+        type=Path,
+        default=Path.cwd(),
+        help="Python project directory (defaults to cwd)",
+    )
+
+    parser.add_argument(
+        "task",
+        nargs="?",
+        default=task.DEFAULT,
+        help=f"Task to run (defined in pyproject.toml, defaults to '{task.DEFAULT}')",
+    )
+
+    # Output format selection - all options write to 'reporter' dest
+    # CLI is the default via set_defaults
+    output_fmt = parser.add_mutually_exclusive_group()
+    output_fmt.add_argument(
+        "--cli",
+        action="store_const",
+        const=report.CliReporter,
+        dest="reporter",
+        help="Print results to the console (default)",
+    )
+    output_fmt.add_argument(
+        "--xml",
+        action="store_const",
+        const=report.XmlReporter,
+        dest="reporter",
+        help="Print results as Junit XML",
+    )
+    output_fmt.add_argument(
+        "--json",
+        action="store_const",
+        const=report.JsonReporter,
+        dest="reporter",
+        help="Print results as lines of JSON",
+    )
+    parser.set_defaults(reporter=report.CliReporter)
+
+    return parser
+
+
+def run(argv: list[str]) -> None:
+    """Main entrypoint of the werr tool."""
+    args = _get_parser().parse_args(argv)
+
+    logging.basicConfig(
+        format="[%(levelname)s] %(message)s",
+        level=logging.DEBUG if args.verbose else logging.INFO,
+    )
+    log.debug("Called with arguments: %s", argv)
+
+    success = task.run(args.project, args.task, args.reporter)
+    if not success:
+        sys.exit(1)

werr-0.1.0/werrlib/cmd.py

@@ -0,0 +1,64 @@
+"""Wrappers of `subprocess` for custom werr functionality."""
+
+from __future__ import annotations
+
+import logging
+import os
+import subprocess
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+log = logging.getLogger("cmd")
+
+
+@dataclass(frozen=True, slots=True)
+class Result:
+    """Information about a *completed* process."""
+
+    task: Command
+    returncode: int
+    duration: float
+    output: str
+
+    @property
+    def success(self) -> bool:
+        """Return True if the process was successful."""
+        return self.returncode == 0
+
+
+@dataclass(frozen=True, slots=True)
+class Command:
+    """A command to be run as part of a task."""
+
+    command: str
+
+    @property
+    def name(self) -> str:
+        """The name of the task."""
+        return self.command.split(" ")[0]
+
+    def resolved_command(self, projectdir: Path) -> str:
+        """Return the command with the {...} variables substituted."""
+        return self.command.replace("{project}", str(projectdir.resolve()))
+
+    def run(self, projectdir: Path) -> Result:
+        """Run the task using `uv` in isolated mode."""
+        command = f"uv run --project '{projectdir}' {self.resolved_command(projectdir)}"
+        log.debug("Running command: %s", command)
+        start = time.monotonic()
+        process = subprocess.run(
+            command,
+            shell=True,
+            check=False,  # the returncode is checked manually
+            text=True,
+            stderr=subprocess.STDOUT,
+            stdout=subprocess.PIPE,
+            # env is a copy but without the `VIRTUAL_ENV` variable.
+            env=os.environ.copy() | {"VIRTUAL_ENV": ""},
+        )
+        duration = time.monotonic() - start
+        return Result(self, process.returncode, duration, process.stdout)

werr-0.1.0/werrlib/config.py

@@ -0,0 +1,35 @@
+"""Loading of python project config for checking."""
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+try:
+    import tomllib as tomli
+except ImportError:
+    import tomli  # type: ignore[import]
+
+from . import cmd
+
+log = logging.getLogger("config")
+
+
+def load_project(pyproject: Path, task: str) -> tuple[str, list[cmd.Command]]:
+    """Load the commands from the pyproject.toml file."""
+    with pyproject.open("rb") as f:
+        config = tomli.load(f)
+
+    # validation of [tool.werr] section
+    if "tool" not in config or "werr" not in config["tool"]:
+        raise ValueError("pyproject.toml does not contain a [tool.werr] section")
+    if (
+        "task" not in config["tool"]["werr"]
+        or task not in config["tool"]["werr"]["task"]
+    ):
+        raise ValueError(f"[tool.werr] does not contain a `task.{task}` list")
+
+    return config["project"]["name"], [
+        cmd.Command(task) for task in config["tool"]["werr"]["task"][task]
+    ]

werr-0.1.0/werrlib/main.py

@@ -0,0 +1,35 @@
+"""Entrypoint for the werr CLI tool."""
+
+__all__ = ("console_entry",)
+
+import logging
+import subprocess
+import sys
+import traceback
+
+from . import cli
+
+log = logging.getLogger("saturn")
+
+
+def console_entry() -> None:
+    """Entrypoint for CLI usage."""
+    try:
+        cli.run(sys.argv[1:])
+    # TODO: Better process failure error reporting
+    except subprocess.CalledProcessError as e:
+        log.debug(traceback.format_exc())
+        log.error(str(e.stdout).strip())  # noqa: TRY400
+        log.error(str(e.stderr).strip())  # noqa: TRY400
+        sys.exit(e.returncode)
+    except Exception as e:  # noqa: BLE001
+        log.debug(traceback.format_exc())
+        log.error(e)  # noqa: TRY400
+        sys.exit(1)
+    except KeyboardInterrupt:
+        log.error("Interrupted by user.")  # noqa: TRY400
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    console_entry()

werr-0.1.0/werrlib/report.py

@@ -0,0 +1,195 @@
+"""Manage the recording and reporting of tasks."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import textwrap
+from _colorize import ANSIColors as C  # ty: ignore[unresolved-import]
+from abc import ABC, abstractmethod
+
+from . import cmd, xml
+
+log = logging.getLogger("report")
+ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+
+_SUITENAME = "werr"
+_TOTAL_HEAD_LEN = 25
+_HEAD_PFX = "      "
+
+
+class Reporter(ABC):
+    """A reporter for reporting the results of a task."""
+
+    @staticmethod
+    @abstractmethod
+    def emit_info(msg: str) -> None:
+        """Print a message for an interactive reader."""
+
+    @staticmethod
+    @abstractmethod
+    def emit_start(cmd: cmd.Command) -> None:
+        """What is printed before a command begins."""
+
+    @staticmethod
+    @abstractmethod
+    def emit_end(result: cmd.Result) -> None:
+        """What is printed after a command completes."""
+
+    @staticmethod
+    @abstractmethod
+    def emit_summary(results: list[cmd.Result]) -> None:
+        """What is printed after the task has completed."""
+
+
+class CliReporter(Reporter):
+    """A reporter for reporting the results of a task to the console."""
+
+    task_index = 0
+
+    @staticmethod
+    def emit_info(msg: str) -> None:
+        """Print to console."""
+        print(msg)
+
+    @staticmethod
+    def emit_start(cmd: cmd.Command) -> None:
+        """Emit the start of a command."""
+        prefix = f"[{CliReporter.task_index+1}]"
+        print(f"{prefix:<5} {cmd.name:<20} ", end="", flush=True)
+        CliReporter.task_index += 1
+
+    @staticmethod
+    def emit_end(result: cmd.Result) -> None:
+        """Emit the end of a command."""
+        if result.success:
+            status = f"{C.GREEN}PASSED{C.RESET}"
+        else:
+            status = f"{C.RED}FAILED{C.RESET}"
+
+        print(f"({result.duration:>2.2f} secs) {status:>18}", flush=True)
+
+    @staticmethod
+    def emit_summary(results: list[cmd.Result]) -> None:
+        """Print the summary line explaining what the net result was."""
+        successes = [result for result in results if result.success]
+        failures = [result for result in results if not result.success]
+        duration = sum(result.duration for result in results)
+
+        msg = (
+            f"Ran {len(results)} check{_plural(len(results))} in "
+            f"{duration:>2.2f} secs, "
+            f"{len(successes)} Passed, {len(failures)} Failed"
+        )
+        print(f"{C.RED if failures else C.GREEN}{msg}{C.RESET}")
+
+        if failures:
+            print("\nFailures:\n---------")
+            for result in failures:
+                CliReporter.emit_start(result.task)
+                print()
+                print(textwrap.indent(result.output, _HEAD_PFX))
+
+
+class JsonReporter(Reporter):
+    """A reporter for reporting the results of a task in lines of JSON."""
+
+    @staticmethod
+    def emit_info(msg: str) -> None:
+        """Print nothing."""
+
+    @staticmethod
+    def emit_start(cmd: cmd.Command) -> None:
+        """Print nothing."""
+
+    @staticmethod
+    def emit_end(result: cmd.Result) -> None:
+        """Emit the end of a command."""
+        print(
+            json.dumps(
+                {
+                    "task": result.task.name,
+                    "command": result.task.command,
+                    "duration": result.duration,
+                    "output": ansi_escape.sub("", result.output),
+                    "success": result.success,
+                }
+            )
+        )
+
+    @staticmethod
+    def emit_summary(results: list[cmd.Result]) -> None:
+        """Print nothing."""
+
+
+class XmlReporter(Reporter):
+    """A reporter for reporting the results of a task as Junit XML."""
+
+    @staticmethod
+    def emit_info(msg: str) -> None:
+        """Print nothing."""
+
+    @staticmethod
+    def emit_start(cmd: cmd.Command) -> None:
+        """Print nothing."""
+
+    @staticmethod
+    def emit_end(result: cmd.Result) -> None:
+        """Print nothing."""
+
+    @staticmethod
+    def emit_summary(results: list[cmd.Result]) -> None:
+        """Print Junit XML summary."""
+        print(_create_xml(results))
+
+
+def _plural(size: int) -> str:
+    """Return 's' if the size is not a single element."""
+    if size == 1:
+        return ""
+    return "s"
+
+
+def _create_xml(results: list[cmd.Result]) -> str:
+    """Create a string representing the results as Junit XML."""
+    failures = [result for result in results if not result.success]
+    duration = sum(result.duration for result in results)
+
+    root = xml.Node(
+        "testsuites",
+        tests=len(results),
+        failures=len(failures),
+        errors=0,
+        skipped=0,
+        time=duration,
+    )
+    sa = xml.Node(
+        "testsuite",
+        name=_SUITENAME,
+        time=duration,
+        tests=len(results),
+        failures=len(failures),
+        errors=0,
+        skipped=0,
+    )
+    root.add_child(sa)
+
+    for result in results:
+        sa.add_child(_result_xml(result))
+
+    return root.to_document()
+
+
+def _result_xml(result: cmd.Result) -> xml.Node:
+    """Create a single Junit XML testcase."""
+    node = xml.Node(
+        "testcase",
+        name=result.task.name,
+        time=result.duration,
+        classname=_SUITENAME,
+    )
+    if not result.success:
+        node.add_child(xml.Node("failure", ansi_escape.sub("", result.output)))
+    return node

werr-0.1.0/werrlib/task.py

@@ -0,0 +1,34 @@
+"""Orchestration of task execution."""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+from . import config, report
+
+DEFAULT = "check"
+
+
+def run(
+    projectdir: Path,
+    task: str = DEFAULT,
+    reporter: type[report.Reporter] = report.CliReporter,
+) -> bool:
+    """Run the specified task and return True if all are successful.
+
+    Emit results as we go.
+    """
+    name, cmds = config.load_project(projectdir / "pyproject.toml", task)
+    reporter.emit_info(f"Project: {name} ({task})")
+
+    results = []
+    for cmd in cmds:
+        reporter.emit_start(cmd)
+        result = cmd.run(projectdir)
+        results.append(result)
+        reporter.emit_end(result)
+
+    reporter.emit_summary(results)
+
+    return all(result.success for result in results)

werr-0.1.0/werrlib/xml.py

@@ -0,0 +1,59 @@
+"""Abstractions for the creation and stringification of XML objects."""
+
+from __future__ import annotations
+
+import textwrap
+
+_Val = str | int | float
+
+_HEADER = "<?xml version='1.0' encoding='utf-8'?>"
+
+
+class Node:
+    """An XML element."""
+
+    name: str
+    attributes: dict[str, _Val]
+
+    # The content of an element is usually either text or more elements.
+    text: str
+    children: list[Node]
+
+    def __init__(self, _name: str, _text: str = "", **attributes: _Val) -> None:
+        """Initialise an element by name, optional text content and tag attributes
+        set via kwargs.
+        """
+        self.name = _name
+        self.attributes = attributes
+
+        self.text = _text
+        self.children = []
+
+    def add_child(self, child: Node) -> None:
+        """Add a child node to the current node."""
+        self.children.append(child)
+
+    def __str__(self) -> str:
+        """String XML representation of the node."""
+        attrs = " ".join((f'{name}="{val}"' for name, val in self.attributes.items()))
+        tags = f"<{self.name} {attrs}"
+        if self.text or self.children:
+            tags += ">\n" + _str_internal(self.text, self.children) + f"</{self.name}>"
+        else:
+            tags += "/>"
+
+        return tags
+
+    def to_document(self) -> str:
+        """Create an XML document by prefixing the stringified root element with
+        a header.
+        """
+        return f"{_HEADER}\n{self}"
+
+
+def _str_internal(text: str, children: list[Node]) -> str:
+    """Create a string representation of the inside of a node."""
+    if children:
+        text += "\n".join(str(child) for child in children) + "\n"
+
+    return textwrap.indent(text, "    ")