dScriptModule 3.4.5__py3-none-any.whl → 3.5.1__py3-none-any.whl

dScriptModule/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "3.4.5"
+__version__ = "3.5.1"
 
 from .dScriptObject import *
 from .dScriptServer import *

dScriptModule/dScriptBoard.py

@@ -12,6 +12,7 @@ from .dScriptObject import *
 import asyncio
 import struct
 import socket
+import threading
 from Crypto import Random
 from Crypto.Cipher import AES
 
@@ -41,12 +42,16 @@ class dScriptBoard(dScriptObject):
 
     _EventHandlers = { 'status':[], 'config':[], 'light':[], 'shutter':[], 'socket':[], 'motion':[], 'button':[] }
     __loop = None
+    __async_lock = None
+    __sync_lock = None
     
     '''Initialize the dScriptBoard element with at least its IP and port to be able to connect later'''
     def __init__(self, TCP_IP, TCP_PORT=17123, PROTOCOL='binary') -> None:
         _LOGGER.debug("dScriptBoard - %s:%s: __init__", TCP_IP, TCP_PORT)
         self.IP = TCP_IP
         self.Port = TCP_PORT
+        self.__async_lock = None # created on first use within the running event loop
+        self.__sync_lock = threading.Lock()
         self.SetProtocol(PROTOCOL)
         self.GetHostName()
 
@@ -80,7 +85,7 @@ class dScriptBoard(dScriptObject):
             if self._Protocol == self._Protocols[4] and self._IsInList(msg[0], self._AESNonceCommands):    #BinaryAES and command with NONCE
                 msg = await self._async_AESEncrypt(msg)
                 data = await self.__async_Send(msg,16) #BinaryAES commands always return 16 bytes
-                data = await self._async_AESEncrypt(data,self._GetKeyByValue(command,self._DecimalCommands))
+                data = await self._async_AESDecrypt(data,self._GetKeyByValue(command,self._DecimalCommands))
                 return data[:self._BinaryReturnByteCounts[command]] # return only the number of bytes usually returend by Binary protocol
             elif self._Protocol == self._Protocols[3] or self._Protocol == self._Protocols[4]:    #Binary or BinaryAES but command without NONCE
                 return await self.__async_Send(msg,self._BinaryReturnByteCounts[command])
@@ -193,52 +198,85 @@ class dScriptBoard(dScriptObject):
     '''Send a message to the board''' 
     def __Send(self,msg,buff):
         _LOGGER.debug("dScriptBoard - %s: Send: %s | %s", self.friendlyname, msg, buff)
+        if self.__sync_lock is None:
+            self.__sync_lock = threading.Lock()
+        with self.__sync_lock: # the board firmware processes one request at a time - never send in parallel
+            s = None
+            try:
+                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                s.settimeout(self.ConnectionTimeout)
+                s.connect((self.IP, self.Port))
+                s.sendall(msg)
+                data = b''
+                while len(data) < buff:
+                    try:
+                        chunk = s.recv(buff - len(data))
+                    except socket.timeout:
+                        if data: break # board sent less than expected - return what we got
+                        raise
+                    if not chunk: break
+                    data = data + chunk
+                return data
+            except Exception as e: 
+                _LOGGER.error("dScriptBoard - %s: Send failed: %s (%s.%s)", self.friendlyname, str(e), e.__class__.__module__, type(e).__name__)
+                return False
+            finally:
+                if s is not None:
+                    try: s.close()
+                    except Exception: pass
+
+    '''Close an asyncio stream writer without raising'''
+    async def __async_CloseWriter(self,writer):
+        if writer is None:
+            return
         try:
-            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            s.settimeout(self.ConnectionTimeout)
-            s.connect((self.IP, self.Port))
-        except Exception as e: 
-            _LOGGER.error("dScriptBoard - %s: Send failed: %s (%s.%s)", self.friendlyname, str(e), e.__class__.__module__, type(e).__name__)
-            return False
-        try:
-            s.send(msg)
-            data = s.recv(buff)
-        except Exception as e: 
-            _LOGGER.error("dScriptBoard - %s: Send failed: %s (%s.%s)", self.friendlyname, str(e), e.__class__.__module__, type(e).__name__)
-            s.close()
-            return False
-        s.close()
-        return data
+            writer.close()
+            await asyncio.wait_for(writer.wait_closed(), timeout=self.ConnectionTimeout)
+        except Exception:
+            pass
 
     '''Send a message to the board''' 
     async def __async_Send(self,msg,buff,retry=False):
         _LOGGER.debug("dScriptBoard - %s: async_Send: %s | %s", self.friendlyname, msg, buff)
