pyvlx 0.2.27__py3-none-any.whl

pyvlx/node.py

@@ -0,0 +1,74 @@
+"""
+Module for basic object for nodes.
+
+Node object is an interface class and should
+be derived by other objects like window openers
+and roller shutters.
+"""
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, List, Optional
+
+from .api import SetNodeName
+from .exception import PyVLXException
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+CallbackType = Callable[["Node"], Awaitable[None]]
+
+
+class Node:
+    """Class for node abstraction."""
+
+    def __init__(self, pyvlx: "PyVLX", node_id: int, name: str, serial_number: Optional[str]):
+        """Initialize Node object."""
+        self.pyvlx = pyvlx
+        self.node_id = node_id
+        self.name = name
+        self.serial_number = serial_number
+        self.device_updated_cbs: List[CallbackType] = []
+        self.pyvlx.connection.register_connection_opened_cb(self.after_update)
+        self.pyvlx.connection.register_connection_closed_cb(self.after_update)
+
+    def register_device_updated_cb(self, device_updated_cb: CallbackType) -> None:
+        """Register device updated callback."""
+        self.device_updated_cbs.append(device_updated_cb)
+
+    def unregister_device_updated_cb(self, device_updated_cb: CallbackType) -> None:
+        """Unregister device updated callback."""
+        self.device_updated_cbs.remove(device_updated_cb)
+
+    async def after_update(self) -> None:
+        """Execute callbacks after internal state has been changed."""
+        for device_updated_cb in self.device_updated_cbs:
+            # pylint: disable=not-callable
+            await self.pyvlx.loop.create_task(device_updated_cb(self))  # type: ignore
+
+    async def rename(self, name: str) -> None:
+        """Change name of node."""
+        set_node_name = SetNodeName(pyvlx=self.pyvlx, node_id=self.node_id, name=name)
+        await set_node_name.do_api_call()
+        if not set_node_name.success:
+            raise PyVLXException("Unable to rename node")
+        self.name = name
+
+    @property
+    def is_available(self) -> bool:
+        """Return True if node is available."""
+        return self.pyvlx.get_connected()
+
+    def __str__(self) -> str:
+        """Return object as readable string."""
+        return (
+            '<{} name="{}" '
+            'node_id="{}" '
+            'serial_number="{}"/>'.format(
+                type(self).__name__, self.name, self.node_id, self.serial_number
+            )
+        )
+
+    def __eq__(self, other: Any) -> bool:
+        """Equal operator."""
+        return (
+            type(self).__name__ == type(other).__name__
+            and self.__dict__ == other.__dict__
+        )

pyvlx/node_helper.py

