pyvlx 0.2.27__py3-none-any.whl

pyvlx/__init__.py

@@ -0,0 +1,21 @@
+"""Module for accessing KLF 200 gateway with python."""
+
+from .discovery import VeluxDiscovery
+from .exception import PyVLXException
+from .klf200gateway import Klf200Gateway
+from .lightening_device import Light, LighteningDevice
+from .log import PYVLXLOG
+from .node import Node
+from .nodes import Nodes
+from .on_off_switch import OnOffSwitch
+from .opening_device import (
+    Awning, Blade, Blind, GarageDoor, Gate, OpeningDevice, RollerShutter,
+    Window)
+from .parameter import (
+    CurrentIntensity, CurrentPosition, Intensity, Parameter, Position,
+    SwitchParameter, SwitchParameterOff, SwitchParameterOn, UnknownIntensity,
+    UnknownPosition)
+# flake8: noqa
+from .pyvlx import PyVLX
+from .scene import Scene
+from .scenes import Scenes

pyvlx/api/__init__.py

@@ -0,0 +1,23 @@
+"""Module for all KLF 200 API frames."""
+# flake8: noqa
+
+from .activate_scene import ActivateScene
+from .api_event import ApiEvent
+from .command_send import CommandSend
+from .factory_default import FactoryDefault
+from .get_all_nodes_information import GetAllNodesInformation
+from .get_local_time import (
+    FrameGetLocalTimeConfirmation, FrameGetLocalTimeRequest, GetLocalTime)
+from .get_network_setup import GetNetworkSetup
+from .get_node_information import GetNodeInformation
+from .get_protocol_version import GetProtocolVersion
+from .get_scene_list import GetSceneList
+from .get_state import GetState
+from .get_version import GetVersion
+from .house_status_monitor import (
+    HouseStatusMonitorDisable, HouseStatusMonitorEnable)
+from .leave_learn_state import LeaveLearnState
+from .password_enter import PasswordEnter
+from .reboot import Reboot
+from .set_node_name import SetNodeName
+from .set_utc import SetUTC

pyvlx/api/activate_scene.py

@@ -0,0 +1,63 @@
+"""Module for retrieving scene list from API."""
+from typing import TYPE_CHECKING, Optional
+
+from .api_event import ApiEvent
+from .frames import (
+    ActivateSceneConfirmationStatus, FrameActivateSceneConfirmation,
+    FrameActivateSceneRequest, FrameBase,
+    FrameCommandRemainingTimeNotification, FrameCommandRunStatusNotification,
+    FrameSessionFinishedNotification)
+from .session_id import get_new_session_id
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class ActivateScene(ApiEvent):
+    """Class for activating scene via API."""
+
+    def __init__(
+            self, pyvlx: "PyVLX", scene_id: int, wait_for_completion: bool = True, timeout_in_seconds: int = 60
+    ):
+        """Initialize SceneList class."""
+        super().__init__(pyvlx=pyvlx, timeout_in_seconds=timeout_in_seconds)
+        self.success = False
+        self.scene_id = scene_id
+        self.wait_for_completion = wait_for_completion
+        self.session_id: Optional[int] = None
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if (
+                isinstance(frame, FrameActivateSceneConfirmation)
+                and frame.session_id == self.session_id
+        ):
+            if frame.status == ActivateSceneConfirmationStatus.ACCEPTED:
+                self.success = True
+            return not self.wait_for_completion
+        if (
+                isinstance(frame, FrameCommandRemainingTimeNotification)
+                and frame.session_id == self.session_id
+        ):
+            # Ignoring FrameCommandRemainingTimeNotification
+            return False
+        if (
+                isinstance(frame, FrameCommandRunStatusNotification)
+                and frame.session_id == self.session_id
+        ):
+            # At the moment I don't reall understand what the FrameCommandRunStatusNotification is good for.
+            # Ignoring these packets for now
+            return False
+        if (
+                isinstance(frame, FrameSessionFinishedNotification)
+                and frame.session_id == self.session_id
+        ):
+            return True
+        return False
+
+    def request_frame(self) -> FrameActivateSceneRequest:
+        """Construct initiating frame."""
+        self.session_id = get_new_session_id()
+        return FrameActivateSceneRequest(
+            scene_id=self.scene_id, session_id=self.session_id
+        )

