avrotize 2.21.1__py3-none-any.whl

avrotize/structuretogo/go_enum.jinja

@@ -0,0 +1,12 @@
+package {{ base_package }}
+
+{%- if doc %}
+// {{ doc }}
+{%- endif %}
+type {{ enum_name }} {{ base_type }}
+
+const (
+{%- for symbol in symbols %}
+    {{ enum_name }}_{{ symbol }} {{ enum_name }} = {% if base_type == 'string' %}"{{ symbol }}"{% else %}{{ loop.index0 }}{% endif %}
+{%- endfor %}
+)

avrotize/structuretogo/go_helpers.jinja

@@ -0,0 +1,26 @@
+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
+func CreateInstance{{ struct.name }}() {{ struct.name }} {
+    return {{ struct.name }}{
+        {%- for field in struct.fields %}
+        {{ field.name }}: {{ field.value }},
+        {%- endfor %}
+    }
+}
+{% endfor %}
+
+{%- for enum in enums %}
+
+// CreateInstance{{ enum.name }} creates a sample instance of {{ enum.name }}
+func CreateInstance{{ enum.name }}() {{ enum.name }} {
+    return {{ enum.name }}_{{ enum.symbols[0] }}
+}
+{% endfor %}

avrotize/structuretogo/go_interface.jinja

@@ -0,0 +1,18 @@
+package {{ base_package }}
+
+{%- if doc %}
+// {{ doc }}
+// This is an abstract type - implementations should use concrete types that implement this interface.
+{%- endif %}
+type {{ interface_name }} interface {
+    {%- for method in methods %}
+    {%- if method.doc %}
+    // {{ method.doc }}
+    {%- endif %}
+    {%- if method.return_type %}
+    {{ method.name }}() {{ method.return_type }}
+    {%- else %}
+    {{ method.name }}({{ method.param_name }} {{ method.param_type }})
+    {%- endif %}
+    {%- endfor %}
+}

avrotize/structuretogo/go_struct.jinja