+        if self.__async_lock is None:
+            self.__async_lock = asyncio.Lock()
+        async with self.__async_lock: # the board firmware processes one request at a time - never send in parallel
+            data = await self.__async_SendUnlocked(msg,buff)
+        if data is None and not retry:
+            _LOGGER.debug("dScriptBoard - %s: async_Send retry sending: %s | %s", self.friendlyname, msg, buff)
+            return await self.__async_Send(msg,buff,True)
+        elif data is None:
+            _LOGGER.error("dScriptBoard - %s: async_Send failed with retry: %s | %s", self.friendlyname, msg, buff)
+            return False
+        return data
+
+    '''Send a message to the board without locking - returns None on timeout to allow a retry'''
+    async def __async_SendUnlocked(self,msg,buff):
+        writer = None
         try:
-            writer = None
             if self.__loop is not None:
                 _LOGGER.warning("dScriptBoard - %s: async_Send loop parameter is no longer forwarded as of python 3.10", self.friendlyname )
-            #reader, writer = await asyncio.open_connection(self.IP, self.Port, loop=self.__loop)
-            reader, writer = await asyncio.open_connection(self.IP, self.Port)
+            reader, writer = await asyncio.wait_for(asyncio.open_connection(self.IP, self.Port), timeout=self.ConnectionTimeout)
             writer.write(msg)
-            data = await reader.read(buff)
-            writer.close()
+            await asyncio.wait_for(writer.drain(), timeout=self.ConnectionTimeout)
+            data = b''
+            while len(data) < buff:
+                try:
+                    chunk = await asyncio.wait_for(reader.read(buff - len(data)), timeout=self.ConnectionTimeout)
+                except asyncio.TimeoutError:
+                    if data: break # board sent less than expected - return what we got
+                    raise
+                if not chunk: break
+                data = data + chunk
             return data
-        except TimeoutError as e:
-            if not retry:
-                _LOGGER.debug("dScriptBoard - %s: async_Send retry sending: %s | %s", self.friendlyname, msg, buff)
-                if writer:
-                    writer.close()
-                await self.__async_Send(msg,buff,True)
-            else:
-                _LOGGER.error("dScriptBoard - %s: async_Send failed with retry: %s (%s.%s)", self.friendlyname, str(e), e.__class__.__module__, type(e).__name__)
-                if not write is None:
-                    writer.close()
-                return False
+        except asyncio.TimeoutError as e:
+            _LOGGER.debug("dScriptBoard - %s: async_Send timeout: %s (%s.%s)", self.friendlyname, str(e), e.__class__.__module__, type(e).__name__)
+            return None
         except Exception as e: 
             _LOGGER.error("dScriptBoard - %s: async_Send failed: %s (%s.%s)", self.friendlyname, str(e), e.__class__.__module__, type(e).__name__)
-            if not write is None:
-                writer.close()
             return False
+        finally:
+            await self.__async_CloseWriter(writer)
         
     '''Check if identifier parameter is valid'''
     def __CheckIdentifier(self,identifier,idtype) -> bool:
@@ -304,7 +342,7 @@ class dScriptBoard(dScriptObject):
     '''Initialize the board and write its results as attributes'''
     async def async_InitBoard(self) -> None:
         _LOGGER.debug("dScriptBoard - %s: async_InitBoard", self.friendlyname)
-        self.GetHostName()
+        await asyncio.get_running_loop().run_in_executor(None, self.GetHostName)
         await self.async_GetStatus()
         await self.async_GetConfig()
         
@@ -320,7 +358,7 @@ class dScriptBoard(dScriptObject):
             databits=self._ToDataBits(data)
 
             _LOGGER.info("dScriptBoard - %s: GetStatus: update board status information", self.friendlyname)
