acbox 0.0.0__py3-none-any.whl

acbox/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.0.0"
+__hash__ = "de1dc99"

acbox/cli/flags/base.py

@@ -0,0 +1,44 @@
+import argparse
+
+
+class ArgumentTypeBase:
+    class _NA:
+        pass
+
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+        self._default = self._NA
+        self.__name__ = self.__class__.__name__
+
+    @property
+    def default(self):
+        return self._default
+
+    @default.setter
+    def default(self, value):
+        if value is ArgumentTypeBase._NA:
+            self._default = ArgumentTypeBase._NA
+        else:
+            self._default = self._validate(value)
+        return self._default
+
+    def __call__(self, txt):
+        self._value = None
+        self._value = self._validate(txt)
+        return self
+
+    @property
+    def value(self):
+        return getattr(self, "_value", self.default)
+
+    def _validate(self, value):
+        try:
+            return self.validate(value)
+        except argparse.ArgumentTypeError as exc:
+            if not hasattr(self, "_value"):
+                raise RuntimeError(f"cannot use {value=} as default: {exc.args[0]}")
+            raise
+
+    def validate(self, txt):
+        raise NotImplementedError("need to implement the .validate(self, txt)  method")

acbox/cli/flags/logging.py

@@ -0,0 +1,34 @@
+import argparse
+import logging
+from typing import Any
+
+from ..parsers.base import ArgumentParserBase
+
+
+def add_arguments_logging(parser: ArgumentParserBase, baselevel: int = logging.INFO) -> None:
+    group = parser.add_argument_group("Logging", "Logging related options")
+    group.add_argument("-v", "--verbose", dest="managed-loglevel", action="append_const", const=1, help="report verbose logging")
+    group.add_argument("-q", "--quiet", dest="managed-loglevel", action="append_const", const=-1, help="report quiet logging")
+
+    levelmap = [
+        logging.DEBUG,
+        logging.INFO,
+        logging.WARNING,
+        logging.ERROR,
+        logging.CRITICAL,
+        logging.FATAL,
+    ]
+    if baselevel not in levelmap:
+        raise IndexError(f"cannot find level {baselevel} in: {levelmap}")
+
+    def setup_logging(config: dict[str, Any]) -> None:
+        logging.basicConfig(**config)
+
+    def callback(args: argparse.Namespace):
+        config = {}
+        count = levelmap.index(baselevel) - sum(getattr(args, "managed-loglevel") or [0])
+        config["level"] = levelmap[min(max(count, 0), len(levelmap) - 1)]
+        setup_logging(config)
+        delattr(args, "managed-loglevel")
+
+    parser.callbacks.append(callback)

