⚡️ Speed up method AsyncTranscriptions.create by 6% - #19

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