struct-frame 0.0.24__tar.gz → 0.0.25__tar.gz

{struct_frame-0.0.24 → struct_frame-0.0.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: struct-frame
-Version: 0.0.24
+Version: 0.0.25
 Summary: A framework for serializing data with headers
 Project-URL: Homepage, https://github.com/mylonics/struct-frame
 Project-URL: Issues, https://github.com/mylonics/struct-frame/issues

{struct_frame-0.0.24 → struct_frame-0.0.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "struct-frame"
-version = "0.0.24"
+version = "0.0.25"
 authors = [
   { name="Rijesh Augustine", email="rijesh@mylonics.com" },
 ]

{struct_frame-0.0.24 → struct_frame-0.0.25}/src/struct_frame/boilerplate/py/struct_frame_parser.py

@@ -4,10 +4,10 @@ from enum import Enum
 
 def fletcher_checksum_calculation(buffer, start=0, end=None):
     if end == None:
-        end = buffer.length
+        end = len(buffer)
 
     byte1 = 0
-    byte2 = 2
+    byte2 = 0
 
     for x in range(start, end):
         byte1 += buffer[x]
@@ -17,26 +17,26 @@ def fletcher_checksum_calculation(buffer, start=0, end=None):
 
 
 class BasicPacket:
-    start_byte = None
+    start_byte = 0x90
     header_length = 0
     footer_length = 0
 
     desired_packet_length = 0
     packet = []
 
-    def __init__(self, start_byte, header_length, footer_length):
+    def __init__(self, start_byte=0x90, header_length=2, footer_length=2):
         self.start_byte = start_byte
         self.header_length = header_length
         self.footer_length = footer_length
 
-    def add_header_byte(self, byte, clear):
+    def add_header_byte(self, byte, clear=False):
         if clear:
             self.packet.clear()
-        self.packet.push(byte)
+        self.packet.append(byte)
         return len(self.packet) == self.header_length
 
     def add_packet_byte(self, byte):
-        self.packet.push(byte)
+        self.packet.append(byte)
         return len(self.packet) == self.desired_packet_length
 
     def get_msg_id(self):
@@ -54,15 +54,20 @@ class BasicPacket:
     def get_msg_buffer(self):
         return self.packet[self.header_length:self.desired_packet_length - self.footer_length]
 
+    def encode_msg(self, msg):
+        return self.encode(msg.pack(), msg.msg_id)
+
     def encode(self, data, msg_id):
         output = []
-        output.push(self.start_byte)
-        output.push(msg_id)
-        output.push(data)
+        output.append(self.start_byte)
+        output.append(msg_id)
+        if (len(data)):
+            for b in data:
+                output.append(b)
         checksum = fletcher_checksum_calculation(data)
 
-        output.push(checksum[0])
-        output.push(checksum[1])
+        output.append(checksum[0])
+        output.append(checksum[1])
         return output
 
 
@@ -75,44 +80,39 @@ class ParserState(Enum):
 class FrameParser:
     state = ParserState.LOOKING_FOR_START_BYTE
     buffer = []
-    parser = None
+    packetFormat = None
     msg_definitions = None
     msg_id_loc = None
     msg_type = None
 
-    def __init__(self, parsers, msg_definitions):
-        self.parsers = parsers
+    def __init__(self, packetFormats, msg_definitions):
+        self.packetFormats = packetFormats
         self.msg_definitions = msg_definitions
 
     def parse_char(self, c):
-        if state == ParserState.LOOKING_FOR_START_BYTE:
-            self.parser = self.parsers[c]
-            if self.parser:
-                if self.parser.add_header_byte(c, True):
-                    state = ParserState.GETTING_PACKET
+        if self.state == ParserState.LOOKING_FOR_START_BYTE:
+            self.packetFormat = self.packetFormats[c]
+            if self.packetFormat:
+                if self.packetFormat.add_header_byte(c, True):
+                    self.state = ParserState.GETTING_PACKET
                 else:
-                    state = ParserState.GETTING_HEADER
+                    self.state = ParserState.GETTING_HEADER
 
-        elif state == ParserState.GETTING_HEADER:
-            if self.parser.add_header_byte(c):
-                msg_id = self.parser.get_msg_id()
+        elif self.state == ParserState.GETTING_HEADER:
+            if self.packetFormat.add_header_byte(c):
+                msg_id = self.packetFormat.get_msg_id()
                 self.msg_type = self.msg_definitions[msg_id]
                 if self.msg_type:
-                    self.parser.get_full_packet_length(self.msg_type.msg_size)
-                    state = ParserState.GETTING_PACKET
+                    self.packetFormat.get_full_packet_length(
+                        self.msg_type.msg_size)
+                    self.state = ParserState.GETTING_PACKET
                 else:
-                    state = ParserState.LOOKING_FOR_START_BYTE
+                    self.state = ParserState.LOOKING_FOR_START_BYTE
 
-        elif state == ParserState.GETTING_PACKET:
-            if self.parser.add_packet_byte(c):
-                state = ParserState.LOOKING_FOR_START_BYTE
-                if self.parser.validatePackage:
-                    return self.msg_type.create_unpack(self.parser.get_msg_buffer())
+        elif self.state == ParserState.GETTING_PACKET:
+            if self.packetFormat.add_packet_byte(c):
+                self.state = ParserState.LOOKING_FOR_START_BYTE
+                if self.packetFormat.validate_packet():
+                    return self.msg_type.create_unpack(bytes(self.packetFormat.get_msg_buffer()))
 
         return False
-
-
-def TestFunction():
-    parsers = {BasicPacket.start_byte, BasicPacket()}
-    frameParser = FrameParser(parsers)
-    frameParser.parse_char

{struct_frame-0.0.24 → struct_frame-0.0.25}/src/struct_frame/generate.py

@@ -340,7 +340,7 @@ def generateTsFileStrings(path):
 def generatePyFileStrings(path):
     out = {}
     for key, value in packages.items():
-        name = os.path.join(path, value.name + ".sf.py")
+        name = os.path.join(path, value.name + "_sf.py")
         data = ''.join(FilePyGen.generate(value))
         out[name] = data
     return out

{struct_frame-0.0.24 → struct_frame-0.0.25}/src/struct_frame/py_gen.py

@@ -88,32 +88,12 @@ class MessagePyGen():
         structName = '%s%s' % (pascalCase(msg.package), msg.name)
         result += 'class %s(Structured):\n' % structName
         result += '    msg_size = %s\n' % msg.size
-        if msg.id:
+        if msg.id != None:
             result += '    msg_id = %s\n' % msg.id
 
-        size = 1
-        if not msg.fields:
-            # Empty structs are not allowed in C standard.
-            # Therefore add a dummy field if an empty message occurs.
-            result += '    dummy_field: pad'
-        else:
-            size = msg.size
-
         result += '\n'.join([FieldPyGen.generate(f)
                             for key, f in msg.fields.items()])
 
-        # defineName = '%s_%s' % (CamelToSnakeCase(
-        #    msg.package).upper(), CamelToSnakeCase(msg.name).upper())
-        # result += '#define %s_MAX_SIZE %d\n' % (defineName, size)
-#
-        # if msg.id:
-        #    result += '#define %s_MSG_ID %d\n' % (defineName, msg.id)
-#
-        # funcName = defineName.lower()
-        # if msg.id:
-        #    result += 'MESSAGE_HELPER(%s, %s, %d, %d);\n\n' % (funcName, structName,
-        #                                                       size, msg.id)
-#
         return result + '\n'
 
     @staticmethod
@@ -153,7 +133,7 @@ class FilePyGen():
 
             yield '%s_definitions = {\n' % package.name
             for key, msg in package.sortedMessages().items():
-                if msg.id:
+                if msg.id != None:
                     structName = '%s%s' % (pascalCase(msg.package), msg.name)
                     yield '    %s: %s,\n' % (msg.id, structName)