boneio 1.2.0.dev7__tar.gz → 1.2.0.dev9__tar.gz

{boneio-1.2.0.dev7/boneio.egg-info → boneio-1.2.0.dev9}/PKG-INFO

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

boneio-1.2.0.dev9/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.dev9/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.dev9/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.dev7 → boneio-1.2.0.dev9}/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.dev7 → boneio-1.2.0.dev9}/boneio/core/manager/manager.py

@@ -566,6 +566,13 @@ class Manager:
                             val = action_definition.get(opt_key)
                             if val is not None:
                                 parsed_action[opt_key] = val
+                        # Convert transition TimePeriod to float seconds
+                        if "transition" in parsed_action:
+                            t_val = parsed_action["transition"]
+                            if hasattr(t_val, "total_in_seconds"):
+                                parsed_action["transition"] = t_val.total_in_seconds
+                            elif not isinstance(t_val, (int, float)):
+                                parsed_action["transition"] = 0.0
                         _copy_long_press_meta(parsed_action, action_definition)
                         parsed_actions[click_type].append(parsed_action)
                         continue
@@ -739,6 +746,20 @@ class Manager:
                 output_id = action_definition.get("output_id")
                 action_output = action_definition.get("action_output", "TOGGLE")
                 
+                # Clamp transition to repeat_interval to avoid overlapping animations
+                transition_val = action_definition.get("transition")
+                if transition_val and action_definition.get("repeat"):
+                    repeat_interval = action_definition.get("repeat_interval")
+                    if repeat_interval:
+                        ri_seconds = repeat_interval.total_in_seconds if hasattr(repeat_interval, "total_in_seconds") else repeat_interval / 1000.0
+                        if transition_val > ri_seconds:
+                            _LOGGER.debug(
+                                "Clamping transition %.3fs to repeat_interval %.3fs",
+                                transition_val, ri_seconds,
+                            )
+                            transition_val = ri_seconds
+                    action_definition = {**action_definition, "transition": transition_val}
+                
                 if action_output == "CYCLE_COLOR":
                     await self.remote_devices.cycle_color(
                         device_id=remote_device_id,