structurize 3.7.3__tar.gz → 3.8.0__tar.gz

{structurize-3.7.3/structurize.egg-info → structurize-3.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.7.3
+Version: 3.8.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.7.3 → structurize-3.8.0}/avrotize/__init__.py

@@ -51,6 +51,8 @@ _mappings = {
     "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"),
     "convert_asn1_to_avro": (f"{mod}.asn1toavro", "convert_asn1_to_avro"),
+    "convert_avro_to_asn1": (f"{mod}.avrotoasn1", "convert_avro_to_asn1"),
+    "convert_structure_to_asn1": (f"{mod}.structuretoasn1", "convert_structure_to_asn1"),
     "convert_xsd_to_avro": (f"{mod}.xsdtoavro", "convert_xsd_to_avro"),
     "convert_avro_to_json_schema": (f"{mod}.avrotojsons", "convert_avro_to_json_schema"),
     "convert_avro_to_kusto_file": (f"{mod}.avrotokusto", "convert_avro_to_kusto_file"),

{structurize-3.7.3 → structurize-3.8.0}/avrotize/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.7.3'
-__version_tuple__ = version_tuple = (3, 7, 3)
+__version__ = version = '3.8.0'
+__version_tuple__ = version_tuple = (3, 8, 0)
 
-__commit_id__ = commit_id = 'g4eb36ac42'
+__commit_id__ = commit_id = 'geb0e0af04'

structurize-3.8.0/avrotize/avrotoasn1.py

