retab 0.0.42__py3-none-any.whl → 0.0.43__py3-none-any.whl

retab/_utils/mime.py

@@ -1,165 +0,0 @@
-import base64
-import hashlib
-import io
-import json
-import mimetypes
-from pathlib import Path
-from typing import Sequence, TypeVar, get_args
-
-import httpx
-import PIL.Image
-import puremagic
-from pydantic import HttpUrl
-
-from ..types.mime import MIMEData
-from ..types.modalities import SUPPORTED_TYPES
-
-T = TypeVar("T")
-
-
-def generate_blake2b_hash_from_bytes(bytes_: bytes) -> str:
-    return hashlib.blake2b(bytes_, digest_size=8).hexdigest()
-
-
-def generate_blake2b_hash_from_base64(base64_string: str) -> str:
-    return generate_blake2b_hash_from_bytes(base64.b64decode(base64_string))
-
-
-def generate_blake2b_hash_from_string(input_string: str) -> str:
-    return generate_blake2b_hash_from_bytes(input_string.encode("utf-8"))
-
-
-def generate_blake2b_hash_from_dict(input_dict: dict) -> str:
-    return generate_blake2b_hash_from_string(json.dumps(input_dict, sort_keys=True).strip())
-
-
-def convert_pil_image_to_mime_data(image: PIL.Image.Image) -> MIMEData:
-    """Convert a PIL Image object to a MIMEData object.
-
-    Args:
-        image: PIL Image object to convert
-
-    Returns:
-        MIMEData object containing the image data
-    """
-    # Convert PIL image to base64 string
-    buffered = io.BytesIO()
-    choosen_format = image.format if (image.format and image.format.lower() in ["png", "jpeg", "gif", "webp"]) else "JPEG"
-    image.save(buffered, format=choosen_format)
-    base64_content = base64.b64encode(buffered.getvalue()).decode("utf-8")
-
-    content_hash = hashlib.sha256(base64_content.encode("utf-8")).hexdigest()
-
-    # Create MIMEData object
-    return MIMEData(filename=f"image_{content_hash}.{choosen_format.lower()}", url=f"data:image/{choosen_format.lower()};base64,{base64_content}")
-
-
-def convert_mime_data_to_pil_image(mime_data: MIMEData) -> PIL.Image.Image:
-    """Convert a MIMEData object to a PIL Image object.
-
-    Args:
-        mime_data: MIMEData object containing image data
-
-    Returns:
-        PIL Image object
-
-    Raises:
-        ValueError: If the MIMEData object does not contain image data
-    """
-    if not mime_data.mime_type.startswith("image/"):
-        raise ValueError("MIMEData object does not contain image data")
-
-    # Decode base64 content to bytes
-    image_bytes = base64.b64decode(mime_data.content)
-
-    # Create PIL Image from bytes
-    image = PIL.Image.open(io.BytesIO(image_bytes))
-
-    return image
-
-
-def prepare_mime_document(document: Path | str | bytes | io.IOBase | MIMEData | PIL.Image.Image | HttpUrl) -> MIMEData:
-    """
-    Convert documents (file paths or file-like objects) to MIMEData objects.
-
-    Args:
-        document: A path, string, bytes, or file-like object (IO[bytes])
-
-    Returns:
-        A MIMEData object
-    """
-    # Check if document is a HttpUrl (Pydantic type)
-
-    if isinstance(document, PIL.Image.Image):
-        return convert_pil_image_to_mime_data(document)
-
-    if isinstance(document, MIMEData):
-        return document
-
-    if isinstance(document, bytes):
-        # `document` is already the raw bytes
-        try:
-            extension = puremagic.from_string(document)
-            if extension.lower() in [".jpg", ".jpeg", ".jfif"]:
-                extension = ".jpeg"
-        except Exception:
-            extension = ".txt"
-        file_bytes = document
-        filename = "uploaded_file" + extension
-    elif isinstance(document, io.IOBase):
-        # `document` is a file-like object
-        file_bytes = document.read()
-        filename = getattr(document, "name", "uploaded_file")
-        filename = Path(filename).name
-    elif hasattr(document, "unicode_string") and callable(getattr(document, "unicode_string")):
-        with httpx.Client() as client:
-            url: str = document.unicode_string()  # type: ignore
-            response = client.get(url)
-            response.raise_for_status()
-            try:
-                extension = puremagic.from_string(response.content)
-                if extension.lower() in [".jpg", ".jpeg", ".jfif"]:
-                    extension = ".jpeg"
-            except Exception:
-                extension = ".txt"
-            file_bytes = response.content  # Fix: Use response.content instead of document
-            filename = "uploaded_file" + extension
-    else:
-        # `document` is a path or a string; cast it to Path
-        assert isinstance(document, (Path, str))
-        pathdoc = Path(document)
-        with open(pathdoc, "rb") as f:
-            file_bytes = f.read()
-        filename = pathdoc.name
-
-    # Base64-encode
-    encoded_content = base64.b64encode(file_bytes).decode("utf-8")
-    # Compute SHA-256 hash over the *base64-encoded* content
-    hash_obj = hashlib.sha256(encoded_content.encode("utf-8"))
-    hash_obj.hexdigest()
-
-    # Guess MIME type based on file extension
-    guessed_type, _ = mimetypes.guess_type(filename)
-    mime_type = guessed_type or "application/octet-stream"
-    # Build and return the MIMEData object
-    mime_data = MIMEData(filename=filename, url=f"data:{mime_type};base64,{encoded_content}")
-    assert_valid_file_type(mime_data.extension)  # <-- Validate extension as needed
-
-    return mime_data
-
-
-def prepare_mime_document_list(documents: Sequence[Path | str | bytes | MIMEData | io.IOBase | PIL.Image.Image]) -> list[MIMEData]:
-    """
-    Convert documents (file paths or file-like objects) to MIMEData objects.
-
-    Args:
-        documents: List of document paths or file-like objects
-
-    Returns:
-        List of MIMEData objects
-    """
-    return [prepare_mime_document(doc) for doc in documents]
-
-
-def assert_valid_file_type(file_extension: str) -> None:
-    assert "." + file_extension in get_args(SUPPORTED_TYPES), f"Invalid file type: {file_extension}. Must be one of: {get_args(SUPPORTED_TYPES)}"

