Add support for Message, Command, and processing partial data

Author: maxnz

README.md

@@ -74,7 +74,7 @@ Runs before `newAnimationDataCallback`, `newAnimationInfoCallback`, `newEndAnima
 def receiveData(data: bytes):
     # Your code here
 
-sender.receiveCallback = receiveData
+sender.on_receive_callback = receiveData
 ```
 
 ### NewAnimationDataCallback
@@ -86,7 +86,7 @@ Runs after the `receiveCallback`.
 def processAnimationData(data: 'AnimationData'):
     # Your code here
 
-sender.newAnimationDataCallback = processAnimationData
+sender.on_new_animation_data_callback = processAnimationData
 ```
 
 ### NewAnimationInfoCallback
@@ -98,7 +98,7 @@ Runs after the `receiveCallback`.
 def handleNewAnimationInfo(info: 'AnimationInfo'):
     # Your code here
 
-sender.newAnimationInfoCallback = handleNewAnimationInfo
+sender.on_new_animation_info_callback = handleNewAnimationInfo
 ```
 
 ### NewEndAnimationCallback
@@ -110,7 +110,7 @@ Runs after the `receiveCallback`.
 def handleEndAnimation(anim: 'EndAnimation'):
     # Your code here
 
-sender.newEndAnimationCallback = handleEndAnimation
+sender.on_new_end_animation_callback = handleEndAnimation
 ```
 
 ### NewSectionCallback *(Coming soon)*
@@ -122,7 +122,7 @@ Runs after the `receiveCallback`.
 def newSectionHandler(sect: 'Section'):
     # Your code here
 
-sender.newSectionCallback = newSectionHandler
+sender.on_new_section_callback = newSectionHandler
 ```
 
 ### NewStripInfoCallback *(Coming soon)*
@@ -134,5 +134,5 @@ Runs after the `receiveCallback`.
 def processStripInfo(info: 'StripInfo'):
     # Your code here
 
