acbox 0.0.0b1__tar.gz

acbox-0.0.0b1/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: acbox
+Version: 0.0.0b1
+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.9
+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.9
+Description-Content-Type: text/markdown
+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.0b1/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.0b1/pyproject.toml

@@ -0,0 +1,107 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "acbox"
+version = "0.0.0b1"
+description = "Collection of small tools"
+readme = "README.md"
+license = { text = "MIT" }
+
+requires-python = ">= 3.9"
+
+authors = [
+  { name = "Antonio Cavallo", email = "a.cavallo@cavallinux.eu" },
+]
+
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+
+dependencies = []
+
+[dependency-groups]
+dev = [
+    "build",
+    "lxml",
+    "mypy",
+    "pre-commit",
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-html",
+    "ruff",
+    "types-python-dateutil",
+]
+
+
+[project.optional-dependencies]
+extra = []
+
+[project.urls]
+Source = "https://github.com/cav71/acbox"
+Issues = "https://github.com/cav71/acbox"
+Documentation = "https://github.com/cav71/acbox"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+namespaces = true
+
+[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/\\.*",
+]
+
+[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.0b1/setup.cfg

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

acbox-0.0.0b1/src/acbox/cli/shared.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import argparse
+import inspect
+import sys
+import types
+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
+
+
+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")
+
+
+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 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)
+
+
+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.0b1/src/acbox/fileops.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+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]

acbox-0.0.0b1/src/acbox/utils.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from pathlib import Path
+from types import ModuleType
+
+
+def loadmod(path: Path | str) -> ModuleType:
+    from importlib import util
+    from types import ModuleType
+    from urllib.parse import urlparse
+    from urllib.request import urlopen
+
+    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 = util.spec_from_file_location(Path(path).name, Path(path))
+    module = util.module_from_spec(spec)  # type: ignore
+    spec.loader.exec_module(module)  # type: ignore
+    return module

acbox-0.0.0b1/src/acbox.egg-info/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: acbox
+Version: 0.0.0b1
+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.9
+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.9
+Description-Content-Type: text/markdown
+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.0b1/src/acbox.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/acbox/fileops.py
+src/acbox/utils.py
+src/acbox.egg-info/PKG-INFO
+src/acbox.egg-info/SOURCES.txt
+src/acbox.egg-info/dependency_links.txt
+src/acbox.egg-info/requires.txt
+src/acbox.egg-info/top_level.txt
+src/acbox/cli/__init__.py
+src/acbox/cli/shared.py
+tests/test_cli_shared.py
+tests/test_fileops.py
+tests/test_internals.py
+tests/test_utils.py

acbox-0.0.0b1/src/acbox.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

acbox-0.0.0b1/src/acbox.egg-info/requires.txt

@@ -0,0 +1,2 @@
+
+[extra]

acbox-0.0.0b1/src/acbox.egg-info/top_level.txt

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

acbox-0.0.0b1/tests/test_cli_shared.py

