pyvlx 0.2.27__py3-none-any.whl

pyvlx/api/get_protocol_version.py

@@ -0,0 +1,40 @@
+"""Module for retrieving protocol version from API."""
+
+from typing import TYPE_CHECKING
+
+from pyvlx.dataobjects import DtoProtocolVersion
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameGetProtocolVersionConfirmation,
+    FrameGetProtocolVersionRequest)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class GetProtocolVersion(ApiEvent):
+    """Class for retrieving protocol version from API."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize GetProtocolVersion class."""
+        super().__init__(pyvlx=pyvlx)
+        self.success = False
+        self.protocolversion = DtoProtocolVersion()
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if not isinstance(frame, FrameGetProtocolVersionConfirmation):
+            return False
+        self.protocolversion = DtoProtocolVersion(frame.major_version, frame.minor_version)
+        self.success = True
+        return True
+
+    def request_frame(self) -> FrameGetProtocolVersionRequest:
+        """Construct initiating frame."""
+        return FrameGetProtocolVersionRequest()
+
+    @property
+    def version(self) -> str:
+        """Return Protocol Version as human readable string."""
+        return "{}.{}".format(self.protocolversion.majorversion, self.protocolversion.minorversion)

pyvlx/api/get_scene_list.py

@@ -0,0 +1,49 @@
+"""Module for retrieving scene list from API."""
+from typing import TYPE_CHECKING, List, Optional, Tuple
+
+from pyvlx.log import PYVLXLOG
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameGetSceneListConfirmation, FrameGetSceneListNotification,
+    FrameGetSceneListRequest)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class GetSceneList(ApiEvent):
+    """Class for retrieving scene list from API."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize SceneList class."""
+        super().__init__(pyvlx=pyvlx)
+        self.success = False
+        self.count_scenes: Optional[int] = None
+        self.scenes: List[Tuple[int, str]] = []
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if isinstance(frame, FrameGetSceneListConfirmation):
+            self.count_scenes = frame.count_scenes
+            if self.count_scenes == 0:
+                self.success = True
+                return True
+            # We are still waiting for FrameGetSceneListNotification(s)
+            return False
+        if isinstance(frame, FrameGetSceneListNotification):
+            self.scenes.extend(frame.scenes)
+            if frame.remaining_scenes != 0:
+                # We are still waiting for FrameGetSceneListConfirmation(s)
+                return False
+            if self.count_scenes != len(self.scenes):
+                PYVLXLOG.warning(
+                    "Warning: number of received scenes does not match expected number"
+                )
+            self.success = True
+            return True
+        return False
+
+    def request_frame(self) -> FrameGetSceneListRequest:
+        """Construct initiating frame."""
+        return FrameGetSceneListRequest()

pyvlx/api/get_state.py

@@ -0,0 +1,43 @@
+"""Module for retrieving gateway state from API."""
+from typing import TYPE_CHECKING, Optional
+
+from pyvlx.const import GatewayState, GatewaySubState
+from pyvlx.dataobjects import DtoState
+
+from .api_event import ApiEvent
+from .frames import FrameBase, FrameGetStateConfirmation, FrameGetStateRequest
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class GetState(ApiEvent):
+    """Class for retrieving gateway state from API."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize GetState class."""
+        super().__init__(pyvlx=pyvlx)
+        self.success = False
+        self.state = DtoState()
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if not isinstance(frame, FrameGetStateConfirmation):
+            return False
+        self.success = True
+        self.state = DtoState(frame.gateway_state, frame.gateway_sub_state)
+        return True
+
+    def request_frame(self) -> FrameGetStateRequest:
+        """Construct initiating frame."""
+        return FrameGetStateRequest()
+
+    @property
+    def gateway_state(self) -> Optional[GatewayState]:
+        """Return Gateway State as human readable string. Deprecated."""
+        return self.state.gateway_state
+
+    @property
+    def gateway_sub_state(self) -> Optional[GatewaySubState]:
+        """Return Gateway Sub State as human readable string. Deprecated."""
+        return self.state.gateway_sub_state

pyvlx/api/get_version.py

@@ -0,0 +1,34 @@
+"""Module for retrieving firmware version from API."""
+from typing import TYPE_CHECKING
+
+from pyvlx.dataobjects import DtoVersion
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameGetVersionConfirmation, FrameGetVersionRequest)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class GetVersion(ApiEvent):
+    """Class for retrieving firmware version from API."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize GetVersion class."""
+        super().__init__(pyvlx=pyvlx)
+        self.success = False
+        self.version = DtoVersion()
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if not isinstance(frame, FrameGetVersionConfirmation):
+            return False
+        self.version = DtoVersion(frame.software_version, frame.hardware_version,
+                                  frame.product_group, frame.product_type)
+        self.success = True
+        return True
+
+    def request_frame(self) -> FrameGetVersionRequest:
+        """Construct initiating frame."""
+        return FrameGetVersionRequest()

pyvlx/api/house_status_monitor.py

