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

struct_frame/__init__.py

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

struct_frame/c_gen.py

@@ -178,12 +178,12 @@ class FileCGen():
         #    yield '\n'
 
         if package.messages:
-            yield 'uint8_t get_message_length(uint8_t msg_id){\n switch (msg_id)\n {\n'
+            yield 'bool get_message_length(size_t msg_id, size_t* size){\n switch (msg_id)\n {\n'
             for key, msg in package.sortedMessages().items():
                 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 '  case %s_MSG_ID: *size = %s_MAX_SIZE; return true;\n' % (name, name)
 
-            yield '  default: break;\n } return 0;\n}'
+            yield '  default: break;\n } return false;\n}'
             yield '\n'

struct_frame/generate.py

@@ -7,6 +7,7 @@ import shutil
 from struct_frame import FileCGen
 from struct_frame import FileTsGen
 from struct_frame import FilePyGen
+from struct_frame import FileGqlGen
 from proto_schema_parser.parser import Parser
 from proto_schema_parser import ast
 
@@ -260,9 +261,12 @@ 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/'])
+parser.add_argument('--c_path', nargs=1, type=str, default=['generated/c/'])
+parser.add_argument('--ts_path', nargs=1, type=str, default=['generated/ts/'])
+parser.add_argument('--py_path', nargs=1, type=str, default=['generated/py/'])
+parser.add_argument('--build_gql', action='store_true')
+parser.add_argument('--gql_path', nargs=1, type=str,
+                    default=['generated/gql/'])
 
 
 def parseFile(filename):
@@ -350,7 +354,7 @@ def main():
     args = parser.parse_args()
     parseFile(args.filename)
 
-    if (not args.build_c and not args.build_ts and not args.build_py):
+    if (not args.build_c and not args.build_ts and not args.build_py and not args.build_gql):
         print("Select at least one build argument")
         return
 
@@ -370,6 +374,12 @@ def main():
     if (args.build_py):
         files.update(generatePyFileStrings(args.py_path[0]))
 
+    if (args.build_gql):
+        for key, value in packages.items():
+            name = os.path.join(args.gql_path[0], value.name + '.graphql')
+            data = ''.join(FileGqlGen.generate(value))
+            files[name] = data
+
     for filename, filedata in files.items():
         dirname = os.path.dirname(filename)
         if dirname and not os.path.exists(dirname):
@@ -392,6 +402,8 @@ def main():
         shutil.copytree(os.path.join(dir_path, "boilerplate/py"),
                         args.py_path[0], dirs_exist_ok=True)
 
+    # No boilerplate for GraphQL currently
+
     if args.debug:
         printPackages()
     print("Struct Frame successfully completed")

struct_frame/gql_gen.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+# Simple GraphQL schema generator for struct-frame
+
+from struct_frame import version, pascalCase, CamelToSnakeCase
+import time
+
+# Mapping from proto primitive types to GraphQL scalar types
+gql_types = {
+    "uint8": "Int",
+    "int8": "Int",
+    "uint16": "Int",
+    "int16": "Int",
+    "uint32": "Int",
+    "int32": "Int",
+    "uint64": "Int",  # Could be custom scalar if needed
+    "int64": "Int",   # Could be custom scalar if needed
+    "bool": "Boolean",
+    "float": "Float",
+    "double": "Float",
+}
+
+
+def _gql_enum_value_name(name: str) -> str:
+    # If already in ALL_CAPS (possibly with underscores) keep as is
+    if name.replace('_', '').isupper():
+        return name
+    return CamelToSnakeCase(name).upper()
+
+
+def _clean_comment_line(c: str) -> str:
+    c = c.strip()
+    if c.startswith('#'):
+        c = c[1:].strip()
+    # Remove leading // once or twice
+    if c.startswith('//'):
+        c = c[2:].strip()
+    # If parser already kept leading markers inside line, remove repeated
+    if c.startswith('//'):
+        c = c[2:].strip()
+    return c
+
+
+def _triple_quote_block(lines):
+    cleaned = [_clean_comment_line(l) for l in lines if _clean_comment_line(l)]
+    if not cleaned:
+        return None
+    return '"""\n' + '\n'.join(cleaned) + '\n"""'
+
+
+def _single_quote_line(lines):
+    cleaned = [_clean_comment_line(l) for l in lines if _clean_comment_line(l)]
+    if not cleaned:
+        return None
+    # Join multi-line into one sentence for single-line description
+    return '"' + ' '.join(cleaned) + '"'
+
+
+class EnumGqlGen:
+    @staticmethod
+    def generate(enum):
+        lines = []
+        if enum.comments:
+            desc = _triple_quote_block(enum.comments)
+            if desc:
+                lines.append(desc)
+        enum_name = f"{pascalCase(enum.package)}{enum.name}"
+        lines.append(f"enum {enum_name} {{")
+        for key, value in enum.data.items():
+            if value[1]:
+                desc = _single_quote_line(value[1])
+                if desc:
+                    lines.append(f"  {desc}")
+            lines.append(f"  {_gql_enum_value_name(key)}")
+        lines.append("}\n")
+        return '\n'.join(lines)
+
+
+class FieldGqlGen:
+    @staticmethod
+    def type_name(field):
+        t = field.fieldType
+        if t in gql_types:
+            return gql_types[t]
+        return f"{pascalCase(field.package)}{t}"
+
+    @staticmethod
+    def generate(field):
+        lines = []
+        if field.comments:
+            desc = _single_quote_line(field.comments)
+            if desc:
+                lines.append(f"  {desc}")
+        lines.append(f"  {field.name}: {FieldGqlGen.type_name(field)}")
+        return '\n'.join(lines)
+
+
+class MessageGqlGen:
+    @staticmethod
+    def generate(msg):
+        lines = []
+        if msg.comments:
+            desc = _triple_quote_block(msg.comments)
+            if desc:
+                lines.append(desc)
+        type_name = f"{pascalCase(msg.package)}{msg.name}"
+        lines.append(f"type {type_name} {{")
+        if not msg.fields:
+            lines.append("  _empty: Boolean")
+        else:
+            for key, f in msg.fields.items():
+                lines.append(FieldGqlGen.generate(f))
+        lines.append("}\n")
+        return '\n'.join(lines)
+
+
+class FileGqlGen:
+    @staticmethod
+    def generate(package):
+        # Multiline triple-quoted header block
+        yield f"# Automatically generated GraphQL schema\n# Generated by struct-frame {version} at {time.asctime()}\n\n"
+
+        first_block = True
+        # Enums
+        for _, enum in package.enums.items():
+            if not first_block:
+                yield '\n'
+            first_block = False
+            yield EnumGqlGen.generate(enum).rstrip() + '\n'
+
+        # Messages (object types)
+        for _, msg in package.sortedMessages().items():
+            if not first_block:
+                yield '\n'
+            first_block = False
+            yield MessageGqlGen.generate(msg).rstrip() + '\n'
+
+        # Root Query type
+        if package.messages:
+            if not first_block:
+                yield '\n'
+            yield 'type Query {\n'
+            for _, msg in package.sortedMessages().items():
+                type_name = f"{pascalCase(msg.package)}{msg.name}"
+                yield f"  {msg.name}: {type_name}\n"
+            yield '}\n'

struct_frame/py_gen.py

@@ -94,7 +94,26 @@ class MessagePyGen():
         result += '\n'.join([FieldPyGen.generate(f)
                             for key, f in msg.fields.items()])
 
-        return result + '\n'
+        result += '\n\n    def __str__(self):\n'
+        result += f'        out = "{msg.name} Msg, ID {msg.id}, Size {msg.size} \\n"\n'
+        for key, f in msg.fields.items():
+            result += f'        out += f"{key} = '
+            result += '{self.' + key + '}\\n"\n'
+        result += f'        out += "\\n"\n'
+        result += f'        return out'
+
+        result += '\n\n    def to_dict(self, include_name = True, include_id = True):\n'
+        result += f'        out = {{'
+        for key, f in msg.fields.items():
+            result += f' "{key}" : self.{key}{"" if f.isDefaultType | f.isEnum else ".to_dict(False, False)"  }, '
+        result += f'}}\n'
+        result += f'        if include_name:\n'
+        result += f'            out["name"] = "{msg.name}"\n'
+        result += f'        if include_id:\n'
+        result += f'            out["msg_id"] = "{msg.id}"\n'
+        result += f'        return out\n'
+
+        return result
 
     @staticmethod
     def get_initializer(msg, null_init):

