somestuff-corestuff 0.1.0__tar.gz

somestuff_corestuff-0.1.0/.gitignore

@@ -0,0 +1,180 @@
+/**/.gtfs_cache
+/*.local
+.claude
+
+/*gguf*
+
+/docker-config
+/docker_build_local.log
+
+/ms?hit
+*mstest*py
+*_test.py
+/umqtt
+.idea/
+/upydev_.config
+*.local.*
+/scripts/logdir/
+
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+

somestuff_corestuff-0.1.0/LICENSE.md

@@ -0,0 +1,163 @@
+GNU Lesser General Public License
+=================================
+
+_Version 3, 29 June 2007_  
+_Copyright © 2007 Free Software Foundation, Inc. &lt;<http://fsf.org/>&gt;_
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+
+This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+### 0. Additional Definitions
+
+As used herein, “this License” refers to version 3 of the GNU Lesser
+General Public License, and the “GNU GPL” refers to version 3 of the GNU
+General Public License.
+
+“The Library” refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+An “Application” is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+A “Combined Work” is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the “Linked
+Version”.
+
+The “Minimal Corresponding Source” for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+The “Corresponding Application Code” for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+### 1. Exception to Section 3 of the GNU GPL
+
+You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+### 2. Conveying Modified Versions
+
+If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+* **a)** under this License, provided that you make a good faith effort to
+ensure that, in the event an Application does not supply the
+function or data, the facility still operates, and performs
+whatever part of its purpose remains meaningful, or
+
+* **b)** under the GNU GPL, with none of the additional permissions of
+this License applicable to that copy.
+
+### 3. Object Code Incorporating Material from Library Header Files
+
+The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+* **a)** Give prominent notice with each copy of the object code that the
+Library is used in it and that the Library and its use are
+covered by this License.
+* **b)** Accompany the object code with a copy of the GNU GPL and this license
+document.
+
+### 4. Combined Works
+
+You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+* **a)** Give prominent notice with each copy of the Combined Work that
+the Library is used in it and that the Library and its use are
+covered by this License.
+
+* **b)** Accompany the Combined Work with a copy of the GNU GPL and this license
+document.
+
+* **c)** For a Combined Work that displays copyright notices during
+execution, include the copyright notice for the Library among
+these notices, as well as a reference directing the user to the
+copies of the GNU GPL and this license document.
+
+* **d)** Do one of the following:
+    - **0)** Convey the Minimal Corresponding Source under the terms of this
+License, and the Corresponding Application Code in a form
+suitable for, and under terms that permit, the user to
+recombine or relink the Application with a modified version of
+the Linked Version to produce a modified Combined Work, in the
+manner specified by section 6 of the GNU GPL for conveying
+Corresponding Source.
+    - **1)** Use a suitable shared library mechanism for linking with the
+Library.  A suitable mechanism is one that **(a)** uses at run time
+a copy of the Library already present on the user's computer
+system, and **(b)** will operate properly with a modified version
+of the Library that is interface-compatible with the Linked
+Version.
+
+* **e)** Provide Installation Information, but only if you would otherwise
+be required to provide such information under section 6 of the
+GNU GPL, and only to the extent that such information is
+necessary to install and execute a modified version of the
+Combined Work produced by recombining or relinking the
+Application with a modified version of the Linked Version. (If
+you use option **4d0**, the Installation Information must accompany
+the Minimal Corresponding Source and Corresponding Application
+Code. If you use option **4d1**, you must provide the Installation
+Information in the manner specified by section 6 of the GNU GPL
+for conveying Corresponding Source.)
+
+### 5. Combined Libraries
+
+You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+* **a)** Accompany the combined library with a copy of the same work based
+on the Library, uncombined with any other library facilities,
+conveyed under the terms of this License.
+* **b)** Give prominent notice with the combined library that part of it
+is a work based on the Library, and explaining where to find the
+accompanying uncombined form of the same work.
+
+### 6. Revised Versions of the GNU Lesser General Public License
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License “or any later version”
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

somestuff_corestuff-0.1.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.5
+Name: somestuff-corestuff
+Version: 0.1.0
+Summary: Shared settings loader for the somestuff packages: pydantic-settings over config.yaml with config.local.yaml overrides from the working directory, plus JSON/dict helpers
+Project-URL: Homepage, https://github.com/vroomfondel/somestuff
+Project-URL: Repository, https://github.com/vroomfondel/somestuff
+Project-URL: Issues, https://github.com/vroomfondel/somestuff/issues
+Author-email: Henning Thieß <ht@xomox.cc>
+License-File: LICENSE.md
+Keywords: configuration,iot,pydantic-settings,yaml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: cachetools>=5.5
+Requires-Dist: email-validator>=2.2
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: pydantic-extra-types>=2.10
+Requires-Dist: pydantic-settings>=2.10
+Requires-Dist: pydantic>=2.11
+Requires-Dist: pytz>=2025.1
+Requires-Dist: ruamel-yaml>=0.18
+Description-Content-Type: text/markdown
+
+# somestuff-corestuff
+
+Shared settings loader for the `somestuff.*` packages that read the repo-wide `config.yaml`
+(`ecowittstuff`, `netatmostuff`, `hydromailstuff`, `llmstuff`).
+
+```python
+from somestuff.corestuff.config import get_settings, get_timezone, settings
+
+get_settings().mqtt.host      # explicit
+settings.mqtt.host            # lazy proxy, same object
+```
+
+Nothing is read at import time. The first access loads, in this order of precedence:
+
+| Source                      | Where it is looked for                                                                       |
+|-----------------------------|----------------------------------------------------------------------------------------------|
+| environment variables       | nested with `__`, e.g. `MQTT__HOST=broker`                                                   |
+| `config.local.yaml`         | `SOMESTUFF_CONFIG_LOCAL_PATH`, else `SOMESTUFF_CONFIG_DIR_PATH`, else the CWD, else `/app`   |
+| `config.yaml`               | `SOMESTUFF_CONFIG_PATH`, else `SOMESTUFF_CONFIG_DIR_PATH`, else the CWD, else `/app`, else the packaged sample |
+
+`config.local.yaml` carries the secrets and is never part of a distribution; keep it in the directory you start the tool from.
+`python3 -m somestuff.corestuff.config` (or `somestuff-config-dump`) prints the effective settings.
+
+`somestuff.corestuff.configure_logging()` installs the shared loguru format and routes stdlib `logging` into it;
+`somestuff.corestuff.helper` has the JSON encoder (`ComplexEncoder`) and `update_deep()`.

somestuff_corestuff-0.1.0/README.md

@@ -0,0 +1,25 @@
+# somestuff-corestuff
+
+Shared settings loader for the `somestuff.*` packages that read the repo-wide `config.yaml`
+(`ecowittstuff`, `netatmostuff`, `hydromailstuff`, `llmstuff`).
+
+```python
+from somestuff.corestuff.config import get_settings, get_timezone, settings
+
+get_settings().mqtt.host      # explicit
+settings.mqtt.host            # lazy proxy, same object
+```
+
+Nothing is read at import time. The first access loads, in this order of precedence:
+
+| Source                      | Where it is looked for                                                                       |
+|-----------------------------|----------------------------------------------------------------------------------------------|
+| environment variables       | nested with `__`, e.g. `MQTT__HOST=broker`                                                   |
+| `config.local.yaml`         | `SOMESTUFF_CONFIG_LOCAL_PATH`, else `SOMESTUFF_CONFIG_DIR_PATH`, else the CWD, else `/app`   |
+| `config.yaml`               | `SOMESTUFF_CONFIG_PATH`, else `SOMESTUFF_CONFIG_DIR_PATH`, else the CWD, else `/app`, else the packaged sample |
+
+`config.local.yaml` carries the secrets and is never part of a distribution; keep it in the directory you start the tool from.
+`python3 -m somestuff.corestuff.config` (or `somestuff-config-dump`) prints the effective settings.
+
+`somestuff.corestuff.configure_logging()` installs the shared loguru format and routes stdlib `logging` into it;
+`somestuff.corestuff.helper` has the JSON encoder (`ComplexEncoder`) and `update_deep()`.

somestuff_corestuff-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "somestuff-corestuff"
+dynamic = ["version"]
+description = "Shared settings loader for the somestuff packages: pydantic-settings over config.yaml with config.local.yaml overrides from the working directory, plus JSON/dict helpers"
+readme = "README.md"
+requires-python = ">=3.13"
+authors = [{ name = "Henning Thieß", email = "ht@xomox.cc" }]
+license-files = ["LICENSE.md"]
+keywords = ["configuration", "pydantic-settings", "yaml", "iot"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: System Administrators",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries",
+    "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
+    "Operating System :: POSIX :: Linux",
+    "Typing :: Typed",
+]
+dependencies = [
+    "loguru>=0.7.3",
+    "pydantic>=2.11",
+    "pydantic-settings>=2.10",
+    "pydantic-extra-types>=2.10",
+    "email-validator>=2.2",
+    "ruamel.yaml>=0.18",
+    "pytz>=2025.1",
+    "cachetools>=5.5",
+]
+
+[project.scripts]
+somestuff-config-dump = "somestuff.corestuff.config:log_settings"
+
+[project.urls]
+Homepage = "https://github.com/vroomfondel/somestuff"
+Repository = "https://github.com/vroomfondel/somestuff"
+Issues = "https://github.com/vroomfondel/somestuff/issues"
+
+[tool.hatch.version]
+path = "somestuff/corestuff/__init__.py"
+
+# Build-level selection governs sdist AND wheel; a wheel-only `packages` leaves the sdist unscoped.
+# A target-level `exclude` replaces the build-level list instead of extending it, so each target carries the full set.
+[tool.hatch.build]
+packages = ["somestuff"]
+exclude = ["**/__pycache__", "**/*.pyc", "**/*.local.*", "**/*_deployment.yml", "**/*_cronjob.yml", "**/*.example", "**/*.example.yaml", "**/*.sh"]
+
+[tool.hatch.build.targets.sdist]
+exclude = ["**/__pycache__", "**/*.pyc", "**/*.local.*", "**/*_deployment.yml", "**/*_cronjob.yml", "**/*.example", "**/*.example.yaml", "**/*.sh"]
+
+[tool.hatch.build.targets.wheel]
+exclude = ["**/__pycache__", "**/*.pyc", "**/*.local.*", "**/*_deployment.yml", "**/*_cronjob.yml", "**/*.example", "**/*.example.yaml", "**/*.sh", "**/README.md"]

