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

struct_frame/__init__.py

@@ -2,8 +2,9 @@ from .base import version, NamingStyleC, CamelToSnakeCase, pascalCase
 
 from .c_gen import FileCGen
 from .ts_gen import FileTsGen
+from .py_gen import FilePyGen
 
 from .generate import main
 
-__all__ = ["main", "FileCGen", "FileTsGen", "version",
+__all__ = ["main", "FileCGen", "FileTsGen", "FilePyGen", "version",
            "NamingStyleC", "CamelToSnakeCase", "pascalCase"]

struct_frame/boilerplate/c/struct_frame.h

@@ -88,11 +88,16 @@ static inline bool msg_finish(struct_buffer *buffer) {
     name msg = *(name *)(buffer->data);                                                            \
     return msg;                                                                                    \
   }                                                                                                \
+  static inline name funcname##_get(uint8_t *buffer) {                                             \
+    name msg = *(name *)(buffer);                                                                  \
+    return msg;                                                                                    \
+  }                                                                                                \
   static inline name funcname##_get_from_buffer_result(buffer_parser_result_t result) {            \
     name msg = *(name *)(result.msg_loc);                                                          \
     return msg;                                                                                    \
   }                                                                                                \
   static inline name *funcname##_get_ref(struct_buffer *buffer) { return (name *)(buffer->data); } \
+  static inline name *funcname##_get_ref(uint8_t *buffer) { return (name *)(buffer); }             \
   static inline name *funcname##_get_ref_from_buffer_result(buffer_parser_result_t result) {       \
     return (name *)(result.msg_loc);                                                               \
   }

struct_frame/boilerplate/c/struct_frame_cpp.h