retab/_utils/responses.py

@@ -1,169 +0,0 @@
-import datetime
-import json
-
-from jiter import from_json
-from openai.types.chat.chat_completion_content_part_image_param import ChatCompletionContentPartImageParam, ImageURL
-from openai.types.chat.chat_completion_content_part_param import ChatCompletionContentPartParam
-from openai.types.chat.chat_completion_content_part_text_param import ChatCompletionContentPartTextParam
-from openai.types.chat.parsed_chat_completion import ParsedChatCompletionMessage
-from openai.types.completion_usage import CompletionTokensDetails, CompletionUsage, PromptTokensDetails
-from openai.types.responses.easy_input_message_param import EasyInputMessageParam
-
-# from openai.types.responses.response_input_param import ResponseInputParam
-from openai.types.responses.response import Response
-from openai.types.responses.response_input_image_param import ResponseInputImageParam
-from openai.types.responses.response_input_message_content_list_param import ResponseInputMessageContentListParam
-from openai.types.responses.response_input_param import ResponseInputItemParam
-from openai.types.responses.response_input_text_param import ResponseInputTextParam
-
-from ..types.chat import ChatCompletionRetabMessage
-from ..types.documents.extractions import RetabParsedChatCompletion, RetabParsedChoice
-
-
-def convert_to_openai_format(messages: list[ChatCompletionRetabMessage]) -> list[ResponseInputItemParam]:
-    """
-    Converts a list of ChatCompletionRetabMessage to the OpenAI ResponseInputParam format.
-
-    Args:
-        messages: List of chat messages in UIForm format
-
-    Returns:
-        Messages in OpenAI ResponseInputParam format for the Responses API
-    """
-    formatted_messages: list[ResponseInputItemParam] = []
-
-    for message in messages:
-        role = message["role"]
-        content = message["content"]
-
-        # Handle different content formats
-        formatted_content: ResponseInputMessageContentListParam = []
-
-        if isinstance(content, str):
-            # Simple text content - provide direct string value
-            formatted_content.append(ResponseInputTextParam(text=content, type="input_text"))
-        elif isinstance(content, list):
-            # Content is a list of parts
-            for part in content:
-                if part["type"] == "text":
-                    formatted_content.append(ResponseInputTextParam(text=part["text"], type="input_text"))
-                elif part["type"] == "image_url":
-                    if "detail" in part["image_url"]:
-                        detail = part["image_url"]["detail"]
-                    else:
-                        detail = "high"
-                    formatted_content.append(ResponseInputImageParam(image_url=part["image_url"]["url"], type="input_image", detail=detail))
-                else:
-                    print(f"Not supported content type: {part['type']}... Skipping...")
-
-        # Create Message structure which is one of the types in ResponseInputItemParam
-        formatted_message = EasyInputMessageParam(role=role, content=formatted_content, type="message")
-
-        formatted_messages.append(formatted_message)
-
-    return formatted_messages
-
-
-def convert_from_openai_format(messages: list[ResponseInputItemParam]) -> list[ChatCompletionRetabMessage]:
-    """
-    Converts messages from OpenAI ResponseInputParam format to ChatCompletionRetabMessage format.
-
-    Args:
-        messages: Messages in OpenAI ResponseInputParam format
-
-    Returns:
-        List of chat messages in UIForm format
-    """
-    formatted_messages: list[ChatCompletionRetabMessage] = []
-
-    for message in messages:
-        if "role" not in message or "content" not in message:
-            # Mandatory fields for a message
-            if message.get("type") != "message":
-                print(f"Not supported message type: {message.get('type')}... Skipping...")
-            continue
-
-        role = message["role"]
-        content = message["content"]
-
-        if "type" not in message:
-            # The type is required by all other sub-types of ResponseInputItemParam except for EasyInputMessageParam and Message, which are messages.
-            message["type"] = "message"
-
-        role = message["role"]
-        content = message["content"]
-        formatted_content: str | list[ChatCompletionContentPartParam]
-
-        if isinstance(content, str):
-            formatted_content = content
-        else:
-            # Handle different content formats
-            formatted_content = []
-            for part in content:
-                if part["type"] == "input_text":
-                    formatted_content.append(ChatCompletionContentPartTextParam(text=part["text"], type="text"))
-                elif part["type"] == "input_image":
-                    image_url = part.get("image_url") or ""
-                    image_detail = part.get("detail") or "high"
-                    formatted_content.append(ChatCompletionContentPartImageParam(image_url=ImageURL(url=image_url, detail=image_detail), type="image_url"))
-                else:
-                    print(f"Not supported content type: {part['type']}... Skipping...")
-
-        # Create message in UIForm format
-        formatted_message = ChatCompletionRetabMessage(role=role, content=formatted_content)
-        formatted_messages.append(formatted_message)
-
-    return formatted_messages
-
-
-def parse_openai_responses_response(response: Response) -> RetabParsedChatCompletion:
-    """
-    Convert an OpenAI Response (Responses API) to RetabParsedChatCompletion type.
-
-    Args:
-        response: Response from OpenAI Responses API
-
-    Returns:
-        Parsed response in RetabParsedChatCompletion format
-    """
-    # Create the RetabParsedChatCompletion object
-    if response.usage:
-        usage = CompletionUsage(
-            prompt_tokens=response.usage.input_tokens,
-            completion_tokens=response.usage.output_tokens,
-            total_tokens=response.usage.total_tokens,
-            prompt_tokens_details=PromptTokensDetails(
-                cached_tokens=response.usage.input_tokens_details.cached_tokens,
-            ),
-            completion_tokens_details=CompletionTokensDetails(
-                reasoning_tokens=response.usage.output_tokens_details.reasoning_tokens,
-            ),
-        )
-    else:
-        usage = None
-
-    # Parse the ParsedChoice
-    choices = []
-    output_text = response.output_text
-    result_object = from_json(bytes(output_text, "utf-8"), partial_mode=True)  # Attempt to parse the result even if EOF is reached
-
-    choices.append(
-        RetabParsedChoice(
-            index=0,
-            message=ParsedChatCompletionMessage(
-                role="assistant",
-                content=json.dumps(result_object),
-            ),
-            finish_reason="stop",
-        )
-    )
-
-    return RetabParsedChatCompletion(
-        id=response.id,
-        choices=choices,
-        created=int(datetime.datetime.now().timestamp()),
-        model=response.model,
-        object="chat.completion",
-        likelihoods={},
-        usage=usage,
-    )

