structurize 2.20.5__tar.gz → 2.21.1__tar.gz

{structurize-2.20.5/structurize.egg-info → structurize-2.21.1}/PKG-INFO

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

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.20.5'
-__version_tuple__ = version_tuple = (2, 20, 5)
+__version__ = version = '2.21.1'
+__version_tuple__ = version_tuple = (2, 21, 1)
 
-__commit_id__ = commit_id = 'g4811363b1'
+__commit_id__ = commit_id = 'g9b9841dd3'

{structurize-2.20.5 → structurize-2.21.1}/avrotize/avrotopython.py

@@ -327,7 +327,8 @@ class AvroToPython:
     def generate_test_class(self, package_name: str, class_name: str, fields: List[Dict[str, str]], import_types: Set[str]) -> None:
         """Generates a unit test class for a Python data class"""
         test_class_name = f"Test_{class_name}"
-        tests_package_name = "test_"+package_name.replace('.', '_').lower()
+        flat_package = package_name.replace('.', '_').lower()
+        tests_package_name = flat_package if flat_package.startswith('test_') else f"test_{flat_package}"
         test_class_definition = process_template(
             "avrotopython/test_class.jinja",
             package_name=package_name,
@@ -348,7 +349,8 @@ class AvroToPython:
     def generate_test_enum(self, package_name: str, class_name: str, symbols: List[str]) -> None:
         """Generates a unit test class for a Python enum"""
         test_class_name = f"Test_{class_name}"
-        tests_package_name = "test_"+package_name.replace('.', '_').lower()
+        flat_package = package_name.replace('.', '_').lower()
+        tests_package_name = flat_package if flat_package.startswith('test_') else f"test_{flat_package}"
         test_class_definition = process_template(
             "avrotopython/test_enum.jinja",
             package_name=package_name,

{structurize-2.20.5 → structurize-2.21.1}/avrotize/structuretocsharp.py

@@ -2072,8 +2072,8 @@ class StructureToCSharp:
             if enum_values:
                 for value in enum_values:
                     if isinstance(value, str):
-                        # Convert to PascalCase enum member name
-                        symbol_name = ''.join(word.capitalize() for word in re.split(r'[_\-\s]+', value))
+                        # Convert to PascalCase enum member name - must match generate_enum logic
+                        symbol_name = pascal(str(value).replace('-', '_').replace(' ', '_'))
                         symbols.append(symbol_name)
                     else:
                         # For numeric enums, use Value1, Value2, etc.

{structurize-2.20.5 → structurize-2.21.1}/avrotize/structuretogo.py

@@ -523,6 +523,10 @@ class StructureToGo:
             v = f'float64({random.uniform(-100, 100)})'
         elif go_type == '[]byte':
             v = '[]byte("' + ''.join(random.choices(string.ascii_letters + string.digits, k=10)) + '")'
+        elif go_type == 'time.Time':
+            v = 'time.Now()'
+        elif go_type == 'time.Duration':
+            v = 'time.Hour'
         elif go_type.startswith('[]'):
             inner_type = go_type[2:]
             v = f'{go_type}{{{self.random_value(inner_type)}}}'
@@ -549,10 +553,15 @@ class StructureToGo:
             'enums': self.enums,
             'base_package': self.base_package,
         }
+        needs_time_import = False
         for struct in context['structs']:
             for field in struct['fields']:
                 if 'value' not in field:
                     field['value'] = self.random_value(field['type'])
+                # Check if time package is needed
+                if 'time.Time' in field['type'] or 'time.Duration' in field['type']:
+                    needs_time_import = True
+        context['needs_time_import'] = needs_time_import
         helpers_file_name = os.path.join(self.output_dir, 'pkg', self.base_package, f"{self.base_package}_helpers.go")
         render_template('structuretogo/go_helpers.jinja', helpers_file_name, **context)
 

{structurize-2.20.5 → structurize-2.21.1}/avrotize/structuretojava.py

@@ -384,7 +384,12 @@ class StructureToJava:
             field_count=len(field_names)
         )
         
