pyvlx 0.2.27__py3-none-any.whl

pyvlx/api/frames/frame_get_protocol_version.py

@@ -0,0 +1,53 @@
+"""Module for get version frame classes."""
+from pyvlx.const import Command
+
+from .frame import FrameBase
+
+
+class FrameGetProtocolVersionRequest(FrameBase):
+    """Frame for requesting protocol version."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_GET_PROTOCOL_VERSION_REQ)
+
+
+class FrameGetProtocolVersionConfirmation(FrameBase):
+    """Frame for response for get protocol version requests."""
+
+    PAYLOAD_LEN = 4
+
+    def __init__(self, major_version: int = 0, minor_version: int = 0):
+        """Init Frame."""
+        super().__init__(Command.GW_GET_PROTOCOL_VERSION_CFM)
+        self.major_version = major_version
+        self.minor_version = minor_version
+
+    @property
+    def version(self) -> str:
+        """Return formatted protocol version."""
+        return "{}.{}".format(self.major_version, self.minor_version)
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        return bytes(
+            [
+                self.major_version >> 8 & 255,
+                self.major_version & 255,
+                self.minor_version >> 8 & 255,
+                self.minor_version & 255,
+            ]
+        )
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.major_version = payload[0] * 256 + payload[1]
+        self.minor_version = payload[2] * 256 + payload[3]
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} version="{}"/>'.format(
+            type(self).__name__, self.version
+        )

pyvlx/api/frames/frame_get_scene_list.py

@@ -0,0 +1,82 @@
+"""Module for get scene list frame classes."""
+from typing import List, Tuple
+
+from pyvlx.const import Command
+from pyvlx.exception import PyVLXException
+from pyvlx.string_helper import bytes_to_string, string_to_bytes
+
+from .frame import FrameBase
+
+
+class FrameGetSceneListRequest(FrameBase):
+    """Frame for get scene list request."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_GET_SCENE_LIST_REQ)
+
+
+class FrameGetSceneListConfirmation(FrameBase):
+    """Frame for confirmation for scene list request."""
+
+    PAYLOAD_LEN = 1
+
+    def __init__(self, count_scenes: int = 0):
+        """Init Frame."""
+        super().__init__(Command.GW_GET_SCENE_LIST_CFM)
+        self.count_scenes = count_scenes
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        return bytes([self.count_scenes])
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.count_scenes = payload[0]
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} count_scenes="{}"/>'.format(
+            type(self).__name__, self.count_scenes
+        )
+
+
+class FrameGetSceneListNotification(FrameBase):
+    """Frame for scene list notification."""
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_GET_SCENE_LIST_NTF)
+        self.scenes: List[Tuple[int, str]] = []
+        self.remaining_scenes = 0
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        ret = bytes([len(self.scenes)])
+        for number, name in self.scenes:
+            ret += bytes([number])
+            ret += string_to_bytes(name, 64)
+        ret += bytes([self.remaining_scenes])
+        return ret
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        number_of_objects = payload[0]
+        self.remaining_scenes = payload[-1]
+        predicted_len = number_of_objects * 65 + 2
+        if len(payload) != predicted_len:
+            raise PyVLXException("scene_list_notification_wrong_length")
+        self.scenes = []
+        for i in range(number_of_objects):
+            scene = payload[(i * 65 + 1) : (i * 65 + 66)]
+            number = scene[0]
+            name = bytes_to_string(scene[1:])
+            self.scenes.append((number, name))
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} scenes="{}" remaining_scenes="{}">'.format(
+            type(self).__name__, self.scenes, self.remaining_scenes
+        )

pyvlx/api/frames/frame_get_state.py

