ha-mcp-dev 8.1.1.dev2289__tar.gz → 8.1.1.dev2292__tar.gz

{ha_mcp_dev-8.1.1.dev2289/src/ha_mcp_dev.egg-info → ha_mcp_dev-8.1.1.dev2292}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 8.1.1.dev2289
+Version: 8.1.1.dev2292
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Author-email: Julien <github@qc-h.net>
 License: MIT

{ha_mcp_dev-8.1.1.dev2289 → ha_mcp_dev-8.1.1.dev2292}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "8.1.1.dev2289"
+version = "8.1.1.dev2292"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 # Upper bound widened to <3.15 so the package installs on Home Assistant's

{ha_mcp_dev-8.1.1.dev2289 → ha_mcp_dev-8.1.1.dev2292}/src/ha_mcp/backup_manager.py

@@ -1441,10 +1441,11 @@ async def _fetch_dashboard(client: Any, entity_id: str) -> Any:
     try:
         config, _config_hash = await _get_dashboard_config_internal(client, fetch_path)
     except ToolError as err:
-        # ToolError carries the structured failure payload; treat a
-        # missing/unknown dashboard as "nothing to back up" (also covers a
-        # brand-new dashboard on the create path). "Unknown config
-        # specified" is HA's message for an unresolved url_path.
+        # ToolError carries the structured failure payload, including HA's
+        # preserved ``config_not_found`` code; treat a missing/unknown
+        # dashboard as "nothing to back up" (also covers a brand-new dashboard
+        # on the create path). "Unknown config specified" is HA's message for
+        # an unresolved url_path.
         msg = str(err).lower()
         if "not_found" in msg or "config_not_found" in msg or "unknown config" in msg:
             return None

{ha_mcp_dev-8.1.1.dev2289 → ha_mcp_dev-8.1.1.dev2292}/src/ha_mcp/tools/tools_config_dashboards.py

@@ -8,7 +8,7 @@ import json
 import logging
 import re
 from dataclasses import dataclass, replace
-from typing import Annotated, Any, Literal, cast, overload
+from typing import Annotated, Any, Literal, NoReturn, cast, overload
 
 from fastmcp.exceptions import ToolError
 from fastmcp.tools import tool
@@ -40,7 +40,7 @@ from ..dashboard_screenshot.paths import (
     match_dashboard_view,
     resolve_dashboard_view,
 )