-        class_definition = class_definition.rstrip() + equals_hashcode + "\n}\n"
+        # Generate createTestInstance() method for testing (only for non-abstract classes)
+        create_test_instance = ''
+        if not is_abstract:
+            create_test_instance = self.generate_create_test_instance_method(class_name, fields, schema_namespace)
+        
+        class_definition = class_definition.rstrip() + create_test_instance + equals_hashcode + "\n}\n"
 
         if write_file:
             self.write_to_file(package, class_name, class_definition)
@@ -455,6 +460,86 @@ class StructureToJava:
             return str(value)
         return f"/* unsupported const value */"
 
+    def get_test_value(self, java_type: str) -> str:
+        """ Get a test value for a Java type """
+        # Handle arrays/lists
+        if java_type.startswith("List<") or java_type.startswith("ArrayList<"):
+            return "new java.util.ArrayList<>()"
+        if java_type.startswith("Map<"):
+            return "new java.util.HashMap<>()"
+        if java_type.endswith("[]"):
+            return f"new {java_type[:-2]}[0]"
+        
+        # Primitive test values
+        test_values = {
+            'String': '"test-string"',
+            'string': '"test-string"',
+            'int': '42',
+            'Integer': '42',
+            'long': '42L',
+            'Long': '42L',
+            'double': '3.14',
+            'Double': '3.14',
+            'float': '3.14f',
+            'Float': '3.14f',
+            'boolean': 'true',
+            'Boolean': 'true',
+            'byte': '(byte)0',
+            'Byte': '(byte)0',
+            'short': '(short)0',
+            'Short': '(short)0',
+            'BigInteger': 'java.math.BigInteger.ZERO',
+            'BigDecimal': 'java.math.BigDecimal.ZERO',
+            'byte[]': 'new byte[0]',
+            'LocalDate': 'java.time.LocalDate.now()',
+            'LocalTime': 'java.time.LocalTime.now()',
+            'Instant': 'java.time.Instant.now()',
+            'Duration': 'java.time.Duration.ZERO',
+            'UUID': 'java.util.UUID.randomUUID()',
+            'URI': 'java.net.URI.create("http://example.com")',
+            'Object': 'new Object()',
+            'void': 'null',
+            'Void': 'null',
+        }
+        
+        if java_type in test_values:
+            return test_values[java_type]
+        
+        # Check if it's a generated type (enum or class)
+        if java_type in self.generated_types_java_package:
+            type_kind = self.generated_types_java_package[java_type]
+            if type_kind == "enum":
+                return f'{java_type}.values()[0]'
+            elif type_kind == "class":
+                return f'{java_type}.createTestInstance()'
+        
+        # Default: try to instantiate
+        return f'new {java_type}()'
+
+    def generate_create_test_instance_method(self, class_name: str, fields: List[Dict], parent_package: str) -> str:
+        """ Generates a static createTestInstance method that creates a fully initialized instance """
+        method = f"\n{INDENT}/**\n{INDENT} * Creates a test instance with all required fields populated\n{INDENT} * @return a fully initialized test instance\n{INDENT} */\n"
+        method += f"{INDENT}public static {class_name} createTestInstance() {{\n"
+        method += f"{INDENT*2}{class_name} instance = new {class_name}();\n"
+        
+        for field in fields:
+            # Skip const fields
+            if field.get('is_const', False):
+                continue
+            
+            field_name = field['name']
+            field_type = field['type']
+            
+            # Get a test value for this field
+            test_value = self.get_test_value(field_type)
+            
+            # Setter name: set{Pascal(field_name)}
+            method += f"{INDENT*2}instance.set{pascal(field_name)}({test_value});\n"
+        
+        method += f"{INDENT*2}return instance;\n"
+        method += f"{INDENT}}}\n"
+        return method
+
     def generate_enum(self, structure_schema: Dict, field_name: str, parent_package: str, write_file: bool) -> JavaType:
         """ Generates a Java enum from JSON Structure enum schema """
         

{structurize-2.20.5 → structurize-2.21.1}/avrotize/structuretopython.py

@@ -39,6 +39,7 @@ class StructureToPython:
         self.schema_doc: JsonNode = None
         self.generated_types: Dict[str, str] = {}
         self.generated_structure_types: Dict[str, Dict[str, Union[str, Dict, List]]] = {}
