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

struct_frame/__init__.py

@@ -5,4 +5,5 @@ from .ts_gen import FileTsGen
 
 from .generate import main
 
-__all__ = ["main", "FileCGen", "FileTsGen", "version", "NamingStyleC", "CamelToSnakeCase", "pascalCase"]
+__all__ = ["main", "FileCGen", "FileTsGen", "version",
+           "NamingStyleC", "CamelToSnakeCase", "pascalCase"]

struct_frame/base.py

@@ -3,6 +3,7 @@ import re
 
 version = "0.0.1"
 
+
 class NamingStyle:
     def enum_name(self, name):
         return "_%s" % (name)
@@ -52,7 +53,7 @@ class NamingStyleC(NamingStyle):
         return self.underscore(name)
 
     def enum_entry(self, name):
-        return self.underscore(name).upper()
+        return name.upper()
 
     def func_name(self, name):
         return self.underscore(name)
@@ -66,15 +67,19 @@ class NamingStyleC(NamingStyle):
         word = re.sub(r"([a-z\d])([A-Z])", r'\1_\2', word)
         word = word.replace("-", "_")
         return word.lower()
-    
+
+
 def camelCase(st):
     output = ''.join(x for x in st.title() if x.isalnum())
     return output[0].lower() + output[1:]
 
+
 def pascalCase(st):
     return ''.join(x for x in st.title() if x.isalnum())
 
+
 pattern = re.compile(r'(?<!^)(?=[A-Z])')
 
+
 def CamelToSnakeCase(data):
-    return pattern.sub('_', data).lower()
+    return pattern.sub('_', data).lower()

struct_frame/boilerplate/c/struct_frame.h

@@ -4,51 +4,50 @@
 #include "string.h"
 #include "struct_frame_types.h"
 