somestuff_corestuff-0.1.0/somestuff/corestuff/README.md

@@ -0,0 +1,25 @@
+# somestuff-corestuff
+
+Shared settings loader for the `somestuff.*` packages that read the repo-wide `config.yaml`
+(`ecowittstuff`, `netatmostuff`, `hydromailstuff`, `llmstuff`).
+
+```python
+from somestuff.corestuff.config import get_settings, get_timezone, settings
+
+get_settings().mqtt.host      # explicit
+settings.mqtt.host            # lazy proxy, same object
+```
+
+Nothing is read at import time. The first access loads, in this order of precedence:
+
+| Source                      | Where it is looked for                                                                       |
+|-----------------------------|----------------------------------------------------------------------------------------------|
+| environment variables       | nested with `__`, e.g. `MQTT__HOST=broker`                                                   |
+| `config.local.yaml`         | `SOMESTUFF_CONFIG_LOCAL_PATH`, else `SOMESTUFF_CONFIG_DIR_PATH`, else the CWD, else `/app`   |
+| `config.yaml`               | `SOMESTUFF_CONFIG_PATH`, else `SOMESTUFF_CONFIG_DIR_PATH`, else the CWD, else `/app`, else the packaged sample |
+
+`config.local.yaml` carries the secrets and is never part of a distribution; keep it in the directory you start the tool from.
+`python3 -m somestuff.corestuff.config` (or `somestuff-config-dump`) prints the effective settings.
+
+`somestuff.corestuff.configure_logging()` installs the shared loguru format and routes stdlib `logging` into it;
+`somestuff.corestuff.helper` has the JSON encoder (`ComplexEncoder`) and `update_deep()`.