-sender.newStripInfoCallback = processStripInfo
+sender.on_new_strip_info_callback = processStripInfo
 ```

animatedledstrip/animation_sender.py

@@ -27,6 +27,7 @@
 from .animation_info import AnimationInfo
 from .end_animation import EndAnimation
 from .global_vars import *
+from .message import Message
 from .section import Section
 from .strip_info import StripInfo
 
@@ -39,21 +40,40 @@ def __init__(self, ip_address: str, port_num: int):
         self.port: int = port_num
         self.connection: 'socket.socket' = socket.socket()
         self.connected: bool = False
+        self.started: bool = False
         self.recv_thread: Optional['Thread'] = None
+
         self.running_animations: Dict[str, 'AnimationData'] = {}
         self.sections: Dict[str, 'Section'] = {}
-        self.stripInfo: Optional['StripInfo'] = None
         self.supported_animations: List['AnimationInfo'] = []
+        self.strip_info: Optional['StripInfo'] = None
+
+        self.on_connect_callback: Optional[Callable[[str, int], Any]] = None
+        self.on_disconnect_callback: Optional[Callable[[str, int], Any]] = None
+        self.on_unable_to_connect_callback: Optional[Callable[[str, int], Any]] = None
 
-        self.receiveCallback: Optional[Callable[[bytes], Any]] = None
-        self.newAnimationDataCallback: Optional[Callable[['AnimationData'], Any]] = None
-        self.newAnimationInfoCallback: Optional[Callable[['AnimationInfo'], Any]] = None
-        self.newEndAnimationCallback: Optional[Callable[['EndAnimation'], Any]] = None
-        self.newSectionCallback: Optional[Callable[['Section'], Any]] = None
-        self.newStripInfoCallback: Optional[Callable[['StripInfo'], Any]] = None
+        self.on_receive_callback: Optional[Callable[[bytes], Any]] = None
+        self.on_new_animation_data_callback: Optional[Callable[['AnimationData'], Any]] = None
+        self.on_new_animation_info_callback: Optional[Callable[['AnimationInfo'], Any]] = None
+        self.on_new_end_animation_callback: Optional[Callable[['EndAnimation'], Any]] = None
+        self.on_new_message_callback: Optional[Callable[['Message'], Any]] = None
+        self.on_new_section_callback: Optional[Callable[['Section'], Any]] = None
+        self.on_new_strip_info_callback: Optional[Callable[['StripInfo'], Any]] = None
+
+        self.partial_data: bytes = b''
 
     def start(self) -> 'AnimationSender':
         """Connect to the server"""
+        if self.started:
+            return self
+
+        self.running_animations.clear()
+        self.sections.clear()
+        self.supported_animations.clear()
+        self.strip_info = None
+
+        self.started = True
+
         # Attempt to connect to the server
         self.connection = socket.create_connection((self.address, self.port), timeout=2.0)
 
@@ -74,7 +94,7 @@ def end(self) -> 'AnimationSender':
         # Connection has been closed, so set connected = False
         self.connected = False
 
-        self.stripInfo = None
+        self.strip_info = None
 
         # If the separate thread for receiving animations was started, join it with the main thread.
         # The loop should stop because the connection is closed and connected is False,
@@ -100,15 +120,26 @@ def parse_data(self):
         try:
             all_input: bytes = self.connection.recv(4096)
 
+            # Handle any partial data from previous communications
+            complete_input: bytes = self.partial_data + all_input
+            self.partial_data = b''
+
             # Split up data (multiple may have come in the same message -
             #  they are split up with triple semicolons)
-            # TODO: Support partial data
-            for split_input in all_input.split(DELIMITER):
+            input_list = complete_input.split(DELIMITER)
+
+            # If last input is partial, save for later when the rest comes
+            if not complete_input.endswith(DELIMITER):
+                self.partial_data = input_list[-1]
+                input_list = input_list[:-1]
+
+            # Process inputs
+            for split_input in input_list:
                 if len(split_input) == 0:
                     continue
 
-                if self.receiveCallback:
-                    self.receiveCallback(split_input)
+                if self.on_receive_callback:
+                    self.on_receive_callback(split_input)
 
                 if split_input.startswith(ANIMATION_DATA_PREFIX):
                     # Create the AnimationData instance
@@ -118,8 +149,8 @@ def parse_data(self):
                     self.running_animations[data.id] = data
 
                     # Call callback
-                    if self.newAnimationDataCallback:
-                        self.newAnimationDataCallback(data)
+                    if self.on_new_animation_data_callback:
+                        self.on_new_animation_data_callback(data)
 
                 elif split_input.startswith(ANIMATION_INFO_PREFIX):
                     # Create the AnimationInfo instance
@@ -129,8 +160,11 @@ def parse_data(self):
                     self.supported_animations.append(info)
 
                     # Call callback
-                    if self.newAnimationInfoCallback:
-                        self.newAnimationInfoCallback(info)
+                    if self.on_new_animation_info_callback:
+                        self.on_new_animation_info_callback(info)
+
+                elif split_input.startswith(COMMAND_PREFIX):
+                    logging.warning("Receiving Command is not supported by client")
 
                 elif split_input.startswith(END_ANIMATION_PREFIX):
                     # Create the EndAnimation instance
@@ -140,32 +174,40 @@ def parse_data(self):
                     del self.running_animations[data.id]
 
                     # Call callback
-                    if self.newEndAnimationCallback:
-                        self.newEndAnimationCallback(data)
+                    if self.on_new_end_animation_callback:
+                        self.on_new_end_animation_callback(data)
+
+                elif split_input.startswith(MESSAGE_PREFIX):
+                    # Create the Message instance
+                    msg = Message.from_json(split_input)
+
+                    # Call callback
+                    if self.on_new_message_callback:
+                        self.on_new_message_callback(msg)
 
                 elif split_input.startswith(SECTION_PREFIX):
-                    # Create the EndAnimation instance
+                    # Create the Section instance
                     sect = Section.from_json(split_input)
 
                     # Add new section to the sections dict
                     self.sections[sect.name] = sect
 
                     # Call callback
-                    if self.newSectionCallback:
-                        self.newSectionCallback(sect)
+                    if self.on_new_section_callback:
+                        self.on_new_section_callback(sect)
 
                 elif split_input.startswith(STRIP_INFO_PREFIX):
                     # Create the StripInfo instance
                     info = StripInfo.from_json(split_input)
 
-                    self.stripInfo = info
+                    self.strip_info = info
 
                     # Call callback
-                    if self.newStripInfoCallback:
-                        self.newStripInfoCallback(info)
+                    if self.on_new_strip_info_callback:
+                        self.on_new_strip_info_callback(info)
 
                 else:
-                    logging.warning('Unrecognized data type: {} ({})'.format(split_input[:4], split_input))
+                    logging.warning('Unrecognized data type: {}'.format(split_input[:4]))
 
         except socket.timeout:
             pass

animatedledstrip/command.py

@@ -0,0 +1,43 @@
+#   Copyright (c) 2019-2020 AnimatedLEDStrip
+#
+#   Permission is hereby granted, free of charge, to any person obtaining a copy
+#   of this software and associated documentation files (the "Software"), to deal
+#   in the Software without restriction, including without limitation the rights
+#   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#   copies of the Software, and to permit persons to whom the Software is
+#   furnished to do so, subject to the following conditions:
+#
+#   The above copyright notice and this permission notice shall be included in
+#   all copies or substantial portions of the Software.
+#
+#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+#   THE SOFTWARE.
+
+from .utils import check_data_type
+
+
+class Command(object):
+    """A command to send to the server"""
+
+    def __init__(self):
+        self.command = ''
+
+    def json(self) -> str:
+        """Create a JSON representation of this instance"""
+        if self.check_data_types() is False:
+            # If something has a bad data type (and STRICT_TYPE_CHECKING is False), return an empty string
+            return ''
+        else:
+            # Otherwise, create the JSON representation and return it
+            return ''.join(['CMD :{',
+                            '"command":"{}"'.format(self.command),
+                            '}'])
+
+    def check_data_types(self) -> bool:
+        """Check that all parameter types are correct"""
+        return check_data_type('message', self.command, str)

animatedledstrip/global_vars.py

@@ -27,6 +27,8 @@
 
 ANIMATION_DATA_PREFIX: bytes = bytes('DATA:', 'utf-8')
 ANIMATION_INFO_PREFIX: bytes = bytes('AINF:', 'utf-8')
+COMMAND_PREFIX: bytes = bytes('CMD :', 'utf-8')
 END_ANIMATION_PREFIX: bytes = bytes('END :', 'utf-8')
+MESSAGE_PREFIX: bytes = bytes('MSG :', 'utf-8')
 SECTION_PREFIX: bytes = bytes('SECT:', 'utf-8')
 STRIP_INFO_PREFIX: bytes = bytes('SINF:', 'utf-8')

animatedledstrip/message.py

@@ -0,0 +1,52 @@
+#   Copyright (c) 2019-2020 AnimatedLEDStrip
+#
+#   Permission is hereby granted, free of charge, to any person obtaining a copy
+#   of this software and associated documentation files (the "Software"), to deal
+#   in the Software without restriction, including without limitation the rights
+#   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#   copies of the Software, and to permit persons to whom the Software is
+#   furnished to do so, subject to the following conditions:
+#
+#   The above copyright notice and this permission notice shall be included in
+#   all copies or substantial portions of the Software.
+#
+#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+#   THE SOFTWARE.
+
+import json
+from typing import AnyStr
+
+from .utils import check_data_type
+
+
+class Message(object):
+    """A message from the server"""
+
+    def __init__(self):
+        self.message: str = ''
+
+    @classmethod
+    def from_json(cls, input_str: AnyStr) -> 'Message':
+        """Create an AnimationData instance from a JSON representation"""
+        # Parse the JSON
+        input_json = json.loads(input_str[5:])
+
+        # Create a new Message instance
+        new_instance = cls()
+
+        # Get each property from the JSON, reverting to defaults if it can't be found
+        new_instance.message = input_json.get('message', new_instance.message)
+
+        # Double check that everything has the right data type
+        new_instance.check_data_types()
+
+        return new_instance
+
+    def check_data_types(self) -> bool:
+        """Check that all parameter types are correct"""
+        return check_data_type('message', self.message, str)

get_raw.py

@@ -1,14 +1,14 @@
 from animatedledstrip import AnimationSender
 
 
-sender = AnimationSender("10.0.0.55", 6)
+sender = AnimationSender("10.44.167.23", 6)
 
 
 def receive(data: bytes):
     print(str(data) + '\n')
 
 
-sender.receiveCallback = receive
+sender.on_receive_callback = receive
 
 sender.start()
 

test/animatedledstrip/test_animation_sender.py

@@ -31,14 +31,14 @@ def test_constructor():
     assert sender.connected is False
     assert sender.recv_thread is None
     assert sender.running_animations == {}
-    assert sender.stripInfo is None
+    assert sender.strip_info is None
     assert sender.supported_animations == []
-    assert sender.receiveCallback is None
-    assert sender.newAnimationDataCallback is None
-    assert sender.newAnimationInfoCallback is None
-    assert sender.newEndAnimationCallback is None
-    assert sender.newSectionCallback is None
-    assert sender.newStripInfoCallback is None
+    assert sender.on_receive_callback is None
+    assert sender.on_new_animation_data_callback is None
+    assert sender.on_new_animation_info_callback is None
+    assert sender.on_new_end_animation_callback is None
+    assert sender.on_new_section_callback is None
+    assert sender.on_new_strip_info_callback is None
 
 
 def test_send_animation():
@@ -216,9 +216,9 @@ def test_parse_data_strip_info():
 
             sender.parse_data()
 
-            assert sender.stripInfo is not None
+            assert sender.strip_info is not None
 
-            info = sender.stripInfo
+            info = sender.strip_info
 
             assert info.num_leds == 240
             assert info.pin == 12
@@ -236,9 +236,9 @@ def test_parse_data_strip_info():
 
             sender.parse_data()
 
-            assert sender.stripInfo is not None
+            assert sender.strip_info is not None
 
-            info2 = sender.stripInfo
+            info2 = sender.strip_info
 
             assert info2.num_leds == 20
             assert info2.pin is None