@@ -0,0 +1,47 @@
+"""Frames for receiving state from gateway."""
+from pyvlx.const import Command, GatewayState, GatewaySubState
+
+from .frame import FrameBase
+
+
+class FrameGetStateRequest(FrameBase):
+    """Frame for requesting state."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_GET_STATE_REQ)
+
+
+class FrameGetStateConfirmation(FrameBase):
+    """Frame for confirmation for get state requests."""
+
+    PAYLOAD_LEN = 6
+
+    def __init__(
+            self,
+            gateway_state: GatewayState = GatewayState.TEST_MODE,
+            gateway_sub_state: GatewaySubState = GatewaySubState.IDLE,
+    ):
+        """Init Frame."""
+        super().__init__(Command.GW_GET_STATE_CFM)
+        self.gateway_state = gateway_state
+        self.gateway_sub_state = gateway_sub_state
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        payload = bytes([self.gateway_state.value, self.gateway_sub_state.value])
+        payload += bytes(4)  # State date, reserved for future use
+        return payload
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.gateway_state = GatewayState(payload[0])
+        self.gateway_sub_state = GatewaySubState(payload[1])
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} gateway_state="{}" gateway_sub_state="{}"/>'.format(
+            type(self).__name__, self.gateway_state, self.gateway_sub_state
+        )

pyvlx/api/frames/frame_get_version.py

@@ -0,0 +1,72 @@
+"""Module for get version frame classes."""
+from typing import Union
+
+from pyvlx.const import Command
+
+from .frame import FrameBase
+
+
+class FrameGetVersionRequest(FrameBase):
+    """Frame for requesting version."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_GET_VERSION_REQ)
+
+
+class FrameGetVersionConfirmation(FrameBase):
+    """Frame for response for get version requests."""
+
+    PAYLOAD_LEN = 9
+
+    def __init__(self, software_version: Union[bytes, str] = bytes(6), hardware_version: int = 0):
+        """Init Frame."""
+        super().__init__(Command.GW_GET_VERSION_CFM)
+        if isinstance(software_version, str):
+            software_version = bytes(int(c) for c in software_version.split("."))
+        self._software_version = software_version
+        self.hardware_version = hardware_version
+        self.product_group = 14
+        self.product_type = 3
+
+    @property
+    def version(self) -> str:
+        """Return formatted version."""
+        return "{}: Software version: {}, hardware version: {}".format(
+            self.product, self.software_version, self.hardware_version
+        )
+
+    @property
+    def software_version(self) -> str:
+        """Return software version as human readable string."""
+        return ".".join(str(c) for c in self._software_version)
+
+    @property
+    def product(self) -> str:
+        """Return product as human readable string."""
+        if self.product_group == 14 and self.product_type == 3:
+            return "KLF 200"
+        return "Unknown Product: {}:{}".format(self.product_group, self.product_type)
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        ret = self._software_version
+        ret += bytes([self.hardware_version, self.product_group, self.product_type])
+        return ret
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self._software_version = payload[0:6]
+        self.hardware_version = payload[6]
+        self.product_group = payload[7]
+        self.product_type = payload[8]
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return (
+            '<{} software_version="{}" hardware_version="{}" product="{}"/>'.format(
+                type(self).__name__, self.software_version, self.hardware_version, self.product
+            )
+        )

pyvlx/api/frames/frame_helper.py

@@ -0,0 +1,40 @@
+"""Helper module for SLIP Frames."""
+from typing import Tuple
+
+from pyvlx.const import Command
+from pyvlx.exception import PyVLXException
+
+
+def calc_crc(raw: bytes) -> int:
+    """Calculate cyclic redundancy check (CRC)."""
+    crc = 0
+    for sym in raw:
+        crc = crc ^ int(sym)
+    return crc
+
+
+def extract_from_frame(data: bytes) -> Tuple[Command, bytes]:
+    """Extract payload and command from frame."""
+    if len(data) <= 4:
+        raise PyVLXException("could_not_extract_from_frame_too_short", data=data)
+    length = data[0] * 256 + data[1] - 1
+    if len(data) != length + 3:
+        raise PyVLXException(
+            "could_not_extract_from_frame_invalid_length",
+            data=data,
+            current_length=len(data),
+            expected_length=length + 3,
+        )
+    if calc_crc(data[:-1]) != data[-1]:
+        raise PyVLXException(
+            "could_not_extract_from_frame_invalid_crc",
+            data=data,
+            expected_crc=calc_crc(data[:-1]),
+            current_crc=data[-1],
+        )
+    payload = data[4:-1]
+    try:
+        command = Command(data[2] * 256 + data[3])
+    except ValueError as type_error:
+        raise PyVLXException("could_not_extract_from_frame_command", data=data) from type_error
+    return command, payload

