struct-frame 0.0.24__py3-none-any.whl → 0.0.25__py3-none-any.whl

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/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/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)
 

{struct_frame-0.0.24.dist-info → struct_frame-0.0.25.dist-info}/METADATA

@@ -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.dist-info → struct_frame-0.0.25.dist-info}/RECORD

@@ -2,20 +2,21 @@ struct_frame/__init__.py,sha256=6v6MeHXVPlCn-sXE23fbGHqz8VA_xqCab8yeJ61-Njo,327
 struct_frame/__main__.py,sha256=tIybnBeFHvwiwVhodVOSnxhne5AX_80mtXBx4rneSB4,143
 struct_frame/base.py,sha256=1Z_0vMkwz0X8r2hIVLv5yuhwwD929LwNMzVKBqFxxac,2012
 struct_frame/c_gen.py,sha256=dQw52Zgec38O471KaHuYkRyehcxfjmSOpvhppExgB1c,5969
-struct_frame/generate.py,sha256=vAPTCLikB_DIy_mopLRWovZqDlOe8Y61Z6gcQi9AMdI,12598
-struct_frame/py_gen.py,sha256=6sdZEPBUteNUh2lv2OWLdJlj2Q_r-WipQX7kF6BHAvo,4811
+struct_frame/generate.py,sha256=vhBAvhFuDAvJdPXaYvdNTcMJeoirlnhc8NsVp0Gls7Q,12598
+struct_frame/py_gen.py,sha256=ZdfLWK7z_tayNW5zAKVSQMCHzw5Q8UEtxZNbJuPQZBw,4052
 struct_frame/ts_gen.py,sha256=qdJgAMxL2lV_WmGZErjHpgukYHNNpKpECarXdfmngEI,6266
 struct_frame/boilerplate/c/struct_frame.h,sha256=sVJtzKsA5H6irH_dTdbVmiL0A74cG8AhzO37xSlANzo,5074
 struct_frame/boilerplate/c/struct_frame_cpp.h,sha256=S6KEgeW78TGVeGGRuTseTXwkMNtzFT-n7faRg3A6nfo,1387
 struct_frame/boilerplate/c/struct_frame_gen.h,sha256=rsuYGesEv1rWzSU1z6ybG-1e95RuVR7_IiR1mGLhYpQ,14
 struct_frame/boilerplate/c/struct_frame_parser.h,sha256=5WP-0fH8BbqTeRUdzAye0Qh6gPBNHwVUocB3-gn5MOE,3005
 struct_frame/boilerplate/c/struct_frame_types.h,sha256=5aJUQ_cbVPM9drdRfo1gmN46-PiAtICAZYrpVjmHaJA,1684
-struct_frame/boilerplate/py/struct_frame_parser.py,sha256=txqaYNs5KFgnOsxRIbF3FGMwwtx0-6ynEDjOTy8LcU0,3607
+struct_frame/boilerplate/py/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+struct_frame/boilerplate/py/struct_frame_parser.py,sha256=TGGvVylzqKpiPAAG06eBUHqSQBzwuvAXiSpDi5m0Yd0,3789
 struct_frame/boilerplate/ts/struct_frame.ts,sha256=botKdIKVP7Bi6BJdXfIZaGAmoATnuj54LxZxc4DAWqM,2252
 struct_frame/boilerplate/ts/struct_frame_gen.ts,sha256=KAZitCUBeE8k0LSYLfOvR1GfG9JWDJUEDtmAOvOUAX0,168
 struct_frame/boilerplate/ts/struct_frame_parser.ts,sha256=6eTbafomqTsX3Fvfn82rxNQMxu4PwTaPug38xw4wrhE,3523
 struct_frame/boilerplate/ts/struct_frame_types.ts,sha256=aBtxVI2lUJKGPTtJAOpbStpS2sXSKvd4XWCIsOnaMk8,2130
-struct_frame-0.0.24.dist-info/METADATA,sha256=IfG-TS9rPWYr5ovqto2FXPP1VYo5u_j-OLahTg7M5rU,745
-struct_frame-0.0.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-struct_frame-0.0.24.dist-info/licenses/LICENSE,sha256=UjbLtGfcHCIqJg9UzEVGoNW8fyX4Ah9ZbsuAmJ_vhmk,1094
-struct_frame-0.0.24.dist-info/RECORD,,
+struct_frame-0.0.25.dist-info/METADATA,sha256=g8s0pxX1XU8picrrHIxGdisb5isILnHxyfzugbluRKA,745
+struct_frame-0.0.25.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+struct_frame-0.0.25.dist-info/licenses/LICENSE,sha256=UjbLtGfcHCIqJg9UzEVGoNW8fyX4Ah9ZbsuAmJ_vhmk,1094
+struct_frame-0.0.25.dist-info/RECORD,,