pyvlx/api/api_event.py

@@ -0,0 +1,73 @@
+"""Base class for waiting for a specific answer frame from velux ap.."""
+import asyncio
+from typing import TYPE_CHECKING, Optional
+
+from .frames import FrameBase
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class ApiEvent:
+    """Base class for waiting a specific frame from API connection."""
+
+    def __init__(self, pyvlx: "PyVLX", timeout_in_seconds: int = 10):
+        """Initialize ApiEvent."""
+        self.pyvlx = pyvlx
+        self.response_received_or_timeout = asyncio.Event()
+
+        self.success = False
+        self.timeout_in_seconds = timeout_in_seconds
+        self.timeout_callback = None
+        self.timeout_handle: Optional[asyncio.TimerHandle] = None
+
+    async def do_api_call(self) -> None:
+        """Start. Sending and waiting for answer."""
+        # We check for connection before entering the semaphore section
+        # because otherwise we might try to connect, which calls this, and we get stuck on
+        # the semaphore.
+        await self.pyvlx.check_connected()
+
+        if self.pyvlx.get_connected():
+            async with self.pyvlx.api_call_semaphore:
+                self.pyvlx.connection.register_frame_received_cb(self.response_rec_callback)
+                await self.send_frame()
+                await self.start_timeout()
+                await self.response_received_or_timeout.wait()
+                self.response_received_or_timeout.clear()
+                await self.stop_timeout()
+                self.pyvlx.connection.unregister_frame_received_cb(self.response_rec_callback)
+        else:
+            self.success = False
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        raise NotImplementedError("handle_frame has to be implemented")
+
+    async def send_frame(self) -> None:
+        """Send frame to API connection."""
+        await self.pyvlx.send_frame(self.request_frame())
+
+    def request_frame(self) -> FrameBase:
+        """Construct initiating frame."""
+        raise NotImplementedError("send_frame has to be implemented")
+
+    async def response_rec_callback(self, frame: FrameBase) -> None:
+        """Handle frame. Callback from internal api connection."""
+        if await self.handle_frame(frame):
+            self.response_received_or_timeout.set()
+
+    def timeout(self) -> None:
+        """Handle timeout for not having received expected frame."""
+        self.response_received_or_timeout.set()
+
+    async def start_timeout(self) -> None:
+        """Start timeout."""
+        self.timeout_handle = self.pyvlx.connection.loop.call_later(
+            self.timeout_in_seconds, self.timeout
+        )
+
+    async def stop_timeout(self) -> None:
+        """Stop timeout."""
+        if self.timeout_handle is not None:
+            self.timeout_handle.cancel()

pyvlx/api/command_send.py

@@ -0,0 +1,85 @@
+"""Module for retrieving scene list from API."""
+from typing import TYPE_CHECKING, Any, Optional
+
+from ..exception import PyVLXException
+from ..parameter import Parameter
+from .api_event import ApiEvent
+from .frames import (
+    CommandSendConfirmationStatus, FrameBase,
+    FrameCommandRemainingTimeNotification, FrameCommandRunStatusNotification,
+    FrameCommandSendConfirmation, FrameCommandSendRequest,
+    FrameSessionFinishedNotification)
+from .session_id import get_new_session_id
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class CommandSend(ApiEvent):
+    """Class for sending command to API."""
+
+    def __init__(
+            self,
+            pyvlx: "PyVLX",
+            node_id: int,
+            parameter: Parameter,
+            active_parameter: int = 0,
+            wait_for_completion: bool = True,
+            timeout_in_seconds: int = 2,
+            **functional_parameter: Any
+    ):
+        """Initialize SceneList class."""
+        super().__init__(pyvlx=pyvlx, timeout_in_seconds=timeout_in_seconds)
+        self.success = False
+        self.node_id = node_id
+        self.parameter = parameter
+        self.active_parameter = active_parameter
+        self.functional_parameter = functional_parameter
+        self.wait_for_completion = wait_for_completion
+        self.session_id: Optional[int] = None
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if (
+                isinstance(frame, FrameCommandSendConfirmation)
+                and frame.session_id == self.session_id
+        ):
+            if frame.status == CommandSendConfirmationStatus.ACCEPTED:
+                self.success = True
+            return not self.wait_for_completion
+        if (
+                isinstance(frame, FrameCommandRemainingTimeNotification)
+                and frame.session_id == self.session_id
+        ):
+            # Ignoring FrameCommandRemainingTimeNotification
+            return False
+        if (
+                isinstance(frame, FrameCommandRunStatusNotification)
+                and frame.session_id == self.session_id
+        ):
+            # At the moment I don't reall understand what the FrameCommandRunStatusNotification is good for.
+            # Ignoring these packets for now
+            return False
+        if (
+                isinstance(frame, FrameSessionFinishedNotification)
+                and frame.session_id == self.session_id
+        ):
+            return True
+        return False
+
+    async def send(self) -> None:
+        """Send frame to KLF200."""
+        await self.do_api_call()
+        if not self.success:
+            raise PyVLXException("Unable to send command")
+
+    def request_frame(self) -> FrameCommandSendRequest:
+        """Construct initiating frame."""
+        self.session_id = get_new_session_id()
+        return FrameCommandSendRequest(
+            node_ids=[self.node_id],
+            parameter=self.parameter,
+            active_parameter=self.active_parameter,
+            session_id=self.session_id,
+            **self.functional_parameter
+        )