@@ -9,8 +9,6 @@ class StructFrameDevice : public struct_buffer {
       : struct_buffer{config, nullptr, 0, 0, false, 0, LOOKING_FOR_START_BYTE, 0, {false, 0, 0}},
         parser_result_{config, false, 0, 0, false, {0, 0}} {}
 
-  void Init() { PutArray(struct_buffer::data, struct_buffer::max_size, 0); }
-
   void RunRx() {
     uint8_t *buffer;
     size_t buffer_size;
@@ -28,6 +26,9 @@ class StructFrameDevice : public struct_buffer {
 
   void RunTx() { PutArray(struct_buffer::data, struct_buffer::max_size, struct_buffer::size); }
 
+ protected:
+  void Init() { PutArray(struct_buffer::data, struct_buffer::max_size, 0); }
+
   // Put Array must accept the full buffer of data and returns a pointer to either a new buffer or the same buffer
   // that is free
   virtual void PutArray(uint8_t *&buffer, size_t &max_length, size_t length) = 0;
@@ -36,7 +37,5 @@ class StructFrameDevice : public struct_buffer {
   virtual void GetArray(uint8_t *&buffer, size_t &length) = 0;
 
   virtual void HandleResult() = 0;
-
- private:
   buffer_parser_result_t parser_result_;
 };

struct_frame/boilerplate/py/struct_frame_parser.py

@@ -0,0 +1,118 @@
+
+from enum import Enum
+
+
+def fletcher_checksum_calculation(buffer, start=0, end=None):
+    if end == None:
+        end = buffer.length
+
+    byte1 = 0
+    byte2 = 2
+
+    for x in range(start, end):
+        byte1 += buffer[x]
+        byte2 += byte1
+
+    return [byte1, byte2]
+
+
+class BasicPacket:
+    start_byte = None
+    header_length = 0
+    footer_length = 0
+
+    desired_packet_length = 0
+    packet = []
+
+    def __init__(self, start_byte, header_length, footer_length):
+        self.start_byte = start_byte
+        self.header_length = header_length
+        self.footer_length = footer_length
+
+    def add_header_byte(self, byte, clear):
+        if clear:
+            self.packet.clear()
+        self.packet.push(byte)
+        return len(self.packet) == self.header_length
+
+    def add_packet_byte(self, byte):
+        self.packet.push(byte)
+        return len(self.packet) == self.desired_packet_length
+
+    def get_msg_id(self):
+        return self.packet[1]
+
+    def get_full_packet_length(self, msg_length):
+        self.desired_packet_length = self.header_length + self.footer_length + msg_length
+        return self.desired_packet_length
+
+    def validate_packet(self):
+        checksum = fletcher_checksum_calculation(
+            self.packet, self.header_length, self.desired_packet_length - self.footer_length)
+        return checksum[0] == self.packet[-2] and checksum[1] == self.packet[-1]
+
+    def get_msg_buffer(self):
+        return self.packet[self.header_length:self.desired_packet_length - self.footer_length]
+
+    def encode(self, data, msg_id):
+        output = []
+        output.push(self.start_byte)
+        output.push(msg_id)
+        output.push(data)
+        checksum = fletcher_checksum_calculation(data)
+
+        output.push(checksum[0])
+        output.push(checksum[1])
+        return output
+
+
+class ParserState(Enum):
+    LOOKING_FOR_START_BYTE = 0
+    GETTING_HEADER = 1
+    GETTING_PACKET = 2
+
+
+class FrameParser:
+    state = ParserState.LOOKING_FOR_START_BYTE
+    buffer = []
+    parser = None
+    msg_definitions = None
+    msg_id_loc = None
+    msg_type = None
+
+    def __init__(self, parsers, msg_definitions):
+        self.parsers = parsers
+        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
+                else:
+                    state = ParserState.GETTING_HEADER
+
+        elif state == ParserState.GETTING_HEADER:
+            if self.parser.add_header_byte(c):
+                msg_id = self.parser.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
+                else:
+                    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())
+
+        return False
+
+
+def TestFunction():
+    parsers = {BasicPacket.start_byte, BasicPacket()}
+    frameParser = FrameParser(parsers)
+    frameParser.parse_char

struct_frame/boilerplate/ts/struct_frame_gen.ts

@@ -1,7 +1,7 @@
 
-import * as bs from './biostream.sf';
+import * as myl from './myl_vehicle.sf';
 
 export function get_message_length(msg_id: number) {
   console.log(msg_id)
-  return bs.get_message_length(msg_id);
+  return myl.get_message_length(msg_id);
 }

struct_frame/generate.py

@@ -6,6 +6,7 @@ import os
 import shutil
 from struct_frame import FileCGen
 from struct_frame import FileTsGen
+from struct_frame import FilePyGen
 from proto_schema_parser.parser import Parser
 from proto_schema_parser import ast
 
@@ -258,8 +259,10 @@ parser.add_argument('filename')
 parser.add_argument('--debug', action='store_true')
 parser.add_argument('--build_c', action='store_true')
 parser.add_argument('--build_ts', action='store_true')
+parser.add_argument('--build_py', action='store_true')
 parser.add_argument('--c_path', nargs=1, type=str, default=['c/'])
 parser.add_argument('--ts_path', nargs=1, type=str, default=['ts/'])
+parser.add_argument('--py_path', nargs=1, type=str, default=['py/'])
 
 
 def parseFile(filename):
@@ -334,11 +337,20 @@ def generateTsFileStrings(path):
     return out
 
 
+def generatePyFileStrings(path):
+    out = {}
+    for key, value in packages.items():
+        name = os.path.join(path, value.name + ".sf.py")
+        data = ''.join(FilePyGen.generate(value))
+        out[name] = data
+    return out
+
+
 def main():
     args = parser.parse_args()
     parseFile(args.filename)
 
-    if (not args.build_c and not args.build_ts):
+    if (not args.build_c and not args.build_ts and not args.build_py):
         print("Select at least one build argument")
         return
 
@@ -348,12 +360,16 @@ def main():
         print(
             f'Recursion Error. Messages most likely have a cyclical dependancy. Check Message: {recErrCurrentMessage} and Field: {recErrCurrentField}')
 
+    files = {}
     if (args.build_c):
-        files = generateCFileStrings(args.c_path[0])
+        files.update(generateCFileStrings(args.c_path[0]))
 
     if (args.build_ts):
         files.update(generateTsFileStrings(args.ts_path[0]))
 
+    if (args.build_py):
+        files.update(generatePyFileStrings(args.py_path[0]))
+
     for filename, filedata in files.items():
         dirname = os.path.dirname(filename)
         if dirname and not os.path.exists(dirname):
@@ -372,6 +388,10 @@ def main():
         shutil.copytree(os.path.join(dir_path, "boilerplate/ts"),
                         args.ts_path[0], dirs_exist_ok=True)
 
+    if (args.build_py):
+        shutil.copytree(os.path.join(dir_path, "boilerplate/py"),
+                        args.py_path[0], dirs_exist_ok=True)
+
     if args.debug:
         printPackages()
     print("Struct Frame successfully completed")

struct_frame/py_gen.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+# kate: replace-tabs on; indent-width 4;
+
+from struct_frame import version, NamingStyleC, CamelToSnakeCase, pascalCase
+import time
+
+StyleC = NamingStyleC()
+
+py_types = {"uint8": "uint8",
+            "int8": "int8",
+            "uint16": "uint16",
+            "int16": "int16",
+            "uint32": "uint32",
+            "int32": "int32",
+            "bool": "bool8",
+            "float": "float32",
+            "double": "float64",
+            "uint64": 'uint64',
+            "int64":  'int64',
+            }
+
+
+class EnumPyGen():
+    @staticmethod
+    def generate(field):
+        leading_comment = field.comments
+
+        result = ''
+        if leading_comment:
+            for c in leading_comment:
+                result = '#%s\n' % c
+
+        enumName = '%s%s' % (pascalCase(field.package), field.name)
+        result += 'class %s(Enum):\n' % (enumName)
+
+        enum_length = len(field.data)
+        enum_values = []
+        for index, (d) in enumerate(field.data):
+            leading_comment = field.data[d][1]
+
+            if leading_comment:
+                for c in leading_comment:
+                    enum_values.append("#" + c)
+
+            enum_value = "    %s_%s = %d" % (CamelToSnakeCase(
+                field.name).upper(), StyleC.enum_entry(d), field.data[d][0])
+
+            enum_values.append(enum_value)
+
+        result += '\n'.join(enum_values)
+        return result
+
+
+class FieldPyGen():
+    @staticmethod
+    def generate(field):
+        result = ''
+
+        var_name = field.name
+        type_name = field.fieldType
+        if type_name in py_types:
+            type_name = py_types[type_name]
+        else:
+            type_name = '%s%s' % (pascalCase(field.package), type_name)
+            if field.isEnum:
+                type_name = 'uint8 #%s' % type_name
+
+        result += '    %s: %s' % (var_name, type_name)
+
+        leading_comment = field.comments
+        if leading_comment:
+            for c in leading_comment:
+                result = "#" + c + "\n" + result
+
+        return result
+
+
+class MessagePyGen():
+    @staticmethod
+    def generate(msg):
+        leading_comment = msg.comments
+
+        result = ''
+        if leading_comment:
+            for c in msg.comments:
+                result = '#%s\n' % c
+
+        structName = '%s%s' % (pascalCase(msg.package), msg.name)
+        result += 'class %s(Structured):\n' % structName
+        result += '    msg_size = %s\n' % msg.size
+        if msg.id:
+            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
+    def get_initializer(msg, null_init):
+        if not msg.fields:
+            return '{0}'
+
+        parts = []
+        for field in msg.fields:
+            parts.append(field.get_initializer(null_init))
+        return '{' + ', '.join(parts) + '}'
+
+
+class FilePyGen():
+    @staticmethod
+    def generate(package):
+        yield '# Automatically generated struct frame header \n'
+        yield '# Generated by %s at %s. \n\n' % (version, time.asctime())
+
+        yield 'from structured import *\n'
+        yield 'from enum import Enum\n\n'
+
+        if package.enums:
+            yield '# Enum definitions\n'
+            for key, enum in package.enums.items():
+                yield EnumPyGen.generate(enum) + '\n\n'
+
+        if package.messages:
+            yield '# Struct definitions \n'
+            # Need to sort messages to make sure dependecies are properly met
+
+            for key, msg in package.sortedMessages().items():
+                yield MessagePyGen.generate(msg) + '\n'
+            yield '\n'
+
+        if package.messages:
+
+            yield '%s_definitions = {\n' % package.name
+            for key, msg in package.sortedMessages().items():
+                if msg.id:
+                    structName = '%s%s' % (pascalCase(msg.package), msg.name)
+                    yield '    %s: %s,\n' % (msg.id, structName)
+
+            yield '}\n'

struct_frame/ts_gen.py

@@ -101,9 +101,10 @@ class MessageTsGen():
             for c in msg.comments:
                 result = '%s\n' % c
 
-        struct_name = '%s_%s' % (packageName, StyleC.type_name(msg.name))
+        package_msg_name = '%s_%s' % (packageName, msg.name)
+
         result += 'export const %s = new typed_struct.Struct(\'%s\') ' % (
-            struct_name, struct_name)
+            package_msg_name, package_msg_name)
 
         result += '\n'
 
@@ -119,25 +120,26 @@ class MessageTsGen():
                             for key, f in msg.fields.items()])
         result += '\n    .compile();\n\n'
 