somestuff_corestuff-0.1.0/somestuff/corestuff/__init__.py

@@ -0,0 +1,57 @@
+"""corestuff — shared settings loader (pydantic-settings over config.yaml + config.local.yaml) and helpers.
+
+Lookup order for ``config.yaml``: ``SOMESTUFF_CONFIG_PATH``, ``SOMESTUFF_CONFIG_DIR_PATH``, the current
+directory, ``/app``, then the packaged sample. ``config.local.yaml`` is searched the same way
+(``SOMESTUFF_CONFIG_LOCAL_PATH``) and merged over it. Nothing is read at import time: call
+:func:`somestuff.corestuff.config.get_settings`, or use the lazy ``settings`` proxy.
+"""
+
+import inspect
+import logging
+import os
+import sys
+from collections.abc import Callable
+from types import FrameType
+from typing import TYPE_CHECKING
+
+from loguru import logger as glogger
+
+if TYPE_CHECKING:
+    from loguru import Record
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__", "configure_logging"]
+
+
+def _loguru_skiplog_filter(record: "Record") -> bool:
+    return not record.get("extra", {}).get("skiplog", False)
+
+
+class _InterceptHandler(logging.Handler):
+    def emit(self, record: logging.LogRecord) -> None:
+        level: str | int
+        try:
+            level = glogger.level(record.levelname).name
+        except ValueError:
+            level = record.levelno
+        frame: FrameType | None = inspect.currentframe()
+        depth = 0
+        while frame and (depth == 0 or frame.f_code.co_filename == logging.__file__):
+            frame = frame.f_back
+            depth += 1
+        glogger.bind(classname=record.name).opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
+
+
+def configure_logging(
+    verbose: bool = False, loguru_filter: Callable[["Record"], bool] = _loguru_skiplog_filter
+) -> None:
+    level_name: str = "DEBUG" if verbose else os.getenv("LOGURU_LEVEL", "INFO")
+    os.environ["LOGURU_LEVEL"] = level_name
+    glogger.remove()
+    logger_fmt: str = (
+        "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{module}</cyan>::<cyan>{extra[classname]}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>"
+    )
+    glogger.add(sys.stderr, level=level_name, format=logger_fmt, filter=loguru_filter)  # type: ignore[arg-type]
+    glogger.configure(extra={"classname": "None", "skiplog": False})
+    logging.basicConfig(handlers=[_InterceptHandler()], level=logging.getLevelNamesMapping()[level_name], force=True)

