boneio 1.2.0.dev8__tar.gz → 1.2.0.dev10__tar.gz

{boneio-1.2.0.dev8/boneio.egg-info → boneio-1.2.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.2.0.dev8
+Version: 1.2.0.dev10
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

boneio-1.2.0.dev10/boneio/core/config/migrations/__init__.py

@@ -0,0 +1,222 @@
+"""Configuration migration system for boneIO.
+
+Migrations are versioned and executed once per config file.
+The config_version field in the boneio section tracks which
+migrations have already been applied.
+
+Each migration module registers itself via the @register_migration decorator.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass, field
+from typing import Callable
+
+_LOGGER = logging.getLogger(__name__)
+
+# Current schema version — bump this when adding new migrations
+CURRENT_SCHEMA_VERSION = 2
+
+
+@dataclass
+class Migration:
+    """A single config migration step.
+
+    Attributes:
+        version: Target schema version after this migration.
+        name: Human-readable description.
+        migrate_dict: Transforms the raw config dict in memory.
+        migrate_file: Optional — persists changes directly in the YAML file.
+    """
+
+    version: int
+    name: str
+    migrate_dict: Callable[[dict], dict]
+    migrate_file: Callable[[str], None] | None = None
+
+
+# Global ordered registry of migrations
+_MIGRATIONS: list[Migration] = []
+
+
+def register_migration(
+    version: int,
+    name: str,
+    migrate_file: Callable[[str], None] | None = None,
+) -> Callable:
+    """Decorator to register a dict migration function.
+
+    Args:
+        version: Target schema version after this migration.
+        name: Human-readable description.
+        migrate_file: Optional file-level persistence function.
+
+    Returns:
+        Decorator that registers the function and returns it unchanged.
+    """
+
+    def decorator(fn: Callable[[dict], dict]) -> Callable[[dict], dict]:
+        _MIGRATIONS.append(
+            Migration(
+                version=version,
+                name=name,
+                migrate_dict=fn,
+                migrate_file=migrate_file,
+            )
+        )
+        # Keep sorted by version
+        _MIGRATIONS.sort(key=lambda m: m.version)
+        return fn
+
+    return decorator
+
+
+def get_config_version(doc: dict) -> int:
+    """Read config_version from the boneio section (default 0).
+
+    Args:
+        doc: Raw config dict.
+
+    Returns:
+        Current config version number.
+    """
+    boneio = doc.get("boneio")
+    if isinstance(boneio, dict):
+        return boneio.get("config_version", 0)
+    return 0
+
+
+def run_migrations(
+    doc: dict,
+    from_version: int | None = None,
+    config_file: str | None = None,
+) -> tuple[dict, int]:
+    """Run all pending migrations on a config dict.
+
+    Args:
+        doc: Raw config dict (will be mutated in place).
+        from_version: Override starting version (default: read from doc).
+        config_file: If provided, also persist file-level migrations
+                     and update config_version in the file.
+
+    Returns:
+        Tuple of (migrated dict, new config_version).
+    """
+    if from_version is None:
+        from_version = get_config_version(doc)
+
+    if from_version >= CURRENT_SCHEMA_VERSION:
+        return doc, from_version
+
+    applied: list[str] = []
+
+    for migration in _MIGRATIONS:
+        if migration.version <= from_version:
+            continue
+        if migration.version > CURRENT_SCHEMA_VERSION:
+            break
+
+        _LOGGER.info(
+            "Running migration v%d: %s", migration.version, migration.name
+        )
+        doc = migration.migrate_dict(doc)
+        applied.append(f"v{migration.version}: {migration.name}")
+
+        # Persist file-level changes
+        if config_file and migration.migrate_file:
+            try:
+                migration.migrate_file(config_file)
+            except Exception as e:
+                _LOGGER.error(
+                    "Failed to persist migration v%d to file: %s",
+                    migration.version,
+                    e,
+                )
+
+    new_version = CURRENT_SCHEMA_VERSION
+
+    if applied:
+        _LOGGER.info("Migrations applied: %s", ", ".join(applied))
+
+        # Persist config_version to file
+        if config_file:
+            try:
+                _persist_config_version(config_file, new_version)
+            except Exception as e:
+                _LOGGER.error("Failed to persist config_version: %s", e)
+
+    # Update in-memory dict
+    if "boneio" not in doc or not isinstance(doc.get("boneio"), dict):
+        doc["boneio"] = {}
+    doc["boneio"]["config_version"] = new_version
+
+    return doc, new_version
+
+
+def _persist_config_version(config_file: str, version: int) -> None:
+    """Write config_version into the boneio section of the YAML file.
+
+    Handles three cases:
+    - config_version already exists → update value
+    - boneio section exists but no config_version → insert after 'boneio:'
+    - no boneio section → skip (shouldn't happen in practice)
+
+    Args:
+        config_file: Path to the YAML config file.
+        version: New config_version value to write.
+    """
+    with open(config_file, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+
+    updated_lines: list[str] = []
+    version_written = False
+    in_boneio = False
+    boneio_indent = -1
+    config_version_re = re.compile(r"^(\s*)config_version:\s*\d+")
+
+    for i, line in enumerate(lines):
+        stripped = line.rstrip()
+
+        # Check if we're entering the boneio section
+        if stripped == "boneio:" or stripped.startswith("boneio:"):
+            in_boneio = True
+            boneio_indent = len(line) - len(line.lstrip())
+            updated_lines.append(line)
+            continue
+
+        if in_boneio and not version_written:
+            line_indent = len(line) - len(line.lstrip())
+
+            # Existing config_version line — replace it
+            if config_version_re.match(line):
+                indent = " " * (boneio_indent + 2)
+                updated_lines.append(f"{indent}config_version: {version}\n")
+                version_written = True
+                continue
+
+            # Left the boneio section (non-empty line at same or lower indent)
+            if stripped and line_indent <= boneio_indent and i > 0:
+                # Insert config_version before leaving
+                indent = " " * (boneio_indent + 2)
+                updated_lines.append(f"{indent}config_version: {version}\n")
+                version_written = True
+                in_boneio = False
+
+        updated_lines.append(line)
+
+    # If boneio was the last section and we haven't written yet
+    if in_boneio and not version_written:
+        indent = " " * (boneio_indent + 2)
+        updated_lines.append(f"{indent}config_version: {version}\n")
+
+    with open(config_file, "w", encoding="utf-8") as f:
+        f.writelines(updated_lines)
+
+    _LOGGER.info("Persisted config_version: %d to %s", version, config_file)
+
+
+# Import migration modules to trigger registration
+from boneio.core.config.migrations import v1_proxy_port  # noqa: E402, F401
+from boneio.core.config.migrations import v2_transition  # noqa: E402, F401

boneio-1.2.0.dev10/boneio/core/config/migrations/v1_proxy_port.py

@@ -0,0 +1,75 @@
+"""Migration v1: Rename deprecated config fields.
+
+- web.nginx_proxy_port -> web.proxy_port
+- modbus_sensors -> modbus_devices (warning only, no rename)
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+
+from boneio.core.config.migrations import register_migration
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _persist_proxy_port(config_file: str) -> None:
+    """Replace nginx_proxy_port with proxy_port in the YAML file.
+
+    Args:
+        config_file: Path to the YAML config file.
+    """
+    with open(config_file, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+
+    updated = False
+    updated_lines: list[str] = []
+    for line in lines:
+        if "nginx_proxy_port:" in line:
+            indent = len(line) - len(line.lstrip())
+            value_part = line.split("nginx_proxy_port:", 1)[1]
+            new_line = " " * indent + "proxy_port:" + value_part
+            updated_lines.append(new_line)
+            updated = True
+            _LOGGER.info(
+                "Replaced in config file: %s -> %s",
+                line.rstrip(),
+                new_line.rstrip(),
+            )
+        else:
+            updated_lines.append(line)
+
+    if updated:
+        with open(config_file, "w", encoding="utf-8") as f:
+            f.writelines(updated_lines)
+
+
+@register_migration(
+    version=1,
+    name="nginx_proxy_port -> proxy_port, modbus_sensors deprecation",
+    migrate_file=_persist_proxy_port,
+)
+def migrate(doc: dict) -> dict:
+    """Migrate web.nginx_proxy_port to web.proxy_port and warn about modbus_sensors.
+
+    Args:
+        doc: Raw config dict.
+
+    Returns:
+        Migrated config dict.
+    """
+    # web.nginx_proxy_port -> web.proxy_port
+    if "web" in doc and isinstance(doc["web"], dict):
+        if "nginx_proxy_port" in doc["web"]:
+            _LOGGER.info("Migrating 'web.nginx_proxy_port' to 'web.proxy_port'")
+            doc["web"]["proxy_port"] = doc["web"].pop("nginx_proxy_port")
+
+    # modbus_sensors -> modbus_devices (warning only)
+    if "modbus_sensors" in doc:
+        _LOGGER.warning(
+            "Modbus sensors are renamed to modbus_devices. "
+            "Please update your config."
+        )
+
+    return doc

boneio-1.2.0.dev10/boneio/core/config/migrations/v2_transition.py

@@ -0,0 +1,94 @@
+"""Migration v2: Convert transition field from float to timeperiod string.
+
+Before: transition: 2 (bare number, interpreted as seconds)
+After:  transition: 2s (timeperiod string with unit)
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+
+from boneio.core.config.migrations import register_migration
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _persist_transition(config_file: str) -> None:
+    """Replace bare-number transition values with timeperiod strings in YAML file.
+
+    Matches lines like ``transition: 2`` or ``transition: 0.5`` and appends ``s``.
+
+    Args:
+        config_file: Path to the YAML config file.
+    """
+    with open(config_file, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+
+    updated = False
+    updated_lines: list[str] = []
+    transition_re = re.compile(r"^(\s*transition:\s*)(\d+(?:\.\d+)?)\s*$")
+
+    for line in lines:
+        m = transition_re.match(line)
+        if m:
+            new_line = f"{m.group(1)}{m.group(2)}s\n"
+            updated_lines.append(new_line)
+            updated = True
+            _LOGGER.info(
+                "Replaced in config file: %s -> %s",
+                line.rstrip(),
+                new_line.rstrip(),
+            )
+        else:
+            updated_lines.append(line)
+
+    if updated:
+        with open(config_file, "w", encoding="utf-8") as f:
+            f.writelines(updated_lines)
+
+
+@register_migration(
+    version=2,
+    name="transition: float -> timeperiod string",
+    migrate_file=_persist_transition,
+)
+def migrate(doc: dict) -> dict:
+    """Convert transition fields from int/float to timeperiod strings.
+
+    Walks through event and binary_sensor sections, finding action
+    definitions with a bare numeric transition value and converting
+    them to strings with an ``s`` suffix.
+
+    Args:
+        doc: Raw config dict.
+
+    Returns:
+        Migrated config dict.
+    """
+    for section_name in ("event", "binary_sensor"):
+        for item in doc.get(section_name, []) or []:
+            if not isinstance(item, dict):
+                continue
+            actions = item.get("actions")
+            if not isinstance(actions, dict):
+                continue
+            for _click_type, action_list in actions.items():
+                if not isinstance(action_list, list):
+                    continue
+                for action_def in action_list:
+                    if not isinstance(action_def, dict):
+                        continue
+                    if "transition" in action_def:
+                        val = action_def["transition"]
+                        if isinstance(val, (int, float)):
+                            new_val = f"{val}s"
+                            _LOGGER.info(
+                                "Migrating transition: %s -> '%s' in %s action",
+                                val,
+                                new_val,
+                                section_name,
+                            )
+                            action_def["transition"] = new_val
+
+    return doc

{boneio-1.2.0.dev8 → boneio-1.2.0.dev10}/boneio/core/config/yaml_util.py

@@ -724,84 +724,32 @@ class CustomValidator(Validator):
 
 
 
-def _migrate_config(doc: dict, config_file: str | None = None) -> tuple[dict, bool]:
-    """
-    Apply configuration migrations for backward compatibility.
-    
+def _run_config_migrations(doc: dict, config_file: str | None = None) -> tuple[dict, bool]:
+    """Run versioned config migrations via the migrations module.
+
+    Migrations are only applied if config_version < CURRENT_SCHEMA_VERSION.
+    When config_file is provided, changes are persisted to the YAML file
+    and config_version is updated so migrations won't run again.
+
     Args:
-        doc: Configuration document to migrate
-        config_file: Optional path to config file for persisting migrations
-        
+        doc: Raw configuration dict (mutated in place).
+        config_file: Optional path to config file for persistence.
+
     Returns:
-        Tuple of (migrated configuration document, whether migrations were applied)
+        Tuple of (migrated dict, whether any migrations were applied).
     """
-    migrated = False
-    migrations_applied = []
-    
-    # Migration: nginx_proxy_port -> proxy_port in web section
-    if "web" in doc and isinstance(doc["web"], dict):
-        if "nginx_proxy_port" in doc["web"]:
-            _LOGGER.info("Migrating 'web.nginx_proxy_port' to 'web.proxy_port'")
-            doc["web"]["proxy_port"] = doc["web"].pop("nginx_proxy_port")
-            migrated = True
-            migrations_applied.append("web.nginx_proxy_port -> web.proxy_port")
-    
-    # Migration: modbus_sensors -> modbus_devices
-    if "modbus_sensors" in doc:
-        _LOGGER.warning("Modbus sensors are renamed to modbus_devices. Please update your config.")
-        migrated = True
-        migrations_applied.append("modbus_sensors -> modbus_devices")
-    
-    if migrated:
-        _LOGGER.info("Configuration migrations applied: %s", ", ".join(migrations_applied))
-        
-        # Persist migrations to config file if provided
-        if config_file:
-            try:
-                _persist_migrations(config_file, doc, migrations_applied)
-            except Exception as e:
-                _LOGGER.error("Failed to persist migrations to config file: %s", e)
-    
-    return doc, migrated
+    from boneio.core.config.migrations import (
+        CURRENT_SCHEMA_VERSION,
+        get_config_version,
+        run_migrations,
+    )
 
+    current_version = get_config_version(doc)
+    if current_version >= CURRENT_SCHEMA_VERSION:
+        return doc, False
 
-def _persist_migrations(config_file: str, migrated_doc: dict, migrations: list[str]) -> None:
-    """
-    Persist migrated configuration back to YAML file.
-    
-    Args:
-        config_file: Path to config file
-        migrated_doc: Migrated configuration document
-        migrations: List of applied migrations for logging
-    """
-    import os
-    from pathlib import Path
-    
-    config_dir = Path(config_file).parent
-    
-    # Read original file to preserve structure and !include directives
-    with open(config_file, 'r', encoding='utf-8') as f:
-        original_lines = f.readlines()
-    
-    # For web.nginx_proxy_port -> web.proxy_port migration
-    if any("nginx_proxy_port" in m for m in migrations):
-        updated_lines = []
-        for line in original_lines:
-            # Replace nginx_proxy_port with proxy_port in the line
-            if "nginx_proxy_port:" in line:
-                indent = len(line) - len(line.lstrip())
-                value_part = line.split("nginx_proxy_port:", 1)[1]
-                updated_line = " " * indent + "proxy_port:" + value_part
-                updated_lines.append(updated_line)
-                _LOGGER.info("Replaced line in config file: %s -> %s", line.rstrip(), updated_line.rstrip())
-            else:
-                updated_lines.append(line)
-        
-        # Write back to file
-        with open(config_file, 'w', encoding='utf-8') as f:
-            f.writelines(updated_lines)
-        
-        _LOGGER.info("Persisted migrations to config file: %s", config_file)
+    doc, new_version = run_migrations(doc, current_version, config_file)
+    return doc, new_version > current_version
 
 
 def load_config_from_string(config_str: str) -> dict:
@@ -809,11 +757,12 @@ def load_config_from_string(config_str: str) -> dict:
     schema = _get_schema()  # Use cached schema instead of loading every time
     v = CustomValidator(schema, purge_unknown=True)
 
-    # First normalize the document
-    doc = v.normalized(config_str, always_return_document=True)  # type: ignore[attr-defined]
+    # Apply migrations on raw dict BEFORE normalization/coercion
+    # (coerce: positive_time_period would fail on bare int like transition: 2)
+    migrated_str, _ = _run_config_migrations(config_str, config_file=None)
     
-    # Apply migrations (without persisting - that happens in load_config_from_file)
-    doc, _ = _migrate_config(doc, config_file=None)
+    # Normalize the document (applies coercion rules)
+    doc = v.normalized(migrated_str, always_return_document=True)  # type: ignore[attr-defined]
     
     # Then merge board config
     merged_doc = merge_board_config(doc)
@@ -847,11 +796,12 @@ def load_config_from_file(config_file: str):
     schema = _get_schema()
     v = CustomValidator(schema, purge_unknown=True)
     
-    # First normalize the document
-    doc = v.normalized(config_yaml, always_return_document=True)  # type: ignore[attr-defined]
+    # Apply migrations on raw dict BEFORE normalization/coercion
+    # (coerce: positive_time_period would fail on bare int like transition: 2)
+    config_yaml, migrations_applied = _run_config_migrations(config_yaml, config_file=config_file)
     
-    # Apply migrations and persist to file if needed
-    doc, migrations_applied = _migrate_config(doc, config_file=config_file)
+    # Normalize the document (applies coercion rules)
+    doc = v.normalized(config_yaml, always_return_document=True)  # type: ignore[attr-defined]
     
     # Then merge board config
     merged_doc = merge_board_config(doc)

{boneio-1.2.0.dev8 → boneio-1.2.0.dev10}/boneio/core/manager/update.py

@@ -585,8 +585,10 @@ class UpdateManager(AsyncUpdater):
             target_version: Version being installed (None if not updating)
             progress: Update progress percentage (0 = not updating, 1-100 = in progress)
         """
-        # HA interprets 0/false as "not updating", 1-100 as "updating with progress"
-        in_progress_value: int | bool = progress if progress > 0 else False
+        # HA update entity progress:
+        # - in_progress: boolean (true = updating, false = idle)
+        # - update_percentage: float 0-100 (shows progress bar in HA UI)
+        is_updating = progress > 0
         
         state_payload = {
             "installed_version": current_version,
@@ -595,7 +597,8 @@ class UpdateManager(AsyncUpdater):
             "release_url": self._last_check_result.get("release_url", "") if self._last_check_result else "",
             "release_summary": self._last_check_result.get("release_notes", "") if self._last_check_result else "",
             "entity_picture": "http://boneio.eu/logo_fb_circle.png",
-            "in_progress": in_progress_value,
+            "in_progress": is_updating,
+            "update_percentage": float(progress) if is_updating else None,
         }
         
         topic_prefix = self._manager._config_helper.topic_prefix

{boneio-1.2.0.dev8 → boneio-1.2.0.dev10}/boneio/schema/schema.yaml

@@ -1325,6 +1325,12 @@ boneio:
   meta:
     label: "https://boneio.eu/docs/black/0.9.x-dev/configuration/boneio \n BoneIO configuration section. It's new section for boneIO Black. It enables you to use predefined device types. For now only 0.7 and 0.8 devices are supported."
   schema:
+    config_version:
+      type: integer
+      required: False
+      default: 0
+      meta:
+        label: Schema version for config migrations. Managed automatically.
     name:
       type: string
       required: True

boneio-1.2.0.dev10/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "1.2.0dev10"

{boneio-1.2.0.dev8 → boneio-1.2.0.dev10}/boneio/webui/app.py

@@ -696,6 +696,7 @@ if FRONTEND_DIR.exists() and (FRONTEND_DIR / "index.html").exists():
         return JSONResponse(
             content=manifest,
             media_type="application/manifest+json",
+            headers={"Cache-Control": "no-store, no-cache, must-revalidate"},
         )
 
     @app.get("/sw.js")
@@ -704,11 +705,17 @@ if FRONTEND_DIR.exists() and (FRONTEND_DIR / "index.html").exists():
         return FileResponse(
             f"{FRONTEND_DIR}/sw.js",
             media_type="application/javascript",
+            headers={"Cache-Control": "no-store, no-cache, must-revalidate"},
         )
 
     @app.get("/{filename:path}")
     async def serve_react_app(filename: str):
-        """Serve static files from frontend-dist, fallback to index.html for SPA routing."""
+        """Serve static files from frontend-dist, fallback to index.html for SPA routing.
+
+        Hashed assets (in /assets/) are immutable and cached long-term.
+        index.html (SPA fallback) is never cached to prevent stale versions
+        being served through Cloudflare Tunnel or other caching proxies.
+        """
         file_path = (FRONTEND_DIR / filename).resolve()
         if (
             filename
@@ -716,8 +723,18 @@ if FRONTEND_DIR.exists() and (FRONTEND_DIR / "index.html").exists():
             and file_path.exists()
             and file_path.is_file()
         ):
+            # Hashed assets can be cached forever
+            if filename.startswith("assets/"):
+                return FileResponse(
+                    str(file_path),
+                    headers={"Cache-Control": "public, max-age=31536000, immutable"},
+                )
             return FileResponse(str(file_path))
-        return FileResponse(f"{FRONTEND_DIR}/index.html")
+        # SPA fallback — never cache index.html
+        return FileResponse(
+            f"{FRONTEND_DIR}/index.html",
+            headers={"Cache-Control": "no-store, no-cache, must-revalidate"},
+        )
 else:
     _LOGGER.warning(
         f"Frontend not found at {FRONTEND_DIR}. "

{boneio-1.2.0.dev8/boneio/webui/schema → boneio-1.2.0.dev10/boneio/webui/frontend-dist/schem}/adc.schema.json

@@ -37,8 +37,8 @@
           },
           "update_interval": {
             "type": [
-              "number",
-              "string"
+              "string",
+              "number"
             ],
             "x-timeperiod": true,
             "default": "60s",