@@ -0,0 +1,165 @@
+"""Helper module for Node objects."""
+from typing import TYPE_CHECKING, Optional, Union
+
+from .api.frames import (
+    FrameGetAllNodesInformationNotification,
+    FrameGetNodeInformationNotification)
+from .const import NodeTypeWithSubtype
+from .lightening_device import Light
+from .log import PYVLXLOG
+from .node import Node
+from .on_off_switch import OnOffSwitch
+from .opening_device import (
+    Awning, Blade, Blind, DualRollerShutter, GarageDoor, Gate, RollerShutter,
+    Window)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+def convert_frame_to_node(
+    pyvlx: "PyVLX",
+    frame: Union[
+        FrameGetNodeInformationNotification, FrameGetAllNodesInformationNotification
+    ],
+) -> Optional[Node]:
+    """Convert FrameGet[All]Node[s]InformationNotification into Node object."""
+    # pylint: disable=too-many-return-statements
+
+    if frame.node_type == NodeTypeWithSubtype.WINDOW_OPENER:
+        return Window(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+            position_parameter=frame.current_position,
+            rain_sensor=False,
+        )
+
+    if frame.node_type == NodeTypeWithSubtype.WINDOW_OPENER_WITH_RAIN_SENSOR:
+        return Window(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+            position_parameter=frame.current_position,
+            rain_sensor=True,
+        )
+
+    if frame.node_type == NodeTypeWithSubtype.DUAL_ROLLER_SHUTTER:
+        return DualRollerShutter(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+            position_parameter=frame.current_position,
+        )
+
+    if frame.node_type in [
+        NodeTypeWithSubtype.ROLLER_SHUTTER,
+        NodeTypeWithSubtype.SWINGING_SHUTTERS,
+    ]:
+        return RollerShutter(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+            position_parameter=frame.current_position,
+        )
+
+    if frame.node_type in [
+        NodeTypeWithSubtype.INTERIOR_VENETIAN_BLIND,
+        NodeTypeWithSubtype.VERTICAL_INTERIOR_BLINDS,
+        NodeTypeWithSubtype.INTERIOR_VENETIAN_BLIND,
+    ]:
+        return RollerShutter(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+        )
+
+    # Blinds have position and orientation (inherit frame.current_position_fp3) attribute
+    if frame.node_type in [
+        NodeTypeWithSubtype.EXTERIOR_VENETIAN_BLIND,
+        NodeTypeWithSubtype.ADJUSTABLE_SLUTS_ROLLING_SHUTTER,
+        NodeTypeWithSubtype.LOUVER_BLIND,
+    ]:
+        return Blind(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+            position_parameter=frame.current_position,
+        )
+
+    if frame.node_type in [
+        NodeTypeWithSubtype.VERTICAL_EXTERIOR_AWNING,
+        NodeTypeWithSubtype.HORIZONTAL_AWNING,
+        NodeTypeWithSubtype.HORIZONTAL_AWNING_ALT,
+    ]:
+        return Awning(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+            position_parameter=frame.current_position,
+        )
+
+    if frame.node_type == NodeTypeWithSubtype.ON_OFF_SWITCH:
+        return OnOffSwitch(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+        )
+
+    if frame.node_type in [
+        NodeTypeWithSubtype.GARAGE_DOOR_OPENER,
+        NodeTypeWithSubtype.LINAR_ANGULAR_POSITION_OF_GARAGE_DOOR,
+    ]:
+        return GarageDoor(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+            position_parameter=frame.current_position,
+        )
+
+    if frame.node_type == NodeTypeWithSubtype.GATE_OPENER:
+        return Gate(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+            position_parameter=frame.current_position,
+        )
+
+    if frame.node_type == NodeTypeWithSubtype.GATE_OPENER_ANGULAR_POSITION:
+        return Gate(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+            position_parameter=frame.current_position,
+        )
+
+    if frame.node_type == NodeTypeWithSubtype.BLADE_OPENER:
+        return Blade(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+            position_parameter=frame.current_position,
+        )
+
+    if frame.node_type in [NodeTypeWithSubtype.LIGHT, NodeTypeWithSubtype.LIGHT_ON_OFF]:
+        return Light(
+            pyvlx=pyvlx,
+            node_id=frame.node_id,
+            name=frame.name,
+            serial_number=frame.serial_number,
+        )
+
+    PYVLXLOG.warning("%s not implemented", frame.node_type)
+    return None

pyvlx/node_updater.py

