structurize 3.2.0__tar.gz → 3.2.2__tar.gz

{structurize-3.2.0/structurize.egg-info → structurize-3.2.2}/PKG-INFO

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

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '3.2.0'
-__version_tuple__ = version_tuple = (3, 2, 0)
+__version__ = version = '3.2.2'
+__version_tuple__ = version_tuple = (3, 2, 2)
 
-__commit_id__ = commit_id = 'gb9324402c'
+__commit_id__ = commit_id = 'g4fc2eb920'

{structurize-3.2.0 → structurize-3.2.2}/avrotize/schema_inference.py

@@ -648,6 +648,22 @@ class JsonStructureSchemaInferrer(SchemaInferrer):
         if python_value is None:
             return "null"
 
+        # Handle integers with proper range detection
+        # bool is subclass of int in Python, so check bool first
+        if isinstance(python_value, bool):
+            return "boolean"
+        
+        if isinstance(python_value, int):
+            # Check if value fits in int32 range
+            if -2147483648 <= python_value <= 2147483647:
+                return "integer"  # int32 alias
+            else:
+                # Per JSON Structure spec, int64 values are string-encoded
+                # Since we're inferring from JSON native numbers (which can't exceed
+                # double precision ~2^53), use 'double' for large integers from JSON
+                # This allows validation of the source data as-is
+                return "double"
+
         if isinstance(python_value, dict):
             # Generate an object type
             safe_name = avro_name(type_name.rsplit('.', 1)[-1])
@@ -691,7 +707,16 @@ class JsonStructureSchemaInferrer(SchemaInferrer):
                     items = item_types[0]
                 else:
                     # Use choice for multiple item types
-                    items = {"type": "choice", "choices": item_types}
+                    # choices must be a map with type names as keys
+                    choices_map: Dict[str, Any] = {}
+                    for it in item_types:
+                        if isinstance(it, str):
+                            choices_map[it] = {"type": it}
+                        elif isinstance(it, dict):
+                            # For object types, use name if available
+                            name = it.get("name", f"type{len(choices_map)}")
+                            choices_map[name] = it
+                    items = {"type": "choice", "choices": choices_map}
             else:
                 items = {"type": "string"}
 
@@ -808,7 +833,15 @@ class JsonStructureSchemaInferrer(SchemaInferrer):
             if len(item_types) == 1:
                 list_types.append({"type": "array", "items": item_types[0]})
             else:
-                list_types.append({"type": "array", "items": {"type": "choice", "choices": item_types}})
+                # Build choices map from item types
+                choices_map: Dict[str, Any] = {}
+                for it in item_types:
+                    if isinstance(it, str):
+                        choices_map[it] = {"type": it}
+                    elif isinstance(it, dict):
+                        name = it.get("name", f"type{len(choices_map)}")
+                        choices_map[name] = it
+                list_types.append({"type": "array", "items": {"type": "choice", "choices": choices_map}})
 
         value_types: List[Any] = []
         for item3 in map_types:
@@ -944,9 +977,14 @@ class JsonStructureSchemaInferrer(SchemaInferrer):
                 
                 if field_name == parent_field:
                     if len(variant_types) > 1:
+                        # Build choices as a map (object) per JSON Structure spec
+                        # Each value is a schema directly (the object type definition)
+                        choices_map: Dict[str, Any] = {}
+                        for vt in variant_types:
+                            choices_map[vt["name"]] = vt
                         envelope_properties[safe_name] = {
                             "type": "choice",
-                            "choices": variant_types
+                            "choices": choices_map
                         }
                     else:
                         envelope_properties[safe_name] = variant_types[0] if variant_types else {"type": "object"}
@@ -975,9 +1013,13 @@ class JsonStructureSchemaInferrer(SchemaInferrer):
             
             return envelope_record
         
-        # Handle top-level discriminated union
+        # Handle top-level discriminated union as inline union
+        # Inline unions match the actual instance format where the discriminator
+        # is a property value, not a key wrapper (tagged union)
         if result.discriminator_field:
