avrotize 2.20.3__py3-none-any.whl → 2.20.4__py3-none-any.whl

avrotize/avrotocsharp/run_coverage.sh.jinja

@@ -0,0 +1,149 @@
+#!/bin/bash
+# Shell script to run tests with code coverage and generate reports
+# Generated for project: {{ project_name }}
+
+# Default values
+THRESHOLD=85
+HTML_REPORT=false
+OPEN_REPORT=false
+FAIL_ON_LOW_COVERAGE=true
+
+# Parse command line arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --threshold)
+            THRESHOLD="$2"
+            shift 2
+            ;;
+        --html-report)
+            HTML_REPORT=true
+            shift
+            ;;
+        --open-report)
+            OPEN_REPORT=true
+            HTML_REPORT=true
+            shift
+            ;;
+        --no-fail)
+            FAIL_ON_LOW_COVERAGE=false
+            shift
+            ;;
+        *)
+            echo "Unknown option: $1"
+            echo "Usage: $0 [--threshold N] [--html-report] [--open-report] [--no-fail]"
+            exit 1
+            ;;
+    esac
+done
+
+echo "🧪 Running tests with code coverage for {{ project_name }}..."
+
+# Clean previous coverage results
+COVERAGE_DIR="./coverage"
+if [ -d "$COVERAGE_DIR" ]; then
+    rm -rf "$COVERAGE_DIR"
+    echo "🧹 Cleaned previous coverage results"
+fi
+
+# Run tests with coverage collection
+echo "📊 Collecting code coverage..."
+dotnet test --collect:"XPlat Code Coverage" --results-directory:"$COVERAGE_DIR" --logger:"console;verbosity=detailed"
+TEST_EXIT_CODE=$?
+
+if [ $TEST_EXIT_CODE -ne 0 ]; then
+    echo "❌ Tests failed!"
+    exit $TEST_EXIT_CODE
+fi
+
+# Find coverage file
+COVERAGE_FILE=$(find "$COVERAGE_DIR" -name "*.cobertura.xml" | head -n 1)
+if [ -z "$COVERAGE_FILE" ]; then
+    echo "❌ No coverage file found!"
+    exit 1
+fi
+
+echo "📄 Coverage file: $COVERAGE_FILE"
+
+# Parse coverage percentage using grep and sed
+COVERAGE_LINE_RATE=$(grep -o 'line-rate="[0-9.]*"' "$COVERAGE_FILE" | head -n 1 | sed 's/line-rate="//;s/"//')
+COVERAGE_PERCENT=$(echo "$COVERAGE_LINE_RATE * 100" | bc -l | xargs printf "%.2f")
+
+# Parse branch coverage
+BRANCH_LINE_RATE=$(grep -o 'branch-rate="[0-9.]*"' "$COVERAGE_FILE" | head -n 1 | sed 's/branch-rate="//;s/"//')
+BRANCH_PERCENT=$(echo "$BRANCH_LINE_RATE * 100" | bc -l | xargs printf "%.2f")
+
+# Color codes
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+WHITE='\033[1;37m'
+NC='\033[0m' # No Color
+
+# Determine colors based on threshold
+LINE_COLOR=$GREEN
+if (( $(echo "$COVERAGE_PERCENT < $THRESHOLD" | bc -l) )); then
+    LINE_COLOR=$RED
+fi
+
+BRANCH_COLOR=$GREEN
+if (( $(echo "$BRANCH_PERCENT < $THRESHOLD" | bc -l) )); then
+    BRANCH_COLOR=$RED
+fi
+
+echo -e "📈 Line Coverage: ${LINE_COLOR}${COVERAGE_PERCENT}%${NC}"
+echo -e "🌿 Branch Coverage: ${BRANCH_COLOR}${BRANCH_PERCENT}%${NC}"
+
+# Generate HTML report if requested
+if [ "$HTML_REPORT" = true ]; then
+    echo -e "${BLUE}📊 Generating HTML coverage report...${NC}"
+    
+    # Check if reportgenerator is installed
+    if ! command -v reportgenerator &> /dev/null; then
+        echo -e "${YELLOW}⬇️ Installing ReportGenerator...${NC}"
+        dotnet tool install -g dotnet-reportgenerator-globaltool
+    fi
+    
+    HTML_REPORT_PATH="$COVERAGE_DIR/html"
+    reportgenerator "-reports:$COVERAGE_FILE" "-targetdir:$HTML_REPORT_PATH" "-reporttypes:Html"
+    
+    echo -e "${GREEN}📊 HTML report generated: $HTML_REPORT_PATH/index.html${NC}"
+    
+    if [ "$OPEN_REPORT" = true ]; then
+        if command -v xdg-open &> /dev/null; then
+            xdg-open "$HTML_REPORT_PATH/index.html"
+        elif command -v open &> /dev/null; then
+            open "$HTML_REPORT_PATH/index.html"
+        else
+            echo "Cannot auto-open browser. Please open: $HTML_REPORT_PATH/index.html"
+        fi
+        echo -e "${GREEN}🌐 Opened coverage report in browser${NC}"
+    fi
+fi
+
+# Coverage summary
+echo ""
+echo -e "${CYAN}📊 Coverage Summary:${NC}"
+echo -e "  Line Coverage: ${WHITE}${COVERAGE_PERCENT}%${NC} (Threshold: ${THRESHOLD}%)"
+echo -e "  Branch Coverage: ${WHITE}${BRANCH_PERCENT}%${NC}"
+
+# Determine status
+if (( $(echo "$COVERAGE_PERCENT >= $THRESHOLD" | bc -l) )); then
+    echo -e "  Status: ${GREEN}✅ PASSED${NC}"
+    STATUS_CODE=0
+else
+    echo -e "  Status: ${RED}❌ FAILED${NC}"
+    STATUS_CODE=1
+fi
+
+# Fail if coverage is below threshold and FAIL_ON_LOW_COVERAGE is set
+if [ "$FAIL_ON_LOW_COVERAGE" = true ] && [ $STATUS_CODE -eq 1 ]; then
+    echo ""
+    echo -e "${RED}❌ Coverage ${COVERAGE_PERCENT}% is below the required threshold of ${THRESHOLD}%${NC}"
+    exit 1
+fi
+
+echo ""
+echo -e "${GREEN}✅ Coverage analysis completed successfully!${NC}"
+exit 0

