pyvlx 0.2.27__py3-none-any.whl

pyvlx/api/frames/frame_get_all_nodes_information.py

@@ -0,0 +1,218 @@
+"""Module for get all node information from gateway."""
+import struct
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+from pyvlx.const import (
+    Command, NodeTypeWithSubtype, NodeVariation, OperatingState, Velocity)
+from pyvlx.exception import PyVLXException
+from pyvlx.parameter import Parameter
+from pyvlx.string_helper import bytes_to_string, string_to_bytes
+
+from .alias_array import AliasArray
+from .frame import FrameBase
+
+
+class FrameGetAllNodesInformationRequest(FrameBase):
+    """Frame for get node information request."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_GET_ALL_NODES_INFORMATION_REQ)
+
+
+class AllNodesInformationStatus(Enum):
+    # pylint: disable=invalid-name
+    """Enum for node information status."""
+
+    OK = 0
+    Error_System_Table_Empty = 1
+
+
+class FrameGetAllNodesInformationConfirmation(FrameBase):
+    """Frame for confirmation for node information request."""
+
+    PAYLOAD_LEN = 2
+
+    def __init__(
+        self,
+        status: AllNodesInformationStatus = AllNodesInformationStatus.OK,
+        number_of_nodes: int = 0,
+    ):
+        """Init Frame."""
+        super().__init__(Command.GW_GET_ALL_NODES_INFORMATION_CFM)
+        self.status = status
+        self.number_of_nodes = number_of_nodes
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        return bytes([self.status.value, self.number_of_nodes])
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.status = AllNodesInformationStatus(payload[0])
+        self.number_of_nodes = payload[1]
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} status="{}" number_of_nodes="{}"/>'.format(
+            type(self).__name__, self.status, self.number_of_nodes
+        )
+
+
+class FrameGetAllNodesInformationNotification(FrameBase):
+    """Frame for notification of all nodes information request."""
+
+    PAYLOAD_LEN = 124
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_GET_ALL_NODES_INFORMATION_NTF)
+        self.node_id = 0
+        self.order = 0
+        self.placement = 0
+        self.name = ""
+        self.velocity = Velocity.DEFAULT
+        self.node_type = NodeTypeWithSubtype.NO_TYPE
+        self.product_group = 0
+        self.product_type = 0
+        self.node_variation = NodeVariation.NOT_SET
+        self.power_mode = 0
+        self.build_number = 0
+        self._serial_number = bytes(8)
+        self.state = OperatingState.UNKNOWN
+        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
+        self.alias_array = AliasArray()
+
+    @property
+    def serial_number(self) -> Optional[str]:
+        """Property for serial number in a human readable way."""
+        if self._serial_number == bytes(8):
+            return None
+        return ":".join("{:02x}".format(c) for c in self._serial_number)
+
+    @serial_number.setter
+    def serial_number(self, serial_number: str) -> None:
+        """Set serial number."""
+        if serial_number is None:
+            self._serial_number = bytes(8)
+            return
+        self._serial_number = b""
+        for elem in serial_number.split(":"):
+            self._serial_number += bytes.fromhex(elem)
+        if len(self._serial_number) != 8:
+            raise PyVLXException("could_not_parse_serial_number")
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        payload = bytes()
+        payload += bytes([self.node_id])
+        payload += bytes([self.order >> 8 & 255, self.order & 255])
+        payload += bytes([self.placement])
+        payload += bytes(string_to_bytes(self.name, 64))
+        payload += bytes([self.velocity.value])
+        payload += bytes([self.node_type.value >> 8 & 255, self.node_type.value & 255])
+        payload += bytes([self.product_group])
+        payload += bytes([self.product_type])
+        payload += bytes([self.node_variation.value])
+        payload += bytes([self.power_mode])
+        payload += bytes([self.build_number])
+        payload += bytes(self._serial_number)
+        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)
+        payload += bytes(self.alias_array)
+
+        return payload
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.node_id = payload[0]
+        self.order = payload[1] * 256 + payload[2]
+        self.placement = payload[3]
+        self.name = bytes_to_string(payload[4:68])
+        self.velocity = Velocity(payload[68])
+        self.node_type = NodeTypeWithSubtype(payload[69] * 256 + payload[70])
+        self.product_group = payload[71]
+        self.product_type = payload[72]
+        self.node_variation = NodeVariation(payload[73])
+        self.power_mode = payload[74]
+        self.build_number = payload[75]
+        self._serial_number = payload[76:84]
+        self.state = OperatingState(payload[84])
+        self.current_position = Parameter(payload[85:87])
+        self.target = Parameter(payload[87:89])
+        self.current_position_fp1 = Parameter(payload[89:91])
+        self.current_position_fp2 = Parameter(payload[91:93])
+        self.current_position_fp3 = Parameter(payload[93:95])
+        self.current_position_fp4 = Parameter(payload[95:97])
+        self.remaining_time = payload[97] * 256 + payload[98]
+        self.timestamp = struct.unpack(">I", payload[99:103])[0]
+        self.alias_array = AliasArray(payload[103:125])
+
+    @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="{}" order="{}" '
+            'placement="{}" name="{}" velocity="{}" node_type="{}" product_group="{}" '
+            'product_type="{}" node_variation="{}" power_mode="{}" build_number="{}" '
+            'serial_number="{}" state="{}" current_position="{}" '
+            'target="{}" current_position_fp1="{}" current_position_fp2="{}" '
+            'current_position_fp3="{}" current_position_fp4="{}" '
+            'remaining_time="{}" time="{}" alias_array="{}"/>'.format(
+                type(self).__name__,
+                self.node_id,
+                self.order,
+                self.placement,
+                self.name,
+                self.velocity,
+                self.node_type,
+                self.product_group,
+                self.product_type,
+                self.node_variation,
+                self.power_mode,
+                self.build_number,
+                self.serial_number,
+                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,
+                self.alias_array,
+            )
+        )
+
+
+class FrameGetAllNodesInformationFinishedNotification(FrameBase):
+    """Frame for notification of all nodes information finished notification."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_GET_ALL_NODES_INFORMATION_FINISHED_NTF)

