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

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,,