avrotize/avrotocsharp/testproject.csproj.jinja

@@ -11,5 +11,9 @@
         <PackageReference Include="NUnit" Version="{{ NUNIT_VERSION }}" />
         <PackageReference Include="NUnit3TestAdapter" Version="{{ NUNIT_ADAPTER_VERSION }}" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="{{ MSTEST_SDK_VERSION }}" />
+        <PackageReference Include="coverlet.collector" Version="{{ COVERLET_VERSION }}">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
     </ItemGroup>
 </Project>  

avrotize/avrotocsharp.py

@@ -14,9 +14,12 @@ from avrotize.constants import (
     NEWTONSOFT_JSON_VERSION,
     SYSTEM_TEXT_JSON_VERSION,
     SYSTEM_MEMORY_DATA_VERSION,
+    PROTOBUF_NET_VERSION,
+    MSGPACK_VERSION,
     NUNIT_VERSION,
     NUNIT_ADAPTER_VERSION,
     MSTEST_SDK_VERSION,
+    COVERLET_VERSION,
 )
 import glob
 
@@ -49,7 +52,9 @@ class AvroToCSharp:
         self.system_text_json_annotation = False
         self.newtonsoft_json_annotation = False
         self.system_xml_annotation = False
+        self.msgpack_annotation = False
         self.avro_annotation = False