+        self.generated_enum_symbols: Dict[str, List[str]] = {}
         self.type_dict: Dict[str, Dict] = {}
         self.definitions: Dict[str, Any] = {}
         self.schema_registry: Dict[str, Dict] = {}
@@ -285,6 +286,7 @@ class StructureToPython:
         class_name = pascal(explicit_name if explicit_name else structure_schema.get('name', 'UnnamedClass'))
         schema_namespace = structure_schema.get('namespace', parent_namespace)
         namespace = self.concat_namespace(self.base_package, schema_namespace).lower()
+        package_name = self.python_package_from_structure_type(schema_namespace, class_name)
         python_qualified_name = self.python_fully_qualified_name_from_structure_type(schema_namespace, class_name)
         
         if python_qualified_name in self.generated_types:
@@ -357,8 +359,8 @@ class StructureToPython:
         )
 
         if write_file:
-            self.write_to_file(namespace, class_name, class_definition)
-            self.generate_test_class(namespace, class_name, field_docstrings, import_types)
+            self.write_to_file(package_name, class_name, class_definition)
+            self.generate_test_class(package_name, class_name, field_docstrings, import_types)
 
         self.generated_types[python_qualified_name] = 'class'
         self.generated_structure_types[python_qualified_name] = structure_schema
@@ -423,6 +425,7 @@ class StructureToPython:
         class_name = pascal(structure_schema.get('name', field_name + 'Enum'))
         schema_namespace = structure_schema.get('namespace', parent_namespace)
         namespace = self.concat_namespace(self.base_package, schema_namespace).lower()
+        package_name = self.python_package_from_structure_type(schema_namespace, class_name)
         python_qualified_name = self.python_fully_qualified_name_from_structure_type(schema_namespace, class_name)
         
         if python_qualified_name in self.generated_types:
@@ -441,10 +444,11 @@ class StructureToPython:
         )
 
         if write_file:
-            self.write_to_file(namespace, class_name, enum_definition)
-            self.generate_test_enum(namespace, class_name, symbols)
+            self.write_to_file(package_name, class_name, enum_definition)
+            self.generate_test_enum(package_name, class_name, symbols)
 
         self.generated_types[python_qualified_name] = 'enum'
+        self.generated_enum_symbols[python_qualified_name] = symbols
         return python_qualified_name
 
     def generate_choice(self, structure_schema: Dict, parent_namespace: str, 
@@ -511,6 +515,7 @@ class StructureToPython:
         class_name = pascal(structure_schema.get('name', 'UnnamedMap'))
         schema_namespace = structure_schema.get('namespace', parent_namespace)
         namespace = self.concat_namespace(self.base_package, schema_namespace).lower()
+        package_name = self.python_package_from_structure_type(schema_namespace, class_name)
         python_qualified_name = self.python_fully_qualified_name_from_structure_type(schema_namespace, class_name)
         
         if python_qualified_name in self.generated_types:
@@ -535,7 +540,7 @@ class StructureToPython:
         )
         
         if write_file:
-            self.write_to_file(namespace, class_name, map_definition)
+            self.write_to_file(package_name, class_name, map_definition)
         
         self.generated_types[python_qualified_name] = 'map'
         return python_qualified_name
@@ -596,7 +601,24 @@ class StructureToPython:
             elif field_type.startswith('typing.Union['):
                 field_type = resolve(field_type)
                 return generate_value(field_type)
-            return test_values.get(field_type, 'Test_' + field_type + '.create_instance()')
+            if field_type in test_values:
+                return test_values[field_type]
+            # Check if this is an enum type - use first symbol value
+            # Look up by fully qualified name or by short name (class name only)
+            enum_symbols = None
+            if field_type in self.generated_enum_symbols:
+                enum_symbols = self.generated_enum_symbols[field_type]
+            else:
+                # Try to find by short name (the field type might be just the class name)
+                for qualified_name, symbols in self.generated_enum_symbols.items():
+                    if qualified_name.endswith('.' + field_type) or qualified_name == field_type:
+                        enum_symbols = symbols
+                        break
+            if enum_symbols:
+                return f"{field_type.split('.')[-1]}.{enum_symbols[0]}"
+            # For complex types, use None since fields are typically optional
+            # This avoids needing to construct nested objects with required args
+            return 'None'
 
         return generate_value(field_type)
 
