structurize 3.6.0__tar.gz → 3.7.0__tar.gz

{structurize-3.6.0/structurize.egg-info → structurize-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.6.0
+Version: 3.7.0
 Summary: Tools to convert from and to JSON Structure from various other schema languages.
 Author-email: Clemens Vasters <clemensv@microsoft.com>
 Classifier: Programming Language :: Python :: 3

{structurize-3.6.0 → structurize-3.7.0}/avrotize/__init__.py

@@ -25,6 +25,28 @@ class LazyLoader:
 # Define the functions and their corresponding module paths
 _mappings = {
     "convert_proto_to_avro": (f"{mod}.prototoavro", "convert_proto_to_avro"),
+    "convert_jtd_to_avro": (f"{mod}.jtdtoavro", "convert_jtd_to_avro"),
+    "convert_avro_to_jtd": (f"{mod}.avrotojtd", "convert_avro_to_jtd"),
+    "convert_jtd_to_structure": (f"{mod}.jtdtostructure", "convert_jtd_to_structure"),
+    "convert_structure_to_jtd": (f"{mod}.structuretojtd", "convert_structure_to_jtd"),
+    "convert_surrealql_to_avro": (f"{mod}.surrealtoavro", "convert_surrealql_to_avro"),
+    "convert_avro_to_surrealql": (f"{mod}.avrotosurreal", "convert_avro_to_surrealql"),
+    "convert_flatbuffers_to_avro": (f"{mod}.flatbufferstoavro", "convert_flatbuffers_to_avro"),
+    "convert_avro_to_flatbuffers": (f"{mod}.avrotoflatbuffers", "convert_avro_to_flatbuffers"),
+    "convert_flatbuffers_to_json_structure": (f"{mod}.flatbufferstojstruct", "convert_flatbuffers_to_json_structure"),
+    "convert_json_structure_to_flatbuffers": (f"{mod}.jstructtoflatbuffers", "convert_json_structure_to_flatbuffers"),
+    "convert_thrift_to_avro": (f"{mod}.thrifttoavro", "convert_thrift_to_avro"),
+    "convert_avro_to_thrift": (f"{mod}.avrotothrift", "convert_avro_to_thrift"),
+    "convert_thrift_to_structure": (f"{mod}.thriftstructure", "convert_thrift_to_structure"),
+    "convert_structure_to_thrift": (f"{mod}.thriftstructure", "convert_structure_to_thrift"),
+    "convert_smithy_to_avro": (f"{mod}.smithytoavro", "convert_smithy_to_avro"),
+    "convert_avro_to_smithy": (f"{mod}.avrotosmithy", "convert_avro_to_smithy"),
+    "convert_smithy_to_json_structure": (f"{mod}.smithytojstruct", "convert_smithy_to_json_structure"),
+    "convert_json_structure_to_smithy": (f"{mod}.jstructtosmithy", "convert_json_structure_to_smithy"),
+    "convert_raml_to_avro": (f"{mod}.ramltoavro", "convert_raml_to_avro"),
+    "convert_avro_to_raml": (f"{mod}.avrotoraml", "convert_avro_to_raml"),
+    "convert_raml_to_json_structure": (f"{mod}.ramltojstruct", "convert_raml_to_json_structure"),
+    "convert_json_structure_to_raml": (f"{mod}.jstructtoraml", "convert_json_structure_to_raml"),
     "convert_jsons_to_avro": (f"{mod}.jsonstoavro", "convert_jsons_to_avro"),
     "convert_kafka_struct_to_avro_schema": (f"{mod}.kstructtoavro", "convert_kafka_struct_to_avro_schema"),
     "convert_kusto_to_avro": (f"{mod}.kustotoavro", "convert_kusto_to_avro"),
@@ -35,6 +57,14 @@ _mappings = {
     "convert_avro_to_kusto_db": (f"{mod}.avrotokusto", "convert_avro_to_kusto_db"),
     "convert_avro_to_parquet": (f"{mod}.avrotoparquet", "convert_avro_to_parquet"),
     "convert_avro_to_proto": (f"{mod}.avrotoproto", "convert_avro_to_proto"),
+    "convert_cue_to_avro": (f"{mod}.cuetoavro", "convert_cue_to_avro"),
+    "convert_avro_to_cue": (f"{mod}.avrotocue", "convert_avro_to_cue"),
+    "convert_cue_to_json_structure": (f"{mod}.cuetostructure", "convert_cue_to_json_structure"),
+    "convert_json_structure_to_cue": (f"{mod}.structuretocue", "convert_json_structure_to_cue"),
+    "convert_capnproto_to_avro": (f"{mod}.capnprototoavro", "convert_capnproto_to_avro"),
+    "convert_avro_to_capnproto": (f"{mod}.avrotocapnproto", "convert_avro_to_capnproto"),
+    "convert_capnproto_to_json_structure": (f"{mod}.capnprototoavro", "convert_capnproto_to_json_structure"),
+    "convert_json_structure_to_capnproto": (f"{mod}.avrotocapnproto", "convert_json_structure_to_capnproto"),
     "convert_avro_to_sql": (f"{mod}.avrotodb", "convert_avro_to_sql"),
     "convert_avro_to_xsd": (f"{mod}.avrotoxsd", "convert_avro_to_xsd"),
     "convert_avro_to_java": (f"{mod}.avrotojava", "convert_avro_to_java"),

{structurize-3.6.0 → structurize-3.7.0}/avrotize/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.6.0'
-__version_tuple__ = version_tuple = (3, 6, 0)
+__version__ = version = '3.7.0'
+__version_tuple__ = version_tuple = (3, 7, 0)
 
-__commit_id__ = commit_id = 'g1329b8c45'
+__commit_id__ = commit_id = 'gd5dcf3fee'

structurize-3.7.0/avrotize/avrotocapnproto.py

@@ -0,0 +1,183 @@
+"""Convert Avrotize/Avro schemas to Cap'n Proto .capnp schemas."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import tempfile
+from typing import Any
+
+INDENT = "  "
+FILE_ID = "0xd12f8a7e9b0c4a6f"
+
+
+def _safe_ident(name: str) -> str:
+    safe = re.sub(r"[^A-Za-z0-9_]", "_", name)
+    if not safe or safe[0].isdigit():
+        safe = f"_{safe}"
+    return safe
+
+
+def _type_name(schema: dict[str, Any]) -> str:
+    namespace = schema.get("namespace")
+    name = schema["name"]
+    return f"{namespace}.{name}" if namespace else name
+
+
+class AvroToCapnpConverter:
+    primitive_map = {
+        "null": "Void",
+        "boolean": "Bool",
+        "int": "Int32",
+        "long": "Int64",
+        "float": "Float32",
+        "double": "Float64",
+        "bytes": "Data",
+        "string": "Text",
+    }
+
+    def __init__(self, namespace: str | None = None) -> None:
+        self.namespace = namespace
+        self.named: dict[str, dict[str, Any]] = {}
+        self.emitted: set[str] = set()
+
+    def convert(self, avro_schema: Any) -> str:
+        schemas = avro_schema if isinstance(avro_schema, list) else [avro_schema]
+        for schema in schemas:
+            if isinstance(schema, dict) and schema.get("type") in {"record", "enum"}:
+                self.named[schema["name"]] = schema
+                self.named[_type_name(schema)] = schema
+        lines = [f"@{FILE_ID};", ""]
+        if self.namespace:
+            lines.append(f"# namespace: {self.namespace}")
+        lines.append("# Generated by avrotize. File id is stable for deterministic output; replace if needed.")
+        lines.append("")
+        for schema in schemas:
+            if isinstance(schema, dict) and schema.get("type") in {"enum", "record"}:
+                name = _type_name(schema)
+                if name not in self.emitted:
+                    lines.extend(self._render_named(schema, 0))
+                    lines.append("")
+        return "\n".join(lines).rstrip() + "\n"
+
+    def _render_named(self, schema: dict[str, Any], level: int) -> list[str]:
+        if schema.get("type") == "enum":
+            return self._render_enum(schema, level)
+        if schema.get("type") == "record":
+            return self._render_struct(schema, level)
+        return []
+
+    def _render_enum(self, schema: dict[str, Any], level: int) -> list[str]:
+        self.emitted.add(_type_name(schema))
+        lines = [f"{INDENT * level}enum {_safe_ident(schema['name'])} {{"]
+        for index, symbol in enumerate(schema.get("symbols", [])):
+            lines.append(f"{INDENT * (level + 1)}{_safe_ident(symbol)} @{index};")
+        lines.append(f"{INDENT * level}}}")
+        return lines
+
+    def _render_struct(self, schema: dict[str, Any], level: int) -> list[str]:
+        self.emitted.add(_type_name(schema))
+        lines = [f"{INDENT * level}struct {_safe_ident(schema['name'])} {{"]
+        fields = schema.get("fields", [])
+        grouped: dict[str, list[tuple[int, dict[str, Any], Any]]] = {}
+        normal: list[tuple[int, dict[str, Any], Any]] = []
+        for index, field in enumerate(fields):
+            avro_type = field.get("type")
+            union_name = field.get("capnpUnion")
+            item = (index, field, avro_type)
+            if union_name:
+                grouped.setdefault(str(union_name), []).append(item)
+            else:
+                normal.append(item)
+        for index, field, avro_type in normal:
+            lines.extend(self._render_field(field, avro_type, index, level + 1))
+        for _, items in grouped.items():
+            lines.append(f"{INDENT * (level + 1)}union {{")
+            for index, field, avro_type in items:
+                lines.extend(self._render_field(field, avro_type, index, level + 2))
+            lines.append(f"{INDENT * (level + 1)}}}")
+        lines.append(f"{INDENT * level}}}")
+        return lines
+
+    def _render_field(self, field: dict[str, Any], avro_type: Any, index: int, level: int) -> list[str]:
+        capnp_type, nested = self._capnp_type(avro_type, _safe_ident(field.get("name", f"field{index}")))
+        ordinal = index
+        lines: list[str] = []
+        lines.extend(self._render_inline_nested(nested, level))
+        lines.append(f"{INDENT * level}{_safe_ident(field.get('name', f'field{index}'))} @{ordinal} :{capnp_type};")
+        return lines
+
+    def _render_inline_nested(self, nested: list[dict[str, Any]], level: int) -> list[str]:
+        lines: list[str] = []
+        for schema in nested:
+            lines.extend(self._render_named(schema, level))
+        return lines
+
+    def _non_null_union(self, avro_type: list[Any]) -> list[Any]:
+        return [item for item in avro_type if item != "null" and not (isinstance(item, dict) and item.get("type") == "null")]
+
+    def _capnp_type(self, avro_type: Any, field_name: str) -> tuple[str, list[dict[str, Any]]]:
+        if isinstance(avro_type, list):
+            non_null = self._non_null_union(avro_type)
+            if len(non_null) == 1:
+                return self._capnp_type(non_null[0], field_name)
+            union_schema = {
+                "type": "record",
+                "name": f"{field_name[:1].upper()}{field_name[1:]}Choice",
+                "fields": [{"name": f"choice{i}", "type": t, "capnpUnion": "union"} for i, t in enumerate(non_null)],
+            }
+            return union_schema["name"], [union_schema]
+        if isinstance(avro_type, dict):
+            avro_kind = avro_type.get("type")
+            if isinstance(avro_kind, list):
+                return self._capnp_type(avro_kind, field_name)
+            if avro_kind == "array":
+                item_type, nested = self._capnp_type(avro_type.get("items", "string"), f"{field_name}Item")
+                return f"List({item_type})", nested
+            if avro_kind == "map":
+                entry = {
+                    "type": "record",
+                    "name": f"{field_name[:1].upper()}{field_name[1:]}Entry",
+                    "fields": [
+                        {"name": "key", "type": "string"},
+                        {"name": "value", "type": avro_type.get("values", "string")},
+                    ],
+                }
+                return f"List({entry['name']})", [entry]
+            if avro_kind == "record":
+                return avro_type["name"], [avro_type]
+            if avro_kind == "enum":
+                return avro_type["name"], [avro_type]
+            if avro_kind == "fixed":
+                return "Data", []
+            return self._capnp_type(avro_kind, field_name)
+        if isinstance(avro_type, str):
+            named = self.named.get(avro_type)
+            if named:
+                return named["name"], []
+            return self.primitive_map.get(avro_type, avro_type.split(".")[-1]), []
+        return "Text", []
+
+
+def convert_avro_to_capnproto(avro_schema_path: str, capnp_file_path: str, namespace: str | None = None) -> None:
+    """Convert an Avrotize/Avro schema file to a Cap'n Proto .capnp schema file."""
+    with open(avro_schema_path, "r", encoding="utf-8") as avro_file:
+        avro_schema = json.load(avro_file)
+    converter = AvroToCapnpConverter(namespace=namespace)
+    capnp_schema = converter.convert(avro_schema)
+    os.makedirs(os.path.dirname(os.path.abspath(capnp_file_path)) or ".", exist_ok=True)
+    with open(capnp_file_path, "w", encoding="utf-8") as capnp_file:
+        capnp_file.write(capnp_schema)
+
+
+def convert_json_structure_to_capnproto(structure_file: str, capnp_file_path: str, namespace: str | None = None) -> None:
+    """Convert JSON Structure to Cap'n Proto by bridging through Avrotize/Avro."""
+    from avrotize.jstructtoavro import convert_json_structure_to_avro
+
+    temp_parent = os.path.dirname(os.path.abspath(capnp_file_path)) or os.getcwd()
+    os.makedirs(temp_parent, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="avrotize-capnp-", dir=temp_parent) as temp_dir:
+        avro_file = os.path.join(temp_dir, "schema.avsc")
+        convert_json_structure_to_avro(structure_file, avro_file)
+        convert_avro_to_capnproto(avro_file, capnp_file_path, namespace=namespace)

{structurize-3.6.0 → structurize-3.7.0}/avrotize/avrotocsharp.py

@@ -57,9 +57,11 @@ class AvroToCSharp:
         self.cbor_annotation = False
         self.avro_annotation = False
         self.protobuf_net_annotation = False
+        self.openapi_generator_compat = False
         self.generated_types: Dict[str,str] = {}
         self.generated_avro_types: Dict[str, Dict[str, Union[str, Dict, List]]] = {}
         self.type_dict: Dict[str, Dict] = {}
+        self.emitted_option_namespaces: set[str] = set()
 
     def get_qualified_name(self, namespace: str, name: str) -> str:
         """ Concatenates namespace and name with a dot separator """
@@ -191,14 +193,19 @@ class AvroToCSharp:
         if self.msgpack_annotation:
             class_definition += "[MessagePackObject]\n"
 
-        fields_str = [self.generate_property(index + 1, field, class_name, avro_namespace) for index, field in enumerate(avro_schema.get('fields', []))]
+        fields = avro_schema.get('fields', [])
+        fields_str = [self.generate_property(index + 1, field, class_name, avro_namespace) for index, field in enumerate(fields)]
         class_body = "\n".join(fields_str)
         class_definition += f"public partial class {class_name}"
         if self.avro_annotation:
             class_definition += " : global::Avro.Specific.ISpecificRecord"
+        if self.openapi_generator_compat:
+            class_definition += ", System.ComponentModel.DataAnnotations.IValidatableObject" if self.avro_annotation else " : System.ComponentModel.DataAnnotations.IValidatableObject"
         class_definition += "\n{\n"+class_body
         class_definition += f"\n{INDENT}/// <summary>\n{INDENT}/// Default constructor\n{INDENT}///</summary>\n"
         class_definition += f"{INDENT}public {class_name}()\n{INDENT}{{\n{INDENT}}}"
+        if self.openapi_generator_compat and fields:
+            class_definition += self.generate_openapi_compat_constructor(class_name, fields, avro_namespace)
         if self.avro_annotation:
             class_definition += f"\n\n{INDENT}/// <summary>\n{INDENT}/// Constructor from Avro GenericRecord\n{INDENT}///</summary>\n"
             class_definition += f"{INDENT}public {class_name}(global::Avro.Generic.GenericRecord obj)\n{INDENT}{{\n"
@@ -270,7 +277,9 @@ class AvroToCSharp:
             system_xml_annotation=self.system_xml_annotation,
             msgpack_annotation=self.msgpack_annotation,
             cbor_annotation=self.cbor_annotation,
-            json_match_clauses=self.create_is_json_match_clauses(avro_schema, avro_namespace, class_name)
+            json_match_clauses=self.create_is_json_match_clauses(avro_schema, avro_namespace, class_name),
+            openapi_generator_compat=self.openapi_generator_compat,
+            openapi_fields=self.get_openapi_compat_fields(fields, class_name, avro_namespace)
         )
 
         # emit Equals and GetHashCode for value equality
@@ -394,7 +403,9 @@ class AvroToCSharp:
             field_name = field['name']
             if self.is_csharp_reserved_word(field_name):
                 field_name = f"@{field_name}"
-            if self.pascal_properties:
+            if self.openapi_generator_compat:
+                field_name = self.get_openapi_property_name(field_name, class_name)
+            elif self.pascal_properties:
                 field_name = pascal(field_name)
             if field_name == class_name:
                 field_name += "_"
@@ -436,7 +447,9 @@ class AvroToCSharp:
             field_name = field['name']
             if self.is_csharp_reserved_word(field_name):
                 field_name = f"@{field_name}"
-            if self.pascal_properties:
+            if self.openapi_generator_compat:
+                field_name = self.get_openapi_property_name(field_name, class_name)
+            elif self.pascal_properties:
                 field_name = pascal(field_name)
             if field_name == class_name:
                 field_name += "_"
@@ -753,6 +766,8 @@ class AvroToCSharp:
             field_name = pascal(field_name)
         if field_name == class_name:
             field_name += "_"
+        if self.openapi_generator_compat:
+            return self.generate_openapi_compat_property(field, field_type, field_name, annotation_name, class_name)
         prop = ''
         prop += f"{INDENT}/// <summary>\n{INDENT}/// { field.get('doc', field_name) }\n{INDENT}/// </summary>\n"
         
@@ -815,12 +830,116 @@ class AvroToCSharp:
         prop += f"{INDENT}public {field_type} {field_name} {{ get; set; }}{initialization}"
         return prop
 
+    def is_openapi_optional_avro_field(self, field: Dict) -> bool:
+        """Returns true if the Avro field is nullable and should use Option<T>."""
+        avro_type = field.get('type')
+        return isinstance(avro_type, list) and 'null' in avro_type and len([t for t in avro_type if t != 'null']) == 1
+
+    def get_openapi_property_name(self, field_name: str, class_name: str) -> str:
+        """Returns the OpenAPI Generator-style C# property name."""
+        name = field_name[1:] if field_name.startswith('@') else field_name
+        property_name = pascal(name)
+        if property_name == class_name:
+            property_name += "_"
+        return property_name
+
+    def generate_openapi_compat_property(self, field: Dict, field_type: str, field_name: str, annotation_name: str, class_name: str) -> str:
+        """Generates an OpenAPI Generator-compatible property."""
+        property_name = self.get_openapi_property_name(field_name, class_name)
+        doc = field.get('doc', property_name)
+        prop = f"{INDENT}/// <summary>\n{INDENT}/// {doc}\n{INDENT}/// </summary>\n"
+        if self.is_openapi_optional_avro_field(field):
+            option_name = f"{property_name}Option"
+            prop += f"{INDENT}[System.Text.Json.Serialization.JsonIgnore]\n"
+            prop += f"{INDENT}public Option<{field_type}> {option_name} {{ get; private set; }}\n"
+            prop += f"{INDENT}[System.Text.Json.Serialization.JsonPropertyName(\"{annotation_name}\")]\n"
+            prop += f"{INDENT}public {field_type} {property_name} {{ get => {option_name}; set => {option_name} = new(value); }}"
+        else:
+            initialization = ""
+            if field_type == "string":
+                initialization = " = string.Empty;"
+            elif field_type.startswith("List<") or field_type.startswith("Dictionary<"):
+                initialization = " = new();"
+            elif field_type.startswith("global::") and not self.is_csharp_primitive_type(field_type):
+                initialization = " = new();"
+            prop += f"{INDENT}[System.Text.Json.Serialization.JsonPropertyName(\"{annotation_name}\")]\n"
+            prop += f"{INDENT}public {field_type} {property_name} {{ get; set; }}{initialization}"
+        return prop
+
+    def get_openapi_compat_fields(self, fields: List[Dict], class_name: str, parent_namespace: str) -> List[Dict[str, Any]]:
+        """Builds template metadata for OpenAPI Generator-compatible converters."""
+        result: List[Dict[str, Any]] = []
+        for field in fields:
+            raw_name = field['name']
+            safe_name = f"@{raw_name}" if self.is_csharp_reserved_word(raw_name) else raw_name
+            field_type = self.convert_avro_type_to_csharp(class_name, raw_name, field['type'], parent_namespace)
+            property_name = self.get_openapi_property_name(safe_name, class_name)
+            result.append({
+                "wire_name": raw_name,
+                "property_name": property_name,
+                "option_name": f"{property_name}Option",
+                "type": field_type,
+                "is_optional": self.is_openapi_optional_avro_field(field)
+            })
+        return result
+
+    def generate_openapi_compat_constructor(self, class_name: str, fields: List[Dict], parent_namespace: str) -> str:
+        """Generates an OpenAPI Generator-compatible all-properties constructor."""
+        openapi_fields = self.get_openapi_compat_fields(fields, class_name, parent_namespace)
+        parameters = []
+        assignments = []
+        for field in openapi_fields:
+            parameter_name = field["property_name"][0].lower() + field["property_name"][1:]
+            if field["is_optional"]:
+                parameters.append(f"Option<{field['type']}> {parameter_name}")
+                assignments.append(f"{INDENT*2}{field['option_name']} = {parameter_name};")
+            else:
+                parameters.append(f"{field['type']} {parameter_name}")
+                assignments.append(f"{INDENT*2}{field['property_name']} = {parameter_name};")
+        return (
+            f"\n\n{INDENT}/// <summary>\n{INDENT}/// Initializes a new instance with all properties.\n{INDENT}/// </summary>\n"
+            f"{INDENT}public {class_name}({', '.join(parameters)})\n{INDENT}{{\n"
+            + "\n".join(assignments) +
+            f"\n{INDENT}}}"
+        )
+
+    def write_openapi_option_file(self, namespace: str) -> None:
+        """Writes the reusable Option<T> type for OpenAPI Generator-compatible output."""
+        if namespace in self.emitted_option_namespaces:
+            return
+        self.emitted_option_namespaces.add(namespace)
+        directory_path = os.path.join(self.output_dir, os.path.join('src', namespace.replace('.', os.sep)))
+        os.makedirs(directory_path, exist_ok=True)
+        file_path = os.path.join(directory_path, "Option.cs")
+        file_content = (
+            "using System;\n\n"
+            f"namespace {namespace}\n{{\n"
+            f"{INDENT}/// <summary>\n"
+            f"{INDENT}/// Represents an optional value that distinguishes unset from explicit null/default.\n"
+            f"{INDENT}/// </summary>\n"
+            f"{INDENT}public readonly struct Option<T>\n{INDENT}{{\n"
+            f"{INDENT*2}public bool IsSet {{ get; }}\n"
+            f"{INDENT*2}public T Value {{ get; }}\n\n"
+            f"{INDENT*2}public Option(T value)\n{INDENT*2}{{\n"
+            f"{INDENT*3}IsSet = true;\n"
+            f"{INDENT*3}Value = value;\n"
+            f"{INDENT*2}}}\n\n"
+            f"{INDENT*2}public static implicit operator Option<T>(T value) => new(value);\n"
+            f"{INDENT*2}public static implicit operator T(Option<T> option) => option.Value;\n"
+            f"{INDENT}}}\n"
+            "}"
+        )
+        with open(file_path, 'w', encoding='utf-8') as file:
+            file.write(file_content)
+
     def write_to_file(self, namespace: str, name: str, definition: str):
         """ Writes the class or enum to a file """
         directory_path = os.path.join(
             self.output_dir, os.path.join('src', namespace.replace('.', os.sep)))
         if not os.path.exists(directory_path):
             os.makedirs(directory_path, exist_ok=True)
+        if self.openapi_generator_compat:
+            self.write_openapi_option_file(namespace)
         file_path = os.path.join(directory_path, f"{name}.cs")
 
         with open(file_path, 'w', encoding='utf-8') as file:
@@ -829,9 +948,11 @@ class AvroToCSharp:
             file_content += "using System.Linq;\n"
             if self.protobuf_net_annotation:
                 file_content += "using ProtoBuf;\n"
-            if self.system_text_json_annotation:
+            if self.system_text_json_annotation or self.openapi_generator_compat:
                 file_content += "using System.Text.Json;\n"
                 file_content += "using System.Text.Json.Serialization;\n"
+            if self.openapi_generator_compat:
+                file_content += "using System.ComponentModel.DataAnnotations;\n"
             if self.newtonsoft_json_annotation:
                 file_content += "using Newtonsoft.Json;\n"
             if self.system_xml_annotation:  # Add XML serialization using directive
@@ -921,12 +1042,14 @@ class AvroToCSharp:
         if avro_schema and 'fields' in avro_schema:
             for field in cast(List[Dict[str,JsonNode]],avro_schema['fields']):
                 field_name = str(field['name'])
-                if self.pascal_properties:
+                if self.is_csharp_reserved_word(field_name):
+                    field_name = f"@{field_name}"
+                if self.openapi_generator_compat:
+                    field_name = self.get_openapi_property_name(field_name, class_name)
+                elif self.pascal_properties:
                     field_name = pascal(field_name)
                 if field_name == class_name:
                     field_name += "_"
-                if self.is_csharp_reserved_word(field_name):
-                    field_name = f"@{field_name}"
                 field_type = self.convert_avro_type_to_csharp(class_name, field_name, field['type'], str(avro_schema.get('namespace', '')))
                 is_class = field_type in self.generated_types and self.generated_types[field_type] == "class"
                 is_enum = self.is_enum_type(field['type'])
@@ -1121,7 +1244,8 @@ def convert_avro_to_csharp(
     msgpack_annotation=False,
     cbor_annotation=False,
     avro_annotation=False,
-    protobuf_net_annotation=False
+    protobuf_net_annotation=False,
+    openapi_generator_compat=False
 ):
     """Converts Avro schema to C# classes
 
@@ -1138,6 +1262,7 @@ def convert_avro_to_csharp(
         cbor_annotation (bool, optional): Use Dahomey.Cbor annotations. Defaults to False.
         avro_annotation (bool, optional): Use Avro annotations. Defaults to False.
         protobuf_net_annotation (bool, optional): Use protobuf-net annotations. Defaults to False.
+        openapi_generator_compat (bool, optional): Generate OpenAPI Generator-compatible C# models. Defaults to False.
     """
 
     if not base_namespace:
@@ -1152,6 +1277,7 @@ def convert_avro_to_csharp(
     avrotocs.cbor_annotation = cbor_annotation
     avrotocs.avro_annotation = avro_annotation
     avrotocs.protobuf_net_annotation = protobuf_net_annotation
+    avrotocs.openapi_generator_compat = openapi_generator_compat
     avrotocs.convert(avro_schema_path, cs_file_path)
 
 
@@ -1167,7 +1293,8 @@ def convert_avro_schema_to_csharp(
     msgpack_annotation: bool = False,
     cbor_annotation: bool = False,
     avro_annotation: bool = False,
-    protobuf_net_annotation: bool = False
+    protobuf_net_annotation: bool = False,
+    openapi_generator_compat: bool = False
 ):
     """Converts Avro schema to C# classes
 
@@ -1195,4 +1322,5 @@ def convert_avro_schema_to_csharp(
     avrotocs.cbor_annotation = cbor_annotation
     avrotocs.avro_annotation = avro_annotation
     avrotocs.protobuf_net_annotation = protobuf_net_annotation
+    avrotocs.openapi_generator_compat = openapi_generator_compat
     avrotocs.convert_schema(avro_schema, output_dir)

structurize-3.7.0/avrotize/avrotocue.py

@@ -0,0 +1,145 @@
+"""Avrotize Schema to CUE subset converter."""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+
+_AVRO_TO_CUE = {
+    "string": "string",
+    "int": "int",
+    "long": "int",
+    "float": "float",
+    "double": "number",
+    "boolean": "bool",
+    "bytes": "bytes",
+    "null": "null",
+}
+
+
+class AvroToCueConverter:
+    """Emits CUE definitions for the same practical subset parsed by cuetoavro."""
+
+    def __init__(self, namespace: str | None = None) -> None:
+        self.namespace = namespace
+        self.emitted: set[str] = set()
+
+    def convert(self, avro_schema: Any) -> str:
+        schemas = avro_schema if isinstance(avro_schema, list) else [avro_schema]
+        namespace = self.namespace or self.find_namespace(schemas)
+        lines: list[str] = []
+        package = self.package_from_namespace(namespace)
+        if package:
+            lines.extend([f"package {package}", ""])
+        for schema in schemas:
+            if isinstance(schema, dict) and schema.get("type") == "record":
+                lines.extend(self.record_definition(schema))
+                lines.append("")
+        if not any(isinstance(schema, dict) and schema.get("type") == "record" for schema in schemas):
+            lines.extend(["#Document: {}", ""])
+        return "\n".join(lines).rstrip() + "\n"
+
+    @staticmethod
+    def find_namespace(schemas: list[Any]) -> str | None:
+        for schema in schemas:
+            if isinstance(schema, dict) and schema.get("namespace"):
+                return schema["namespace"]
+        return None
+
+    @staticmethod
+    def package_from_namespace(namespace: str | None) -> str | None:
+        if not namespace:
+            return None
+        name = namespace.split(".")[-1]
+        name = re.sub(r"[^A-Za-z0-9_]", "_", name)
+        if not name or name[0].isdigit():
+            name = f"_{name}"
+        return name
+
+    def record_definition(self, record: dict[str, Any]) -> list[str]:
+        name = record.get("name", "Document").split(".")[-1]
+        lines = [f"#{name}: {{"]
+        for field in record.get("fields", []):
+            lines.append(f"  {self.field_to_cue(field)}")
+        lines.append("}")
+        return lines
+
+    def field_to_cue(self, field: dict[str, Any]) -> str:
+        field_name = field.get("name", "field")
+        cue_type, nullable = self.type_to_cue(field.get("type", "string"))
+        suffix = "?" if nullable else ""
+        default = field.get("default", _NO_DEFAULT)
+        if default is not _NO_DEFAULT:
+            cue_type = f"{cue_type} | *{self.literal_to_cue(default)}"
+        return f"{field_name}{suffix}: {cue_type}"
+
+    def type_to_cue(self, avro_type: Any) -> tuple[str, bool]:
+        if isinstance(avro_type, list):
+            non_null = [item for item in avro_type if item != "null"]
+            nullable = len(non_null) != len(avro_type)
+            if len(non_null) == 1:
+                cue_type, _ = self.type_to_cue(non_null[0])
+                return cue_type, nullable
+            choices = [self.type_to_cue(item)[0] for item in non_null]
+            if nullable:
+                choices.append("null")
+            return " | ".join(choices) if choices else "null", nullable
+        if isinstance(avro_type, str):
+            if avro_type in _AVRO_TO_CUE:
+                return _AVRO_TO_CUE[avro_type], False
+            return f"#{avro_type.split('.')[-1]}", False
+        if isinstance(avro_type, dict):
+            type_name = avro_type.get("type")
+            if isinstance(type_name, str) and type_name in _AVRO_TO_CUE:
+                return _AVRO_TO_CUE[type_name], False
+            if type_name == "array":
+                item_type, _ = self.type_to_cue(avro_type.get("items", "string"))
+                return f"[...{item_type}]", False
+            if type_name == "map":
+                value_type, _ = self.type_to_cue(avro_type.get("values", "string"))
+                return f"{{ [string]: {value_type} }}", False
+            if type_name == "enum":
+                values = avro_type.get("x-cue-symbols", {})
+                symbols = [values.get(symbol, symbol) for symbol in avro_type.get("symbols", [])]
+                return " | ".join(self.literal_to_cue(symbol) for symbol in symbols), False
+            if type_name == "record":
+                fields = avro_type.get("fields", [])
+                if not fields:
+                    return "{}", False
+                inner = ["{"]
+                for field in fields:
+                    inner.append(f"    {self.field_to_cue(field)}")
+                inner.append("  }")
+                return "\n".join(inner), False
+            if isinstance(type_name, str):
+                return self.type_to_cue(type_name)
+        return "string", False
+
+    @staticmethod
+    def literal_to_cue(value: Any) -> str:
+        if value is None:
+            return "null"
+        if isinstance(value, bool):
+            return "true" if value else "false"
+        if isinstance(value, (int, float)):
+            return str(value)
+        return json.dumps(str(value))
+
+
+class _NoDefault:
+    pass
+
+
+_NO_DEFAULT = _NoDefault()
+
+
+def convert_avro_to_cue(avro_schema_path: str, cue_file_path: str, namespace: str | None = None) -> None:
+    """Convert an Avrotize/Avro schema file to a CUE subset file."""
+    with open(avro_schema_path, "r", encoding="utf-8") as avro_file:
+        avro_schema = json.load(avro_file)
+    converter = AvroToCueConverter(namespace=namespace)
+    cue_text = converter.convert(avro_schema)
+    with open(cue_file_path, "w", encoding="utf-8") as cue_file:
+        cue_file.write(cue_text)