+        self.protobuf_net_annotation = False
         self.generated_types: Dict[str,str] = {}
         self.generated_avro_types: Dict[str, Dict[str, Union[str, Dict, List]]] = {}
         self.type_dict: Dict[str, Dict] = {}
@@ -177,7 +182,14 @@ class AvroToCSharp:
             else:
                 class_definition += f"[XmlRoot(\"{class_name}\")]\n"
 
-        fields_str = [self.generate_property(field, class_name, avro_namespace) for field in avro_schema.get('fields', [])]
+        if self.protobuf_net_annotation:
+            class_definition += "[ProtoContract]\n"
+
+        # Add MessagePack serialization attribute for the class if enabled
+        if self.msgpack_annotation:
+            class_definition += "[MessagePackObject]\n"
+
+        fields_str = [self.generate_property(index + 1, field, class_name, avro_namespace) for index, field in enumerate(avro_schema.get('fields', []))]
         class_body = "\n".join(fields_str)
         class_definition += f"public partial class {class_name}"
         if self.avro_annotation:
@@ -250,9 +262,11 @@ class AvroToCSharp:
             "avrotocsharp/dataclass_core.jinja",
             class_name=class_name,
             avro_annotation=self.avro_annotation,
+            protobuf_net_annotation=self.protobuf_net_annotation,
             system_text_json_annotation=self.system_text_json_annotation,
             newtonsoft_json_annotation=self.newtonsoft_json_annotation,
-            system_xml_annotation=self.system_xml_annotation, 
+            system_xml_annotation=self.system_xml_annotation,
+            msgpack_annotation=self.msgpack_annotation,
             json_match_clauses=self.create_is_json_match_clauses(avro_schema, avro_namespace, class_name)
         )
 
@@ -516,14 +530,19 @@ class AvroToCSharp:
                 union_type_name = union_type.rsplit('.', 1)[-1]
             if self.is_csharp_reserved_word(union_type_name):
                 union_type_name = f"@{union_type_name}"
+            proto_member_name = union_type_name[1:] if union_type_name.startswith("@") else union_type_name
             class_definition_objctr += f"{INDENT*3}if (obj is {union_type})\n{INDENT*3}{{\n{INDENT*4}self.{union_type_name} = ({union_type})obj;\n{INDENT*4}return self;\n{INDENT*3}}}\n"
             if union_type in self.generated_types and self.generated_types[union_type] == "class":
                 class_definition_genericrecordctor += f"{INDENT*3}if (obj.Schema.Fullname == {union_type}.AvroSchema.Fullname)\n{INDENT*3}{{\n{INDENT*4}this.{union_type_name} = new {union_type}(obj);\n{INDENT*4}return;\n{INDENT*3}}}\n"
             class_definition_ctors += \
                 f"{INDENT*2}/// <summary>\n{INDENT*2}/// Constructor for {union_type_name} values\n{INDENT*2}/// </summary>\n" + \
                 f"{INDENT*2}public {union_class_name}({union_type}? {union_type_name})\n{INDENT*2}{{\n{INDENT*3}this.{union_type_name} = {union_type_name};\n{INDENT*2}}}\n"
+            # Add Key attribute for MessagePack serialization if enabled
+            msgpack_key_attr = f"{INDENT*2}[Key({i})]\n" if self.msgpack_annotation else ""
             class_definition_decls += \
                 f"{INDENT*2}/// <summary>\n{INDENT*2}/// Gets the {union_type_name} value\n{INDENT*2}/// </summary>\n" + \
+                (f"{INDENT*2}[ProtoMember({i+1}, Name=\"{proto_member_name}\")]\n" if self.protobuf_net_annotation else "") + \
+                msgpack_key_attr + \
                 f"{INDENT*2}public {union_type}? {union_type_name} {{ get; set; }} = null;\n"
             class_definition_toobject += f"{INDENT*3}if ({union_type_name} != null) {{\n{INDENT*4}return {union_type_name};\n{INDENT*3}}}\n"
 