acbox/cli/parsers/base.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import argparse
+import types
+
+from ..flags.base import ArgumentTypeBase
+from ..shared import ArgsCallback, check_default_constructor
+
+
+class ArgumentParserBase(argparse.ArgumentParser):
+    def __init__(self, modules: list[types.ModuleType], *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.modules = modules
+        self.callbacks: list[ArgsCallback | None] = []
+
+    def _post_process(self, options):
+        for name in dir(options):
+            if isinstance(getattr(options, name), ArgumentTypeBase):
+                fallback = getattr(options, name).value
+                setattr(
+                    options,
+                    name,
+                    None if fallback is ArgumentTypeBase._NA else fallback,
+                )
+        for callback in self.callbacks:
+            options = callback(options) or options
+        return options
+
+    def parse_known_args(self, args=None, namespace=None):
+        options, argv = super().parse_known_args(args, namespace)
+        return self._post_process(options), argv
+
+    def parse_args(self, args=None, namespace=None):
+        options = super().parse_args(args, namespace)
+        for name in dir(options):
+            if isinstance(getattr(options, name), ArgumentTypeBase):
+                fallback = getattr(options, name).value
+                setattr(
+                    options,
+                    name,
+                    None if fallback is ArgumentTypeBase._NA else fallback,
+                )
+        return options
+
+    def add_argument(self, *args, **kwargs):
+        typ = kwargs.get("type")
+        obj = None
+        if isinstance(typ, type) and issubclass(typ, ArgumentTypeBase):
+            check_default_constructor(typ)
+            obj = typ()
+        if isinstance(typ, ArgumentTypeBase):
+            obj = typ
+        if obj is not None:
+            obj.default = kwargs.get("default", ArgumentTypeBase._NA)
+            kwargs["default"] = obj
+            kwargs["type"] = obj
+        super().add_argument(*args, **kwargs)
+
+    def error(self, message):
+        try:
+            super().error(message)
+        except SystemExit:
+            # gh-121018
+            raise argparse.ArgumentError(None, message)
+
+    @classmethod
+    def get_parser(cls, modules: list[types.ModuleType], **kwargs):
+        raise NotImplementedError("implement this method")

acbox/cli/parsers/parser.py

@@ -0,0 +1 @@
+from __future__ import annotations

acbox/cli/parsers/simple.py

@@ -0,0 +1,47 @@
+import argparse
+import logging
+import sys
+import types
+
+from .base import ArgumentParserBase
+
+log = logging.getLogger(__name__)
+
+
+def log_sys_info(modules: list[types.ModuleType]):
+    log.debug("interpreter: %s", sys.executable)
+
+
+class ArgumentParser(ArgumentParserBase):
+    def parse_args(self, args=None, namespace=None):
+        options = super().parse_args(args, namespace)
+
+        # reserver attributes
+        for reserved in [
+            "modules",
+            "error",
+        ]:
+            if not hasattr(options, reserved):
+                continue
+            raise RuntimeError(f"cannot add an argument with dest='{reserved}'")
+        options.error = self.error
+        options.modules = self.modules
+
+        for callback in self.callbacks:
+            if not callback:
+                continue
+            options = callback(options) or options
+
+        log_sys_info(self.modules)
+        return options
+
+    @classmethod
+    def get_parser(cls, modules: list[types.ModuleType], **kwargs):
+        class Formatter(
+            argparse.RawTextHelpFormatter,
+            argparse.RawDescriptionHelpFormatter,
+            argparse.ArgumentDefaultsHelpFormatter,
+        ):
+            pass
+
+        return cls(modules, formatter_class=Formatter, **kwargs)

acbox/cli/script.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import argparse
+import contextlib
+import functools
+import inspect
+import logging
+import sys
+import time
+from typing import Any, Callable
+
+from .parsers.base import ArgumentParserBase
+from .parsers.simple import ArgumentParser
+from .shared import AbortCliError, AbortWrongArgumentError
+
+log = logging.getLogger(__name__)
+
+
+@contextlib.contextmanager
+def setup(
+    function: Callable,
+    add_arguments: (Callable[[ArgumentParserBase], None] | Callable[[argparse.ArgumentParser], None] | None) = None,
+    process_args: (Callable[[argparse.Namespace], argparse.Namespace | None] | None) = None,
+):
+    sig = inspect.signature(function)
+    module = inspect.getmodule(function)
+
+    # the cli decorated function might have two special parameters:
+    #  - args this will receive non-parsed arguments (eg from nargs="*")
+    #  - parser escape hatch to the parser object (probably never used)
+    if "args" in sig.parameters and "parser" in sig.parameters:
+        raise RuntimeError(f"function '{module}.{function.__name__}' cannot take args and parser at the same time")
+
+    # doc is taken from the function itself or the containing module
+    description, _, epilog = (function.__doc__ or module.__doc__ or "").strip().partition("\n")
+    epilog = f"{description}\n{'-' * len(description)}\n{epilog}"
+    description = ""
+
+    # extract parser info/fallbacks from all these modules
+    modules = [
+        sys.modules[__name__],
+    ]
+    if module:
+        modules.append(module)
+
+    parser = ArgumentParser.get_parser(modules, description=description, epilog=epilog)
+    if add_arguments and (callbacks := add_arguments(parser)):
+        if isinstance(callbacks, list):
+            parser.callbacks.extend(callbacks)
+        else:
+            parser.callbacks.append(callbacks)
+
+    kwargs = {}
+    if "parser" in sig.parameters:
+        kwargs["parser"] = parser
+
+    t0 = time.monotonic()
+    success = "completed"
+    errormsg = ""
+    show_timing = True
+    # breakpoint()
+    try:
+        if "parser" not in sig.parameters:
+            args = parser.parse_args()
+            if process_args:
+                args = process_args(args) or args
+
+            if "args" in sig.parameters:
+                kwargs["args"] = args
+        yield sig.bind(**kwargs)
+
+    except argparse.ArgumentError:
+        sys.exit(2)
+        pass
+    except AbortCliError as exc:
+        show_timing = False
+        if exc.args:
+            print(str(exc), file=sys.stderr)
+        sys.exit(2)
+    except AbortWrongArgumentError as exc:
+        show_timing = False
+        parser.print_usage(sys.stderr)
+        print(f"{parser.prog}: error: {exc.args[0]}", file=sys.stderr)
+        sys.exit(2)
+    except SystemExit as exc:
+        show_timing = False
+        sys.exit(exc.code)
+    except Exception:
+        log.exception("un-handled exception")
+        success = "failed with an exception"
+    finally:
+        if show_timing:
+            delta = round(time.monotonic() - t0, 2)
+            log.debug("task %s in %.2fs", success, delta)
+    if errormsg:
+        parser.error(errormsg)
+
+
+def cli(
+    add_arguments: (Callable[[ArgumentParserBase], Any] | Callable[[argparse.ArgumentParser], Any] | None) = None,
+    process_args: (Callable[[argparse.Namespace], argparse.Namespace | None] | None) = None,
+):
+    def _cli1(function):
+        module = inspect.getmodule(function)
+
+        if inspect.iscoroutinefunction(function):
+
+            @functools.wraps(function)
+            async def _cli2(*args, **kwargs):
+                with setup(function, add_arguments, process_args) as ba:
+                    return await function(*ba.args, **ba.kwargs)
+
+        else:
+
+            @functools.wraps(function)
+            def _cli2(*args, **kwargs):
+                with setup(function, add_arguments, process_args) as ba:
+                    return function(*ba.args, **ba.kwargs)
+
+        _cli2.attributes = {
+            "doc": function.__doc__ or module.__doc__ or "",
+        }
+        return _cli2
+
+    return _cli1

acbox/cli/shared.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import argparse
+import inspect
+import sys
+from typing import Callable
+
+# The return type of add_arguments
+
+if sys.version_info >= (3, 10):
+    ArgsCallback = Callable[[argparse.Namespace], None | argparse.Namespace]
+else:
+    ArgsCallback = Callable
+
+
+class CliBaseError(Exception):
+    pass
+
+
+class AbortCliError(CliBaseError):
+    pass
+
+
+class AbortWrongArgumentError(CliBaseError):
+    pass
+
+
+def check_default_constructor(klass: type):
+    signature = inspect.signature(klass.__init__)  # type: ignore[misc]
+    for name, value in signature.parameters.items():
+        if name in {"self", "args", "kwargs"}:
+            continue
+        if value.default is inspect.Signature.empty:
+            raise RuntimeError(f"the {klass}() cannot be called without arguments")

acbox/cli2.py

@@ -0,0 +1,59 @@
+import functools
+import logging
+from argparse import Namespace
+from typing import Callable
+
+import click
+
+TypeFn = Callable[[Namespace], None]
+
+
+def add_loglevel(fn: TypeFn) -> TypeFn:
+    fn = click.option("-v", "--verbose", count=True)(fn)
+    fn = click.option("-q", "--quiet", count=True)(fn)
+    return fn
+
+
+def process_loglevel(options: Namespace, verbose_flag: bool = False) -> Namespace:
+    level = max(min(options.__dict__.pop("verbose") - options.__dict__.pop("quiet"), 1), -1)
+
+    # console = Console(theme=Theme({"log.time": "cyan"}))
+    logging.basicConfig(
+        level={-1: logging.WARNING, 0: logging.INFO, 1: logging.DEBUG}[level],
+        # datefmt="[%X]",
+        # handlers=[RichHandler(console=console, rich_tracebacks=True)]
+    )
+    if verbose_flag:
+        options.verbose = level > 0
+    return options
+
+
+def clickwrapper(
+    add_arguments: Callable[[TypeFn], TypeFn] | None = None,
+    process_options: Callable[[Namespace], None | Namespace] | None = None,
+    verbose_flag: bool = False,
+) -> Callable[[TypeFn], None]:
+    def _clickwrapper(fn: TypeFn):
+        fn = add_loglevel(fn)
+        if add_arguments:
+            fn = add_arguments(fn)
+
+        @functools.wraps(fn)
+        def __clickwrapper(*args, **kwargs):
+            options = Namespace(**kwargs)
+            options = process_loglevel(options, verbose_flag=verbose_flag) or options
+            if hasattr(options, "error"):
+                raise RuntimeError("you have an error option")
+
+            def error(msg):
+                raise click.UsageError(msg)
+
+            options.error = error
+            if process_options:
+                options = process_options(options) or options
+
+            return fn(options)
+
+        return __clickwrapper
+
+    return _clickwrapper

acbox/dictionaries.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, MutableMapping
+from typing import Any
+
+DELETE = object()
+
+
+def dictupdate(data: MutableMapping[str, Any], updates: Iterable[tuple[str, Any]]) -> list[tuple[str, Any]]:
+    undo = []
+    for path, value in updates:
+        cur = data
+        loc = path.split(".")
+        for i in range(len(loc) - 1):
+            if loc[i] not in cur:
+                cur[loc[i]] = dict()
+                undo.append((".".join(loc[: i + 1]), DELETE))
+            cur = cur[loc[i]]
+
+        orig = cur.get(loc[-1], DELETE)
+        undo.append((path, orig))
+        if value is DELETE:
+            del cur[loc[-1]]
+        else:
+            cur[loc[-1]] = value
+
+    return undo
+
+
+def dictrollback(data: MutableMapping[str, Any], undo: list[tuple[str, Any]]) -> None:
+    for path, value in reversed(undo):
+        cur = data
+        loc = path.split(".")
+        for c in loc[:-1]:
+            cur = cur[c]
+        if value is DELETE:
+            del cur[loc[-1]]
+        else:
+            cur[loc[-1]] = value

acbox/fileops.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Callable, Generator
+
+
+def which_n(exe: str | Path) -> list[Path] | None:
+    candidates: list[Path] | None = None
+    for srcdir in os.environ.get("PATH", "").split(os.pathsep):
+        for ext in os.environ.get("PATHEXT", "").split(os.pathsep):
+            path = srcdir / Path(exe).with_suffix(ext)
+            if not path.exists():
+                continue
+            if candidates is None:
+                candidates = []
+            candidates.append(path)
+    return candidates
+
+
+def which(exe: str | Path) -> Path | None:
+    candidates = which_n(exe)
+    if candidates is None:
+        return None
+    return candidates[0]
+
+
+@contextlib.contextmanager
+def tmpdir(source: Path | None) -> Generator[Path, None, None]:
+    wdir = source if source else Path(tempfile.mkdtemp())
+    wdir.mkdir(parents=True, exist_ok=True)
+    try:
+        yield wdir
+    finally:
+        if not source:
+            shutil.rmtree(wdir, ignore_errors=True)
+
+
+@contextlib.contextmanager
+def backups() -> Generator[Callable[[Path | str], tuple[Path, Path]], None, None]:
+    pathlist: list[Path] = []
+
+    def save(path: Path | str) -> tuple[Path, Path]:
+        nonlocal pathlist
+        original = Path(path).expanduser().absolute()
+        backup = original.parent / f"{original.name}.bak"
+        if backup.exists():
+            raise RuntimeError("backup file present", backup)
+        shutil.copy(original, backup)
+        pathlist.append(backup)
+        return original, backup
+
+    try:
+        yield save
+    finally:
+        for backup in pathlist:
+            original = backup.with_suffix("")
+            original.unlink()
+            shutil.move(backup, original)

acbox/git.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import dataclasses as dc
+from pathlib import Path
+
+from .runner import Paths, Runner
+
+
+@dc.dataclass
+class Git:
+    workdir: Path
+    runc: Runner
+
+    @classmethod
+    def new(cls, workdir: Path, verbose: bool) -> Git:
+        workdir = workdir.expanduser().absolute()
+        return cls(workdir, runc=Runner(verbose=verbose, exe=["git", "--git-dir", f"{workdir}/.git"]))
+
+    # @classmethod
+    # def clone(cls, url: str, workdir: Path, args: Paths | None = None, verbose: bool = False) -> Git:
+    #     runc = Runner(verbose=True)
+    #     runc(["git", "clone", *(args or []), url, workdir])
+    #     return cls.new(workdir, verbose)
+
+    def __call__(self, args: Paths) -> str:
+        out = self.runc(args, capture=True) or ""
+        return (out.decode("utf-8") if isinstance(out, bytes) else out).strip()
+
+    def branch(self, name: str = "HEAD") -> str:
+        return self(["rev-parse", "--abbrev-ref", name])
+
+    def commits_on_branch(self, main: str = "origin/main"):
+        changes = self(["reflog", "show", "--no-abbrev", self.branch()])
+        return len([n for n in changes.split("\n") if n.strip()])
+        # parent = self(["merge-base", self.branch(), main]).strip()
+        # return int(self(["rev-list", "--count", f"{parent}..{self.branch()}"]))

acbox/loader.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import dataclasses as dc
+import logging
+from pathlib import Path
+from typing import Any, Literal, Sequence
+
+logger = logging.getLogger(__name__)
+
+Paths = str | Path | Sequence[str | Path]
+
+
+def makepaths(args: Paths) -> list[Path]:
+    if isinstance(args, (str, Path)):
+        return [Path(args)]
+    return [Path(a) for a in args]
+
+
+@dc.dataclass
+class LoaderBase:
+    paths: list[Path] | None = None
+
+    def __post_init__(self):
+        self.paths = [Path(p).expanduser() for p in (self.paths or [])]
+
+    def lookup(self, name: Path | str) -> Path | None:
+        for item in self.paths or [Path.cwd()]:
+            if (found := (item / name)).exists():
+                return found
+        return None
+
+    def load(self, name: Path | str, mode: Literal["auto", "binary", "raw", "text"] = "auto") -> Any:
+        if not (path := self.lookup(name)):
+            raise FileNotFoundError(2, "cannot lookup name", name)
+
+        if mode in {"binary", "raw"}:
+            return path.read_bytes()
+        elif mode == "text":
+            return path.read_text()
+
+        kind = path.suffix
+        if kind.upper() in {".JSON"}:
+            from json import loads
+
+            return loads(self.load(path.absolute(), "text"))
+        elif kind.upper() in {".YAML", ".YML"}:
+            from yaml import safe_load
+
+            return safe_load(self.load(path.absolute(), "text"))
+        else:
+            raise TypeError(f"cannot find type ({kind}) for {path}")
+        return None

acbox/maincli.py

@@ -0,0 +1,8 @@
+import click
+import rich
+
+
+def main():
+    print("Hi! from", __file__)
+    print("Got", rich)
+    print("Got", click)

acbox/packer.py

@@ -0,0 +1,25 @@
+# from https://packaging.python.org/en/latest/specifications/inline-script-metadata/#inline-script-metadata
+import re
+from pathlib import Path
+
+import tomllib
+
+REGEX = r"(?m)^# /// (?P<type>[a-zA-Z0-9-]+)$\s(?P<content>(^#(| .*)$\s)+)^# ///$"
+
+
+def read_header(path: Path | str) -> dict | None:
+    text = path if isinstance(path, str) else path.read_text()
+
+    name = "script"
+    matches = list(filter(lambda m: m.group("type") == name, re.finditer(REGEX, text)))
+    if len(matches) > 1:
+        raise ValueError(f"Multiple {name} blocks found")
+    elif len(matches) == 1:
+        content = "".join(line[2:] if line.startswith("# ") else line[1:] for line in matches[0].group("content").splitlines(keepends=True))
+        return tomllib.loads(content)
+    else:
+        return None
+
+
+if __name__ == "__main__":
+    print(read_header(Path("support/builder.py")))

acbox/run1.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import dataclasses as dc
+import logging
+import os
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import BinaryIO, Literal, Sequence
+
+COLORS = {
+    "blue": "\033[94m",
+    "green": "\033[92m",
+    "red": "\033[91m",
+    "clear": "\033[0m",
+}
+
+logger = logging.getLogger(__name__)
+
+
+class RunnerError(Exception):
+    pass
+
+
+@dc.dataclass
+class BaseFilter:
+    def __call__(self, stream: BinaryIO) -> None:
+        for line in iter(stream.readline, b""):
+            pass
+
+
+OMode = Literal["capture", "null", "display", "capture+display"] | BaseFilter
+EMode = Literal["null", "display"] | BaseFilter
+Paths = str | Path | Sequence[str | Path]
+
+
+@dc.dataclass
+class CaptureFilter(BaseFilter):
+    encode: str | None = "utf-8"
+    result: str | bytes | None = None
+
+    def __call__(self, stream: BinaryIO) -> None:
+        result = []
+        for line in iter(stream.readline, b""):
+            result.append(line[:-1])
+        stream.close()
+        if self.encode:
+            self.result = b"\n".join(result).decode(self.encode)
+        else:
+            self.result = b"\n".join(result)
+
+
+@dc.dataclass
+class DisplayFilter(BaseFilter):
+    color: str | None
+    pre: str = "   | "
+    clear: str = COLORS["clear"]
+    capture: bool = False
+    encode: str | None = "utf-8"
+    result: str | bytes | None = None
+
+    def __call__(self, stream: BinaryIO) -> None:
+        result = []
+        for rawline in iter(stream.readline, b""):
+            if self.capture:
+                result.append(rawline[:-1])
+            line = rawline.decode("utf-8")
+            if line.strip().startswith("Warning:"):
+                line = line.replace("Warning:", f"{COLORS['red']}Warning:{self.clear}{self.color}")
+            print(
+                f"{self.pre}{self.color}{line.rstrip()}{self.clear}",
+                flush=True,
+                file=sys.stderr,
+            )
+        stream.close()
+        if self.capture:
+            self.result = b"\n".join(result).decode(self.encode) if self.encode else b"\n".join(result)
+
+
+def mkpaths(args: Paths) -> list[str]:
+    return [str(args)] if isinstance(args, (str, Path)) else [str(a) for a in args]
+
+
+def runc(
+    args: Paths,
+    stdout: OMode = "display",
+    stderr: EMode = "display",
+    overrides: dict[str, str] | None = None,
+    **kwargs,
+) -> str | bytes | None:
+    kwargs["env"] = kwargs.pop("env") if "env" in kwargs else os.environ.copy()
+    kwargs["env"].update(overrides or {})
+    kwargs["cwd"] = (str(v) if (v := kwargs.pop("cwd")) else None) if "cwd" in kwargs else None
+
+    with subprocess.Popen(mkpaths(args), stderr=subprocess.PIPE, stdout=subprocess.PIPE, **kwargs) as process:
+        if stdout == "capture":
+            ofiltermap: BaseFilter = CaptureFilter()
+        elif stdout == "null":
+            ofiltermap = BaseFilter()
+        elif stdout == "display":
+            ofiltermap = DisplayFilter(COLORS["blue"], "   | ")
+        elif stdout == "capture+display":
+            ofiltermap = DisplayFilter(COLORS["blue"], "   | ", capture=True)
+        elif isinstance(stdout, BaseFilter):
+            ofiltermap = stdout
+        else:
+            raise RuntimeError(f"unsupported type in {stdout=}")
+        othread = threading.Thread(target=ofiltermap, args=(process.stdout,), daemon=True)
+
+        if stderr == "null":
+            efiltermap: BaseFilter = BaseFilter()
+        elif stderr == "display":
+            efiltermap = DisplayFilter(COLORS["green"], "   | ")
+        elif isinstance(stderr, BaseFilter):
+            efiltermap = stderr
+        else:
+            raise RuntimeError(f"unsupported type in {stderr=}")
+        ethread = threading.Thread(
+            target=efiltermap,
+            args=(process.stderr,),
+            daemon=True,
+        )
+        othread.start()
+        ethread.start()
+        while process.poll() is not None:
+            time.sleep(0.05)
+        othread.join()
+        ethread.join()
+
+    if process.returncode:
+        envs = " ".join(f'{k}="{v}"' for k, v in (overrides or {}).items())
+        cmdline = subprocess.list2cmdline(mkpaths(args))
+        raise RunnerError(f"failed to execute in cwd={kwargs['cwd']} ==> {envs} {cmdline}")
+    return ofiltermap.result if hasattr(ofiltermap, "result") else None
+
+
+if __name__ == "__main__":
+    x = runc(["ls", "-l"], "capture", "display")
+    print(x)

acbox/runner.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import contextlib
+import dataclasses as dc
+import logging
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Generator
+
+from .run1 import EMode, OMode, Paths, mkpaths, runc
+
+logger = logging.getLogger(__name__)
+
+
+@dc.dataclass
+class Runner:
+    verbose: bool
+    dryrun: bool | None = None
+    exe: Paths | None = None
+    cwd: Path | None = None
+    overrides: dict[str, str] | None = None
+    log: logging.Logger | None = None
+
+    @staticmethod
+    @contextlib.contextmanager
+    def tmpdir(source: Path | None = None) -> Generator[Path, None, None]:
+        wdir = source if source else Path(tempfile.mkdtemp())
+        wdir.mkdir(parents=True, exist_ok=True)
+        try:
+            yield wdir
+        finally:
+            if not source:
+                shutil.rmtree(wdir, ignore_errors=True)
+
+    def __call__(
+        self,
+        args: Paths,
+        capture: bool = False,
+        verbose: bool | None = None,
+        dryrun: bool | None = None,
+        cwd: Path | str | bool | None = None,
+        overrides: dict[str, str] | None = None,
+        log: logging.Logger | None = None,
+    ) -> str | bytes | None:
+        # capture/verbose are interacting to control how the stdout is handled
+        check = (capture, self.verbose if verbose is None else verbose)
+        stdout: OMode = "null"
+        if check == (True, False):
+            stdout = "capture"
+        elif check == (True, True):
+            stdout = "capture+display"
+        elif check == (False, True):
+            stdout = "display"
+        elif check == (False, False):
+            stdout = "null"
+        else:
+            raise RuntimeError(f"un-handled value {check=}")
+        stderr: EMode = "display" if self.verbose else "null"
+
+        dryrun = self.dryrun if dryrun is None else dryrun
+        if "capture" in stdout and dryrun:
+            raise RuntimeError("cannot dryrun and caputure")
+
+        cwd = cwd or self.cwd
+        overrides = overrides or self.overrides
+        log = log or self.log or logger
+
+        fullargs = mkpaths(args)
+        if self.exe:
+            fullargs = [*mkpaths(self.exe), *fullargs]
+
+        log.debug("%srun: %s", "(dry-run) " if dryrun else "", " ".join(fullargs))
+        if dryrun:
+            return None
+        return runc(fullargs, stdout=stdout, stderr=stderr, overrides=overrides, cwd=cwd)
+
+
+if __name__ == "__main__":
+    runner = Runner(True)
+    y = runner(["ls", "-l"], capture=False, verbose=True)
+    print(y)
+
+    # --git-dir=$dest/.git --work-tree $dest
+    runner = Runner(True, exe=["git", "--git-dir", "{workdir}/.git"])
+    runner("status")

acbox/ureporting.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import dataclasses as dc
+import functools
+import itertools
+from enum import IntEnum, auto
+
+
+class S(IntEnum):
+    OK = auto()
+    FAILED = auto()
+    WARN = auto()
+    NOSTATUS = auto()
+
+
+@dc.dataclass
+class Record:
+    status: S
+    group: str  # kry to group the record under
+    key: str
+    report: str = ""
+
+
+@dc.dataclass
+class ColorText:
+    message: str
+    status: S
+
+    def __format__(self, width):
+        reset = "\033[0m"
+        message = self.message
+        msg = {
+            S.OK: f"\033[42m{message}{reset}",
+            S.FAILED: f"\033[41m{message}{reset}",
+            S.WARN: f"\033[43;30m{message}{reset}",
+            S.NOSTATUS: f"{message}",
+        }[self.status]
+        return msg + " " * (int(width or len(self.message)) - len(self.message))
+
+
+def indent(txt: str, pre: str, first: str | None = None) -> str:
+    return (pre if first is None else first) + txt.replace("\n", "\n" + pre)
+
+
+def dumps(report: list[Record], sorted_groups: bool = True) -> str:
+    def resolve(states):
+        if S.FAILED in states:
+            status = S.FAILED
+        elif S.WARN in states:
+            status = S.WARN
+        elif S.OK in states:
+            status = S.OK
+        else:
+            status = S.NOSTATUS
+        return status
+
+    def color(status: S, fall=".") -> ColorText:
+        message = {
+            S.OK: "+",
+            S.FAILED: "x",
+            S.WARN: "!",
+            S.NOSTATUS: ".",
+        }[status]
+        return ColorText(message, status)
+
+    def colorize(message: str, status: S) -> ColorText:
+        return ColorText(message, status)
+
+    pre = " " * 3
+    result = []
+
+    width = max(len(record.key) for record in report)
+
+    def bygroup(fn, items):
+        return fn(items, key=lambda r: r.group)
+
+    def nosorted(items, key):
+        return items
+
+    for group, itrecords in bygroup(itertools.groupby, bygroup(nosorted, report)):
+        records = list(itrecords)
+        status = resolve(set(record.status for record in records))
+        result.append(f"{color(status)} {group}")
+        start = " " * 4 + " " * width
+        for record in records:
+            if record.group != group:
+                continue
+            if isinstance(record.report, str):
+                message = record.report
+            elif isinstance(record.report, list):
+                message = indent("\n".join(record.report), pre=start).lstrip()
+            else:
+                raise RuntimeError("unable to handle type", type(record.report))
+            result.append(f"{pre}{colorize(record.key, record.status):{width}} {message}")
+
+    return "\n".join(result)
+
+
+def print_report(report: list[Record], sorted_groups: bool = True) -> int:
+    errors = sum(r.status == S.FAILED for r in report)
+    warnings = sum(r.status == S.WARN for r in report)
+    print(dumps(report, sorted_groups))
+    if errors:
+        t = ColorText("FAILED", S.FAILED)
+        print(f"{t} found {errors} errors, and {warnings} warnings")
+    elif warnings:
+        t = ColorText("WARN", S.WARN)
+        print(f"{t} found {warnings} warnings")
+    else:
+        t = ColorText("OK", S.OK)
+        print(f"{t}")
+    return min(int(sum(r.status == S.FAILED for r in report)), 1)
+
+
+def check(fn):
+    @functools.wraps(fn)
+    def _fn(*args, **kwargs):
+        result = fn(*args, **kwargs)
+        return result if isinstance(result, list) else [result]
+
+    return _fn
+
+
+if __name__ == "__main__":
+    report = []
+    report.append(Record(S.NOSTATUS, "group-0", "key-0", "message"))
+    report.append(Record(S.OK, "group-0", "key-2", "message-2"))
+    report.append(Record(S.FAILED, "group-0", "key-3", "message-3"))
+    report.append(Record(S.WARN, "group-0", "key-4", "message-4"))
+    report.append(Record(S.NOSTATUS, "group-1", "key-0", "message"))
+    report.append(Record(S.OK, "group-1", "key-2", "message-2"))
+    report.append(Record(S.OK, "group-1", "key-3", "message-3"))
+    report.append(Record(S.WARN, "group-1", "key-4", "message-4"))
+    ret = print_report(report)
+    print(f"Final status -> {ret}")

acbox/utils.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from importlib.util import module_from_spec, spec_from_file_location
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+from urllib.parse import urlparse
+from urllib.request import urlopen
+
+
+def loadmod(path: Path | str) -> ModuleType:
+    if urlparse(str(path)).scheme in {"http", "https"}:
+        urltxt = str(urlopen(str(path)).read(), encoding="utf-8")
+        mod = ModuleType(str(path).rpartition("/")[2])
+        exec(urltxt, mod.__dict__)
+        return mod
+
+    spec = spec_from_file_location(Path(path).name, Path(path))
+    module = module_from_spec(spec)  # type: ignore
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+
+
+class NA:
+    pass
+
+
+def diffdict(
+    left: dict[str, Any], right: dict[str, Any], exclude: list[str] | None = None, na: str | type[NA] = NA
+) -> dict[str, tuple[Any, Any]]:
+    result = {}
+    for key in sorted(set(left) | set(right)):
+        if exclude and key in exclude:
+            continue
+        if key not in left:
+            result[key] = (na, right[key])
+        elif key not in right:
+            result[key] = (left[key], na)
+        elif left[key] != right[key]:
+            result[key] = (left[key], right[key])
+    return result

acbox-0.0.0.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: acbox
+Version: 0.0.0
+Summary: Collection of small tools
+Author-email: Antonio Cavallo <a.cavallo@cavallinux.eu>
+License: MIT
+Project-URL: Source, https://github.com/cav71/acbox
+Project-URL: Issues, https://github.com/cav71/acbox
+Project-URL: Documentation, https://github.com/cav71/acbox
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click
+Requires-Dist: filetype
+Requires-Dist: rich
+Requires-Dist: pyyaml
+Provides-Extra: extra
+
+## ACBox my little toolbox
+
+[![PyPI version](https://img.shields.io/pypi/v/acbox.svg?color=blue)](https://pypi.org/project/acbox)
+[![Python versions](https://img.shields.io/pypi/pyversions/acbox.svg)](https://pypi.org/project/acbox)
+[![Codecov (main)](https://img.shields.io/codecov/c/github/cav71/acbox/main)](https://app.codecov.io/gh/cav71/acbox/tree/main)
+[![Build](https://github.com/cav71/acbox/actions/workflows/main.yml/badge.svg)](https://github.com/cav71/acbox/actions/workflows/main.yml)
+
+
+[![License - MIT](https://img.shields.io/badge/license-MIT-9400d3.svg)](https://spdx.org/licenses/)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/acbox)
+[![Mypy](https://img.shields.io/badge/types-Mypy-blue.svg)](https://mypy-lang.org/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+
+
+### Development
+
+```
+python3.13 -m venv .venv
+source .venv/bin/activate
+```
+
+```
+python -m pip install --upgrade pip
+python -m pip install --group dev
+pre-commit install
+```
+
+Ready.

acbox-0.0.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+acbox/__init__.py,sha256=kM9hNFcHh_nzPpKmTIZ2_ZCZpISWTcacn_fS1bi9gWo,42
+acbox/cli2.py,sha256=b5p6gXa_16Z1d6QPT2bo0QFPWS5eVjhxbrnEkmibA_g,1778
+acbox/dictionaries.py,sha256=SJdRK58LTw1Ysg69R_N6HSCJNNmfIQmsUfMp5UoPmWA,1067
+acbox/fileops.py,sha256=1zDI4pj069QWxwGG_Bxt5JD-EnFbz-VtNRZ2QdUDp5A,1799
+acbox/git.py,sha256=wDtxBiCS1re9rKTBSlnPtd5me_iitnm4KEV0uc_EQh4,1309
+acbox/loader.py,sha256=t9QWOe0JnjO--e2HDJlie6Xdtc4fqn1h-iMEz5kYlcI,1518
+acbox/maincli.py,sha256=Qnkfjoad_0bKECSZxoZALLECezGNDuZjr0kepqoa4hg,118
+acbox/packer.py,sha256=VaqPBhIsOIDQsmFRTMiPCMyvr6qIvLyuZLnHa5DLyUI,867
+acbox/run1.py,sha256=R_09NRzNHNwU1rf3AiZinpTGKkxqWxIPbVMVPEXCKi0,4404
+acbox/runner.py,sha256=p5SSctPiNvONy5hZQvdpJf92CC0hcuecXvfi-d-OIvc,2651
+acbox/ureporting.py,sha256=UdzFf8HU6IgNYeqHiShPs9J_lMMsOiLtpPfi-99iaNw,4075
+acbox/utils.py,sha256=_i9q0Ft72d5Aud1eCpQAKINP4t_JTKFQyk5cs3yQ6F0,1266
+acbox/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+acbox/cli/script.py,sha256=JQOfZvXzgzwoftIMFRTtuBCtCFatKk-Ly_L6VfgnqPg,4044
+acbox/cli/shared.py,sha256=tVdExf5XaOhcTLic17urbaWU0I9D2dA34_5uFAAXZbs,806
+acbox/cli/flags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+acbox/cli/flags/base.py,sha256=fG-fTFkA-XXq3XLOdmIifgGM4pUNRJ_aEZpjaMWd8Bc,1158
+acbox/cli/flags/logging.py,sha256=04KAjZ6KLb8bMfy4R0-f0vRgC2K1SuUouBwtO6_wRR8,1238
+acbox/cli/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+acbox/cli/parsers/base.py,sha256=xKLUVfwCkuLBdJkYl5IyxyjXSw-E4ILy_wf5zKu-OtY,2398
+acbox/cli/parsers/parser.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+acbox/cli/parsers/simple.py,sha256=DZX1GIUf-coto7GVhLNb8WHHmkqNe3o7Kn5FDeFWnVM,1275
+acbox-0.0.0.dist-info/METADATA,sha256=v3fjDIoSfJ_A5BI9MoRKRhK2QKeSFjI6EkaoPI80f8Y,1865
+acbox-0.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+acbox-0.0.0.dist-info/entry_points.txt,sha256=e_OU4H7NG6VzjUzF55JOEV-4-hhIr-uSDPwapxHLywI,45
+acbox-0.0.0.dist-info/top_level.txt,sha256=ONP4w-2ISebZn3jvJcSrlPOj2pcXMKl93FwtRk9AJYs,6
+acbox-0.0.0.dist-info/RECORD,,

acbox-0.0.0.dist-info/WHEEL

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

acbox-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+acbox = acbox.maincli:main

acbox-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+acbox