@@ -604,7 +626,8 @@ class StructureToPython:
                            import_types: Set[str]) -> None:
         """Generates a unit test class for a Python dataclass"""
         test_class_name = f"Test_{class_name}"
-        tests_package_name = "test_" + package_name.replace('.', '_').lower()
+        # Use a simpler file naming scheme based on class name only
+        test_file_name = f"test_{class_name.lower()}"
         test_class_definition = process_template(
             "structuretopython/test_class.jinja",
             package_name=package_name,
@@ -617,7 +640,7 @@ class StructureToPython:
         )
 
         base_dir = os.path.join(self.output_dir, "tests")
-        test_file_path = os.path.join(base_dir, f"{tests_package_name.replace('.', '_').lower()}.py")
+        test_file_path = os.path.join(base_dir, f"{test_file_name}.py")
         if not os.path.exists(os.path.dirname(test_file_path)):
             os.makedirs(os.path.dirname(test_file_path), exist_ok=True)
         with open(test_file_path, 'w', encoding='utf-8') as file:
@@ -626,7 +649,8 @@ class StructureToPython:
     def generate_test_enum(self, package_name: str, class_name: str, symbols: List[str]) -> None:
         """Generates a unit test class for a Python enum"""
         test_class_name = f"Test_{class_name}"
-        tests_package_name = "test_" + package_name.replace('.', '_').lower()
+        # Use a simpler file naming scheme based on class name only
+        test_file_name = f"test_{class_name.lower()}"
         test_class_definition = process_template(
             "structuretopython/test_enum.jinja",
             package_name=package_name,
@@ -635,7 +659,7 @@ class StructureToPython:
             symbols=symbols
         )
         base_dir = os.path.join(self.output_dir, "tests")
-        test_file_path = os.path.join(base_dir, f"{tests_package_name.replace('.', '_').lower()}.py")
+        test_file_path = os.path.join(base_dir, f"{test_file_name}.py")
         if not os.path.exists(os.path.dirname(test_file_path)):
             os.makedirs(os.path.dirname(test_file_path), exist_ok=True)
         with open(test_file_path, 'w', encoding='utf-8') as file:
@@ -643,9 +667,8 @@ class StructureToPython:
 
     def write_to_file(self, package: str, class_name: str, python_code: str):
         """Writes a Python class to a file"""
-        # Add 'struct' module to the package path
-        full_package = f"{package}.struct"
-        parent_package_name = '.'.join(full_package.split('.')[:-1])
+        # The containing directory is the parent package (matches avrotopython.py)
+        parent_package_name = '.'.join(package.split('.')[:-1])
         parent_package_path = os.sep.join(parent_package_name.split('.')).lower()
         directory_path = os.path.join(self.output_dir, "src", parent_package_path)
         if not os.path.exists(directory_path):
@@ -758,7 +781,11 @@ class StructureToPython:
 def convert_structure_to_python(structure_schema_path, py_file_path, package_name='', dataclasses_json_annotation=False, avro_annotation=False):
     """Converts JSON Structure schema to Python dataclasses"""
     if not package_name:
-        package_name = os.path.splitext(os.path.basename(structure_schema_path))[0].lower().replace('-', '_')
+        # Strip .json extension, then also strip .struct suffix if present (*.struct.json naming convention)
+        base_name = os.path.splitext(os.path.basename(structure_schema_path))[0]
+        if base_name.endswith('.struct'):
+            base_name = base_name[:-7]  # Remove '.struct' suffix
+        package_name = base_name.lower().replace('-', '_')
 
     structure_to_python = StructureToPython(package_name, dataclasses_json_annotation=dataclasses_json_annotation, avro_annotation=avro_annotation)
     structure_to_python.convert(structure_schema_path, py_file_path)

{structurize-2.20.5 → structurize-2.21.1}/avrotize/structuretots.py

@@ -332,15 +332,25 @@ class StructureToTypeScript:
                 class_name, prop_name, prop_schema, namespace, import_types)
             is_required = prop_name in required_props
             is_optional = not is_required