@@ -570,9 +589,14 @@ class AvroToCSharp:
         if self.system_xml_annotation:
             class_definition += \
                 f"{INDENT}[XmlRoot(\"{union_class_name}\")]\n"
+        if self.msgpack_annotation:
+            class_definition += \
+                f"{INDENT}[MessagePackObject]\n"
         if self.system_text_json_annotation:
             class_definition += \
                 f"{INDENT}[System.Text.Json.Serialization.JsonConverter(typeof({union_class_name}))]\n"
+        if self.protobuf_net_annotation:
+            class_definition += f"{INDENT}[ProtoContract]\n"
         class_definition += \
             f"{INDENT}public sealed class {union_class_name}"
         if self.system_text_json_annotation:
@@ -697,6 +721,8 @@ class AvroToCSharp:
     def is_enum_type(self, avro_type: Union[str, Dict, List]) -> bool:
         """ Checks if a type is an enum (including nullable enums) """
         if isinstance(avro_type, str):
+            if avro_type in ('null', 'boolean', 'int', 'long', 'float', 'double', 'bytes', 'string'):
+                return False
             schema = self.schema_doc
             name = avro_type.split('.')[-1]
             namespace = ".".join(avro_type.split('.')[:-1])
@@ -711,7 +737,7 @@ class AvroToCSharp:
             return avro_type.get('type') == 'enum'
         return False
 
-    def generate_property(self, field: Dict, class_name: str, parent_namespace: str) -> str:
+    def generate_property(self, field_index: int, field: Dict, class_name: str, parent_namespace: str) -> str:
         """ Generates a property """
         is_enum_type = self.is_enum_type(field['type'])
         field_type = self.convert_avro_type_to_csharp(
@@ -727,6 +753,9 @@ class AvroToCSharp:
         prop = ''
         prop += f"{INDENT}/// <summary>\n{INDENT}/// { field.get('doc', field_name) }\n{INDENT}/// </summary>\n"
         
+        if self.protobuf_net_annotation:
+            prop += f"{INDENT}[ProtoMember({field_index}, Name=\"{annotation_name}\")]\n"
+        
         # Add XML serialization attribute if enabled
         if self.system_xml_annotation:
             xmlkind = field.get('xmlkind', 'element')
@@ -735,6 +764,10 @@ class AvroToCSharp:
             elif xmlkind == 'attribute':
                 prop += f"{INDENT}[XmlAttribute(\"{annotation_name}\")]\n"
         
+        # Add MessagePack serialization attribute if enabled
+        if self.msgpack_annotation:
+            prop += f"{INDENT}[Key({field_index})]\n"
+
         if self.system_text_json_annotation:
             prop += f"{INDENT}[System.Text.Json.Serialization.JsonPropertyName(\"{annotation_name}\")]\n"
             if is_enum_type:
@@ -743,6 +776,8 @@ class AvroToCSharp:
                 prop += f"{INDENT}[System.Text.Json.Serialization.JsonConverter(typeof({field_type}))]\n"
         if self.newtonsoft_json_annotation:
             prop += f"{INDENT}[Newtonsoft.Json.JsonProperty(\"{annotation_name}\")]\n"
+            if is_enum_type:
+                prop += f"{INDENT}[Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]\n"
         
         # Determine initialization value
         initialization = ""
@@ -785,6 +820,8 @@ class AvroToCSharp:
             # Common using statements (add more as needed)
             file_content = "using System;\nusing System.Collections.Generic;\n"
             file_content += "using System.Linq;\n"
+            if self.protobuf_net_annotation:
+                file_content += "using ProtoBuf;\n"
             if self.system_text_json_annotation:
                 file_content += "using System.Text.Json;\n"
                 file_content += "using System.Text.Json.Serialization;\n"
@@ -792,6 +829,8 @@ class AvroToCSharp:
                 file_content += "using Newtonsoft.Json;\n"
             if self.system_xml_annotation:  # Add XML serialization using directive
                 file_content += "using System.Xml.Serialization;\n"
+            if self.msgpack_annotation:  # Add MessagePack serialization using directive
+                file_content += "using MessagePack;\n"
 
             if namespace:
                 # Namespace declaration with correct indentation for the definition
@@ -833,7 +872,9 @@ class AvroToCSharp:
                 avro_annotation=self.avro_annotation,
                 system_xml_annotation=self.system_xml_annotation,
                 system_text_json_annotation=self.system_text_json_annotation,
-                newtonsoft_json_annotation=self.newtonsoft_json_annotation
+                newtonsoft_json_annotation=self.newtonsoft_json_annotation,
+                protobuf_net_annotation=self.protobuf_net_annotation,
+                msgpack_annotation=self.msgpack_annotation
             )
         elif type_kind == "enum":
             test_class_definition = process_template(
@@ -845,7 +886,8 @@ class AvroToCSharp:
                 avro_annotation=self.avro_annotation,
                 system_xml_annotation=self.system_xml_annotation,
                 system_text_json_annotation=self.system_text_json_annotation,
-                newtonsoft_json_annotation=self.newtonsoft_json_annotation
+                newtonsoft_json_annotation=self.newtonsoft_json_annotation,
+                protobuf_net_annotation=self.protobuf_net_annotation
             )
 
         test_file_path = os.path.join(test_directory_path, f"{test_class_name}.cs")