retab/_utils/stream_context_managers.py

@@ -1,52 +0,0 @@
-from contextlib import AbstractAsyncContextManager, AbstractContextManager
-from typing import Any, AsyncGenerator, Callable, Generator, TypeVar, Union
-
-T = TypeVar("T")
-
-
-class AsyncGeneratorContextManager(AbstractAsyncContextManager[AsyncGenerator[T, None]]):
-    def __init__(self, generator_func: Callable[..., AsyncGenerator[T, None]], *args: Any, **kwargs: Any):
-        self.generator_func = generator_func
-        self.args = args
-        self.kwargs = kwargs
-        self.iterator: Union[AsyncGenerator[T, None], None] = None
-
-    async def __aenter__(self) -> AsyncGenerator[T, None]:
-        # Create the asynchronous iterator from the generator function
-        self.iterator = self.generator_func(*self.args, **self.kwargs)
-        return self.iterator
-
-    async def __aexit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: Any) -> None:
-        # Ensure the iterator is properly closed if it supports aclose
-        if self.iterator is not None:
-            await self.iterator.aclose()
-
-
-class GeneratorContextManager(AbstractContextManager[Generator[T, None, None]]):
-    def __init__(self, generator_func: Callable[..., Generator[T, None, None]], *args: Any, **kwargs: Any):
-        self.generator_func = generator_func
-        self.args = args
-        self.kwargs = kwargs
-        self.iterator: Union[Generator[T, None, None], None] = None
-
-    def __enter__(self) -> Generator[T, None, None]:
-        self.iterator = self.generator_func(*self.args, **self.kwargs)
-        return self.iterator
-
-    def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: Any) -> None:
-        if self.iterator is not None:
-            self.iterator.close()
-
-
-def as_async_context_manager(func: Callable[..., AsyncGenerator[T, None]]) -> Callable[..., AsyncGeneratorContextManager[T]]:
-    def wrapper(*args: Any, **kwargs: Any) -> AsyncGeneratorContextManager[T]:
-        return AsyncGeneratorContextManager(func, *args, **kwargs)
-
-    return wrapper
-
-
-def as_context_manager(func: Callable[..., Generator[T, None, None]]) -> Callable[..., GeneratorContextManager[T]]:
-    def wrapper(*args: Any, **kwargs: Any) -> GeneratorContextManager[T]:
-        return GeneratorContextManager(func, *args, **kwargs)
-
-    return wrapper