somestuff_corestuff-0.1.0/somestuff/corestuff/config.py

@@ -0,0 +1,291 @@
+import datetime
+import json
+import os
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, ClassVar, Dict, List, Optional, Tuple, Type, cast
+
+import pytz
+from cachetools import TTLCache, cached
+from loguru import logger
+from pydantic import BaseModel, EmailStr, Field, HttpUrl, model_validator
+from pydantic.networks import IPvAnyAddress
+from pydantic_extra_types.mac_address import MacAddress
+from pydantic_settings import (
+    BaseSettings,
+    DotEnvSettingsSource,
+    EnvSettingsSource,
+    InitSettingsSource,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+)
+from ruamel.yaml import YAML
+
+from somestuff.corestuff import helper
+
+_PKG = "SOMESTUFF"
+_PACKAGE_DIR: Path = Path(__file__).parent.resolve()
+_CONFIG_FILENAME = "config.yaml"
+_CONFIG_LOCAL_FILENAME = "config.local.yaml"
+
+
+def _search_dirs() -> List[Path]:
+    env_dir: str | None = os.getenv(f"{_PKG}_CONFIG_DIR_PATH")
+    if env_dir:
+        return [Path(env_dir)]
+    return [Path.cwd(), Path("/app")]
+
+
+def _first_existing(filename: str) -> Path | None:
+    for d in _search_dirs():
+        candidate: Path = Path(d, filename)
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def config_path() -> Path:
+    env_path: str | None = os.getenv(f"{_PKG}_CONFIG_PATH")
+    if env_path:
+        return Path(env_path)
+    return _first_existing(_CONFIG_FILENAME) or Path(_PACKAGE_DIR, _CONFIG_FILENAME)
+
+
+def config_local_path() -> Path | None:
+    env_path: str | None = os.getenv(f"{_PKG}_CONFIG_LOCAL_PATH")
+    if env_path:
+        return Path(env_path)
+    return _first_existing(_CONFIG_LOCAL_FILENAME)
+
+
+def _load_yaml(path: Path | None) -> Dict[str, Any] | None:
+    if path is None or not path.is_file():
+        return None
+    try:
+        return YAML().load(path)
+    except Exception as e:
+        logger.opt(exception=e).exception(f"Error loading config file: {path}")
+        return None
+
+
+@lru_cache(maxsize=1)
+def get_effective_config() -> Dict[str, Any]:
+    base: Dict[str, Any] | None = _load_yaml(config_path())
+    local: Dict[str, Any] | None = _load_yaml(config_local_path())
+    if base is None:
+        return {} if local is None else local
+    if local is None:
+        return base
+    return cast(Dict[str, Any], helper.update_deep(base, local))
+
+
+class _EffectiveConfigSource(PydanticBaseSettingsSource):
+    def get_field_value(self, field: Any, field_name: str) -> Tuple[Any, str, bool]:
+        return None, field_name, False
+
+    def __call__(self) -> Dict[str, Any]:
+        return dict(get_effective_config())
+
+
+# alias in settings not correctly handled for pydantic v2
+# https://github.com/pydantic/pydantic/issues/8379
+
+
+class MqttTopic(BaseModel):
+    # modulename: str
+    # submodulename: str
+    topic: str
+    subscribe: bool = False
+
+
+class MqttTopics(BaseModel):
+    root: Dict[str, Dict[str, MqttTopic]]
+
+    @model_validator(mode="before")
+    @classmethod
+    def _populate_root(cls, v: Any) -> Any:
+        if isinstance(v, dict) and "root" not in v:
+            return {"root": v}
+        return v
+
+    def __iter__(self) -> Any:
+        return iter(self.root)  # type: ignore
+
+    def __getitem__(self, item: Any) -> Any:
+        return self.root[item]
+
+
+class NetatmoModule(BaseModel):
+    name: str
+    id: Optional[MacAddress] = None
+
+
+class Netatmo(BaseModel):
+    username: str
+    password: str
+    client_id: str
+    client_secret: str
+    refresh_token: Optional[str] = None
+    outdoormodule: NetatmoModule
+    rainmodule: NetatmoModule
+
+
+class Ecowitt(BaseModel):
+    application_key: str | None = None
+    api_key: str | None = None
+    mac: MacAddress | None = None
+
+    # HttpUrlString = Annotated[HttpUrl, AfterValidator(lambda v: str(v))]
+    realtime_url: HttpUrl = Field(default=HttpUrl("https://api.ecowitt.net/api/v3/device/real_time"))
+    device_info_url: HttpUrl = Field(default=HttpUrl("https://api.ecowitt.net/api/v3/device/info"))
+
+    # @field_validator('mac', mode="before")
+    # @classmethod
+    # def validate_mac(cls, v):
+    #     # logger.debug(f"VALIDATE MAC: {v}")
+    #     if not v:
+    #         return None
+    #
+    #     return cls.mac_no_colon_to_colon(v)
+
+
+class Redis(BaseModel):
+    host: str = Field(default="127.0.0.1")
+    host_in_cluster: Optional[str] = Field(default=None)
+    port: int = Field(default=6379)
+    port_in_cluster: int = Field(default=6379)
+
+
+class Google(BaseModel):
+    gemini_api_key: str | None = Field(default=None)
+
+
+class Anthropic(BaseModel):
+    anthropic_api_key: str | None = Field(default=None)
+
+
+class Postgresql(BaseModel):
+    host: str = Field(default="127.0.0.1")
+    host_in_cluster: Optional[str] = Field(default="postgresql.postgresql.svc")
+    username: str = Field(default="postgres")
+    password: str = Field(default="empty")
+    dbname: str = Field(default="postgres")
+    port: int = Field(default=5432)
+    port_in_cluster: int = Field(default=5432)
+    # url: Optional[PostgresDsn] = Field(default=None)
+    url: Optional[str] = Field(default=None)
+
+
+class Mqtt(BaseModel):
+    host: str = Field(default="127.0.0.1")
+    port: int = Field(default=1883)
+    username: str = Field()
+    password: str = Field()
+
+
+class MqttMessageDefaultMetadata(BaseModel):
+    # created_at is not really needed here -> will be added "on-the-fly"
+    created_at: None | str = Field(default=None)
+    # latitude, longitude, elevation for sensor/actor
+    lat: None | float = Field(default=None)
+    lon: None | float = Field(default=None)
+    ele: None | float = Field(default=None)
+
+
+class Hydromail(BaseModel):
+    smtpip: IPvAnyAddress
+    mailfrom: EmailStr
+    mailreplyto: EmailStr
+    mailsubject_base: str
+    mailrecipients_to: List[EmailStr]
+    mailrecipients_cc: List[EmailStr]
+
+
+class Settings(BaseSettings):
+    model_config: ClassVar[SettingsConfigDict] = SettingsConfigDict(
+        populate_by_name=True,
+        # env_prefix="TAS_",
+        case_sensitive=False,
+        extra="ignore",  # ignore | forbid | allow
+        protected_namespaces=(),
+        env_nested_delimiter="__",
+        # alias_generator=AliasGenerator(
+        #     validation_alias=to_camel,
+        #     serialization_alias=to_pascal,
+        # )
+    )
+
+    # emailsettings: EmailSettings
+    redis: Redis
+    postgresql: Postgresql
+    timezone: str = Field(default="Europe/Berlin")
+    google: Google
+    anthropic: Anthropic
+    ecowitt: Ecowitt
+    mqtt: Mqtt
+    mqtt_message_default_metadata: MqttMessageDefaultMetadata
+    netatmo: Netatmo
+    hydromail: Hydromail
+    mqtt_topics: MqttTopics
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: Type[BaseSettings],
+        init_settings: InitSettingsSource,  # type: ignore
+        env_settings: EnvSettingsSource,  # type: ignore
+        dotenv_settings: DotEnvSettingsSource,  # type: ignore
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> Tuple[PydanticBaseSettingsSource, ...]:
+        return init_settings, env_settings, _EffectiveConfigSource(settings_cls)
+
+
+@lru_cache(maxsize=1)
+def get_settings() -> Settings:
+    logger.debug(f"EFFECTIVE CONFIGPATH: {config_path()}")
+    logger.debug(f"EFFECTIVE CONFIGLOCALPATH: {config_local_path()}")
+    return Settings()  # type: ignore[call-arg]
+
+
+class _LazySettings:
+    def __getattr__(self, name: str) -> Any:
+        return getattr(get_settings(), name)
+
+
+settings: Settings = cast(Settings, _LazySettings())
+
+
+@lru_cache(maxsize=1)
+def get_timezone() -> datetime.tzinfo:
+    return pytz.timezone(get_settings().timezone)
+
+
+def str2bool(v: str | bool) -> bool:
+    if not v:
+        return False
+
+    if isinstance(v, bool):
+        return v
+
+    return v.lower() in ("yes", "true", "t", "1")
+
+
+@cached(cache=TTLCache(maxsize=1, ttl=60))
+def is_in_cluster() -> bool:
+    sa: Path = Path("/var/run/secrets/kubernetes.io/serviceaccount")
+    if sa.exists() and sa.is_dir():
+        return os.getenv("KUBERNETES_SERVICE_HOST") is not None
+    return False
+
+
+def log_settings() -> None:
+    logger.info(json.dumps(get_settings().model_dump(by_alias=True), indent=4, sort_keys=False, default=str))
+
+
+if __name__ == "__main__":
+    from somestuff.corestuff import configure_logging
+
+    configure_logging()
+    log_settings()
+    logger.info(json.dumps(get_effective_config(), indent=4, sort_keys=False, default=str))
+    helper.get_loguru_logger_info()