@@ -856,13 +898,14 @@ class AvroToCSharp:
         """ Retrieves fields for a given class name """
 
         class Field:
-            def __init__(self, fn: str, ft:str, tv:Any, ct: bool, pm: bool, ie: bool):
+            def __init__(self, fn: str, ft:str, tv:Any, ct: bool, pm: bool, ie: bool, iu: bool):
                 self.field_name = fn
                 self.field_type = ft
                 self.test_value = tv
                 self.is_const = ct
                 self.is_primitive = pm
                 self.is_enum = ie
+                self.is_union = iu
 
         fields: List[Field] = []
         if avro_schema and 'fields' in avro_schema:
@@ -877,16 +920,19 @@ class AvroToCSharp:
                 field_type = self.convert_avro_type_to_csharp(class_name, field_name, field['type'], str(avro_schema.get('namespace', '')))
                 is_class = field_type in self.generated_types and self.generated_types[field_type] == "class"
                 is_enum = self.is_enum_type(field['type'])
+                is_union = field_type in self.generated_types and self.generated_types[field_type] == "union"
+                test_value = self.get_test_value(field_type, field['type'], str(avro_schema.get('namespace', ''))) if not "const" in field else '\"'+str(field["const"])+'\"'
                 f = Field(field_name,
                           field_type,
-                          (self.get_test_value(field_type) if not "const" in field else '\"'+str(field["const"])+'\"'),
+                          test_value,
                           "const" in field and field["const"] is not None,
                           not is_class,
-                          is_enum)
+                          is_enum,
+                          is_union)
                 fields.append(f)
         return cast(List[Any], fields)
 
-    def get_test_value(self, csharp_type: str) -> str:
+    def get_test_value(self, csharp_type: str, avro_type: JsonNode = None, parent_namespace: str = '') -> str:
         """Returns a default test value based on the Avro type"""
         # For nullable object types, return typed null to avoid var issues
         if csharp_type == "object?":
@@ -908,6 +954,19 @@ class AvroToCSharp:
         }
         if csharp_type.endswith('?'):
             csharp_type = csharp_type[:-1]
+        
+        # Check if this is a union type (either by generated_types lookup or by type structure)
+        if csharp_type in self.generated_types and self.generated_types[csharp_type] == "union":
+            # For union types, we need to initialize with one of the valid options
+            # Find the first non-null type in the union and create a value for it
+            if isinstance(avro_type, list):
+                non_null_types = [t for t in avro_type if t != 'null']
+                if non_null_types:
+                    first_option = non_null_types[0]
+                    first_option_csharp = self.convert_avro_type_to_csharp('', 'Option0', first_option, parent_namespace)
+                    first_option_value = self.get_test_value(first_option_csharp, first_option, parent_namespace)
+                    return f'new {csharp_type}({first_option_value})'
+        
         return test_values.get(csharp_type, f'new {csharp_type}()')
 
     def convert_schema(self, schema: JsonNode, output_dir: str):
@@ -967,10 +1026,14 @@ class AvroToCSharp:
                         system_xml_annotation=self.system_xml_annotation,
                         system_text_json_annotation=self.system_text_json_annotation,
                         newtonsoft_json_annotation=self.newtonsoft_json_annotation,
+                        protobuf_net_annotation=self.protobuf_net_annotation,
+                        msgpack_annotation=self.msgpack_annotation,
                         CSHARP_AVRO_VERSION=CSHARP_AVRO_VERSION,
                         NEWTONSOFT_JSON_VERSION=NEWTONSOFT_JSON_VERSION,
                         SYSTEM_TEXT_JSON_VERSION=SYSTEM_TEXT_JSON_VERSION,
                         SYSTEM_MEMORY_DATA_VERSION=SYSTEM_MEMORY_DATA_VERSION,
+                        PROTOBUF_NET_VERSION=PROTOBUF_NET_VERSION,
+                        MSGPACK_VERSION=MSGPACK_VERSION,
                         NUNIT_VERSION=NUNIT_VERSION,
                         NUNIT_ADAPTER_VERSION=NUNIT_ADAPTER_VERSION,
                         MSTEST_SDK_VERSION=MSTEST_SDK_VERSION))
@@ -988,9 +1051,39 @@ class AvroToCSharp:
                         system_xml_annotation=self.system_xml_annotation,
                         system_text_json_annotation=self.system_text_json_annotation,
                         newtonsoft_json_annotation=self.newtonsoft_json_annotation,
+                        protobuf_net_annotation=self.protobuf_net_annotation,
                         NUNIT_VERSION=NUNIT_VERSION,
                         NUNIT_ADAPTER_VERSION=NUNIT_ADAPTER_VERSION,
-                        MSTEST_SDK_VERSION=MSTEST_SDK_VERSION))
+                        MSTEST_SDK_VERSION=MSTEST_SDK_VERSION,
+                        COVERLET_VERSION=COVERLET_VERSION))
+
+        # Generate coverage scripts
+        if not os.path.exists(os.path.join(output_dir, "run_coverage.ps1")):
+            coverage_ps1_file = os.path.join(output_dir, "run_coverage.ps1")
+            with open(coverage_ps1_file, 'w', encoding='utf-8') as file:
+                file.write(process_template(
+                    "avrotocsharp/run_coverage.ps1.jinja", 
+                    project_name=project_name))
+        
+        if not os.path.exists(os.path.join(output_dir, "run_coverage.sh")):
+            coverage_sh_file = os.path.join(output_dir, "run_coverage.sh")
+            with open(coverage_sh_file, 'w', encoding='utf-8') as file:
+                file.write(process_template(
+                    "avrotocsharp/run_coverage.sh.jinja", 
+                    project_name=project_name))
+            # Make the shell script executable on Unix-like systems
+            try:
+                os.chmod(coverage_sh_file, 0o755)
+            except:
+                pass  # Ignore on Windows
+        
+        # Generate README with coverage documentation
+        if not os.path.exists(os.path.join(output_dir, "README.md")):
+            readme_file = os.path.join(output_dir, "README.md")
+            with open(readme_file, 'w', encoding='utf-8') as file:
+                file.write(process_template(
+                    "avrotocsharp/README.md.jinja", 
+                    project_name=project_name))
 
         self.output_dir = output_dir
         for avro_schema in (avs for avs in schema if isinstance(avs, dict)):
