⚡️ Speed up method AudioTranscriptionRequest.serialize_model by 18%

[codeflash-ai]

📄 18% (0.18x) speedup for AudioTranscriptionRequest.serialize_model in src/mistralai/models/audiotranscriptionrequest.py

⏱️ Runtime : 1.87 milliseconds → 1.58 milliseconds (best of 93 runs)

📝 Explanation and details

The optimized code achieves an 18% speedup through several algorithmic and memory efficiency improvements:

Key Optimizations:

1. O(1) membership testing: Converted optional_fields and nullable_fields from lists to sets, eliminating O(n) list scans in favor of O(1) hash lookups during the k in optional_fields checks in the loop.

2. Precomputed intersection: Created optional_nullable_fields = optional_fields_set & nullable_fields_set outside the loop to avoid repeatedly computing k in optional_fields and k in nullable_fields for each field.

3. Combined get/pop operation: Replaced separate serialized.get(k) and serialized.pop(k, None) calls with a single serialized.pop(k, None), reducing dictionary operations from 2 to 1 per iteration.

4. Eliminated set allocation: Changed self.__pydantic_fields_set__.intersection({n}) to direct membership test n in fields_set, avoiding temporary set creation for each field check.

5. Reduced attribute lookups: Cached self.__pydantic_fields_set__ and type(self).model_fields as local variables to avoid repeated attribute access.

Performance Impact:
The test results show consistent 11-23% improvements across various scenarios, with the best gains (20-23%) occurring in cases with multiple optional fields where the set-based lookups provide maximum benefit. The optimization is particularly effective for models with many fields, as evidenced by the test_many_instances_serialization showing 20.2% improvement when processing 100 instances.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 240 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

from typing import List, Literal, Optional

import pydantic
# imports
import pytest  # used for our unit tests
from mistralai.models.audiotranscriptionrequest import \
    AudioTranscriptionRequest
from typing_extensions import Annotated


# Minimal stubs for dependencies
class UNSET_SENTINEL:
    pass

UNSET = UNSET_SENTINEL()

class OptionalNullable:
    def __init__(self, value):
        self.value = value
    def __eq__(self, other):
        if isinstance(other, OptionalNullable):
            return self.value == other.value
        return self.value == other

class File:
    def __init__(self, filename):
        self.filename = filename
    def __eq__(self, other):
        if not isinstance(other, File):
            return False
        return self.filename == other.filename

class TimestampGranularity:
    def __init__(self, granularity):
        self.granularity = granularity
    def __eq__(self, other):
        if not isinstance(other, TimestampGranularity):
            return False
        return self.granularity == other.granularity

class FieldMetadata:
    def __init__(self, multipart=None):
        self.multipart = multipart

class MultipartFormMetadata:
    def __init__(self, file=None):
        self.file = file

class BaseModel(pydantic.BaseModel):
    pass
from mistralai.models.audiotranscriptionrequest import \
    AudioTranscriptionRequest


# Helper function for handler
def default_handler(obj):
    # Simulate Pydantic's serialization
    d = {}
    for name, field in obj.model_fields.items():
        k = field.alias or name
        d[k] = getattr(obj, name)
    return d

# unit tests

# -------- BASIC TEST CASES --------

def test_basic_required_only():
    # Only required field 'model' set
    req = AudioTranscriptionRequest(model="whisper-1")
    codeflash_output = req.serialize_model(default_handler); result = codeflash_output # 13.6μs -> 11.6μs (17.0% faster)





def test_edge_empty_list_granularities():
    # timestamp_granularities is an empty list
    req = AudioTranscriptionRequest(
        model="whisper-1",
        timestamp_granularities=[],
    )
    codeflash_output = req.serialize_model(default_handler); result = codeflash_output # 13.3μs -> 11.5μs (15.8% faster)

def test_edge_stream_field_alias():
    # STREAM field should be serialized as 'stream'
    req = AudioTranscriptionRequest(
        model="whisper-1",
        STREAM=False,
    )
    codeflash_output = req.serialize_model(default_handler); result = codeflash_output # 10.8μs -> 9.28μs (16.6% faster)

def test_edge_stream_field_default():
    # STREAM field default value
    req = AudioTranscriptionRequest(
        model="whisper-1",
    )
    codeflash_output = req.serialize_model(default_handler); result = codeflash_output # 10.5μs -> 9.04μs (15.6% faster)

def test_edge_file_field_none():
    # file field explicitly set to None
    req = AudioTranscriptionRequest(
        model="whisper-1",
        file=None,
    )
    codeflash_output = req.serialize_model(default_handler); result = codeflash_output # 10.1μs -> 8.80μs (14.9% faster)






#------------------------------------------------
from __future__ import annotations

from typing import List, Literal, Optional

import pydantic
# imports
import pytest
from mistralai.models.audiotranscriptionrequest import \
    AudioTranscriptionRequest
from mistralai.models.file import File
from mistralai.models.timestampgranularity import TimestampGranularity
from mistralai.types import UNSET, UNSET_SENTINEL, BaseModel, OptionalNullable
from mistralai.utils import (FieldMetadata, MultipartFormMetadata,
                             validate_const)
from pydantic import model_serializer
from pydantic.functional_validators import AfterValidator
from typing_extensions import Annotated


# Helper function to run the serializer with a simple handler
def handler(obj):
    # Pydantic's .dict() gives us the raw dict, including unset/None values
    # We need to include alias for fields like 'STREAM' -> 'stream'
    return obj.model_dump(by_alias=True, exclude_unset=False)

# Basic Test Cases

def test_minimal_required_fields():
    # Only required field 'model' is set
    req = AudioTranscriptionRequest(model="whisper-1")
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 40.2μs -> 35.4μs (13.7% faster)


def test_optional_fields_none():
    # Optional fields set to None should not appear except 'stream'
    req = AudioTranscriptionRequest(
        model="whisper-1",
        file=None,
        file_url=None,
        file_id=None,
        language=None,
        temperature=None,
        timestamp_granularities=None,
    )
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 23.2μs -> 19.4μs (19.1% faster)

def test_optional_fields_explicitly_set():
    # Set optional nullable fields explicitly (should appear)
    req = AudioTranscriptionRequest(
        model="whisper-1",
        file_url=None,
        file_id=None,
        language=None,
        temperature=None,
    )
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 17.8μs -> 14.5μs (22.9% faster)

def test_stream_alias_and_default():
    # Check that 'STREAM' field uses alias 'stream' and defaults to False
    req = AudioTranscriptionRequest(model="whisper-1")
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 33.9μs -> 30.2μs (12.4% faster)

def test_stream_explicit_false():
    # Explicitly set stream to False
    req = AudioTranscriptionRequest(model="whisper-1", STREAM=False)
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 29.7μs -> 26.7μs (11.3% faster)

# Edge Test Cases

def test_unset_sentinel_fields():
    # Fields set to UNSET should not appear in output
    req = AudioTranscriptionRequest(
        model="whisper-1",
        file_url=UNSET,
        file_id=UNSET,
        language=UNSET,
        temperature=UNSET,
    )
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 30.5μs -> 26.4μs (15.7% faster)

def test_empty_string_fields():
    # Fields set to empty string should appear
    req = AudioTranscriptionRequest(
        model="whisper-1",
        file_url="",
        file_id="",
        language="",
    )
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 23.1μs -> 19.8μs (16.6% faster)

def test_zero_temperature():
    # temperature=0.0 should appear and not be omitted
    req = AudioTranscriptionRequest(model="whisper-1", temperature=0.0)
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 26.7μs -> 23.6μs (13.1% faster)

def test_negative_temperature():
    # temperature negative value should be serialized
    req = AudioTranscriptionRequest(model="whisper-1", temperature=-1.0)
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 26.5μs -> 23.7μs (11.7% faster)

def test_timestamp_granularities_empty_list():
    # timestamp_granularities set to empty list should appear
    req = AudioTranscriptionRequest(model="whisper-1", timestamp_granularities=[])
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 28.8μs -> 26.5μs (8.61% faster)

def test_file_field_none_vs_unset():
    # file=None should not appear, file unset should not appear
    req_none = AudioTranscriptionRequest(model="whisper-1", file=None)
    req_unset = AudioTranscriptionRequest(model="whisper-1")
    codeflash_output = req_none.serialize_model(handler); result_none = codeflash_output # 28.3μs -> 26.0μs (8.90% faster)
    codeflash_output = req_unset.serialize_model(handler); result_unset = codeflash_output # 18.0μs -> 15.4μs (16.9% faster)


def test_stream_field_alias_and_case():
    # STREAM field should be serialized as 'stream' (lowercase)
    req = AudioTranscriptionRequest(model="whisper-1", STREAM=False)
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 38.8μs -> 34.4μs (12.7% faster)

def test_language_field_unicode():
    # Unicode language code should be serialized
    req = AudioTranscriptionRequest(model="whisper-1", language="日本語")
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 28.9μs -> 25.8μs (11.8% faster)

def test_file_url_field_none_and_is_set():
    # file_url explicitly set to None should appear
    req = AudioTranscriptionRequest(model="whisper-1", file_url=None)
    codeflash_output = req.serialize_model(handler); result = codeflash_output # 27.5μs -> 24.6μs (11.8% faster)

# Large Scale Test Cases



def test_many_instances_serialization():
    # Serialize many instances and check determinism
    for i in range(100):
        req = AudioTranscriptionRequest(model=f"whisper-{i}", language="en")
        codeflash_output = req.serialize_model(handler); result = codeflash_output # 1.39ms -> 1.16ms (20.2% faster)

To edit these changes git checkout codeflash/optimize-AudioTranscriptionRequest.serialize_model-mh32b16v and push.