struct_frame-0.0.27.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: struct-frame
+Version: 0.0.27
+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
+Author-email: Rijesh Augustine <rijesh@mylonics.com>
+License-Expression: MIT
+License-File: LICENSE
+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
+
+A framework for serializing data with headers
+
+## Quick Start
+
+### Python Usage
+```bash
+# Install dependencies
+pip install -e .
+
+# Generate code from proto file
+python src/main.py examples/myl_vehicle.proto --build_c --build_ts --build_py
+
+# Generated files will be in the generated/ directory
+```
+
+### TypeScript Example
+```bash
+# Install TypeScript dependencies
+npm i -D typescript typed-struct @types/node
+
+# Generate TypeScript code first
+python src/main.py examples/myl_vehicle.proto --build_ts
+
+# Compile and run the example
+npx tsc examples/index.ts --outDir generated/
+node generated/examples/index.js
+```
+
+### C Example
+```bash
+# Generate C code first  
+python src/main.py examples/myl_vehicle.proto --build_c
+
+# Compile the C example
+gcc examples/main.c -I generated/c -o main
+./main
+```
+
+## Project Structure
+
+- `src/` - Source code for the struct-frame library
+- `examples/` - Example usage and demo files
+- `generated/` - Generated output files (ignored by git)

struct_frame-0.0.27.dist-info/RECORD

@@ -0,0 +1,12 @@
+struct_frame/__init__.py,sha256=m9hfIbcgCYvt-fIeYrJRQyk6I7rq35jSdZIhrMmZntg,374
+struct_frame/__main__.py,sha256=tIybnBeFHvwiwVhodVOSnxhne5AX_80mtXBx4rneSB4,143
+struct_frame/base.py,sha256=1Z_0vMkwz0X8r2hIVLv5yuhwwD929LwNMzVKBqFxxac,2012
+struct_frame/c_gen.py,sha256=RFzEx0EuMoxBwdRi3O1NZGJ4iw3c3h7g8rRU3zD2ubU,5997
+struct_frame/generate.py,sha256=rfz7d0w37UWs0qlylOhYgD3k0GVmBoaZAGWQp_HUmHc,13131
+struct_frame/gql_gen.py,sha256=6-zaocD3qgPQyovjAihxl3DJZ9OHXM225VvO5KQmtkI,4488
+struct_frame/py_gen.py,sha256=7kvMsWPxAyLzTQg_BRj3g-yICH-6ilIGxMABEQdLayQ,4980
+struct_frame/ts_gen.py,sha256=qdJgAMxL2lV_WmGZErjHpgukYHNNpKpECarXdfmngEI,6266
+struct_frame-0.0.27.dist-info/METADATA,sha256=LwhsBrTZ0SQOMrMbHgWguP3d796SfASF8QwTe_y9cjU,1578
+struct_frame-0.0.27.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+struct_frame-0.0.27.dist-info/licenses/LICENSE,sha256=UjbLtGfcHCIqJg9UzEVGoNW8fyX4Ah9ZbsuAmJ_vhmk,1094
+struct_frame-0.0.27.dist-info/RECORD,,

struct_frame/boilerplate/c/struct_frame.h

@@ -1,103 +0,0 @@
-#pragma once
-#include "stdbool.h"
-#include "stdint.h"
-#include "string.h"
-#include "struct_frame_types.h"
-
-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++) {
-    checksum.byte1 += buffer[i];
-    checksum.byte2 += checksum.byte1;
-  }
-  return checksum;
-}
-
-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) {
-    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);
-    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) {
-    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) {
-    buffer->data[buffer->size++] = size;
-  }
-
-  void *out = &buffer->data[buffer->size];
-  buffer->size += size;
-
-  return out;
-}
-
-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 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(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

@@ -1,41 +0,0 @@
-#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 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); }
-
- 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;
-
-  // 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;
-  buffer_parser_result_t parser_result_;
-};

struct_frame/boilerplate/c/struct_frame_gen.h

@@ -1 +0,0 @@
-#pragma once

struct_frame/boilerplate/c/struct_frame_parser.h