@@ -0,0 +1,187 @@
+package {{ base_package }}
+
+import (
+    {%- for import_item in imports %}
+    "{{ import_item }}"
+    {%- endfor %}
+    {%- if json_annotation %}
+    "encoding/json"
+    {%- endif %}
+    {%- if json_annotation or avro_annotation %}
+    "compress/gzip"
+    "bytes"
+    "fmt"
+    "io"
+    "strings"
+    {%- endif %}
+    {%- if avro_annotation %}
+    "github.com/hamba/avro/v2"
+    {%- endif %}
+    {%- for ref_pkg in referenced_packages %}
+    "{{ ref_pkg }}"
+    {%- endfor %}
+)
+
+{%- if doc %}
+// {{ doc }}
+{%- endif %}
+type {{ struct_name }} struct {
+    {%- for field in fields %}
+    {{ field.name }} {{ field.type }}{% if json_annotation or avro_annotation %} `{%- if json_annotation -%}json:"{{ field.original_name }}"{%- endif -%}{%- if avro_annotation %} avro:"{{ field.original_name }}"{%- endif -%}`{% endif %}
+    {%- endfor %}
+}
+
+{%- if base_interface %}
+
+// Verify that {{ struct_name }} implements {{ base_interface }} interface
+var _ {{ base_interface }} = (*{{ struct_name }})(nil)
+
+{%- for field in fields %}
+
+// Get{{ field.name }} returns the {{ field.original_name }} field
+func (s *{{ struct_name }}) Get{{ field.name }}() {{ field.type }} {
+    return s.{{ field.name }}
+}
+
+// Set{{ field.name }} sets the {{ field.original_name }} field
+func (s *{{ struct_name }}) Set{{ field.name }}(value {{ field.type }}) {
+    s.{{ field.name }} = value
+}
+{%- endfor %}
+{%- endif %}
+
+{%- if avro_annotation and avro_schema %}
+
+// AvroSchema is the embedded Avro schema for {{ struct_name }}
+const {{ struct_name }}AvroSchema = `{{ avro_schema }}`
+
+// GetAvroSchema returns the parsed Avro schema for {{ struct_name }}
+func (s *{{ struct_name }}) GetAvroSchema() (avro.Schema, error) {
+    return avro.Parse({{ struct_name }}AvroSchema)
+}
+{%- endif %}
+
+{%- if json_annotation or avro_annotation %}
+func (s *{{ struct_name }}) ToByteArray(contentType string) ([]byte, error) {
+    var result []byte
+    var err error
+    
+    // Strip +gzip suffix to get the base media type
+    mediaType := strings.Split(contentType, ";")[0]
+    isGzipped := strings.HasSuffix(mediaType, "+gzip")
+    if isGzipped {
+        mediaType = strings.TrimSuffix(mediaType, "+gzip")
+    }
+    
+    switch mediaType {
+    {%- if json_annotation %}
+    case "application/json":
+        result, err = json.Marshal(s)
+        if err != nil {
+            return nil, err
+        }
+    {%- endif %}
+    {%- if avro_annotation %}
+    case "avro/binary", "application/vnd.apache.avro+avro":
+        schema, err := s.GetAvroSchema()
+        if err != nil {
+            return nil, fmt.Errorf("failed to parse Avro schema: %w", err)
+        }
+        result, err = avro.Marshal(schema, s)
+        if err != nil {
+            return nil, fmt.Errorf("failed to marshal Avro: %w", err)
+        }
+    {%- endif %}
+    default:
+        return nil, fmt.Errorf("unsupported media type: %s", mediaType)
+    }
+    
+    if isGzipped {
+        var buf bytes.Buffer
+        gzipWriter := gzip.NewWriter(&buf)
+        _, err = gzipWriter.Write(result)
+        if err != nil {
+            return nil, err
+        }
+        err = gzipWriter.Close()
+        if err != nil {
+            return nil, err
+        }
+        result = buf.Bytes()
+    }
+    return result, nil
+}
+
+func {{ struct_name }}FromData(data interface{}, contentType string) (*{{ struct_name }}, error) {
+    var err error
+    var s {{ struct_name }}
+    
+    // Strip +gzip suffix to get the base media type
+    mediaType := strings.Split(contentType, ";")[0]
+    isGzipped := strings.HasSuffix(mediaType, "+gzip")
+    if isGzipped {
+        mediaType = strings.TrimSuffix(mediaType, "+gzip")
+    }
+    
+    if isGzipped {
+        var reader io.Reader
+        switch v := data.(type) {
+        case []byte:
+            reader = bytes.NewReader(v)
+        case io.Reader:
+            reader = v
+        default:
+            return nil, fmt.Errorf("unsupported data type for gzip: %T", data)
+        }
+        gzipReader, err := gzip.NewReader(reader)
+        if err != nil {
+            return nil, err
+        }
+        defer gzipReader.Close()
+        data, err = io.ReadAll(gzipReader)
+        if err != nil {
+            return nil, err
+        }
+    }
+    
+    switch mediaType {
+    {%- if json_annotation %}
+    case "application/json":
+        switch v := data.(type) {
+        case []byte:
+            err = json.Unmarshal(v, &s)
+        case string:
+            err = json.Unmarshal([]byte(v), &s)
+        case io.Reader:
+            err = json.NewDecoder(v).Decode(&s)
+        default:
+            return nil, fmt.Errorf("unsupported data type for JSON: %T", data)
+        }
+    {%- endif %}
+    {%- if avro_annotation %}
+    case "avro/binary", "application/vnd.apache.avro+avro":
+        var tempInstance {{ struct_name }}
+        schema, schemaErr := tempInstance.GetAvroSchema()
+        if schemaErr != nil {
+            return nil, fmt.Errorf("failed to parse Avro schema: %w", schemaErr)
+        }
+        switch v := data.(type) {
+        case []byte:
+            err = avro.Unmarshal(schema, v, &s)
+        default:
+            return nil, fmt.Errorf("unsupported data type for Avro: %T", data)
+        }
+    {%- endif %}
+    default:
+        return nil, fmt.Errorf("unsupported media type: %s", mediaType)
+    }
+    if err != nil {
+        return nil, err
+    }
+    return &s, nil
+}
+{%- endif %}
+
+func (s *{{ struct_name }}) ToObject() interface{} {
+    return s
+}

avrotize/structuretogo/go_test.jinja

@@ -0,0 +1,70 @@
+package {{ base_package }}
+
+import (
+    "testing"
+    {%- 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 }}()
+    
+    // Test JSON marshaling
+    data, err := json.Marshal(&instance)
+    if err != nil {
+        t.Fatalf("Failed to marshal {{ struct_name }}: %v", err)
+    }
+    
+    // Test JSON unmarshaling
+    var decoded {{ struct_name }}
+    err = json.Unmarshal(data, &decoded)
+    if err != nil {
+        t.Fatalf("Failed to unmarshal {{ struct_name }}: %v", err)
+    }
+    
+    // Test ToByteArray and FromData methods
+    contentType := "application/json"
+    byteArray, err := instance.ToByteArray(contentType)
+    if err != nil {
+        t.Fatalf("Failed to convert to byte array: %v", err)
+    }
+    
+    fromData, err := {{ struct_name }}FromData(byteArray, contentType)
+    if err != nil {
+        t.Fatalf("Failed to create from data: %v", err)
+    }
+    
+    if fromData == nil {
+        t.Fatal("FromData returned nil")
+    }
+    
+    // Test with gzipped data
+    contentTypeGzip := "application/json+gzip"
+    byteArrayGzip, err := instance.ToByteArray(contentTypeGzip)
+    if err != nil {
+        t.Fatalf("Failed to convert to gzipped byte array: %v", err)
+    }
+    
+    fromDataGzip, err := {{ struct_name }}FromData(byteArrayGzip, contentTypeGzip)
+    if err != nil {
+        t.Fatalf("Failed to create from gzipped data: %v", err)
+    }
+    
+    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
+    {%- for symbol in fields %}
+    _ = {{ struct_name }}_{{ symbol }}
+    {%- endfor %}
+    {%- endif %}
+}