-            self._ModuleID=self._Modules[databytes[0]]
+            self._ModuleID=self._Modules.get(databytes[0], 'Unknown (%s)' % databytes[0])
             self._SystemFirmwareMajor=databytes[1]
             self._SystemFirmwareMinor=databytes[2]
             self._ApplicationFirmwareMajor=databytes[3]
@@ -343,7 +381,7 @@ class dScriptBoard(dScriptObject):
             databits=self._ToDataBits(data)
 
             _LOGGER.info("dScriptBoard - %s: async_GetStatus: update board status information", self.friendlyname)
-            self._ModuleID=self._Modules[databytes[0]]
+            self._ModuleID=self._Modules.get(databytes[0], 'Unknown (%s)' % databytes[0])
             self._SystemFirmwareMajor=databytes[1]
             self._SystemFirmwareMinor=databytes[2]
             self._ApplicationFirmwareMajor=databytes[3]
@@ -666,7 +704,7 @@ class dScriptBoard(dScriptObject):
             databytes=self._ToDataBytes(data)
             return self.__CheckSet(self._ToDataBytes(data)[0])
         except Exception as e:
-            _LOGGER.error("dScriptBoard - %s: async_SetLight failed: %s (%s.%s)", str(e), e.__class__.__module__, type(e).__name__)
+            _LOGGER.error("dScriptBoard - %s: async_SetLight failed: %s (%s.%s)", self.friendlyname, str(e), e.__class__.__module__, type(e).__name__)
 
     '''Execute the SH, SetShutter command to define a shutter status'''
     def SetShutter(self,identifier,state) -> None | bool:

dScriptModule/dScriptObject.py

@@ -40,8 +40,8 @@ class dScriptObject(object):
             'GetConfig':12, 'GetLight':1, 'GetShutter':2, 'GetSocket':1, 'GetMotion':1, 'GetButton':1,
             'HeartBeat':0, 'TestOnline':0, 'StopServer':0, 'BoardRestart':0}
 
-    _Modules = {30:'dS3484', 31:'dS1242', 34:'dS2824', 35:'dS378'}
-    _ModulesConfig = {30:{'_PhysicalRelays':4,}, 31:{'_PhyiscalRelays':2}, 34:{'_PhysicalRelays':24}, 35:{'_PhysicalRelays':8}}
+    _Modules = {30:'dS3484', 31:'dS1242', 34:'dS2824', 35:'dS378', 36:'TCP184', 42:'dS2832'}
+    _ModulesConfig = {30:{'_PhysicalRelays':4,}, 31:{'_PhysicalRelays':2}, 34:{'_PhysicalRelays':24}, 35:{'_PhysicalRelays':8}, 36:{'_PhysicalRelays':4}}
     _OnOffStates = {0:'off', 1:'on', 2:'toggle'}
     _ShutterStates = {0:'stopped', 1:'opening', 2:'closing'}
 
@@ -66,6 +66,12 @@ class dScriptObject(object):
                 return key
         return None
 
+    '''Return the event handlers of this instance (class level dict is only the template of known topics)'''
+    def _GetEventHandlers(self):
+        if '_EventHandlers' not in self.__dict__:
+            self._EventHandlers = { topic:[] for topic in type(self)._EventHandlers.keys() }
+        return self._EventHandlers
+
     '''Translate received set of data into byte array'''
     def _ToDataBytes(self,data):
         #_LOGGER.debug("dScriptObject: _ToDataBytes: %s",data)
@@ -83,30 +89,35 @@ class dScriptObject(object):
     def addEventHandler(self, topic, handler):
         #_LOGGER.debug("dScriptObject: addEventHandler")
         topic=topic.lower()
-        if not self._IsInList(topic,self._EventHandlers.keys()):
+        handlers=self._GetEventHandlers()
+        if not self._IsInList(topic,handlers.keys()):
             raise Exception("Unknown event handler topic: %s", topic)
             return False
-        self._EventHandlers[topic].append(handler) 
+        if not handler in handlers[topic]: # never register the same handler twice
+            handlers[topic].append(handler) 
         return True
 
     def removeEventHandler(self, topic, handler):
         #_LOGGER.debug("dScriptObject: removeEventHandler")
         topic=topic.lower()