-static inline struct checksum_t fletcher_checksum_calculation(uint8_t *buffer, uint8_t data_length)
-{
+static inline struct checksum_t fletcher_checksum_calculation(uint8_t *buffer, uint8_t data_length) {
   checksum_t checksum;
 
-  for (int i = 0; i < data_length; i++)
-  {
+  for (int i = 0; i < data_length; i++) {
     checksum.byte1 += buffer[i];
     checksum.byte2 += checksum.byte1;
   }
   return checksum;
 }
 
-static inline void msg_encode(struct_buffer *buffer, void *msg_buffer, uint8_t msg_id, uint8_t size)
-{
+static inline bool msg_encode(struct_buffer *buffer, void *msg_buffer, uint8_t msg_id, uint8_t size) {
+  if (buffer->in_progress) {
+    return false;
+  }
+  buffer->in_progress = true;
+
   buffer->data[buffer->size++] = buffer->config.start_byte;
   buffer->crc_start_loc = buffer->size;
   buffer->data[buffer->size++] = msg_id;
 
-  if (buffer->config.has_len)
-  {
+  if (buffer->config.has_len) {
     buffer->data[buffer->size++] = size;
   }
   memcpy(buffer->data + buffer->size, (uint8_t *)msg_buffer, size);
   buffer->size += size;
-  if (buffer->config.has_crc)
-  {
-    checksum_t crc = fletcher_checksum_calculation(buffer->data + buffer->crc_start_loc,
-                                                   buffer->crc_start_loc - buffer->size);
+  if (buffer->config.has_crc) {
+    checksum_t crc =
+        fletcher_checksum_calculation(buffer->data + buffer->crc_start_loc, buffer->crc_start_loc - buffer->size);
     buffer->data[buffer->size++] = crc.byte1;
     buffer->data[buffer->size++] = crc.byte2;
   }
+  buffer->in_progress = false;
+  return true;
 }
 
-static inline void *msg_reserve(struct_buffer *buffer, uint8_t msg_id, uint8_t size)
-{
-  if (buffer->in_progress)
-  {
+static inline void *msg_reserve(struct_buffer *buffer, uint8_t msg_id, uint8_t size) {
+  if (buffer->in_progress) {
     return 0;
   }
   buffer->in_progress = true;
   buffer->data[buffer->size++] = buffer->config.start_byte;
 
   buffer->data[buffer->size++] = msg_id;
-  if (buffer->config.has_len)
-  {
+  if (buffer->config.has_len) {
     buffer->data[buffer->size++] = size;
   }
 
@@ -58,46 +57,42 @@ static inline void *msg_reserve(struct_buffer *buffer, uint8_t msg_id, uint8_t s
   return out;
 }
 
-static inline void msg_finish(struct_buffer *buffer)
-{
-  if (buffer->config.has_crc)
-  {
-    checksum_t crc = fletcher_checksum_calculation(buffer->data + buffer->crc_start_loc,
-                                                   buffer->crc_start_loc - buffer->size);
+static inline bool msg_finish(struct_buffer *buffer) {
+  if (buffer->in_progress == false) {
+    return false;
+  }
+  if (buffer->config.has_crc) {
+    checksum_t crc =
+        fletcher_checksum_calculation(buffer->data + buffer->crc_start_loc, buffer->crc_start_loc - buffer->size);
     buffer->data[buffer->size++] = crc.byte1;
     buffer->data[buffer->size++] = crc.byte2;
   }
   buffer->in_progress = false;
+  return true;
 }
 
-#define MESSAGE_HELPER(funcname, name, msg_size, msg_id)                                    \
-  static inline void funcname##_encode(struct_buffer *buffer, name *name##_obj)                    \
-  {                                                                                         \
-    msg_encode(buffer, name##_obj, msg_id, msg_size);                                       \
-  }                                                                                         \
-  static inline bool funcname##_reserve(struct_buffer *buffer, name **msg)                         \
-  {                                                                                         \
-    void *ptr = msg_reserve(buffer, msg_id, msg_size);                                      \
-    if (ptr)                                                                                \
-    {                                                                                       \
-      *msg = (name *)ptr;                                                                   \
-      return true;                                                                          \
-    }                                                                                       \
-    return false;                                                                           \
-  }                                                                                         \
-  static inline void funcname##_finish(struct_buffer *buffer) { msg_finish(buffer); }              \
-  static inline name funcname##_get(struct_buffer *buffer)                                         \
-  {                                                                                         \
-    name msg = *(name *)(buffer->data);                                                     \
-    return msg;                                                                             \
-  }                                                                                         \
-  static inline name funcname##_get_from_buffer_result(buffer_parser_result_t result)              \
-  {                                                                                         \
-    name msg = *(name *)(result.msg_loc);                                                   \
-    return msg;                                                                             \
-  }                                                                                         \
+#define MESSAGE_HELPER(funcname, name, msg_size, msg_id)                                           \
+  static inline bool funcname##_encode(struct_buffer *buffer, name *name##_obj) {                  \
+    return msg_encode(buffer, name##_obj, msg_id, msg_size);                                       \
+  }                                                                                                \
+  static inline bool funcname##_reserve(struct_buffer *buffer, name **msg) {                       \
+    void *ptr = msg_reserve(buffer, msg_id, msg_size);                                             \
+    if (ptr) {                                                                                     \
+      *msg = (name *)ptr;                                                                          \
+      return true;                                                                                 \
+    }                                                                                              \
+    return false;                                                                                  \
+  }                                                                                                \
+  static inline bool funcname##_finish(struct_buffer *buffer) { return msg_finish(buffer); }       \
+  static inline name funcname##_get(struct_buffer *buffer) {                                       \
+    name msg = *(name *)(buffer->data);                                                            \
+    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_from_buffer_result(buffer_parser_result_t result)         \
-  {                                                                                         \
-    return (name *)(result.msg_loc);                                                        \
+  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

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "struct_frame_parser.h"
+#include "struct_frame_types.h"
+
+class StructFrameDevice : public struct_buffer {
+ public:
+  StructFrameDevice(struct_frame_config config)
+      : 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;
+    GetArray(buffer, buffer_size);
+    if (buffer && buffer_size) {
+      while (!parser_result_.finished) {
+        if (parse_buffer(buffer, buffer_size, &parser_result_)) {
+          if (parser_result_.valid) {
+            HandleResult();
+          }
+        }
+      }
+    }
+  }
+
+  void RunTx() { PutArray(struct_buffer::data, struct_buffer::max_size, struct_buffer::size); }
+
+  // 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;
+
+  // Get array, a pointer to an array and refernce to the array length is pased and mutated by this function
+  virtual void GetArray(uint8_t *&buffer, size_t &length) = 0;
+
+  virtual void HandleResult() = 0;
+
+ private:
+  buffer_parser_result_t parser_result_;
+};

struct_frame/boilerplate/c/struct_frame_gen.h

@@ -1,2 +1 @@
 #pragma once
-#include "myl_vehicle.sf.h"

struct_frame/boilerplate/c/struct_frame_parser.h

@@ -17,11 +17,9 @@ static inline bool parse_default_format_char_for_len_id(msg_id_len_t *msg_id_len
   return true;
 }
 
-parser_functions_t default_parser_functions = {parse_default_format_char_for_len_id,
-                                                      parse_default_format_validate};
+parser_functions_t default_parser_functions = {parse_default_format_char_for_len_id, parse_default_format_validate};
 
-static inline parser_functions_t *parse_char_for_start_byte(const struct_frame_config config,
-                                                     const uint8_t c) {
+static inline parser_functions_t *parse_char_for_start_byte(const struct_frame_config config, const uint8_t c) {
   if (config.start_byte == c) {
     return &default_parser_functions;
   }
@@ -65,6 +63,7 @@ static inline bool parse_char(struct_buffer *pb, uint8_t c) {
 static inline bool parse_buffer(uint8_t *buffer, size_t size, buffer_parser_result_t *parser_result) {
   enum ParserState state = LOOKING_FOR_START_BYTE;
   parser_functions_t *parse_func_ptr;
+  parser_result->finished = false;
   for (size_t i = parser_result->r_loc; i < size; i++) {
     switch (state) {
       case LOOKING_FOR_START_BYTE:
@@ -83,7 +82,6 @@ static inline bool parse_buffer(uint8_t *buffer, size_t size, buffer_parser_resu
       case GETTING_PAYLOAD:
         parser_result->msg_loc = buffer + i;
         parser_result->r_loc = i + parser_result->msg_id_len.len;
-        parser_result->found = true;
         if (parse_func_ptr->validate_packet(parser_result->msg_loc, &parser_result->msg_id_len)) {
           parser_result->valid = true;
           return true;
@@ -97,5 +95,7 @@ static inline bool parse_buffer(uint8_t *buffer, size_t size, buffer_parser_resu
         break;
     }
   }
+  parser_result->finished = true;
+  parser_result->r_loc = 0;
   return false;
 }

struct_frame/boilerplate/c/struct_frame_types.h

@@ -43,7 +43,6 @@ typedef struct _struct_frame_buffer {
 
 typedef struct _buffer_parser_result_t {
   struct_frame_config config;
-  bool found;
   bool valid;
   uint8_t *msg_loc;
   size_t r_loc;
@@ -56,12 +55,11 @@ typedef struct _buffer_parser_result_t {
 
 #define default_parser {0, 0, 0x90}
 
-#define zero_initialized_parser_result {default_parser, false, false, 0, 0, false, {0, 0}};
+#define zero_initialized_parser_result {default_parser, false, 0, 0, false, {0, 0}}
 
 #define CREATE_DEFAULT_STRUCT_BUFFER(name, size) \
   uint8_t name##_buffer[size];                   \
-  struct_buffer name = {                         \
-      default_parser, name##_buffer, size, 0, false, 0, LOOKING_FOR_START_BYTE, 0, {false, 0, 0}}
+  struct_buffer name = {default_parser, name##_buffer, size, 0, false, 0, LOOKING_FOR_START_BYTE, 0, {false, 0, 0}};
 
 typedef struct checksum_t {
   uint8_t byte1;

struct_frame/c_gen.py

@@ -14,7 +14,10 @@ c_types = {"uint8": "uint8_t",
            "int32": "int32_t",
            "bool": "bool",
            "float": "float",
-           "double": "double"}
+           "double": "double",
+           "uint64": 'uint64_t',
+           "int64":  'int64_t',
+           }
 
 
 class EnumCGen():
@@ -26,7 +29,7 @@ class EnumCGen():
         if leading_comment:
             for c in leading_comment:
                 result = '%s\n' % c
-        
+
         enumName = '%s%s' % (pascalCase(field.package), field.name)
         result += 'typedef enum %s' % (enumName)
 
@@ -46,8 +49,9 @@ class EnumCGen():
                 # last enum member should not end with a comma
                 comma = ""
 
-            enum_value = "    %s_%s = %d%s" % (CamelToSnakeCase(field.name).upper(),StyleC.enum_entry(d), field.data[d][0], comma)
-            
+            enum_value = "    %s_%s = %d%s" % (CamelToSnakeCase(
+                field.name).upper(), StyleC.enum_entry(d), field.data[d][0], comma)
+
             enum_values.append(enum_value)
 
         result += '\n'.join(enum_values)
@@ -65,7 +69,7 @@ class FieldCGen():
         result = ''
 
         var_name = field.name
-        type_name = field.fieldType 
+        type_name = field.fieldType
         if type_name in c_types:
             type_name = c_types[type_name]
         else:
@@ -73,7 +77,6 @@ class FieldCGen():
             if field.isEnum:
                 type_name = '%s_t' % type_name
 
-        
         result += '    %s %s%s;' % (type_name, var_name, "")
 
         leading_comment = field.comments
@@ -94,8 +97,7 @@ class MessageCGen():
             for c in msg.comments:
                 result = '%s\n' % c
 
-        
-        structName = '%s%s' % (pascalCase(msg.package), msg.name.title())
+        structName = '%s%s' % (pascalCase(msg.package), msg.name)
         result += 'typedef struct %s {' % structName
 
         result += '\n'
@@ -107,25 +109,26 @@ class MessageCGen():
             result += '    char dummy_field;'
         else:
             size = msg.size
-        
-        result += '\n'.join([FieldCGen.generate(f) for key, f in msg.fields.items()])
+
+        result += '\n'.join([FieldCGen.generate(f)
+                            for key, f in msg.fields.items()])
         result += '\n}'
         result += ' %s;\n\n' % structName
-        
-        defineName = '%s_%s' % (CamelToSnakeCase(msg.package).upper(), CamelToSnakeCase(msg.name).upper())
-        result += '#define %s_MAX_SIZE %d;\n' % (defineName, size)
+
+        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)
+                                                               size, msg.id)
 
         return result + '\n'
-    
+
     @staticmethod
     def get_initializer(msg, null_init):
         if not msg.fields:
@@ -148,7 +151,7 @@ class FileCGen():
 
         yield '#include "struct_frame.h"\n'
 
-        #include additional header files if available in the future
+        # include additional header files if available in the future
 
         if package.enums:
             yield '/* Enum definitions */\n'
@@ -164,7 +167,7 @@ class FileCGen():
             yield '\n'
 
         # Add default initializers if needed
-        #if package.messages:
+        # if package.messages:
         #    yield '/* Initializer values for message structs */\n'
         #    for key, msg in package.messages.items():
         #        identifier = '%s_%s_init_default' % (package.name, StyleC.struct_name(msg.name))
@@ -177,9 +180,10 @@ class FileCGen():
         if package.messages:
             yield 'uint8_t get_message_length(uint8_t msg_id){\n switch (msg_id)\n {\n'
             for key, msg in package.sortedMessages().items():
-                name = '%s_%s' % (CamelToSnakeCase(msg.package).upper(), CamelToSnakeCase(msg.name).upper())
-                yield '  case %s_MSG_ID: return %s_MAX_SIZE;\n' % (name, name)
+                name = '%s_%s' % (CamelToSnakeCase(
+                    msg.package).upper(), CamelToSnakeCase(msg.name).upper())
+                if msg.id:
+                    yield '  case %s_MSG_ID: return %s_MAX_SIZE;\n' % (name, name)
 
             yield '  default: break;\n } return 0;\n}'
             yield '\n'
-

struct_frame/generate.py

@@ -2,6 +2,8 @@
 # kate: replace-tabs on; indent-width 4;
 
 
+import os
+import shutil
 from struct_frame import FileCGen
 from struct_frame import FileTsGen
 from proto_schema_parser.parser import Parser
@@ -21,7 +23,9 @@ default_types = {
     "int32": {"size": 4},
     "bool": {"size": 1},
     "float": {"size": 4},
-    "double": {"size": 8}
+    "double": {"size": 8},
+    "int64": {"size": 8},
+    "uint64": {"size": 8}
 }
 
 
@@ -241,6 +245,7 @@ class Package:
             output = output + value.__str__() + "\n"
         return output
 
+
 packages = {}
 processed_file = []
 required_file = []
@@ -309,8 +314,6 @@ def printPackages():
     for key, value in packages.items():
         print(value)
 
-import os
-import shutil
 
 def generateCFileStrings(path):
     out = {}
@@ -321,6 +324,7 @@ def generateCFileStrings(path):
 
     return out
 
+
 def generateTsFileStrings(path):
     out = {}
     for key, value in packages.items():
@@ -346,7 +350,7 @@ def main():
 
     if (args.build_c):
         files = generateCFileStrings(args.c_path[0])
-    
+
     if (args.build_ts):
         files.update(generateTsFileStrings(args.ts_path[0]))
 
@@ -355,21 +359,22 @@ def main():
         if dirname and not os.path.exists(dirname):
             os.makedirs(dirname)
 
-        with open(filename , 'w', encoding='utf-8') as f:
-                    f.write(filedata)
+        with open(filename, 'w', encoding='utf-8') as f:
+            f.write(filedata)
 
     dir_path = os.path.dirname(os.path.realpath(__file__))
 
     if (args.build_c):
-        shutil.copytree(os.path.join(dir_path,"boilerplate/c"), args.c_path[0], dirs_exist_ok=True)
-    
+        shutil.copytree(os.path.join(dir_path, "boilerplate/c"),
+                        args.c_path[0], dirs_exist_ok=True)
+
     if (args.build_ts):
-        shutil.copytree(os.path.join(dir_path,"boilerplate/ts"), args.ts_path[0], dirs_exist_ok=True)
-    
+        shutil.copytree(os.path.join(dir_path, "boilerplate/ts"),
+                        args.ts_path[0], dirs_exist_ok=True)
+
     if args.debug:
         printPackages()
     print("Struct Frame successfully completed")
-    
 
 
 if __name__ == '__main__':

struct_frame/ts_gen.py

@@ -7,19 +7,20 @@ import time
 StyleC = NamingStyleC()
 
 ts_types = {
-    "int8_t":     'Int8',
-    "uint8_t":    'UInt8',
-    "int16_t":    'Int16LE',
-    "uint16_t":   'UInt16LE',
+    "int8":     'Int8',
+    "uint8":    'UInt8',
+    "int16":    'Int16LE',
+    "uint16":   'UInt16LE',
     "bool":     'Boolean8',
     "double":   'Float64LE',
     "float":    'Float32LE',
-    "int32_t":  'Int32LE',
-    "uint32_t": 'UInt32LE',
-    "uint64_t": 'BigInt64LE',
-    "int64_t":  'BigUInt64LE',
+    "int32":  'Int32LE',
+    "uint32": 'UInt32LE',
+    "uint64": 'BigInt64LE',
+    "int64":  'BigUInt64LE',
 }
 
+
 class EnumTsGen():
     @staticmethod
     def generate(field, packageName):
@@ -29,7 +30,8 @@ class EnumTsGen():
             for c in leading_comment:
                 result = '%s\n' % c
 
-        result += 'export enum %s%s' % (packageName, StyleC.enum_name(field.name))
+        result += 'export enum %s%s' % (packageName,
+                                        StyleC.enum_name(field.name))
 
         result += ' {\n'
 
@@ -49,7 +51,7 @@ class EnumTsGen():
 
             enum_value = "    %s = %d%s" % (
                 StyleC.enum_entry(d), field.data[d][0], comma)
-           
+
             enum_values.append(enum_value)
 
         result += '\n'.join(enum_values)
@@ -65,7 +67,7 @@ class FieldTsGen():
         isEnum = False
 #        isEnum = field.pbtype in ('ENUM', 'UENUM')
         var_name = StyleC.var_name(field.name)
-        type_name = field.fieldType 
+        type_name = field.fieldType
         if type_name in ts_types:
             type_name = ts_types[type_name]
         else:
@@ -98,7 +100,7 @@ class MessageTsGen():
         if leading_comment:
             for c in msg.comments:
                 result = '%s\n' % c
-                
+
         struct_name = '%s_%s' % (packageName, StyleC.type_name(msg.name))
         result += 'export const %s = new typed_struct.Struct(\'%s\') ' % (
             struct_name, struct_name)
@@ -113,7 +115,8 @@ class MessageTsGen():
         else:
             size = msg.size
 
-        result += '\n'.join([FieldTsGen.generate(f, packageName) for key, f in msg.fields.items()])
+        result += '\n'.join([FieldTsGen.generate(f, packageName)
+                            for key, f in msg.fields.items()])
         result += '\n    .compile();\n\n'
 
         result += 'export const %s_max_size = %d;\n' % (struct_name, size)
@@ -147,7 +150,7 @@ class MessageTsGen():
         for field in msg.fields:
             parts.append(field.get_initializer(null_init))
         return '{' + ', '.join(parts) + '}'
-    
+
 
 class FileTsGen():
     @staticmethod
@@ -163,8 +166,8 @@ class FileTsGen():
 
         yield "import { msg_encode, msg_reserve, msg_finish } from './struct_frame';\n\n"
 
-        #include additional header files here if available in the future
-        
+        # include additional header files here if available in the future
+
         if package.enums:
             yield '/* Enum definitions */\n'
             for key, enum in package.enums.items():

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: struct-frame
-Version: 0.0.20
+Version: 0.0.23
 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
@@ -26,5 +26,3 @@ node index.js
 npx tsc --project tsconfig.json; node index.js
 
 
-usage python -m struct_frame
-

struct_frame-0.0.23.dist-info/RECORD

@@ -0,0 +1,19 @@
+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,,

struct_frame-0.0.20.dist-info/RECORD

@@ -1,18 +0,0 @@
-struct_frame/__init__.py,sha256=t_GBVV-CeYA4Yupfu-pH5922nisafAOZLsyyfrJtD0c,269
-struct_frame/__main__.py,sha256=tIybnBeFHvwiwVhodVOSnxhne5AX_80mtXBx4rneSB4,143
-struct_frame/base.py,sha256=Sx1hwOjpmbhArPldw4jYibvd7UMRtfkSO_P0lu9NqZA,2021
-struct_frame/c_gen.py,sha256=_XC96txPtH0ukbrMSyYegVb5GwV5ADEEDd6yY3Hg3vU,5848
-struct_frame/generate.py,sha256=9_DTI54tjG48fP9GUzb6npRmzgynAOUJgIVFXQSlxm8,11819
-struct_frame/ts_gen.py,sha256=b_mx5IwemcWB70082iHSGOAPzqcnnglXB-fEk4Q2uLM,6123
-struct_frame/boilerplate/c/struct_frame.h,sha256=Y0V39aqXfR-eTSNe6f1hdc55GXHXBADBK2kbNrxCo-k,4909
-struct_frame/boilerplate/c/struct_frame_gen.h,sha256=MdXFYOO6E7IN4DM5EaEMXXowZb4auv8UeyQBprkqx68,43
-struct_frame/boilerplate/c/struct_frame_parser.h,sha256=A38zoqaAxh4cw4rG7zzF7FFQ9qnfqP2w41cpn2dO2CA,3052
-struct_frame/boilerplate/c/struct_frame_types.h,sha256=e67BvA1kAg_OnjnktUv1fAtLB0nn7FzPVhIPaque5Ts,1740
-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.20.dist-info/METADATA,sha256=ybLoKrdsxSTfOnAOghQzYzwnXhT9jpCzNk1l3LjYX-Q,734
-struct_frame-0.0.20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-struct_frame-0.0.20.dist-info/licenses/LICENSE,sha256=UjbLtGfcHCIqJg9UzEVGoNW8fyX4Ah9ZbsuAmJ_vhmk,1094
-struct_frame-0.0.20.dist-info/RECORD,,