boneIO 1.3.0__tar.gz → 1.3.0.dev3__tar.gz

{boneio-1.3.0/boneio.egg-info → boneio-1.3.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.3.0
+Version: 1.3.0.dev3
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0
@@ -35,7 +35,7 @@ Requires-Dist: requests==2.32.5
 Requires-Dist: packaging==25.0
 Requires-Dist: aioesphomeapi>=29.0.0
 Requires-Dist: zeroconf>=0.148.0
-Requires-Dist: canopen-asyncio>=2.4.1
+Requires-Dist: canopen-asyncio>=2.3.0
 Dynamic: license-file
 
 Example usage:

{boneio-1.3.0 → boneio-1.3.0.dev3}/boneio/bonecli.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import time as _boot_time
-
 _BOOT_T0 = _boot_time.monotonic()
 
 import logging
@@ -21,7 +20,6 @@ print(f"[BOOT TIMING] stdlib imports: {_boot_time.monotonic() - _BOOT_T0:.2f}s",
 # startup time. Only version is imported here for --version CLI flag.
 _t_ver = _boot_time.monotonic()
 from boneio.version import __version__
-
 print(f"[BOOT TIMING] ALL imports: {_boot_time.monotonic() - _BOOT_T0:.2f}s", flush=True)
 
 TASK_CANCELATION_TIMEOUT = 1
@@ -207,9 +205,7 @@ def run(
 ) -> int:
     """Run BoneIO."""
     import time as _time
-
     from yaml import MarkedYAMLError
-
     from boneio.core.config import load_config_from_file
     from boneio.core.events import GracefulExit
     from boneio.core.utils.logger import configure_logger, setup_logging
@@ -218,38 +214,14 @@ def run(
     setup_logging(debug_level=debug)
     _LOGGER.info("BoneIO %s starting.", __version__)
     _LOGGER.debug("[STARTUP TIMING] after setup_logging: %.2fs", _time.monotonic() - _t0)
-
-    # --- Initialize OLED before anything else (independent of config) ---
-    # This is wrapped in try/except so the app always starts even if
-    # OLED hardware is missing, broken, or display libraries aren't installed.
-    try:
-        from boneio.hardware.display.early_oled import (
-            draw_config_error,
-            draw_crash,
-            draw_status,
-            init_early_oled,
-        )
-        init_early_oled()
-        draw_status("Loading config...")
-    except Exception:
-        # OLED is optional — define no-op stubs so rest of the function works
-        _LOGGER.debug("Early OLED not available, continuing without display")
-        def draw_status(msg: str) -> None: pass  # noqa: E731
-        def draw_config_error(msg: str) -> None: pass  # noqa: E731
-        def draw_crash(exc: BaseException) -> None: pass  # noqa: E731
-
     try:
         _t1 = _time.monotonic()
-        _config = load_config_from_file(
-            config_file=config, progress_callback=draw_status,
-        )
+        _config = load_config_from_file(config_file=config)
         _LOGGER.debug("[STARTUP TIMING] load_config_from_file: %.2fs", _time.monotonic() - _t1)
         if not _config:
             _LOGGER.error("Config not loaded. Exiting.")
-            draw_config_error("Config file is empty or missing")
             return 1
         configure_logger(log_config=_config.get("logger") or {}, debug=debug)
-        draw_status("Importing modules...")
         # Granular timing of runner sub-imports to find the bottleneck
         _t_a = _time.monotonic()
         from boneio.const import ACTION
@@ -270,9 +242,6 @@ def run(
         from boneio.runner import async_run
         _LOGGER.debug("[RUNNER IMPORT] boneio.runner (rest): %.2fs", _time.monotonic() - _t_a)
         _LOGGER.debug("[STARTUP TIMING] total before async_run: %.2fs", _time.monotonic() - _t0)
-
-        draw_status("Starting...")
-
         ret = asyncio.run(
             async_run(
                 config=_config,
@@ -291,11 +260,6 @@ def run(
         return 0
     except (ConfigurationException, MarkedYAMLError) as err:
         _LOGGER.error("Failed to load config. %s Exiting.", err)
-        draw_config_error(str(err)[:100])
-        return 1
-    except Exception as err:
-        _LOGGER.error("Unexpected error during startup: %s", err, exc_info=True)
-        draw_crash(err)
         return 1
 
 
@@ -304,7 +268,6 @@ def run_modbus_command(
 ) -> int:
     """Run BoneIO."""
     from yaml import MarkedYAMLError
-
     from boneio.core.events import GracefulExit
     from boneio.core.utils.logger import configure_logger, setup_logging
     from boneio.exceptions import ConfigurationException, RestartRequestException

{boneio-1.3.0 → boneio-1.3.0.dev3}/boneio/components/cover/cover.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
 import asyncio
-import json
 import logging
+import json
 import threading
 import time
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 
-from boneio.components.output import BasicOutput
 from boneio.const import (
     CLOSED,
     CLOSING,
@@ -21,6 +20,7 @@ from boneio.core.events import EventBus
 from boneio.core.messaging import BasicMqtt
 from boneio.core.utils import TimePeriod
 from boneio.models import CoverState, PositionDict
+from boneio.components.output import BasicOutput
 from boneio.models.events import CoverEvent
 
 _LOGGER = logging.getLogger(__name__)
@@ -187,17 +187,13 @@ class BaseCover(BaseCoverABC, BasicMqtt):
 
         self._event_bus.add_sigterm_listener(self.on_exit)
 
-        try:
-            self._loop.call_soon_threadsafe(
-                self._loop.call_later,
-                0.5,
-                self.send_state,
-                self.state,
-                self.json_position
-            )
-        except RuntimeError:
-            # Event loop is closed (e.g. during tests)
-            pass
+        self._loop.call_soon_threadsafe(
+            self._loop.call_later,
+            0.5,
+            self.send_state,
+            self.state,
+            self.json_position
+        )
 
     async def on_exit(self) -> None:
         """Stop on exit."""
@@ -210,12 +206,8 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             self._open_relay.turn_off()
             self._close_relay.turn_off()
             # Send relay states to WebSocket (not MQTT - that's handled by output_type check)
-            try:
-                asyncio.create_task(self._open_relay.async_send_state())
-                asyncio.create_task(self._close_relay.async_send_state())
-            except RuntimeError:
-                # Event loop is closed (e.g. during tests or shutdown)
-                pass
+            asyncio.create_task(self._open_relay.async_send_state())
+            asyncio.create_task(self._close_relay.async_send_state())
             if self._current_operation in (OPENING, CLOSING):
                 self._last_operation = self._current_operation
             self._current_operation = IDLE
@@ -275,7 +267,9 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             await self.stop()
         elif self._position >= 100:
             await self.close()
-        elif self._position <= 0 or self._last_operation == CLOSING:
+        elif self._position <= 0:
+            await self.open()
+        elif self._last_operation == CLOSING:
             await self.open()
         else:
             await self.close()
@@ -315,7 +309,9 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             await self.open()
         elif self._position >= 100:
             await self.close()
-        elif self._position <= 0 or self._last_operation == CLOSING:
+        elif self._position <= 0:
+            await self.open()
+        elif self._last_operation == CLOSING:
             await self.open()
         else:
             await self.close()
@@ -329,18 +325,6 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         else:
             return CLOSED if self._position == 0 else OPEN
 
-    @property
-    def is_open(self) -> bool:
-        """Whether the cover is currently open (position > 0).
-        
-        Used by the action conditions system to evaluate ``is_open`` / ``is_closed``
-        checks for covers.
-        
-        Returns:
-            True if the cover is not fully closed.
-        """
-        return self._position > 0
-
     @property
     def position(self) -> int:
         return round(self._position, 0)

{boneio-1.3.0 → boneio-1.3.0.dev3}/boneio/components/cover/time_based.py

@@ -6,11 +6,11 @@ import threading
 import time
 from collections.abc import Callable
 
-from boneio.components.cover.cover import BaseCover
-from boneio.components.output import BasicOutput
 from boneio.const import CLOSE, CLOSING, IDLE, OPEN, OPENING, STOP
+from boneio.components.cover.cover import BaseCover
 from boneio.core.events import EventBus
 from boneio.core.utils import TimePeriod
+from boneio.components.output import BasicOutput
 
 _LOGGER = logging.getLogger(__name__)
 DEFAULT_RESTORED_STATE = {"position": 100}
@@ -43,7 +43,7 @@ class TimeBasedCover(BaseCover):
 
     def _move_cover(self, direction: str, duration: float, target_position: int | None = None):
         """Run in sepearate thread.
-
+        
         Args:
             direction: Direction of movement (OPEN or CLOSE)
             duration: Full time for 0-100% movement in milliseconds
@@ -60,10 +60,7 @@ class TimeBasedCover(BaseCover):
 
         if total_steps == 0 or duration == 0:
             self._current_operation = IDLE
-            try:
-                self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
-            except RuntimeError:
-                pass
+            self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
             return
 
         # Calculate actual duration based on remaining distance
@@ -72,10 +69,7 @@ class TimeBasedCover(BaseCover):
 
         relay.turn_on()
         # Send relay state to WebSocket (not MQTT - that's handled by output_type check)
-        try:
-            self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
-        except RuntimeError:
-            pass
+        self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
         start_time = time.monotonic()
 
         while not self._stop_event.is_set():
@@ -90,10 +84,7 @@ class TimeBasedCover(BaseCover):
 
             self._last_timestamp = current_time # Użyj pobranego czasu
             if current_time - self._last_update_time >= 1:
-                try:
-                    self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
-                except RuntimeError:
-                    break
+                self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
                 self._last_update_time = current_time
 
             if target_position is not None:
@@ -107,15 +98,9 @@ class TimeBasedCover(BaseCover):
             time.sleep(0.05)  # Małe opóźnienie, aby nie blokować CPU
         relay.turn_off()
         # Send relay state to WebSocket (not MQTT - that's handled by output_type check)
-        try:
-            self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
-        except RuntimeError:
-            pass
+        self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
         self._current_operation = IDLE
-        try:
-            self._loop.call_soon_threadsafe(lambda: self.send_state_and_save(self.json_position))
-        except RuntimeError:
-            pass
+        self._loop.call_soon_threadsafe(lambda: self.send_state_and_save(self.json_position))
         self._last_update_time = time.monotonic() # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
 
     async def run_cover(self, current_operation: str, target_position: int | None = None) -> None:

{boneio-1.3.0 → boneio-1.3.0.dev3}/boneio/components/group/output_group.py

@@ -112,11 +112,6 @@ class OutputGroup(BasicOutput):
         """Check if group is active (ON state)."""
         return self._state == ON
 
-    @property
-    def group_members(self) -> list[BasicOutput]:
-        """Return list of member outputs."""
-        return self._group_members
-
     @override
     async def async_send_state(self, optimized_value: str | None = None) -> None:
         """Send state to message bus and event bus for WebSocket."""

{boneio-1.3.0 → boneio-1.3.0.dev3}/boneio/components/input/binary_sensor.py

@@ -3,11 +3,12 @@
 from __future__ import annotations
 
 import logging
+
 import time
 from typing import cast
 
 from boneio.components.input.detectors import BinarySensorDetector
-from boneio.const import PRESSED, RELEASED, BinaryStateTypes, ClickTypes
+from boneio.const import BinaryStateTypes, ClickTypes, PRESSED, RELEASED
 from boneio.hardware.gpio.input import GpioBaseClass, get_gpio_manager
 from boneio.models import InputState
 from boneio.models.events import InputEvent

{boneio-1.3.0 → boneio-1.3.0.dev3}/boneio/components/input/event.py

@@ -5,10 +5,10 @@ from __future__ import annotations
 import logging
 import time
 
-from boneio.components.input.detectors import MultiClickDetector
 from boneio.const import ClickTypes
-from boneio.core.utils import TimePeriod
+from boneio.components.input.detectors import MultiClickDetector
 from boneio.hardware.gpio.input import GpioBaseClass, get_gpio_manager
+from boneio.core.utils import TimePeriod
 
 _LOGGER = logging.getLogger(__name__)
 

{boneio-1.3.0 → boneio-1.3.0.dev3}/boneio/components/output/basic.py

@@ -6,13 +6,12 @@ import logging
 import time
 
 from boneio.const import COVER, LIGHT, NONE, OFF, ON, OUTPUT, STATE, SWITCH
-from boneio.core.events import EventBus, async_track_point_in_time, utcnow
 from boneio.core.messaging import BasicMqtt
-from boneio.core.utils import callback
-from boneio.core.utils.timeperiod import TimePeriod
+from boneio.models.events import OutputEvent
+from boneio.core.events import EventBus, async_track_point_in_time, utcnow
 from boneio.integration.interlock import SoftwareInterlockManager
+from boneio.core.utils import callback
 from boneio.models import OutputState
-from boneio.models.events import OutputEvent
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -44,26 +43,6 @@ class BasicOutput(BasicMqtt):
         """Initialize Basic output."""
         self._momentary_turn_on = kwargs.pop("momentary_turn_on", None)
         self._momentary_turn_off = kwargs.pop("momentary_turn_off", None)
-
-        # --- Adjustable duration (editable momentary_turn_on via HA number) ---
-        self._adjustable_duration_enabled: bool = kwargs.pop("adjustable_duration", False)
-        _dur_default_raw = kwargs.pop("duration_default", None)
-        _dur_min_raw = kwargs.pop("duration_min", None)
-        _dur_max_raw = kwargs.pop("duration_max", None)
-        self._duration_unit: str = kwargs.pop("duration_unit", "s")
-        # Pop legacy field in case it still exists in config
-        kwargs.pop("duration_step", None)
-
-        from boneio.core.utils.timeperiod import parse_time_to_seconds
-
-        self._duration_min: float = max(1.0, parse_time_to_seconds(_dur_min_raw, 1.0))
-        self._duration_max: float = max(self._duration_min, parse_time_to_seconds(_dur_max_raw, 3600.0))
-        self._duration_default: float = parse_time_to_seconds(_dur_default_raw, 60.0)
-        # Current adjustable duration value in seconds (will be overwritten by restored state)
-        self._adjustable_duration: float = max(
-            self._duration_min, min(self._duration_max, self._duration_default)
-        )
-
         super().__init__(id=id, name=name or id, topic_type=topic_type, topic_prefix=topic_prefix, **kwargs)
         self._output_type: str = output_type
         self._event_bus: EventBus = event_bus
@@ -72,7 +51,6 @@ class BasicOutput(BasicMqtt):
         if output_type == COVER:
             self._momentary_turn_on = None
             self._momentary_turn_off = None
-            self._adjustable_duration_enabled = False
         self._state = ON if restored_state else OFF
         self._momentary_action = None
         self._last_timestamp = 0.0
@@ -161,10 +139,6 @@ class BasicOutput(BasicMqtt):
             expander_id=self.expander_id,
             area=self.area,
             interlock_groups=self._interlock_groups,
-            adjustable_duration=self._adjustable_duration_enabled,
-            adjustable_duration_value=self._adjustable_duration if self._adjustable_duration_enabled else None,
-            duration_min=self._duration_min if self._adjustable_duration_enabled else None,
-            duration_max=self._duration_max if self._adjustable_duration_enabled else None,
         )
         
         output_event = OutputEvent(
@@ -220,26 +194,15 @@ class BasicOutput(BasicMqtt):
         _LOGGER.warning("set_brightness not supported for %s output type", self.output_type)
 
     def _execute_momentary_turn(self, momentary_type: str) -> None:
-        """Execute momentary action.
-
-        If adjustable_duration is enabled and this is a turn-ON action,
-        use the dynamic duration instead of the static momentary_turn_on.
-        """
+        """Execute momentary action."""
         if self._momentary_action:
             _LOGGER.debug("Cancelling momentary action for %s", self.name)
             self._momentary_action()
-
-        if momentary_type == ON:
-            action = self.async_turn_off
-            if self._adjustable_duration_enabled:
-                # Use dynamic duration from HA number entity
-                delayed_action = TimePeriod(seconds=self._adjustable_duration)
-            else:
-                delayed_action = self._momentary_turn_on
-        else:
-            action = self.async_turn_on
-            delayed_action = self._momentary_turn_off
-
+        (action, delayed_action) = (
+            (self.async_turn_off, self._momentary_turn_on)
+            if momentary_type == ON
+            else (self.async_turn_on, self._momentary_turn_off)
+        )
         if delayed_action:
             _LOGGER.debug("Applying momentary action for %s in %s", self.name, delayed_action.as_timedelta)
             self._momentary_action = async_track_point_in_time(
@@ -255,59 +218,6 @@ class BasicOutput(BasicMqtt):
         await action(timestamp=timestamp)
         self._momentary_action = None
 
-    # -- Adjustable duration -------------------------------------------------
-
-    @property
-    def adjustable_duration_enabled(self) -> bool:
-        """Whether this output has an adjustable duration (HA number entity)."""
-        return self._adjustable_duration_enabled
-
-    @property
-    def adjustable_duration(self) -> float:
-        """Current adjustable duration value in seconds."""
-        return self._adjustable_duration
-
-    @property
-    def duration_min(self) -> float:
-        """Minimum duration in seconds for HA slider."""
-        return self._duration_min
-
-    @property
-    def duration_max(self) -> float:
-        """Maximum duration in seconds for HA slider."""
-        return self._duration_max
-
-    @property
-    def duration_unit(self) -> str:
-        """Unit of measurement for HA number entity ('s' or 'min')."""
-        return self._duration_unit
-
-    def set_adjustable_duration(self, seconds: float) -> None:
-        """Set the adjustable duration value.
-
-        Clamps to [duration_min, duration_max].
-        OutputManager handles persistence and MQTT publishing.
-
-        Args:
-            seconds: New duration in seconds.
-        """
-        self._adjustable_duration = max(
-            self._duration_min, min(self._duration_max, float(seconds))
-        )
-        _LOGGER.debug(
-            "Output '%s' adjustable duration set to %.1fs", self.id, self._adjustable_duration
-        )
-
-    def restore_adjustable_duration(self, seconds: float) -> None:
-        """Restore persisted duration value (called during init by OutputManager).
-
-        Args:
-            seconds: Persisted duration value.
-        """
-        self._adjustable_duration = max(
-            self._duration_min, min(self._duration_max, float(seconds))
-        )
-
     @property
     def is_active(self) -> bool:
         """Is active check."""