-from ..errors import ErrorCode, create_error_response
+from ..errors import ErrorCode, create_error_response, get_error_code, get_error_message
 from ..strict_bps import BestPracticeKeyParam
 from ..utils.config_hash import compute_config_hash
 from ..utils.python_sandbox import (
@@ -134,8 +134,9 @@ async def _get_dashboard_config_internal(
     ``tools_config_scenes.py``).
 
     Raises ``ToolError`` with ``ErrorCode.SERVICE_CALL_FAILED`` if the
-    WebSocket call reports failure or the response is not a dict; callers
-    can rely on the returned tuple being populated.
+    WebSocket call reports failure or the response is not a dict. HA's
+    upstream error code is preserved as ``ha_error_code`` when present, so
+    callers can distinguish confirmed absence from an unverifiable read.
     """
     get_data: dict[str, Any] = {"type": "lovelace/config", "force": True}
     if url_path:
@@ -144,14 +145,20 @@ async def _get_dashboard_config_internal(
     response = await client.send_websocket_message(get_data)
 
     if isinstance(response, dict) and not response.get("success", True):
-        error_msg = response.get("error", {})
-        if isinstance(error_msg, dict):
-            error_msg = error_msg.get("message", str(error_msg))
+        error_msg = get_error_message(response)
+        if error_msg is None:
+            error_msg = str(response.get("error", {}))
+        ha_error_code = response.get("error_code") or get_error_code(response)
+        error_context: dict[str, Any] = {"url_path": url_path}
+        if ha_error_code is not None:
+            # Preserve HA's code so downstream safety decisions do not have to
+            # infer an absent config from a multiply-prefixed message alone.
+            error_context["ha_error_code"] = str(ha_error_code)
         raise_tool_error(
             create_error_response(
                 ErrorCode.SERVICE_CALL_FAILED,
                 f"Dashboard fetch failed: {error_msg}",
-                context={"url_path": url_path},
+                context=error_context,
             )
         )
 
@@ -772,12 +779,39 @@ def _card_matches(
 # regresses silently to never firing — re-verify with major HA upgrades.
 _LAZY_RESOLVE_TRIGGER = "Unknown config specified"
 
+# Exact ``lovelace/config`` messages meaning that a storage dashboard exists
+# but has not been given a config yet. Mirrors smart_search/_deep.py and stays
+# deliberately narrower than ``_LAZY_RESOLVE_TRIGGER``: an unknown path or any
+# other pre-read failure must remain fail-closed before a full replacement.
+_NO_STORED_CONFIG_MESSAGES = frozenset(
+    {"No config found.", "Command failed: No config found."}
+)
+_DASHBOARD_FETCH_FAILED_PREFIX = "Dashboard fetch failed: "
+_HA_CONFIG_NOT_FOUND_CODE = "config_not_found"
+
 
 def _should_lazy_resolve(error_msg: str) -> bool:
     """Return True if a WS error message indicates the identifier needs resolving."""
     return _LAZY_RESOLVE_TRIGGER in error_msg
 
 
+def _is_no_stored_dashboard_config_error(exc: ToolError) -> bool:
+    """Return whether HA confirms that an existing dashboard has no config."""
+    try:
+        error_data = json.loads(str(exc))
+    except (json.JSONDecodeError, TypeError):
+        return False
+    if (
+        not isinstance(error_data, dict)
+        or error_data.get("ha_error_code") != _HA_CONFIG_NOT_FOUND_CODE
+    ):
+        return False
+    message = extract_tool_error_message(exc).removeprefix(
+        _DASHBOARD_FETCH_FAILED_PREFIX
+    )
+    return message in _NO_STORED_CONFIG_MESSAGES
+
+
 # The ha_mcp_tools/dashboards WS command: list / get / search over the live
 # lovelace collection in one in-process frame. Named once so the routing helpers
 # and their tests agree on the wire string (Global-Constraint-2 idiom, mirroring
@@ -1262,6 +1296,22 @@ async def fetch_dashboards_list(
     return None
 
 
+def _raise_dashboard_registry_read_error(*, action: str, url_path: str) -> NoReturn:
+    """Raise the shared user-facing error for an unreadable dashboard registry."""
+    raise_tool_error(
+        create_error_response(
+            ErrorCode.SERVICE_CALL_FAILED,
+            "Failed to read the Home Assistant dashboard registry",
+            suggestions=[
+                "Retry the operation",
+                "Check the Home Assistant connection and logs",
+                "Use ha_config_get_dashboard(list_only=True) to verify registry access",
+            ],
+            context={"action": action, "url_path": url_path},
+        )
+    )
+
+
 async def _resolve_dashboard(
     client: Any, identifier: str
 ) -> tuple[dict[str, str] | None, list[dict[str, Any]] | None]:
@@ -2972,7 +3022,12 @@ class DashboardConfigTools:
     async def _resolve_set_dashboard_url_path(
         self, url_path: str
     ) -> tuple[str, str | None, list[dict[str, Any]] | None]:
-        """Validate + canonicalize ``url_path`` for ``ha_config_set_dashboard``.
+        """Validate the set target and canonicalize supported dashboard identifiers.
+
+        Hyphenless input is allowed only when it exactly matches an existing
+        dashboard's ``url_path`` (plus the built-in ``lovelace`` alias case).
+        New dashboard paths must contain a hyphen. An internal-ID-only match may
+        still canonicalize to a different, hyphenated existing ``url_path``.
 
         Returns ``(url_path, pre_resolved_from, pre_fetched_dashboards)``:
         ``url_path`` is canonicalized (``"default"`` -> ``"lovelace"``, and an
@@ -3004,22 +3059,17 @@ class DashboardConfigTools:
         if url_path == "default":
             url_path = "lovelace"
 
-        # Pre-resolve internal dashboard ID to url_path form before the
-        # hyphen check below, so callers may pass either form. Only fires
-        # when the identifier looks like an internal id (no hyphen, not
-        # the built-in "lovelace") and matches a known dashboard.
+        # Pre-resolve a hyphenless dashboard identifier before enforcing the
+        # exact-url-path exception below. Internal-ID support is preserved when
+        # it canonicalizes to a hyphenated existing path, but an ID-only match
+        # cannot exempt a different hyphenless path from validation.
         #
-        # Caveat: if a caller passes a hyphenless identifier intending
-        # to *create* a new dashboard, but it happens to match an
-        # existing dashboard's id, the rewrite silently re-targets the
-        # operation onto that existing dashboard. Pre-PR they'd have
-        # hit the hyphen-validation error and known their input was
-        # invalid; now the create-vs-update distinction depends on
-        # whether the registry happens to contain a matching id.
-        # We log the rewrite and surface the original identifier as
-        # ``resolved_from`` on the success response so callers can
-        # detect this redirect.
+        # This is still a create-or-update API: a caller intending to create a
+        # dashboard can target an existing one, either by exact url_path or by a
+        # supported internal-ID rewrite. ``action`` reports create vs update;
+        # ``resolved_from`` additionally reports only the latter rewrite.
         pre_resolved_from: str | None = None
+        exact_url_path_exists = False
         # When the pre-resolver fires and finds a match, ``_resolve_dashboard``
         # has already fetched ``lovelace/dashboards/list``. Capture that list
         # so the existence-check site below can reuse it instead of paying
@@ -3027,29 +3077,37 @@ class DashboardConfigTools:
         pre_fetched_dashboards: list[dict[str, Any]] | None = None
         if "-" not in url_path and url_path != "lovelace":
             resolved, dashboards = await _resolve_dashboard(self._client, url_path)
+            if dashboards is None:
+                _raise_dashboard_registry_read_error(action="set", url_path=url_path)
             if resolved is not None and resolved["url_path"]:
-                original_url_path = url_path
-                url_path = resolved["url_path"]
-                pre_resolved_from = original_url_path
+                exact_url_path_exists = resolved["url_path"] == url_path
                 pre_fetched_dashboards = dashboards
-                logger.info(
-                    "ha_config_set_dashboard pre-resolver mapped %r -> %r",
-                    original_url_path,
-                    url_path,
-                )
+                if not exact_url_path_exists and "-" in resolved["url_path"]:
+                    original_url_path = url_path
+                    url_path = resolved["url_path"]
+                    pre_resolved_from = original_url_path
+                    logger.info(
+                        "ha_config_set_dashboard pre-resolver mapped %r -> %r",
+                        original_url_path,
+                        url_path,
+                    )
 
-        # Validate url_path contains hyphen for new dashboards
+        # Existing exact url_path values may predate HA's creation rule and must
+        # remain valid update targets unchanged.
         # The built-in "lovelace" dashboard is exempt since it already exists
-        if "-" not in url_path and url_path != "lovelace":
+        if not exact_url_path_exists and "-" not in url_path and url_path != "lovelace":
+            suggestions = [
+                "Use format like 'my-dashboard' or 'mobile-view'",
+                "Use 'lovelace' or 'default' to edit the default dashboard",
+            ]
+            hyphenated_url_path = url_path.replace("_", "-")
+            if hyphenated_url_path != url_path:
+                suggestions.insert(0, f"Try '{hyphenated_url_path}' instead")
             raise_tool_error(
                 create_error_response(
                     ErrorCode.VALIDATION_INVALID_PARAMETER,
                     "url_path must contain a hyphen (-)",
-                    suggestions=[
-                        f"Try '{url_path.replace('_', '-')}' instead",
-                        "Use format like 'my-dashboard' or 'mobile-view'",
-                        "Use 'lovelace' or 'default' to edit the default dashboard",
-                    ],
+                    suggestions=suggestions,
                     context={"action": "set", "url_path": url_path},
                 )
             )
@@ -3102,6 +3160,7 @@ class DashboardConfigTools:
         url_path: str, python_transform: str, current_config: dict[str, Any]
     ) -> dict[str, Any]:
         """Run ``python_transform`` against ``current_config`` in the sandbox."""
+        was_strategy_dashboard = "strategy" in current_config
         try:
             transformed_config = safe_execute(python_transform, current_config)
         except PythonSandboxError as e:
@@ -3127,6 +3186,12 @@ class DashboardConfigTools:
                     context={"action": "python_transform", "url_path": url_path},
                 )
             )
+        DashboardConfigTools._validate_strategy_dashboard_replacement(
+            url_path,
+            was_strategy_dashboard=was_strategy_dashboard,
+            replacement_config=transformed_config,
+            action="python_transform",
+        )
         return transformed_config
 
     async def _save_dashboard_python_transform(
@@ -3255,7 +3320,10 @@ class DashboardConfigTools:
         if pre_fetched_dashboards is not None:
             existing_dashboards = pre_fetched_dashboards
         else:
-            existing_dashboards = await fetch_dashboards_list(self._client) or []
+            fetched_dashboards = await fetch_dashboards_list(self._client)
+            if fetched_dashboards is None:
+                _raise_dashboard_registry_read_error(action="set", url_path=url_path)
+            existing_dashboards = fetched_dashboards
         dashboard_exists = any(
             d.get("url_path") == url_path for d in existing_dashboards
         )
@@ -3344,7 +3412,7 @@ class DashboardConfigTools:
     ) -> tuple[str | None, bool, str | None]:
         """Update metadata for an existing dashboard if any metadata params were provided.
 
-        Returns ``(dashboard_id, metadata_updated, hint)``.
+        Returns ``(dashboard_id, metadata_updated, warning)``.
         """
         dashboard_id = None
         for dashboard in existing_dashboards:
@@ -3370,13 +3438,13 @@ class DashboardConfigTools:
         if metadata_update_fields and dashboard_id is None:
             # Dashboard ID not found in storage list (e.g. default lovelace on
             # fresh installs). Metadata update via lovelace/dashboards/update
-            # is not possible without a storage ID — config update still proceeds.
-            hint = (
+            # is not possible without a storage ID. The caller either proceeds
+            # with a requested config write or rejects the resulting no-op.
+            warning = (
                 "Metadata fields were provided but could not be applied: "
-                "dashboard has no storage ID (likely the built-in default dashboard). "
-                "Config changes were still saved."
+                "dashboard has no storage ID (likely the built-in default dashboard)."
             )
-            return dashboard_id, False, hint
+            return dashboard_id, False, warning
         return dashboard_id, False, None
 
     async def _ensure_dashboard_exists(
@@ -3391,7 +3459,7 @@ class DashboardConfigTools:
     ) -> tuple[bool, str | None, bool, str | None]:
         """Create the dashboard if missing, else update its metadata if requested.
 
-        Returns ``(dashboard_exists, dashboard_id, metadata_updated, hint)`` —
+        Returns ``(dashboard_exists, dashboard_id, metadata_updated, warning)`` —
         ``dashboard_exists`` reflects state *before* this call, so the caller
         can distinguish create vs update for the response's
         ``action``/``dashboard_created`` fields.
@@ -3409,7 +3477,7 @@ class DashboardConfigTools:
             )
             return dashboard_exists, dashboard_id, False, None
 