pyvlx/api/frames/frame_get_limitation.py

@@ -0,0 +1,127 @@
+
+"""Module for get local time classes."""
+from typing import List, Optional
+
+from pyvlx.const import Command, LimitationType, Originator, Priority
+
+from .frame import FrameBase
+
+
+class FrameGetLimitationStatus(FrameBase):
+    """Frame for requesting limitation status."""
+
+    PAYLOAD_LEN = 25
+
+    def __init__(self,
+                 node_ids: Optional[List[int]] = None,
+                 session_id: Optional[int] = None,
+                 limitation_type: LimitationType = LimitationType.MIN_LIMITATION):
+        """Init Frame."""
+        super().__init__(Command.GW_GET_LIMITATION_STATUS_REQ)
+        self.session_id = session_id
+        self.originator = Originator.USER
+        self.priority = Priority.USER_LEVEL_2
+        self.node_ids = node_ids if node_ids is not None else []
+
+        self.parameter_id = 0  # Main Parameter
+        self.limitations_type = limitation_type
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        assert self.session_id is not None
+        ret = bytes([self.session_id >> 8 & 255, self.session_id & 255])
+        ret += bytes([len(self.node_ids)])  # index array count
+        ret += bytes(self.node_ids) + bytes(20 - len(self.node_ids))
+        ret += bytes([self.parameter_id])
+        ret += bytes([self.limitations_type.value])
+        return ret
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return f'<{type(self).__name__} node_ids="{self.node_ids}" ' \
+               f'session_id="{self.session_id}" originator="{self.originator}" />'
+
+
+class FrameGetLimitationStatusConfirmation(FrameBase):
+    """Frame for response for get limitation requests."""
+
+    PAYLOAD_LEN = 3
+
+    def __init__(self, session_id: Optional[int] = None, data: Optional[int] = None):
+        """Init Frame."""
+        super().__init__(Command.GW_GET_LIMITATION_STATUS_CFM)
+        self.session_id = session_id
+        self.data = data
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        assert self.session_id is not None
+        ret = bytes([self.session_id >> 8 & 255, self.session_id & 255])
+        assert self.data is not None
+        ret += bytes([self.data])
+        return ret
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.session_id = payload[0] * 256 + payload[1]
+        self.data = payload[2]
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} session_id="{}" status="{}"/>'.format(
+            type(self).__name__, self.session_id, self.data
+        )
+
+
+class FrameGetLimitationStatusNotification(FrameBase):
+    """Frame for notification of note information request."""
+
+    PAYLOAD_LEN = 10
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_LIMITATION_STATUS_NTF)
+        self.session_id: Optional[int] = None
+        self.node_id = 0
+        self.parameter_id = 0
+        self.min_value: Optional[bytes] = None
+        self.max_value: Optional[bytes] = None
+        self.limit_originator: Optional[Originator] = None
+        self.limit_time: Optional[int] = None
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        assert self.session_id is not None
+        assert self.min_value is not None
+        assert self.max_value is not None
+        assert self.limit_originator is not None
+        assert self.limit_time is not None
+        payload = bytes([self.session_id >> 8 & 255, self.session_id & 255])
+        payload += bytes([self.node_id])
+        payload += bytes([self.parameter_id])
+        payload += self.min_value
+        payload += self.max_value
+        payload += bytes([self.limit_originator.value])
+        payload += bytes([self.limit_time])
+        return payload
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.session_id = payload[0] * 256 + payload[1]
+        self.node_id = payload[2]
+        self.parameter_id = payload[3]
+        self.min_value = payload[4:5]
+        self.max_value = payload[6:7]
+        self.limit_originator = Originator(payload[8])
+        self.limit_time = payload[9]
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return (
+            '<{} node_id="{}" session_id="{}" min_value="{!r}" '
+            'max_value="{!r}" originator="{}" limit_time="{}"/>'.format(
+                type(self).__name__, self.node_id, self.session_id,
+                self.min_value, self.max_value, self.limit_originator,
+                self.limit_time
+            )
+        )