@@ -0,0 +1,330 @@
+# pylint: disable=line-too-long
+
+""" AvroToASN1 class for converting Avrotize (Avro) schema to an ASN.1 module. """
+
+import json
+import os
+import re
+from typing import Dict, List, Union
+
+from avrotize.common import is_generic_avro_type
+
+JsonNode = Union[Dict, List, str, int, float, bool, None]
+
+
+class AvroToASN1:
+    """ Converts an Avrotize (Avro) schema to an ASN.1 (X.680) module. """
+
+    def __init__(self, module_name: str = 'AvrotizeSchema'):
+        self.module_name = self._to_type_reference(module_name)
+        # Ordered list of top-level "Name ::= ..." assignment strings.
+        self.assignments: List[str] = []
+        # ASN.1 type names already emitted (global uniqueness for typereferences).
+        self.known_types: Dict[str, str] = {}
+        # Avro full name -> ASN.1 type name.
+        self.type_name_map: Dict[str, str] = {}
+        self.used_type_names: set = set()
+
+    # ------------------------------------------------------------------ names
+
+    @staticmethod
+    def _sanitize(name: str) -> str:
+        """Turn an arbitrary name into an ASN.1-legal token body (letters, digits, hyphens)."""
+        if not name:
+            return 'x'
+        # Keep only the last dotted segment for namespaced names.
+        name = name.split('.')[-1]
+        # Replace any run of illegal characters with a single hyphen.
+        name = re.sub(r'[^A-Za-z0-9]+', '-', name)
+        # Collapse consecutive hyphens and strip leading/trailing hyphens.
+        name = re.sub(r'-+', '-', name).strip('-')
+        if not name:
+            return 'x'
+        # ASN.1 tokens must start with a letter.
+        if not name[0].isalpha():
+            name = 'x-' + name
+        return name
+
+    def _to_type_reference(self, name: str) -> str:
+        """ASN.1 typereference: must start with an upper-case letter."""
+        token = self._sanitize(name)
+        return token[0].upper() + token[1:]
+
+    def _to_identifier(self, name: str) -> str:
+        """ASN.1 identifier (member / enum value): must start with a lower-case letter."""
+        token = self._sanitize(name)
+        letters = [c for c in token if c.isalpha()]
+        if letters and all(c.isupper() for c in letters):
+            # ALL-CAPS tokens (e.g. Avro enum symbols) read best fully lower-cased.
+            token = token.lower()
+        return token[0].lower() + token[1:]
+
+    def _unique_type_name(self, name: str) -> str:
+        """Return a module-unique ASN.1 typereference for the given name."""
+        base = self._to_type_reference(name)
+        candidate = base
+        counter = 1
+        while candidate in self.used_type_names:
+            counter += 1
+            candidate = f"{base}{counter}"
+        self.used_type_names.add(candidate)
+        return candidate
+
+    # ------------------------------------------------------------- primitives
+
+    def _map_primitive(self, avro_type: Union[str, dict]) -> str:
+        """Map an Avro primitive (or logical) type to an ASN.1 built-in type."""
+        if isinstance(avro_type, dict):
+            logical_type = avro_type.get('logicalType')
+            base = avro_type.get('type')
+            if logical_type == 'date':
+                return 'DATE'
+            if logical_type in ('timestamp-millis', 'timestamp-micros',
+                                'local-timestamp-millis', 'local-timestamp-micros'):
+                return 'DATE-TIME'
+            if logical_type in ('time-millis', 'time-micros'):
+                return 'TIME-OF-DAY'
+            if logical_type == 'decimal':
+                return 'REAL'
+            if logical_type == 'uuid':
+                return 'UTF8String'
+            if logical_type == 'duration':
+                return 'UTF8String'
+            return self._map_primitive(base)
+
+        mapping = {
+            'null': 'NULL',
+            'boolean': 'BOOLEAN',
+            'int': 'INTEGER',
+            'long': 'INTEGER',
+            'float': 'REAL',
+            'double': 'REAL',
+            'bytes': 'OCTET STRING',
+            'string': 'UTF8String',
+        }
+        return mapping.get(avro_type, '')
+
+    @staticmethod
+    def _is_primitive(avro_type: Union[str, dict]) -> bool:
+        if isinstance(avro_type, dict):
+            return 'logicalType' in avro_type or avro_type.get('type') in {
+                'null', 'boolean', 'int', 'long', 'float', 'double', 'bytes', 'string'}
+        return avro_type in {'null', 'boolean', 'int', 'long', 'float', 'double', 'bytes', 'string'}
+
+    # ------------------------------------------------------------- expressions
+
+    def type_expression(self, avro_type: JsonNode) -> str:
+        """Return an ASN.1 type expression for an Avro type (defining named types as a side effect)."""
+        if isinstance(avro_type, str):
+            if self._is_primitive(avro_type):
+                return self._map_primitive(avro_type)
+            # Reference to a previously defined named type.
+            return self.type_name_map.get(avro_type, self._to_type_reference(avro_type))
+
+        if isinstance(avro_type, list):
+            return self._union_expression(avro_type)
+
+        if isinstance(avro_type, dict):
+            if 'logicalType' in avro_type:
+                return self._map_primitive(avro_type)
+            kind = avro_type.get('type')
+            if kind == 'record' or kind == 'error':
+                return self._define_record(avro_type)
+            if kind == 'enum':
+                return self._define_enum(avro_type)
+            if kind == 'fixed':
+                return self._define_fixed(avro_type)
+            if kind == 'array':
+                items = avro_type.get('items', 'string')
+                return f"SEQUENCE OF {self.type_expression(items)}"
+            if kind == 'map':
+                values = avro_type.get('values', 'string')
+                return f"SEQUENCE OF SEQUENCE {{ key UTF8String, value {self.type_expression(values)} }}"
+            if self._is_primitive(avro_type):
+                return self._map_primitive(avro_type)
+            if isinstance(kind, (dict, list)):
+                return self.type_expression(kind)
+            if isinstance(kind, str):
+                return self.type_name_map.get(kind, self._to_type_reference(kind))
+        return 'UTF8String'
+
+    def _union_expression(self, union: List[JsonNode]) -> str:
+        """Map an Avro union to an ASN.1 type expression (nullability is handled by the caller)."""
+        if is_generic_avro_type(union):
+            return 'ANY'
+        non_null = [t for t in union if t != 'null']
+        if len(non_null) == 0:
+            return 'NULL'
+        if len(non_null) == 1:
+            return self.type_expression(non_null[0])
+        members = []
+        used: set = set()
+        for i, branch in enumerate(non_null):
+            alt = self._alternative_name(branch, i, used)
+            members.append(f"{alt} {self.type_expression(branch)}")
+        return "CHOICE { " + ", ".join(members) + " }"
+
+    def _alternative_name(self, branch: JsonNode, index: int, used: set) -> str:
+        """Derive a unique ASN.1 CHOICE alternative identifier from a union branch."""
+        if isinstance(branch, str):
+            base = self._to_identifier(branch)
+        elif isinstance(branch, dict):
+            if 'name' in branch:
+                base = self._to_identifier(branch['name'])
+            else:
+                base = self._to_identifier(str(branch.get('type', f'choice{index}')))
+        else:
+            base = f'choice{index}'
+        candidate = base
+        counter = 1
+        while candidate in used:
+            counter += 1
+            candidate = f"{base}{counter}"
+        used.add(candidate)
+        return candidate
+
+    # --------------------------------------------------------------- defining
+
+    def _define_record(self, record: dict) -> str:
+        """Emit an ASN.1 SEQUENCE assignment for an Avro record, returning its type name."""
+        full_name = self._full_name(record)
+        if full_name in self.type_name_map:
+            return self.type_name_map[full_name]
+
+        type_name = self._unique_type_name(record.get('name', 'Record'))
+        # Register before recursing so self-references resolve.
+        self.type_name_map[full_name] = type_name
+
+        fields = record.get('fields', [])
+        used_members: set = set()
+        members = [(self._member_definition(field, used_members), field.get('doc'))
+                   for field in fields]
+
+        if members:
+            lines: List[str] = []
+            for i, (core, doc) in enumerate(members):
+                comma = "," if i < len(members) - 1 else ""
+                if doc:
+                    lines.append(f"    -- {self._comment(doc)}")
+                lines.append(f"    {core}{comma}")
+            body = "SEQUENCE {\n" + "\n".join(lines) + "\n}"
+        else:
+            body = "SEQUENCE {}"
+        self._append_assignment(type_name, body, record.get('doc'))
+        return type_name
+
+    def _member_definition(self, field: dict, used_members: set) -> str:
+        """Build a single ASN.1 SEQUENCE member (without comment) from an Avro field."""
+        name = self._unique_identifier(field['name'], used_members)
+        field_type = field['type']
+        optional = isinstance(field_type, list) and 'null' in field_type
+        expr = self.type_expression(field_type)
+        member = f"{name} {expr}"
+        if optional:
+            member += " OPTIONAL"
+        return member
+
+    def _define_enum(self, enum: dict) -> str:
+        """Emit an ASN.1 ENUMERATED assignment for an Avro enum, returning its type name."""
+        full_name = self._full_name(enum)
+        if full_name in self.type_name_map:
+            return self.type_name_map[full_name]
+
+        type_name = self._unique_type_name(enum.get('name', 'Enum'))
+        self.type_name_map[full_name] = type_name
+
+        values: List[str] = []
+        used_symbols: set = set()
+        for i, symbol in enumerate(enum.get('symbols', [])):
+            sym = self._unique_identifier(symbol, used_symbols)
+            values.append(f"{sym}({i})")
+        body = "ENUMERATED { " + ", ".join(values) + " }" if values else "ENUMERATED { unspecified(0) }"
+        self._append_assignment(type_name, body, enum.get('doc'))
+        return type_name
+
+    def _define_fixed(self, fixed: dict) -> str:
+        """Emit an ASN.1 OCTET STRING (SIZE(n)) assignment for an Avro fixed type."""
+        full_name = self._full_name(fixed)
+        if full_name in self.type_name_map:
+            return self.type_name_map[full_name]
+
+        type_name = self._unique_type_name(fixed.get('name', 'Fixed'))
+        self.type_name_map[full_name] = type_name
+        size = fixed.get('size', 0)
+        self._append_assignment(type_name, f"OCTET STRING (SIZE({size}))", fixed.get('doc'))
+        return type_name
+
+    # ------------------------------------------------------------- utilities
+
+    def _unique_identifier(self, name: str, used: set) -> str:
+        base = self._to_identifier(name)
+        candidate = base
+        counter = 1
+        while candidate in used:
+            counter += 1
+            candidate = f"{base}-{counter}"
+        used.add(candidate)
+        return candidate
+
+    @staticmethod
+    def _full_name(schema: dict) -> str:
+        name = schema.get('name', '')
+        namespace = schema.get('namespace', '')
+        return f"{namespace}.{name}" if namespace else name
+
+    @staticmethod
+    def _comment(text: str) -> str:
+        """ASN.1 line comment body: no line breaks, no double-hyphen terminator."""
+        return re.sub(r'\s+', ' ', str(text)).replace('--', '- -').strip()
+
+    def _append_assignment(self, type_name: str, body: str, doc: str = None) -> None:
+        assignment = ''
+        if doc:
+            assignment += f"-- {self._comment(doc)}\n"
+        assignment += f"{type_name} ::= {body}"
+        self.assignments.append(assignment)
+        self.known_types[type_name] = body
+
+    # ----------------------------------------------------------------- render
+
+    def convert(self, avro_schema: JsonNode) -> str:
+        """Convert an Avro schema (dict or list of named types) to an ASN.1 module string."""
+        schemas = avro_schema if isinstance(avro_schema, list) else [avro_schema]
+        for schema in schemas:
+            if not isinstance(schema, dict):
+                continue
+            kind = schema.get('type')
+            if kind in ('record', 'error'):
+                self._define_record(schema)
+            elif kind == 'enum':
+                self._define_enum(schema)
+            elif kind == 'fixed':
+                self._define_fixed(schema)
+        return self.render()
+
+    def render(self) -> str:
+        """Render the accumulated assignments as a complete ASN.1 module."""
+        lines = [f"{self.module_name} DEFINITIONS AUTOMATIC TAGS ::= BEGIN", ""]
+        for assignment in self.assignments:
+            lines.append(assignment)
+            lines.append("")
+        lines.append("END")
+        return "\n".join(lines) + "\n"
+
+
+def convert_avro_to_asn1(avro_schema_path: str, asn1_file_path: str, module_name: str = '') -> None:
+    """Convert an Avrotize schema file to an ASN.1 module file."""
+    with open(avro_schema_path, 'r', encoding='utf-8') as avro_file:
+        avro_schema = json.load(avro_file)
+
+    if not module_name:
+        module_name = os.path.splitext(os.path.basename(asn1_file_path))[0] or 'AvrotizeSchema'
+
+    converter = AvroToASN1(module_name)
+    asn1_text = converter.convert(avro_schema)
+
+    out_dir = os.path.dirname(asn1_file_path)
+    if out_dir and not os.path.exists(out_dir):
+        os.makedirs(out_dir, exist_ok=True)
+    with open(asn1_file_path, 'w', encoding='utf-8') as asn1_file:
+        asn1_file.write(asn1_text)

