boneio 1.5.0.dev19__tar.gz → 1.5.0.dev23__tar.gz

{boneio-1.5.0.dev19/boneio.egg-info → boneio-1.5.0.dev23}/PKG-INFO

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

{boneio-1.5.0.dev19 → boneio-1.5.0.dev23}/boneio/bonecli.py

@@ -217,6 +217,9 @@ def run(
     _t0 = _time.monotonic()
     setup_logging(debug_level=debug)
     _LOGGER.info("BoneIO %s starting.", __version__)
+    from boneio.core.config.yaml_compat import log_yaml_backend
+
+    log_yaml_backend()
     _LOGGER.debug("[STARTUP TIMING] after setup_logging: %.2fs", _time.monotonic() - _t0)
 
     # --- Initialize OLED before anything else (independent of config) ---

{boneio-1.5.0.dev19 → boneio-1.5.0.dev23}/boneio/components/cover/venetian.py

@@ -182,9 +182,12 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         self._last_update_time = time.monotonic()  # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
 
         # Tilt restore: schedule tilt recovery on the event loop.
+        # _tilt_before_close is only set by _save_tilt_for_restore() when
+        # the appropriate flag (UI or action) was enabled, so its presence
+        # is the authoritative signal that restore was requested.
         # Skip when position reached 0% (fully closed) or 100% (fully open)
         # — at extremes, restoring tilt contradicts user intent.
-        if self._tilt_restore_after_close and self._tilt_before_close is not None:
+        if self._tilt_before_close is not None:
             restore_tilt = self._tilt_before_close
             self._tilt_before_close = None
             at_extreme = self._position <= 0 or self._position >= 100
@@ -301,8 +304,8 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
     def _save_tilt_for_restore(self) -> None:
         """Save current tilt position for later restoration.
 
-        Called before any closing movement. Determines whether to save
-        based on the call source:
+        Called before any movement (open, close, or set_position).
+        Determines whether to save based on the call source:
         - UI/HA calls: uses tilt_restore_after_close setting
         - Action calls: uses _action_tilt_restore flag (set by executor)
         """
@@ -314,7 +317,7 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         if should_restore and self._tilt_position > 0:
             self._tilt_before_close = self._tilt_position
             _LOGGER.debug(
-                "VenetianCover %s: saving tilt=%d%% before close",
+                "VenetianCover %s: saving tilt=%d%% before movement",
                 self._id,
                 round(self._tilt_position),
             )
@@ -333,26 +336,22 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
     async def set_cover_position(self, position: int) -> None:
         """Set cover position with tilt restore support.
 
-        When moving to a lower position (closing direction) and
-        tilt_restore_after_close is enabled, saves the current tilt
-        so it can be restored after the movement finishes.
+        Saves the current tilt so it can be restored after the movement
+        finishes, regardless of direction (up or down).
 
         Args:
             position: Target position (0-100).
         """
-        if position < self._position:
-            self._save_tilt_for_restore()
-        else:
-            self._tilt_before_close = None
+        self._save_tilt_for_restore()
         await super().set_cover_position(position)
 
     async def open(self) -> None:
         """Open venetian cover.
 
-        Clears any saved tilt-before-close value since opening
-        resets the tilt to 100% naturally.
+        Saves the current tilt so it can be restored after the
+        opening movement finishes (same as close).
         """
-        self._tilt_before_close = None
+        self._save_tilt_for_restore()
         await super().open()
 
     def update_config_times(self, config: dict) -> None:

{boneio-1.5.0.dev19 → boneio-1.5.0.dev23}/boneio/core/config/config_helper.py

@@ -448,6 +448,26 @@ class ConfigHelper:
 
         return merged
 
+    def update_config_section(self, section: str, data: object) -> None:
+        """Update a single section in the in-memory config cache.
+
+        Fast path: modifies the cached dict directly without reloading
+        YAML from disk.  If the cache is not populated yet, this is a
+        no-op — the next ``get_config()`` call will load from file.
+
+        Args:
+            section: Top-level config key (e.g. ``"event"``, ``"output"``).
+            data: New value for that section (typically a ``list[dict]``).
+        """
+        if self._config_cache is None:
+            _LOGGER.debug(
+                "Config cache not populated, skipping in-place update for '%s'",
+                section,
+            )
+            return
+        self._config_cache[section] = data
+        _LOGGER.debug("Updated config section '%s' in-place", section)
+
     def get_section(self, section_name: str, force_reload: bool = False) -> Any:
         """Get a specific configuration section.
         

{boneio-1.5.0.dev19 → boneio-1.5.0.dev23}/boneio/core/config/migrations/v4_wled_cache.py

@@ -39,9 +39,11 @@ def _persist_wled_cache_strip(config_file: str) -> None:
     # First, find and extract WLED data from the in-memory parse
     # to save into .wled_cache.json before removing from YAML
     try:
-        from yaml import SafeLoader, load
+        from yaml import load
 
-        class IncludeLoader(SafeLoader):
+        from boneio.core.config.yaml_compat import FastSafeLoader
+
+        class IncludeLoader(FastSafeLoader):
             """YAML loader that preserves !include tags."""
 
         def _include_constructor(
@@ -70,7 +72,7 @@ def _persist_wled_cache_strip(config_file: str) -> None:
             include_path = config_dir / rd_section.filename
             if include_path.exists():
                 with open(include_path, encoding="utf-8") as f:
-                    rd_list = load(f, Loader=SafeLoader)  # noqa: S506
+                    rd_list = load(f, Loader=FastSafeLoader)  # noqa: S506
                 _strip_wled_fields_from_file(include_path, rd_list, config_dir)
             return
 

{boneio-1.5.0.dev19 → boneio-1.5.0.dev23}/boneio/core/config/schema_converter.py

@@ -6,10 +6,18 @@ import os
 from typing import IO, Any, Union
 
 import yaml
-from yaml import SafeLoader, load
+from yaml import load
 
+# Prefer the libyaml-backed loader when available (~10x faster). Imported
+# directly instead of via boneio.core.config.yaml_compat because this module
+# must stay importable without the full boneIO dependency graph (CI).
+try:
+    from yaml import CSafeLoader as _BaseLoader
+except ImportError:  # pragma: no cover - PyYAML built without libyaml
+    from yaml import SafeLoader as _BaseLoader  # type: ignore[assignment]
 
-class BoneIOLoader(SafeLoader):
+
+class BoneIOLoader(_BaseLoader):  # type: ignore[misc]
     """Custom YAML loader with !include constructor."""
     
     def __init__(self, stream: Union[str, IO]):

boneio-1.5.0.dev23/boneio/core/config/yaml_compat.py

@@ -0,0 +1,45 @@
+"""PyYAML backend selection.
+
+PyYAML ships two implementations: a pure-Python parser/emitter and a much
+faster one backed by the C library ``libyaml`` (``CSafeLoader`` /
+``CSafeDumper``). The C backend is roughly 10x faster at parsing and 5x
+faster at emitting, which matters a lot on the BeagleBone Black where the
+pure-Python parser needs several seconds for the boneIO schema.
+
+This module exposes ``FastSafeLoader`` / ``FastSafeDumper`` which resolve to
+the C implementation when available and fall back to the pure-Python one
+otherwise. It intentionally imports nothing besides ``yaml`` so it can also
+be used by standalone tooling (e.g. the schema converter run in CI).
+"""
+
+from __future__ import annotations
+
+import logging
+
+try:
+    from yaml import CSafeDumper as FastSafeDumper
+    from yaml import CSafeLoader as FastSafeLoader
+
+    HAS_LIBYAML = True
+except ImportError:  # pragma: no cover - depends on the installed PyYAML build
+    from yaml import SafeDumper as FastSafeDumper  # type: ignore[assignment]
+    from yaml import SafeLoader as FastSafeLoader  # type: ignore[assignment]
+
+    HAS_LIBYAML = False
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def log_yaml_backend() -> None:
+    """Log which PyYAML backend is in use.
+
+    Call this once during startup so slow installations (PyYAML built
+    without libyaml) can be spotted in the logs.
+    """
+    if HAS_LIBYAML:
+        _LOGGER.debug("Using libyaml (C) PyYAML backend")
+        return
+    _LOGGER.warning(
+        "PyYAML was built without libyaml — YAML parsing will be ~10x slower. "
+        "Install libyaml-dev and reinstall PyYAML to speed up config handling."
+    )