pyvlx 0.2.20__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.20 → pyvlx-0.2.21}/pyvlx/__init__.py

@@ -4,7 +4,9 @@ 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)

{pyvlx-0.2.20 → pyvlx-0.2.21}/pyvlx/api/__init__.py

@@ -2,6 +2,7 @@
 # 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
@@ -14,7 +15,7 @@ from .get_scene_list import GetSceneList
 from .get_state import GetState
 from .get_version import GetVersion
 from .house_status_monitor import (
-    house_status_monitor_disable, house_status_monitor_enable)
+    HouseStatusMonitorDisable, HouseStatusMonitorEnable)
 from .leave_learn_state import LeaveLearnState
 from .password_enter import PasswordEnter
 from .reboot import Reboot

{pyvlx-0.2.20 → 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.20 → 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.20 → pyvlx-0.2.21}/pyvlx/api/factory_default.py

@@ -1,21 +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)
+    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")
@@ -23,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.20 → pyvlx-0.2.21}/pyvlx/api/frame_creation.py

@@ -1,10 +1,12 @@
 """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,
+    FrameActivationLogUpdatedNotification, FrameBase,
     FrameCommandRemainingTimeNotification, FrameCommandRunStatusNotification,
     FrameCommandSendConfirmation, FrameCommandSendRequest,
     FrameDiscoverNodesConfirmation, FrameDiscoverNodesNotification,
@@ -38,7 +40,7 @@ from .frames import (
     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)
@@ -54,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:

{pyvlx-0.2.20 → pyvlx-0.2.21}/pyvlx/api/frames/alias_array.py

@@ -1,24 +1,26 @@
 """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=None):
+    def __init__(self, raw: Optional[bytes] = None):
         """Initialize alias array."""
-        self.alias_array_ = []
+        self.alias_array_: List[Tuple[bytes, bytes]] = []
         if raw is not None:
             self.parse_raw(raw)
 
-    def __str__(self):
+    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):
+    def __bytes__(self) -> bytes:
         """Get raw bytes of alias array."""
         ret = bytes([len(self.alias_array_)])
         for alias in self.alias_array_:
@@ -26,7 +28,7 @@ class AliasArray:
         ret += bytes((5 - len(self.alias_array_)) * 4)
         return ret
 
-    def parse_raw(self, raw):
+    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))

{pyvlx-0.2.20 → pyvlx-0.2.21}/pyvlx/api/frames/frame.py

@@ -1,6 +1,7 @@
 """Module for Frames."""
 import struct
 
+from pyvlx.const import Command
 from pyvlx.exception import PyVLXException
 
 from .frame_helper import calc_crc
@@ -9,17 +10,17 @@ from .frame_helper import calc_crc
 class FrameBase:
     """Class for Base Frame."""
 
-    def __init__(self, command):
+    def __init__(self, command: Command):
         """Initialize Base Frame."""
         self.command = command
 
-    def __bytes__(self):
+    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):
+    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
@@ -33,21 +34,19 @@ class FrameBase:
                 frame_type=type(self).__name__,
             )
 
-    def get_payload(self):
+    def get_payload(self) -> bytes:
         """Return Payload."""
-        # pylint: disable=no-self-use
         return b""
 
-    def from_payload(self, payload):
+    def from_payload(self, payload: bytes) -> None:
         """Init frame from binary data."""
-        # pylint: disable=no-self-use
 
-    def __str__(self):
+    def __str__(self) -> str:
         """Return human readable string."""
         return "<{}/>".format(type(self).__name__)
 
     @staticmethod
-    def build_frame(command, payload):
+    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)