alltoml 0.0.0__tar.gz

alltoml-0.0.0/LICENSE

@@ -0,0 +1,16 @@
+Copyright (c) 2025 Erik Soma
+
+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.

alltoml-0.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.3
+Name: alltoml
+Version: 0.0.0
+Summary: TOML configuration everywhere
+Author: Erik Soma
+Author-email: stillusingirc@gmail.com
+Requires-Python: >=3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: deep-chainmap (>=0.1.3,<0.2.0)
+Requires-Dist: platformdirs (>=4.4.0,<5.0.0)

alltoml-0.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "alltoml"
+requires-python = ">=3.12"
+version = "0.0.0"
+description = "TOML configuration everywhere"
+authors = [
+    {name="Erik Soma",  email="stillusingirc@gmail.com"}
+]
+
+[tool.poetry.dependencies]
+python = "^3.12"
+platformdirs = "^4.4.0"
+deep-chainmap = "^0.1.3"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "7.4.3"
+pytest-cov = "4.1.0"
+
+[build-system]
+requires = ["poetry-core", "setuptools==69.0.2"]
+build-backend = "poetry.core.masonry.api"
+
+[virtualenvs]
+in-project = true
+
+[tool.pyright]
+venvPath = "."
+venv = ".venv"

alltoml-0.0.0/src/alltoml/__init__.py

@@ -0,0 +1,7 @@
+__all__ = ["load", "load_from_argv", "load_from_environ", "load_from_file"]
+
+
+from ._argv import load_from_argv
+from ._environ import load_from_environ
+from ._file import load_from_file
+from ._load import load

alltoml-0.0.0/src/alltoml/_argv.py

@@ -0,0 +1,41 @@
+__all__ = ["load_from_argv"]
+
+import sys
+from itertools import islice
+from typing import Any
+from typing import Callable
+from typing import Iterable
+
+from ._parse import store_settings
+
+
+def load_from_argv(
+    argv: Iterable[str] | None = None,
+    *,
+    on_extra: Callable[[str], None] = lambda n: None,
+    on_failure: Callable[[str, str | None], None] = lambda n, v: None,
+    prefix: str = "--config.",
+) -> dict[str, Any]:
+    settings: dict[str, Any] = {}
+
+    if argv is None:
+        argv = sys.argv[1:]
+
+    argv_i = iter(argv)
+    while True:
+        try:
+            arg = next(argv_i)
+        except StopIteration:
+            break
+        if arg.startswith(prefix):
+            raw_key = arg[len(prefix) :]
+            try:
+                raw_value = next(argv_i)
+            except StopIteration:
+                on_failure(arg, None)
+                continue
+            store_settings(settings, raw_key, raw_value, lambda: on_failure(arg, raw_value))
+        else:
+            on_extra(arg)
+
+    return settings

alltoml-0.0.0/src/alltoml/_environ.py

@@ -0,0 +1,37 @@
+__all__ = ["load_from_environ"]
+
+import os
+from itertools import islice
+from os import environ
+from re import sub as re_sub
+from types import NoneType
+from types import UnionType
+from typing import Any
+from typing import Callable
+from typing import Final
+from typing import Mapping
+from typing import Sequence
+from typing import Union
+from typing import get_args as get_typing_args
+from typing import get_origin as get_typing_origin
+
+from ._parse import store_settings
+
+
+def load_from_environ(
+    environ: Mapping[str, str] | None = None,
+    *,
+    prefix: str = "CONFIG.",
+    on_failure: Callable[[str, str], None] = lambda n, v: None,
+) -> dict[str, Any]:
+    settings: dict[str, Any] = {}
+
+    if environ is None:
+        environ = os.environ
+
+    for key, raw_value in environ.items():
+        if key.startswith(prefix):
+            raw_key = key[len(prefix) :]
+            store_settings(settings, raw_key, raw_value, lambda: on_failure(key, raw_value))
+
+    return settings

alltoml-0.0.0/src/alltoml/_file.py

@@ -0,0 +1,21 @@
+__all__ = ["load_from_file"]
+
+import tomllib
+from pathlib import Path
+from typing import Any
+from typing import Callable
+
+
+def load_from_file(
+    base_path: Path,
+    *,
+    name: Path = Path("config.toml"),
+    on_failure: Callable[[Path], None] = lambda p: None,
+) -> dict[str, Any]:
+    file_path = base_path / name
+    try:
+        with open(file_path, "rb") as file:
+            return tomllib.load(file)
+    except (OSError, tomllib.TOMLDecodeError):
+        on_failure(file_path)
+    return {}

alltoml-0.0.0/src/alltoml/_load.py

