avrotize 2.21.1__py3-none-any.whl

avrotize/structuretocsharp/json_structure_converters.cs.jinja

@@ -0,0 +1,399 @@
+using System;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Xml;
+
+{% if namespace %}
+namespace {{ namespace }}
+{
+{% endif %}
+{% set ind=4 if namespace else 0 %}
+{% filter indent(width=ind, first=True) %}
+/// <summary>
+/// JSON converters for JSON Structure types that require string serialization.
+/// Per JSON Structure Core spec, int64, uint64, int128, uint128, and decimal
+/// types use string representation in JSON to preserve precision.
+/// </summary>
+public static class JsonStructureConverters
+{
+    /// <summary>
+    /// Gets default JsonSerializerOptions configured with JSON Structure converters
+    /// </summary>
+    public static JsonSerializerOptions GetOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new Int64StringConverter());
+        options.Converters.Add(new NullableInt64StringConverter());
+        options.Converters.Add(new UInt64StringConverter());
+        options.Converters.Add(new NullableUInt64StringConverter());
+        options.Converters.Add(new Int128StringConverter());
+        options.Converters.Add(new NullableInt128StringConverter());
+        options.Converters.Add(new UInt128StringConverter());
+        options.Converters.Add(new NullableUInt128StringConverter());
+        options.Converters.Add(new DecimalStringConverter());
+        options.Converters.Add(new NullableDecimalStringConverter());
+        options.Converters.Add(new TimeSpanIso8601Converter());
+        options.Converters.Add(new NullableTimeSpanIso8601Converter());
+        return options;
+    }
+}
+
+/// <summary>
+/// Converts Int64 (long) to/from JSON string for precision preservation
+/// </summary>
+public class Int64StringConverter : JsonConverter<long>
+{
+    /// <inheritdoc/>
+    public override long Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            return long.Parse(reader.GetString()!, CultureInfo.InvariantCulture);
+        }
+        return reader.GetInt64();
+    }
+
+    /// <inheritdoc/>
+    public override void Write(Utf8JsonWriter writer, long value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));
+    }
+}
+
+/// <summary>
+/// Converts nullable Int64 (long?) to/from JSON string for precision preservation
+/// </summary>
+public class NullableInt64StringConverter : JsonConverter<long?>
+{
+    /// <inheritdoc/>
+    public override long? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return null;
+        }
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            var str = reader.GetString();
+            if (string.IsNullOrEmpty(str)) return null;
+            return long.Parse(str, CultureInfo.InvariantCulture);
+        }
+        return reader.GetInt64();
+    }
+
+    /// <inheritdoc/>
+    public override void Write(Utf8JsonWriter writer, long? value, JsonSerializerOptions options)
+    {
+        if (value.HasValue)
+        {
+            writer.WriteStringValue(value.Value.ToString(CultureInfo.InvariantCulture));
+        }
+        else
+        {
+            writer.WriteNullValue();
+        }
+    }
+}
+
+/// <summary>
+/// Converts UInt64 (ulong) to/from JSON string for precision preservation
+/// </summary>
+public class UInt64StringConverter : JsonConverter<ulong>
+{
+    /// <inheritdoc/>
+    public override ulong Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            return ulong.Parse(reader.GetString()!, CultureInfo.InvariantCulture);
+        }
+        return reader.GetUInt64();
+    }
+
+    /// <inheritdoc/>
+    public override void Write(Utf8JsonWriter writer, ulong value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));
+    }
+}
+
+/// <summary>
+/// Converts nullable UInt64 (ulong?) to/from JSON string for precision preservation
+/// </summary>
+public class NullableUInt64StringConverter : JsonConverter<ulong?>
+{
+    /// <inheritdoc/>
+    public override ulong? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return null;
+        }
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            var str = reader.GetString();
+            if (string.IsNullOrEmpty(str)) return null;
+            return ulong.Parse(str, CultureInfo.InvariantCulture);
+        }
+        return reader.GetUInt64();
+    }
+
+    /// <inheritdoc/>
+    public override void Write(Utf8JsonWriter writer, ulong? value, JsonSerializerOptions options)
+    {
+        if (value.HasValue)
+        {
+            writer.WriteStringValue(value.Value.ToString(CultureInfo.InvariantCulture));
+        }
+        else
+        {
+            writer.WriteNullValue();
+        }
+    }
+}
+
+/// <summary>
+/// Converts Int128 to/from JSON string for precision preservation
+/// </summary>
+public class Int128StringConverter : JsonConverter<Int128>
+{
+    /// <inheritdoc/>
+    public override Int128 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            return Int128.Parse(reader.GetString()!, CultureInfo.InvariantCulture);
+        }
+        // Fallback: try to read as number
+        return Int128.Parse(reader.GetInt64().ToString(), CultureInfo.InvariantCulture);
+    }
+
+    /// <inheritdoc/>
+    public override void Write(Utf8JsonWriter writer, Int128 value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));
+    }
+}
+
+/// <summary>
+/// Converts nullable Int128 to/from JSON string for precision preservation
+/// </summary>
+public class NullableInt128StringConverter : JsonConverter<Int128?>
+{
+    /// <inheritdoc/>
+    public override Int128? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return null;
+        }
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            var str = reader.GetString();
+            if (string.IsNullOrEmpty(str)) return null;
+            return Int128.Parse(str, CultureInfo.InvariantCulture);
+        }
+        return Int128.Parse(reader.GetInt64().ToString(), CultureInfo.InvariantCulture);
+    }
+
+    /// <inheritdoc/>
+    public override void Write(Utf8JsonWriter writer, Int128? value, JsonSerializerOptions options)
+    {
+        if (value.HasValue)
+        {
+            writer.WriteStringValue(value.Value.ToString(CultureInfo.InvariantCulture));
+        }
+        else
+        {
+            writer.WriteNullValue();
+        }
+    }
+}
+
+/// <summary>
+/// Converts UInt128 to/from JSON string for precision preservation
+/// </summary>
+public class UInt128StringConverter : JsonConverter<UInt128>
+{
+    /// <inheritdoc/>
+    public override UInt128 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            return UInt128.Parse(reader.GetString()!, CultureInfo.InvariantCulture);
+        }
+        return UInt128.Parse(reader.GetUInt64().ToString(), CultureInfo.InvariantCulture);
+    }
+
+    /// <inheritdoc/>
+    public override void Write(Utf8JsonWriter writer, UInt128 value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));
+    }
+}
+
+/// <summary>
+/// Converts nullable UInt128 to/from JSON string for precision preservation
+/// </summary>
+public class NullableUInt128StringConverter : JsonConverter<UInt128?>
+{
+    /// <inheritdoc/>
+    public override UInt128? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return null;
+        }
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            var str = reader.GetString();
+            if (string.IsNullOrEmpty(str)) return null;
+            return UInt128.Parse(str, CultureInfo.InvariantCulture);
+        }
+        return UInt128.Parse(reader.GetUInt64().ToString(), CultureInfo.InvariantCulture);
+    }
+
+    /// <inheritdoc/>
+    public override void Write(Utf8JsonWriter writer, UInt128? value, JsonSerializerOptions options)
+    {
+        if (value.HasValue)
+        {
+            writer.WriteStringValue(value.Value.ToString(CultureInfo.InvariantCulture));
+        }
+        else
+        {
+            writer.WriteNullValue();
+        }
+    }
+}
+
+/// <summary>
+/// Converts decimal to/from JSON string for precision preservation
+/// </summary>
+public class DecimalStringConverter : JsonConverter<decimal>
+{
+    /// <inheritdoc/>
+    public override decimal Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            return decimal.Parse(reader.GetString()!, CultureInfo.InvariantCulture);
+        }
+        return reader.GetDecimal();
+    }
+
+    /// <inheritdoc/>
+    public override void Write(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));
+    }
+}
+
+/// <summary>
+/// Converts nullable decimal to/from JSON string for precision preservation
+/// </summary>
+public class NullableDecimalStringConverter : JsonConverter<decimal?>
+{
+    /// <inheritdoc/>
+    public override decimal? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return null;
+        }
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            var str = reader.GetString();
+            if (string.IsNullOrEmpty(str)) return null;
+            return decimal.Parse(str, CultureInfo.InvariantCulture);
+        }
+        return reader.GetDecimal();
+    }
+
+    /// <inheritdoc/>
+    public override void Write(Utf8JsonWriter writer, decimal? value, JsonSerializerOptions options)
+    {
+        if (value.HasValue)
+        {
+            writer.WriteStringValue(value.Value.ToString(CultureInfo.InvariantCulture));
+        }
+        else
+        {
+            writer.WriteNullValue();
+        }
+    }
+}
+
+/// <summary>
+/// Converts TimeSpan to/from ISO 8601 duration format (e.g., "PT1H30M")
+/// </summary>
+public class TimeSpanIso8601Converter : JsonConverter<TimeSpan>
+{
+    /// <inheritdoc/>
+    public override TimeSpan Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var str = reader.GetString();
+        if (string.IsNullOrEmpty(str))
+        {
+            return TimeSpan.Zero;
+        }
+        // Try ISO 8601 duration format first
+        if (str.StartsWith("P", StringComparison.OrdinalIgnoreCase))
+        {
+            return XmlConvert.ToTimeSpan(str);
+        }
+        // Fall back to standard TimeSpan parsing
+        return TimeSpan.Parse(str, CultureInfo.InvariantCulture);
+    }
+
+    /// <inheritdoc/>
+    public override void Write(Utf8JsonWriter writer, TimeSpan value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(XmlConvert.ToString(value));
+    }
+}
+
+/// <summary>
+/// Converts nullable TimeSpan to/from ISO 8601 duration format (e.g., "PT1H30M")
+/// </summary>
+public class NullableTimeSpanIso8601Converter : JsonConverter<TimeSpan?>
+{
+    /// <inheritdoc/>
+    public override TimeSpan? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return null;
+        }
+        var str = reader.GetString();
+        if (string.IsNullOrEmpty(str))
+        {
+            return null;
+        }
+        // Try ISO 8601 duration format first
+        if (str.StartsWith("P", StringComparison.OrdinalIgnoreCase))
+        {
+            return XmlConvert.ToTimeSpan(str);
+        }
+        // Fall back to standard TimeSpan parsing
+        return TimeSpan.Parse(str, CultureInfo.InvariantCulture);
+    }
+
+    /// <inheritdoc/>
+    public override void Write(Utf8JsonWriter writer, TimeSpan? value, JsonSerializerOptions options)
+    {
+        if (value.HasValue)
+        {
+            writer.WriteStringValue(XmlConvert.ToString(value.Value));
+        }
+        else
+        {
+            writer.WriteNullValue();
+        }
+    }
+}
+{% endfilter %}
+{% if namespace %}
+}
+{% endif %}

