chore(deps): update from template

Author: helmut-hoffer-von-ankershoffen

.copier-answers.yml

@@ -1,4 +1,4 @@
-_commit: v0.16.3
+_commit: v0.16.5
 _src_path: gh:helmut-hoffer-von-ankershoffen/oe-python-template
 attestations_enabled: true
 author_email: helmuthva@gmail.com

.github/workflows/_test.yml

@@ -66,6 +66,8 @@ jobs:
       - name: Smoke tests
         run: |
           uv run --no-dev oe-python-template-example --help
+          uv run --all-extras oe-python-template-example system info
+          uv run --all-extras oe-python-template-example system health
       
       - name: Test / regular
         run: |

ATTRIBUTIONS.md

@@ -12189,7 +12189,7 @@ License: LGPL-2.1-or-later
 
 ```
 
-## oe-python-template-example (0.4.15) - MIT License
+## oe-python-template-example (0.4.16) - MIT License
 
 🧠 Example project scaffolded and kept up to date with OE Python Template (oe-python-template).
 

CLI_REFERENCE.md

@@ -14,7 +14,7 @@ $ oe-python-template-example [OPTIONS] COMMAND [ARGS]...
 * `--show-completion`: Show completion for the current shell, to copy it or customize the installation.
 * `--help`: Show this message and exit.
 
-🧠 OE Python Template Example v0.4.15 - built with love in Berlin 🐻
+🧠 OE Python Template Example v0.4.16 - built with love in Berlin 🐻
 
 **Commands**:
 

src/oe_python_template_example/system/_service.py

@@ -6,9 +6,12 @@
 import pwd
 import sys
 import time
-from typing import Any
+from socket import AF_INET, SOCK_DGRAM, socket
+from typing import Any, NotRequired, TypedDict, cast
+from urllib.error import HTTPError
 
 from pydantic_settings import BaseSettings
+from requests import get
 from uptime import boottime, uptime
 
 from ..utils import (  # noqa: TID252
@@ -27,7 +30,28 @@
 )
 from ._settings import Settings
 
-logger = get_logger(__name__)
+log = get_logger(__name__)
+
+
+class RuntimeDict(TypedDict, total=False):
+    """Type for runtime information dictionary."""
+
+    environment: str
+    username: str
+    process: dict[str, Any]
+    host: dict[str, Any]
+    python: dict[str, Any]
+    environ: dict[str, str]
+
+
+class InfoDict(TypedDict, total=False):
+    """Type for the info dictionary."""
+
+    package: dict[str, Any]
+    runtime: RuntimeDict
+    settings: dict[str, Any]
+    # Allow additional string keys with any values for service info
+    __extra__: NotRequired[dict[str, Any]]
 
 
 class Service(BaseService):
@@ -74,12 +98,47 @@ def is_token_valid(self, token: str) -> bool:
         Returns:
             bool: True if the token is valid, False otherwise.
         """
-        logger.info(token)
+        log.info(token)
         if not self._settings.token:
-            logger.warning("Token is not set in settings.")
+            log.warning("Token is not set in settings.")
             return False
         return token == self._settings.token.get_secret_value()
 
+    @staticmethod
+    def _get_public_ipv4(timeout: int = 5) -> str | None:
+        """Get the public IPv4 address of the system.
+
+        Args:
+            timeout (int): Timeout for the request in seconds.
+
+        Returns:
+            str: The public IPv4 address.
+        """
+        try:
+            response = get(url="https://api.ipify.org", timeout=timeout)
+            response.raise_for_status()
+            return response.text
+        except HTTPError as e:
+            message = f"Failed to get public IP: {e}"
+            log.exception(message)
+            return None
+
+    @staticmethod
+    def _get_local_ipv4() -> str | None:
+        """Get the local IPv4 address of the system.
+
+        Returns:
+            str: The local IPv4 address.
+        """
+        try:
+            with socket(AF_INET, SOCK_DGRAM) as connection:
+                connection.connect(("8.8.8.8", 80))
+                return str(connection.getsockname()[0])
+        except Exception as e:
+            message = f"Failed to get local IP: {e}"
+            log.exception(message)
+            return None
+
     @staticmethod
     def info(include_environ: bool = False, filter_secrets: bool = True) -> dict[str, Any]:
         """
@@ -95,7 +154,7 @@ def info(include_environ: bool = False, filter_secrets: bool = True) -> dict[str
             dict[str, Any]: Service configuration.
         """
         bootdatetime = boottime()
-        rtn = {
+        rtn: InfoDict = {
             "package": {
                 "version": __version__,
                 "name": __project_name__,
@@ -104,35 +163,49 @@ def info(include_environ: bool = False, filter_secrets: bool = True) -> dict[str
             },
             "runtime": {
                 "environment": __env__,
+                "username": pwd.getpwuid(os.getuid())[0],
+                "process": {
+                    "command_line": " ".join(sys.argv),
+                    "entry_point": sys.argv[0] if sys.argv else None,
+                    "process_info": json.loads(get_process_info().model_dump_json()),
+                },
+                "host": {
+                    "os": {
+                        "platform": platform.platform(),
+                        "system": platform.system(),
+                        "release": platform.release(),
+                        "version": platform.version(),
+                    },
+                    "machine": {
+                        "arch": platform.machine(),
+                        "processor": platform.processor(),
+                        "cpu_count": os.cpu_count(),
+                    },
+                    "network": {
+                        "hostname": platform.node(),
+                        "local_ipv4": Service._get_local_ipv4(),
+                        "public_ipv4": Service._get_public_ipv4(),
+                    },
+                    "uptime": {
+                        "seconds": uptime(),
+                        "boottime": bootdatetime.isoformat() if bootdatetime else None,
+                    },
+                },
                 "python": {
                     "version": platform.python_version(),
                     "compiler": platform.python_compiler(),
                     "implementation": platform.python_implementation(),
                     "sys.path": sys.path,
-                },
-                "interpreter_path": sys.executable,
-                "command_line": " ".join(sys.argv),
-                "entry_point": sys.argv[0] if sys.argv else None,
-                "process_info": json.loads(get_process_info().model_dump_json()),
-                "username": pwd.getpwuid(os.getuid())[0],
-                "host": {
-                    "system": platform.system(),
-                    "release": platform.release(),
-                    "version": platform.version(),
-                    "machine": platform.machine(),
-                    "processor": platform.processor(),
-                    "hostname": platform.node(),
-                    "ip_address": platform.uname().node,
-                    "cpu_count": os.cpu_count(),
-                    "uptime": uptime(),
-                    "boottime": bootdatetime.isoformat() if bootdatetime else None,
+                    "interpreter_path": sys.executable,
                 },
             },
+            "settings": {},
         }
 
+        runtime = cast("RuntimeDict", rtn["runtime"])
         if include_environ:
             if filter_secrets:
-                rtn["runtime"]["environ"] = {
+                runtime["environ"] = {
                     k: v
                     for k, v in os.environ.items()
                     if not (
@@ -144,9 +217,9 @@ def info(include_environ: bool = False, filter_secrets: bool = True) -> dict[str
                     )
                 }
             else:
-                rtn["runtime"]["environ"] = dict(os.environ)
+                runtime["environ"] = dict(os.environ)
 
-        settings = {}
+        settings: dict[str, Any] = {}
         for settings_class in locate_subclasses(BaseSettings):
             settings_instance = load_settings(settings_class)
             env_prefix = settings_instance.model_config.get("env_prefix", "")
@@ -158,12 +231,16 @@ def info(include_environ: bool = False, filter_secrets: bool = True) -> dict[str
                 settings[flat_key] = value
         rtn["settings"] = settings
 
+        # Convert the TypedDict to a regular dict before adding dynamic service keys
+        result_dict: dict[str, Any] = dict(rtn)
+
         for service_class in locate_subclasses(BaseService):
             if service_class is not Service:
                 service = service_class()
-                rtn[service.key()] = service.info()
+                result_dict[service.key()] = service.info()
 
-        return rtn
+        log.info("Service info: %s", result_dict)
+        return result_dict
 
     @staticmethod
     def div_by_zero() -> float: