avrotize 2.20.5__py3-none-any.whl → 2.21.0__py3-none-any.whl

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 = None

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/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/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/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/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/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/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/structuretots/package.json.jinja

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

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/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)

{avrotize-2.20.5.dist-info → avrotize-2.21.0.dist-info}/METADATA

@@ -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.dist-info → avrotize-2.21.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 avrotize/__init__.py,sha256=t5h5wkHXr6M0mmHAB5rhjZ3Gxy9xutGTGIfojfao9rI,3820
 avrotize/__main__.py,sha256=5pY8dYAURcOnFRvgb6fgaOIa_SOzPLIWbU8-ZTQ0jG4,88
-avrotize/_version.py,sha256=Tb8qbJxGNJ4RppXbnEAb2Lw5OeBX6K5TYQKxOq4_vZw,706
+avrotize/_version.py,sha256=bf4KNcBF9L-a9QOdPA5vh1kn4plN-XZsFCOsYIbiS1c,706
 avrotize/asn1toavro.py,sha256=QDNwfBfXMxSH-k487CA3CaGCGDzOLs4PpVbbENm5uF0,8386
 avrotize/avrotize.py,sha256=VHFpBltMVBpyt0ju3ZWW725BKjQ4Fk-nrAy8udW-X44,5713
 avrotize/avrotocpp.py,sha256=hRZV247_TDD7Sm6_8sFx-UH5SueLLx2Wg6TvAVUX0iE,25693
@@ -44,11 +44,11 @@ avrotize/proto3parser.py,sha256=MfE84c-oAWWuzYmKlEZ5g5LUF7YzZaASFh2trX3UCaw,1560
 avrotize/prototoavro.py,sha256=hqXBGRxYojaEbEgoHZxXwMG4R1nWC7UMl_XNLWfqH38,17346
 avrotize/structuretocddl.py,sha256=RK_dTJf0oAo6BIBM48NHRcWC96OtUjlgUC6HzXs5Lkk,21234
 avrotize/structuretocpp.py,sha256=tBWOvyZPYQ1CHN6RgDnWlmzJ1giOyQ9SlHBHWvhPyiw,35898
-avrotize/structuretocsharp.py,sha256=Y5TLMxUA0yt9QlXb8L9mSKFhLGmJkanwsg0yo0QfugI,122209
+avrotize/structuretocsharp.py,sha256=qYYAV6M8I2xv-VUzOobPT1_FYAoBBe0VRTMe9eY8r1g,122229
 avrotize/structuretocsv.py,sha256=w9cwXAnnakKaeTtXsLWWO8KwYnXUxyXvC7a-ZKs-E94,13851
 avrotize/structuretodatapackage.py,sha256=NEHRt30KfVDWH1EQakvuMdRZTtfVXx8fsaYud0ofb2g,29768
 avrotize/structuretodb.py,sha256=3QE_TCdNklGH5ymzGsEnX1sI4OhvX2AYKPH7xtR5tHk,43926
-avrotize/structuretogo.py,sha256=VCEUz-5J8uRqX1hWaTimtfVzEsIB-gs4wxa308rYD0s,32470
+avrotize/structuretogo.py,sha256=FNL5et5xxAoS0YSPJWGliWAFZPH_p8Nmu9pSEAT4J0U,32876
 avrotize/structuretographql.py,sha256=wcGXnrup5v5saRa1BhR6o-X8q8ujsQMVqrFHQTBPjww,20468
 avrotize/structuretoiceberg.py,sha256=itKb33Kj-7-udk4eHTLmTEasIeh1ggpZ3e_bwCxLABM,15344
 avrotize/structuretojava.py,sha256=jG2Vcf1KdezWrZo5lsecxLnmnMw1rA96uOxVWJQ4Rso,43372
@@ -57,9 +57,9 @@ avrotize/structuretojsons.py,sha256=PJrQBaf6yQHu5eFkePxbjPBEmL-fYfX2wj6OmH1jsWw,
 avrotize/structuretokusto.py,sha256=rOKgYIcm7ZK8RS-VvMFPNzPzwtv7c4dIKU-fKjrJLyM,30618
 avrotize/structuretomd.py,sha256=exfCldYbieVdduhotSoLrxsbphmyJQyeQso9qv4qyUw,13642
 avrotize/structuretoproto.py,sha256=Aq0-fwMXSjjAxgZ5mq1kpo_TauigMRrJK9LNyoN-YGs,42679
-avrotize/structuretopython.py,sha256=ePlXrwbqA9r63Vw6xL-Gq3hBUScdcF9aqCQSi_xtaGo,37980
+avrotize/structuretopython.py,sha256=Ub7gRtsMXGmWVN1qbBiHuYXa9Qo2CqsVQKrg9vpX7h4,39073
 avrotize/structuretorust.py,sha256=ChRmO7uzU-pMdDdS0Vtg-MVUaOaNhNUPwH-ZKKOHglU,35134
-avrotize/structuretots.py,sha256=bMBz9onD48nnFehg47x4wf8rUTghu_CucstkrZivqLk,32098
+avrotize/structuretots.py,sha256=CcxY2EYf4QOG9-yC8TxStBWpk-QdhXKzL1zNHjVOBbw,35057
 avrotize/structuretoxsd.py,sha256=01VpasyWSMOx04sILHLP7H-WkhGdXAEGKohUUfgrNf0,32797
 avrotize/xsdtoavro.py,sha256=nQtNH_3pEZBp67oUCPqzhvItEExHTe-8obsIfNRXt8Y,19064
 avrotize/avrotocpp/CMakeLists.txt.jinja,sha256=t2ADvvi3o20xfVrsRBaUvZlpVCDR4h6Szsf0GcuSkH0,3015
@@ -131,10 +131,10 @@ avrotize/structuretocsharp/project.sln.jinja,sha256=QKNG10hUo3sPCajx213TEUfZIMft
 avrotize/structuretocsharp/testproject.csproj.jinja,sha256=7SDzEM0wNV4a7JfCWG5AYiZT7KyJA-9gq_57tHqifRI,756
 avrotize/structuretocsharp/tuple_converter.cs.jinja,sha256=b2dsU7-5HcYdUMb1xpDAogBnKvKp7H86euT6EDrwLdc,3975
 avrotize/structuretogo/go_enum.jinja,sha256=2oXejDK4o5ALKhn9nb1YYYJJ1L696giwwT5xuosm51E,293
-avrotize/structuretogo/go_helpers.jinja,sha256=CwxHH0uh2JsGoj6-OViH0qk223gVekfKLrYZP00Z1-o,597
+avrotize/structuretogo/go_helpers.jinja,sha256=yYJrkxYU3Ho4IBpCo8yJdip5XrZ1sYHguWlEjihuPg0,654
 avrotize/structuretogo/go_interface.jinja,sha256=5kQpjTXmQ-llzok75cjcRNaoJ32sIgDDXDYLeNdQqdY,514
 avrotize/structuretogo/go_struct.jinja,sha256=jCsHTnwizX6MAS3c0iP5QZ-lxnsxKOCbXMRlIaZAgbo,5411
-avrotize/structuretogo/go_test.jinja,sha256=h4GHxr6MhN04Ct9sjSyp-SJlx25wI_OUrgarKXi2wCo,1799
+avrotize/structuretogo/go_test.jinja,sha256=KyEUrHOxf4O0A6S69o0vH29hKDQOL2k8lvljavDeIc0,2021
 avrotize/structuretojava/choice_core.jinja,sha256=H-VhQzIIwgu9myuw3j9WxFx01maTOlm2YiHaHEWhsyw,1069
 avrotize/structuretojava/class_core.jinja,sha256=mn3KVnvIxHIUB1Tep_YeISnM7k6ytQdOynQ4sUGrCAc,981
 avrotize/structuretojava/enum_core.jinja,sha256=yXnXQbr3IEudUj5OOFqDUJT7TfGqAJMy6O6K5DQ1lUQ,487
@@ -152,20 +152,20 @@ avrotize/structuretopython/dataclass_core.jinja,sha256=fUTLjlRjkH0P-1lK91o4IKGFa
 avrotize/structuretopython/enum_core.jinja,sha256=DDE7Mw9M2hjb0x1ErY9IvwASgAkI1hzFWjKbHsTfDRs,1253
 avrotize/structuretopython/map_alias.jinja,sha256=lq1vh37yrMTlOKQXhcu5xxkZg8kCDnskw1DUqW06aq0,567
 avrotize/structuretopython/pyproject_toml.jinja,sha256=IuMr-XjXVmTx1R91DGLJ6y3LskCBcwt-xxJNi5hR1qA,587