avrotize/structuretocsharp/program.cs.jinja

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
+
+/// <summary>
+/// Program that creates instances using test classes and serializes them to JSON
+/// for validation against JSON Structure schemas.
+/// Uses the ToByteArray method when available to ensure the class's serialization path is tested.
+/// </summary>
+public class InstanceSerializerProgram
+{
+    public static void Main(string[] args)
+    {
+        string outputDir = args.Length > 0 ? args[0] : ".";
+        Directory.CreateDirectory(outputDir);
+        
+        Console.WriteLine($"Generating JSON instance files in: {outputDir}");
+        
+        {%- for class_info in classes %}
+        // Generate instance for {{ class_info.class_name }}
+        try
+        {
+            var test_{{ class_info.class_name }} = new {{ class_info.full_qualified_test_name }}();
+            var instance_{{ class_info.class_name }} = test_{{ class_info.class_name }}.CreateInstance();
+            {%- if has_to_byte_array %}
+            // Use ToByteArray to serialize via the class's serialization method
+            var bytes_{{ class_info.class_name }} = instance_{{ class_info.class_name }}.ToByteArray("application/json");
+            var filePath_{{ class_info.class_name }} = Path.Combine(outputDir, "{{ class_info.class_name }}.json");
+            File.WriteAllBytes(filePath_{{ class_info.class_name }}, bytes_{{ class_info.class_name }});
+            {%- else %}
+            // Fallback: use JsonSerializer directly when ToByteArray is not available
+            var jsonOptions = new JsonSerializerOptions { WriteIndented = true };
+            var json_{{ class_info.class_name }} = JsonSerializer.Serialize(instance_{{ class_info.class_name }}, jsonOptions);
+            var filePath_{{ class_info.class_name }} = Path.Combine(outputDir, "{{ class_info.class_name }}.json");
+            File.WriteAllText(filePath_{{ class_info.class_name }}, json_{{ class_info.class_name }});
+            {%- endif %}
+            Console.WriteLine($"Created: {filePath_{{ class_info.class_name }}}");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error generating {{ class_info.class_name }}: {ex.Message}");
+            Console.WriteLine($"Stack trace: {ex.StackTrace}");
+        }
+        {% endfor %}
+        
+        Console.WriteLine("JSON instance generation complete.");
+    }
+}