@@ -1,101 +0,0 @@
-#pragma once
-#include "stdint.h"
-#include "struct_frame_gen.h"
-#include "struct_frame_types.h"
-
-// https://github.com/serge-sans-paille/frozen
-
-static inline bool parse_default_format_validate(uint8_t *data, msg_id_len_t *msg_id_len) {
-  (void)data;
-  (void)msg_id_len;
-  return true;
-}
-
-static inline bool parse_default_format_char_for_len_id(msg_id_len_t *msg_id_len, const uint8_t c) {
-  msg_id_len->msg_id = c;
-  msg_id_len->len = get_message_length(c);
-  return true;
-}
-
-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) {
-  if (config.start_byte == c) {
-    return &default_parser_functions;
-  }
-  return NULL;
-}
-
-static inline bool parse_char(struct_buffer *pb, uint8_t c) {
-  parser_functions_t *parse_func_ptr = NULL;
-  switch (pb->state) {
-    case LOOKING_FOR_START_BYTE:
-      parse_func_ptr = parse_char_for_start_byte(pb->config, c);
-      if (parse_func_ptr) {
-        pb->config.parser_funcs = parse_func_ptr;
-        pb->state = GETTING_LENGTH_MSG_AND_ID;
-      }
-      break;
-
-    case GETTING_LENGTH_MSG_AND_ID:
-      if (pb->config.parser_funcs->get_msg_id_len(&pb->msg_id_len, c)) {
-        pb->state = GETTING_PAYLOAD;
-        pb->size = 0;
-      }
-      break;
-
-    case GETTING_PAYLOAD:
-      pb->data[pb->size++] = c;
-      if (pb->size >= pb->msg_id_len.len) {
-        pb->state = LOOKING_FOR_START_BYTE;
-        return pb->config.parser_funcs->validate_packet(pb->data, &pb->msg_id_len);
-      }
-
-      break;
-
-    default:
-      break;
-  }
-
-  return false;
-}
-
-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:
-        parse_func_ptr = parse_char_for_start_byte(parser_result->config, buffer[i]);
-        if (parse_func_ptr) {
-          state = GETTING_LENGTH_MSG_AND_ID;
-        }
-        break;
-
-      case GETTING_LENGTH_MSG_AND_ID:
-        if (parse_func_ptr->get_msg_id_len(&parser_result->msg_id_len, buffer[i])) {
-          state = GETTING_PAYLOAD;
-        }
-        break;
-
-      case GETTING_PAYLOAD:
-        parser_result->msg_loc = buffer + i;
-        parser_result->r_loc = i + parser_result->msg_id_len.len;
-        if (parse_func_ptr->validate_packet(parser_result->msg_loc, &parser_result->msg_id_len)) {
-          parser_result->valid = true;
-          return true;
-        } else {
-          parser_result->valid = false;
-          return true;
-        }
-        break;
-
-      default:
-        break;
-    }
-  }
-  parser_result->finished = true;
-  parser_result->r_loc = 0;
-  return false;
-}

struct_frame/boilerplate/c/struct_frame_types.h

@@ -1,67 +0,0 @@
-#pragma once
-
-#include "stdbool.h"
-#include "stdint.h"
-
-typedef struct _msg_id_len_t {
-  bool valid;
-  uint8_t len;
-  uint8_t msg_id;
-} msg_id_len_t;
-
-typedef struct _parser_functions_t {
-  bool (*get_msg_id_len)(msg_id_len_t *, uint8_t);
-  bool (*validate_packet)(uint8_t *, msg_id_len_t *);
-} parser_functions_t;
-
-typedef struct _struct_frame_config {
-  uint8_t has_crc;
-  uint8_t has_len;
-  uint8_t start_byte;
-  parser_functions_t *parser_funcs;
-} struct_frame_config;
-
-enum ParserState { LOOKING_FOR_START_BYTE = 0, GETTING_LENGTH_MSG_AND_ID = 1, GETTING_PAYLOAD = 2 };
-
-typedef struct _struct_frame_buffer {
-  // Used for framing and parsing
-  struct_frame_config config;
-  uint8_t *data;
-  size_t max_size;
-  size_t size;
-  bool in_progress;
-
-  // Used for framing
-  size_t crc_start_loc;
-
-  // Used for parsing
-  enum ParserState state;
-  size_t payload_len;
-  msg_id_len_t msg_id_len;
-
-} struct_buffer;
-
-typedef struct _buffer_parser_result_t {
-  struct_frame_config config;
-  bool valid;
-  uint8_t *msg_loc;
-  size_t r_loc;
-  bool finished;
-  msg_id_len_t msg_id_len;
-} buffer_parser_result_t;
-
-// https://github.com/serge-sans-paille/frozen
-// https://www.npmjs.com/package/typed-struct
-
-#define default_parser {0, 0, 0x90}
-
-#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}};
-
-typedef struct checksum_t {
-  uint8_t byte1;
-  uint8_t byte2;
-} checksum_t;

