structurize 3.7.4__tar.gz → 3.9.0__tar.gz

{structurize-3.7.4/structurize.egg-info → structurize-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.7.4
+Version: 3.9.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.4 → structurize-3.9.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.4 → structurize-3.9.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.4'
-__version_tuple__ = version_tuple = (3, 7, 4)
+__version__ = version = '3.9.0'
+__version_tuple__ = version_tuple = (3, 9, 0)
 
-__commit_id__ = commit_id = 'gd6893c97b'
+__commit_id__ = commit_id = 'g20391dedb'

structurize-3.9.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.4 → structurize-3.9.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.4 → structurize-3.9.0}/avrotize/avrotogo.py

@@ -1,7 +1,8 @@
 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, xml_wire_name, xml_enum_wire_value)
 
 INDENT = '    '
 
@@ -26,6 +27,7 @@ class AvroToGo:
         self.referenced_packages_stack: List[Dict[str, Set[str]]] = []
         self.avro_annotation = False
         self.json_annotation = False
+        self.xml_annotation = False
         self.longest_common_prefix = ''
         self.package_site = 'github.com'
         self.package_username = 'username'
@@ -33,10 +35,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"""
@@ -117,9 +128,8 @@ class AvroToGo:
                 return f"[]{item_type}"
             elif avro_type['type'] == 'map':
                 values_type = self.convert_avro_type_to_go(field_name, avro_type['values'], nullable=True, parent_namespace=parent_namespace)
-                if values_type.startswith('*'): 
-                    return f"map[string]{values_type}"
-                return f"map[string]{values_type}"
+                map_type = f"map[string]{values_type}"
+                return f"XMLMap[{values_type}]" if self.xml_annotation else map_type
             elif 'logicalType' in avro_type:
                 if avro_type['logicalType'] == 'date':
                     return 'time.Time'
@@ -162,11 +172,20 @@ class AvroToGo:
         self.generated_types_avro_namespace[avro_fullname] = "struct"
         self.generated_types_go_package[go_struct_name] = "struct"
 
-        fields = [{
-            'name': pascal(field['name']),
-            'type': self.convert_avro_type_to_go(field['name'], field['type'], parent_namespace=namespace),
-            'original_name': field['name']
-        } for field in avro_schema.get('fields', [])]
+        fields = []
+        for field in avro_schema.get('fields', []):
+            field_type = self.convert_avro_type_to_go(field['name'], field['type'], parent_namespace=namespace)
+            raw_type = field['type']
+            fields.append({
+                'name': pascal(field['name']),
+                'type': field_type,
+                'original_name': field['name'],
+                'xml_name': xml_wire_name(field['name'], field),
+                'xml_kind': field.get('xmlkind', 'element'),
+                'xml_required': not (isinstance(raw_type, list) and 'null' in raw_type) and not (isinstance(raw_type, dict) and raw_type.get('type') in ('array', 'map')),
+                'xml_repeated': isinstance(raw_type, dict) and raw_type.get('type') == 'array',
+                'xml_ambiguous': field_type.lstrip('*') == 'interface{}',
+            })
 
         # Collect imports from field types
         go_types = [f['type'] for f in fields]
@@ -178,6 +197,10 @@ class AvroToGo:
             'fields': fields,
             'avro_schema': json.dumps(avro_schema),
             'json_annotation': self.json_annotation,
+            'xml_annotation': self.xml_annotation,
+            'xml_name': xml_wire_name(avro_schema['name'], avro_schema),
+            'xml_namespace': avro_schema.get('xmlns', ''),
+            'needs_xml_name': bool(avro_schema.get('xmlns')) or xml_wire_name(avro_schema['name'], avro_schema) != go_struct_name,
             'avro_annotation': self.avro_annotation,
             'json_match_predicates': [self.get_is_json_match_clause(f['name'], f['type']) for f in fields],
             'base_package': self.base_package,
@@ -214,9 +237,14 @@ class AvroToGo:
         context = {
             'doc': avro_schema.get('doc', ''),
             'struct_name': enum_name,
-            'symbols': avro_schema.get('symbols', []),
+            'symbols': [
+                {'name': symbol, 'xml_value': xml_enum_wire_value(symbol, avro_schema)}
+                for symbol in avro_schema.get('symbols', [])
+            ],
             'imports': imports,
             'base_package': self.base_package,
+            'xml_annotation': self.xml_annotation,
+            'string_enum': self.avro_annotation,
             'referenced_packages': self.referenced_packages.keys()
         }
 
@@ -229,9 +257,10 @@ class AvroToGo:
         self.enums.append({
             'name': enum_name,
             'symbols': avro_schema.get('symbols', []),
+            'string_enum': self.avro_annotation,
         })
 
-        self.generate_unit_test('enum', enum_name, context['symbols'])
+        self.generate_unit_test('enum', enum_name, avro_schema.get('symbols', []))
 
         return enum_name
 
@@ -247,6 +276,7 @@ class AvroToGo:
             'union_class_name': union_class_name,
             'union_types': union_types,
             'json_annotation': self.json_annotation,
+            'xml_annotation': self.xml_annotation,
             'avro_annotation': self.avro_annotation,
             'get_is_json_match_clause': self.get_is_json_match_clause,
             'base_package': self.base_package,
@@ -294,14 +324,14 @@ class AvroToGo:
             return f"if _, ok := node[\"{field_name}\"].([]byte); !ok {{ return false }}"
         elif field_type == 'interface{}':
             return f"if _, ok := node[\"{field_name}\"].(interface{{}}); !ok {{ return false }}"
-        elif field_type.startswith('map[string]'):
+        elif field_type.startswith('map[string]') or field_type.startswith('XMLMap['):
             return f"if _, ok := node[\"{field_name}\"].(map[string]interface{{}}); !ok {{ return false }}"
         elif field_type.startswith('[]'):
             return f"if _, ok := node[\"{field_name}\"].([]interface{{}}); !ok {{ return false }}"
         elif field_type in self.generated_types_go_package:
             return f"if _, ok := node[\"{field_name}\"].({field_type}); !ok {{ return false }}"
         else:
-            return f"if _, ok := node[\"{field_name}\"].(map[string.interface{{}}); !ok {{ return false }}"
+            return f"if _, ok := node[\"{field_name}\"].(map[string]interface{{}}); !ok {{ return false }}"
 
     def get_imports_for_definition(self, types: List[str]) -> Set[str]:
         """Collects necessary imports for the Go definition based on the Go types"""
@@ -393,6 +423,7 @@ class AvroToGo:
             'package_site': self.package_site,
             'package_username': self.package_username,
             'json_annotation': self.json_annotation,
+            'xml_annotation': self.xml_annotation,
             'avro_annotation': self.avro_annotation
         }
 
@@ -418,6 +449,15 @@ class AvroToGo:
         self.write_go_mod_file()
         self.write_modname_go_file()
         self.generate_helpers()
+        self.write_xml_helpers()
+        format_go_files(self.output_dir)
+
+    def write_xml_helpers(self) -> None:
+        """Write generic XML support for map fields."""
+        if not self.xml_annotation:
+            return
+        helper_path = os.path.join(self.output_dir, 'pkg', self.base_package, 'xml_helpers.go')
+        render_template('avrotogo/xml_helpers.jinja', helper_path, base_package=self.base_package)
 
     def write_go_mod_file(self):
         """Writes the go.mod file for the Go project"""
@@ -453,7 +493,7 @@ class AvroToGo:
         self.convert_schema(schema, output_dir)
 
 
-def convert_avro_to_go(avro_schema_path, go_file_path, package_name='', avro_annotation=False, json_annotation=False, package_site='github.com', package_username='username'):
+def convert_avro_to_go(avro_schema_path, go_file_path, package_name='', avro_annotation=False, json_annotation=False, xml_annotation=False, package_site='github.com', package_username='username'):
     """Converts Avro schema to Go structs
 
     Args:
@@ -462,6 +502,7 @@ def convert_avro_to_go(avro_schema_path, go_file_path, package_name='', avro_ann
         package_name (str): Base package name
         avro_annotation (bool): Include Avro annotations
         json_annotation (bool): Include JSON annotations
+        xml_annotation (bool): Include XML annotations and serialization
     """
     if not package_name:
         package_name = os.path.splitext(os.path.basename(avro_schema_path))[0]
@@ -469,12 +510,13 @@ def convert_avro_to_go(avro_schema_path, go_file_path, package_name='', avro_ann
     avrotogo = AvroToGo(package_name)
     avrotogo.avro_annotation = avro_annotation
     avrotogo.json_annotation = json_annotation
+    avrotogo.xml_annotation = xml_annotation
     avrotogo.package_site = package_site if package_site else 'github.com'
     avrotogo.package_username = package_username if package_username else 'username'
     avrotogo.convert(avro_schema_path, go_file_path)
 
 
-def convert_avro_schema_to_go(avro_schema: JsonNode, output_dir: str, package_name='', avro_annotation=False, json_annotation=False, package_site='github.com', package_username='username'):
+def convert_avro_schema_to_go(avro_schema: JsonNode, output_dir: str, package_name='', avro_annotation=False, json_annotation=False, xml_annotation=False, package_site='github.com', package_username='username'):
     """Converts Avro schema to Go structs
 
     Args:
@@ -483,10 +525,12 @@ def convert_avro_schema_to_go(avro_schema: JsonNode, output_dir: str, package_na
         package_name (str): Base package name
         avro_annotation (bool): Include Avro annotations
         json_annotation (bool): Include JSON annotations
+        xml_annotation (bool): Include XML annotations and serialization
     """
     avrotogo = AvroToGo(package_name)
     avrotogo.avro_annotation = avro_annotation
     avrotogo.json_annotation = json_annotation
+    avrotogo.xml_annotation = xml_annotation
     avrotogo.package_site = package_site if package_site else 'github.com'
     avrotogo.package_username = package_username if package_username else 'username'
     avrotogo.convert_schema(avro_schema, output_dir)