pyvlx/api/frames/frame_get_local_time.py

@@ -0,0 +1,38 @@
+"""Module for get local time classes."""
+from pyvlx.const import Command
+from pyvlx.dataobjects import DtoLocalTime
+
+from .frame import FrameBase
+
+
+class FrameGetLocalTimeRequest(FrameBase):
+    """Frame for requesting local time."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_GET_LOCAL_TIME_REQ)
+
+
+class FrameGetLocalTimeConfirmation(FrameBase):
+    """Frame for response for get local time requests."""
+
+    PAYLOAD_LEN = 15
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_GET_LOCAL_TIME_CFM)
+        self.time = DtoLocalTime()
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        return self.time.to_payload()
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.time.from_payload(payload)
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{0}>{1}</{0}>'.format(type(self).__name__, self.time)

pyvlx/api/frames/frame_get_network_setup.py

@@ -0,0 +1,64 @@
+"""Frames for receiving network setup from gateway."""
+from pyvlx.const import Command, DHCPParameter
+
+from .frame import FrameBase
+
+
+class FrameGetNetworkSetupRequest(FrameBase):
+    """Frame for requesting network setup."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_GET_NETWORK_SETUP_REQ)
+
+
+class FrameGetNetworkSetupConfirmation(FrameBase):
+    """Frame for confirmation for get network setup requests."""
+
+    PAYLOAD_LEN = 13
+
+    def __init__(self, ipaddress: bytes = bytes(4), netmask: bytes = bytes(4), gateway: bytes = bytes(4),
+                 dhcp: DHCPParameter = DHCPParameter.DISABLE):
+        """Init Frame."""
+        super().__init__(Command.GW_GET_NETWORK_SETUP_CFM)
+        self._ipaddress = ipaddress
+        self._netmask = netmask
+        self._gateway = gateway
+        self.dhcp = dhcp
+
+    @property
+    def ipaddress(self) -> str:
+        """Return ipaddress as human readable string."""
+        return ".".join(str(c) for c in self._ipaddress)
+
+    @property
+    def netmask(self) -> str:
+        """Return ipaddress as human readable string."""
+        return ".".join(str(c) for c in self._netmask)
+
+    @property
+    def gateway(self) -> str:
+        """Return ipaddress as human readable string."""
+        return ".".join(str(c) for c in self._gateway)
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        payload = self._ipaddress
+        payload += self._netmask
+        payload += self._gateway
+        payload += bytes(self.dhcp.value)
+        return payload
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self._ipaddress = payload[0:4]
+        self._netmask = payload[4:8]
+        self._gateway = payload[8:12]
+        self.dhcp = DHCPParameter(payload[12])
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} ipaddress="{}" netmask="{}" gateway="{}" dhcp="{}"/>'.format(
+            type(self).__name__, self.ipaddress, self.netmask, self.gateway, self.dhcp)