+            field_type_no_null = self.strip_nullable(field_type)
+            
+            # Check if the field type is an enum
+            is_enum = False
+            for import_type in import_types:
+                if import_type.endswith('.' + field_type_no_null) or import_type == field_type_no_null:
+                    if import_type in self.generated_types and self.generated_types[import_type] == 'enum':
+                        is_enum = True
+                        break
             
             fields.append({
                 'name': self.safe_name(prop_name),
                 'original_name': prop_name,
                 'type': field_type,
-                'type_no_null': self.strip_nullable(field_type),
+                'type_no_null': field_type_no_null,
                 'is_required': is_required,
                 'is_optional': is_optional,
-                'is_primitive': self.is_typescript_primitive(self.strip_nullable(field_type).replace('[]', '')),
+                'is_primitive': self.is_typescript_primitive(field_type_no_null.replace('[]', '')),
+                'is_enum': is_enum,
                 'docstring': prop_schema.get('description', '') if isinstance(prop_schema, dict) else ''
             })
 
@@ -359,6 +369,11 @@ class StructureToTypeScript:
                 relative_import_path = f'./{relative_import_path}'
             imports_with_paths[import_type_name] = relative_import_path + '.js'
 
+        # Prepare required fields with test values for createInstance()
+        required_fields = [f for f in fields if f.get('is_required', not f.get('is_optional', False))]
+        for field in required_fields:
+            field['test_value'] = self.generate_test_value(field)
+
         # Generate class definition using template
         class_definition = process_template(
             "structuretots/class_core.ts.jinja",
@@ -368,6 +383,7 @@ class StructureToTypeScript:
             is_abstract=is_abstract,
             docstring=structure_schema.get('description', '').strip() if 'description' in structure_schema else f'A {class_name} class.',
             fields=fields,
+            required_fields=required_fields,
             imports=imports_with_paths,
             typedjson_annotation=self.typedjson_annotation,
         )
@@ -384,8 +400,10 @@ class StructureToTypeScript:
                      write_file: bool = True) -> str:
         """ Generates a TypeScript enum from JSON Structure enum """
         enum_name = pascal(structure_schema.get('name', field_name + 'Enum'))
-        namespace = self.concat_namespace(self.base_package, structure_schema.get('namespace', parent_namespace)).lower()
-        typescript_qualified_name = self.typescript_fully_qualified_name_from_structure_type(parent_namespace, enum_name)
+        schema_namespace = structure_schema.get('namespace', parent_namespace)
+        namespace = self.concat_namespace(self.base_package, schema_namespace).lower()
+        # Use schema_namespace (not parent_namespace) to match the file location
+        typescript_qualified_name = self.typescript_fully_qualified_name_from_structure_type(schema_namespace, enum_name)
         
         if typescript_qualified_name in self.generated_types:
             return typescript_qualified_name
@@ -522,17 +540,36 @@ class StructureToTypeScript:
         if field_type.startswith('{ [key: string]:'):
             return '{}'
         
-        # Return test value or construct object for custom types
-        return test_values.get(field_type, f'{{}} as {field_type}')
+        # Handle enums - use first value with Object.values()
+        if field.get('is_enum', False):
+            return f'Object.values({field_type})[0] as {field_type}'
+        
+        # Return test value for primitives, or call createInstance() for complex types (classes)
+        return test_values.get(field_type, f'{field_type}.createInstance()')
 
     def generate_test_class(self, namespace: str, class_name: str, fields: List[Dict[str, Any]]) -> None:
         """Generates a unit test class for a TypeScript class"""
         # Get only required fields for the test
         required_fields = [f for f in fields if f['is_required']]
         
+        # Collect enum imports needed for test file
+        enum_imports: Dict[str, str] = {}
+        
         # Generate test values for required fields
         for field in required_fields:
             field['test_value'] = self.generate_test_value(field)
+            # Check if this field is an enum and needs an import
+            if field.get('is_enum', False):
+                enum_type = field['type_no_null']
+                # Find the enum in generated_types to get its full path
+                for qualified_name, type_kind in self.generated_types.items():
+                    if type_kind == 'enum' and qualified_name.endswith('.' + enum_type):
+                        # Build import path - lowercase namespace like write_to_file does
+                        parts = qualified_name.split('.')
+                        enum_namespace = '.'.join(parts[:-1]).lower()
+                        enum_import_path = enum_namespace.replace('.', '/') + '/' + enum_type
+                        enum_imports[enum_type] = f'../src/{enum_import_path}'
+                        break
         
         # Determine relative path from test directory to src
         namespace_path = namespace.replace('.', '/') if namespace else ''