@@ -0,0 +1,52 @@
+"""Module for house status monitor."""
+from typing import TYPE_CHECKING
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameHouseStatusMonitorDisableConfirmation,
+    FrameHouseStatusMonitorDisableRequest,
+    FrameHouseStatusMonitorEnableConfirmation,
+    FrameHouseStatusMonitorEnableRequest)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class HouseStatusMonitorEnable(ApiEvent):
+    """Class for enabling house status monotor."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize HouseStatusMonitorEnable class."""
+        super().__init__(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 not isinstance(frame, FrameHouseStatusMonitorEnableConfirmation):
+            return False
+        self.success = True
+        return True
+
+    def request_frame(self) -> FrameHouseStatusMonitorEnableRequest:
+        """Construct initiating frame."""
+        return FrameHouseStatusMonitorEnableRequest()
+
+
+class HouseStatusMonitorDisable(ApiEvent):
+    """Class for disabling house status monotor."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize HouseStatusMonitorEnable class."""
+        super().__init__(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 not isinstance(frame, FrameHouseStatusMonitorDisableConfirmation):
+            return False
+        self.success = True
+        return True
+
+    def request_frame(self) -> FrameHouseStatusMonitorDisableRequest:
+        """Construct initiating frame."""
+        return FrameHouseStatusMonitorDisableRequest()

pyvlx/api/leave_learn_state.py

@@ -0,0 +1,33 @@
+"""Module for handling the login to API."""
+from typing import TYPE_CHECKING
+
+from pyvlx.dataobjects import DtoLeaveLearnState
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameLeaveLearnStateConfirmation, FrameLeaveLearnStateRequest)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class LeaveLearnState(ApiEvent):
+    """Class for handling leave learn state to API."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize leave learn state class."""
+        super().__init__(pyvlx=pyvlx)
+        self.status = DtoLeaveLearnState()
+        self.success = False
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if not isinstance(frame, FrameLeaveLearnStateConfirmation):
+            return False
+        self.status.status = frame.status
+        self.success = True
+        return True
+
+    def request_frame(self) -> FrameLeaveLearnStateRequest:
+        """Construct initiating frame."""
+        return FrameLeaveLearnStateRequest()

pyvlx/api/password_enter.py

@@ -0,0 +1,39 @@
+"""Module for handling the login to API."""
+from typing import TYPE_CHECKING
+
+from pyvlx.log import PYVLXLOG
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FramePasswordEnterConfirmation, FramePasswordEnterRequest,
+    PasswordEnterConfirmationStatus)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class PasswordEnter(ApiEvent):
+    """Class for handling login to API."""
+
+    def __init__(self, pyvlx: "PyVLX", password: str):
+        """Initialize login class."""
+        super().__init__(pyvlx=pyvlx)
+        self.password = password
+        self.success = False
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if not isinstance(frame, FramePasswordEnterConfirmation):
+            return False
+        if frame.status == PasswordEnterConfirmationStatus.FAILED:
+            PYVLXLOG.warning(
+                'Failed to authenticate with password "%s****"', self.password[:2]
+            )
+            self.success = False
+        if frame.status == PasswordEnterConfirmationStatus.SUCCESSFUL:
+            self.success = True
+        return True
+
+    def request_frame(self) -> FramePasswordEnterRequest:
+        """Construct initiating frame."""
+        return FramePasswordEnterRequest(password=self.password)

pyvlx/api/reboot.py