pyvlx/api/factory_default.py

@@ -0,0 +1,34 @@
+"""Module for handling the FactoryDefault to API."""
+from typing import TYPE_CHECKING
+
+from pyvlx.log import PYVLXLOG
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameGatewayFactoryDefaultConfirmation,
+    FrameGatewayFactoryDefaultRequest)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class FactoryDefault(ApiEvent):
+    """Class for handling Factory reset API."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize facotry default class."""
+        super().__init__(pyvlx=pyvlx)
+        self.pyvlx = pyvlx
+        self.success = False
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if isinstance(frame, FrameGatewayFactoryDefaultConfirmation):
+            PYVLXLOG.warning("KLF200 is factory resetting")
+            self.success = True
+            return True
+        return False
+
+    def request_frame(self) -> FrameGatewayFactoryDefaultRequest:
+        """Construct initiating frame."""
+        return FrameGatewayFactoryDefaultRequest()

pyvlx/api/frame_creation.py

@@ -0,0 +1,202 @@
+"""Helper module for creating a frame out of raw data."""
+from typing import Optional
+
+from pyvlx.const import Command
+from pyvlx.log import PYVLXLOG
+
+from .frames import (
+    FrameActivateSceneConfirmation, FrameActivateSceneRequest,
+    FrameActivationLogUpdatedNotification, FrameBase,
+    FrameCommandRemainingTimeNotification, FrameCommandRunStatusNotification,
+    FrameCommandSendConfirmation, FrameCommandSendRequest,
+    FrameDiscoverNodesConfirmation, FrameDiscoverNodesNotification,
+    FrameDiscoverNodesRequest, FrameErrorNotification,
+    FrameGatewayFactoryDefaultConfirmation, FrameGatewayFactoryDefaultRequest,
+    FrameGatewayRebootConfirmation, FrameGatewayRebootRequest,
+    FrameGetAllNodesInformationConfirmation,
+    FrameGetAllNodesInformationFinishedNotification,
+    FrameGetAllNodesInformationNotification,
+    FrameGetAllNodesInformationRequest, FrameGetLimitationStatus,
+    FrameGetLimitationStatusConfirmation, FrameGetLimitationStatusNotification,
+    FrameGetLocalTimeConfirmation, FrameGetLocalTimeRequest,
+    FrameGetNetworkSetupConfirmation, FrameGetNetworkSetupRequest,
+    FrameGetNodeInformationConfirmation, FrameGetNodeInformationNotification,
+    FrameGetNodeInformationRequest, FrameGetProtocolVersionConfirmation,
+    FrameGetProtocolVersionRequest, FrameGetSceneListConfirmation,
+    FrameGetSceneListNotification, FrameGetSceneListRequest,
+    FrameGetStateConfirmation, FrameGetStateRequest,
+    FrameGetVersionConfirmation, FrameGetVersionRequest,
+    FrameHouseStatusMonitorDisableConfirmation,
+    FrameHouseStatusMonitorDisableRequest,
+    FrameHouseStatusMonitorEnableConfirmation,
+    FrameHouseStatusMonitorEnableRequest, FrameLeaveLearnStateConfirmation,
+    FrameLeaveLearnStateRequest, FrameNodeInformationChangedNotification,
+    FrameNodeStatePositionChangedNotification, FramePasswordChangeConfirmation,
+    FramePasswordChangeNotification, FramePasswordChangeRequest,
+    FramePasswordEnterConfirmation, FramePasswordEnterRequest,
+    FrameSessionFinishedNotification, FrameSetNodeNameConfirmation,
+    FrameSetNodeNameRequest, FrameSetUTCConfirmation, FrameSetUTCRequest,
+    FrameStatusRequestConfirmation, FrameStatusRequestNotification,
+    FrameStatusRequestRequest, extract_from_frame)
+
+
+def frame_from_raw(raw: bytes) -> Optional[FrameBase]:
+    """Create and return frame from raw bytes."""
+    command, payload = extract_from_frame(raw)
+    frame = create_frame(command)
+    if frame is None:
+        PYVLXLOG.warning(
+            "Command %s not implemented, raw: %s",
+            command,
+            ":".join("{:02x}".format(c) for c in raw),
+        )
+        return None
+    frame.validate_payload_len(payload)
+    frame.from_payload(payload)
+    return frame
+
+
+def create_frame(command: Command) -> Optional[FrameBase]:
+    """Create and return empty Frame from Command."""
+    # pylint: disable=too-many-branches,too-many-return-statements,too-many-statements
+    if command == Command.GW_ERROR_NTF:
+        return FrameErrorNotification()
+    if command == Command.GW_COMMAND_SEND_REQ:
+        return FrameCommandSendRequest()
+    if command == Command.GW_COMMAND_SEND_CFM:
+        return FrameCommandSendConfirmation()
+    if command == Command.GW_COMMAND_RUN_STATUS_NTF:
+        return FrameCommandRunStatusNotification()
+    if command == Command.GW_COMMAND_REMAINING_TIME_NTF:
+        return FrameCommandRemainingTimeNotification()
+    if command == Command.GW_SESSION_FINISHED_NTF:
+        return FrameSessionFinishedNotification()
+
+    if command == Command.GW_PASSWORD_ENTER_REQ:
+        return FramePasswordEnterRequest()
+    if command == Command.GW_PASSWORD_ENTER_CFM:
+        return FramePasswordEnterConfirmation()
+
+    if command == Command.GW_PASSWORD_CHANGE_REQ:
+        return FramePasswordChangeRequest()
+    if command == Command.GW_PASSWORD_CHANGE_CFM:
+        return FramePasswordChangeConfirmation()
+    if command == Command.GW_PASSWORD_CHANGE_NTF:
+        return FramePasswordChangeNotification()
+
+    if command == Command.GW_REBOOT_REQ:
+        return FrameGatewayRebootRequest()
+    if command == Command.GW_REBOOT_CFM:
+        return FrameGatewayRebootConfirmation()
+
+    if command == Command.GW_SET_FACTORY_DEFAULT_REQ:
+        return FrameGatewayFactoryDefaultRequest()
+    if command == Command.GW_SET_FACTORY_DEFAULT_CFM:
+        return FrameGatewayFactoryDefaultConfirmation()
+
+    if command == Command.GW_GET_LOCAL_TIME_REQ:
+        return FrameGetLocalTimeRequest()
+    if command == Command.GW_GET_LOCAL_TIME_CFM:
+        return FrameGetLocalTimeConfirmation()
+
+    if command == Command.GW_CS_DISCOVER_NODES_REQ:
+        return FrameDiscoverNodesRequest()
+    if command == Command.GW_CS_DISCOVER_NODES_CFM:
+        return FrameDiscoverNodesConfirmation()
+    if command == Command.GW_CS_DISCOVER_NODES_NTF:
+        return FrameDiscoverNodesNotification()
+
+    if command == Command.GW_GET_SCENE_LIST_REQ:
+        return FrameGetSceneListRequest()
+    if command == Command.GW_GET_SCENE_LIST_CFM:
+        return FrameGetSceneListConfirmation()
+    if command == Command.GW_GET_SCENE_LIST_NTF:
+        return FrameGetSceneListNotification()
+
+    if command == Command.GW_GET_NODE_INFORMATION_REQ:
+        return FrameGetNodeInformationRequest()
+    if command == Command.GW_GET_NODE_INFORMATION_CFM:
+        return FrameGetNodeInformationConfirmation()
+    if command == Command.GW_GET_NODE_INFORMATION_NTF:
+        return FrameGetNodeInformationNotification()
+
+    if command == Command.GW_GET_ALL_NODES_INFORMATION_REQ:
+        return FrameGetAllNodesInformationRequest()
+    if command == Command.GW_GET_ALL_NODES_INFORMATION_CFM:
+        return FrameGetAllNodesInformationConfirmation()
+    if command == Command.GW_GET_ALL_NODES_INFORMATION_NTF:
+        return FrameGetAllNodesInformationNotification()
+    if command == Command.GW_GET_ALL_NODES_INFORMATION_FINISHED_NTF:
+        return FrameGetAllNodesInformationFinishedNotification()
+
+    if command == Command.GW_ACTIVATE_SCENE_REQ:
+        return FrameActivateSceneRequest()
+    if command == Command.GW_ACTIVATE_SCENE_CFM:
+        return FrameActivateSceneConfirmation()
+
+    if command == Command.GW_GET_VERSION_REQ:
+        return FrameGetVersionRequest()
+    if command == Command.GW_GET_VERSION_CFM:
+        return FrameGetVersionConfirmation()
+    if command == Command.GW_GET_PROTOCOL_VERSION_REQ:
+        return FrameGetProtocolVersionRequest()
+    if command == Command.GW_GET_PROTOCOL_VERSION_CFM:
+        return FrameGetProtocolVersionConfirmation()
+
+    if command == Command.GW_SET_NODE_NAME_REQ:
+        return FrameSetNodeNameRequest()
+    if command == Command.GW_SET_NODE_NAME_CFM:
+        return FrameSetNodeNameConfirmation()
+
+    if command == Command.GW_NODE_INFORMATION_CHANGED_NTF:
+        return FrameNodeInformationChangedNotification()
+
+    if command == Command.GW_GET_STATE_REQ:
+        return FrameGetStateRequest()
+    if command == Command.GW_GET_STATE_CFM:
+        return FrameGetStateConfirmation()
+
+    if command == Command.GW_GET_LIMITATION_STATUS_REQ:
+        return FrameGetLimitationStatus()
+    if command == Command.GW_GET_LIMITATION_STATUS_CFM:
+        return FrameGetLimitationStatusConfirmation()
+    if command == Command.GW_LIMITATION_STATUS_NTF:
+        return FrameGetLimitationStatusNotification()
+
+    if command == Command.GW_GET_NETWORK_SETUP_REQ:
+        return FrameGetNetworkSetupRequest()
+    if command == Command.GW_GET_NETWORK_SETUP_CFM:
+        return FrameGetNetworkSetupConfirmation()
+
+    if command == Command.GW_SET_UTC_REQ:
+        return FrameSetUTCRequest()
+    if command == Command.GW_SET_UTC_CFM:
+        return FrameSetUTCConfirmation()
+
+    if command == Command.GW_ACTIVATION_LOG_UPDATED_NTF:
+        return FrameActivationLogUpdatedNotification()
+
+    if command == Command.GW_HOUSE_STATUS_MONITOR_ENABLE_REQ:
+        return FrameHouseStatusMonitorEnableRequest()
+    if command == Command.GW_HOUSE_STATUS_MONITOR_ENABLE_CFM:
+        return FrameHouseStatusMonitorEnableConfirmation()
+    if command == Command.GW_HOUSE_STATUS_MONITOR_DISABLE_REQ:
+        return FrameHouseStatusMonitorDisableRequest()
+    if command == Command.GW_HOUSE_STATUS_MONITOR_DISABLE_CFM:
+        return FrameHouseStatusMonitorDisableConfirmation()
+
+    if command == Command.GW_NODE_STATE_POSITION_CHANGED_NTF:
+        return FrameNodeStatePositionChangedNotification()
+    if command == Command.GW_LEAVE_LEARN_STATE_CFM:
+        return FrameLeaveLearnStateConfirmation()
+    if command == Command.GW_LEAVE_LEARN_STATE_REQ:
+        return FrameLeaveLearnStateRequest()
+
+    if command == Command.GW_STATUS_REQUEST_REQ:
+        return FrameStatusRequestRequest()
+    if command == Command.GW_STATUS_REQUEST_CFM:
+        return FrameStatusRequestConfirmation()
+    if command == Command.GW_STATUS_REQUEST_NTF:
+        return FrameStatusRequestNotification()
+
+    return None