somestuff_corestuff-0.1.0/somestuff/corestuff/config.yaml

@@ -0,0 +1,117 @@
+emailsettings:
+  privileged_sender: "someone@example.com"
+  mailaddress: "mailbox@example.com"
+  mailuser: "mailbox@example.com"
+  mailpassword: "fumpuslumpus"
+  imapserver: "imap.hopefully.not.office365.blargh"
+  imapport: 143
+  smtpserver: "smtp.hopefully.not.office365.blargh"
+  smtpport: 587
+  folders:
+    old: "WORKED"
+    cur: "WORKING"
+    rej: "REJECTED"
+    err: "FAILED"
+  alloweddomains:
+    - "onecorp.bizme"
+    - "secondcorp.bizme"
+
+hydromail:
+  smtpip: "127.0.0.1"
+  mailfrom: "hydromail@example.com"
+  mailreplyto: "hydromail@example.org"
+  mailsubject_base: "Regenmessdaten :: Some Where There"
+  mailrecipients_to:
+    - "otherone@example.org"
+  mailrecipients_cc:
+    - "someone@example.net"
+    - "somehone@example.org"
+
+
+redis:
+  host: "127.0.0.1"
+  port: 6379
+
+google:
+  gemini_api_key: "WOBBLE-DOBBLE-DINGDONG"
+
+anthropic:
+  anthropic_api_key: "sk-ant-DOBBLE-WOBBLE-DINGDONG"
+
+ecowitt:
+  application_key: "bluppkey"
+  api_key: "blargkey"
+  realtime_url: "https://api.ecowitt.net/api/v3/device/real_time"
+  device_info_url: "https://api.ecowitt.net/api/v3/device/info"
+  mac: "de:ad:be:ef:fe:ed"
+
+netatmo:
+  username: "someusername"
+  password: "somepassword"
+  client_id: "someclientid"
+  client_secret: "someclientsecret"
+  # refresh_token: "somerefreshtoken"
+  outdoormodule:
+    name: "Außen"
+    id: "01:12:34:56:22:11"
+  rainmodule:
+    name: "RegenModul"
+    id: "01:12:34:56:33:22"
+
+
+postgresql:
+  host: "127.0.0.1"
+  host_in_cluster: "postgresql.postgresql.svc"
+  port: 5438
+  port_in_cluster: 5432
+  username: "postgres"
+  password: "postgrespass"
+  dbname: "postgres"
+
+
+
+mqtt:
+  username: "MQTT_USERNAME"
+  password: "MQTT_PASS"
+  host: "MQTT_HOST"
+  port: 1883
+  # TLS not used/implemented as of now.
+
+mqtt_topics:
+  ecowitt:
+    pressure:
+      topic: "ecowitt/pressure"
+      subscribe: false
+  netatmo:
+    temperature:
+      topic: "netatmo/temperature"
+      subscribe: false
+    rainfeed:
+      topic: "netatmo/rain"
+      subscribe: false
+    rainfeed1h:
+      topic: "netatmo/rain1h"
+      subscribe: false
+    rainfeed24h:
+      topic: "netatmo/rain24h"
+      subscribe: false
+    pressurefeed:
+      topic: "netatmo/pressure"
+      subscribe: false
+  wasserstand:
+    ma:
+      topic: "esp32/esp32_9191919191/ma"
+      subscribe: false
+    busvoltage:
+      topic: "esp32/esp32_9191919191/busvoltage"
+      subscribe: false
+    wasserstand:
+      topic: "nodered/hydrostatics/hydrostatic0/status"
+      subscribe: false
+
+mqtt_message_default_metadata:
+  # latitude, longitude, elevation for sensor/actor
+  lat: 1.234567
+  lon: 2.345678
+  ele: 3.456
+