retab/_utils/usage/usage.py

@@ -1,301 +0,0 @@
-from typing import Optional
-
-from openai.types.completion_usage import CompletionUsage
-from pydantic import BaseModel, Field
-
-# https://platform.openai.com/docs/guides/prompt-caching
-from ...types.ai_models import Amount, Pricing
-from ..._utils.ai_models import get_model_card
-
-# ─── PRICING MODELS ────────────────────────────────────────────────────────────
-
-
-def compute_api_call_cost(pricing: Pricing, usage: CompletionUsage, is_ft: bool = False) -> Amount:
-    """
-    Computes the price (as an Amount) for the given token usage, based on the pricing.
-
-    Assumptions / rules:
-      - The pricing rates are per 1,000,000 tokens.
-      - The usage is broken out into prompt and completion tokens.
-      - If details are provided, the prompt tokens are split into:
-          • cached text tokens (if any),
-          • audio tokens (if any), and
-          • the remaining are treated as "regular" text tokens.
-      - Similarly, completion tokens are split into audio tokens (if any) and the remaining text.
-      - For text tokens, if a cached price is not explicitly provided in pricing.text.cached,
-        we assume a 50% discount off the prompt price.
-      - (A similar rule could be applied to audio tokens – i.e. 20% of the normal price –
-       if cached audio tokens were provided. In our usage model, however, only text tokens
-       are marked as cached.)
-      - If is_ft is True, the price is adjusted using the ft_price_hike multiplier.
-    """
-
-    # ----- Process prompt tokens -----
-    prompt_cached_text = 0
-    prompt_audio = 0
-    if usage.prompt_tokens_details:
-        prompt_cached_text = usage.prompt_tokens_details.cached_tokens or 0
-        prompt_audio = usage.prompt_tokens_details.audio_tokens or 0
-
-    # The rest of the prompt tokens are assumed to be regular (non-cached) text tokens.
-    prompt_regular_text = usage.prompt_tokens - prompt_cached_text - prompt_audio
-
-    # ----- Process completion tokens -----
-    completion_audio = 0
-    if usage.completion_tokens_details:
-        completion_audio = usage.completion_tokens_details.audio_tokens or 0
-
-    # The rest are text tokens.
-    completion_regular_text = usage.completion_tokens - completion_audio
-
-    # ----- Calculate text token costs -----
-    # Regular prompt text tokens cost at the standard prompt rate.
-    cost_text_prompt = prompt_regular_text * pricing.text.prompt
-
-    # Cached text tokens: if the pricing model provides a cached rate, use it.
-    # Otherwise, apply a 50% discount (i.e. 0.5 * prompt price).
-    text_cached_price = pricing.text.prompt * pricing.text.cached_discount
-    cost_text_cached = prompt_cached_text * text_cached_price
-
-    # Completion text tokens cost at the standard completion rate.
-    cost_text_completion = completion_regular_text * pricing.text.completion
-
-    total_text_cost = cost_text_prompt + cost_text_cached + cost_text_completion
-
-    # ----- Calculate audio token costs (if any) -----
-    total_audio_cost = 0.0
-    if pricing.audio:
-        cost_audio_prompt = prompt_audio * pricing.audio.prompt
-        cost_audio_completion = completion_audio * pricing.audio.completion
-        total_audio_cost = cost_audio_prompt + cost_audio_completion
-
-    total_cost = (total_text_cost + total_audio_cost) / 1e6
-
-    # Apply fine-tuning price hike if applicable
-    if is_ft and hasattr(pricing, "ft_price_hike"):
-        total_cost *= pricing.ft_price_hike
-
-    return Amount(value=total_cost, currency="USD")
-
-
-def compute_cost_from_model(model: str, usage: CompletionUsage) -> Amount:
-    # Extract base model name for fine-tuned models like "ft:gpt-4o:retab:4389573"
-    is_ft = False
-    if model.startswith("ft:"):
-        # Split by colon and take the second part (index 1) which contains the base model
-        parts = model.split(":")
-        if len(parts) > 1:
-            model = parts[1]
-            is_ft = True
-
-    # Use the get_model_card function from types.ai_models
-    try:
-        model_card = get_model_card(model)
-        pricing = model_card.pricing
-    except ValueError:
-        raise ValueError(f"No pricing information found for model: {model}")
-
-    return compute_api_call_cost(pricing, usage, is_ft)
-
-
-########################
-# USELESS FOR NOW
-########################
-
-
-class CompletionsUsage(BaseModel):
-    """The aggregated completions usage details of the specific time bucket."""
-
-    object: str = Field(default="organization.usage.completions.result", description="Type identifier for the completions usage object")
-    input_tokens: int = Field(
-        description="The aggregated number of text input tokens used, including cached tokens. For customers subscribe to scale tier, this includes scale tier tokens."
-    )
-    input_cached_tokens: int = Field(
-        description="The aggregated number of text input tokens that has been cached from previous requests. For customers subscribe to scale tier, this includes scale tier tokens."
-    )
-    output_tokens: int = Field(description="The aggregated number of text output tokens used. For customers subscribe to scale tier, this includes scale tier tokens.")
-    input_audio_tokens: int = Field(description="The aggregated number of audio input tokens used, including cached tokens.")
-    output_audio_tokens: int = Field(description="The aggregated number of audio output tokens used.")
-    num_model_requests: int = Field(description="The count of requests made to the model.")
-    project_id: Optional[str] = Field(default=None, description="When group_by=project_id, this field provides the project ID of the grouped usage result.")
-    user_id: Optional[str] = Field(default=None, description="When group_by=user_id, this field provides the user ID of the grouped usage result.")
-    api_key_id: Optional[str] = Field(default=None, description="When group_by=api_key_id, this field provides the API key ID of the grouped usage result.")
-    model: Optional[str] = Field(default=None, description="When group_by=model, this field provides the model name of the grouped usage result.")
-    batch: Optional[bool] = Field(default=None, description="When group_by=batch, this field tells whether the grouped usage result is batch or not.")
-
-
-########################
-# DETAILED COST BREAKDOWN
-########################
-
-
-class TokenCounts(BaseModel):
-    """Detailed breakdown of token counts by type and category."""
-
-    # Prompt token counts
-    prompt_regular_text: int
-    prompt_cached_text: int
-    prompt_audio: int
-
-    # Completion token counts
-    completion_regular_text: int
-    completion_audio: int
-
-    # Total tokens (should match sum of all components)
-    total_tokens: int
-
-
-class CostBreakdown(BaseModel):
-    """Detailed breakdown of API call costs by token type and usage category."""
-
-    # Total cost amount
-    total: Amount
-
-    # Text token costs broken down by category
-    text_prompt_cost: Amount
-    text_cached_cost: Amount
-    text_completion_cost: Amount
-    text_total_cost: Amount
-
-    # Audio token costs broken down by category (if applicable)
-    audio_prompt_cost: Optional[Amount] = None
-    audio_completion_cost: Optional[Amount] = None
-    audio_total_cost: Optional[Amount] = None
-
-    # Token counts for reference
-    token_counts: TokenCounts
-
-    # Model and fine-tuning information
-    model: str
-    is_fine_tuned: bool = False
-
-
-def compute_api_call_cost_with_breakdown(pricing: Pricing, usage: CompletionUsage, model: str, is_ft: bool = False) -> CostBreakdown:
-    """
-    Computes a detailed price breakdown for the given token usage, based on the pricing.
-
-    Returns a CostBreakdown object containing costs broken down by token type and category.
-    """
-    # ----- Process prompt tokens -----
-    prompt_cached_text = 0
-    prompt_audio = 0
-    if usage.prompt_tokens_details:
-        prompt_cached_text = usage.prompt_tokens_details.cached_tokens or 0
-        prompt_audio = usage.prompt_tokens_details.audio_tokens or 0
-
-    # The rest of the prompt tokens are assumed to be regular (non-cached) text tokens.
-    prompt_regular_text = usage.prompt_tokens - prompt_cached_text - prompt_audio
-
-    # ----- Process completion tokens -----
-    completion_audio = 0
-    if usage.completion_tokens_details:
-        completion_audio = usage.completion_tokens_details.audio_tokens or 0
-
-    # The rest are text tokens.
-    completion_regular_text = usage.completion_tokens - completion_audio
-
-    # ----- Calculate text token costs -----
-    # Regular prompt text tokens cost at the standard prompt rate.
-    cost_text_prompt = prompt_regular_text * pricing.text.prompt
-
-    # Cached text tokens: if the pricing model provides a cached rate, use it.
-    # Otherwise, apply a 50% discount (i.e. 0.5 * prompt price).
-    text_cached_price = pricing.text.prompt * pricing.text.cached_discount
-    cost_text_cached = prompt_cached_text * text_cached_price
-
-    # Completion text tokens cost at the standard completion rate.
-    cost_text_completion = completion_regular_text * pricing.text.completion
-
-    total_text_cost = cost_text_prompt + cost_text_cached + cost_text_completion
-
-    # ----- Calculate audio token costs (if any) -----
-    cost_audio_prompt = 0.0
-    cost_audio_completion = 0.0
-    total_audio_cost = 0.0
-
-    if pricing.audio and (prompt_audio > 0 or completion_audio > 0):
-        cost_audio_prompt = prompt_audio * pricing.audio.prompt
-        cost_audio_completion = completion_audio * pricing.audio.completion
-        total_audio_cost = cost_audio_prompt + cost_audio_completion
-
-    # Convert to dollars (divide by 1M) and create Amount objects
-    ft_multiplier = pricing.ft_price_hike if is_ft else 1.0
-
-    # Create Amount objects for each cost category
-    text_prompt_amount = Amount(value=(cost_text_prompt / 1e6) * ft_multiplier, currency="USD")
-    text_cached_amount = Amount(value=(cost_text_cached / 1e6) * ft_multiplier, currency="USD")
-    text_completion_amount = Amount(value=(cost_text_completion / 1e6) * ft_multiplier, currency="USD")
-    text_total_amount = Amount(value=(total_text_cost / 1e6) * ft_multiplier, currency="USD")
-
-    # Audio amounts (if applicable)
-    audio_prompt_amount = None
-    audio_completion_amount = None
-    audio_total_amount = None
-
-    if pricing.audio and (prompt_audio > 0 or completion_audio > 0):
-        audio_prompt_amount = Amount(value=(cost_audio_prompt / 1e6) * ft_multiplier, currency="USD")
-        audio_completion_amount = Amount(value=(cost_audio_completion / 1e6) * ft_multiplier, currency="USD")
-        audio_total_amount = Amount(value=(total_audio_cost / 1e6) * ft_multiplier, currency="USD")
-
-    # Total cost
-    total_cost = (total_text_cost + total_audio_cost) / 1e6 * ft_multiplier
-    total_amount = Amount(value=total_cost, currency="USD")
-
-    # Create TokenCounts object with token usage breakdown
-    token_counts = TokenCounts(
-        prompt_regular_text=prompt_regular_text,
-        prompt_cached_text=prompt_cached_text,
-        prompt_audio=prompt_audio,
-        completion_regular_text=completion_regular_text,
-        completion_audio=completion_audio,
-        total_tokens=usage.total_tokens,
-    )
-
-    return CostBreakdown(
-        total=total_amount,
-        text_prompt_cost=text_prompt_amount,
-        text_cached_cost=text_cached_amount,
-        text_completion_cost=text_completion_amount,
-        text_total_cost=text_total_amount,
-        audio_prompt_cost=audio_prompt_amount,
-        audio_completion_cost=audio_completion_amount,
-        audio_total_cost=audio_total_amount,
-        token_counts=token_counts,
-        model=model,
-        is_fine_tuned=is_ft,
-    )
-
-
-def compute_cost_from_model_with_breakdown(model: str, usage: CompletionUsage) -> CostBreakdown:
-    """
-    Computes a detailed cost breakdown for an API call using the specified model and usage.
-
-    Args:
-        model: The model name (can be a fine-tuned model like "ft:gpt-4o:retab:4389573")
-        usage: Token usage statistics for the API call
-
-    Returns:
-        CostBreakdown object with detailed cost information
-
-    Raises:
-        ValueError: If no pricing information is found for the model
-    """
-    # Extract base model name for fine-tuned models like "ft:gpt-4o:retab:4389573"
-    original_model = model
-    is_ft = False
-
-    if model.startswith("ft:"):
-        # Split by colon and take the second part (index 1) which contains the base model
-        parts = model.split(":")
-        if len(parts) > 1:
-            model = parts[1]
-            is_ft = True
-
-    # Use the get_model_card function from types.ai_models
-    try:
-        model_card = get_model_card(model)
-        pricing = model_card.pricing
-    except ValueError:
-        raise ValueError(f"No pricing information found for model: {original_model}")
-
-    return compute_api_call_cost_with_breakdown(pricing, usage, original_model, is_ft)