-avrotize/structuretopython/test_class.jinja,sha256=i3aFsWlBjIAmnplAe4jW4E0dXYBY-LfnptOK9jV6tQY,3353
+avrotize/structuretopython/test_class.jinja,sha256=2X39h1z3BHltRRK8WJt4vGqZuUbhzsdSfH7aWmijjSM,3254
 avrotize/structuretopython/test_enum.jinja,sha256=MruAUhAZRCMPcZBBZDJ5XzUwdp5XEZnv7UicMKkFaU4,834
 avrotize/structuretorust/dataclass_enum.rs.jinja,sha256=X3Fv3sqqX5USMK2eC_XQevE4BGClHS4nws5SeO1PZB8,1667
 avrotize/structuretorust/dataclass_struct.rs.jinja,sha256=US3tt5nb-2PKwlIIj4P7ABVDVfWMRp2BBrXKv50qVeo,4743
 avrotize/structuretorust/dataclass_union.rs.jinja,sha256=FFVQcHDT_2zhYxGWJVRA_5_UsdW_h0ZJINyIxZ_wyBo,2418
-avrotize/structuretots/class_core.ts.jinja,sha256=Tpopmsa2f9CRpU8HD3be7D2ZqXh9qJRqLjMkkvuUl_Y,2415
+avrotize/structuretots/class_core.ts.jinja,sha256=OHc36PuGBybCqtcJKv96jBsCf4C3o4v0RYzxe2IlJ6k,2883
 avrotize/structuretots/enum_core.ts.jinja,sha256=9PQg5jNhIGU-M-0PFM9Dm62cSu6b1bpOugdefb6Iv4c,176
 avrotize/structuretots/gitignore.jinja,sha256=lM5D9egdAJGZ9khvspxQmmUda3F9SvHWZ8JTxEw_mYM,76
 avrotize/structuretots/index.ts.jinja,sha256=-R4R_En1N4W_BEN3z3bLts9Xi4KnBTDLrYMvBPisaJk,29
-avrotize/structuretots/package.json.jinja,sha256=fYC2mguywpYf1-poALreCK4kH_OGWMUF6-7KWBzTprk,751
-avrotize/structuretots/test_class.ts.jinja,sha256=GHNzFdv3V-gYnk-rAnGS74JZD_3hSdiWzp3i_pPyGsQ,1059
+avrotize/structuretots/package.json.jinja,sha256=OfJn4g68VhBP-yvJCdsWm_1RHx1kphsmdWpxu_Fst1E,819
+avrotize/structuretots/test_class.ts.jinja,sha256=7tJ6hPo3A9zToTkwolVyXYhmZ_E4uI_OnnYsUUzUEdQ,1180
 avrotize/structuretots/tsconfig.json.jinja,sha256=8Pl65JW8uOMEexxkteobo0ZEqsJBO31HegNRUrf8XGQ,515
-avrotize-2.20.5.dist-info/entry_points.txt,sha256=m8J2TWiqbZh7SBQezc1CNrM_GVPWf01zOFcAKhzCC0U,51
-avrotize-2.20.5.dist-info/licenses/LICENSE,sha256=xGtQGygTETTtDQJafZCUbpsed3GxO6grmqig-jGEuSk,11348
-avrotize-2.20.5.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-avrotize-2.20.5.dist-info/METADATA,sha256=e73VGgny-HJBo9KbLs_RgM5nabpS_9lvNsD0O4bKW9A,80208
-avrotize-2.20.5.dist-info/RECORD,,
+avrotize-2.21.0.dist-info/entry_points.txt,sha256=m8J2TWiqbZh7SBQezc1CNrM_GVPWf01zOFcAKhzCC0U,51
+avrotize-2.21.0.dist-info/licenses/LICENSE,sha256=xGtQGygTETTtDQJafZCUbpsed3GxO6grmqig-jGEuSk,11348
+avrotize-2.21.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+avrotize-2.21.0.dist-info/METADATA,sha256=RN5Bzebf6IsPXbPK4bUjg_WB3aMtJSb9b9OenEA1g9I,80208
+avrotize-2.21.0.dist-info/RECORD,,