structurize 3.5.9__tar.gz → 3.5.11__tar.gz

{structurize-3.5.9/structurize.egg-info → structurize-3.5.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.5.9
+Version: 3.5.11
 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.5.9 → structurize-3.5.11}/avrotize/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.5.9'
-__version_tuple__ = version_tuple = (3, 5, 9)
+__version__ = version = '3.5.11'
+__version_tuple__ = version_tuple = (3, 5, 11)
 
-__commit_id__ = commit_id = 'gb097b347e'
+__commit_id__ = commit_id = 'g9e1128f35'

{structurize-3.5.9 → structurize-3.5.11}/avrotize/structuretocpp.py

@@ -295,8 +295,18 @@ class StructureToCpp:
             # Convert to C++ type
             field_type = self.convert_structure_type_to_cpp(class_name, field_name, prop_schema, schema_namespace, nullable=not is_required)
             
-            # Get source type
-            source_type = prop_schema.get('type', 'string') if isinstance(prop_schema, dict) and isinstance(prop_schema.get('type'), str) else 'object'
+            # Get source type - handle nullable unions like ["int64", "null"]
+            if isinstance(prop_schema, dict):
+                raw_type = prop_schema.get('type', 'string')
+                if isinstance(raw_type, str):
+                    source_type = raw_type
+                elif isinstance(raw_type, list):
+                    non_null_types = [t for t in raw_type if t != 'null']
+                    source_type = non_null_types[0] if len(non_null_types) == 1 and isinstance(non_null_types[0], str) else 'object'
+                else:
+                    source_type = 'object'
+            else:
+                source_type = 'object'
             all_field_info.append((field_name, prop_name, field_type, source_type))
             if source_type in ('int64', 'uint64', 'int128', 'uint128', 'decimal'):
                 string_json_fields.append((field_name, prop_name, field_type, source_type))

{structurize-3.5.9 → structurize-3.5.11}/avrotize/structuretogo.py

@@ -329,7 +329,15 @@ class StructureToGo:
             if not is_required and not field_type.startswith('*') and not field_type.startswith('[') and not field_type.startswith('map[') and field_type != 'interface{}':
                 field_type = f'*{field_type}'
             