{structurize-3.7.3 → structurize-3.8.0}/avrotize/avrotocsharp.py

@@ -58,6 +58,7 @@ class AvroToCSharp:
         self.avro_annotation = False
         self.protobuf_net_annotation = False
         self.openapi_generator_compat = False
+        self.target_framework = ''
         self.generated_types: Dict[str,str] = {}
         self.generated_avro_types: Dict[str, Dict[str, Union[str, Dict, List]]] = {}
         self.type_dict: Dict[str, Dict] = {}
@@ -1189,6 +1190,7 @@ class AvroToCSharp:
                     file.write(process_template(
                         "avrotocsharp/project.csproj.jinja",
                         project_name=project_name, 
+                        target_framework=self.target_framework,
                         avro_annotation=self.avro_annotation,
                         system_xml_annotation=self.system_xml_annotation,
                         system_text_json_annotation=self.system_text_json_annotation,
@@ -1216,6 +1218,7 @@ class AvroToCSharp:
                     file.write(process_template(
                         "avrotocsharp/testproject.csproj.jinja", 
                         project_name=project_name,
+                        target_framework=self.target_framework,
                         avro_annotation=self.avro_annotation,
                         system_xml_annotation=self.system_xml_annotation,
                         system_text_json_annotation=self.system_text_json_annotation,
@@ -1279,7 +1282,8 @@ def convert_avro_to_csharp(
     cbor_annotation=False,
     avro_annotation=False,
     protobuf_net_annotation=False,
-    openapi_generator_compat=False
+    openapi_generator_compat=False,
+    target_framework=''
 ):
     """Converts Avro schema to C# classes
 
@@ -1297,6 +1301,7 @@ def convert_avro_to_csharp(
         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.
+        target_framework (str, optional): Target framework moniker written into the generated .csproj (e.g. 'net8.0'). A ';'-separated value emits <TargetFrameworks> for multi-targeting. Defaults to '' (net10.0).
     """
 
     if not base_namespace:
@@ -1312,6 +1317,7 @@ def convert_avro_to_csharp(
     avrotocs.avro_annotation = avro_annotation
     avrotocs.protobuf_net_annotation = protobuf_net_annotation
     avrotocs.openapi_generator_compat = openapi_generator_compat
+    avrotocs.target_framework = target_framework
     avrotocs.convert(avro_schema_path, cs_file_path)
 
 
@@ -1328,7 +1334,8 @@ def convert_avro_schema_to_csharp(
     cbor_annotation: bool = False,
     avro_annotation: bool = False,
     protobuf_net_annotation: bool = False,
-    openapi_generator_compat: bool = False
+    openapi_generator_compat: bool = False,
+    target_framework: str = ''
 ):
     """Converts Avro schema to C# classes
 
@@ -1345,6 +1352,7 @@ def convert_avro_schema_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.
+        target_framework (str, optional): Target framework moniker written into the generated .csproj (e.g. 'net8.0'). A ';'-separated value emits <TargetFrameworks> for multi-targeting. Defaults to '' (net10.0).
     """
     avrotocs = AvroToCSharp(base_namespace)
     avrotocs.project_name = project_name
@@ -1357,4 +1365,5 @@ def convert_avro_schema_to_csharp(
     avrotocs.avro_annotation = avro_annotation
     avrotocs.protobuf_net_annotation = protobuf_net_annotation
     avrotocs.openapi_generator_compat = openapi_generator_compat
+    avrotocs.target_framework = target_framework
     avrotocs.convert_schema(avro_schema, output_dir)

{structurize-3.7.3 → structurize-3.8.0}/avrotize/avrotogo.py

@@ -1,7 +1,7 @@
 import json
 import os
 from typing import Dict, List, Union, Set
-from avrotize.common import get_longest_namespace_prefix, is_generic_avro_type, is_any_value_type, pascal, render_template
+from avrotize.common import get_longest_namespace_prefix, is_generic_avro_type, is_any_value_type, pascal, render_template, format_go_files
 
 INDENT = '    '
 
@@ -33,10 +33,19 @@ class AvroToGo:
         self.enums = []
 
     def _safe_package_name(self, name: str) -> str:
-        """Converts a name to a safe Go package name"""
-        if name in self.GO_RESERVED_WORDS:
-            return f"{name}_"
-        return name
+        """Converts a name to a safe Go package name (a valid lowercase identifier).
+
+        Sanitizes any character that is not valid in a Go identifier (dots,
+        hyphens from file names, etc.) to underscores so the emitted ``package``
+        clause is compilable and gofmt-parseable.
+        """
+        import re
+        safe = re.sub(r'[^a-zA-Z0-9_]+', '_', name).strip('_').lower()
+        if not safe or not re.match(r'^[a-z]', safe):
+            safe = f"pkg_{safe}" if safe else "pkg"
+        if safe in self.GO_RESERVED_WORDS:
+            return f"{safe}_"
+        return safe
 
     def safe_identifier(self, name: str) -> str:
         """Converts a name to a safe Go identifier"""
@@ -418,6 +427,7 @@ class AvroToGo:
         self.write_go_mod_file()
         self.write_modname_go_file()
         self.generate_helpers()
+        format_go_files(self.output_dir)
 
     def write_go_mod_file(self):
         """Writes the go.mod file for the Go project"""

{structurize-3.7.3 → structurize-3.8.0}/avrotize/commands.json

@@ -1,4 +1,95 @@
 [
+  {
+    "command": "a2asn",
+    "description": "Convert Avrotize schema to ASN.1 schema",
+    "group": "1_Schemas",
+    "function": {
+      "name": "avrotize.avrotoasn1.convert_avro_to_asn1",
+      "args": {
+        "avro_schema_path": "input_file_path",
+        "asn1_file_path": "output_file_path",
+        "module_name": "args.module"
+      }
+    },
+    "extensions": [
+      ".avsc"
+    ],
+    "args": [
+      {
+        "name": "input",
+        "type": "str",
+        "nargs": "?",
+        "help": "Path to the Avrotize schema file (or read from stdin if omitted)",
+        "required": false
+      },
+      {
+        "name": "--out",
+        "type": "str",
+        "help": "Path to the ASN.1 schema file",
+        "required": false
+      },
+      {
+        "name": "--avsc",
+        "type": "str",
+        "help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
+        "required": false
+      },
+      {
+        "name": "--module",
+        "type": "str",
+        "help": "ASN.1 module name (defaults to the output file name)",
+        "required": false
+      }
+    ],
+    "suggested_output_file_path": "{input_file_name}.asn1",
+    "prompts": []
+  },
+  {
+    "command": "s2asn",
+    "description": "Convert JSON Structure schema to ASN.1 schema",
+    "group": "1_Schemas",
+    "function": {
+      "name": "avrotize.structuretoasn1.convert_structure_to_asn1",
+      "args": {
+        "structure_schema_path": "input_file_path",
+        "asn1_file_path": "output_file_path",
+        "module_name": "args.module"
+      }
+    },
+    "extensions": [
+      ".struct.json",
+      ".json"
+    ],
+    "args": [
+      {
+        "name": "input",
+        "type": "str",
+        "nargs": "?",
+        "help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
+        "required": false
+      },
+      {
+        "name": "--out",
+        "type": "str",
+        "help": "Path to the ASN.1 schema file",
+        "required": false
+      },
+      {
+        "name": "--struct",
+        "type": "str",
+        "help": "Deprecated: Path to the JSON Structure schema file (for backcompat)",
+        "required": false
+      },
+      {
+        "name": "--module",
+        "type": "str",
+        "help": "ASN.1 module name (defaults to the output file name)",
+        "required": false
+      }
+    ],
+    "suggested_output_file_path": "{input_file_name}.asn1",
+    "prompts": []
+  },
   {
     "command": "p2a",
     "description": "Convert Proto schema to Avrotize schema",
@@ -2575,7 +2666,8 @@
         "cbor_annotation": "args.cbor_annotation",
         "pascal_properties": "args.pascal_properties",
         "base_namespace": "args.namespace",
-        "openapi_generator_compat": "args.openapi_generator_compat"
+        "openapi_generator_compat": "args.openapi_generator_compat",
+        "target_framework": "args.target_framework"
       }
     },
     "extensions": [
@@ -2669,6 +2761,12 @@
         "help": "Generate OpenAPI Generator-compatible C# models with Option<T> optional properties and System.Text.Json converters",
         "default": false,
         "required": false
+      },
+      {
+        "name": "--target-framework",
+        "type": "str",
+        "help": "Target framework moniker written into the generated .csproj (e.g. net8.0). A ';'-separated value emits <TargetFrameworks> for multi-targeting. Defaults to net10.0.",
+        "required": false
       }
     ],
     "suggested_output_file_path": "{input_file_name}-cs",
@@ -2719,7 +2817,8 @@
         "pascal_properties": "args.pascal_properties",
         "base_namespace": "args.namespace",
         "project_name": "args.project_name",
-        "openapi_generator_compat": "args.openapi_generator_compat"
+        "openapi_generator_compat": "args.openapi_generator_compat",
+        "target_framework": "args.target_framework"
       }
     },
     "extensions": [
@@ -2799,6 +2898,12 @@
         "help": "Generate OpenAPI Generator-compatible C# models with Option<T> optional properties and System.Text.Json converters",
         "default": false,
         "required": false
+      },
+      {
+        "name": "--target-framework",
+        "type": "str",
+        "help": "Target framework moniker written into the generated .csproj (e.g. net8.0). A ';'-separated value emits <TargetFrameworks> for multi-targeting. Defaults to net10.0.",
+        "required": false
       }
     ],
     "suggested_output_file_path": "{input_file_name}-cs",

{structurize-3.7.3 → structurize-3.8.0}/avrotize/common.py

@@ -940,6 +940,47 @@ def render_template(template: str, output: str, **kvargs):
         f.write(out)
 
 
+def format_go_files(directory: str) -> bool:
+    """Run ``gofmt`` over every ``.go`` file under ``directory`` to produce
+    canonical, gofmt-clean output.
+
+    This normalizes indentation (tabs), sorts imports, aligns struct fields and
+    ``const`` blocks, fixes blank-line placement, and guarantees a trailing
+    newline at EOF -- everything the Go emitters cannot easily express in Jinja
+    templates. Struct-tag spacing is fixed in the templates instead, because
+    ``gofmt`` never rewrites the contents of raw string literals.
+
+    Best-effort: if the Go toolchain is not installed, the generated files are
+    left untouched and ``False`` is returned (the emitter still produced valid,
+    compilable Go).
+
+    Args:
+        directory (str): Directory containing generated ``.go`` files. ``gofmt``
+            processes it recursively.
+
+    Returns:
+        bool: ``True`` if ``gofmt`` (or ``go fmt``) ran, ``False`` otherwise.
+    """
+    import shutil
+    import subprocess
+    gofmt = shutil.which('gofmt')
+    try:
+        if gofmt:
+            subprocess.run(
+                [gofmt, '-w', directory], check=False,
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            return True
+        go = shutil.which('go')
+        if go:
+            subprocess.run(
+                [go, 'fmt', './...'], cwd=directory, check=False,
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            return True
+    except OSError:
+        return False
+    return False
+
+
 def get_longest_namespace_prefix(schema):
     """ Get the longest common prefix for the namespace of all types in the schema. """
     namespaces = set(collect_namespaces(schema))

{structurize-3.7.3 → structurize-3.8.0}/avrotize/dependencies/typescript/node22/package.json

@@ -9,7 +9,7 @@
   },
   "devDependencies": {
     "@types/node": "^26.0.0",
-    "typescript": "^6.0.2",
+    "typescript": "^7.0.2",
     "jest": "^30.2.0",
     "@types/jest": "^30.0.0"
   }