⚡️ Speed up method AsyncTranscriptions.create by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for AsyncTranscriptions.create in src/together/resources/audio/transcriptions.py

⏱️ Runtime : 445 microseconds → 420 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 5% runtime improvement and 0.6% throughput increase through several targeted optimizations:

Key Optimizations:

1. Session Context Management (APIRequestor.arequest):

   • Replaced manual ctx.__aenter__() and ctx.__aexit__() calls with async with AioHTTPSession() context manager
   • This eliminates redundant context management overhead and ensures proper resource cleanup
   • Line profiler shows the session setup time reduced from 4.35ms to part of the 6.89ms context entry

2. File Type Checking Optimization (AsyncTranscriptions.create):

   • Pre-computed file_is_str = isinstance(file, str) and file_is_path = isinstance(file, Path) to cache type checks
   • Avoided double Path(file) conversion by using file if file_is_path else Path(file)
   • Reduced redundant isinstance() calls in the file handling logic

3. Parameter Processing Efficiency:

   • Pre-computed param_format using getattr(response_format, "value", response_format) to avoid repeated attribute lookups
   • Simplified boolean conversion from str(value).lower() to direct "true" if value else "false"
   • Streamlined the timestamp granularities handling with cached attribute access

4. File Cleanup Simplification:

   • Replaced nested dictionary checks with direct files_data.get("file") for cleaner file object retrieval
   • Maintained the same safety checks but with fewer operations

Performance Impact:
The optimizations particularly benefit scenarios with frequent API calls and file operations. The 5% runtime improvement comes primarily from reduced context management overhead and fewer redundant type checks. The throughput improvement (651 vs 647 ops/second) indicates better resource utilization, especially valuable for batch transcription workloads where these micro-optimizations compound across many requests.

These changes are most effective for high-frequency transcription scenarios where the reduced per-operation overhead accumulates to meaningful performance gains.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import asyncio  # For async execution and concurrency
import io  # For creating in-memory file objects
import os  # For environment variable manipulation
import tempfile  # For temporary file creation
import types  # For mock types
from pathlib import Path

import pytest  # For unit testing
from together import error
from together.abstract import api_requestor
from together.resources.audio.transcriptions import AsyncTranscriptions
from together.types import (AudioTranscriptionResponse,
                            AudioTranscriptionResponseFormat,
                            AudioTranscriptionVerboseResponse, TogetherClient,
                            TogetherRequest)

# --- MOCKING HELPERS ---

class DummyTogetherResponse:
    """A dummy response object mimicking TogetherResponse."""
    def __init__(self, data):
        self.data = data

class DummyClient:
    """A dummy TogetherClient for test instantiation."""
    def __init__(
        self,
        base_url=None,
        api_key="test-api-key",
        max_retries=None,
        supplied_headers=None,
        timeout=None,
    ):
        self.base_url = base_url
        self.api_key = api_key
        self.max_retries = max_retries
        self.supplied_headers = supplied_headers
        self.timeout = timeout

class DummyAPIRequestor(api_requestor.APIRequestor):
    """A dummy APIRequestor that returns canned responses for testing."""

    async def arequest(self, options, stream=False, request_timeout=None):
        # Simulate different responses based on params
        params = options.params
        files = options.files
        # Simulate error if model is purposely invalid
        if params.get("model") == "invalid-model":
            raise error.APIConnectionError("Invalid model")
        # Simulate error if file param is purposely invalid
        if files.get("file") == "badfile":
            raise error.APIConnectionError("Invalid file")
        # Simulate verbose_json response
        if params.get("response_format") in ("verbose_json", AudioTranscriptionResponseFormat.VERBOSE_JSON):
            return DummyTogetherResponse(
                {
                    "text": "This is a verbose transcript.",
                    "segments": [{"start": 0.0, "end": 1.0, "text": "Hello world"}],
                    "words": [{"start": 0.0, "end": 0.5, "word": "Hello"}],
                    "language": params.get("language", "en"),
                }
            ), False, "api-key"
        # Simulate normal json response
        return DummyTogetherResponse(
            {
                "text": "This is a transcript.",
                "language": params.get("language", "en"),
            }
        ), False, "api-key"