@@ -545,7 +582,8 @@ class StructureToTypeScript:
             "structuretots/test_class.ts.jinja",
             class_name=class_name,
             required_fields=required_fields,
-            relative_path=relative_path
+            relative_path=relative_path,
+            enum_imports=enum_imports
         )
         
         # Write test file
@@ -589,17 +627,30 @@ class StructureToTypeScript:
             f.write(gitignore)
 
     def generate_index(self) -> None:
-        """ Generates index.ts that exports all generated types """
+        """ Generates index.ts that exports all generated types with aliased exports """
         exports = []
         for qualified_name, type_kind in self.generated_types.items():
-            type_name = qualified_name.split('.')[-1]
-            namespace = '.'.join(qualified_name.split('.')[:-1])
+            # Split the qualified_name into parts
+            parts = qualified_name.split('.')
+            type_name = parts[-1]  # The actual type name
+            namespace = '.'.join(parts[:-1])  # The namespace excluding the type
+            
+            # Construct the relative path to the .js file
             if namespace:
                 # Lowercase the namespace to match the directory structure created by write_to_file
                 relative_path = namespace.lower().replace('.', '/') + '/' + type_name
             else:
                 relative_path = type_name
-            exports.append(f"export * from './{relative_path}.js';")
+            
+            if not relative_path.startswith('./'):
+                relative_path = './' + relative_path
+            
+            # Construct the alias name by joining all parts with underscores (PascalCase)
+            alias_parts = [pascal(part) for part in parts]
+            alias_name = '_'.join(alias_parts)
+            
+            # Generate the export statement with alias (like avrotots does)
+            exports.append(f"export {{ {type_name} as {alias_name} }} from '{relative_path}.js';")
         
         index_content = '\n'.join(exports) + '\n' if exports else ''
         
@@ -619,23 +670,34 @@ class StructureToTypeScript:
         self.convert_schema(schema, output_dir, package_name)
 
     def convert_schema(self, schema: JsonNode, output_dir: str, package_name: str = '') -> None:
-        """ Converts a JSON Structure schema to TypeScript classes """
+        """ Converts a JSON Structure schema (or list of schemas) to TypeScript classes """
+        # Normalize to list
+        if not isinstance(schema, list):
+            schema = [schema]
+        
         self.output_dir = output_dir
         self.schema_doc = schema
         
-        # Register schema IDs
-        self.register_schema_ids(self.schema_doc)
+        # Register schema IDs for all schemas
+        for s in schema:
+            if isinstance(s, dict):
+                self.register_schema_ids(s)
         
-        # Process definitions
-        if 'definitions' in self.schema_doc:
-            for def_name, def_schema in self.schema_doc['definitions'].items():
-                if isinstance(def_schema, dict):
-                    self.generate_class_or_choice(def_schema, '', write_file=True, explicit_name=def_name)
-        
-        # Process root schema if it's an object or choice
-        if 'type' in self.schema_doc:
-            root_namespace = self.schema_doc.get('namespace', '')
-            self.generate_class_or_choice(self.schema_doc, root_namespace, write_file=True)
+        # Process each schema
+        for s in schema:
+            if not isinstance(s, dict):
+                continue
+                
+            # Process definitions
+            if 'definitions' in s:
+                for def_name, def_schema in s['definitions'].items():
+                    if isinstance(def_schema, dict):
+                        self.generate_class_or_choice(def_schema, '', write_file=True, explicit_name=def_name)
+            
+            # Process root schema if it's an object or choice
+            if 'type' in s:
+                root_namespace = s.get('namespace', '')
+                self.generate_class_or_choice(s, root_namespace, write_file=True)
         
         # Generate project files
         self.generate_package_json(package_name)

{structurize-2.20.5 → structurize-2.21.1/structurize.egg-info}/PKG-INFO

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