pyvlx/api/frames/__init__.py

@@ -0,0 +1,76 @@
+"""Module for all KLF 200 API frames."""
+
+from .alias_array import AliasArray
+# flake8: noqa
+from .frame import FrameBase
+from .frame_activate_scene import (
+    ActivateSceneConfirmationStatus, FrameActivateSceneConfirmation,
+    FrameActivateSceneRequest)
+from .frame_activation_log_updated import FrameActivationLogUpdatedNotification
+from .frame_command_send import (
+    CommandSendConfirmationStatus, FrameCommandRemainingTimeNotification,
+    FrameCommandRunStatusNotification, FrameCommandSendConfirmation,
+    FrameCommandSendRequest, FrameSessionFinishedNotification)
+from .frame_discover_nodes import (
+    FrameDiscoverNodesConfirmation, FrameDiscoverNodesNotification,
+    FrameDiscoverNodesRequest)
+from .frame_error_notification import ErrorType, FrameErrorNotification
+from .frame_facory_default import (
+    FrameGatewayFactoryDefaultConfirmation, FrameGatewayFactoryDefaultRequest)
+from .frame_get_all_nodes_information import (
+    FrameGetAllNodesInformationConfirmation,
+    FrameGetAllNodesInformationFinishedNotification,
+    FrameGetAllNodesInformationNotification,
+    FrameGetAllNodesInformationRequest)
+from .frame_get_limitation import (
+    FrameGetLimitationStatus, FrameGetLimitationStatusConfirmation,
+    FrameGetLimitationStatusNotification)
+from .frame_get_local_time import (
+    FrameGetLocalTimeConfirmation, FrameGetLocalTimeRequest)
+from .frame_get_network_setup import (
+    DHCPParameter, FrameGetNetworkSetupConfirmation,
+    FrameGetNetworkSetupRequest)
+from .frame_get_node_information import (
+    FrameGetNodeInformationConfirmation, FrameGetNodeInformationNotification,
+    FrameGetNodeInformationRequest)
+from .frame_get_protocol_version import (
+    FrameGetProtocolVersionConfirmation, FrameGetProtocolVersionRequest)
+from .frame_get_scene_list import (
+    FrameGetSceneListConfirmation, FrameGetSceneListNotification,
+    FrameGetSceneListRequest)
+from .frame_get_state import (
+    FrameGetStateConfirmation, FrameGetStateRequest, GatewayState,
+    GatewaySubState)
+from .frame_get_version import (
+    FrameGetVersionConfirmation, FrameGetVersionRequest)
+from .frame_helper import calc_crc, extract_from_frame
+from .frame_house_status_monitor_disable_cfm import (
+    FrameHouseStatusMonitorDisableConfirmation)
+from .frame_house_status_monitor_disable_req import (
+    FrameHouseStatusMonitorDisableRequest)
+from .frame_house_status_monitor_enable_cfm import (
+    FrameHouseStatusMonitorEnableConfirmation)
+from .frame_house_status_monitor_enable_req import (
+    FrameHouseStatusMonitorEnableRequest)
+from .frame_leave_learn_state import (
+    FrameLeaveLearnStateConfirmation, FrameLeaveLearnStateRequest,
+    LeaveLearnStateConfirmationStatus)
+from .frame_node_information_changed import (
+    FrameNodeInformationChangedNotification)
+from .frame_node_state_position_changed_notification import (
+    FrameNodeStatePositionChangedNotification)
+from .frame_password_change import (
+    FramePasswordChangeConfirmation, FramePasswordChangeNotification,
+    FramePasswordChangeRequest, PasswordChangeConfirmationStatus)
+from .frame_password_enter import (
+    FramePasswordEnterConfirmation, FramePasswordEnterRequest,
+    PasswordEnterConfirmationStatus)
+from .frame_reboot import (
+    FrameGatewayRebootConfirmation, FrameGatewayRebootRequest)
+from .frame_set_node_name import (
+    FrameSetNodeNameConfirmation, FrameSetNodeNameRequest,
+    SetNodeNameConfirmationStatus)
+from .frame_set_utc import FrameSetUTCConfirmation, FrameSetUTCRequest
+from .frame_status_request import (
+    FrameStatusRequestConfirmation, FrameStatusRequestNotification,
+    FrameStatusRequestRequest)