@pytest.fixture
def dummy_client(monkeypatch):
    """Fixture to provide an AsyncTranscriptions instance with a dummy APIRequestor."""
    client = DummyClient()
    transcriber = AsyncTranscriptions(client)
    # Patch the APIRequestor with our dummy
    monkeypatch.setattr(api_requestor, "APIRequestor", DummyAPIRequestor)
    return transcriber

# --- BASIC TEST CASES ---

@pytest.mark.asyncio
async def test_create_with_file_path_basic(dummy_client, tmp_path):
    """Test create with a valid file path and default params."""
    # Create a small temp audio file
    file_path = tmp_path / "audio.wav"
    file_path.write_bytes(b"RIFF....WAVEfmt ")  # Write minimal WAV header
    result = await dummy_client.create(file=file_path)

@pytest.mark.asyncio

async def test_create_with_url_string_basic(dummy_client):
    """Test create with a URL string as the file parameter."""
    url = "https://example.com/audio.mp3"
    result = await dummy_client.create(file=url)

@pytest.mark.asyncio




async def test_create_with_invalid_model_raises(dummy_client):
    """Test create with an invalid model triggers APIConnectionError."""
    file_obj = io.BytesIO(b"FAKEAUDIO")
    with pytest.raises(error.APIConnectionError):
        await dummy_client.create(file=file_obj, model="invalid-model")

@pytest.mark.asyncio

async def test_create_closes_file_on_exception(tmp_path, monkeypatch):
    """Test that create closes the file if an exception occurs."""
    class FailingAPIRequestor(DummyAPIRequestor):
        async def arequest(self, options, stream=False, request_timeout=None):
            raise error.APIConnectionError("Simulated error")
    monkeypatch.setattr(api_requestor, "APIRequestor", FailingAPIRequestor)
    file_path = tmp_path / "audio.wav"
    file_path.write_bytes(b"RIFF....WAVEfmt ")
    transcriber = AsyncTranscriptions(DummyClient())
    try:
        with pytest.raises(error.APIConnectionError):
            await transcriber.create(file=file_path)
    finally:
        # File should be closed (no open file handles remain)
        pass  # On most OS, file closes automatically, but this checks for leaks

@pytest.mark.asyncio

async def test_create_with_path_object(dummy_client, tmp_path):
    """Test create with a pathlib.Path object as file."""
    file_path = tmp_path / "audio.mp3"
    file_path.write_bytes(b"FAKEAUDIO")
    result = await dummy_client.create(file=file_path)

# --- CONCURRENT EXECUTION / LARGE SCALE TEST CASES ---

@pytest.mark.asyncio




#------------------------------------------------
import asyncio
import io
import os
# Patch the imported names in the module under test
import sys
import tempfile
import types
from pathlib import Path
from types import SimpleNamespace

import pytest
from together.resources.audio.transcriptions import AsyncTranscriptions
# Patch the response classes and formats for direct import
from together.types import (AudioTranscriptionResponse,
                            AudioTranscriptionResponseFormat,
                            AudioTranscriptionVerboseResponse)


# Mocks and stubs for required classes and constants
class DummyTogetherClient:
    def __init__(
        self,
        base_url=None,
        api_key="test_api_key",
        max_retries=None,
        supplied_headers=None,
        timeout=None,
    ):
        self.base_url = base_url
        self.api_key = api_key
        self.max_retries = max_retries
        self.supplied_headers = supplied_headers
        self.timeout = timeout



# Helper for creating a dummy file-like object
def make_dummy_file(content=b"audio"):
    return io.BytesIO(content)

@pytest.mark.asyncio






async def test_create_edge_file_path_not_found(tmp_path):
    # Test with a file path that does not exist
    file_path = tmp_path / "does_not_exist.wav"
    client = DummyTogetherClient()
    transcriber = AsyncTranscriptions(client)
    with pytest.raises(FileNotFoundError):
        await transcriber.create(file=str(file_path))

@pytest.mark.asyncio
async def test_create_edge_invalid_file_type():
    # Test with an invalid file type (e.g., integer)
    client = DummyTogetherClient()
    transcriber = AsyncTranscriptions(client)
    with pytest.raises(TypeError):
        await transcriber.create(file=12345)

@pytest.mark.asyncio

To edit these changes git checkout codeflash/optimize-AsyncTranscriptions.create-mh00j2to and push.