pyvlx/api/frames/frame_house_status_monitor_disable_cfm.py

@@ -0,0 +1,14 @@
+"""Module for confirmation for  disabling the house status monitor."""
+from pyvlx.const import Command
+
+from .frame import FrameBase
+
+
+class FrameHouseStatusMonitorDisableConfirmation(FrameBase):
+    """Frame for requesting enabling the house status monitor."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_HOUSE_STATUS_MONITOR_DISABLE_CFM)

pyvlx/api/frames/frame_house_status_monitor_disable_req.py

@@ -0,0 +1,14 @@
+"""Module for requesting disabling the house status monitor."""
+from pyvlx.const import Command
+
+from .frame import FrameBase
+
+
+class FrameHouseStatusMonitorDisableRequest(FrameBase):
+    """Frame for requesting disabling the house status monitor."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_HOUSE_STATUS_MONITOR_DISABLE_REQ)

pyvlx/api/frames/frame_house_status_monitor_enable_cfm.py

@@ -0,0 +1,14 @@
+"""Module for confirmation for enabling the house status monitor."""
+from pyvlx.const import Command
+
+from .frame import FrameBase
+
+
+class FrameHouseStatusMonitorEnableConfirmation(FrameBase):
+    """Frame for confirmation for enabling the house status monitor."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_HOUSE_STATUS_MONITOR_ENABLE_CFM)

pyvlx/api/frames/frame_house_status_monitor_enable_req.py

@@ -0,0 +1,14 @@
+"""Module for requesting enabling the house status monitor."""
+from pyvlx.const import Command
+
+from .frame import FrameBase
+
+
+class FrameHouseStatusMonitorEnableRequest(FrameBase):
+    """Frame for requesting enabling the house status monitor."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_HOUSE_STATUS_MONITOR_ENABLE_REQ)

pyvlx/api/frames/frame_leave_learn_state.py