somestuff_corestuff-0.1.0/somestuff/corestuff/helper.py

@@ -0,0 +1,141 @@
+import datetime
+import json
+import traceback
+import uuid
+from enum import Enum
+from typing import Any, Dict, List
+
+
+def get_loguru_logger_info() -> None:
+    # deferred import
+    from loguru import logger
+
+    def inspect_loggers() -> List[Dict[str, Any]]:
+        """Gibt eine Liste aller konfigurierten Logger-Handler zurück."""
+        handlers_info = []
+
+        lvint_to_lvname: Dict[int, str] = {lvv.no: lvv.name for lvv in logger._core.levels.values()}  # type: ignore
+
+        for handler_id, handler in logger._core.handlers.items():  # type: ignore
+            info = {
+                "id": handler_id,
+                "level": handler._levelno,
+                "level_name": lvint_to_lvname[handler._levelno],  # handler._level_name,
+                "format": handler._formatter,
+                "sink": str(handler._sink),
+                "filter": handler._filter.__name__ if callable(handler._filter) else str(handler._filter),
+                "colorize": getattr(handler, "_colorize", None),
+                "serialize": getattr(handler, "_serialize", None),
+            }
+            handlers_info.append(info)
+
+        return handlers_info
+
+    def get_all_filters() -> List[Any]:
+        """Gibt alle Filter aller Handler zurück."""
+        filters = []
+
+        for handler_id, handler in logger._core.handlers.items():  # type: ignore
+            filter_func = handler._filter
+            if filter_func is not None:
+                filters.append(
+                    {
+                        "handler_id": handler_id,
+                        "filter": filter_func,
+                        "filter_name": filter_func.__name__ if callable(filter_func) else str(filter_func),
+                    }
+                )
+
+        return filters
+
+    for handler in inspect_loggers():
+        logger.info(f"Handler {handler['id']}:")
+        logger.info(f"  Level: {handler['level_name']} ({handler['level']})")
+        logger.info(f"  Format: {handler['format']}")
+        logger.info(f"  Sink: {handler['sink']}")
+        logger.info(f"  Filter: {handler['filter']}")
+        logger.info("")
+
+    # only filters:
+    for f in get_all_filters():
+        logger.info(f"Handler {f['handler_id']}: {f['filter_name']}")
+
+
+class ComplexEncoder(json.JSONEncoder):
+    def default(self, obj: Any) -> Any:
+        if hasattr(obj, "repr_json"):
+            return obj.repr_json()
+        elif hasattr(obj, "as_string"):
+            return obj.as_string()
+        elif isinstance(obj, uuid.UUID):
+            return str(obj)
+        elif isinstance(obj, datetime.datetime):
+            return obj.isoformat()  # strftime("%Y-%m-%d %H:%M:%S %Z")
+        elif isinstance(obj, datetime.date):
+            return obj.strftime("%Y-%m-%d")
+        elif isinstance(obj, datetime.timedelta):
+            return str(obj)
+        elif isinstance(obj, dict) or isinstance(obj, list):
+            robj: str = get_pretty_dict_json_no_sort(obj)
+            return robj
+        else:
+            return json.JSONEncoder.default(self, obj)
+
+
+def print_pretty_dict_json(data: Any, indent: int = 4) -> None:
+    from loguru import logger
+
+    logger.info(json.dumps(data, indent=indent, sort_keys=True, cls=ComplexEncoder, default=str))
+
+
+def get_pretty_dict_json(data: Any, indent: int = 4) -> str:
+    return json.dumps(data, indent=indent, sort_keys=True, cls=ComplexEncoder, default=str)
+
+
+def get_pretty_dict_json_no_sort(data: Any, indent: int = 4) -> str:
+    return json.dumps(data, indent=indent, sort_keys=False, cls=ComplexEncoder, default=str)
+
+
+def update_deep(base: Dict[str, Any] | List[Any], u: Dict[str, Any] | List[Any]) -> Dict[str, Any] | List[Any]:
+    if isinstance(u, dict):
+        if not isinstance(base, dict):
+            base = {}
+
+        for k, v in u.items():
+            if isinstance(v, dict) or isinstance(v, list):
+                base[k] = update_deep(base.get(k, {}), v)
+            else:
+                base[k] = v
+
+    elif isinstance(u, list):
+        if not isinstance(base, list):
+            base = []  # may destroy the existing data if mismatch!!!
+
+        # Stelle sicher, dass base lang genug ist
+        # geht auch kompakter, aber so ist es gut lesbar
+        while len(base) < len(u):
+            base.append(None)
+
+        # Stelle sicher, dass base nicht länger ist...
+        # geht auch kompakter, aber so ist es gut lesbar
+        while len(base) > len(u):
+            base.pop()
+
+        for i, v in enumerate(u):
+            if isinstance(v, dict) or isinstance(v, list):
+                base[i] = update_deep(base[i] if base[i] is not None else ({} if isinstance(v, dict) else []), v)  # type: ignore
+            else:
+                base[i] = v
+
+    return base
+
+
+def get_exception_tb_as_string(exc: Exception) -> str:
+    tb1: traceback.TracebackException = traceback.TracebackException.from_exception(exc)
+    tbsg = tb1.format()
+    tbs = ""
+
+    for line in tbsg:
+        tbs = tbs + "\n" + line
+
+    return tbs