@@ -0,0 +1,162 @@
+"""Module for updating nodes via frames."""
+import datetime
+from typing import TYPE_CHECKING, Any
+
+from .api.frames import (
+    FrameBase, FrameGetAllNodesInformationNotification,
+    FrameNodeStatePositionChangedNotification, FrameStatusRequestNotification)
+from .const import NodeParameter, OperatingState
+from .lightening_device import LighteningDevice
+from .log import PYVLXLOG
+from .on_off_switch import OnOffSwitch
+from .opening_device import Blind, DualRollerShutter, OpeningDevice
+from .parameter import Intensity, Parameter, Position, SwitchParameter
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class NodeUpdater:
+    """Class for updating nodes via incoming frames,  usually received by house monitor."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize NodeUpdater object."""
+        self.pyvlx = pyvlx
+
+    async def process_frame_status_request_notification(
+        self, frame: FrameStatusRequestNotification
+    ) -> None:
+        """Process FrameStatusRequestNotification."""
+        PYVLXLOG.debug("NodeUpdater process frame: %s", frame)
+        if frame.node_id not in self.pyvlx.nodes:
+            return
+        node = self.pyvlx.nodes[frame.node_id]
+        if isinstance(node, Blind):
+            if NodeParameter(0) not in frame.parameter_data:  # MP missing in frame
+                return
+            if NodeParameter(3) not in frame.parameter_data:  # FP3 missing in frame
+                return
+            position = Position(frame.parameter_data[NodeParameter(0)])
+            orientation = Position(frame.parameter_data[NodeParameter(3)])
+            if position.position <= Parameter.MAX:
+                node.position = position
+                PYVLXLOG.debug("%s position changed to: %s", node.name, position)
+            if orientation.position <= Parameter.MAX:
+                node.orientation = orientation
+                PYVLXLOG.debug("%s orientation changed to: %s", node.name, orientation)
+            await node.after_update()
+
+        if isinstance(node, DualRollerShutter):
+            if NodeParameter(0) not in frame.parameter_data:  # MP missing in frame
+                return
+            if NodeParameter(1) not in frame.parameter_data:  # FP1 missing in frame
+                return
+            if NodeParameter(2) not in frame.parameter_data:  # FP2 missing in frame
+                return
+            position = Position(frame.parameter_data[NodeParameter(0)])
+            position_upper_curtain = Position(frame.parameter_data[NodeParameter(1)])
+            position_lower_curtain = Position(frame.parameter_data[NodeParameter(2)])
+            if position.position <= Parameter.MAX:
+                node.position = position
+                PYVLXLOG.debug("%s position changed to: %s", node.name, position)
+            if position_upper_curtain.position <= Parameter.MAX:
+                node.position_upper_curtain = position_upper_curtain
+                PYVLXLOG.debug(
+                    "%s position upper curtain changed to: %s",
+                    node.name,
+                    position_upper_curtain,
+                )
+            if position_lower_curtain.position <= Parameter.MAX:
+                node.position_lower_curtain = position_lower_curtain
+                PYVLXLOG.debug(
+                    "%s position lower curtain changed to: %s",
+                    node.name,
+                    position_lower_curtain,
+                )
+            await node.after_update()
+
+    async def process_frame(self, frame: FrameBase) -> None:
+        """Update nodes via frame, usually received by house monitor."""
+        if isinstance(
+            frame,
+            (
+                FrameGetAllNodesInformationNotification,
+                FrameNodeStatePositionChangedNotification,
+            ),
+        ):
+            PYVLXLOG.debug("NodeUpdater process frame: %s", frame)
+            if frame.node_id not in self.pyvlx.nodes:
+                return
+            node = self.pyvlx.nodes[frame.node_id]
+            position = Position(frame.current_position)
+            target: Any = Position(frame.target)
+            # KLF transmits for functional parameters basically always 'No feed-back value known’ (0xF7FF).
+            # In home assistant this cause unreasonable values like -23%. Therefore a check is implemented
+            # whether the frame parameter is inside the maximum range.
+
+            # Set opening device status
+            if isinstance(node, OpeningDevice):
+                if (position.position > target.position <= Parameter.MAX) and (
+                    (frame.state == OperatingState.EXECUTING)
+                    or frame.remaining_time > 0
+                ):
+                    node.is_opening = True
+                    PYVLXLOG.debug("%s is opening", node.name)
+                    node.state_received_at = datetime.datetime.now()
+                    node.estimated_completion = (
+                        node.state_received_at
+                        + datetime.timedelta(0, frame.remaining_time)
+                    )
+                    PYVLXLOG.debug(
+                        "%s will be opening until", node.estimated_completion
+                    )
+                elif (position.position < target.position <= Parameter.MAX) and (
+                    (frame.state == OperatingState.EXECUTING)
+                    or frame.remaining_time > 0
+                ):
+                    node.is_closing = True
+                    PYVLXLOG.debug("%s is closing", node.name)
+                    node.state_received_at = datetime.datetime.now()
+                    node.estimated_completion = (
+                        node.state_received_at
+                        + datetime.timedelta(0, frame.remaining_time)
+                    )
+                    PYVLXLOG.debug(
+                        "%s will be closing until", node.estimated_completion
+                    )
+                else:
+                    if node.is_opening:
+                        node.is_opening = False
+                        node.state_received_at = None
+                        node.estimated_completion = None
+                        PYVLXLOG.debug("%s stops opening", node.name)
+                    if node.is_closing:
+                        node.is_closing = False
+                        PYVLXLOG.debug("%s stops closing", node.name)
+
+            # Set main parameter
+            if isinstance(node, OpeningDevice):
+                if position.position <= Parameter.MAX:
+                    node.position = position
+                    node.target = target
+                    PYVLXLOG.debug("%s position changed to: %s", node.name, position)
+                await node.after_update()
+            elif isinstance(node, LighteningDevice):
+                intensity = Intensity(frame.current_position)
+                if intensity.intensity <= Parameter.MAX:
+                    node.intensity = intensity
+                    PYVLXLOG.debug("%s intensity changed to: %s", node.name, intensity)
+                await node.after_update()
+            elif isinstance(node, OnOffSwitch):
+                state = SwitchParameter(frame.current_position)
+                target = SwitchParameter(frame.target)
+                if state.state == target.state:
+                    if state.state == Parameter.ON:
+                        node.parameter = state
+                        PYVLXLOG.debug("%s state changed to: %s", node.name, state)
+                    elif state.state == Parameter.OFF:
+                        node.parameter = state
+                        PYVLXLOG.debug("%s state changed to: %s", node.name, state)
+                    await node.after_update()
+        elif isinstance(frame, FrameStatusRequestNotification):
+            await self.process_frame_status_request_notification(frame)

pyvlx/nodes.py

