Cost Tracking

def estimate_cost(
    file_path: Path,
    model: ModelType,
    *,
    algorithm: str = "page",
    max_cost: float | None = None,
    use_glossary: bool = False,
    reasoning_effort: str = "minimal",
) -> CostEstimate:
    """Estimate the cost of translating a document."""
    estimated_tokens = estimate_document_tokens(file_path)
    input_cost_per_1k, output_cost_per_1k = MODEL_COSTS.get(model, (0.0, 0.0))
    
    # Calculate input tokens based on algorithm
    if algorithm == "context-aware":
        input_tokens = estimate_context_aware_tokens(estimated_tokens)
        output_tokens = estimated_tokens
    else:
        input_tokens = estimated_tokens
        output_tokens = estimated_tokens
    
    # Add prompt overhead (3%)
    prompt_factor = 0.03
    input_tokens = math.ceil(input_tokens * (1 + prompt_factor))
    
    # Add glossary overhead (20% if enabled)
    if use_glossary:
        glossary_overhead = math.ceil((input_tokens + output_tokens) * 0.20)
        input_tokens += glossary_overhead
    
    input_cost = (input_tokens / 1000) * input_cost_per_1k
    output_cost = (output_tokens / 1000) * output_cost_per_1k
    estimated_cost = input_cost + output_cost

def estimate_document_tokens(file_path: Path) -> int:
    """Estimate the number of tokens in a document."""
    file_type = FileType(file_path.suffix.lstrip(".").lower())
    
    if file_type == FileType.PDF:
        # Rough estimate: 500 tokens per page
        import pypdf
        with open(file_path, "rb") as f:
            pdf = pypdf.PdfReader(f)
            return len(pdf.pages) * 500
    
    elif file_type == FileType.DOCX:
        # Rough estimate: 1.3 tokens per word, rounded up
        from docx import Document
        doc = Document(file_path)
        word_count = sum(len(p.text.split()) for p in doc.paragraphs)
        return int(word_count * 1.3 + 0.999)
    
    else:  # TXT
        # Rough estimate: 1 token per 4 characters, rounded up
        text = file_path.read_text()
        return -(-len(text) // 4)  # Ceiling division

MODEL_COSTS: dict[ModelType, tuple[float, float]] = {
    ModelType.OPENAI: (
        0.00125,  # $0.00125 per 1K input tokens
        0.01,     # $0.01 per 1K output tokens (GPT-5)
    ),
    ModelType.ANTHROPIC: (
        0.003,    # $0.003 per 1K input tokens
        0.015,    # $0.015 per 1K output tokens (Sonnet 4)
    ),
    ModelType.GEMINI: (
        0.00125,  # $0.00125 per 1K input tokens
        0.01,     # $0.01 per 1K output tokens (Gemini 2.5 Pro)
    ),
    ModelType.OLLAMA: (0.0, 0.0),  # Free for local models
}

class CostLevel(str, Enum):
    LOW = "low"          # < $1
    MEDIUM = "medium"    # $1-$5
    HIGH = "high"        # $5-$20
    VERY_HIGH = "very_high"  # > $20

def get_cost_level(cost: float) -> CostLevel:
    if cost < 1.0:
        return CostLevel.LOW
    elif cost < 5.0:
        return CostLevel.MEDIUM
    elif cost < 20.0:
        return CostLevel.HIGH
    else:
        return CostLevel.VERY_HIGH

def estimate_context_aware_tokens(
    estimated_tokens: int, 
    context_multiplier: float = 4
) -> int:
    """Estimate input tokens for context-aware translation.
    
    Context-aware algorithm uses more input tokens due to:
    - Previous chunk context
    - Previous translation context
    - Translation instructions
    """
    return math.ceil(estimated_tokens * context_multiplier)

warnings = []

if model != ModelType.OLLAMA:
    # Large document warning
    if estimated_total_tokens > 50000:
        warnings.append(
            f"Large document detected ({estimated_total_tokens:,} tokens). "
            "Consider using Ollama for no cost."
        )
    
    # Context-aware overhead warning
    if algorithm == "context-aware":
        context_overhead = input_tokens - estimated_tokens
        warnings.append(
            f"Context-aware algorithm uses additional input tokens for context "
            f"(+{context_overhead:,} tokens, ~{context_overhead * 100 // estimated_tokens}% overhead). "
            f"This improves translation quality but increases cost."
        )
    
    # Glossary overhead warning
    if use_glossary:
        warnings.append(
            f"Glossary enabled adds input token overhead (~20% of total tokens)."
        )
    
    # Max cost exceeded warning
    if max_cost and estimated_cost > max_cost:
        warnings.append(
            f"Estimated cost (${estimated_cost:.2f}) exceeds maximum "
            f"threshold (${max_cost:.2f})"
        )

# Reasoning effort warning (applies to all models)
if reasoning_effort != "minimal":
    warnings.append(
        f"Reasoning effort is '{reasoning_effort}', which means cost and time estimations are unreliable and will be much higher. "
        f"Make sure to set a --max-cost and keep an eye on the live cost and time predictions in the progress bar."
    )

class CostEstimate:
    """Cost estimate for a translation task."""
    
    def __init__(
        self,
        estimated_tokens: int,
        estimated_cost: float,
        estimated_time: float,
        warnings: list[str],
    ) -> None:
        self.estimated_tokens = estimated_tokens
        self.estimated_cost = estimated_cost
        self.estimated_time = estimated_time
        self.warnings = warnings
        self.cost_level = get_cost_level(estimated_cost)

from tinbox.core.translation.interface import TranslationResponse

response = await translator.translate(request)
print(f"Tokens used: {response.tokens_used}")
print(f"Cost: ${response.cost:.4f}")
print(f"Time taken: {response.time_taken:.2f}s")

Translating pages... ━━━━━━━━━━━━━━━━━━━━ 15/20 75% $2.34

tinbox translate --to de --max-cost 10.00 document.pdf

if config.max_cost and total_cost > config.max_cost:
    raise TranslationError(
        f"Translation cost of {total_cost:.2f} exceeded maximum cost of {config.max_cost:.2f}"
    )

# Assume 30 tokens/second for cloud models, 20 tokens/second for local
tokens_per_second = 20 if model == ModelType.OLLAMA else 30
estimated_time = output_tokens / tokens_per_second

tinbox translate --to de --model openai document.pdf

# Estimated tokens: ~5,000 (500 per page)
# Input cost: $0.00625 (5K × $0.00125)
# Output cost: $0.05 (5K × $0.01)
# Total: ~$0.056
# Cost level: LOW

tinbox translate --to de --model openai --algorithm context-aware document.pdf

# Estimated tokens: ~25,000 base (500 per page)
# Input tokens: ~100,000 (4x context overhead)
# Input cost: $0.125 (100K × $0.00125)
# Output cost: $0.25 (25K × $0.01)
# Total: ~$0.375
# Cost level: LOW

tinbox translate --to ja --model anthropic --use-glossary novel.docx

# Estimated tokens: ~100,000 base
# With glossary: ~120,000 total
# Input cost: $0.36 (120K × $0.003)
# Output cost: $1.80 (120K × $0.015)
# Total: ~$2.16
# Cost level: MEDIUM

tinbox translate --to es --model openai --reasoning-effort high \
  --max-cost 50.00 manual.pdf

# Warning: Cost estimation unreliable with high reasoning
# Actual cost may be 10-20x higher than estimate
# Always set --max-cost with reasoning models!

tinbox translate --to de --force document.pdf

force: bool = Field(
    default=False,
    description="Whether to skip cost and size warnings",
)