-            source_type = prop_schema.get('type', 'string') if isinstance(prop_schema.get('type'), str) else 'object'
+            # Get source type - handle nullable unions like ["int64", "null"]
+            raw_type = prop_schema.get('type', 'string')
+            if isinstance(raw_type, str):
+                source_type = raw_type
+            elif isinstance(raw_type, list):
+                non_null_types = [t for t in raw_type if t != 'null']
+                source_type = non_null_types[0] if len(non_null_types) == 1 and isinstance(non_null_types[0], str) else 'object'
+            else:
+                source_type = 'object'
             fields.append({
                 'name': pascal(prop_name),
                 'type': field_type,

{structurize-3.5.9 → structurize-3.5.11}/avrotize/structuretojava.py

@@ -435,7 +435,15 @@ class StructureToJava:
                 prop_type = prop_type[:-1]
             const_value = self.format_const_value(const_val, prop_type)
         
-        source_type = prop_schema.get('type', 'string') if isinstance(prop_schema.get('type'), str) else 'object'
+        # Get source type - handle nullable unions like ["int64", "null"]
+        raw_type = prop_schema.get('type', 'string')
+        if isinstance(raw_type, str):
+            source_type = raw_type
+        elif isinstance(raw_type, list):
+            non_null_types = [t for t in raw_type if t != 'null']
+            source_type = non_null_types[0] if len(non_null_types) == 1 and isinstance(non_null_types[0], str) else 'object'
+        else:
+            source_type = 'object'
         return {
             'name': safe_field_name,
             'original_name': prop_name,

{structurize-3.5.9 → structurize-3.5.11}/avrotize/structuretopython.py

@@ -469,8 +469,16 @@ class StructureToPython:
         if not is_required and not prop_type.startswith('typing.Optional['):
             prop_type = f'typing.Optional[{prop_type}]'
 
-        # Get source type from structure schema
-        source_type = prop_schema.get('type', 'string') if isinstance(prop_schema.get('type'), str) else 'object'
+        # Get source type from structure schema - handle nullable unions like ["int64", "null"]
+        raw_type = prop_schema.get('type', 'string')
+        if isinstance(raw_type, str):
+            source_type = raw_type
+        elif isinstance(raw_type, list):
+            # Extract the non-null type from a nullable union
+            non_null_types = [t for t in raw_type if t != 'null']
+            source_type = non_null_types[0] if len(non_null_types) == 1 and isinstance(non_null_types[0], str) else 'object'
+        else:
+            source_type = 'object'
 
         return {
             'name': field_name,
@@ -489,17 +497,51 @@ class StructureToPython:
         field_docstring = f"{field_name} ({field_type})"
         return field_docstring
 
+    # Mapping of special characters to descriptive names for enum member
+    # identifiers.  Applied *before* the catch-all regex so that symbols
+    # like "5+" and "5-" produce distinct identifiers instead of both
+    # collapsing to "5_".
+    _CHAR_NAME_MAP = {
+        '+': '_PLUS',
+        '-': '_MINUS',
+        '*': '_STAR',
+        '/': '_SLASH',
+        '&': '_AMP',
+        '|': '_PIPE',
+        '!': '_BANG',
+        '?': '_QMARK',
+        '#': '_HASH',
+        '%': '_PCT',
+        '@': '_AT',
+        '^': '_CARET',
+        '~': '_TILDE',
+        '<': '_LT',
+        '>': '_GT',
+        '=': '_EQ',
+        '.': '_DOT',
+        ',': '_COMMA',
+        ':': '_COLON',
+        ';': '_SEMI',
+        '(': '_LPAREN',
+        ')': '_RPAREN',
+        '[': '_LBRACK',
+        ']': '_RBRACK',
+        '{': '_LBRACE',
+        '}': '_RBRACE',
+    }
+
     def _python_enum_member_name(self, value) -> str:
         """Derives a valid Python identifier for an enum member from a JSON
         Structure enum value.
 
         Numeric values (including negative integers) are prefixed with
         ``VALUE_`` (with negatives spelled ``VALUE_NEG_n``) so the generated
-        class body is valid Python. String values that aren't already valid
-        identifiers — e.g. they start with a digit or contain hyphens/spaces —
-        are coerced via ``pascal`` and prefixed with ``VALUE_`` if they still
-        don't start with a letter or underscore. Reserved words get a
-        trailing underscore.
+        class body is valid Python.  String values are sanitized by
+        replacing known special characters with descriptive names (e.g.
+        ``+`` → ``_PLUS``, ``-`` → ``_MINUS``) and then replacing any
+        remaining non-identifier characters with underscores.  Values that
+        start with a digit are prefixed with ``VALUE_``.  Reserved words
+        get a trailing underscore.
         """
         if isinstance(value, bool):
             return "TRUE_" if value else "FALSE_"
@@ -512,7 +554,18 @@ class StructureToPython:
                 token = str(value)
             return f"VALUE_{token}"
         text = str(value)
-        candidate = re.sub(r'[^0-9A-Za-z_]', '_', text)
+        # Replace known special characters with descriptive names
+        parts: list[str] = []
+        for ch in text:
+            if ch in self._CHAR_NAME_MAP:
+                parts.append(self._CHAR_NAME_MAP[ch])
+            else:
+                parts.append(ch)
+        candidate = ''.join(parts)
+        # Replace any remaining invalid identifier characters
+        candidate = re.sub(r'[^0-9A-Za-z_]', '_', candidate)
+        # Collapse runs of underscores and strip leading/trailing underscores
+        candidate = re.sub(r'_+', '_', candidate).strip('_')
         if not candidate or not (candidate[0].isalpha() or candidate[0] == '_'):
             candidate = f"VALUE_{candidate}" if candidate else "VALUE_"
         if is_python_reserved_word(candidate):
@@ -540,10 +593,22 @@ class StructureToPython:
         # Build (member_name, repr) pairs. ``repr`` is rendered verbatim into the
         # class body, so for numeric enums we emit the bare numeric literal and
         # for string enums a quoted Python string literal.
+        # Names that collide with each other or with generated methods are
+        # disambiguated with numeric suffixes.
         members: List[Tuple[str, str]] = []
         symbols: List[str] = []
+        # Pre-seed with names that would clash with generated Enum methods or
+        # Python Enum internals.
+        used_names: set[str] = {'from_ordinal', 'to_ordinal', 'mro', '_ignore_',
+                                '_generate_next_value_', '_missing_', '_order_'}
         for value in raw_values:
-            member_name = self._python_enum_member_name(value)
+            base_name = self._python_enum_member_name(value)
+            member_name = base_name
+            suffix = 2
+            while member_name in used_names:
+                member_name = f"{base_name}_{suffix}"
+                suffix += 1
+            used_names.add(member_name)
             if is_numeric:
                 value_repr = repr(value)
             else:

{structurize-3.5.9 → structurize-3.5.11}/avrotize/structuretorust.py

@@ -324,7 +324,15 @@ class StructureToRust:
             
             serde_rename = field_name != original_field_name
             
-            source_type = prop_schema.get('type', 'string') if isinstance(prop_schema.get('type'), str) else 'object'
+            # Get source type - handle nullable unions like ["int64", "null"]
+            raw_type = prop_schema.get('type', 'string')
+            if isinstance(raw_type, str):
+                source_type = raw_type
+            elif isinstance(raw_type, list):
+                non_null_types = [t for t in raw_type if t != 'null']
+                source_type = non_null_types[0] if len(non_null_types) == 1 and isinstance(non_null_types[0], str) else 'object'
+            else:
+                source_type = 'object'
             fields.append({
                 'original_name': original_field_name,
                 'name': field_name,

{structurize-3.5.9 → structurize-3.5.11}/avrotize/structuretots.py

@@ -342,7 +342,18 @@ class StructureToTypeScript:
                         is_enum = True
                         break
             
-            source_type = prop_schema.get('type', 'string') if isinstance(prop_schema, dict) and isinstance(prop_schema.get('type'), str) else 'object'
+            # Get source type - handle nullable unions like ["int64", "null"]
+            if isinstance(prop_schema, dict):
+                raw_type = prop_schema.get('type', 'string')
+                if isinstance(raw_type, str):
+                    source_type = raw_type
+                elif isinstance(raw_type, list):
+                    non_null_types = [t for t in raw_type if t != 'null']
+                    source_type = non_null_types[0] if len(non_null_types) == 1 and isinstance(non_null_types[0], str) else 'object'
+                else:
+                    source_type = 'object'
+            else:
+                source_type = 'object'
             fields.append({
                 'name': self.safe_name(prop_name),
                 'original_name': prop_name,

{structurize-3.5.9 → structurize-3.5.11/structurize.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.5.9
+Version: 3.5.11
 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