structurize 3.5.10__tar.gz → 3.5.12__tar.gz

{structurize-3.5.10/structurize.egg-info → structurize-3.5.12}/PKG-INFO

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.5.10'
-__version_tuple__ = version_tuple = (3, 5, 10)
+__version__ = version = '3.5.12'
+__version_tuple__ = version_tuple = (3, 5, 12)
 
-__commit_id__ = commit_id = 'g974039ac5'
+__commit_id__ = commit_id = 'g0eb0a7b9d'

{structurize-3.5.10 → structurize-3.5.12}/avrotize/avrotojsons.py

@@ -98,22 +98,34 @@ class AvroToJsonSchemaConverter:
                     json_type['type'] = 'integer'
                     json_type['format'] = 'int64'
                     return json_type
-                # Avrotize schema extensions: string-based logical types
-                elif base_type == 'string' and logical_type == 'date':
+                # Avrotize schema extensions: string-based logical types.
+                # The rfc3339-* family is the current emission; the bare reserved
+                # names on a string base are still recognized for backward compat.
+                elif base_type == 'string' and logical_type in ['date', 'rfc3339-date']:
                     # Avrotize extension: string with date logicalType
                     json_type['type'] = 'string'
                     json_type['format'] = 'date'
                     return json_type
-                elif base_type == 'string' and logical_type in ['timestamp-millis', 'timestamp-micros', 'datetime']:
+                elif base_type == 'string' and logical_type in [
+                        'timestamp-millis', 'timestamp-micros', 'datetime',
+                        'rfc3339-timestamp-millis', 'rfc3339-timestamp-micros',
+                        'rfc3339-local-timestamp-millis', 'rfc3339-local-timestamp-micros']:
                     # Avrotize extension: string with datetime logicalType
                     json_type['type'] = 'string'
                     json_type['format'] = 'date-time'
                     return json_type
-                elif base_type == 'string' and logical_type in ['time-millis', 'time-micros', 'time']:
+                elif base_type == 'string' and logical_type in [
+                        'time-millis', 'time-micros', 'time',
+                        'rfc3339-time-millis', 'rfc3339-time-micros']:
                     # Avrotize extension: string with time logicalType
                     json_type['type'] = 'string'
                     json_type['format'] = 'time'
                     return json_type
+                elif base_type == 'string' and logical_type in ['duration', 'rfc3339-duration']:
+                    # Avrotize extension: string with duration logicalType (RFC 3339)
+                    json_type['type'] = 'string'
+                    json_type['format'] = 'duration'
+                    return json_type
                 elif logical_type == 'decimal':
                     json_type['type'] = 'number'
                     return json_type

{structurize-3.5.10 → structurize-3.5.12}/avrotize/avrotojstruct.py

@@ -305,6 +305,16 @@ class AvroToJsonStructure:
             "timestamp-millis": {"type": "int64", "logicalType": "timestampMillis"},
             "date": {"type": "int32", "logicalType": "date"},
             "uuid": {"type": "string", "format": "uuid"},
+            # Avrotize Schema rfc3339-* string temporal family -> JSON Structure native
+            # temporal types (round-trips with jstructtoavro). See issue #335.
+            "rfc3339-date": {"type": "date"},
+            "rfc3339-time-millis": {"type": "time"},
+            "rfc3339-time-micros": {"type": "time"},
+            "rfc3339-timestamp-millis": {"type": "datetime"},
+            "rfc3339-timestamp-micros": {"type": "datetime"},
+            "rfc3339-local-timestamp-millis": {"type": "datetime"},
+            "rfc3339-local-timestamp-micros": {"type": "datetime"},
+            "rfc3339-duration": {"type": "duration"},
         }
         return mapping.get(logical_type, {"type": "string"})
 

{structurize-3.5.10 → structurize-3.5.12}/avrotize/avrotokusto.py

@@ -7,6 +7,16 @@ from avrotize.common import build_flat_type_dict, inline_avro_references, strip_
 from azure.kusto.data import KustoClient, KustoConnectionStringBuilder, ClientRequestProperties
 
 
+def kusto_string_literal(value: str) -> str:
+    """Return a KQL verbatim string literal for a raw Python string."""
+    return '@"' + value.replace('"', '""') + '"'
+
+
+def kusto_json_literal(value: Any) -> str:
+    """Return a KQL string literal containing one JSON encoding of value."""
+    return kusto_string_literal(json.dumps(value))
+
+
 class AvroToKusto:
     """Converts an Avro schema to a Kusto table schema."""
 
