pyvlx 0.2.27__py3-none-any.whl

pyvlx/api/frames/frame_password_enter.py

@@ -0,0 +1,70 @@
+"""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 FramePasswordEnterRequest(FrameBase):
+    """Frame for sending password enter request."""
+
+    MAX_SIZE = 32
+    PAYLOAD_LEN = 32
+
+    def __init__(self, password: Optional[str] = None):
+        """Init Frame."""
+        super().__init__(Command.GW_PASSWORD_ENTER_REQ)
+        self.password = password
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        if self.password is None:
+            raise PyVLXException("password is none")
+        if len(self.password) > self.MAX_SIZE:
+            raise PyVLXException("password is too long")
+        return string_to_bytes(self.password, self.MAX_SIZE)
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.password = bytes_to_string(payload)
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        password_esc = (
+            None if self.password is None else "{}****".format(self.password[:2])
+        )
+        return '<{} password="{}"/>'.format(type(self).__name__, password_esc)
+
+
+class PasswordEnterConfirmationStatus(Enum):
+    """Enum class for status of password enter confirmation."""
+
+    SUCCESSFUL = 0
+    FAILED = 1
+
+
+class FramePasswordEnterConfirmation(FrameBase):
+    """Frame for confirmation for sent password."""
+
+    PAYLOAD_LEN = 1
+
+    def __init__(self, status: PasswordEnterConfirmationStatus = PasswordEnterConfirmationStatus.SUCCESSFUL):
+        """Init Frame."""
+        super().__init__(Command.GW_PASSWORD_ENTER_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 = PasswordEnterConfirmationStatus(payload[0])
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} status="{}"/>'.format(type(self).__name__, self.status)

pyvlx/api/frames/frame_reboot.py

@@ -0,0 +1,32 @@
+"""Module for reboot frame classes."""
+from pyvlx.const import Command
+
+from .frame import FrameBase
+
+
+class FrameGatewayRebootRequest(FrameBase):
+    """Frame for requesting reboot."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_REBOOT_REQ)
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{}/>'.format(type(self).__name__)
+
+
+class FrameGatewayRebootConfirmation(FrameBase):
+    """Frame for response for reboot requests."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_REBOOT_CFM)
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{}/>'.format(type(self).__name__)

pyvlx/api/frames/frame_set_node_name.py

@@ -0,0 +1,73 @@
+"""Module for requesting change of node name."""
+from enum import Enum
+from typing import Optional
+
+from pyvlx.const import Command
+from pyvlx.string_helper import bytes_to_string, string_to_bytes
+
+from .frame import FrameBase
+
+
+class FrameSetNodeNameRequest(FrameBase):
+    """Frame for requesting node name change."""
+
+    PAYLOAD_LEN = 65
+
+    def __init__(self, node_id: int = 0, name: Optional[str] = None):
+        """Init Frame."""
+        super().__init__(Command.GW_SET_NODE_NAME_REQ)
+        self.node_id = node_id
+        self.name = name
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        ret = bytes([self.node_id])
+        assert self.name is not None
+        ret += string_to_bytes(self.name, 64)
+        return ret
+
+    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])
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} node_id="{}" name="{}"/>'.format(
+            type(self).__name__, self.node_id, self.name
+        )
+
+
+class SetNodeNameConfirmationStatus(Enum):
+    """Enum class for status of password enter confirmation."""
+
+    OK = 0
+    ERROR_REQUEST_REJECTED = 1
+    ERROR_INVALID_SYSTEM_TABLE_INDEX = 2
+
+
+class FrameSetNodeNameConfirmation(FrameBase):
+    """Frame for confirmation for set node name."""
+
+    PAYLOAD_LEN = 2
+
+    def __init__(self, status: SetNodeNameConfirmationStatus = SetNodeNameConfirmationStatus.OK, node_id: int = 0):
+        """Init Frame."""
+        super().__init__(Command.GW_SET_NODE_NAME_CFM)
+        self.status = status
+        self.node_id = node_id
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        return bytes([self.status.value, self.node_id])
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.status = SetNodeNameConfirmationStatus(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
+        )

pyvlx/api/frames/frame_set_utc.py

@@ -0,0 +1,45 @@
+"""Module for sending command to gw."""
+import struct
+from datetime import datetime
+
+from pyvlx.const import Command
+
+from .frame import FrameBase
+
+
+class FrameSetUTCConfirmation(FrameBase):
+    """Frame for confirmation for setting UTC time."""
+
+    PAYLOAD_LEN = 0
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_SET_UTC_CFM)
+
+
+class FrameSetUTCRequest(FrameBase):
+    """Frame for command for setting UTC time."""
+
+    PAYLOAD_LEN = 4
+
+    def __init__(self, timestamp: float = 0):
+        """Init Frame."""
+        super().__init__(Command.GW_SET_UTC_REQ)
+        self.timestamp = timestamp
+
+    @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 get_payload(self) -> bytes:
+        """Return Payload."""
+        return struct.pack(">I", self.timestamp)
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.timestamp = struct.unpack(">I", payload[0:4])[0]
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} time="{}"/>'.format(type(self).__name__, self.timestamp_formatted)

pyvlx/api/frames/frame_status_request.py

@@ -0,0 +1,212 @@
+"""Module for get node information from gateway."""
+from enum import Enum
+from typing import Dict, List, Optional
+
+from pyvlx.const import (
+    Command, NodeParameter, RunStatus, StatusReply, StatusType)
+from pyvlx.exception import PyVLXException
+from pyvlx.parameter import Parameter
+
+from .frame import FrameBase
+
+
+class FrameStatusRequestRequest(FrameBase):
+    """Frame for status request request."""
+
+    PAYLOAD_LEN = 26
+
+    def __init__(self, session_id: Optional[int] = None, node_ids: Optional[List[int]] = None):
+        """Init Frame."""
+        super().__init__(Command.GW_STATUS_REQUEST_REQ)
+        self.session_id = session_id
+        self.node_ids = node_ids if node_ids is not None else []
+        self.status_type = StatusType.REQUEST_CURRENT_POSITION
+        self.fpi1 = 254     # Request FP1 to FP7
+        self.fpi2 = 0
+
+    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.status_type.value])
+        ret += bytes([self.fpi1])
+        ret += bytes([self.fpi2])
+        return ret
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.session_id = payload[0] * 256 + payload[1]
+        len_node_ids = payload[2]
+        if len_node_ids > 20:
+            raise PyVLXException("command_send_request_wrong_node_length")
+        self.node_ids = []
+        for i in range(len_node_ids):
+            self.node_ids.append(payload[3] + i)
+
+        self.status_type = StatusType(payload[23])
+        self.fpi1 = payload[24]
+        self.fpi2 = payload[25]
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return (
+            '<{} session_id="{}" node_ids="{}" '
+            'status_type="{}" fpi1="{}" fpi2="{}"/>'.format(
+                type(self).__name__, self.session_id,
+                self.node_ids,
+                self.status_type, self.fpi1, self.fpi2
+            )
+        )
+
+
+class StatusRequestStatus(Enum):
+    """Enum for status request status."""
+
+    REJECTED = 0
+    ACCEPTED = 1
+
+
+class FrameStatusRequestConfirmation(FrameBase):
+    """Frame for confirmation for status request request."""
+
+    PAYLOAD_LEN = 3
+
+    def __init__(self, session_id: Optional[int] = None, status: Optional[StatusRequestStatus] = None):
+        """Init Frame."""
+        super().__init__(Command.GW_STATUS_REQUEST_CFM)
+        self.session_id = session_id
+        self.status = status
+
+    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.status is not None
+        ret += bytes([self.status.value])
+        return ret
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.session_id = payload[0] * 256 + payload[1]
+        self.status = StatusRequestStatus(payload[2])
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return '<{} session_id="{}" status="{}"/>'.format(
+            type(self).__name__, self.session_id, self.status
+        )
+
+
+class FrameStatusRequestNotification(FrameBase):
+    """Frame for notification of status request request."""
+
+    # PAYLOAD_LEN = 59
+    # No PAYLOAD_LEN because it is variable depending on StatusType
+
+    def __init__(self) -> None:
+        """Init Frame."""
+        super().__init__(Command.GW_STATUS_REQUEST_NTF)
+        self.session_id = 0
+        self.status_id = 0
+        self.node_id = 0
+        self.run_status = RunStatus.EXECUTION_COMPLETED
+        self.status_reply = StatusReply.UNKNOWN_STATUS_REPLY
+        self.status_type = StatusType.REQUEST_TARGET_POSITION
+        self.status_count = 0
+        self.parameter_data: Dict[NodeParameter, Parameter] = {}
+        self.target_position = Parameter()
+        self.current_position = Parameter()
+        self.remaining_time = 0
+        self.last_master_execution_address = b''
+        self.last_command_originator = 0
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        payload = bytes()
+        payload += bytes([self.session_id >> 8 & 255, self.session_id & 255])
+        payload += bytes([self.status_id])
+        payload += bytes([self.node_id])
+        payload += bytes([self.run_status.value])
+        payload += bytes([self.status_reply.value])
+        payload += bytes([self.status_type.value])
+        if self.status_type == StatusType.REQUEST_MAIN_INFO:
+            payload += bytes(self.target_position.raw)
+            payload += bytes(self.current_position.raw)
+            payload += bytes([self.remaining_time >> 8 & 255, self.remaining_time & 255])
+            payload += self.last_master_execution_address
+            payload += bytes([self.last_command_originator])
+        else:
+            payload += bytes([self.status_count])
+            keys = self.parameter_data.keys()
+            for key in keys:
+                payload += bytes([key.value])
+                payload += bytes(self.parameter_data[key].raw)
+            payload += bytes(51 - len(self.parameter_data))
+
+        return payload
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+        self.session_id = payload[0] * 256 + payload[1]
+        self.status_id = payload[2]
+        self.node_id = payload[3]
+        self.run_status = RunStatus(payload[4])
+        self.status_reply = StatusReply(payload[5])
+        self.status_type = StatusType(payload[6])
+        if self.status_type == StatusType.REQUEST_MAIN_INFO:
+            self.target_position = Parameter(payload[7:8])
+            self.current_position = Parameter(payload[9:10])
+            self.remaining_time = payload[11] * 256 + payload[12]
+            self.last_master_execution_address = payload[13:16]
+            self.last_command_originator = payload[17]
+        else:
+            self.status_count = payload[7]
+            for i in range(8, 8 + self.status_count*3, 3):
+                self.parameter_data.update({NodeParameter(payload[i]): Parameter(payload[i+1:i+3])})
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        if self.status_type == StatusType.REQUEST_MAIN_INFO:
+            return (
+                '<{} session_id="{}" status_id="{}" '
+                'node_id="{}" run_status="{}" status_reply="{}" status_type="{}" target_position="{}" '
+                'current_position="{}" remaining_time="{}" last_master_execution_address="{!r}" last_command_originator="{}"/>'.format(
+                    type(self).__name__,
+                    self.session_id,
+                    self.status_id,
+                    self.node_id,
+                    self.run_status,
+                    self.status_reply,
+                    self.status_type,
+                    self.target_position,
+                    self.current_position,
+                    self.remaining_time,
+                    self.last_master_execution_address,
+                    self.last_command_originator,
+                )
+            )
+
+        parameter_data_str = ""
+        for key, value in self.parameter_data.items():
+            parameter_data_str += "%s: %s, " % (
+                str(key),
+                str(value),
+            )
+
+        return (
+            '<{} session_id="{}" status_id="{}" '
+            'node_id="{}" run_status="{}" status_reply="{}" status_type="{}" status_count="{}" '
+            'parameter_data="{}"/>'.format(
+                type(self).__name__,
+                self.session_id,
+                self.status_id,
+                self.node_id,
+                self.run_status,
+                self.status_reply,
+                self.status_type,
+                self.status_count,
+                parameter_data_str
+            )
+        )

pyvlx/api/get_all_nodes_information.py

@@ -0,0 +1,46 @@
+"""Module for retrieving node information from API."""
+from typing import TYPE_CHECKING, List
+
+from pyvlx.log import PYVLXLOG
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameGetAllNodesInformationConfirmation,
+    FrameGetAllNodesInformationFinishedNotification,
+    FrameGetAllNodesInformationNotification,
+    FrameGetAllNodesInformationRequest)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class GetAllNodesInformation(ApiEvent):
+    """Class for retrieving node information from API."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize SceneList class."""
+        super().__init__(pyvlx=pyvlx)
+        self.number_of_nodes = 0
+        self.success = False
+        self.notification_frames: List[FrameGetAllNodesInformationNotification] = []
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if isinstance(frame, FrameGetAllNodesInformationConfirmation):
+            self.number_of_nodes = frame.number_of_nodes
+            # We are still waiting for FrameGetAllNodesInformationNotification
+            return False
+        if isinstance(frame, FrameGetAllNodesInformationNotification):
+            self.notification_frames.append(frame)
+        if isinstance(frame, FrameGetAllNodesInformationFinishedNotification):
+            if self.number_of_nodes != len(self.notification_frames):
+                PYVLXLOG.warning(
+                    "Number of received scenes does not match expected number"
+                )
+            self.success = True
+            return True
+        return False
+
+    def request_frame(self) -> FrameGetAllNodesInformationRequest:
+        """Construct initiating frame."""
+        return FrameGetAllNodesInformationRequest()

