boneio 1.5.0.dev22__tar.gz → 1.5.0.dev24__tar.gz

{boneio-1.5.0.dev22/boneio.egg-info → boneio-1.5.0.dev24}/PKG-INFO

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

{boneio-1.5.0.dev22 → boneio-1.5.0.dev24}/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.dev22 → boneio-1.5.0.dev24}/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.dev22 → boneio-1.5.0.dev24}/boneio/core/cloud/registration.py

@@ -7,18 +7,19 @@ for PWA support with custom subdomains.
 
 import asyncio
 import base64
+from datetime import datetime, timezone
 import hashlib
 import hmac
+from importlib.resources import files
 import logging
 import os
+import re
 import shutil
 import subprocess
 from contextlib import suppress
 from pathlib import Path
-from typing import TYPE_CHECKING
 
-if TYPE_CHECKING:
-    import aiohttp
+import aiohttp
 
 from boneio.core.cloud.secrets import MASTER_SECRET as DEFAULT_MASTER_SECRET
 from boneio.core.system.monitor import get_network_info
@@ -152,10 +153,8 @@ class CloudRegistration:
         """
         return {"Authorization": f"Bearer {self._compute_token()}"}
 
-    async def _get_session(self) -> "aiohttp.ClientSession":
+    async def _get_session(self) -> aiohttp.ClientSession:
         """Get or create aiohttp session."""
-        import aiohttp
-
         if self._session is None or self._session.closed:
             self._session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=30))
         return self._session
@@ -205,8 +204,6 @@ class CloudRegistration:
         Returns:
             True if registration was successful
         """
-        import aiohttp
-
         try:
             session = await self._get_session()
 
@@ -250,8 +247,6 @@ class CloudRegistration:
         Returns:
             True if certificate was fetched successfully
         """
-        import aiohttp
-
         try:
             session = await self._get_session()
 
@@ -327,8 +322,7 @@ class CloudRegistration:
             # Output format: "notAfter=Jun  3 12:00:00 2026 GMT"
             line = result.stdout.strip()
             date_str = line.split("=", 1)[1]
-
-            from datetime import datetime, timezone
+            date_str = re.sub(r"\s+", " ", date_str.strip())
 
             expiry = datetime.strptime(date_str, "%b %d %H:%M:%S %Y %Z").replace(
                 tzinfo=timezone.utc
@@ -373,8 +367,6 @@ class CloudRegistration:
         """
         dest = CADDY_CONFIG_DIR / "init-certs-cloud.sh"
         try:
-            from importlib.resources import files
-
             src = files("boneio.core.cloud.data").joinpath("init-certs-cloud.sh")
             src_bytes = src.read_bytes()
 
@@ -445,8 +437,6 @@ class CloudRegistration:
                 _LOGGER.info("Backed up docker-compose.yaml to %s", backup)
 
             # Replace with bundled cloud template
-            from importlib.resources import files
-
             cloud_src = files("boneio.core.cloud.data").joinpath("docker-compose-cloud.yaml")
             cloud_content = cloud_src.read_text(encoding="utf-8")
             compose_file.write_text(cloud_content)
@@ -484,8 +474,6 @@ class CloudRegistration:
             if not self._check_compose_writable():
                 return False
 
-            from importlib.resources import files
-
             src = files("boneio.core.cloud.data").joinpath("docker-compose.yaml")
             original_content = src.read_text(encoding="utf-8")
 
@@ -515,9 +503,10 @@ class CloudRegistration:
 
     async def _recreate_caddy(self) -> bool:
         """
-        Recreate Caddy container to apply new docker-compose config.
+        Recreate and restart Caddy container to apply new certs or docker-compose config.
 
-        Uses 'docker compose up -d caddy' to pick up volume and entrypoint changes.
+        Uses 'docker compose up -d caddy' and 'docker compose restart caddy' to ensure
+        Caddy reloads updated SSL certificates from disk.
 
         Returns:
             True if recreate was successful
@@ -534,8 +523,19 @@ class CloudRegistration:
                 ),
             )
 
+            # Also restart caddy to ensure mounted TLS certs are reloaded from disk
+            await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: subprocess.run(
+                    ["docker", "compose", "restart", "caddy"],
+                    cwd=compose_dir,
+                    capture_output=True,
+                    timeout=60,
+                ),
+            )
+
             if result.returncode == 0:
-                _LOGGER.info("Caddy container recreated successfully")
+                _LOGGER.info("Caddy container recreated and restarted successfully")
                 return True
             else:
                 _LOGGER.error(

{boneio-1.5.0.dev22 → boneio-1.5.0.dev24}/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.dev22 → boneio-1.5.0.dev24}/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.dev24/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."
+    )