pyvlx/api/frames/alias_array.py

@@ -0,0 +1,45 @@
+"""Module for storing alias array."""
+from typing import List, Optional, Tuple
+
+from pyvlx.exception import PyVLXException
+
+
+class AliasArray:
+    """Object for storing alias array."""
+
+    def __init__(self, raw: Optional[bytes] = None):
+        """Initialize alias array."""
+        self.alias_array_: List[Tuple[bytes, bytes]] = []
+        if raw is not None:
+            self.parse_raw(raw)
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return ", ".join(
+            "{:02x}{:02x}={:02x}{:02x}".format(c[0][0], c[0][1], c[1][0], c[1][1])
+            for c in self.alias_array_
+        )
+
+    def __bytes__(self) -> bytes:
+        """Get raw bytes of alias array."""
+        ret = bytes([len(self.alias_array_)])
+        for alias in self.alias_array_:
+            ret += alias[0] + alias[1]
+        ret += bytes((5 - len(self.alias_array_)) * 4)
+        return ret
+
+    def parse_raw(self, raw: bytes) -> None:
+        """Parse alias array from raw bytes."""
+        if not isinstance(raw, bytes):
+            raise PyVLXException("AliasArray::invalid_type_if_raw", type_raw=type(raw))
+        if len(raw) != 21:
+            raise PyVLXException("AliasArray::invalid_size", size=len(raw))
+        nbr_of_alias = raw[0]
+        if nbr_of_alias > 5:
+            raise PyVLXException(
+                "AliasArray::invalid_nbr_of_alias", nbr_of_alias=nbr_of_alias
+            )
+        for i in range(0, nbr_of_alias):
+            self.alias_array_.append(
+                (raw[i * 4 + 1 : i * 4 + 3], raw[i * 4 + 3 : i * 4 + 5])
+            )