-            variant_types = []
+            # Collect all fields from all variants to find common vs variant-specific
+            all_variant_fields: Dict[str, Set[str]] = {}  # variant_value -> field names
+            variant_docs: Dict[str, Dict[str, Any]] = {}  # variant_value -> sample doc
             
             for value in sorted(result.discriminator_values):
                 cluster_docs = [c for c in result.clusters 
@@ -986,27 +1028,98 @@ class JsonStructureSchemaInferrer(SchemaInferrer):
                 if not cluster_docs:
                     continue
                 cluster = cluster_docs[0]
+                all_variant_fields[value] = set(cluster.merged_signature)
+                variant_docs[value] = cluster.documents[0].data if cluster.documents else {}
+            
+            if not all_variant_fields:
+                return None
+            
+            # Find common fields (present in ALL variants)
+            common_fields = set.intersection(*all_variant_fields.values()) if all_variant_fields else set()
+            
+            # Build abstract base type with common fields
+            base_name = avro_name(type_name) + "Base"
+            base_properties: Dict[str, Any] = {}
+            base_required: List[str] = []
+            
+            # Use first variant's doc for type inference of common fields
+            first_value = sorted(result.discriminator_values)[0]
+            rep_doc = variant_docs.get(first_value, {})
+            
+            for field_name in sorted(common_fields):
+                safe_name = avro_name(field_name)
+                field_value = rep_doc.get(field_name)
+                field_type = self.python_type_to_jstruct_type(f"{type_name}.{safe_name}", field_value)
+                
+                if isinstance(field_type, str):
+                    base_properties[safe_name] = {"type": field_type}
+                else:
+                    base_properties[safe_name] = field_type
+                
+                if field_name != safe_name:
+                    base_properties[safe_name]["altnames"] = {self.altnames_key: field_name}
+                
+                # Check if required in all clusters
+                # Note: discriminator field is NOT required as it's handled by selector
+                all_required = all(
+                    field_name in c.required_fields 
+                    for c in result.clusters if c.merged_signature
+                )
+                if all_required and field_name != result.discriminator_field:
+                    base_required.append(safe_name)
+            
+            base_type: Dict[str, Any] = {
+                "abstract": True,
+                "type": "object",
+                "name": base_name,
+                "properties": base_properties
+            }
+            if base_required:
+                base_type["required"] = base_required
+            
+            # Build variant types that extend the base
+            definitions: Dict[str, Any] = {base_name: base_type}
+            choices_map: Dict[str, Any] = {}
+            
+            for value in sorted(result.discriminator_values):
+                if value not in all_variant_fields:
+                    continue
                 
+                # Type name is PascalCase for definitions
                 variant_name = avro_name(''.join(word.capitalize() for word in value.replace('_', ' ').split()))
-                variant_doc = cluster.documents[0].data if cluster.documents else {}
+                # Choice key must match actual selector value in instances
+                choice_key = value
+                
+                variant_doc = variant_docs.get(value, {})
+                variant_specific = all_variant_fields[value] - common_fields
+                
+                # Get cluster with all documents for this variant
+                cluster_for_variant = next(
+                    (c for c in result.clusters 
+                     if any(d.field_values.get(result.discriminator_field) == value 
+                           for d in c.documents)),
+                    None
+                )
                 
                 properties: Dict[str, Any] = {}
                 required: List[str] = []
                 
-                # Add discriminator field with default
-                disc_safe = avro_name(result.discriminator_field)
-                properties[disc_safe] = {
-                    "type": "string",
-                    "default": value
-                }
-                required.append(disc_safe)
-                
-                # Add other fields
-                for field_name in sorted(cluster.merged_signature):
-                    if field_name == result.discriminator_field:
-                        continue
+                # Add variant-specific fields only (common fields inherited from base)
+                for field_name in sorted(variant_specific):
                     safe_name = avro_name(field_name)
-                    field_value = variant_doc.get(field_name)
+                    
+                    # Find the first non-null value across all documents in this variant
+                    # to properly infer the type
+                    field_value = None
+                    if cluster_for_variant:
+                        for doc in cluster_for_variant.documents:
+                            val = doc.data.get(field_name)
+                            if val is not None:
+                                field_value = val
+                                break
+                    if field_value is None:
+                        field_value = variant_doc.get(field_name)
+                    
                     field_type = self.python_type_to_jstruct_type(f"{type_name}.{safe_name}", field_value)
                     
                     if isinstance(field_type, str):
@@ -1017,25 +1130,36 @@ class JsonStructureSchemaInferrer(SchemaInferrer):
                     if field_name != safe_name:
                         properties[safe_name]["altnames"] = {self.altnames_key: field_name}
                     
-                    if field_name in cluster.required_fields:
+                    # Field is required only if present in all documents of this variant
+                    if cluster_for_variant and field_name in cluster_for_variant.required_fields:
                         required.append(safe_name)
                 
                 variant_record: Dict[str, Any] = {
                     "type": "object",
                     "name": variant_name,
+                    "$extends": f"#/definitions/{base_name}",
                     "properties": properties
                 }
                 if required:
                     variant_record["required"] = required
-                variant_types.append(variant_record)
+                
+                definitions[variant_name] = variant_record
+                # Use actual discriminator value as choice key (must match selector in instances)
+                choices_map[choice_key] = {"type": {"$ref": f"#/definitions/{variant_name}"}}
             
-            if len(variant_types) == 1:
-                return variant_types[0]
+            if len(choices_map) == 1:
+                # Single variant - just return it directly
+                return list(definitions.values())[1]  # Skip base, return the variant
             
+            # Build inline union choice type
+            disc_safe = avro_name(result.discriminator_field)
             return {
                 "type": "choice",
                 "name": avro_name(type_name),
-                "choices": variant_types
+                "$extends": f"#/definitions/{base_name}",
+                "selector": disc_safe,
+                "choices": choices_map,
+                "definitions": definitions
             }
         
         # Undiscriminated union - fall back to standard inference

{structurize-3.2.0 → structurize-3.2.2}/avrotize/structuretocsharp.py

@@ -47,6 +47,7 @@ class StructureToCSharp:
         self.schema_registry: Dict[str, Dict] = {}  # Maps $id URIs to schemas
         self.offers: Dict[str, Any] = {}  # Maps add-in names to property definitions from $offers
         self.needs_json_structure_converters = False  # Track if any types need JSON Structure converters
+        self.discriminator_properties: Dict[str, str] = {}  # Maps type ref -> discriminator property name (for inline unions)
 
     def get_qualified_name(self, namespace: str, name: str) -> str:
         """ Concatenates namespace and name with a dot separator """
@@ -390,9 +391,13 @@ class StructureToCSharp:
         # Check additionalProperties setting (Section 3.7.8)
         additional_props = structure_schema.get('additionalProperties', True if is_abstract else None)
         
+        # Check if any property in this class is a discriminator for an inline union
+        discriminator_prop = self.discriminator_properties.get(ref, None)
+        
         fields_str = []
         for prop_name, prop_schema in properties.items():
-            field_def = self.generate_property(prop_name, prop_schema, class_name, schema_namespace, required_props)
+            is_discriminator = (prop_name == discriminator_prop)
+            field_def = self.generate_property(prop_name, prop_schema, class_name, schema_namespace, required_props, is_discriminator=is_discriminator)
             fields_str.append(field_def)
         
         # Add dictionary for additional properties if needed
@@ -460,7 +465,7 @@ class StructureToCSharp:
         self.generated_structure_types[ref] = structure_schema
         return ref
 
-    def generate_property(self, prop_name: str, prop_schema: Dict, class_name: str, parent_namespace: str, required_props: List) -> str:
+    def generate_property(self, prop_name: str, prop_schema: Dict, class_name: str, parent_namespace: str, required_props: List, is_discriminator: bool = False) -> str:
         """ Generates a property for a class """
         property_definition = ''
         
@@ -521,9 +526,13 @@ class StructureToCSharp:
         doc = prop_schema.get('description', prop_schema.get('doc', field_name_cs))
         property_definition += f"{INDENT}/// <summary>\n{INDENT}/// {doc}\n{INDENT}/// </summary>\n"
         
+        # If this property is used as a discriminator in an inline union, add JsonIgnore
+        # because JsonPolymorphic handles it as metadata
+        if is_discriminator and self.system_text_json_annotation:
+            property_definition += f'{INDENT}[System.Text.Json.Serialization.JsonIgnore]\n'
         # Add JSON property name annotation when property name differs from schema name
         # This is needed for proper JSON serialization/deserialization, especially with pascal_properties
-        if needs_json_annotation:
+        elif needs_json_annotation:
             property_definition += f'{INDENT}[System.Text.Json.Serialization.JsonPropertyName("{prop_name}")]\n'
         if self.newtonsoft_json_annotation and needs_json_annotation:
             property_definition += f'{INDENT}[Newtonsoft.Json.JsonProperty("{prop_name}")]\n'
@@ -1027,18 +1036,30 @@ class StructureToCSharp:
             # Fallback to tagged union if no base
             return self.generate_tagged_union(structure_schema, parent_namespace, write_file, explicit_name)
         
-        # First, ensure base class is generated (if it's abstract, it won't be referenced directly)
+        choices = structure_schema.get('choices', {})
+        selector = structure_schema.get('selector', 'type')
+        
+        # Mark the selector property as a discriminator BEFORE generating the base class
+        # This allows generate_class to add [JsonIgnore] to the property
         base_schema_copy = base_schema.copy()
         if 'name' not in base_schema_copy:
             # Extract name from $extends ref
             base_name = extends_ref.split('/')[-1]
             base_schema_copy['name'] = base_name
+        
+        # Calculate what the base class ref will be
+        base_namespace_for_ref = pascal(self.concat_namespace(self.base_namespace, base_schema_copy.get('namespace', schema_namespace)))
+        base_class_name_for_ref = pascal(base_schema_copy['name'])
+        pending_base_ref = 'global::'+self.get_qualified_name(base_namespace_for_ref, base_class_name_for_ref)
+        
+        # Record that this base type's selector property is a discriminator
+        if self.system_text_json_annotation and selector in base_schema.get('properties', {}):
+            self.discriminator_properties[pending_base_ref] = selector
+        
+        # Now generate the base class (it will check discriminator_properties)
         base_class_ref = self.generate_class(base_schema_copy, schema_namespace, write_file)
         base_class_name = base_class_ref.split('::')[-1].split('.')[-1]
         
-        choices = structure_schema.get('choices', {})
-        selector = structure_schema.get('selector', 'type')
-        
         # Generate abstract base class with selector property
         class_definition = f"/// <summary>\n/// {structure_schema.get('description', class_name + ' (inline union base)')}\n/// </summary>\n"
         
@@ -1056,16 +1077,15 @@ class StructureToCSharp:
         
         class_definition += "\n{\n"
         
-        # Add selector property (not required since derived classes set it in constructor)
-        class_definition += f"{INDENT}/// <summary>\n{INDENT}/// Type discriminator\n{INDENT}/// </summary>\n"
-        if self.system_text_json_annotation:
-            class_definition += f'{INDENT}[System.Text.Json.Serialization.JsonPropertyName("{selector}")]\n'
-        
         # Check if selector is already in base properties
         base_has_selector = selector in base_schema.get('properties', {})
-        if base_has_selector:
-            class_definition += f"{INDENT}public new string {pascal(selector)} {{ get; set; }} = \"\";\n"
-        else:
+        
+        # Only add selector property if base class doesn't already have it
+        # If base has the selector, JsonPolymorphic will use it directly
+        if not base_has_selector:
+            class_definition += f"{INDENT}/// <summary>\n{INDENT}/// Type discriminator\n{INDENT}/// </summary>\n"
+            if self.system_text_json_annotation:
+                class_definition += f'{INDENT}[System.Text.Json.Serialization.JsonPropertyName("{selector}")]\n'
             class_definition += f"{INDENT}public string {pascal(selector)} {{ get; set; }} = \"\";\n"
         
         class_definition += "}"
@@ -1076,11 +1096,21 @@ class StructureToCSharp:
         # Generate derived classes for each choice with property merging
         for choice_name, choice_schema_ref in choices.items():
             # Resolve the choice schema
-            if isinstance(choice_schema_ref, dict) and '$ref' in choice_schema_ref:
-                choice_schema = self.resolve_ref(choice_schema_ref['$ref'], self.schema_doc)
+            # Handle both formats:
+            # 1. Direct $ref: {"$ref": "#/definitions/Type"}
+            # 2. Nested in type: {"type": {"$ref": "#/definitions/Type"}}
+            ref_to_resolve = None
+            if isinstance(choice_schema_ref, dict):
+                if '$ref' in choice_schema_ref:
+                    ref_to_resolve = choice_schema_ref['$ref']
+                elif 'type' in choice_schema_ref and isinstance(choice_schema_ref['type'], dict) and '$ref' in choice_schema_ref['type']:
+                    ref_to_resolve = choice_schema_ref['type']['$ref']
+            
+            if ref_to_resolve:
+                choice_schema = self.resolve_ref(ref_to_resolve, self.schema_doc)
                 if not choice_schema:
                     # Try resolving relative to the structure_schema itself
-                    choice_schema = self.resolve_ref(choice_schema_ref['$ref'], structure_schema)
+                    choice_schema = self.resolve_ref(ref_to_resolve, structure_schema)
             else:
                 choice_schema = choice_schema_ref
             
@@ -1219,9 +1249,19 @@ class StructureToCSharp:
             class_definition += field_def
         
         # Add constructor that sets the discriminator
+        # If the selector exists in the base schema, use the original property name (snake_case)
+        # Otherwise use the PascalCase version we defined in the union class
+        base_properties = schema.get('$base_properties', [])
+        if selector in base_properties:
+            # Use the snake_case name from the base class
+            selector_prop_name = selector
+        else:
+            # Use PascalCase name we defined in the union class
+            selector_prop_name = pascal(selector)
+        
         class_definition += f"\n{INDENT}/// <summary>\n{INDENT}/// Constructor that sets the discriminator value\n{INDENT}/// </summary>\n"
         class_definition += f"{INDENT}public {class_name}()\n{INDENT}{{\n"
-        class_definition += f"{INDENT*2}this.{pascal(selector)} = \"{choice_name}\";\n"
+        class_definition += f"{INDENT*2}this.{selector_prop_name} = \"{choice_name}\";\n"
         class_definition += f"{INDENT}}}\n"
         
         # Generate Equals and GetHashCode

{structurize-3.2.0 → structurize-3.2.2/structurize.egg-info}/PKG-INFO

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