pyvlx/api/get_limitation.py

@@ -0,0 +1,64 @@
+"""Module for retrieving limitation value from API."""
+
+from typing import TYPE_CHECKING, Optional
+
+from ..const import LimitationType, Originator
+from ..parameter import Position
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameGetLimitationStatus, FrameGetLimitationStatusConfirmation,
+    FrameGetLimitationStatusNotification)
+from .session_id import get_new_session_id
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class GetLimitation(ApiEvent):
+    """Class for retrieving gateway state from API."""
+
+    def __init__(self, pyvlx: "PyVLX", node_id: int, limitation_type: LimitationType = LimitationType.MIN_LIMITATION):
+        """Initialize SceneList class."""
+        super().__init__(pyvlx=pyvlx)
+        self.node_id = node_id
+        self.limitation_type = limitation_type
+        self.success = False
+        self.notification_frame: Optional[FrameGetLimitationStatusNotification] = None
+        self.session_id: Optional[int] = None
+        self.min_value_raw: Optional[bytes] = None
+        self.max_value_raw: Optional[bytes] = None
+        self.originator: Optional[Originator] = None
+        self.limit_time: Optional[int] = None
+
+    @property
+    def max_value(self) -> int:
+        """Return max value."""
+        assert self.max_value_raw is not None
+        return Position.to_percent(self.max_value_raw)
+
+    @property
+    def min_value(self) -> int:
+        """Return min value."""
+        assert self.min_value_raw is not None
+        return Position.to_percent(self.min_value_raw)
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if isinstance(frame, FrameGetLimitationStatusConfirmation):
+            return False  # Wait for Notification Frame
+        if isinstance(frame, FrameGetLimitationStatusNotification):
+            if frame.session_id == self.session_id:
+                self.success = True
+                self.min_value_raw = frame.min_value
+                self.max_value_raw = frame.max_value
+                self.originator = frame.limit_originator
+                self.limit_time = frame.limit_time
+                self.notification_frame = frame
+                return True
+        return False
+
+    def request_frame(self) -> FrameGetLimitationStatus:
+        """Construct initiating frame."""
+        self.session_id = get_new_session_id()
+        return FrameGetLimitationStatus(node_ids=[self.node_id], session_id=self.session_id,
+                                        limitation_type=self.limitation_type)

