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

retab/utils/mime.py

@@ -0,0 +1,165 @@
+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

@@ -0,0 +1,169 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,301 @@
+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)