pyvlx/api/frames/frame.py

@@ -0,0 +1,56 @@
+"""Module for Frames."""
+import struct
+
+from pyvlx.const import Command
+from pyvlx.exception import PyVLXException
+
+from .frame_helper import calc_crc
+
+
+class FrameBase:
+    """Class for Base Frame."""
+
+    def __init__(self, command: Command):
+        """Initialize Base Frame."""
+        self.command = command
+
+    def __bytes__(self) -> bytes:
+        """Get raw bytes of Frame."""
+        payload = self.get_payload()
+        self.validate_payload_len(payload)
+        return self.build_frame(self.command, payload)
+
+    def validate_payload_len(self, payload: bytes) -> None:
+        """Validate payload len."""
+        if not hasattr(self, "PAYLOAD_LEN"):
+            # No fixed payload len, e.g. within FrameGetSceneListNotification
+            return
+        # pylint: disable=no-member
+        if len(payload) != self.PAYLOAD_LEN:
+            raise PyVLXException(
+                "Invalid payload len",
+                expected_len=self.PAYLOAD_LEN,
+                current_len=len(payload),
+                frame_type=type(self).__name__,
+            )
+
+    def get_payload(self) -> bytes:
+        """Return Payload."""
+        return b""
+
+    def from_payload(self, payload: bytes) -> None:
+        """Init frame from binary data."""
+
+    def __str__(self) -> str:
+        """Return human readable string."""
+        return "<{}/>".format(type(self).__name__)
+
+    @staticmethod
+    def build_frame(command: Command, payload: bytes) -> bytes:
+        """Build raw bytes from command and payload."""
+        packet_length = 2 + len(payload) + 1
+        ret = struct.pack("BB", 0, packet_length)
+        ret += struct.pack(">H", command.value)
+        ret += payload
+        ret += struct.pack("B", calc_crc(ret))
+        return ret