pyvlx/api/get_local_time.py

@@ -0,0 +1,34 @@
+"""Module for local time firmware version from API."""
+from typing import TYPE_CHECKING
+
+from pyvlx.dataobjects import DtoLocalTime
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameGetLocalTimeConfirmation, FrameGetLocalTimeRequest)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class GetLocalTime(ApiEvent):
+    """Class for retrieving firmware version from API."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize GetLocalTime class."""
+        super().__init__(pyvlx=pyvlx)
+        self.success = False
+        self.localtime = DtoLocalTime()
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if not isinstance(frame, FrameGetLocalTimeConfirmation):
+            return False
+        self.localtime = frame.time
+        self.success = True
+
+        return True
+
+    def request_frame(self) -> FrameGetLocalTimeRequest:
+        """Construct initiating frame."""
+        return FrameGetLocalTimeRequest()

pyvlx/api/get_network_setup.py

@@ -0,0 +1,34 @@
+"""Module for retrieving gateway state from API."""
+from typing import TYPE_CHECKING
+
+from pyvlx.dataobjects import DtoNetworkSetup
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameGetNetworkSetupConfirmation, FrameGetNetworkSetupRequest)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class GetNetworkSetup(ApiEvent):
+    """Class for retrieving gateway state from API."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize GetNetworkSetup class."""
+        super().__init__(pyvlx=pyvlx)
+        self.success = False
+        self.networksetup = DtoNetworkSetup()
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if not isinstance(frame, FrameGetNetworkSetupConfirmation):
+            return False
+        self.success = True
+        self.networksetup = DtoNetworkSetup(
+            frame.ipaddress, frame.gateway, frame.netmask, frame.dhcp)
+        return True
+
+    def request_frame(self) -> FrameGetNetworkSetupRequest:
+        """Construct initiating frame."""
+        return FrameGetNetworkSetupRequest()