-        if not self._IsInList(topic,self._EventHandlers.keys()):
+        handlers=self._GetEventHandlers()
+        if not self._IsInList(topic,handlers.keys()):
             raise Exception("Unknown event handler topic: %s", topic)
             return False
-        self._EventHandlers[topic].remove(handler)
+        if handler in handlers[topic]:
+            handlers[topic].remove(handler)
         return True
 
     def _throwEvent(self, sender=IP, topic='topic', identifier=None, value=None):
         _LOGGER.debug("dScriptObject: _throwEvent: from %s about %s for %s with value %s", sender, topic, identifier, value)
         topic=topic.lower()
-        if not self._IsInList(topic,self._EventHandlers.keys()):
+        handlers=self._GetEventHandlers()
+        if not self._IsInList(topic,handlers.keys()):
             raise Exception("Unknown event handler topic: %s", topic)
             return False
         
         eventobj = dScriptEventObj(sender,topic,identifier,value)
-        for handler in self._EventHandlers[topic]:
+        for handler in handlers[topic]:
             eventobj.event += handler
         #_LOGGER.debug("dScriptObject: _throwEvent: object: %s", eventobj)
         eventobj.throw()

dScriptModule/dScriptServer.py

@@ -42,8 +42,8 @@ class dScriptServer(dScriptObject):
             raise Exception("Server already started")
             return False
         try:
-            self.__mode = 'init'
-            self.__thread = Thread(target=self.__ServerThread)
+            self.__mode = 'sync'
+            self.__thread = Thread(target=self.__ServerThread, daemon=True)
             self.__thread.start()
             _LOGGER.debug("dScriptServer - %s:%s: StartServer - completed", self.IP, self.Port)
         except Exception as e: 
@@ -67,7 +67,7 @@ class dScriptServer(dScriptObject):
                  self.__server = server_coro
             _LOGGER.info("dScriptServer - %s:%s: async_StartServer - serving on: %s:%s", self.IP, self.Port, self.IP, self.Port)
             self.State = self.__server.is_serving()
-            self.__mode == 'thread'
+            self.__mode = 'async'
             _LOGGER.debug("dScriptServer - %s:%s: async_StartServer - completed", self.IP, self.Port)
         except Exception as e: 
             _LOGGER.error("dScriptServer - %s:%s: async_StartServer failed: %s (%s.%s)", self.IP, self.Port, str(e), e.__class__.__module__, type(e).__name__)
@@ -85,8 +85,8 @@ class dScriptServer(dScriptObject):
             raise Exception("Server already running")
             return False
         try:
-            self.__mode = 'init'
-            self.__thread = Thread(target=self.__ServerThread_async)
+            self.__mode = 'thread'
+            self.__thread = Thread(target=self.__ServerThread_async, daemon=True)
             self.__thread.start()
             _LOGGER.debug("dScriptServer - %s:%s: StartServer_async_thread - completed", self.IP, self.Port)
         except Exception as e: 
@@ -98,16 +98,20 @@ class dScriptServer(dScriptObject):
             return self.async_StopServer()
         elif self.__mode == 'thread':
             return self.StopServer_async()
-        if self.__server == None:
-            self.__server.shutdown(socket.SHUT_RDWR)
+        if self.__server is None:
             raise Exception("Server already stopped")
+        self.State = False
+        try:
+            self.__server.shutdown(socket.SHUT_RDWR) # wakes up the thread blocked in accept()
+        except Exception:
+            pass
         try:
             self.__server.close()
         except Exception as e:
             _LOGGER.error("dScriptServer: StopServer: Exception on server socket close: %s (%s.%s)", str(e), e.__class__.__module__, type(e).__name__)
             pass
         self.State = False
-        self.__mode == None
+        self.__mode = None
         self.__server = None
         self.__thread = None
 
@@ -125,7 +129,7 @@ class dScriptServer(dScriptObject):
             _LOGGER.error("dScriptServer - %s:%s: async_StopServer failed: %s (%s.%s)", self.IP, self.Port, str(e), e.__class__.__module__, type(e).__name__)
             pass
         self.State = False
-        self.__mode == None
+        self.__mode = None
         self.__server = None
 
     def StopServer_async(self):
