struct-frame 0.0.25__py3-none-any.whl → 0.0.28__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

@@ -17,6 +17,7 @@ c_types = {"uint8": "uint8_t",
            "double": "double",
            "uint64": 'uint64_t',
            "int64":  'int64_t',
+           "string": "char",  # Add string type support
            }
 
 
@@ -60,6 +61,16 @@ class EnumCGen():
         result += ' %s;\n' % (enumName)
 
         result += 'typedef uint8_t %s_t;' % (enumName)
+        
+        # Add module-prefixed enum constants for compatibility
+        result += '\n\n/* Enum constants with module prefix */\n'
+        module_prefix = CamelToSnakeCase(field.package).upper()
+        for d in field.data:
+            # Use the already correct enum constant name
+            enum_constant = f"{CamelToSnakeCase(field.name).upper()}_{StyleC.enum_entry(d)}"
+            module_constant = f"{module_prefix}_{enum_constant}"
+            result += f'#define {module_constant:<35} {enum_constant}\n'
+        
         return result
 
 
@@ -67,18 +78,70 @@ class FieldCGen():
     @staticmethod
     def generate(field):
         result = ''
-
         var_name = field.name
         type_name = field.fieldType
+
+        # Handle basic type resolution
         if type_name in c_types:
-            type_name = c_types[type_name]
+            base_type = c_types[type_name]
         else:
-            type_name = '%s%s' % (pascalCase(field.package), type_name)
             if field.isEnum:
-                type_name = '%s_t' % type_name
-
-        result += '    %s %s%s;' % (type_name, var_name, "")
+                base_type = '%s%s_t' % (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 need both array size and individual string size
+                if field.size_option is not None:
+                    # Fixed string array: size_option strings, each element_size chars
+                    declaration = f"char {var_name}[{field.size_option}][{field.element_size}];"
+                    comment = f"  // Fixed string array: {field.size_option} strings, each max {field.element_size} chars"
+                elif field.max_size is not None:
+                    # Variable string array: count byte + max_size strings of element_size chars each
+                    declaration = f"struct {{ uint8_t count; char data[{field.max_size}][{field.element_size}]; }} {var_name};"
+                    comment = f"  // Variable string array: up to {field.max_size} strings, each max {field.element_size} chars"
+                else:
+                    declaration = f"char {var_name}[1][1];"  # Fallback
+                    comment = "  // String array (error in size specification)"
+            else:
+                # Non-string arrays
+                if field.size_option is not None:
+                    # Fixed array: always exact size
+                    declaration = f"{base_type} {var_name}[{field.size_option}];"
+                    comment = f"  // Fixed array: always {field.size_option} elements"
+                elif field.max_size is not None:
+                    # Variable array: count byte + max elements
+                    declaration = f"struct {{ uint8_t count; {base_type} data[{field.max_size}]; }} {var_name};"
+                    comment = f"  // Variable array: up to {field.max_size} elements"
+                else:
+                    declaration = f"{base_type} {var_name}[1];"  # Fallback
+                    comment = "  // Array (error in size specification)"
+
+            result += f"    {declaration}{comment}"
+
+        # Handle regular strings
+        elif field.fieldType == "string":
+            if field.size_option is not None:
+                # Fixed string: exactly size_option characters
+                declaration = f"char {var_name}[{field.size_option}];"
+                comment = f"  // Fixed string: exactly {field.size_option} chars"
+            elif field.max_size is not None:
+                # Variable string: length byte + max characters
+                declaration = f"struct {{ uint8_t length; char data[{field.max_size}]; }} {var_name};"
+                comment = f"  // Variable string: up to {field.max_size} chars"
+            else:
+                declaration = f"char {var_name}[1];"  # Fallback
+                comment = "  // String (error in size specification)"
+
+            result += f"    {declaration}{comment}"
+
+        # Handle regular fields
+        else:
+            result += f"    {base_type} {var_name};"
 
+        # Add leading comments
         leading_comment = field.comments
         if leading_comment:
             for c in leading_comment:
@@ -178,12 +241,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,8 +7,10 @@ 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
+from proto_schema_parser.ast import FieldCardinality
 
 import argparse
 
@@ -26,7 +28,8 @@ default_types = {
     "float": {"size": 4},
     "double": {"size": 8},
     "int64": {"size": 8},
-    "uint64": {"size": 8}
+    "uint64": {"size": 8},
+    "string": {"size": 4}  # Variable length, estimated size for length prefix
 }
 
 
@@ -79,14 +82,78 @@ class Field:
         self.comments = comments
         self.package = package
         self.isEnum = False
+        self.flatten = False
+        self.is_array = False
+        self.size_option = None   # Fixed size using [size=X]
+        self.max_size = None      # Variable size using [max_size=X]
+        # Element size for repeated string arrays [element_size=X]
+        self.element_size = None
 
     def parse(self, field):
         self.name = field.name
         self.fieldType = field.type
+
+        # Check if this is a repeated field (array)
+        if hasattr(field, 'cardinality') and field.cardinality == FieldCardinality.REPEATED:
+            self.is_array = True
+
         if self.fieldType in default_types:
             self.isDefaultType = True
             self.size = default_types[self.fieldType]["size"]
             self.validated = True
+
+        try:
+            if hasattr(field, 'options') and field.options:
+                # options is typically a list of ast.Option
+                for opt in field.options:
+                    oname = getattr(opt, 'name', None)
+                    ovalue = getattr(opt, 'value', None)
+                    if not oname:
+                        continue
+                    lname = str(oname).strip()
+                    # Support unqualified and a couple of qualified names
+                    if lname in ('flatten', '(sf.flatten)', '(struct_frame.flatten)'):
+                        sval = str(ovalue).strip().lower()
+                        if sval in ('true', '1', 'yes', 'on') or ovalue is True:
+                            self.flatten = True
+                    elif lname in ('size', '(sf.size)', '(struct_frame.size)'):
+                        # Fixed size for arrays or strings
+                        try:
+                            self.size_option = int(ovalue)
+                            if self.size_option <= 0 or self.size_option > 255:
+                                print(
+                                    f"Invalid size {self.size_option} for field {self.name}, must be 1-255")
+                                return False
+                        except (ValueError, TypeError):
+                            print(
+                                f"Invalid size value {ovalue} for field {self.name}, must be an integer")
+                            return False
+                    elif lname in ('max_size', '(sf.max_size)', '(struct_frame.max_size)'):
+                        # Variable size for arrays or strings
+                        try:
+                            self.max_size = int(ovalue)
+                            if self.max_size <= 0 or self.max_size > 255:
+                                print(
+                                    f"Invalid max_size {self.max_size} for field {self.name}, must be 1-255")
+                                return False
+                        except (ValueError, TypeError):
+                            print(
+                                f"Invalid max_size value {ovalue} for field {self.name}, must be an integer")
+                            return False
+                    elif lname in ('element_size', '(sf.element_size)', '(struct_frame.element_size)'):
+                        # Individual element size for repeated string arrays
+                        try:
+                            self.element_size = int(ovalue)
+                            if self.element_size <= 0 or self.element_size > 255:
+                                print(
+                                    f"Invalid element_size {self.element_size} for field {self.name}, must be 1-255")
+                                return False
+                        except (ValueError, TypeError):
+                            print(
+                                f"Invalid element_size value {ovalue} for field {self.name}, must be an integer")
+                            return False
+        except Exception:
+            pass
         return True
 
     def validate(self, currentPackage, packages):
@@ -99,8 +166,8 @@ class Field:
             if ret:
                 if ret.validate(currentPackage, packages):
                     self.isEnum = ret.isEnum
-                    self.validate = True
-                    self.size = ret.size
+                    self.validated = True
+                    base_size = ret.size
                 else:
                     print(
                         f"Failed to validate Field: {self.name} of Type: {self.fieldType} in Package: {currentPackage.name}")
@@ -109,6 +176,77 @@ class Field:
                 print(
                     f"Failed to find Field: {self.name} of Type: {self.fieldType} in Package: {currentPackage.name}")
                 return False
+        else:
+            base_size = self.size
+
+        # Calculate size for arrays and strings
+        if self.is_array:
+            if self.fieldType == "string":
+                # String arrays need both array size AND individual element size
+                if self.element_size is None:
+                    print(
+                        f"String array field {self.name} missing required element_size option")
+                    return False
+
+                if self.size_option is not None:
+                    # Fixed string array: size_option strings, each element_size bytes
+                    self.size = self.size_option * self.element_size
+                elif self.max_size is not None:
+                    # Variable string array: 1 byte count + max_size strings of element_size bytes each
+                    self.size = 1 + (self.max_size * self.element_size)
+                else:
+                    print(
+                        f"String array field {self.name} missing required size or max_size option")
+                    return False
+            else:
+                # Non-string arrays
+                if self.size_option is not None:
+                    # Fixed array: always full, no count byte needed
+                    self.size = base_size * self.size_option
+                elif self.max_size is not None:
+                    # Variable array: 1 byte for count + max space
+                    self.size = 1 + (base_size * self.max_size)
+                else:
+                    print(
+                        f"Array field {self.name} missing required size or max_size option")
+                    return False
+        elif self.fieldType == "string":
+            if self.size_option is not None:
+                # Fixed string: exactly size_option characters
+                self.size = self.size_option
+            elif self.max_size is not None:
+                # Variable string: 1 byte length + max characters
+                self.size = 1 + self.max_size
+            else:
+                print(
+                    f"String field {self.name} missing required size or max_size option")
+                return False
+        else:
+            self.size = base_size
+
+        # Debug output
+        array_info = ""
+        if self.is_array:
+            if self.fieldType == "string":
+                # String arrays show both array size and individual element size
+                if self.size_option is not None:
+                    array_info = f", fixed_string_array size={self.size_option}, element_size={self.element_size}"
+                elif self.max_size is not None:
+                    array_info = f", bounded_string_array max_size={self.max_size}, element_size={self.element_size}"
+            else:
+                # Regular arrays
+                if self.size_option is not None:
+                    array_info = f", fixed_array size={self.size_option}"
+                elif self.max_size is not None:
+                    array_info = f", bounded_array max_size={self.max_size}"
+        elif self.fieldType == "string":
+            # Regular strings
+            if self.size_option is not None:
+                array_info = f", fixed_string size={self.size_option}"
+            elif self.max_size is not None:
+                array_info = f", variable_string max_size={self.max_size}"
+        print(
+            f"  Field {self.name}: type={self.fieldType}, is_array={self.is_array}{array_info}, calculated_size={self.size}")
 
         return True
 
@@ -116,8 +254,21 @@ class Field:
         output = ""
         for c in self.comments:
             output = output + c + "\n"
+        array_info = ""
+        if self.is_array:
+            if self.size_option is not None:
+                array_info = f", Array[size={self.size_option}]"
+            elif self.max_size is not None:
+                array_info = f", Array[max_size={self.max_size}]"
+            else:
+                array_info = ", Array[no size specified]"
+        elif self.fieldType == "string":
+            if self.size_option is not None:
+                array_info = f", String[size={self.size_option}]"
+            elif self.max_size is not None:
+                array_info = f", String[max_size={self.max_size}]"
         output = output + \
-            f"Field: {self.name}, Type:{self.fieldType}, Size:{self.size}"
+            f"Field: {self.name}, Type:{self.fieldType}, Size:{self.size}{array_info}"
         return output
 
 
@@ -166,6 +317,44 @@ class Message:
                 return False
             self.size = self.size + value.size
 
+        # Flatten collision detection: if a field is marked as flatten and is a message,
+        # ensure none of the child field names collide with fields in this message.
+        parent_field_names = set(self.fields.keys())
+        for key, value in self.fields.items():
+            if getattr(value, 'flatten', False):
+                # Only meaningful for non-default, non-enum message types
+                if value.isDefaultType or value.isEnum:
+                    # Flatten has no effect on primitives/enums; skip
+                    continue
+                child = currentPackage.findFieldType(value.fieldType)
+                if not child or getattr(child, 'isEnum', False) or not hasattr(child, 'fields'):
+                    # Unknown or non-message type; skip
+                    continue
+                for ck in child.fields.keys():
+                    if ck in parent_field_names:
+                        print(
+                            f"Flatten collision in Message {self.name}: field '{key}.{ck}' collides with existing field '{ck}'.")
+                        return False
+
+        # Array validation
+        for key, value in self.fields.items():
+            if value.is_array:
+                # All arrays must have size or max_size specified
+                if value.size_option is None and value.max_size is None:
+                    print(
+                        f"Array field {key} in Message {self.name}: must specify size or max_size option")
+                    return False
+            elif value.fieldType == "string":
+                # Strings must have size or max_size specified
+                if value.size_option is None and value.max_size is None:
+                    print(
+                        f"String field {key} in Message {self.name}: must specify size or max_size option")
+                    return False
+            elif value.max_size is not None or value.size_option is not None or value.element_size is not None:
+                print(
+                    f"Field {key} in Message {self.name}: size/max_size/element_size options can only be used with repeated fields or strings")
+                return False
+
         self.validated = True
         return True
 
@@ -260,9 +449,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,15 +542,21 @@ 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
 
+    valid = False
     try:
-        validatePackages()
+        valid = validatePackages()
     except RecursionError as err:
         print(
             f'Recursion Error. Messages most likely have a cyclical dependancy. Check Message: {recErrCurrentMessage} and Field: {recErrCurrentField}')
+        return
+
+    if not valid:
+        print("Validation failed; aborting code generation.")
+        return
 
     files = {}
     if (args.build_c):
@@ -370,6 +568,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 +596,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,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'