acbox 0.0.0b0__tar.gz

acbox-0.0.0b0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: acbox
+Version: 0.0.0b0
+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
+
+
+### 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.0b0/README.md

@@ -0,0 +1,17 @@
+## ACBox my little toolbox
+
+
+### 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.0b0/pyproject.toml

@@ -0,0 +1,116 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "acbox"
+version = "0.0.0b0"
+description = "Collection of small tools"
+readme = "README.md"
+license = { text = "MIT" }
+
+requires-python = ">= 3.10"
+
+authors = [
+  { name = "Antonio Cavallo", email = "a.cavallo@cavallinux.eu" },
+]
+
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+
+dependencies = [
+    "click",
+    "filetype",
+    "rich",
+    "pyyaml",
+]
+
+[dependency-groups]
+dev = [
+    "build",
+    "lxml",
+    "mypy",
+    "pre-commit",
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-html",
+    "ruff",
+    "types-python-dateutil",
+    "types-pyyaml"
+]
+
+
+[project.optional-dependencies]
+extra = []
+
+[project.urls]
+Source = "https://github.com/cav71/acbox"
+Issues = "https://github.com/cav71/acbox"
+Documentation = "https://github.com/cav71/acbox"
+
+[project.scripts]
+acbox = "acbox.maincli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+namespaces = false
+
+[tool.ruff]
+target-version = "py39"
+line-length = 140
+src = ["src/acbox"]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.ruff.lint]
+ignore = []
+select = ["F", "E", "W", "Q", "I001"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["acbox"]
+
+
+[tool.mypy]
+disallow_untyped_defs = false
+follow_imports = "normal"
+ignore_missing_imports = true
+pretty = true
+show_column_numbers = true
+show_error_codes = true
+warn_no_return = false
+warn_unused_ignores = true
+exclude = [
+    "docs/conf\\.py",
+    "^docs/\\.*",
+    "^build/\\.*",
+    "^support/\\.*",
+]
+
+[tool.coverage.run]
+branch = true
+
+[tool.coverage.paths]
+source = [
+  "src/",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]
+
+[tool.pytest.ini_options]
+markers = [
+    "manual: marks tests unsafe for auto-run (eg. better run them manually)",
+]
+asyncio_default_fixture_loop_scope = "function"

acbox-0.0.0b0/setup.cfg

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

acbox-0.0.0b0/src/acbox/__init__.py

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

acbox-0.0.0b0/src/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-0.0.0b0/src/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-0.0.0b0/src/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-0.0.0b0/src/acbox/cli/parsers/parser.py

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

acbox-0.0.0b0/src/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-0.0.0b0/src/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-0.0.0b0/src/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-0.0.0b0/src/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-0.0.0b0/src/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