@@ -145,7 +149,7 @@ class dScriptServer(dScriptObject):
             _LOGGER.error("dScriptServer - %s:%s: StopServer_async_thread failed: %s (%s.%s)", self.IP, self.Port, str(e), e.__class__.__module__, type(e).__name__)
             pass        
         self.State = False
-        self.__mode == None
+        self.__mode = None
         self.__server = None
         self.__thread = None
 
@@ -172,11 +176,12 @@ class dScriptServer(dScriptObject):
             while self.State:
                clientsocket, addr = self.__server.accept()     # Establish connection with client.
                _LOGGER.debug("dScriptServer - %s:%s: ServerThread: client connected: %s", self.IP, self.Port, addr)
+               clientsocket.settimeout(10) # never block a client thread forever
                _thread.start_new_thread(self.__ClientConnected,(clientsocket,addr))
         except Exception as e:
-            _LOGGER.error("dScriptServer - %s:%s: ServerThread failed on client connect: %s (%s.%s)", self.IP, self.Port, str(e), e.__class__.__module__, type(e).__name__)
-            self.StopServer()
-            pass
+            if self.State:
+                _LOGGER.error("dScriptServer - %s:%s: ServerThread failed on client connect: %s (%s.%s)", self.IP, self.Port, str(e), e.__class__.__module__, type(e).__name__)
+                self.StopServer()
         _LOGGER.debug("dScriptServer - %s:%s: ServerThread - stopped serving on: (%s:%s)", self.IP, self.Port, self.IP, self.Port)
 
     def __ServerThread_async(self):
@@ -197,11 +202,10 @@ class dScriptServer(dScriptObject):
         try:
             await self.__server.start_serving()
             self.State = self.__server.is_serving()
-            self.__mode == 'thread'
             _LOGGER.debug("dScriptServer - %s:%s: async_RunServerThread - started serving (%s) on: %s", self.IP, self.Port, self.__server.is_serving(), addr)
             while self.State:
                 self.State = self.__server.is_serving()
-                await asyncio.sleep(0)                
+                await asyncio.sleep(1) # do not spin - this is only a status watcher
             _LOGGER.debug("dScriptServer - %s:%s: async_RunServerThread - stopped serving on: %s", self.IP, self.Port, addr)
         except Exception as e: 
             _LOGGER.error("dScriptServer - %s:%s: async_RunServerThread failed: %s (%s.%s)", self.IP, self.Port, str(e), e.__class__.__module__, type(e).__name__)
@@ -210,31 +214,34 @@ class dScriptServer(dScriptObject):
     def __ClientConnected(self,clientsocket,addr):
         _LOGGER.debug("dScriptServer - %s:%s: ClientConnected: %s | %s", self.IP, self.Port, clientsocket, addr)
         try:
-            data = clientsocket.recv(2) # received byte size is always 2 bytes from dScriptServerUpdate
+            data = clientsocket.recv(self.__socketsize) # firmware sends 3 bytes (cmd, id, state)
             _LOGGER.debug("dScriptServer - %s:%s: ClientConnected: received data from: %s", self.IP, self.Port, addr)
 
-            clientsocket.close()
             _LOGGER.debug("dScriptServer - %s:%s: ClientConnected: closed connection: %s", self.IP, self.Port, addr)
         except Exception as e:
             _LOGGER.error("dScriptServer - %s:%s: ClientConnected failed: %s (%s.%s)", self.IP, self.Port, str(e), e.__class__.__module__, type(e).__name__)
-            #clientsocket.shutdown(socket.SHUT_RDWR)
             return False
+        finally:
+            try: clientsocket.close()
+            except Exception: pass
         self.__InterpreteData(data,addr[0])
 
     async def __async_ClientConnected(self, reader, writer):
         _LOGGER.debug("dScriptServer - %s:%s: async_ClientConnected: %s | %s", self.IP, self.Port, reader, writer)  
         try:
-            data = await reader.read(self.__socketsize) 
-            #message = data.decode() 
             addr = writer.get_extra_info('peername') 
+            data = await asyncio.wait_for(reader.read(self.__socketsize), timeout=10) # never wait forever for a (broken) client
             _LOGGER.debug("dScriptServer - %s:%s: async_ClientConnected: received data from: %s", self.IP, self.Port, addr)