pyvlx/api/get_node_information.py

@@ -0,0 +1,42 @@
+"""Module for retrieving node information from API."""
+from typing import TYPE_CHECKING, Optional
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameGetNodeInformationConfirmation,
+    FrameGetNodeInformationNotification, FrameGetNodeInformationRequest)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class GetNodeInformation(ApiEvent):
+    """Class for retrieving node informationfrom API."""
+
+    def __init__(self, pyvlx: "PyVLX", node_id: int):
+        """Initialize SceneList class."""
+        super().__init__(pyvlx=pyvlx)
+        self.node_id = node_id
+        self.success = False
+        self.notification_frame: Optional[FrameGetNodeInformationNotification] = None
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if (
+                isinstance(frame, FrameGetNodeInformationConfirmation)
+                and frame.node_id == self.node_id
+        ):
+            # We are still waiting for GetNodeInformationNotification
+            return False
+        if (
+                isinstance(frame, FrameGetNodeInformationNotification)
+                and frame.node_id == self.node_id
+        ):
+            self.notification_frame = frame
+            self.success = True
+            return True
+        return False
+
+    def request_frame(self) -> FrameGetNodeInformationRequest:
+        """Construct initiating frame."""
+        return FrameGetNodeInformationRequest(node_id=self.node_id)