pyvlx/api/frames/frame_get_node_information.py

@@ -0,0 +1,223 @@
+"""Module for get node information from gateway."""
+import struct
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+from pyvlx.const import (
+    Command, NodeTypeWithSubtype, NodeVariation, OperatingState, Velocity)
+from pyvlx.exception import PyVLXException
+from pyvlx.parameter import Parameter
+from pyvlx.string_helper import bytes_to_string, string_to_bytes
+
+from .alias_array import AliasArray
+from .frame import FrameBase
+
+
+class FrameGetNodeInformationRequest(FrameBase):
+    """Frame for get node information request."""
+
+    PAYLOAD_LEN = 1
+
+    def __init__(self, node_id: Optional[int] = None):
+        """Init Frame."""
+        super().__init__(Command.GW_GET_NODE_INFORMATION_REQ)
+        self.node_id = node_id
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        assert self.node_id is not None
+        return bytes([self.node_id])
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.node_id = payload[0]
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} node_id="{}"/>'.format(type(self).__name__, self.node_id)
+
+
+class NodeInformationStatus(Enum):
+    # pylint: disable=invalid-name
+    """Enum for node information status."""
+
+    OK = 0
+    Error_Request_Rejected = 1
+    Error_Invalid_Node_Index = 2
+
+
+class FrameGetNodeInformationConfirmation(FrameBase):
+    """Frame for confirmation for node information request."""
+
+    PAYLOAD_LEN = 2
+
+    def __init__(self, status: NodeInformationStatus = NodeInformationStatus.OK, node_id: Optional[int] = None):
+        """Init Frame."""
+        super().__init__(Command.GW_GET_NODE_INFORMATION_CFM)
+        self.status = status
+        self.node_id = node_id
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        assert self.node_id is not None
+        return bytes([self.status.value, self.node_id])
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.status = NodeInformationStatus(payload[0])
+        self.node_id = payload[1]
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} node_id="{}" status="{}"/>'.format(
+            type(self).__name__, self.node_id, self.status
+        )
+
+
+class FrameGetNodeInformationNotification(FrameBase):
+    """Frame for notification of node information request."""
+
+    PAYLOAD_LEN = 124
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_GET_NODE_INFORMATION_NTF)
+        self.node_id = 0
+        self.order = 0
+        self.placement = 0
+        self.name = ""
+        self.velocity = Velocity.DEFAULT
+        self.node_type = NodeTypeWithSubtype.NO_TYPE
+        self.product_group = 0
+        self.product_type = 0
+        self.node_variation = NodeVariation.NOT_SET
+        self.power_mode = 0
+        self.build_number = 0
+        self._serial_number = bytes(8)
+        self.state = OperatingState.UNKNOWN
+        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
+        self.alias_array = AliasArray()
+
+    @property
+    def serial_number(self) -> Optional[str]:
+        """Property for serial number in a human readable way."""
+        if self._serial_number == bytes(8):
+            return None
+        return ":".join("{:02x}".format(c) for c in self._serial_number)
+
+    @serial_number.setter
+    def serial_number(self, serial_number: Optional[str]) -> None:
+        """Set serial number."""
+        if serial_number is None:
+            self._serial_number = bytes(8)
+            return
+        self._serial_number = b""
+        for elem in serial_number.split(":"):
+            self._serial_number += bytes.fromhex(elem)
+        if len(self._serial_number) != 8:
+            raise PyVLXException("could_not_parse_serial_number")
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        payload = bytes()
+        payload += bytes([self.node_id])
+        payload += bytes([self.order >> 8 & 255, self.order & 255])
+        payload += bytes([self.placement])
+        payload += bytes(string_to_bytes(self.name, 64))
+        payload += bytes([self.velocity.value])
+        payload += bytes([self.node_type.value >> 8 & 255, self.node_type.value & 255])
+        payload += bytes([self.product_group])
+        payload += bytes([self.product_type])
+        payload += bytes([self.node_variation.value])
+        payload += bytes([self.power_mode])
+        payload += bytes(
+            [self.build_number]
+        )  # <-- hey @VELUX: your documentation is wrong here
+        payload += bytes(self._serial_number)
+        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)
+        payload += bytes(self.alias_array)
+        return payload
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.node_id = payload[0]
+        self.order = payload[1] * 256 + payload[2]
+        self.placement = payload[3]
+        self.name = bytes_to_string(payload[4:68])
+        self.velocity = Velocity(payload[68])
+        self.node_type = NodeTypeWithSubtype(payload[69] * 256 + payload[70])
+        self.product_group = payload[71]
+        self.product_type = payload[72]
+        self.node_variation = NodeVariation(payload[73])
+        self.power_mode = payload[74]
+        self.build_number = payload[
+            75
+        ]  # <-- hey @VELUX: your documentation is wrong here
+        self._serial_number = payload[76:84]
+        self.state = OperatingState(payload[84])
+        self.current_position = Parameter(payload[85:87])
+        self.target = Parameter(payload[87:89])
+        self.current_position_fp1 = Parameter(payload[89:91])
+        self.current_position_fp2 = Parameter(payload[91:93])
+        self.current_position_fp3 = Parameter(payload[93:95])
+        self.current_position_fp4 = Parameter(payload[95:97])
+        self.remaining_time = payload[97] * 256 + payload[98]
+        self.timestamp = struct.unpack(">I", payload[99:103])[0]
+        self.alias_array = AliasArray(payload[103:125])
+
+    @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="{}" order="{}" '
+            'placement="{}" name="{}" velocity="{}" node_type="{}" product_group="{}" '
+            'product_type="{}" node_variation="{}" power_mode="{}" build_number="{}" '
+            'serial_number="{}" state="{}" current_position="{}" '
+            'target="{}" current_position_fp1="{}" current_position_fp2="{}" '
+            'current_position_fp3="{}" current_position_fp4="{}" '
+            'remaining_time="{}" time="{}" alias_array="{}"/>'.format(
+                type(self).__name__,
+                self.node_id,
+                self.order,
+                self.placement,
+                self.name,
+                self.velocity,
+                self.node_type,
+                self.product_group,
+                self.product_type,
+                self.node_variation,
+                self.power_mode,
+                self.build_number,
+                self.serial_number,
+                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,
+                self.alias_array,
+            )
+        )