-
-            writer.close()
-            await asyncio.sleep(0)
-            _LOGGER.debug("dScriptServer - %s:%s: async_ClientConnected: closed connection: %s", self.IP, self.Port, addr)
         except Exception as e: 
             _LOGGER.error("dScriptServer - %s:%s: async_ClientConnected failed: %s (%s.%s)", self.IP, self.Port, str(e), e.__class__.__module__, type(e).__name__)
             return False
+        finally:
+            try:
+                writer.close()
+                await asyncio.wait_for(writer.wait_closed(), timeout=5)
+            except Exception:
+                pass
+            _LOGGER.debug("dScriptServer - %s:%s: async_ClientConnected: closed connection: %s", self.IP, self.Port, writer.get_extra_info('peername'))
         self.__InterpreteData(data,addr[0])
         
     def __InterpreteData(self,data,SenderIP):
@@ -242,8 +249,15 @@ class dScriptServer(dScriptObject):
         #TO-DO: identify protocol & select according action
         #if self._Protocol == self._Protocols[4]: #BinaryAES
         #    data=self._AESDecrypt(data)
-        databytes=self._ToDataBytes(data)
-        self.__InterpreteBinary(databytes,SenderIP)
+        try:
+            databytes=self._ToDataBytes(data)
+            if len(databytes) == 0:
+                _LOGGER.debug("dScriptServer - %s:%s: InterpreteData: empty message from %s", self.IP, self.Port, SenderIP)
+                return False
+            self.__InterpreteBinary(databytes,SenderIP)
+        except Exception as e:
+            _LOGGER.error("dScriptServer - %s:%s: InterpreteData failed for %s from %s: %s (%s.%s)", self.IP, self.Port, data, SenderIP, str(e), e.__class__.__module__, type(e).__name__)
+            return False
 
     def __InterpreteBinary(self,databytes,SenderIP):
         _LOGGER.debug("dScriptServer - %s:%s: InterpreteBinary: %s | %s", self.IP, self.Port, databytes, SenderIP)
@@ -258,13 +272,18 @@ class dScriptServer(dScriptObject):
         elif cmd == 'heartbeat' or cmd == 'getstatus' or cmd == 'getconfig' or cmd == 'testonline': #all of these do not need an identifier
             self._throwEvent(SenderIP, cmd)
         else:
-            if len(databytes) == 3:
-                if int(databytes[2]) < 0:
+            if len(databytes) >= 3:
+                if int(databytes[2]) < 0 or int(databytes[2]) == 255: # firmware sends -1 (=255 as unsigned byte) for 'no state'
                     self._throwEvent(SenderIP, cmd, int(databytes[1]))
                 elif cmd == 'getlight' or cmd == 'getsocket' or cmd == 'getmotion' or cmd == 'getrelay' or cmd == 'getinput':
-                    self._throwEvent(SenderIP, cmd, int(databytes[1]), self._OnOffStates[databytes[2]])
+                    if databytes[2] in self._OnOffStates:
+                        self._throwEvent(SenderIP, cmd, int(databytes[1]), self._OnOffStates[databytes[2]])
+                    else:
+                        self._throwEvent(SenderIP, cmd, int(databytes[1]))
                 else:
                     self._throwEvent(SenderIP, cmd, int(databytes[1]), int(databytes[2]))
-            else:
+            elif len(databytes) == 2:
                 self._throwEvent(SenderIP, cmd, int(databytes[1]))
+            else:
+                _LOGGER.debug("dScriptServer - %s:%s: InterpreteBinary: missing identifier for %s from %s", self.IP, self.Port, cmd, SenderIP)
         #return True

dScriptModule/dScriptVirtualBoard.py

@@ -20,7 +20,7 @@ class dScriptVirtualBoard(dScriptBoard):
     def __init__(self, TCP_IP='127.0.0.1', TCP_PORT=17123, PROTOCOL='binary'):
         _LOGGER.debug("dScriptVirtualBoard: __init__")
         self._MACAddress="02:00:00:%02x:%02x:%02x" % (random.randint(0, 255),random.randint(0, 255),random.randint(0, 255))
-        self._ModuleID=random.choice(list(dScriptObject._Modules.keys()))
+        self._ModuleID=random.choice(list(dScriptObject._ModulesConfig.keys())) # only modules with known config can be emulated
         self._CustomFirmeware=True
         self.InitBoard()
 