@@ -1012,8 +1105,10 @@ def convert_avro_to_csharp(
     pascal_properties=False, 
     system_text_json_annotation=False, 
     newtonsoft_json_annotation=False, 
-    system_xml_annotation=False,  # New parameter
-    avro_annotation=False
+    system_xml_annotation=False,
+    msgpack_annotation=False,
+    avro_annotation=False,
+    protobuf_net_annotation=False
 ):
     """Converts Avro schema to C# classes
 
@@ -1026,7 +1121,9 @@ def convert_avro_to_csharp(
         system_text_json_annotation (bool, optional): Use System.Text.Json annotations. Defaults to False.
         newtonsoft_json_annotation (bool, optional): Use Newtonsoft.Json annotations. Defaults to False.
         system_xml_annotation (bool, optional): Use System.Xml.Serialization annotations. Defaults to False.
+        msgpack_annotation (bool, optional): Use MessagePack annotations. Defaults to False.
         avro_annotation (bool, optional): Use Avro annotations. Defaults to False.
+        protobuf_net_annotation (bool, optional): Use protobuf-net annotations. Defaults to False.
     """
 
     if not base_namespace:
@@ -1036,8 +1133,10 @@ def convert_avro_to_csharp(
     avrotocs.pascal_properties = pascal_properties
     avrotocs.system_text_json_annotation = system_text_json_annotation
     avrotocs.newtonsoft_json_annotation = newtonsoft_json_annotation
-    avrotocs.system_xml_annotation = system_xml_annotation  # Set the flag
+    avrotocs.system_xml_annotation = system_xml_annotation
+    avrotocs.msgpack_annotation = msgpack_annotation
     avrotocs.avro_annotation = avro_annotation
+    avrotocs.protobuf_net_annotation = protobuf_net_annotation
     avrotocs.convert(avro_schema_path, cs_file_path)
 
 
@@ -1049,8 +1148,10 @@ def convert_avro_schema_to_csharp(
     pascal_properties: bool = False, 
     system_text_json_annotation: bool = False, 
     newtonsoft_json_annotation: bool = False, 
-    system_xml_annotation: bool = False,  # New parameter
-    avro_annotation: bool = False
+    system_xml_annotation: bool = False,
+    msgpack_annotation: bool = False,
+    avro_annotation: bool = False,
+    protobuf_net_annotation: bool = False
 ):
     """Converts Avro schema to C# classes
 
@@ -1063,13 +1164,17 @@ def convert_avro_schema_to_csharp(
         system_text_json_annotation (bool, optional): Use System.Text.Json annotations. Defaults to False.
         newtonsoft_json_annotation (bool, optional): Use Newtonsoft.Json annotations. Defaults to False.
         system_xml_annotation (bool, optional): Use System.Xml.Serialization annotations. Defaults to False.
+        msgpack_annotation (bool, optional): Use MessagePack annotations. Defaults to False.
         avro_annotation (bool, optional): Use Avro annotations. Defaults to False.
+        protobuf_net_annotation (bool, optional): Use protobuf-net annotations. Defaults to False.
     """
     avrotocs = AvroToCSharp(base_namespace)
     avrotocs.project_name = project_name
     avrotocs.pascal_properties = pascal_properties
     avrotocs.system_text_json_annotation = system_text_json_annotation
     avrotocs.newtonsoft_json_annotation = newtonsoft_json_annotation
-    avrotocs.system_xml_annotation = system_xml_annotation  # Set the flag
+    avrotocs.system_xml_annotation = system_xml_annotation
+    avrotocs.msgpack_annotation = msgpack_annotation
     avrotocs.avro_annotation = avro_annotation
+    avrotocs.protobuf_net_annotation = protobuf_net_annotation
     avrotocs.convert_schema(avro_schema, output_dir)