avrotize 2.20.5__tar.gz → 2.21.0__tar.gz

{avrotize-2.20.5 → avrotize-2.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avrotize
-Version: 2.20.5
+Version: 2.21.0
 Summary: Tools to convert from and to Avro Schema from various other schema languages.
 Author-email: Clemens Vasters <clemensv@microsoft.com>
 Requires-Python: >=3.10

{avrotize-2.20.5 → avrotize-2.21.0}/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.0'
+__version_tuple__ = version_tuple = (2, 21, 0)
 
-__commit_id__ = commit_id = 'g4811363b1'
+__commit_id__ = commit_id = 'g1df522119'

{avrotize-2.20.5 → avrotize-2.21.0}/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.

{avrotize-2.20.5 → avrotize-2.21.0}/avrotize/structuretogo/go_helpers.jinja

@@ -1,5 +1,10 @@
 package {{ base_package }}
 
+{%- if needs_time_import %}
+
+import "time"
+{%- endif %}
+
 {%- for struct in structs %}
 
 // CreateInstance{{ struct.name }} creates a new instance of {{ struct.name }} with sample data

{avrotize-2.20.5 → avrotize-2.21.0}/avrotize/structuretogo/go_test.jinja

@@ -2,16 +2,16 @@ package {{ base_package }}
 
 import (
     "testing"
-    {%- if json_annotation %}
+    {%- if json_annotation and kind == 'struct' %}
     "encoding/json"
     {%- endif %}
 )
 
 func Test{{ struct_name }}(t *testing.T) {
     {%- if kind == 'struct' %}
+    {%- if json_annotation %}
     instance := CreateInstance{{ struct_name }}()
     
-    {%- if json_annotation %}
     // Test JSON marshaling
     data, err := json.Marshal(&instance)
     if err != nil {
@@ -56,6 +56,10 @@ func Test{{ struct_name }}(t *testing.T) {
     if fromDataGzip == nil {
         t.Fatal("FromData with gzip returned nil")
     }
+    {%- else %}
+    // Basic instance creation test (no JSON serialization without json annotation)
+    instance := CreateInstance{{ struct_name }}()
+    _ = instance // Verify instance creation works
     {%- endif %}
     {%- elif kind == 'enum' %}
     // Test enum values

{avrotize-2.20.5 → avrotize-2.21.0}/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)
 

{avrotize-2.20.5 → avrotize-2.21.0}/avrotize/structuretopython/test_class.jinja

@@ -11,12 +11,9 @@ sys.path.append(os.path.realpath(os.path.join(os.path.dirname(__file__), '../src
 from {{ package_name | lower }} import {{ class_name }}
 
 {%- for import_type in import_types if import_type not in ['decimal.Decimal', 'datetime.datetime', 'datetime.date', 'datetime.time', 'datetime.timedelta', 'uuid.UUID'] %}
-{%- set import_type_name = 'Test_'+import_type.split('.')[-1] %}
-{%- set import_package_name = 'test_'+'_'.join(import_type.split('.')[:-1]) | lower %}
-
-{%- if import_type.startswith('.') %}
-from .{{ import_package_name }} import {{ import_type_name }}
-{%- else %}
+{%- set import_type_name = import_type.split('.')[-1] %}
+{%- set import_package_name = '.'.join(import_type.split('.')[:-1]) | lower %}
+{%- if import_package_name %}
 from {{ import_package_name }} import {{ import_type_name }}
 {%- endif -%}
 {%- endfor %}

{avrotize-2.20.5 → avrotize-2.21.0}/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] = {}
@@ -445,6 +446,7 @@ class StructureToPython:
             self.generate_test_enum(namespace, 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, 
@@ -596,7 +598,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)
 

{avrotize-2.20.5 → avrotize-2.21.0}/avrotize/structuretots/class_core.ts.jinja

@@ -19,7 +19,7 @@ export {% if is_abstract %}abstract {% endif %}class {{ class_name }}{% if base_
     /** {{ field.docstring }} */
     {%- if typedjson_annotation %}
     {%- set field_type = field.type_no_null %}
-    @jsonMember({{ field_type if not field.is_primitive else 'String' if field_type == 'Date' else field_type | capitalize }})
+    @jsonMember({{ 'String' if field.is_enum else (field_type if not field.is_primitive else 'String' if field_type == 'Date' else field_type | capitalize) }})
     {%- endif %}
     public {{ field.name }}{% if field.is_optional %}?{% endif %}: {{ field.type_no_null }};
     {%- endfor %}
@@ -63,4 +63,16 @@ export {% if is_abstract %}abstract {% endif %}class {{ class_name }}{% if base_
         return result;
     }
     {%- endif %}
+
+    /**
+     * Creates an instance of {{ class_name }} with sample data for testing.
+     * @returns A new {{ class_name }} instance with sample values.
+     */
+    public static createInstance(): {{ class_name }} {
+        return new {{ class_name }}(
+            {%- for field in required_fields %}
+            {{ field.test_value }}{% if not loop.last %},{% endif %}  // {{ field.name }}
+            {%- endfor %}
+        );
+    }
 }

{avrotize-2.20.5 → avrotize-2.21.0}/avrotize/structuretots/package.json.jinja

@@ -31,6 +31,9 @@
     ],
     "testMatch": [
       "**/*.test.ts"
-    ]
+    ],
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    }
   }
 }

{avrotize-2.20.5 → avrotize-2.21.0}/avrotize/structuretots/test_class.ts.jinja

@@ -3,6 +3,9 @@
  */
 
 import { {{ class_name }} } from '../src/{{ relative_path }}';
+{%- for enum_type, enum_path in enum_imports.items() %}
+import { {{ enum_type }} } from '{{ enum_path }}';
+{%- endfor %}
 
 describe('{{ class_name }}', () => {
     it('should create an instance with required fields', () => {

{avrotize-2.20.5 → avrotize-2.21.0}/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,
         )
@@ -522,17 +538,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 +580,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 +625,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 +668,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)