{dScriptModule-3.4.5.dist-info → dscriptmodule-3.5.1.dist-info}/METADATA

@@ -1,21 +1,28 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: dScriptModule
-Version: 3.4.5
+Version: 3.5.1
 Summary: Home Assistant ready python module for dScript boards (by Robot-Electronics / Devantech Ltd.) with CUSTOM app firmware
 Home-page: https://github.com/mk-maddin/dScriptModule
 Author: Martin Kraemer
 Author-email: mk.maddin@gmail.com
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: bitstring
 Requires-Dist: pycryptodome
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # dScriptModule
 Home Assistant ready python module for dScript boards (by Robot-Electronics / Devantech Ltd.) with CUSTOM app firmware available at: https://github.com/mk-maddin/dScriptRoomControl
-
-

dscriptmodule-3.5.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+dScriptModule/__init__.py,sha256=P6tL2pqP0XCgTUeCb8O0ug3G8lK-VmSj1LXyDK1hF3s,144
+dScriptModule/dScriptBoard.py,sha256=7RvcbjhZCIwyHbioPCDr3rFCdQTSWVzFoFxNHK6ZgrY,44880
+dScriptModule/dScriptEvent.py,sha256=gl_h1DfLUkU5YNXadPgZRKQzSH0wv-GkdBo7EuAHqqU,1957
+dScriptModule/dScriptObject.py,sha256=tFJvDXq6ZVivE5KjK7Ktqu2WFavv4lqy5ve94JO5TnM,7138
+dScriptModule/dScriptServer.py,sha256=MwByosqc7u2nuNTqw1YwFuf4gPtvCQf034AXzIWD4YA,15008
+dScriptModule/dScriptVirtualBoard.py,sha256=F3KePf2dO9PXwsTxs936zcm9x0mAiyW7SqU4Lg9lXs4,8245
+dscriptmodule-3.5.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+dscriptmodule-3.5.1.dist-info/METADATA,sha256=jUFucpASGxIURyjl4lixxOBFAEVbg06oZZevadmKqDQ,1023
+dscriptmodule-3.5.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+dscriptmodule-3.5.1.dist-info/top_level.txt,sha256=nXwXjGsXgTqoxseWdKCq33mFMC1UwyM7DMPKjFTkQg0,14
+dscriptmodule-3.5.1.dist-info/RECORD,,

{dScriptModule-3.4.5.dist-info → dscriptmodule-3.5.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.34.2)
+Generator: setuptools (84.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dScriptModule-3.4.5.dist-info/RECORD

@@ -1,11 +0,0 @@
-dScriptModule/__init__.py,sha256=EcM2ruXC4gfB1MeiNcOhetZDkV4EhZmuIBPC7XO5JvI,144
-dScriptModule/dScriptBoard.py,sha256=bAE0QxpU9c2SWfTQCzZCJHvDXeeWieUTu8md2ORHaiQ,42881
-dScriptModule/dScriptEvent.py,sha256=gl_h1DfLUkU5YNXadPgZRKQzSH0wv-GkdBo7EuAHqqU,1957
-dScriptModule/dScriptObject.py,sha256=6DLvuOQfe9mLkx5rBA5pJNGjO0_HQP5A0DA0DKKb8m8,6575
-dScriptModule/dScriptServer.py,sha256=JX7y25EBRq8jO9de7Kw4C9DJv2Nc2NBbQNGPhxXGGPQ,13697
-dScriptModule/dScriptVirtualBoard.py,sha256=kREjRuFWlgMeqb8Ed3BRGmvQj7RvzJyU01_eBLYl4m4,8190
-dScriptModule-3.4.5.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-dScriptModule-3.4.5.dist-info/METADATA,sha256=-z5Xay9X6s0caVyzlrWtZzvj_TI-pHTCETtX88pQpRw,819
-dScriptModule-3.4.5.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
-dScriptModule-3.4.5.dist-info/top_level.txt,sha256=nXwXjGsXgTqoxseWdKCq33mFMC1UwyM7DMPKjFTkQg0,14
-dScriptModule-3.4.5.dist-info/RECORD,,