pyvlx 0.2.19__tar.gz → 0.2.21__tar.gz

pyvlx-0.2.21/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

pyvlx-0.2.21/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.1
+Name: pyvlx
+Version: 0.2.21
+Summary: PyVLX is a wrapper for the Velux KLF 200 API. PyVLX enables you to run scenes and or open and close velux windows.
+Home-page: https://github.com/Julius2342/pyvlx
+Download-URL: https://github.com/Julius2342/pyvlx/archive/0.2.21.zip
+Author: Julius Mittenzwei
+Author-email: julius@mittenzwei.com
+License: LGPL
+Keywords: velux KLF 200 home automation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+PyVLX - controling VELUX windows with Python
+============================================
+
+[![CI](https://github.com/Julius2342/pyvlx/actions/workflows/ci.yml/badge.svg)](https://github.com/Julius2342/pyvlx/actions/workflows/ci.yml)
+
+PyVLX uses the Velux KLF 200 interface to control io-Homecontrol devices, e.g. Velux Windows.
+
+Installation
+------------
+
+PyVLX can be installed via:
+
+```bash
+pip3 install pyvlx
+```
+
+Home Assistant Plugin
+---------------------
+
+PyVLX is used within [Home Assistant](https://www.home-assistant.io/components/velux/). To enable it add the following lines to your ~/.homeassistant/configuration.yml:
+
+```yaml
+velux:
+    host: "192.168.0.0"
+    password: "1ADwl48dka"
+```
+
+*Please note that this uses the WiFi password, not the web login.*
+
+For debugging frames add:
+
+```yaml
+logger:
+  default: warning
+  logs:
+    homeassistant.components.velux: debug
+    pyvlx: debug
+```
+
+
+Basic Operations
+----------------
+
+```python
+"""Just a demo of the new PyVLX module."""
+import asyncio
+from pyvlx import PyVLX, Position
+
+
+async def main(loop):
+    """Demonstrate functionality of PyVLX."""
+    pyvlx = PyVLX('pyvlx.yaml', loop=loop)
+    # Alternative:
+    # pyvlx = PyVLX(host="192.168.2.127", password="velux123", loop=loop)
+
+    # Runing scenes:
+    await pyvlx.load_scenes()
+    await pyvlx.scenes["All Windows Closed"].run()
+
+    # Changing position of windows:
+    await pyvlx.load_nodes()
+    await pyvlx.nodes['Bath'].open()
+    await pyvlx.nodes['Bath'].close()
+    await pyvlx.nodes['Bath'].set_position(Position(position_percent=45))
+
+    # Read limits of windows
+    # limit = await pyvlx.nodes['Bath'].get_limitation()
+    # limit.min_value
+    # limit.max_value
+    
+    # Changing of on-off switches:
+    # await pyvlx.nodes['CoffeeMaker'].set_on()
+    # await pyvlx.nodes['CoffeeMaker'].set_off()
+
+    # You can easily rename nodes:
+    # await pyvlx.nodes["Window 10"].rename("Window 11")
+        
+    await pyvlx.disconnect()
+
+if __name__ == '__main__':
+    # pylint: disable=invalid-name
+    LOOP = asyncio.get_event_loop()
+    LOOP.run_until_complete(main(LOOP))
+    # LOOP.run_forever()
+    LOOP.close()
+```

{pyvlx-0.2.19 → pyvlx-0.2.21}/README.md

@@ -1,7 +1,7 @@
 PyVLX - controling VELUX windows with Python
 ============================================
 
-[![Build Status](https://travis-ci.org/Julius2342/pyvlx.svg?branch=master)](https://travis-ci.org/Julius2342/pyvlx)
+[![CI](https://github.com/Julius2342/pyvlx/actions/workflows/ci.yml/badge.svg)](https://github.com/Julius2342/pyvlx/actions/workflows/ci.yml)
 
 PyVLX uses the Velux KLF 200 interface to control io-Homecontrol devices, e.g. Velux Windows.
 
@@ -63,13 +63,18 @@ async def main(loop):
     await pyvlx.nodes['Bath'].close()
     await pyvlx.nodes['Bath'].set_position(Position(position_percent=45))
 
+    # Read limits of windows
+    # limit = await pyvlx.nodes['Bath'].get_limitation()
+    # limit.min_value
+    # limit.max_value
+    
     # Changing of on-off switches:
     # await pyvlx.nodes['CoffeeMaker'].set_on()
     # await pyvlx.nodes['CoffeeMaker'].set_off()
 
     # You can easily rename nodes:
     # await pyvlx.nodes["Window 10"].rename("Window 11")
-
+        
     await pyvlx.disconnect()
 
 if __name__ == '__main__':

{pyvlx-0.2.19 → pyvlx-0.2.21}/pyvlx/__init__.py

@@ -1,9 +1,12 @@
 """Module for accessing KLF 200 gateway with python."""
 
 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)
@@ -15,4 +18,3 @@ from .parameter import (
 from .pyvlx import PyVLX
 from .scene import Scene
 from .scenes import Scenes
-from .klf200gateway import Klf200Gateway

pyvlx-0.2.21/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-0.2.19 → pyvlx-0.2.21}/pyvlx/api/activate_scene.py

@@ -1,26 +1,32 @@
 """Module for retrieving scene list from API."""
+from typing import TYPE_CHECKING, Optional
+
 from .api_event import ApiEvent
 from .frames import (
     ActivateSceneConfirmationStatus, FrameActivateSceneConfirmation,
-    FrameActivateSceneRequest, FrameCommandRemainingTimeNotification,
-    FrameCommandRunStatusNotification, FrameSessionFinishedNotification)
+    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, scene_id, wait_for_completion=True, timeout_in_seconds=60
+            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 = None
+        self.session_id: Optional[int] = None
 
-    async def handle_frame(self, frame):
+    async def handle_frame(self, frame: FrameBase) -> bool:
         """Handle incoming API frame, return True if this was the expected frame."""
         if (
                 isinstance(frame, FrameActivateSceneConfirmation)
@@ -49,7 +55,7 @@ class ActivateScene(ApiEvent):
             return True
         return False
 
-    def request_frame(self):
+    def request_frame(self) -> FrameActivateSceneRequest:
         """Construct initiating frame."""
         self.session_id = get_new_session_id()
         return FrameActivateSceneRequest(

pyvlx-0.2.21/pyvlx/api/api_event.py

@@ -0,0 +1,70 @@
+"""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()
+
+        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)
+
+    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-0.2.19 → pyvlx-0.2.21}/pyvlx/api/command_send.py

@@ -1,24 +1,32 @@
 """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, FrameCommandRemainingTimeNotification,
-    FrameCommandRunStatusNotification, FrameCommandSendConfirmation,
-    FrameCommandSendRequest, FrameSessionFinishedNotification)
+    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,
-            node_id,
-            parameter,
-            active_parameter=0,
-            wait_for_completion=True,
-            timeout_in_seconds=60,
-            **functional_parameter
+            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)
@@ -28,9 +36,9 @@ class CommandSend(ApiEvent):
         self.active_parameter = active_parameter
         self.functional_parameter = functional_parameter
         self.wait_for_completion = wait_for_completion
-        self.session_id = None
+        self.session_id: Optional[int] = None
 
-    async def handle_frame(self, frame):
+    async def handle_frame(self, frame: FrameBase) -> bool:
         """Handle incoming API frame, return True if this was the expected frame."""
         if (
                 isinstance(frame, FrameCommandSendConfirmation)
@@ -59,7 +67,13 @@ class CommandSend(ApiEvent):
             return True
         return False
 
-    def request_frame(self):
+    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(

{pyvlx-0.2.19 → pyvlx-0.2.21}/pyvlx/api/factory_default.py

@@ -1,19 +1,27 @@
 """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 FrameGatewayFactoryDefaultConfirmation, FrameGatewayFactoryDefaultRequest
+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):
+    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):
+    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")
@@ -21,6 +29,6 @@ class FactoryDefault(ApiEvent):
             return True
         return False
 
-    def request_frame(self):
+    def request_frame(self) -> FrameGatewayFactoryDefaultRequest:
         """Construct initiating frame."""
         return FrameGatewayFactoryDefaultRequest()

{pyvlx-0.2.19 → pyvlx-0.2.21}/pyvlx/api/frame_creation.py

@@ -1,41 +1,46 @@
 """Helper module for creating a frame out of raw data."""
-from pyvlx.log import PYVLXLOG
+from typing import Optional
+
 from pyvlx.const import Command
+from pyvlx.log import PYVLXLOG
+
 from .frames import (
     FrameActivateSceneConfirmation, FrameActivateSceneRequest,
-    FrameActivationLogUpdatedNotification,
+    FrameActivationLogUpdatedNotification, FrameBase,
     FrameCommandRemainingTimeNotification, FrameCommandRunStatusNotification,
     FrameCommandSendConfirmation, FrameCommandSendRequest,
     FrameDiscoverNodesConfirmation, FrameDiscoverNodesNotification,
     FrameDiscoverNodesRequest, FrameErrorNotification,
+    FrameGatewayFactoryDefaultConfirmation, FrameGatewayFactoryDefaultRequest,
     FrameGatewayRebootConfirmation, FrameGatewayRebootRequest,
     FrameGetAllNodesInformationConfirmation,
     FrameGetAllNodesInformationFinishedNotification,
     FrameGetAllNodesInformationNotification,
-    FrameGetAllNodesInformationRequest, FrameGetNodeInformationConfirmation,
-    FrameGetNodeInformationNotification, FrameGetNodeInformationRequest,
-    FrameGetProtocolVersionConfirmation, FrameGetProtocolVersionRequest,
-    FrameGetSceneListConfirmation, FrameGetSceneListNotification,
-    FrameGetSceneListRequest, FrameGetStateConfirmation, FrameGetStateRequest,
+    FrameGetAllNodesInformationRequest, FrameGetLimitationStatus,
+    FrameGetLimitationStatusConfirmation, FrameGetLimitationStatusNotification,
+    FrameGetLocalTimeConfirmation, FrameGetLocalTimeRequest,
+    FrameGetNetworkSetupConfirmation, FrameGetNetworkSetupRequest,
+    FrameGetNodeInformationConfirmation, FrameGetNodeInformationNotification,
+    FrameGetNodeInformationRequest, FrameGetProtocolVersionConfirmation,
+    FrameGetProtocolVersionRequest, FrameGetSceneListConfirmation,
+    FrameGetSceneListNotification, FrameGetSceneListRequest,
+    FrameGetStateConfirmation, FrameGetStateRequest,
     FrameGetVersionConfirmation, FrameGetVersionRequest,
     FrameHouseStatusMonitorDisableConfirmation,
     FrameHouseStatusMonitorDisableRequest,
     FrameHouseStatusMonitorEnableConfirmation,
-    FrameHouseStatusMonitorEnableRequest,
-    FrameNodeInformationChangedNotification,
-    FrameNodeStatePositionChangedNotification,
+    FrameHouseStatusMonitorEnableRequest, FrameLeaveLearnStateConfirmation,
+    FrameLeaveLearnStateRequest, FrameNodeInformationChangedNotification,
+    FrameNodeStatePositionChangedNotification, FramePasswordChangeConfirmation,
+    FramePasswordChangeNotification, FramePasswordChangeRequest,
     FramePasswordEnterConfirmation, FramePasswordEnterRequest,
-    FramePasswordChangeRequest, FramePasswordChangeConfirmation, FramePasswordChangeNotification,
-    FrameSessionFinishedNotification,
-    FrameSetNodeNameConfirmation, FrameSetNodeNameRequest,
-    FrameGetNetworkSetupConfirmation, FrameGetNetworkSetupRequest,
-    FrameSetUTCConfirmation, FrameSetUTCRequest, extract_from_frame,
-    FrameLeaveLearnStateConfirmation, FrameLeaveLearnStateRequest,
-    FrameGetLocalTimeConfirmation, FrameGetLocalTimeRequest,
-    FrameGatewayFactoryDefaultConfirmation, FrameGatewayFactoryDefaultRequest)
+    FrameSessionFinishedNotification, FrameSetNodeNameConfirmation,
+    FrameSetNodeNameRequest, FrameSetUTCConfirmation, FrameSetUTCRequest,
+    FrameStatusRequestConfirmation, FrameStatusRequestNotification,
+    FrameStatusRequestRequest, extract_from_frame)
 
 
-def frame_from_raw(raw):
+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)
@@ -51,7 +56,7 @@ def frame_from_raw(raw):
     return frame
 
 
-def create_frame(command):
+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:
@@ -151,6 +156,13 @@ def create_frame(command):
     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:
@@ -177,7 +189,14 @@ def create_frame(command):
         return FrameNodeStatePositionChangedNotification()
     if command == Command.GW_LEAVE_LEARN_STATE_CFM:
         return FrameLeaveLearnStateConfirmation()
-    if command == command.GW_LEAVE_LEARN_STATE_REQ:
+    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