avrotize/structuretocsharp/project.csproj.jinja

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>net9.0</TargetFramework>
+        <Nullable>enable</Nullable>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    </PropertyGroup>
+    <ItemGroup>
+        {%- if newtonsoft_json_annotation %}
+        <PackageReference Include="Newtonsoft.Json" Version="{{ NEWTONSOFT_JSON_VERSION }}" />
+        {%- endif %}
+        {%- if system_text_json_annotation %}
+        <PackageReference Include="System.Text.Json" Version="{{ SYSTEM_TEXT_JSON_VERSION }}" />
+        {%- endif %}
+        <PackageReference Include="System.Memory.Data" Version="{{ SYSTEM_MEMORY_DATA_VERSION }}" />
+    </ItemGroup>
+</Project>  
+

avrotize/structuretocsharp/project.sln.jinja

@@ -0,0 +1,34 @@
+{%- set slnguid = uuid() -%}
+{%- set prjguid = uuid() -%}
+{%- set testguid = uuid() -%}
+{%- set slnguid2 = uuid() -%}
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.002.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{ {{-slnguid-}} }") = "{{project_name|pascal}}", "src\{{project_name|pascal}}.csproj", "{ {{-prjguid-}} }"
+EndProject
+Project("{ {{-slnguid-}} }") = "{{project_name|pascal}}_test", "test\{{project_name|pascal}}.Test.csproj", "{ {{-testguid-}} }"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{ {{-prjguid-}} }.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{ {{-prjguid-}} }.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{ {{-prjguid-}} }.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{ {{-prjguid-}} }.Release|Any CPU.Build.0 = Release|Any CPU
+		{ {{-testguid-}} }.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{ {{-testguid-}} }.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{ {{-testguid-}} }.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{ {{-testguid-}} }.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = { {{-slnguid2-}} }
+	EndGlobalSection
+EndGlobal

