struct-frame 0.0.29__py3-none-any.whl

struct_frame/gql_gen.py

@@ -0,0 +1,207 @@
+#!/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",
+    "string": "String",
+}
+
+
+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
+        base_type = gql_types.get(t, f"{pascalCase(field.package)}{t}")
+
+        # Handle arrays
+        if getattr(field, 'is_array', False):
+            # Arrays in GraphQL are represented as [Type!]! for non-null arrays of non-null elements
+            # or [Type] for nullable arrays, etc. We'll use [Type!]! as the standard
+            return f"[{base_type}!]!"
+
+        return base_type
+
+    @staticmethod
+    def generate(field, name_override=None):
+        lines = []
+
+        # Generate clean comments with size information, preferring our generated descriptions over proto comments
+        if getattr(field, 'is_array', False):
+            # Array field - use our size descriptions
+            if getattr(field, 'size_option', None) is not None:
+                # Fixed array
+                if field.fieldType == "string":
+                    comment_lines = [
+                        f"Fixed string array: {field.size_option} strings, each {getattr(field, 'element_size', 'N/A')} chars"]
+                else:
+                    comment_lines = [
+                        f"Fixed array: always {field.size_option} elements"]
+            else:
+                # Variable array
+                if field.fieldType == "string":
+                    comment_lines = [
+                        f"Variable string array: up to {getattr(field, 'max_size', 'N/A')} strings, each max {getattr(field, 'element_size', 'N/A')} chars"]
+                else:
+                    comment_lines = [
+                        f"Variable array: up to {getattr(field, 'max_size', 'N/A')} elements"]
+        elif field.fieldType == "string":
+            # Non-array string field
+            if getattr(field, 'size_option', None) is not None:
+                comment_lines = [
+                    f"Fixed string: exactly {field.size_option} characters"]
+            elif getattr(field, 'max_size', None) is not None:
+                comment_lines = [
+                    f"Variable string: up to {field.max_size} characters"]
+            else:
+                comment_lines = field.comments[:] if field.comments else []
+        else:
+            # Regular field - use original comments
+            comment_lines = field.comments[:] if field.comments else []
+
+        if comment_lines:
+            desc = _single_quote_line(comment_lines)
+            if desc:
+                lines.append(f"  {desc}")
+
+        fname = name_override if name_override else field.name
+        lines.append(f"  {fname}: {FieldGqlGen.type_name(field)}")
+        return '\n'.join(lines)
+
+    @staticmethod
+    def generate_flattened_children(field, package, parent_msg):
+        # Expand a message-typed field into its child fields.
+        # If a child field name collides, raise an error and fail generation.
+        t = field.fieldType
+        child_msg = package.messages.get(t)
+        if not child_msg:
+            # Fallback to normal generation if unknown
+            return [FieldGqlGen.generate(field)]
+
+        out_lines = []
+        for ck, cf in child_msg.fields.items():
+            out_lines.append(FieldGqlGen.generate(cf, name_override=ck))
+        return out_lines
+
+
+class MessageGqlGen:
+    @staticmethod
+    def generate(package, 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():
+                if getattr(f, 'flatten', False) and f.fieldType not in gql_types:
+                    lines.extend(
+                        FieldGqlGen.generate_flattened_children(f, package, msg))
+                else:
+                    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(package, 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

@@ -0,0 +1,213 @@
+#!/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',
+            "string": "str",  # Add string type support
+            }
+
+
+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
+
+        # Handle basic type resolution
+        if type_name in py_types:
+            base_type = py_types[type_name]
+        else:
+            if field.isEnum:
+                # For enums, use the full enum class name for better type safety
+                base_type = '%s%s' % (pascalCase(field.package), type_name)
+            else:
+                base_type = '%s%s' % (pascalCase(field.package), type_name)
+
+        # Handle arrays
+        if field.is_array:
+            if field.fieldType == "string":
+                # String arrays require both array size and individual element size
+                if field.size_option is not None:
+                    type_annotation = f"list[{base_type}]  # Fixed string array size={field.size_option}, each max {field.element_size} chars"
+                elif field.max_size is not None:
+                    type_annotation = f"list[{base_type}]  # Bounded string array max_size={field.max_size}, each max {field.element_size} chars"
+                else:
+                    type_annotation = f"list[{base_type}]  # String array"
+            else:
+                # Non-string arrays
+                if field.size_option is not None:
+                    type_annotation = f"list[{base_type}]  # Fixed array size={field.size_option}"
+                elif field.max_size is not None:
+                    type_annotation = f"list[{base_type}]  # Bounded array max_size={field.max_size}"
+                else:
+                    type_annotation = f"list[{base_type}]  # Array"
+        # Handle strings with size info
+        elif field.fieldType == "string":
+            if field.size_option is not None:
+                # Fixed string - exact length
+                type_annotation = f"str  # Fixed string size={field.size_option}"
+            elif field.max_size is not None:
+                # Variable string - up to max length
+                type_annotation = f"str  # Variable string max_size={field.max_size}"
+            else:
+                # Fallback (shouldn't happen with validation)
+                type_annotation = "str  # String"
+        else:
+            # Regular field
+            type_annotation = base_type
+
+        result += '    %s: %s' % (var_name, type_annotation)
+
+        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, byte_order=ByteOrder.LE, byte_order_mode=ByteOrderMode.OVERRIDE):\n' % structName
+        result += '    msg_size = %s\n' % msg.size
+        if msg.id != None:
+            result += '    msg_id = %s\n' % msg.id
+
+        result += '\n'.join([FieldPyGen.generate(f)
+                            for key, f in msg.fields.items()])
+
+        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 += '        out = {}\n'
+        # Handle all field types including arrays
+        for key, f in msg.fields.items():
+            if f.is_array:
+                if f.isDefaultType or f.isEnum or f.fieldType == "string":
+                    # Array of primitives, enums, or strings
+                    result += f'        out["{key}"] = self.{key}\n'
+                else:
+                    # Array of nested messages - convert each element
+                    result += f'        out["{key}"] = [item.to_dict(False, False) for item in self.{key}]\n'
+            elif f.isDefaultType or f.isEnum or f.fieldType == "string":
+                # Regular primitive, enum, or string field
+                result += f'        out["{key}"] = self.{key}\n'
+            else:
+                # Nested message field
+                if getattr(f, 'flatten', False):
+                    # Merge nested dict into parent
+                    result += f'        out.update(self.{key}.to_dict(False, False))\n'
+                else:
+                    result += f'        out["{key}"] = self.{key}.to_dict(False, False)\n'
+        result += '        if include_name:\n'
+        result += f'            out["name"] = "{msg.name}"\n'
+        result += '        if include_id:\n'
+        result += f'            out["msg_id"] = "{msg.id}"\n'
+        result += '        return out\n'
+
+        return result
+
+    @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 != None:
+                    structName = '%s%s' % (pascalCase(msg.package), msg.name)
+                    yield '    %s: %s,\n' % (msg.id, structName)
+
+            yield '}\n'