-        result += 'export const %s_max_size = %d;\n' % (struct_name, size)
+        result += 'export const %s_max_size = %d;\n' % (package_msg_name, size)
 
         if msg.id:
-            result += 'export const %s_msgid = %d\n' % (msg.name, msg.id)
+            result += 'export const %s_msgid = %d\n' % (
+                package_msg_name, msg.id)
 
             result += 'export function %s_encode(buffer: struct_frame_buffer, msg: any) {\n' % (
-                msg.name)
-            result += '    msg_encode(buffer, msg, %s_msgid)\n}\n' % (msg.name)
+                package_msg_name)
+            result += '    msg_encode(buffer, msg, %s_msgid)\n}\n' % (package_msg_name)
 
             result += 'export function %s_reserve(buffer: struct_frame_buffer) {\n' % (
-                msg.name)
+                package_msg_name)
             result += '    const msg_buffer = msg_reserve(buffer, %s_msgid, %s_max_size);\n' % (
-                msg.name, msg.name)
+                package_msg_name, package_msg_name)
             result += '    if (msg_buffer){\n'
             result += '        return new %s(msg_buffer)\n    }\n    return;\n}\n' % (
-                msg.name)
+                package_msg_name)
 
             result += 'export function %s_finish(buffer: struct_frame_buffer) {\n' % (
-                msg.name)
+                package_msg_name)
             result += '    msg_finish(buffer);\n}\n'
         return result + '\n'
 