@@ -0,0 +1,99 @@
+"""Module for storing nodes."""
+from typing import TYPE_CHECKING, Iterator, List, Optional, Union
+
+from .api import GetAllNodesInformation, GetNodeInformation
+from .exception import PyVLXException
+from .node import Node
+from .node_helper import convert_frame_to_node
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class Nodes:
+    """Object for storing node objects."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize Nodes object."""
+        self.pyvlx = pyvlx
+        self.__nodes: List[Node] = []
+
+    def __iter__(self) -> Iterator[Node]:
+        """Iterate."""
+        yield from self.__nodes
+
+    def __getitem__(self, key: Union[str, int]) -> Node:
+        """Return node by name or by index."""
+        if isinstance(key, int):
+            for node in self.__nodes:
+                if node.node_id == key:
+                    return node
+        for node in self.__nodes:
+            if node.name == key:
+                return node
+        raise KeyError
+
+    def __contains__(self, key: Union[str, int, Node]) -> bool:
+        """Check if key is in index."""
+        if isinstance(key, int):
+            for node in self.__nodes:
+                if node.node_id == key:
+                    return True
+        if isinstance(key, Node):
+            for node in self.__nodes:
+                if node == key:
+                    return True
+        for node in self.__nodes:
+            if node.name == key:
+                return True
+        return False
+
+    def __len__(self) -> int:
+        """Return number of nodes."""
+        return len(self.__nodes)
+
+    def add(self, node: Node) -> None:
+        """Add Node, replace existing node if node with node_id is present."""
+        if not isinstance(node, Node):
+            raise TypeError()
+        for i, j in enumerate(self.__nodes):
+            if j.node_id == node.node_id:
+                self.__nodes[i] = node
+                return
+        self.__nodes.append(node)
+
+    def clear(self) -> None:
+        """Clear internal node array."""
+        self.__nodes = []
+
+    async def load(self, node_id: Optional[int] = None) -> None:
+        """Load nodes from KLF 200, if no node_id is specified all nodes are loaded."""
+        if node_id is not None:
+            await self._load_node(node_id=node_id)
+        else:
+            await self._load_all_nodes()
+
+    async def _load_node(self, node_id: int) -> None:
+        """Load single node via API."""
+        get_node_information = GetNodeInformation(pyvlx=self.pyvlx, node_id=node_id)
+        await get_node_information.do_api_call()
+        if not get_node_information.success:
+            raise PyVLXException("Unable to retrieve node information")
+        notification_frame = get_node_information.notification_frame
+        if notification_frame is None:
+            return
+        node = convert_frame_to_node(self.pyvlx, notification_frame)
+        if node is not None:
+            self.add(node)
+
+    async def _load_all_nodes(self) -> None:
+        """Load all nodes via API."""
+        get_all_nodes_information = GetAllNodesInformation(pyvlx=self.pyvlx)
+        await get_all_nodes_information.do_api_call()
+        if not get_all_nodes_information.success:
+            raise PyVLXException("Unable to retrieve node information")
+        self.clear()
+        for notification_frame in get_all_nodes_information.notification_frames:
+            node = convert_frame_to_node(self.pyvlx, notification_frame)
+            if node is not None:
+                self.add(node)

pyvlx/on_off_switch.py

@@ -0,0 +1,44 @@
+"""Module for on/off switches."""
+from typing import TYPE_CHECKING, Optional
+
+from .api.command_send import CommandSend
+from .node import Node
+from .parameter import SwitchParameter, SwitchParameterOff, SwitchParameterOn
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class OnOffSwitch(Node):
+    """Class for controlling on-off switches."""
+
+    def __init__(self, pyvlx: "PyVLX", node_id: int, name: str, serial_number: Optional[str]):
+        """Initialize opening device."""
+        super().__init__(
+            pyvlx=pyvlx, node_id=node_id, name=name, serial_number=serial_number
+        )
+        self.parameter = SwitchParameter()
+
+    async def set_state(self, parameter: SwitchParameter) -> None:
+        """Set switch to desired state."""
+        command = CommandSend(
+            pyvlx=self.pyvlx, node_id=self.node_id, parameter=parameter
+        )
+        await command.send()
+        await self.after_update()
+
+    async def set_on(self) -> None:
+        """Set switch on."""
+        await self.set_state(SwitchParameterOn())
+
+    async def set_off(self) -> None:
+        """Set switch off."""
+        await self.set_state(SwitchParameterOff())
+
+    def is_on(self) -> bool:
+        """Return if switch is set to on."""
+        return self.parameter.is_on()
+
+    def is_off(self) -> bool:
+        """Return if switch is set to off."""
+        return self.parameter.is_off()