avrotize/structuretocsharp/testproject.csproj.jinja

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>net9.0</TargetFramework>
+        <Nullable>enable</Nullable>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <OutputType>Exe</OutputType>
+        <StartupObject>InstanceSerializerProgram</StartupObject>
+    </PropertyGroup>
+    <ItemGroup>
+        <ProjectReference Include="../src/{{project_name | pascal}}.csproj"/>
+    </ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="NUnit" Version="{{ NUNIT_VERSION }}" />
+        <PackageReference Include="NUnit3TestAdapter" Version="{{ NUNIT_ADAPTER_VERSION }}" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="{{ MSTEST_SDK_VERSION }}" />
+    </ItemGroup>
+</Project>  
+

avrotize/structuretocsharp/tuple_converter.cs.jinja

@@ -0,0 +1,121 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+{% if namespace %}
+namespace {{ namespace }}
+{
+{% endif %}
+{% set ind=4 if namespace else 0 %}
+{% filter indent(width=ind, first=True) %}
+/// <summary>
+/// JSON converter for tuple types that serializes as JSON array per JSON Structure spec
+/// </summary>
+/// <typeparam name="T">The tuple record struct type</typeparam>
+public class TupleJsonConverter<T> : JsonConverter<T> where T : struct
+{
+    private readonly PropertyInfo[] _properties;
+    private readonly ConstructorInfo _constructor;
+    
+    /// <summary>
+    /// Initializes the converter with property order from record struct
+    /// </summary>
+    public TupleJsonConverter()
+    {
+        var type = typeof(T);
+        
+        // Get constructor parameters to determine correct order
+        _constructor = type.GetConstructors().FirstOrDefault() 
+            ?? throw new InvalidOperationException($"No constructor found for tuple type {type.Name}");
+        
+        var parameters = _constructor.GetParameters();
+        _properties = new PropertyInfo[parameters.Length];
+        
+        // Match properties to constructor parameters by name (case-insensitive)
+        for (int i = 0; i < parameters.Length; i++)
+        {
+            var param = parameters[i];
+            var property = type.GetProperty(
+                param.Name!, 
+                BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase
+            );
+            
+            if (property == null)
+            {
+                throw new InvalidOperationException(
+                    $"Property not found for constructor parameter '{param.Name}' in tuple type {type.Name}"
+                );
+            }
+            
+            _properties[i] = property;
+        }
+    }
+    
+    /// <summary>
+    /// Reads tuple from JSON array
+    /// </summary>
+    public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.StartArray)
+        {
+            throw new JsonException($"Expected array for tuple type {typeToConvert.Name}, got {reader.TokenType}");
+        }
+        
+        var values = new object?[_properties.Length];
+        var index = 0;
+        
+        while (reader.Read())
+        {
+            if (reader.TokenType == JsonTokenType.EndArray)
+            {
+                break;
+            }
+            
+            if (index >= _properties.Length)
+            {
+                throw new JsonException($"Too many elements in array for tuple type {typeToConvert.Name}. Expected {_properties.Length} elements.");
+            }
+            
+            var propertyType = _properties[index].PropertyType;
+            values[index] = JsonSerializer.Deserialize(ref reader, propertyType, options);
+            index++;
+        }
+        
+        if (index < _properties.Length)
+        {
+            throw new JsonException($"Not enough elements in array for tuple type {typeToConvert.Name}. Expected {_properties.Length}, got {index}.");
+        }
+        
+        // Invoke constructor with values in correct order
+        try
+        {
+            return (T)_constructor.Invoke(values);
+        }
+        catch (Exception ex)
+        {
+            throw new JsonException($"Failed to construct tuple type {typeToConvert.Name}", ex);
+        }
+    }
+    
+    /// <summary>
+    /// Writes tuple as JSON array
+    /// </summary>
+    public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+    {
+        writer.WriteStartArray();
+        
+        foreach (var property in _properties)
+        {
+            var propertyValue = property.GetValue(value);
+            JsonSerializer.Serialize(writer, propertyValue, property.PropertyType, options);
+        }
+        
+        writer.WriteEndArray();
+    }
+}
+{% endfilter %}
+{% if namespace %}
+}
+{% endif %}