-        dashboard_id, metadata_updated, hint = await self._update_dashboard_metadata(
+        dashboard_id, metadata_updated, warning = await self._update_dashboard_metadata(
             url_path,
             existing_dashboards,
             title=title,
@@ -3417,43 +3485,56 @@ class DashboardConfigTools:
             require_admin=require_admin,
             show_in_sidebar=show_in_sidebar,
         )
-        return dashboard_exists, dashboard_id, metadata_updated, hint
+        return dashboard_exists, dashboard_id, metadata_updated, warning
 
     async def _check_dashboard_replace_hash(
-        self, url_path: str, config_hash: str | None
+        self,
+        url_path: str,
+        config_hash: str | None,
+        replacement_config: dict[str, Any],
     ) -> str | None:
-        """Optionally validate config_hash and warn on large full-config replacement.
-
-        Tolerates fetch failures — full replacement still proceeds even if the
-        pre-read can't load the current state (force-replace path).
+        """Validate replacement safety/hash and warn on large full-config replacement.
+
+        Omitting ``config_hash`` remains the force-replace path, but the current
+        config must still be readable so strategy-dashboard protection can be
+        evaluated before any replacement write. The one exception is an existing
+        storage dashboard with no config yet and no supplied ``config_hash``:
+        there is no strategy state to protect, so its first full config may be
+        written. A supplied hash still conflicts with the now-absent config.
         """
         try:
             existing_config, existing_hash = await _get_dashboard_config_internal(
                 self._client, url_path
             )
-        except ToolError:
-            # Pre-read failure is non-fatal on the force-replace path: skip
-            # the optimistic-lock check and large-config warning and proceed
-            # with the replacement.
-            return None
-
-        if not isinstance(existing_config, dict):
-            return None
-
-        existing_config_size = len(json.dumps(existing_config))
-        if config_hash is not None and existing_hash != config_hash:
+        except ToolError as exc:
+            if _is_no_stored_dashboard_config_error(exc):
+                if config_hash is None:
+                    return None
+                self._raise_dashboard_hash_conflict(url_path)
             raise_tool_error(
                 create_error_response(
                     ErrorCode.SERVICE_CALL_FAILED,
-                    "Dashboard modified since last read (conflict)",
+                    "Cannot verify the current dashboard config before full replacement",
+                    details=extract_tool_error_message(exc),
                     suggestions=[
-                        "Call ha_config_get_dashboard() again",
-                        "Use the fresh config_hash, or omit config_hash to force replace",
+                        "Retry the operation",
+                        "Read the dashboard with ha_config_get_dashboard first",
                     ],
                     context={"action": "set", "url_path": url_path},
                 )
             )
 
+        existing_config_size = len(json.dumps(existing_config))
+        if config_hash is not None and existing_hash != config_hash:
+            self._raise_dashboard_hash_conflict(url_path)
+
+        self._validate_strategy_dashboard_replacement(
+            url_path,
+            was_strategy_dashboard="strategy" in existing_config,
+            replacement_config=replacement_config,
+            action="config",
+        )
+
         if existing_config_size >= 10000:
             return (
                 f"Replaced large config ({existing_config_size:,} bytes). "
@@ -3461,6 +3542,44 @@ class DashboardConfigTools:
             )
         return None
 
+    @staticmethod
+    def _raise_dashboard_hash_conflict(url_path: str) -> NoReturn:
+        """Raise the shared optimistic-lock conflict for a full replacement."""
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.SERVICE_CALL_FAILED,
+                "Dashboard modified since last read (conflict)",
+                suggestions=[
+                    "Call ha_config_get_dashboard() again",
+                    "Use the fresh config_hash, or omit config_hash to force replace",
+                ],
+                context={"action": "set", "url_path": url_path},
+            )
+        )
+
+    @staticmethod
+    def _validate_strategy_dashboard_replacement(
+        url_path: str,
+        *,
+        was_strategy_dashboard: bool,
+        replacement_config: dict[str, Any],
+        action: str,
+    ) -> None:
+        """Prevent this tool from taking control of a strategy dashboard."""
+        if not was_strategy_dashboard or "strategy" in replacement_config:
+            return
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.VALIDATION_FAILED,
+                "Strategy dashboards cannot be converted to custom dashboards via this tool",
+                suggestions=[
+                    "Use 'Take Control' in the Home Assistant interface to convert it",
+                    "Keep a strategy configuration when updating this dashboard",
+                ],
+                context={"action": action, "url_path": url_path},
+            )
+        )
+
     async def _save_dashboard_config(
         self, url_path: str, config_dict: dict[str, Any]
     ) -> None:
@@ -3499,7 +3618,7 @@ class DashboardConfigTools:
     ) -> tuple[bool, str | None, dict[str, Any]]:
         """Parse + validate ``config`` and save it as a full replacement.
 
-        Returns ``(config_updated, hint, saved_config)``.
+        Returns ``(config_updated, warning, saved_config)``.
         """
         parsed_config = parse_json_param(config, "config")
         if parsed_config is None or not isinstance(parsed_config, dict):
@@ -3515,12 +3634,14 @@ class DashboardConfigTools:
             )
         config_dict = cast(dict[str, Any], parsed_config)
 
-        hint: str | None = None
+        warning: str | None = None
         if dashboard_exists:
-            hint = await self._check_dashboard_replace_hash(url_path, config_hash)
+            warning = await self._check_dashboard_replace_hash(
+                url_path, config_hash, config_dict
+            )
 
         await self._save_dashboard_config(url_path, config_dict)
-        return True, hint, config_dict
+        return True, warning, config_dict
 
     async def _run_dashboard_config_update(
         self,
@@ -3543,7 +3664,7 @@ class DashboardConfigTools:
             dashboard_exists,
             dashboard_id,
             metadata_updated,
-            hint,
+            metadata_warning,
         ) = await self._ensure_dashboard_exists(
             url_path,
             title=title,
@@ -3555,16 +3676,49 @@ class DashboardConfigTools:
 
         config_updated = False
         render_config: dict[str, Any] | None = None
+        warnings: list[str] = []
         if config is not None:
             (
                 config_updated,
-                config_hint,
+                config_warning,
                 render_config,
             ) = await self._apply_dashboard_config(
                 url_path, config, config_hash, dashboard_exists
             )
-            if config_hint:
-                hint = config_hint
+            if config_warning:
+                warnings.append(config_warning)
+
+        if dashboard_exists and not config_updated and not metadata_updated:
+            if metadata_warning is not None:
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.SERVICE_CALL_FAILED,
+                        "No dashboard changes were applied",
+                        details=metadata_warning,
+                        suggestions=[
+                            "Use a storage-mode dashboard when changing metadata",
+                            "Provide config to replace the dashboard configuration",
+                        ],
+                        context={"action": "set", "url_path": url_path},
+                    )
+                )
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.VALIDATION_INVALID_PARAMETER,
+                    "No dashboard changes were requested",
+                    suggestions=[
+                        "Provide config or python_transform to change dashboard content",
+                        "Provide a metadata field such as title or icon",
+                        "Use ha_config_get_dashboard to read a dashboard without changing it",
+                    ],
+                    context={"action": "set", "url_path": url_path},
+                )
+            )
+
+        if metadata_warning:
+            if config_updated:
+                metadata_warning = f"{metadata_warning} Dashboard config was saved."
+            warnings.insert(0, metadata_warning)
 
         result_dict: dict[str, Any] = {
             "success": True,
@@ -3577,13 +3731,12 @@ class DashboardConfigTools:
             "message": f"Dashboard {url_path} {'created' if not dashboard_exists else 'updated'} successfully",
         }
 
-        if hint:
-            result_dict["hint"] = hint
+        if warnings:
+            result_dict["warnings"] = warnings
         if pre_resolved_from is not None:
-            # Caller passed an internal id; pre-resolver mapped it to
-            # the canonical url_path. Surface the original so a caller
-            # who *intended* to create a new dashboard can detect that
-            # an existing dashboard was updated instead.
+            # This marks identifier canonicalization only. Exact url_path
+            # matches deliberately omit it; callers use ``action`` to tell
+            # whether the create-or-update operation updated an existing target.
             result_dict["resolved_from"] = pre_resolved_from
 
         render_config = await _attach_dashboard_render_paths_after_write(
@@ -3651,11 +3804,11 @@ class DashboardConfigTools:
                 context={"action": "delete"},
             )
             resolved, dashboards = await _resolve_dashboard(self._client, url_path)
+            if dashboards is None:
+                _raise_dashboard_registry_read_error(action="delete", url_path=url_path)
             if resolved is None:
                 available_ids = [
-                    d.get("url_path")
-                    for d in (dashboards or [])[:10]
-                    if d.get("url_path")
+                    d.get("url_path") for d in dashboards[:10] if d.get("url_path")
                 ]
                 raise_tool_error(
                     create_error_response(

{ha_mcp_dev-8.1.1.dev2289 → ha_mcp_dev-8.1.1.dev2292/src/ha_mcp_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 8.1.1.dev2289
+Version: 8.1.1.dev2292
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Author-email: Julien <github@qc-h.net>
 License: MIT