Translation Algorithms

from typing import Protocol
from tinbox.core.translation import ModelInterface, TranslationRequest, TranslationResponse

class ModelInterface(Protocol):
    async def translate(
        self,
        request: TranslationRequest,
    ) -> TranslationResponse:
        """Translate content using the model."""
        ...

    async def validate_model(self) -> bool:
        """Check if the model is available and properly configured."""
        ...

from tinbox.core.translation import TranslationRequest
from tinbox.core.types import ModelType

# Basic text translation
request = TranslationRequest(
    source_lang="en",
    target_lang="fr",
    content="Hello, world!",
    content_type="text/plain",
    model=ModelType.OPENAI,
    model_params={"model_name": "gpt-4o"},
)

# Translation with context
request = TranslationRequest(
    source_lang="en",
    target_lang="de",
    content="He said it was great.",
    context="[PREVIOUS_CHUNK]\nThe restaurant opened yesterday.\n[/PREVIOUS_CHUNK]",
    content_type="text/plain",
    model=ModelType.ANTHROPIC,
    model_params={"model_name": "claude-3-sonnet"},
)

# Translation with glossary and reasoning
from tinbox.core.types import Glossary, GlossaryEntry

glossary = Glossary(entries={"API": "API", "cloud": "Cloud"})

request = TranslationRequest(
    source_lang="en",
    target_lang="ja",
    content="The API connects to the cloud.",
    content_type="text/plain",
    model=ModelType.GEMINI,
    model_params={"model_name": "gemini-2.5-pro"},
    glossary=glossary,
    reasoning_effort="high",
)

from tinbox import translate_document, load_document, create_translator, TranslationConfig
from pathlib import Path

content = await load_document(Path("document.pdf"))
config = TranslationConfig(...)
translator = create_translator(config)

response = await translate_document(content, config, translator)

print(f"Translated text: {response.text[:100]}...")
print(f"Tokens used: {response.tokens_used:,}")
print(f"Cost: ${response.cost:.4f}")
print(f"Time taken: {response.time_taken:.2f}s")

if response.failed_pages:
    print(f"Failed pages: {response.failed_pages}")
    for page, error in response.page_errors.items():
        print(f"  Page {page}: {error}")

if response.warnings:
    for warning in response.warnings:
        print(f"Warning: {warning}")

if response.glossary_updates:
    print(f"New glossary entries: {len(response.glossary_updates)}")
    for entry in response.glossary_updates:
        print(f"  {entry.term} -> {entry.translation}")

config = TranslationConfig(
    ...,
    algorithm="page",
)

config = TranslationConfig(
    ...,
    algorithm="sliding-window",
    window_size=3000,  # Characters per window
    overlap_size=300,  # Overlap between windows
)

config = TranslationConfig(
    ...,
    algorithm="context-aware",
    context_size=2500,  # Target chunk size
)

# Or with custom split token
config = TranslationConfig(
    ...,
    algorithm="context-aware",
    custom_split_token="\n---\n",  # Split on horizontal rules
)

[PREVIOUS_CHUNK]
The previous section's content...
[/PREVIOUS_CHUNK]

[PREVIOUS_CHUNK_TRANSLATION]
Die Übersetzung des vorherigen Abschnitts...
[/PREVIOUS_CHUNK_TRANSLATION]

[NEXT_CHUNK]
The next section's content...
[/NEXT_CHUNK]

Use this context to maintain consistency in terminology and style.

from tinbox.core.translation import TranslationError
from tinbox import translate_document

try:
    result = await translate_document(content, config, translator)
except TranslationError as e:
    print(f"Translation failed: {e}")

from tinbox import translate_document, load_document, create_translator, TranslationConfig
from pathlib import Path

# Load document once
content = await load_document(Path("document.pdf"))

# Page-by-page (fastest)
config_page = TranslationConfig(
    source_lang="en",
    target_lang="de",
    model="openai",
    model_name="gpt-4o",
    algorithm="page",
    input_file=Path("document.pdf"),
)
translator = create_translator(config_page)
result_page = await translate_document(content, config_page, translator)

# Sliding window (balanced)
config_window = config_page.model_copy(update={
    "algorithm": "sliding-window",
    "window_size": 3000,
    "overlap_size": 300,
})
result_window = await translate_document(content, config_window, translator)

# Context-aware (highest quality)
config_context = config_page.model_copy(update={
    "algorithm": "context-aware",
    "context_size": 2500,
    "use_glossary": True,
})
result_context = await translate_document(content, config_context, translator)

print(f"Page: {result_page.cost:.2f}, {result_page.time_taken:.1f}s")
print(f"Window: {result_window.cost:.2f}, {result_window.time_taken:.1f}s")
print(f"Context: {result_context.cost:.2f}, {result_context.time_taken:.1f}s")

from tinbox.core.translation import TranslationError

try:
    result = await translate_document(content, config, translator)
    
    # Check for partial failures
    if result.failed_pages:
        print(f"Warning: {len(result.failed_pages)} pages failed")
        for page in result.failed_pages:
            error = result.page_errors.get(page, "Unknown error")
            print(f"  Page {page}: {error}")
    
    # Check warnings
    for warning in result.warnings:
        print(f"Warning: {warning}")
        
except TranslationError as e:
    print(f"Translation failed completely: {e}")
    # Handle total failure

from tinbox.core.translation import TranslationRequest, create_translator
from tinbox.core.types import ModelType

# Create translator
config = TranslationConfig(...)
translator = create_translator(config)

# Manual translation with custom context
request = TranslationRequest(
    source_lang="en",
    target_lang="fr",
    content="This improves the quality significantly.",
    context="""[PREVIOUS_CHUNK]
We implemented the new algorithm.
[/PREVIOUS_CHUNK]

[PREVIOUS_CHUNK_TRANSLATION]
Nous avons implémenté le nouvel algorithme.
[/PREVIOUS_CHUNK_TRANSLATION]

Use this context to maintain consistency.""",
    content_type="text/plain",
    model=ModelType.ANTHROPIC,
    model_params={"model_name": "claude-3-sonnet"},
)

response = await translator.translate(request)
print(response.text)