@@ -0,0 +1,100 @@
+__all__ = ["load"]
+
+import os
+import re
+import sys
+from logging import getLogger
+from pathlib import Path
+from typing import Any
+from typing import Mapping
+
+from deep_chainmap import DeepChainMap
+from platformdirs import user_data_dir
+
+from ._argv import load_from_argv
+from ._environ import load_from_environ
+from ._file import load_from_file
+
+_log = getLogger("alltoml")
+
+
+def load(
+    application_name: str,
+    application_author: str,
+    *,
+    default_settings: Mapping[str, Any] | None = None,
+) -> Mapping[str, Any]:
+    if default_settings is None:
+        default_settings = {}
+    else:
+        default_settings = {**default_settings}
+    assert isinstance(default_settings, dict)
+
+    if application_name.strip():
+        base_env_prefix = re.sub(r"[\-\s_]+", "_", application_name.strip()).upper()
+        environ_prefix = f"{base_env_prefix}_CONFIG."
+        file_environ_key = f"{base_env_prefix}_CONFIG"
+    else:
+        environ_prefix = "CONFIG."
+        file_environ_key = "CONFIG"
+
+    file_path: Path | None = None
+    # try to find the file path in the environ
+    try:
+        file_path = Path(os.environ[file_environ_key])
+    except KeyError:
+        pass
+    # try to find the file path in the argv, this will take precedence of the one found in environ
+    #
+    # we remove the arguments from the argv list that load_from_argv will scan so that we don't get
+    # errors about extra arguments
+    argv = sys.argv[1:]
+    for i in range(len(argv)):
+        if argv[i] == "--config":
+            try:
+                file_path = Path(argv[i + 1])
+            except IndexError:
+                _log.error("argument %r has no value", "--config")
+                sys.exit(1)
+            argv = [*argv[:i], *argv[i + 2 :]]
+            break
+    # try to load file settings from the path specified by either the environ or argv
+    if file_path is None:
+        file_settings = {}
+    else:
+        file_base_path = file_path.parent
+        file_name = Path(file_path.name)
+        file_settings = load_from_file(file_base_path, name=file_name, on_failure=_file_on_failure)
+
+    user_file_settings = load_from_file(
+        Path(user_data_dir(application_name, application_author)), on_failure=_file_on_failure
+    )
+    cwd_file_settings = load_from_file(Path("."), on_failure=_file_on_failure)
+    environ_settings = load_from_environ(prefix=environ_prefix, on_failure=_environ_on_failure)
+    argv_settings = load_from_argv(argv, on_extra=_argv_on_extra, on_failure=_argv_on_failure)
+
+    return DeepChainMap(
+        argv_settings,
+        file_settings,
+        cwd_file_settings,
+        user_file_settings,
+        environ_settings,
+        default_settings,
+    )
+
+
+def _environ_on_failure(key: str, value: str) -> None:
+    _log.warning("ignoring invalid environment variable: %r", key)
+
+
+def _file_on_failure(file_path: Path) -> None:
+    _log.warning("ignoring invalid config file: %r", str(file_path))
+
+
+def _argv_on_extra(argument: str) -> None:
+    _log.error("argument %r was unexpected", argument)
+    sys.exit(1)
+
+
+def _argv_on_failure(argument: str, value: str | None) -> None:
+    _log.warning("ignoring invalid argument: %r", argument)

alltoml-0.0.0/src/alltoml/_parse.py

@@ -0,0 +1,60 @@
+__all__ = ["store_settings"]
+
+from itertools import islice
+from tomllib import TOMLDecodeError
+from tomllib import loads as toml_loads
+from typing import Any
+from typing import Callable
+from typing import Generator
+
+
+def store_settings(
+    settings: dict[str, Any], raw_key: str, raw_value: str, fail: Callable[[], None]
+) -> None:
+    try:
+        key = tuple(_convert_key(raw_key))
+        value = _convert_value(raw_value)
+    except ValueError:
+        fail()
+        return
+
+    target = settings
+    for name in islice(key, len(key) - 1):
+        try:
+            target = target[name]
+            if not isinstance(target, dict):
+                fail()
+                return
+        except KeyError:
+            target[name] = target = {}
+    if key[-1] in target:
+        fail()
+        return
+    target[key[-1]] = value
+
+
+def _convert_value(raw_value: str) -> Any:
+    try:
+        result = toml_loads(f"value = {raw_value}")
+    except TOMLDecodeError:
+        raise ValueError(raw_value)
+    if set(result.keys()) != {"value"}:
+        raise ValueError(raw_value)
+    return result["value"]
+
+
+def _convert_key(raw_key: str) -> Generator[str, None, None]:
+    try:
+        result = toml_loads(f"{raw_key} = 0")
+    except TOMLDecodeError:
+        raise ValueError(raw_key)
+    while True:
+        if len(result) > 1:
+            raise ValueError(raw_key)
+        for key, value in result.items():
+            yield key
+            result = value
+        if not isinstance(result, dict):
+            if result == 0:
+                return
+            raise ValueError(raw_key)