@@ -0,0 +1,41 @@
+"""Module for leave learn state frame classes."""
+from pyvlx.const import Command, LeaveLearnStateConfirmationStatus
+
+from .frame import FrameBase
+
+
+class FrameLeaveLearnStateRequest(FrameBase):
+    """Frame for leaving learn state request."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_LEAVE_LEARN_STATE_REQ)
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{}/>'.format(type(self).__name__)
+
+
+class FrameLeaveLearnStateConfirmation(FrameBase):
+    """Frame for confirmation for leaving learn State."""
+
+    PAYLOAD_LEN = 1
+
+    def __init__(self, status: int = 0):
+        """Init Frame."""
+        super().__init__(Command.GW_LEAVE_LEARN_STATE_CFM)
+        self.status = LeaveLearnStateConfirmationStatus(status)
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        return bytes([self.status.value])
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.status = LeaveLearnStateConfirmationStatus(payload[0])
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} status="{}"/>'.format(type(self).__name__, self.status)

pyvlx/api/frames/frame_node_information_changed.py

@@ -0,0 +1,57 @@
+"""Module for requesting change of node name."""
+from typing import Optional
+
+from pyvlx.const import Command, NodeVariation
+from pyvlx.string_helper import bytes_to_string, string_to_bytes
+
+from .frame import FrameBase
+
+
+class FrameNodeInformationChangedNotification(FrameBase):
+    """Frame for notification for set node name."""
+
+    PAYLOAD_LEN = 69
+
+    def __init__(
+            self,
+            node_id: int = 0,
+            name: Optional[str] = None,
+            order: int = 0,
+            placement: int = 0,
+            node_variation: NodeVariation = NodeVariation.NOT_SET,
+    ):
+        """Init Frame."""
+        super().__init__(Command.GW_NODE_INFORMATION_CHANGED_NTF)
+        self.node_id = node_id
+        self.name = name
+        self.order = order
+        self.placement = placement
+        self.node_variation = node_variation
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        payload = bytes([self.node_id])
+        assert self.name is not None
+        payload += string_to_bytes(self.name, 64)
+        payload += bytes([self.order >> 8 & 255, self.order & 255])
+        payload += bytes([self.placement])
+        payload += bytes([self.node_variation.value])
+        return payload
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.node_id = payload[0]
+        self.name = bytes_to_string(payload[1:65])
+        self.order = payload[65] * 256 + payload[66]
+        self.placement = payload[67]
+        self.node_variation = NodeVariation(payload[68])
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return (
+            '<{} node_id="{}" name="{}" order="{}" '
+            'placement="{}" node_variation="{}"/>'.format(
+                type(self).__name__, self.node_id, self.name,
+                self.order, self.placement, self.node_variation
+            )
+        )

pyvlx/api/frames/frame_node_state_position_changed_notification.py

@@ -0,0 +1,84 @@
+"""Module for get node information from gateway."""
+import struct
+from datetime import datetime
+
+from pyvlx.const import Command, OperatingState
+from pyvlx.parameter import Parameter
+
+from .frame import FrameBase
+
+
+class FrameNodeStatePositionChangedNotification(FrameBase):
+    """Frame for notification of note information request."""
+
+    PAYLOAD_LEN = 20
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_NODE_STATE_POSITION_CHANGED_NTF)
+        self.node_id = 0
+        self.state: OperatingState = OperatingState.NON_EXECUTING
+        self.current_position = Parameter()
+        self.target = Parameter()
+        self.current_position_fp1 = Parameter()
+        self.current_position_fp2 = Parameter()
+        self.current_position_fp3 = Parameter()
+        self.current_position_fp4 = Parameter()
+        self.remaining_time = 0
+        self.timestamp = 0
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        payload = bytes([self.node_id])
+        payload += bytes([self.state.value])
+        payload += bytes(self.current_position.raw)
+        payload += bytes(self.target.raw)
+        payload += bytes(self.current_position_fp1.raw)
+        payload += bytes(self.current_position_fp2.raw)
+        payload += bytes(self.current_position_fp3.raw)
+        payload += bytes(self.current_position_fp4.raw)
+        payload += bytes([self.remaining_time >> 8 & 255, self.remaining_time & 255])
+        payload += struct.pack(">I", self.timestamp)
+        return payload
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.node_id = payload[0]
+        self.state = OperatingState(payload[1])
+        self.current_position = Parameter(payload[2:4])
+        self.target = Parameter(payload[4:6])
+        self.current_position_fp1 = Parameter(payload[6:8])
+        self.current_position_fp2 = Parameter(payload[8:10])
+        self.current_position_fp3 = Parameter(payload[10:12])
+        self.current_position_fp4 = Parameter(payload[12:14])
+        self.remaining_time = payload[14] * 256 + payload[15]
+        # @VELUX: looks like your timestamp is wrong. Looks like
+        # you are only transmitting the two lower bytes.
+        self.timestamp = struct.unpack(">I", payload[16:20])[0]
+
+    @property
+    def timestamp_formatted(self) -> str:
+        """Return time as human readable string."""
+        return datetime.fromtimestamp(self.timestamp).strftime("%Y-%m-%d %H:%M:%S")
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return (
+            '<{} node_id="{}" '
+            'state="{}" current_position="{}" '
+            'target="{}" current_position_fp1="{}" current_position_fp2="{}" '
+            'current_position_fp3="{}" current_position_fp4="{}" '
+            'remaining_time="{}" time="{}"/>'.format(
+                type(self).__name__,
+                self.node_id,
+                self.state.name,
+                self.current_position,
+                self.target,
+                self.current_position_fp1,
+                self.current_position_fp2,
+                self.current_position_fp3,
+                self.current_position_fp4,
+                self.remaining_time,
+                self.timestamp_formatted,
+            )
+        )

pyvlx/api/frames/frame_password_change.py

@@ -0,0 +1,114 @@
+"""Module for password enter frame classes."""
+from enum import Enum
+from typing import Optional
+
+from pyvlx.const import Command
+from pyvlx.exception import PyVLXException
+from pyvlx.string_helper import bytes_to_string, string_to_bytes
+
+from .frame import FrameBase
+
+
+class FramePasswordChangeRequest(FrameBase):
+    """Frame for sending password enter request."""
+
+    MAX_SIZE = 32
+    PAYLOAD_LEN = 64
+
+    def __init__(self, currentpassword: Optional[str] = None, newpassword: Optional[str] = None):
+        """Init Frame."""
+        super().__init__(Command.GW_PASSWORD_CHANGE_REQ)
+        self.currentpassword = currentpassword
+        self.newpassword = newpassword
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        if self.currentpassword is None:
+            raise PyVLXException("currentpassword is none")
+        if self.newpassword is None:
+            raise PyVLXException("newpassword is none")
+        if len(self.currentpassword) > self.MAX_SIZE:
+            raise PyVLXException("currentpassword is too long")
+        if len(self.newpassword) > self.MAX_SIZE:
+            raise PyVLXException("newpassword is too long")
+
+        return string_to_bytes(self.currentpassword,
+                               self.MAX_SIZE)+string_to_bytes(self.newpassword, self.MAX_SIZE)
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.currentpassword = bytes_to_string(payload[0:32])
+        self.newpassword = bytes_to_string(payload[32:])
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        currentpassword_esc = (
+            None if self.currentpassword is None else "{}****".format(self.currentpassword[:2])
+        )
+        newpassword_esc = (
+            None if self.newpassword is None else "{}****".format(self.newpassword[:2])
+        )
+        return ('<{} currentpassword="{}" newpassword="{}"/>'
+                .format(type(self).__name__, currentpassword_esc, newpassword_esc))
+
+
+class PasswordChangeConfirmationStatus(Enum):
+    """Enum class for status of password change confirmation."""
+
+    SUCCESSFUL = 0
+    FAILED = 1
+
+
+class FramePasswordChangeConfirmation(FrameBase):
+    """Frame for confirmation for sent password."""
+
+    PAYLOAD_LEN = 1
+
+    def __init__(self, status: PasswordChangeConfirmationStatus = PasswordChangeConfirmationStatus.SUCCESSFUL):
+        """Init Frame."""
+        super().__init__(Command.GW_PASSWORD_CHANGE_CFM)
+        self.status = status
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        return bytes([self.status.value])
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.status = PasswordChangeConfirmationStatus(payload[0])
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} status="{}"/>'.format(type(self).__name__, self.status)
+
+
+class FramePasswordChangeNotification(FrameBase):
+    """Frame for sending password changed notification request."""
+
+    MAX_SIZE = 32
+    PAYLOAD_LEN = 32
+
+    def __init__(self, newpassword: Optional[str] = None):
+        """Init Frame."""
+        super().__init__(Command.GW_PASSWORD_CHANGE_NTF)
+        self.newpassword = newpassword
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        if self.newpassword is None:
+            raise PyVLXException("newpassword is none")
+        if len(self.newpassword) > self.MAX_SIZE:
+            raise PyVLXException("newpassword is too long")
+
+        return string_to_bytes(self.newpassword, self.MAX_SIZE)
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.newpassword = bytes_to_string(payload)
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        newpassword_esc = (
+            None if self.newpassword is None else "{}****".format(self.newpassword[:2])
+        )
+        return '<{} newpassword="{}"/>'.format(type(self).__name__, newpassword_esc)