@@ -60,9 +70,9 @@ class AvroToKusto:
         if "doc" in recordschema:
             doc_data = recordschema["doc"]
             doc_data = (doc_data[:997] + "...") if len(doc_data) > 1000 else doc_data
-            doc_string = json.dumps(json.dumps({
+            doc_string = kusto_json_literal({
                 "description": doc_data
-            }))
+            })
             kusto.append(
                 f".alter table {table_ref} docstring {doc_string};")
             kusto.append("")
@@ -89,7 +99,7 @@ class AvroToKusto:
                             doc_content["schema"] = inline_schema
                     else:
                         doc_content["schema"] = inline_schema
-                doc = json.dumps(json.dumps(doc_content))
+                doc = kusto_json_literal(doc_content)
                 doc_string_statement.append(f"   [{column_name}]: {doc}")
         if doc_string_statement and emit_cloudevents_columns:
             doc_string_statement.extend([

{structurize-3.5.10 → structurize-3.5.12}/avrotize/avrotopython.py

@@ -90,6 +90,38 @@ class AvroToPython:
             return name + "_"
         return name
 
+    def safe_enum_symbols(self, symbols: List[str]) -> List[Dict[str, str]]:
+        """Converts Avro enum symbols to collision-safe Python enum members."""
+        enum_symbols = []
+        used_names = set()
+
+        for symbol in symbols:
+            if symbol.isidentifier() and not is_python_reserved_word(symbol):
+                member_name = symbol
+            else:
+                member_name = re.sub(r'[^0-9A-Za-z_]', '_', symbol).strip('_').upper()
+                if not member_name:
+                    member_name = "VALUE"
+                if member_name[0].isdigit():
+                    member_name = f"VALUE_{member_name}"
+                if is_python_reserved_word(symbol) or is_python_reserved_word(member_name.lower()) or is_python_reserved_word(member_name):
+                    member_name = f"{member_name}_"
+
+            base_member_name = member_name
+            suffix = 2
+            while member_name in used_names or not member_name.isidentifier() or is_python_reserved_word(member_name):
+                member_name = f"{base_member_name}_{suffix}"
+                suffix += 1
+
+            used_names.add(member_name)
+            enum_symbols.append({
+                'name': member_name,
+                'value': symbol,
+                'value_literal': repr(symbol)
+            })
+
+        return enum_symbols
+
     def pascal_type_name(self, ref: str) -> str:
         """Converts a reference to a type name"""
         return '_'.join([pascal(part) for part in ref.split('.')[-1].split('_')])
@@ -350,9 +382,12 @@ class AvroToPython:
         if python_qualified_name in self.generated_types:
             return python_qualified_name
 
-        symbols = [symbol if not is_python_reserved_word(
-            symbol) else symbol + "_" for symbol in avro_schema.get('symbols', [])]
-        ordinals =  avro_schema.get('ordinals', {})
+        symbols = self.safe_enum_symbols(avro_schema.get('symbols', []))
+        symbol_names_by_value = {symbol['value']: symbol['name'] for symbol in symbols}
+        ordinals = {
+            symbol_names_by_value[symbol]: ordinal
+            for symbol, ordinal in avro_schema.get('ordinals', {}).items()
+        }
 
         enum_definition = process_template(
             "avrotopython/enum_core.jinja",

{structurize-3.5.10 → structurize-3.5.12}/avrotize/avrotots.py

@@ -16,7 +16,6 @@ def is_typescript_reserved_word(word: str) -> bool:
         'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'return',
         'super', 'switch', 'this', 'throw', 'try', 'typeof', 'var', 'void',
         'while', 'with', 'yield', 'enum', 'string', 'number', 'boolean', 'symbol',
-        'type', 'namespace', 'module', 'declare', 'abstract', 'readonly',
     ]
     return word in reserved_words
 
@@ -32,6 +31,7 @@ class AvroToTypeScript:
         self.src_dir = os.path.join(self.output_dir, "src")
         self.generated_types: Dict[str, str] = {}
         self.generated_type_fields: Dict[str, List[Dict]] = {}  # Store fields for test generation
+        self.generated_type_imports: Dict[str, List[str]] = {}  # Store import type FQNs for test generation
         self.main_schema = None
         self.type_dict = None
         self.INDENT = ' ' * 4
@@ -207,6 +207,10 @@ class AvroToTypeScript:
             self.write_to_file(namespace, class_name, class_definition)
         self.generated_types[ts_qualified_name] = 'class'
         self.generated_type_fields[ts_qualified_name] = fields  # Store fields for test generation
+        # Store the fully-qualified import names so generated test files can resolve
+        # sub-namespaced types (e.g. enums placed in a "<Record>_types" namespace)
+        # to their real source path instead of a flattened, non-existent one.
+        self.generated_type_imports[ts_qualified_name] = sorted(import_types)
         return ts_qualified_name
 
     def generate_enum(self, avro_schema: Dict, parent_namespace: str, write_file: bool = True) -> str:
@@ -670,17 +674,29 @@ class AvroToTypeScript:
         
         fields = self.generated_type_fields.get(qualified_name, [])
         
-        # Build imports for nested types
+        # Build imports for nested types. Reuse the fully-qualified import names
+        # captured during class generation so that types living in sub-namespaces
+        # (e.g. enums placed in a "<Record>_types" namespace) resolve to their real
+        # source path instead of a flattened, non-existent one (issue #338).
         imports_with_paths: Dict[str, str] = {}
+        import_fqns = self.generated_type_imports.get(qualified_name, [])
+        path_by_leaf: Dict[str, str] = {}
+        for fqn in import_fqns:
+            fqn_parts = fqn.split('.')
+            leaf = pascal(fqn_parts[-1])
+            path_by_leaf[leaf] = '../src/' + '/'.join(fqn_parts) + '.js'
         for field in fields:
             field_type = field.get('type_no_null', '')
             if not self.is_typescript_primitive(field_type.replace('[]', '')):
                 # It's a reference type, need to import it
                 type_name = field_type.replace('[]', '').replace('?', '')
                 if type_name and type_name not in ['null', 'any', 'Date']:
-                    # Build relative path from test dir to src dir
-                    src_path = '/'.join(parts)
-                    imports_with_paths[type_name] = f'../src/{src_path.rsplit("/", 1)[0]}/{type_name}.js' if '/' in src_path else f'../src/{parts[0]}/{type_name}.js'
+                    if type_name in path_by_leaf:
+                        imports_with_paths[type_name] = path_by_leaf[type_name]
+                    else:
+                        # Fallback: best-effort path relative to the class namespace
+                        src_path = '/'.join(parts)
+                        imports_with_paths[type_name] = f'../src/{src_path.rsplit("/", 1)[0]}/{type_name}.js' if '/' in src_path else f'../src/{parts[0]}/{type_name}.js'
         
         # Calculate relative path from test directory to class file
         class_path_parts = namespace.split('.') if namespace else []

{structurize-3.5.10 → structurize-3.5.12}/avrotize/avrovalidator.py

@@ -414,6 +414,33 @@ class AvroValidator:
         """
         base_type = schema.get('type')
 
+        # Avrotize Schema rfc3339-* string temporal family (issue #335). These are
+        # valid standard Avro because rfc3339-* is not a reserved Avro logical type;
+        # the value is an RFC 3339 textual string on a string base.
+        if isinstance(logical_type, str) and logical_type.startswith('rfc3339-'):
+            if base_type != 'string':
+                raise AvroValidationError(
+                    f"{logical_type} logical type requires string base type", path)
+            if not isinstance(instance, str):
+                raise AvroValidationError(
+                    f"Expected string for {logical_type}, got {type(instance).__name__}", path)
+            core = logical_type[len('rfc3339-'):]
+            if core == 'date':
+                pattern = self.DATE_PATTERN
+            elif core in ('time-millis', 'time-micros'):
+                pattern = self.TIME_PATTERN
+            elif core in ('timestamp-millis', 'timestamp-micros',
+                          'local-timestamp-millis', 'local-timestamp-micros'):
+                pattern = self.DATETIME_PATTERN
+            elif core == 'duration':
+                pattern = self.DURATION_PATTERN
+            else:
+                pattern = None
+            if pattern is not None and not pattern.match(instance):
+                raise AvroValidationError(
+                    f"Invalid {logical_type} format: {instance}", path)
+            return
+
         if logical_type == 'decimal':
             self._validate_decimal(instance, schema, path)
 

{structurize-3.5.10 → structurize-3.5.12}/avrotize/jsonstoavro.py

@@ -591,14 +591,16 @@ class JsonToAvroConverter:
 
         # if you've got { 'type': 'string', 'format': ['date-time', 'duration'] }, I'm sorry
         if format and isinstance(format, str):
-            if format in ('date-time', 'date'):
+            if format == 'date-time':
+                avro_primitive = {'type': 'long', 'logicalType': 'timestamp-millis'}
+            elif format == 'date':
                 avro_primitive = {'type': 'int', 'logicalType': 'date'}
-            elif format in ('time'):
+            elif format == 'time':
                 avro_primitive = {'type': 'int', 'logicalType': 'time-millis'}
-            elif format in ('duration'):
+            elif format == 'duration':
                 avro_primitive = {'type': 'fixed',
                                   'size': 12, 'logicalType': 'duration'}
-            elif format in ('uuid'):
+            elif format == 'uuid':
                 avro_primitive = {'type': 'string', 'logicalType': 'uuid'}
 
         return avro_primitive
@@ -1357,7 +1359,14 @@ class JsonToAvroConverter:
         if isinstance(avro_type, dict) and 'type' in avro_type and (isinstance(avro_type, list) or not avro_type['type'] in ['array', 'map', 'record', 'enum', 'fixed']):
             if 'dependencies' in avro_type:
                 dependencies.extend(avro_type['dependencies'])
-            avro_type = avro_type['type']
+            # Preserve logical-type annotations (e.g. timestamp-millis, date,
+            # time-millis, uuid). Collapsing these to the bare base type would
+            # silently discard the logical meaning (and, for date-time, the
+            # required 64-bit width). See issue #337.
+            if 'logicalType' in avro_type:
+                avro_type = {k: v for k, v in avro_type.items() if k != 'dependencies'}
+            else:
+                avro_type = avro_type['type']
         return avro_type
 
     def register_type(self, avro_schema, avro_type) -> bool:
@@ -1733,8 +1742,9 @@ class JsonToAvroConverter:
                             # None type is a problem
                             raise ValueError(
                                 f"avro_field_type is None for field {field_name}")
-                        if isinstance(avro_field_type, dict) and 'type' in avro_field_type and not self.is_avro_complex_type(avro_field_type):
+                        if isinstance(avro_field_type, dict) and 'type' in avro_field_type and 'logicalType' not in avro_field_type and not self.is_avro_complex_type(avro_field_type):
                             # if the field type is a basic type, inline it
+                            # (logical types are kept intact, see issue #337)
                             avro_field_type = avro_field_type['type']
                         field_type_list.append(avro_field_type)
                         field_ref_type_list.append(avro_field_ref_type)

{structurize-3.5.10 → structurize-3.5.12}/avrotize/jstructtoavro.py

@@ -20,6 +20,8 @@ class JsonStructureToAvro:
         """Initialize the converter."""
         self.structure_doc: Optional[Dict[str, Any]] = None
         self.converted_types: Dict[str, Dict[str, Any]] = {}
+        self._anon_object_counter: int = 0
+        self._generated_record_names: set = set()
         
     def convert(self, structure_schema: Dict[str, Any]) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
         """
@@ -33,6 +35,8 @@ class JsonStructureToAvro:
         """
         self.structure_doc = structure_schema
         self.converted_types.clear()
+        self._anon_object_counter = 0
+        self._generated_record_names = set()
         
         # Check if this is an inline type (type at root) or uses $root
         root_ref = structure_schema.get('$root')
@@ -386,7 +390,7 @@ class JsonStructureToAvro:
         for prop_name, prop_schema in properties.items():
             field = {
                 'name': prop_name,
-                'type': self._convert_type_reference(prop_schema)
+                'type': self._convert_type_reference(prop_schema, name_hint=prop_name)
             }
             
             # Build documentation with annotations
@@ -678,13 +682,55 @@ class JsonStructureToAvro:
         
         return avro_record
     
-    def _convert_type_reference(self, schema: Union[Dict[str, Any], str]) -> Union[str, Dict[str, Any], List]:
+    def _convert_union_member(self, member: Union[Dict[str, Any], str]) -> Union[str, Dict[str, Any], List]:
+        """Convert a single member of a JSON Structure union type.
+
+        Members are usually primitive type names, but a union may also list the
+        loose container names ``"object"`` and ``"array"`` (open, untyped). A
+        bare ``"object"``/``"array"`` is not a valid Avro type, so map them to
+        their canonical open Avro forms (string-valued map / string-element
+        array), consistent with how inline open objects are handled (#336).
+        """
+        if isinstance(member, str):
+            if member == 'object':
+                return {'type': 'map', 'values': 'string'}
+            if member == 'array':
+                return {'type': 'array', 'items': 'string'}
+            return self._map_primitive_type(member)
+        return self._convert_type_reference(member)
+
+    def _anonymous_object_name(self, name_hint: Optional[str]) -> str:
+        """Generate a valid, unique Avro record name for an inline object.
+
+        Prefers a name derived from the enclosing property (``name_hint``) so
+        that output is readable and round-trips sensibly; falls back to a
+        monotonically increasing generated name. A uniqueness suffix is added
+        when the same hint occurs more than once (e.g. like-named properties at
+        different nesting levels) to avoid Avro name redefinition errors.
+        """
+        if name_hint:
+            candidate = f"{name_hint[0].upper() + name_hint[1:]}Type"
+        else:
+            self._anon_object_counter += 1
+            candidate = f"AnonymousObject{self._anon_object_counter}"
+        unique = candidate
+        suffix = 2
+        while unique in self._generated_record_names:
+            unique = f"{candidate}_{suffix}"
+            suffix += 1
+        self._generated_record_names.add(unique)
+        return unique
+
+    def _convert_type_reference(self, schema: Union[Dict[str, Any], str], name_hint: Optional[str] = None) -> Union[str, Dict[str, Any], List]:
         """
         Convert a type reference or inline type definition.
         
         Args:
             schema: Type schema or reference
-            
+            name_hint: Optional name to use when an inline object must be
+                materialized as a named Avro record (e.g. the enclosing
+                property name). Falls back to a generated unique name.
+        
         Returns:
             Avro type (string, dict, or list for union)
         """
@@ -712,7 +758,7 @@ class JsonStructureToAvro:
         
         # Handle union types (type is an array like ["string", "null"])
         if isinstance(type_value, list):
-            return [self._map_primitive_type(t) if isinstance(t, str) else self._convert_type_reference(t) for t in type_value]
+            return [self._convert_union_member(t) for t in type_value]
         
         # Handle choice types
         if type_value == 'choice':
@@ -744,7 +790,7 @@ class JsonStructureToAvro:
         if type_value == 'array':
             return {
                 'type': 'array',
-                'items': self._convert_type_reference(schema['items'])
+                'items': self._convert_type_reference(schema['items'], name_hint=name_hint)
             }
         
         if type_value == 'map':
@@ -753,6 +799,31 @@ class JsonStructureToAvro:
                 'values': self._convert_type_reference(schema['values'])
             }
         
+        # Handle object types appearing inline (i.e. not as a named $root or
+        # definition). Without this, an inline {"type": "object"} fell through
+        # to _map_primitive_type and emitted a bare "object", which is not a
+        # valid Avro type. See issue #336.
+        if type_value == 'object':
+            properties = schema.get('properties')
+            if properties:
+                # Object with a defined shape -> nested Avro record.
+                obj_name = schema.get('name') or self._anonymous_object_name(name_hint)
+                return self._convert_object(schema, None, obj_name)
+            # Open / property-less object -> Avro map. Honor an
+            # additionalProperties value type when specified, otherwise default
+            # to string (an open object carries arbitrary string-keyed values).
+            additional = schema.get('additionalProperties')
+            if isinstance(additional, dict):
+                values_type: Union[str, Dict[str, Any], List] = self._convert_type_reference(additional)
+            elif isinstance(additional, str):
+                values_type = self._map_primitive_type(additional)
+            else:
+                values_type = 'string'
+            return {
+                'type': 'map',
+                'values': values_type
+            }
+        
         # Handle logical types
         logical_type = schema.get('logicalType')
         if logical_type:
@@ -767,8 +838,13 @@ class JsonStructureToAvro:
     def _map_primitive_type(self, struct_type: str) -> Union[str, Dict[str, Any]]:
         """Map JSON Structure primitive type to Avro primitive type.
         
-        For temporal types, returns Avrotize Schema format with string base type 
-        and logical type annotation (RFC 3339 format).
+        For temporal types, returns Avrotize Schema format with a string base type
+        and an ``rfc3339-*`` logical-type annotation carrying the RFC 3339 textual
+        value. The ``rfc3339-*`` names are NOT reserved Avro logical types, so strict
+        Avro parsers ignore the annotation and treat the value as a plain string,
+        which keeps the emitted schema valid *standard* Avro (see issue #335) while
+        Avrotize-aware tools still recognize the temporal semantics.
+        See specs/avrotize-schema.md (Logical Types).
         """
         # Simple types without logical type annotation
         simple_type_mapping = {
@@ -802,13 +878,16 @@ class JsonStructureToAvro:
             'jsonpointer': 'string',
         }
         
-        # Temporal types with Avrotize Schema string-based logical types (RFC 3339 format)
+        # Temporal types use the rfc3339-* string-based logical-type family so the
+        # output is valid *standard* Avro (rfc3339-* are not reserved Avro logical
+        # types, so strict parsers fall back to the string base) while preserving the
+        # RFC 3339 textual representation. See issue #335 and specs/avrotize-schema.md.
         temporal_type_mapping = {
-            'date': {'type': 'string', 'logicalType': 'date'},  # RFC 3339 full-date
-            'datetime': {'type': 'string', 'logicalType': 'timestamp-millis'},  # RFC 3339 date-time
-            'time': {'type': 'string', 'logicalType': 'time-millis'},  # RFC 3339 partial-time
-            'duration': {'type': 'string', 'logicalType': 'duration'},  # RFC 3339 duration
-            'timestamp': {'type': 'string', 'logicalType': 'timestamp-millis'},  # RFC 3339 date-time
+            'date': {'type': 'string', 'logicalType': 'rfc3339-date'},  # RFC 3339 full-date
+            'datetime': {'type': 'string', 'logicalType': 'rfc3339-timestamp-millis'},  # RFC 3339 date-time
+            'time': {'type': 'string', 'logicalType': 'rfc3339-time-millis'},  # RFC 3339 partial-time
+            'duration': {'type': 'string', 'logicalType': 'rfc3339-duration'},  # RFC 3339 duration
+            'timestamp': {'type': 'string', 'logicalType': 'rfc3339-timestamp-millis'},  # RFC 3339 date-time
         }
         
         # Special types with logical type annotation
@@ -831,29 +910,31 @@ class JsonStructureToAvro:
     def _map_logical_type(self, logical_type: str, base_type: Optional[str]) -> Dict[str, Any]:
         """Map JSON Structure logical type to Avro/Avrotize logical type.
         
-        Uses Avrotize Schema extensions for string-based temporal types (RFC 3339 format).
+        Temporal logical types map to the rfc3339-* string-based family so the output
+        is valid standard Avro (see issue #335 and specs/avrotize-schema.md).
         """
-        # Avrotize Schema: temporal types on string (RFC 3339 format)
+        # Avrotize Schema: temporal types on string carrying RFC 3339 text, using the
+        # rfc3339-* logical-type family (not reserved Avro names -> valid standard Avro).
         logical_mapping = {
             # Timestamps
-            'timestampMicros': {'type': 'string', 'logicalType': 'timestamp-micros'},
-            'timestampMillis': {'type': 'string', 'logicalType': 'timestamp-millis'},
-            'timestamp-micros': {'type': 'string', 'logicalType': 'timestamp-micros'},
-            'timestamp-millis': {'type': 'string', 'logicalType': 'timestamp-millis'},
+            'timestampMicros': {'type': 'string', 'logicalType': 'rfc3339-timestamp-micros'},
+            'timestampMillis': {'type': 'string', 'logicalType': 'rfc3339-timestamp-millis'},
+            'timestamp-micros': {'type': 'string', 'logicalType': 'rfc3339-timestamp-micros'},
+            'timestamp-millis': {'type': 'string', 'logicalType': 'rfc3339-timestamp-millis'},
             # Local timestamps (no timezone)
-            'localTimestampMicros': {'type': 'string', 'logicalType': 'local-timestamp-micros'},
-            'localTimestampMillis': {'type': 'string', 'logicalType': 'local-timestamp-millis'},
-            'local-timestamp-micros': {'type': 'string', 'logicalType': 'local-timestamp-micros'},
-            'local-timestamp-millis': {'type': 'string', 'logicalType': 'local-timestamp-millis'},
+            'localTimestampMicros': {'type': 'string', 'logicalType': 'rfc3339-local-timestamp-micros'},
+            'localTimestampMillis': {'type': 'string', 'logicalType': 'rfc3339-local-timestamp-millis'},
+            'local-timestamp-micros': {'type': 'string', 'logicalType': 'rfc3339-local-timestamp-micros'},
+            'local-timestamp-millis': {'type': 'string', 'logicalType': 'rfc3339-local-timestamp-millis'},
             # Date and time
-            'date': {'type': 'string', 'logicalType': 'date'},
-            'time-millis': {'type': 'string', 'logicalType': 'time-millis'},
-            'time-micros': {'type': 'string', 'logicalType': 'time-micros'},
-            'timeMillis': {'type': 'string', 'logicalType': 'time-millis'},
-            'timeMicros': {'type': 'string', 'logicalType': 'time-micros'},
+            'date': {'type': 'string', 'logicalType': 'rfc3339-date'},
+            'time-millis': {'type': 'string', 'logicalType': 'rfc3339-time-millis'},
+            'time-micros': {'type': 'string', 'logicalType': 'rfc3339-time-micros'},
+            'timeMillis': {'type': 'string', 'logicalType': 'rfc3339-time-millis'},
+            'timeMicros': {'type': 'string', 'logicalType': 'rfc3339-time-micros'},
             # Duration
-            'duration': {'type': 'string', 'logicalType': 'duration'},
-            # UUID
+            'duration': {'type': 'string', 'logicalType': 'rfc3339-duration'},
+            # UUID (valid standard Avro on a string base)
             'uuid': {'type': 'string', 'logicalType': 'uuid'},
             # Decimal (Avrotize extension: on string)
             'decimal': {'type': 'string', 'logicalType': 'decimal'},

{structurize-3.5.10 → structurize-3.5.12}/avrotize/structuretokusto.py

@@ -7,6 +7,16 @@ from avrotize.common import build_flat_type_dict, inline_avro_references, strip_
 from azure.kusto.data import KustoClient, KustoConnectionStringBuilder, ClientRequestProperties
 
 
+def kusto_string_literal(value: str) -> str:
+    """Return a KQL verbatim string literal for a raw Python string."""
+    return '@"' + value.replace('"', '""') + '"'
+
+
+def kusto_json_literal(value: Any) -> str:
+    """Return a KQL string literal containing one JSON encoding of value."""
+    return kusto_string_literal(json.dumps(value))
+
+
 class StructureToKusto:
     """Converts a JSON Structure schema to a Kusto table schema."""
 
@@ -284,9 +294,9 @@ class StructureToKusto:
             if notes:
                 doc_data = doc_data + " " + " ".join(notes)
             
-            doc_string = json.dumps(json.dumps({
+            doc_string = kusto_json_literal({
                 "description": doc_data
-            }))
+            })
             kusto.append(
                 f".alter table {table_ref} docstring {doc_string};")
             kusto.append("")
@@ -304,7 +314,7 @@ class StructureToKusto:
                 else:
                     doc_data = f"Constant field with value: {json.dumps(const_value)}"
                 doc_content = {"description": doc_data}
-                doc = json.dumps(json.dumps(doc_content))
+                doc = kusto_json_literal(doc_content)
                 # Add as comment - const fields are not stored in table
                 kusto.insert(len(kusto) - (2 if kusto and kusto[-1] == "" else 1), 
                            f"-- Const field '{column_name}' with value: {json.dumps(const_value)}")
@@ -323,7 +333,7 @@ class StructureToKusto:
                         doc_content["schema"] = '{ "doc": "Schema too large to inline. Please refer to the JSON Structure schema for more details." }'
                     else:
                         doc_content["schema"] = prop_schema
-                doc = json.dumps(json.dumps(doc_content))
+                doc = kusto_json_literal(doc_content)
                 doc_string_statement.append(f"   [{column_name}]: {doc}")
         if doc_string_statement and emit_cloudevents_columns:
             doc_string_statement.extend([

{structurize-3.5.10 → structurize-3.5.12}/avrotize/structuretopython.py

@@ -497,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_"
@@ -520,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):
@@ -548,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.10 → structurize-3.5.12/structurize.egg-info}/PKG-INFO

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