struct_frame/boilerplate/py/struct_frame_parser.py

@@ -1,118 +0,0 @@
-
-from enum import Enum
-
-
-def fletcher_checksum_calculation(buffer, start=0, end=None):
-    if end == None:
-        end = len(buffer)
-
-    byte1 = 0
-    byte2 = 0
-
-    for x in range(start, end):
-        byte1 += buffer[x]
-        byte2 += byte1
-
-    return [byte1, byte2]
-
-
-class BasicPacket:
-    start_byte = 0x90
-    header_length = 0
-    footer_length = 0
-
-    desired_packet_length = 0
-    packet = []
-
-    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=False):
-        if clear:
-            self.packet.clear()
-        self.packet.append(byte)
-        return len(self.packet) == self.header_length
-
-    def add_packet_byte(self, byte):
-        self.packet.append(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_msg(self, msg):
-        return self.encode(msg.pack(), msg.msg_id)
-
-    def encode(self, data, msg_id):
-        output = []
-        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.append(checksum[0])
-        output.append(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 = []
-    packetFormat = None
-    msg_definitions = None
-    msg_id_loc = None
-    msg_type = None
-
-    def __init__(self, packetFormats, msg_definitions):
-        self.packetFormats = packetFormats
-        self.msg_definitions = msg_definitions
-
-    def parse_char(self, c):
-        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:
-                    self.state = ParserState.GETTING_HEADER
-
-        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.packetFormat.get_full_packet_length(
-                        self.msg_type.msg_size)
-                    self.state = ParserState.GETTING_PACKET
-                else:
-                    self.state = ParserState.LOOKING_FOR_START_BYTE
-
-        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

struct_frame/boilerplate/ts/struct_frame.ts

@@ -1,65 +0,0 @@
-import { Struct } from 'typed-struct';
-import * as sf_types from './struct_frame_types';
-
-function fletcher_checksum_calculation(buffer: Uint8Array, data_length: number): sf_types.checksum_t {
-    const checksum: sf_types.checksum_t = { byte1: 0, byte2: 0 };
-
-    for (let i = 0; i < data_length; i++) {
-        checksum.byte1 += buffer[i];
-        checksum.byte2 += checksum.byte1;
-    }
-    return checksum;
-}
-
-export function msg_encode(buffer: sf_types.struct_frame_buffer, msg: any, msgid: number) {
-    buffer.data[buffer.size++] = buffer.config.start_byte;
-    buffer.crc_start_loc = buffer.size;
-    buffer.data[buffer.size++] = msgid;
-
-    if (buffer.config.has_len) {
-        buffer.data[buffer.size++] = msg.getSize();
-    }
-    const rawData = Struct.raw(msg);
-    for (let i = 0; i < rawData.length; i++) {
-        buffer.data[buffer.size++] = rawData[i]
-    }
-
-    if (buffer.config.has_crc) {
-        const crc = fletcher_checksum_calculation(buffer.data.slice(buffer.crc_start_loc), buffer.crc_start_loc + rawData.length);
-        buffer.data[buffer.size++] = crc.byte1;
-        buffer.data[buffer.size++] = crc.byte2;
-    }
-}
-
-export function msg_reserve(buffer: sf_types.struct_frame_buffer, msg_id: number, msg_size: number) {
-    throw new Error('Function Unimplemented');
-
-    if (buffer.in_progress) {
-        return;
-    }
-    buffer.in_progress = true;
-    buffer.data[buffer.size++] = buffer.config.start_byte;
-
-    buffer.data[buffer.size++] = msg_id;
-    if (buffer.config.has_len) {
-        buffer.data[buffer.size++] = msg_size;
-    }
-
-    const ret = Buffer.from(buffer.data, buffer.size, msg_size);
-    buffer.size += msg_size;
-    return ret;
-}
-
-
-
-export function msg_finish(buffer: sf_types.struct_frame_buffer) {
-    throw new Error('Function Unimplemented');
-
-    if (buffer.config.has_crc) {
-        const crc = fletcher_checksum_calculation(buffer.data.slice(buffer.crc_start_loc), buffer.crc_start_loc - buffer.size);
-        buffer.data[buffer.size++] = crc.byte1;
-        buffer.data[buffer.size++] = crc.byte2;
-        buffer.size += 2
-    }
-    buffer.in_progress = false;
-}                                                                      

struct_frame/boilerplate/ts/struct_frame_gen.ts

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

struct_frame/boilerplate/ts/struct_frame_parser.ts

@@ -1,98 +0,0 @@
-import { get_message_length } from './struct_frame_gen';
-import * as sf_types from './struct_frame_types';
-
-function parse_default_format_validate(buffer: Uint8Array, msg_id_len: sf_types.msg_id_len_t): boolean {
-  return true;
-}
-
-function parse_default_format_char_for_len_id(c: number, msg_id_len: sf_types.msg_id_len_t): boolean {
-  msg_id_len.msg_id = c;
-  msg_id_len.len = get_message_length(c);
-  return true;
-}
-
-const default_parser_functions: sf_types.parser_functions_t = { get_msg_id_len: parse_default_format_char_for_len_id, validate_packet: parse_default_format_validate };
-
-function parse_char_for_start_byte(config: sf_types.struct_frame_config, c: number): sf_types.parser_functions_t | undefined {
-  if (config.start_byte == c) {
-    return default_parser_functions;
-  }
-  return;
-}
-
-export function parse_char(pb: sf_types.struct_frame_buffer, c: number): boolean {
-  let parse_func_ptr: sf_types.parser_functions_t | undefined = undefined;
-  switch (pb.state) {
-    case sf_types.ParserState.LOOKING_FOR_START_BYTE:
-      parse_func_ptr = parse_char_for_start_byte(pb.config, c);
-      if (parse_func_ptr) {
-        pb.config.parser_funcs = parse_func_ptr;
-        pb.state = sf_types.ParserState.GETTING_LENGTH_MSG_AND_ID;
-      }
-      break;
-
-    case sf_types.ParserState.GETTING_LENGTH_MSG_AND_ID:
-      if (pb.config.parser_funcs && pb.config.parser_funcs.get_msg_id_len(c, pb.msg_id_len)) {
-        pb.state = sf_types.ParserState.GETTING_PAYLOAD;
-        pb.size = 0;
-      }
-      break;
-
-    case sf_types.ParserState.GETTING_PAYLOAD:
-      pb.data[pb.size] = c;
-      pb.size++;
-      if (pb.size >= pb.msg_id_len.len) {
-        pb.msg_data = Buffer.from(pb.data, 0, pb.size)
-        pb.state = sf_types.ParserState.LOOKING_FOR_START_BYTE;
-        if (pb.config.parser_funcs) {
-          return pb.config.parser_funcs.validate_packet(pb.data, pb.msg_id_len);
-        }
-        return false;
-      }
-      break;
-
-    default:
-      break;
-  }
-
-  return false;
-}
-
-export function parse_buffer(buffer: Uint8Array, size: number, parser_result: sf_types.buffer_parser_result_t): boolean {
-  let state: sf_types.ParserState = sf_types.ParserState.LOOKING_FOR_START_BYTE;
-  let parse_func_ptr: sf_types.parser_functions_t | undefined;
-  for (let i = parser_result.r_loc; i < size; i++) {
-    switch (state) {
-      case sf_types.ParserState.LOOKING_FOR_START_BYTE:
-        parse_func_ptr = parse_char_for_start_byte(parser_result.config, buffer[i]);
-        if (parse_func_ptr) {
-          state = sf_types.ParserState.GETTING_LENGTH_MSG_AND_ID;
-        }
-        break;
-
-      case sf_types.ParserState.GETTING_LENGTH_MSG_AND_ID:
-        if (parse_func_ptr && parse_func_ptr.get_msg_id_len(buffer[i], parser_result.msg_id_len)) {
-          state = sf_types.ParserState.GETTING_PAYLOAD;
-        }
-        break;
-
-      case sf_types.ParserState.GETTING_PAYLOAD:
-        parser_result.msg_data = Buffer.from(buffer, i, (i + parser_result.msg_id_len.len));
-        parser_result.r_loc = i + parser_result.msg_id_len.len;
-        parser_result.found = true;
-        if (parse_func_ptr && parse_func_ptr.validate_packet(parser_result.msg_data, parser_result.msg_id_len)) {
-          parser_result.valid = true;
-          return true;
-        }
-        else {
-          parser_result.valid = false;
-          return true;
-        }
-        break;
-
-      default:
-        break;
-    }
-  }
-  return false;
-}

struct_frame/boilerplate/ts/struct_frame_types.ts

@@ -1,80 +0,0 @@
-
-export class msg_id_len_t {
-  valid = false;
-  len = 0;
-  msg_id = 0;
-}
-
-export type GetMsgIdLenType = (c: number, msg_id_len: msg_id_len_t) => boolean;
-export type ValidatePacketType = (buffer: Uint8Array, msg_id_len: msg_id_len_t) => boolean;
-
-export interface parser_functions_t {
-  get_msg_id_len: GetMsgIdLenType;
-  validate_packet: ValidatePacketType;
-}
-
-export interface struct_frame_config {
-  has_crc: number;
-  has_len: number;
-  start_byte: number;
-  parser_funcs?: parser_functions_t;
-}
-
-export enum ParserState {
-  LOOKING_FOR_START_BYTE = 0,
-  GETTING_LENGTH_MSG_AND_ID = 1,
-  GETTING_PAYLOAD = 2
-};
-
-export const basic_frame_config: struct_frame_config = { has_crc: 0, has_len: 0, start_byte: 0x90 };
-
-export class struct_frame_buffer {
-  // Used for framing and parsing
-  config: struct_frame_config = basic_frame_config;
-  data: Uint8Array;
-  size = 0;
-  in_progress = false;
-
-  // Used for framing
-  crc_start_loc = 0;
-
-  // Used for parsing
-  state: ParserState = ParserState.LOOKING_FOR_START_BYTE;
-  payload_len = 0;
-  msg_id_len: msg_id_len_t = new msg_id_len_t();
-  msg_data: Buffer = Buffer.allocUnsafe(0);
-
-  constructor(public max_size: number, buffer?: Uint8Array) {
-    if (buffer) {
-      this.data = buffer;
-    } else {
-      this.data = new Uint8Array(max_size);
-    }
-  }
-}
-
-export class buffer_parser_result_t {
-  config: struct_frame_config = basic_frame_config;
-  found = false;
-  valid = false;
-  msg_data: Buffer = Buffer.allocUnsafe(0);
-  r_loc = 0;
-  finished = false;
-  msg_id_len: msg_id_len_t = new msg_id_len_t();
-}
-
-// https://github.com/serge-sans-paille/frozen
-// https://www.npmjs.com/package/typed-struct
-
-//#define default_parser { 0, 0, 0x90 }
-//
-//#define zero_initialized_parser_result { default_parser, false, 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, 0, false, 0, 0, 0, 0, NULL }
-
-export interface checksum_t {
-  byte1: number;
-  byte2: number;
-}

struct_frame-0.0.25.dist-info/METADATA

@@ -1,29 +0,0 @@
-Metadata-Version: 2.4
-Name: struct-frame
-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
-Author-email: Rijesh Augustine <rijesh@mylonics.com>
-License-Expression: MIT
-License-File: LICENSE
-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
-
-
-
-TS install
-
-npm i -D typescript typed-struct @types/node  
-npx tsc --init 
-npx tsc index.ts
-node index.js
-
-
-npx tsc --project tsconfig.json; node index.js
-
-

struct_frame-0.0.25.dist-info/RECORD

@@ -1,22 +0,0 @@
-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=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/__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.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,,