struct_frame/ts_gen.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+# kate: replace-tabs on; indent-width 4;
+
+from struct_frame import version, NamingStyleC
+import time
+
+StyleC = NamingStyleC()
+
+ts_types = {
+    "int8":     'Int8',
+    "uint8":    'UInt8',
+    "int16":    'Int16LE',
+    "uint16":   'UInt16LE',
+    "bool":     'Boolean8',
+    "double":   'Float64LE',
+    "float":    'Float32LE',
+    "int32":  'Int32LE',
+    "uint32": 'UInt32LE',
+    "uint64": 'BigInt64LE',
+    "int64":  'BigUInt64LE',
+    "string":   'String',
+}
+
+# TypeScript type mappings for array declarations
+ts_array_types = {
+    "int8":     'number',
+    "uint8":    'number',
+    "int16":    'number',
+    "uint16":   'number',
+    "bool":     'boolean',
+    "double":   'number',
+    "float":    'number',
+    "int32":    'number',
+    "uint32":   'number',
+    "uint64":   'bigint',
+    "int64":    'bigint',
+    "string":   'string',
+}
+
+
+class EnumTsGen():
+    @staticmethod
+    def generate(field, packageName):
+        leading_comment = field.comments
+        result = ''
+        if leading_comment:
+            for c in leading_comment:
+                result = '%s\n' % c
+
+        result += 'export enum %s%s' % (packageName,
+                                        StyleC.enum_name(field.name))
+
+        result += ' {\n'
+
+        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)
+
+            comma = ","
+            if index == enum_length - 1:
+                # last enum member should not end with a comma
+                comma = ""
+
+            enum_value = "    %s = %d%s" % (
+                StyleC.enum_entry(d), field.data[d][0], comma)
+
+            enum_values.append(enum_value)
+
+        result += '\n'.join(enum_values)
+        result += '\n}'
+
+        return result
+
+
+class FieldTsGen():
+    @staticmethod
+    def generate(field, packageName):
+        result = ''
+        isEnum = False
+        var_name = StyleC.var_name(field.name)
+        type_name = field.fieldType
+
+        # Handle arrays
+        if field.is_array:
+            if field.fieldType == "string":
+                if field.size_option is not None:  # Fixed size array [size=X]
+                    # Fixed string array: string[size] -> Array<string> with fixed length
+                    result += f'    // Fixed string array: {field.size_option} strings, each exactly {field.element_size} chars\n'
+                    result += f'    .Array(\'{var_name}\', \'String\', {field.size_option})'
+                else:  # Variable size array [max_size=X]
+                    # Variable string array: string[max_size=X, element_size=Y] -> Array<string> with count
+                    result += f'    // Variable string array: up to {field.max_size} strings, each max {field.element_size} chars\n'
+                    result += f'    .UInt8(\'{var_name}_count\')\n'
+                    result += f'    .Array(\'{var_name}_data\', \'String\', {field.max_size})'
+            else:
+                # Regular type arrays
+                if type_name in ts_types:
+                    base_type = ts_types[type_name]
+                else:
+                    base_type = f'{packageName.lower()}_{StyleC.struct_name(type_name).lower()}'
+
+                if field.size_option is not None:  # Fixed size array [size=X]
+                    # Fixed array: type[size] -> Array<type> with fixed length
+                    # For fixed arrays, size_option contains the exact size
+                    array_size = field.size_option
+                    result += f'    // Fixed array: always {array_size} elements\n'
+                    result += f'    .Array(\'{var_name}\', \'{base_type}\', {array_size})'
+                else:  # Variable size array [max_size=X]
+                    # Variable array: type[max_size=X] -> count + Array<type>
+                    max_count = field.max_size  # For variable arrays, max_size is the maximum count
+                    result += f'    // Variable array: up to {max_count} elements\n'
+                    result += f'    .UInt8(\'{var_name}_count\')\n'
+                    result += f'    .Array(\'{var_name}_data\', \'{base_type}\', {max_count})'
+        else:
+            # Non-array fields (existing logic)
+            if field.fieldType == "string":
+                if hasattr(field, 'size_option') and field.size_option is not None:
+                    # Fixed string: string[size] -> fixed length string
+                    result += f'    // Fixed string: exactly {field.size_option} chars\n'
+                    result += f'    .String(\'{var_name}\', {field.size_option})'
+                elif hasattr(field, 'max_size') and field.max_size is not None:
+                    # Variable string: string[max_size=X] -> length + data
+                    result += f'    // Variable string: up to {field.max_size} chars\n'
+                    result += f'    .UInt8(\'{var_name}_length\')\n'
+                    result += f'    .String(\'{var_name}_data\', {field.max_size})'
+                else:
+                    # Default string handling (should not occur with new parser)
+                    result += f'    .String(\'{var_name}\')'
+            else:
+                # Regular types
+                if type_name in ts_types:
+                    type_name = ts_types[type_name]
+                else:
+                    type_name = f'{packageName}_{StyleC.struct_name(type_name)}'
+
+                if isEnum:
+                    result += f'    .UInt8(\'{var_name}\', typed<{type_name}>())'
+                else:
+                    result += f'    .{type_name}(\'{var_name}\')'
+
+        leading_comment = field.comments
+        if leading_comment:
+            for c in leading_comment:
+                result = c + "\n" + result
+
+        return result
+
+
+# ---------------------------------------------------------------------------
+#                   Generation of messages (structures)
+# ---------------------------------------------------------------------------
+
+
+class MessageTsGen():
+    @staticmethod
+    def generate(msg, packageName):
+        leading_comment = msg.comments
+
+        result = ''
+        if leading_comment:
+            for c in msg.comments:
+                result = '%s\n' % c
+
+        package_msg_name = '%s_%s' % (packageName, msg.name)
+
+        result += 'export const %s = new typed_struct.Struct(\'%s\') ' % (
+            package_msg_name, package_msg_name)
+
+        result += '\n'
+
+        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 += '    .UInt8(\'dummy_field\');'
+        else:
+            size = msg.size
+
+        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' % (package_msg_name, size)
+
+        if 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' % (
+                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' % (
+                package_msg_name)
+            result += '    const msg_buffer = msg_reserve(buffer, %s_msgid, %s_max_size);\n' % (
+                package_msg_name, package_msg_name)
+            result += '    if (msg_buffer){\n'
+            result += '        return new %s(msg_buffer)\n    }\n    return;\n}\n' % (
+                package_msg_name)
+
+            result += 'export function %s_finish(buffer: struct_frame_buffer) {\n' % (
+                package_msg_name)
+            result += '    msg_finish(buffer);\n}\n'
+        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 FileTsGen():
+    @staticmethod
+    def generate(package):
+        yield '/* Automatically generated struct frame header */\n'
+        yield '/* Generated by %s at %s. */\n\n' % (version, time.asctime())
+
+        yield 'const typed_struct = require(\'typed-struct\')\n'
+        yield 'const ExtractType = typeof typed_struct.ExtractType;\n'
+        yield 'const type = typeof typed_struct.ExtractType;\n\n'
+
+        yield "import { struct_frame_buffer } from './struct_frame_types';\n"
+
+        yield "import { msg_encode, msg_reserve, msg_finish } from './struct_frame';\n\n"
+
+        # include additional header files here if available in the future
+
+        if package.enums:
+            yield '/* Enum definitions */\n'
+            for key, enum in package.enums.items():
+                yield EnumTsGen.generate(enum, package.name) + '\n\n'
+
+        if package.messages:
+            yield '/* Struct definitions */\n'
+            for key, msg in package.sortedMessages().items():
+                yield MessageTsGen.generate(msg, package.name) + '\n'
+            yield '\n'
+
+        if package.messages:
+            # Only generate get_message_length if there are messages with IDs
+            messages_with_id = [
+                msg for key, msg in package.sortedMessages().items() if msg.id]
+            if messages_with_id:
+                yield 'export function get_message_length(msg_id : number){\n switch (msg_id)\n {\n'
+                for msg in messages_with_id:
+                    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'