@@ -182,8 +184,9 @@ class FileTsGen():
         if package.messages:
             yield 'export function get_message_length(msg_id : number){\n switch (msg_id)\n {\n'
             for key, msg in package.sortedMessages().items():
-                name = StyleC.type_name(msg.name)
-                yield '  case %s_msgid: return %s_max_size;\n' % (name, name)
+
+                package_msg_name = '%s_%s' % (package.name, msg.name)
+                yield '  case %s_msgid: return %s_max_size;\n' % (package_msg_name, package_msg_name)
 
             yield '  default: break;\n } return 0;\n}'
             yield '\n'

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: struct-frame
-Version: 0.0.23
+Version: 0.0.24
 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
@@ -11,6 +11,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
 Requires-Dist: proto-schema-parser>=1.4.5
+Requires-Dist: structured-classes>=3.1.0
 Description-Content-Type: text/markdown
 
 

struct_frame-0.0.24.dist-info/RECORD

@@ -0,0 +1,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/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/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.23.dist-info/RECORD

@@ -1,19 +0,0 @@
-struct_frame/__init__.py,sha256=HnmRU0-0so_x2zmRtex4weF1XPd11SE73iBHn0hcKE4,283
-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=UkZEZtKfTEmC0lEeInL7F4amCYFx1-bXPg23382rV-Y,11903
-struct_frame/ts_gen.py,sha256=9arnjhgQZqT4F2aTKyFQrHNpn7u-fqX3B-g_17sxIFE,6137
-struct_frame/boilerplate/c/struct_frame.h,sha256=vou8iXsV_4dQBlZRuMNOr1RnuXD1bUJUR4A3dH_uvwM,4564
-struct_frame/boilerplate/c/struct_frame_cpp.h,sha256=gZRNmrQqmzoGkfwlGKh14dfbndkeVhnro11SNPngJng,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/ts/struct_frame.ts,sha256=botKdIKVP7Bi6BJdXfIZaGAmoATnuj54LxZxc4DAWqM,2252
-struct_frame/boilerplate/ts/struct_frame_gen.ts,sha256=pz6QTIWDTIY0rMCFiGNgp3DcfO7cKsmXrx3rj3zgN_U,164
-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.23.dist-info/METADATA,sha256=hR99Tvri4v-oJ6nFuhoOo8MfsIm91zcCIeCbYO_gk14,704
-struct_frame-0.0.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-struct_frame-0.0.23.dist-info/licenses/LICENSE,sha256=UjbLtGfcHCIqJg9UzEVGoNW8fyX4Ah9ZbsuAmJ_vhmk,1094
-struct_frame-0.0.23.dist-info/RECORD,,