@@ -0,0 +1,174 @@
+import argparse
+
+import pytest
+
+from acbox.cli import shared
+
+
+class Flag(shared.ArgumentTypeBase):
+    def __init__(self, only_odd=False):
+        self.only_odd = only_odd
+        super().__init__()
+
+    def validate(self, txt):
+        value = int(txt)
+        if self.only_odd:
+            if (value % 2) == 0:
+                raise argparse.ArgumentTypeError(f"non odd value '{txt}'")
+        return value
+
+
+def test_check_default_constructor():
+    """verifies the class constructor requires no arguments"""
+
+    class A:
+        def __init__(self, value):
+            pass
+
+    pytest.raises(RuntimeError, shared.check_default_constructor, A)
+
+    class A:
+        def __init__(self, value=1):
+            pass
+
+    assert shared.check_default_constructor(A) is None
+
+
+def test_add_argument():
+    """test all failures mode for add_argument default"""
+    p = shared.ArgumentParserBase([], exit_on_error=False)
+
+    with pytest.raises(ValueError) as e:
+        p.add_argument("--flag", type=Flag, default="yyy")
+    assert e.value.args[0] == "invalid literal for int() with base 10: 'yyy'"
+
+    with pytest.raises(RuntimeError) as e:
+        p.add_argument("--flag", type=Flag(only_odd=True), default="124")
+    assert e.value.args[0] == "cannot use value='124' as default: non odd value '124'"
+
+    with pytest.raises(RuntimeError) as e:
+        p.add_argument("--flag", type=Flag(only_odd=True), default=124)
+    assert e.value.args[0] == "cannot use value=124 as default: non odd value '124'"
+
+    with pytest.raises(RuntimeError) as e:
+        p.add_argument("--flag", type=Flag(only_odd=True), default=126)
+    assert e.value.args[0] == "cannot use value=126 as default: non odd value '126'"
+
+    with pytest.raises(RuntimeError) as e:
+        p.add_argument("--flag", type=Flag(only_odd=True), default="126")
+    assert e.value.args[0] == "cannot use value='126' as default: non odd value '126'"
+
+    p.add_argument("--flag", type=Flag)
+    assert len(action := [a for a in p._actions if isinstance(a.type, shared.ArgumentTypeBase)]) == 1
+    assert action[0].default.default is shared.ArgumentTypeBase._NA
+
+    p.add_argument("--flag1", type=Flag, default="124")
+    assert len(actions := [a for a in p._actions if isinstance(a.type, shared.ArgumentTypeBase)]) == 2
+    assert actions[1].default.default == 124
+
+    p.add_argument("--flag2", type=Flag, default=126)
+    assert len(actions := [a for a in p._actions if isinstance(a.type, shared.ArgumentTypeBase)]) == 3
+    assert actions[2].default.default == 126
+
+
+def test_special_flag_no_restriction():
+    """parse arguments with no default and no constrain on Flag"""
+    p = shared.ArgumentParserBase([], exit_on_error=False)
+    p.add_argument("--flag", type=Flag)
+
+    a = p.parse_args([])
+    assert a.flag is None
+
+    a = p.parse_args(
+        [
+            "--flag",
+            "123",
+        ]
+    )
+    assert a.flag == 123
+
+    a = p.parse_args(
+        [
+            "--flag",
+            "124",
+        ]
+    )
+    assert a.flag == 124
+
+    with pytest.raises(argparse.ArgumentError) as e:
+        p.parse_args(["--flag", "boo"])
+    assert e.value.args[-1] == "invalid Flag value: 'boo'"
+
+    # same as above but with a default fallback
+    p = shared.ArgumentParserBase([], exit_on_error=False)
+    p.add_argument("--flag", type=Flag, default="42")
+
+    a = p.parse_args([])
+    assert a.flag == 42
+
+    a = p.parse_args(
+        [
+            "--flag",
+            "123",
+        ]
+    )
+    assert a.flag == 123
+
+    a = p.parse_args(
+        [
+            "--flag",
+            "124",
+        ]
+    )
+    assert a.flag == 124
+
+    with pytest.raises(argparse.ArgumentError) as e:
+        p.parse_args(["--flag", "boo"])
+    assert e.value.args[-1] == "invalid Flag value: 'boo'"
+
+
+def test_special_flag_with_restriction_no_default():
+    p = shared.ArgumentParserBase([], exit_on_error=False)
+    p.add_argument("--flag", type=Flag(only_odd=True))
+
+    a = p.parse_args([])
+    assert a.flag is None
+
+    a = p.parse_args(
+        [
+            "--flag",
+            "123",
+        ]
+    )
+    assert a.flag == 123
+
+    with pytest.raises(argparse.ArgumentError) as e:
+        p.parse_args(["--flag", "122"])
+    assert e.value.args[-1] == "non odd value '122'"
+
+    with pytest.raises(argparse.ArgumentError) as e:
+        p.parse_args(["--flag", "boo"])
+    assert e.value.args[-1] == "invalid Flag value: 'boo'"
+
+    # same as above but with a default fallback
+    p = shared.ArgumentParserBase([], exit_on_error=False)
+    p.add_argument("--flag", type=Flag(only_odd=True), default=43)
+
+    a = p.parse_args([])
+    assert a.flag == 43
+
+    a = p.parse_args(
+        [
+            "--flag",
+            "123",
+        ]
+    )
+    assert a.flag == 123
+
+    with pytest.raises(argparse.ArgumentError) as e:
+        p.parse_args(["--flag", "122"])
+    assert e.value.args[-1] == "non odd value '122'"
+
+    with pytest.raises(argparse.ArgumentError) as e:
+        p.parse_args(["--flag", "boo"])
+    assert e.value.args[-1] == "invalid Flag value: 'boo'"

acbox-0.0.0b1/tests/test_fileops.py

@@ -0,0 +1,18 @@
+import sys
+from pathlib import Path
+
+from acbox import fileops
+
+
+def test_which():
+    exe = "cmd" if sys.platform == "win32" else "sh"
+
+    path = fileops.which(exe)
+    assert path
+    assert isinstance(path, Path)
+
+    paths = fileops.which_n(exe)
+    assert isinstance(paths, list)
+    assert paths[0] == fileops.which(exe)
+
+    assert fileops.which_n("xwdwxEW") is None

acbox-0.0.0b1/tests/test_internals.py

@@ -0,0 +1,21 @@
+def test_script_lookup(resolver):
+    path = resolver.lookup("simple-script.py")
+    assert path
+    assert path.exists()
+
+
+def test_script_load(resolver):
+    data = resolver.load("simple-script.py", "text")
+    assert (
+        data
+        == """
+VALUE = 123
+
+
+def hello(msg):
+    print(f"Hi {msg}")
+""".lstrip()
+    )
+
+    mod = resolver.load("simple-script.py", "mod")
+    assert mod.VALUE, 123

acbox-0.0.0b1/tests/test_utils.py

@@ -0,0 +1,13 @@
+from acbox import utils
+
+
+def test_load_mod(resolver):
+    path = resolver.lookup("simple-script.py")
+
+    mod = utils.loadmod(path)
+    assert mod.VALUE, 123
+
+
+def test_load_remote():
+    mod = utils.loadmod("https://raw.githubusercontent.com/cav71/acbox/refs/heads/main/tests/test_utils.py")
+    assert hasattr(mod, "test_load_remote")