@@ -0,0 +1,33 @@
+"""Module for handling the Reboot to API."""
+from typing import TYPE_CHECKING
+
+from pyvlx.log import PYVLXLOG
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameGatewayRebootConfirmation, FrameGatewayRebootRequest)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class Reboot(ApiEvent):
+    """Class for handling Reboot to API."""
+
+    def __init__(self, pyvlx: "PyVLX"):
+        """Initialize Reboot 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, FrameGatewayRebootConfirmation):
+            PYVLXLOG.warning("KLF200 is rebooting")
+            self.success = True
+            return True
+        return False
+
+    def request_frame(self) -> FrameGatewayRebootRequest:
+        """Construct initiating frame."""
+        return FrameGatewayRebootRequest()

pyvlx/api/session_id.py

@@ -0,0 +1,20 @@
+"""Module for generating a unique session_id."""
+
+
+_last_session_id = 0
+MAX_SESSION_ID = 65535
+
+
+def get_new_session_id() -> int:
+    """Generate new session_id."""
+    global _last_session_id  # pylint: disable=global-statement
+    _last_session_id = _last_session_id + 1
+    if _last_session_id > MAX_SESSION_ID:
+        _last_session_id = 1
+    return _last_session_id
+
+
+def set_session_id(session_id: int) -> None:
+    """Set session id to value."""
+    global _last_session_id  # pylint: disable=global-statement
+    _last_session_id = session_id

pyvlx/api/set_node_name.py

@@ -0,0 +1,32 @@
+"""Module for changing a node name."""
+from typing import TYPE_CHECKING
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameSetNodeNameConfirmation, FrameSetNodeNameRequest,
+    SetNodeNameConfirmationStatus)
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class SetNodeName(ApiEvent):
+    """Class for changing the name of a node via API."""
+
+    def __init__(self, pyvlx: "PyVLX", node_id: int, name: str):
+        """Initialize class."""
+        super().__init__(pyvlx=pyvlx)
+        self.node_id = node_id
+        self.name = name
+        self.success = False
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if not isinstance(frame, FrameSetNodeNameConfirmation):
+            return False
+        self.success = frame.status == SetNodeNameConfirmationStatus.OK
+        return True
+
+    def request_frame(self) -> FrameSetNodeNameRequest:
+        """Construct initiating frame."""
+        return FrameSetNodeNameRequest(node_id=self.node_id, name=self.name)

pyvlx/api/set_utc.py

@@ -0,0 +1,31 @@
+"""Module for setting UTC time within gateway."""
+import time
+from typing import TYPE_CHECKING
+
+from .api_event import ApiEvent
+from .frames import FrameBase, FrameSetUTCConfirmation, FrameSetUTCRequest
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class SetUTC(ApiEvent):
+    """Class for setting UTC time within gateway."""
+
+    def __init__(self, pyvlx: "PyVLX", timestamp: float = time.time()):
+        """Initialize SetUTC class."""
+        super().__init__(pyvlx=pyvlx)
+        self.timestamp = timestamp
+        self.success = False
+
+    async def handle_frame(self, frame: FrameBase) -> bool:
+        """Handle incoming API frame, return True if this was the expected frame."""
+        if not isinstance(frame, FrameSetUTCConfirmation):
+            return False
+        self.success = True
+        return True
+
+    def request_frame(self) -> FrameSetUTCRequest:
+        """Construct initiating frame."""
+        timestamp = int(self.timestamp)
+        return FrameSetUTCRequest(timestamp=timestamp)

pyvlx/api/status_request.py

@@ -0,0 +1,48 @@
+"""Module for retrieving node information from API."""
+from typing import TYPE_CHECKING, Optional
+
+from .api_event import ApiEvent
+from .frames import (
+    FrameBase, FrameStatusRequestConfirmation, FrameStatusRequestNotification,
+    FrameStatusRequestRequest)
+from .session_id import get_new_session_id
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class StatusRequest(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[FrameStatusRequestNotification] = None
+        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, FrameStatusRequestConfirmation)
+                and frame.session_id == self.session_id
+        ):
+            # We are still waiting for StatusRequestNotification
+            return False
+        if (
+                isinstance(frame, FrameStatusRequestNotification)
+                and frame.session_id == self.session_id
+        ):
+            self.notification_frame = frame
+            self.success = True
+            return True
+        return False
+
+    def request_frame(self) -> FrameStatusRequestRequest:
+        """Construct initiating frame."""
+        self.session_id = get_new_session_id()
+        return FrameStatusRequestRequest(
+            session_id=self.session_id,
+            node_ids=[self.node_id]
+        )

pyvlx/config.py

@@ -0,0 +1,54 @@
+"""Module for configuration."""
+from typing import TYPE_CHECKING, Any, Optional, cast
+
+import yaml
+
+from .exception import PyVLXException
+from .log import PYVLXLOG
+
+if TYPE_CHECKING:
+    from pyvlx import PyVLX
+
+
+class Config:
+    """Object for configuration."""
+
+    DEFAULT_PORT = 51200
+
+    def __init__(self,
+                 pyvlx: "PyVLX",
+                 path: Optional[str] = None,
+                 host: Optional[str] = None,
+                 password: Optional[str] = None,
+                 port: Optional[int] = None):
+        """Initialize Config class."""
+        self.pyvlx = pyvlx
+        self.host = host
+        self.password = password
+        self.port = port or self.DEFAULT_PORT
+        if path is not None:
+            self.read_config(path)
+
+    def read_config(self, path: str) -> None:
+        """Read configuration file."""
+        PYVLXLOG.info("Reading config file: %s", path)
+        try:
+            with open(path, "r", encoding="utf-8") as filehandle:
+                doc = yaml.safe_load(filehandle)
+                self.test_configuration(doc, path)
+                self.host = cast(str, doc["config"]["host"])
+                self.password = cast(str, doc["config"]["password"])
+                if "port" in doc["config"]:
+                    self.port = doc["config"]["port"]
+        except FileNotFoundError as not_found:
+            raise PyVLXException("file does not exist: {0}".format(not_found)) from not_found
+
+    @staticmethod
+    def test_configuration(doc: Any, path: str) -> None:
+        """Test if configuration file is sane."""
+        if "config" not in doc:
+            raise PyVLXException("no element config found in: {0}".format(path))
+        if "host" not in doc["config"]:
+            raise PyVLXException("no element host found in: {0}".format(path))
+        if "password" not in doc["config"]:
+            raise PyVLXException("no element password found in: {0}".format(path))