wip

API_EXAMPLES.md

@@ -0,0 +1,235 @@
+# Esempi di Richieste API - Local Translation Server
+
+## Health Check
+
+```bash
+curl -X GET "http://localhost:8000/"
+```
+
+## Ottenere le lingue supportate
+
+```bash
+curl -X GET "http://localhost:8000/languages"
+```
+
+## Traduzione singola (GET con parametri)
+
+```bash
+# Traduzione semplice
+curl -X POST "http://localhost:8000/translate-single?text=Ciao%20mondo&target_language=en"
+
+# Traduzione con HTML
+curl -X POST "http://localhost:8000/translate-single?text=%3Cp%3ECiao%20%3Cstrong%3Emondo%3C/strong%3E%3C/p%3E&target_language=fr"
+
+# Traduzione con placeholder
+curl -X POST "http://localhost:8000/translate-single?text=Ciao%20%7Bname%7D%2C%20come%20stai%3F&target_language=de"
+```
+
+## Traduzione di oggetti locale complessi
+
+### Esempio base
+
+```bash
+curl -X POST "http://localhost:8000/translate?target_language=en" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "locales": {
+      "welcome": "Benvenuto!",
+      "save_button": "Salva",
+      "cancel_button": "Annulla"
+    }
+  }'
+```
+
+### Esempio con HTML e placeholder
+
+```bash
+curl -X POST "http://localhost:8000/translate?target_language=fr" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "locales": {
+      "welcome_message": "Benvenuto nella nostra applicazione, {username}!",
+      "notification_html": "<div class=\"alert alert-info\"><strong>Info:</strong> Hai {count} nuovi messaggi</div>",
+      "button_save": "Salva documento",
+      "error_required": "Questo campo è obbligatorio",
+      "success_message": "<p>Operazione completata con <em>successo</em>!</p>"
+    }
+  }'
+```
+
+### Esempio per applicazione web complessa
+
+```bash
+curl -X POST "http://localhost:8000/translate?target_language=de" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "locales": {
+      "nav_home": "Home",
+      "nav_products": "Prodotti",
+      "nav_contact": "Contatti",
+      "hero_title": "Benvenuto nel futuro",
+      "hero_subtitle": "La tecnologia che cambia il mondo",
+      "cta_button": "Scopri di più",
+      "form_name_label": "Nome completo",
+      "form_email_label": "Indirizzo email",
+      "form_message_label": "Il tuo messaggio",
+      "form_submit": "Invia messaggio",
+      "validation_required": "Questo campo è obbligatorio",
+      "validation_email": "Inserisci un indirizzo email valido",
+      "success_notification": "<div class=\"notification is-success\"><strong>Grazie!</strong> Il tuo messaggio è stato inviato</div>",
+      "error_notification": "<div class=\"notification is-danger\"><strong>Errore:</strong> Si è verificato un problema</div>",
+      "user_greeting": "Ciao {firstName}, bentornato!",
+      "items_count": "Hai {itemCount} elementi nel carrello",
+      "last_login": "Ultimo accesso: {lastLoginDate}",
+      "footer_copyright": "© 2024 La Nostra Azienda. Tutti i diritti riservati."
+    }
+  }'
+```
+
+### Traduzione verso lingue diverse
+
+```bash
+# Inglese
+curl -X POST "http://localhost:8000/translate?target_language=en" \
+  -H "Content-Type: application/json" \
+  -d '{"locales": {"greeting": "Buongiorno!", "goodbye": "Arrivederci!"}}'
+
+# Francese
+curl -X POST "http://localhost:8000/translate?target_language=fr" \
+  -H "Content-Type: application/json" \
+  -d '{"locales": {"greeting": "Buongiorno!", "goodbye": "Arrivederci!"}}'
+
+# Tedesco
+curl -X POST "http://localhost:8000/translate?target_language=de" \
+  -H "Content-Type: application/json" \
+  -d '{"locales": {"greeting": "Buongiorno!", "goodbye": "Arrivederci!"}}'
+
+# Spagnolo
+curl -X POST "http://localhost:8000/translate?target_language=es" \
+  -H "Content-Type: application/json" \
+  -d '{"locales": {"greeting": "Buongiorno!", "goodbye": "Arrivederci!"}}'
+
+# Russo
+curl -X POST "http://localhost:8000/translate?target_language=ru" \
+  -H "Content-Type: application/json" \
+  -d '{"locales": {"greeting": "Buongiorno!", "goodbye": "Arrivederci!"}}'
+
+# Giapponese
+curl -X POST "http://localhost:8000/translate?target_language=ja" \
+  -H "Content-Type: application/json" \
+  -d '{"locales": {"greeting": "Buongiorno!", "goodbye": "Arrivederci!"}}'
+
+# Cinese
+curl -X POST "http://localhost:8000/translate?target_language=zh" \
+  -H "Content-Type: application/json" \
+  -d '{"locales": {"greeting": "Buongiorno!", "goodbye": "Arrivederci!"}}'
+```
+
+## Test degli errori
+
+### Lingua non supportata
+
+```bash
+curl -X POST "http://localhost:8000/translate?target_language=xyz" \
+  -H "Content-Type: application/json" \
+  -d '{"locales": {"test": "Ciao"}}'
+```
+
+### Body malformato
+
+```bash
+curl -X POST "http://localhost:8000/translate?target_language=en" \
+  -H "Content-Type: application/json" \
+  -d '{"wrong_field": "test"}'
+```
+
+### Parametro mancante
+
+```bash
+curl -X POST "http://localhost:8000/translate" \
+  -H "Content-Type: application/json" \
+  -d '{"locales": {"test": "Ciao"}}'
+```
+
+## Esempi usando JavaScript (fetch)
+
+```javascript
+// Traduzione di oggetti locale
+const translateLocales = async () => {
+  const response = await fetch(
+    "http://localhost:8000/translate?target_language=en",
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        locales: {
+          welcome: "Benvenuto!",
+          save_button: "Salva",
+          cancel_button: "Annulla",
+        },
+      }),
+    }
+  );
+
+  const data = await response.json();
+  console.log(data);
+};
+
+// Ottenere lingue supportate
+const getSupportedLanguages = async () => {
+  const response = await fetch("http://localhost:8000/languages");
+  const data = await response.json();
+  console.log("Lingue supportate:", data.supported_languages);
+};
+
+// Traduzione singola
+const translateSingle = async () => {
+  const response = await fetch(
+    "http://localhost:8000/translate-single?text=Ciao mondo&target_language=en",
+    {
+      method: "POST",
+    }
+  );
+  const data = await response.json();
+  console.log(data);
+};
+```
+
+## Esempi usando Python (requests)
+
+```python
+import requests
+
+# Traduzione di oggetti locale
+def translate_locales():
+    url = "http://localhost:8000/translate"
+    params = {"target_language": "en"}
+    data = {
+        "locales": {
+            "welcome": "Benvenuto!",
+            "save_button": "Salva",
+            "cancel_button": "Annulla"
+        }
+    }
+
+    response = requests.post(url, json=data, params=params)
+    print(response.json())
+
+# Ottenere lingue supportate
+def get_supported_languages():
+    response = requests.get("http://localhost:8000/languages")
+    print(response.json())
+
+# Traduzione singola
+def translate_single():
+    url = "http://localhost:8000/translate-single"
+    params = {
+        "text": "Ciao mondo",
+        "target_language": "en"
+    }
+
+    response = requests.post(url, params=params)
+    print(response.json())
+```

Dockerfile

@@ -0,0 +1,27 @@
+# Local Translation Server Docker Image
+FROM python:3.9-slim
+
+# Installa le dipendenze di sistema necessarie
+RUN apt-get update && apt-get install -y \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Crea un utente non-root
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# Copia e installa i requirements
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copia il codice dell'applicazione
+COPY --chown=user . /app
+
+# Espone la porta 8000
+EXPOSE 8000
+
+# Avvia il server
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,13 +1,196 @@
----
-title: Locale Translate Server
-emoji: 🌐
-colorFrom: blue
-colorTo: yellow
-sdk: static
-pinned: false
-models:
-- Xenova/detr-resnet-50
-short_description: server used to translate web app locales from italian
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Local Translation Server
+
+Un servizio di traduzione locale che traduce oggetti JSON con locales dall'italiano ad altre lingue utilizzando il modello T5 di Hugging Face.
+
+## Caratteristiche
+
+- ✨ Traduzione automatica dall'italiano a più di 30 lingue
+- 🔧 Preserva i tag HTML e i placeholder con parentesi graffe
+- 🚀 API REST facile da usare
+- 🎯 Ottimizzato per oggetti locale di applicazioni web
+- 🏠 Completamente locale, nessun servizio esterno richiesto
+
+## Installazione
+
+1. Clona il repository:
+
+```bash
+git clone <repository-url>
+cd locale_translate_server
+```
+
+2. Installa le dipendenze:
+
+```bash
+pip install -r requirements.txt
+```
+
+3. Avvia il server:
+
+```bash
+python app.py
+```
+
+Il server sarà disponibile su `http://localhost:8000`
+
+## Uso dell'API
+
+### Endpoint Principali
+
+#### 1. Traduci Oggetti Locale - `POST /translate`
+
+Traduce un oggetto JSON contenente locales dall'italiano alla lingua specificata.
+
+**Parametri:**
+
+- `target_language` (query parameter): Codice della lingua target (es: "en", "fr", "de")
+
+**Body della richiesta:**
+
+```json
+{
+  "locales": {
+    "welcome_message": "Benvenuto nella nostra applicazione!",
+    "button_save": "Salva",
+    "error_required": "Questo campo è obbligatorio",
+    "html_content": "<p>Clicca <a href='#'>qui</a> per continuare</p>",
+    "template_message": "Ciao {name}, hai {count} nuovi messaggi"
+  }
+}
+```
+
+**Esempio di richiesta:**
+
+```bash
+curl -X POST "http://localhost:8000/translate?target_language=en" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "locales": {
+      "welcome": "Benvenuto!",
+      "save_btn": "Salva documento"
+    }
+  }'
+```
+
+**Risposta:**
+
+```json
+{
+  "translated_locales": {
+    "welcome": "Welcome!",
+    "save_btn": "Save document"
+  },
+  "source_language": "it",
+  "target_language": "en"
+}
+```
+
+#### 2. Traduci Singolo Testo - `POST /translate-single`
+
+Traduce un singolo testo per test rapidi.
+
+**Parametri:**
+
+- `text` (query parameter): Testo in italiano da tradurre
+- `target_language` (query parameter): Codice della lingua target
+
+**Esempio:**
+
+```bash
+curl -X POST "http://localhost:8000/translate-single?text=Ciao mondo&target_language=en"
+```
+
+#### 3. Lingue Supportate - `GET /languages`
+
+Restituisce la lista delle lingue supportate.
+
+**Risposta:**
+
+```json
+{
+  "supported_languages": ["en", "fr", "de", "es", "pt", "ru", "ja", "ko", "zh", ...]
+}
+```
+
+### Lingue Supportate
+
+Il servizio supporta traduzione verso le seguenti lingue:
+
+- **en** - English
+- **fr** - French
+- **de** - German
+- **es** - Spanish
+- **pt** - Portuguese
+- **ru** - Russian
+- **ja** - Japanese
+- **ko** - Korean
+- **zh** - Chinese
+- **ar** - Arabic
+- **hi** - Hindi
+- **nl** - Dutch
+- **sv** - Swedish
+- **da** - Danish
+- **no** - Norwegian
+- **fi** - Finnish
+- **pl** - Polish
+- **cs** - Czech
+- **hu** - Hungarian
+- **ro** - Romanian
+- **bg** - Bulgarian
+- **hr** - Croatian
+- **sk** - Slovak
+- **sl** - Slovenian
+- **et** - Estonian
+- **lv** - Latvian
+- **lt** - Lithuanian
+- **mt** - Maltese
+- **el** - Greek
+- **tr** - Turkish
+
+## Caratteristiche Speciali
+
+### Preservazione di HTML e Placeholder
+
+Il servizio preserva automaticamente:
+
+1. **Tag HTML**: `<p>`, `<a>`, `<strong>`, etc.
+2. **Placeholder con parentesi graffe**: `{name}`, `{count}`, `{date}`, etc.
+
+**Esempio:**
+
+```
+Input:  "Ciao {name}, hai <strong>{count}</strong> messaggi"
+Output: "Hello {name}, you have <strong>{count}</strong> messages"
+```
+
+## Configurazione
+
+Puoi configurare il servizio tramite variabili d'ambiente:
+
+- `MODEL_NAME`: Nome del modello T5 da utilizzare (default: "google/t5-v1_1-base")
+- `ENVIRONMENT`: Ambiente di esecuzione (default: "development")
+- `DEBUG`: Abilita debug logging (default: "true")
+
+## Documentazione API
+
+Una volta avviato il server, puoi accedere alla documentazione interativa Swagger UI su:
+
+`http://localhost:8000/docs`
+
+## Performance
+
+Il modello T5-base offre un buon bilanciamento tra qualità di traduzione e velocità. Per applicazioni che richiedono traduzione di alta qualità, puoi configurare un modello più grande tramite la variabile d'ambiente `MODEL_NAME`:
+
+```bash
+export MODEL_NAME="google/t5-v1_1-large"
+python app.py
+```
+
+## Docker
+
+Il progetto include un Dockerfile per facilità di deployment:
+
+```bash
+docker build -t locale-translate-server .
+docker run -p 8000:8000 locale-translate-server
+```

app.py

@@ -0,0 +1,185 @@
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Dict, Any, Optional, List
+from chat_service import translate_locale, get_supported_languages
+import logging
+
+# Configura il logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="Local Translation Server",
+    description="API per tradurre oggetti locale dall'italiano ad altre lingue",
+    version="1.0.0"
+)
+
+# Abilita CORS per permettere richieste da altri domini
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+class LocaleRequest(BaseModel):
+    """Modello per la richiesta di traduzione di un oggetto locale."""
+    locales: Dict[str, str]
+    
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "locales": {
+                    "welcome_message": "Benvenuto nella nostra applicazione!",
+                    "button_save": "Salva",
+                    "error_required": "Questo campo è obbligatorio",
+                    "html_content": "<p>Clicca <a href='#'>qui</a> per continuare</p>",
+                    "template_message": "Ciao {name}, hai {count} nuovi messaggi"
+                }
+            }
+        }
+    }
+
+
+class LocaleResponse(BaseModel):
+    """Modello per la risposta di traduzione."""
+    translated_locales: Dict[str, str]
+    source_language: str
+    target_language: str
+    
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "translated_locales": {
+                    "welcome_message": "Welcome to our application!",
+                    "button_save": "Save",
+                    "error_required": "This field is required",
+                    "html_content": "<p>Click <a href='#'>here</a> to continue</p>",
+                    "template_message": "Hello {name}, you have {count} new messages"
+                },
+                "source_language": "it",
+                "target_language": "en"
+            }
+        }
+    }
+
+
+class LanguagesResponse(BaseModel):
+    """Modello per la risposta delle lingue supportate."""
+    supported_languages: List[str]
+
+
+@app.get("/", summary="Health Check")
+def health_check():
+    """Endpoint per verificare che il server sia in esecuzione."""
+    return {
+        "service": "Local Translation Server",
+        "status": "running",
+        "version": "1.0.0"
+    }
+
+
+@app.get("/languages", response_model=LanguagesResponse, summary="Lingue Supportate")
+def get_languages():
+    """Restituisce la lista delle lingue supportate per la traduzione."""
+    return LanguagesResponse(supported_languages=get_supported_languages())
+
+
+@app.post("/translate", response_model=LocaleResponse, summary="Traduci Locales")
+async def translate_locales(
+    request: LocaleRequest,
+    target_language: str = Query(
+        ..., 
+        description="Codice della lingua target (es: 'en', 'fr', 'de')",
+        example="en"
+    )
+):
+    """
+    Traduce un oggetto contenente locales dall'italiano alla lingua specificata.
+    
+    - **locales**: Dizionario chiave-valore dove ogni chiave è un identificatore 
+      e ogni valore è il testo in italiano da tradurre
+    - **target_language**: Codice della lingua target (parametro query)
+    
+    Il servizio preserva:
+    - Tag HTML nel testo
+    - Placeholders con parentesi graffe (es: {name}, {count})
+    - Struttura delle chiavi originali
+    """
+    try:
+        logger.info(f"Richiesta traduzione per {len(request.locales)} locales verso {target_language}")
+        
+        # Verifica che la lingua target sia supportata
+        supported_languages = get_supported_languages()
+        if target_language not in supported_languages:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Lingua '{target_language}' non supportata. Lingue disponibili: {supported_languages}"
+            )
+        
+        # Esegui la traduzione
+        translated_data = translate_locale(request.locales, target_language)
+        
+        logger.info(f"Traduzione completata per {len(translated_data)} locales")
+        
+        return LocaleResponse(
+            translated_locales=translated_data,
+            source_language="it",
+            target_language=target_language
+        )
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Errore durante la traduzione: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Errore interno del server: {str(e)}")
+
+
+@app.post("/translate-single", summary="Traduci Singolo Testo")
+async def translate_single_text(
+    text: str = Query(..., description="Testo in italiano da tradurre"),
+    target_language: str = Query(
+        ..., 
+        description="Codice della lingua target (es: 'en', 'fr', 'de')",
+        example="en"
+    )
+):
+    """
+    Traduce un singolo testo dall'italiano alla lingua specificata.
+    Utile per test rapidi o traduzioni singole.
+    """
+    try:
+        from chat_service import get_translation_service
+        
+        # Verifica che la lingua target sia supportata
+        supported_languages = get_supported_languages()
+        if target_language not in supported_languages:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Lingua '{target_language}' non supportata. Lingue disponibili: {supported_languages}"
+            )
+        
+        # Ottieni il servizio di traduzione e traduci
+        translation_service = get_translation_service()
+        translated_text = translation_service.translate_text(text, target_language)
+        
+        return {
+            "original_text": text,
+            "translated_text": translated_text,
+            "source_language": "it",
+            "target_language": target_language
+        }
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Errore durante la traduzione: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Errore interno del server: {str(e)}")
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

chat_service.py

@@ -0,0 +1,198 @@
+from transformers import pipeline
+import torch
+from config import Config
+from typing import Dict, Any
+import re
+
+# Mapping delle lingue supportate con i loro nomi per i modelli Helsinki-NLP
+LANGUAGE_CODES = {
+    "en": "English",
+    "fr": "French", 
+    "de": "German",
+    "es": "Spanish",
+    "pt": "Portuguese",
+    "ru": "Russian",
+    "ja": "Japanese",
+    "ko": "Korean",
+    "zh": "Chinese",
+    "ar": "Arabic",
+    "hi": "Hindi",
+    "nl": "Dutch",
+    "sv": "Swedish",
+    "da": "Danish",
+    "no": "Norwegian",
+    "fi": "Finnish",
+    "pl": "Polish",
+    "cs": "Czech",
+    "hu": "Hungarian",
+    "ro": "Romanian",
+    "bg": "Bulgarian",
+    "hr": "Croatian",
+    "sk": "Slovak",
+    "sl": "Slovenian",
+    "et": "Estonian",
+    "lv": "Latvian",
+    "lt": "Lithuanian",
+    "mt": "Maltese",
+    "el": "Greek",
+    "tr": "Turkish"
+}
+
+# Mapping per i modelli di traduzione Helsinki-NLP (da italiano verso altre lingue)
+HELSINKI_MODELS = {
+    "en": "Helsinki-NLP/opus-mt-it-en",
+    "fr": "Helsinki-NLP/opus-mt-it-fr",
+    "de": "Helsinki-NLP/opus-mt-it-de", 
+    "es": "Helsinki-NLP/opus-mt-it-es",
+    "pt": "Helsinki-NLP/opus-mt-it-pt",
+    "ru": "Helsinki-NLP/opus-mt-it-ru",
+    "nl": "Helsinki-NLP/opus-mt-it-nl",
+    "sv": "Helsinki-NLP/opus-mt-it-sv",
+    "da": "Helsinki-NLP/opus-mt-it-da",
+    "no": "Helsinki-NLP/opus-mt-it-no",
+    "fi": "Helsinki-NLP/opus-mt-it-fi",
+    "pl": "Helsinki-NLP/opus-mt-it-pl",
+    "cs": "Helsinki-NLP/opus-mt-it-cs",
+    "hu": "Helsinki-NLP/opus-mt-it-hu",
+    "ro": "Helsinki-NLP/opus-mt-it-ro",
+    "bg": "Helsinki-NLP/opus-mt-it-bg",
+    "hr": "Helsinki-NLP/opus-mt-it-hr",
+    "sk": "Helsinki-NLP/opus-mt-it-sk",
+    "sl": "Helsinki-NLP/opus-mt-it-sl",
+    "et": "Helsinki-NLP/opus-mt-it-et",
+    "lv": "Helsinki-NLP/opus-mt-it-lv",
+    "lt": "Helsinki-NLP/opus-mt-it-lt",
+    "el": "Helsinki-NLP/opus-mt-it-el",
+    "tr": "Helsinki-NLP/opus-mt-it-tr"
+}
+
+
+class TranslationService:
+    def __init__(self, device: str = "cpu"):
+        self.device = device
+        self.translators = {}  # Cache per i translator
+        
+    def _get_translator(self, target_language: str):
+        """Ottiene o crea un translator per la lingua target."""
+        if target_language not in self.translators:
+            if target_language in HELSINKI_MODELS:
+                model_name = HELSINKI_MODELS[target_language]
+                try:
+                    self.translators[target_language] = pipeline(
+                        "translation",
+                        model=model_name,
+                        device=0 if self.device == "cuda" else -1,
+                        torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+                    )
+                except Exception as e:
+                    # Fallback per lingue senza modelli specifici
+                    print(f"Modello non disponibile per {target_language}, usando fallback: {e}")
+                    return None
+            else:
+                return None
+        return self.translators[target_language]
+        
+    def _extract_placeholders(self, text: str) -> tuple[str, Dict[str, str]]:
+        """Estrae i placeholders HTML e delle parentesi graffe dal testo."""
+        placeholders = {}
+        
+        # Pattern per HTML tags
+        html_pattern = r'<[^>]+>'
+        html_matches = re.findall(html_pattern, text)
+        
+        # Pattern per parentesi graffe
+        brace_pattern = r'\{[^}]+\}'
+        brace_matches = re.findall(brace_pattern, text)
+        
+        # Sostituisce HTML tags con placeholders
+        processed_text = text
+        for i, match in enumerate(html_matches):
+            placeholder = f"HTMLTAG{i}"
+            placeholders[placeholder] = match
+            processed_text = processed_text.replace(match, placeholder, 1)
+        
+        # Sostituisce parentesi graffe con placeholders
+        for i, match in enumerate(brace_matches):
+            placeholder = f"PLACEHOLDER{i}"
+            placeholders[placeholder] = match
+            processed_text = processed_text.replace(match, placeholder, 1)
+            
+        return processed_text, placeholders
+    
+    def _restore_placeholders(self, text: str, placeholders: Dict[str, str]) -> str:
+        """Ripristina i placeholders nel testo tradotto."""
+        for placeholder, original in placeholders.items():
+            # Rimuovi spazi extra attorno ai placeholder
+            text = text.replace(f" {placeholder} ", original)
+            text = text.replace(f" {placeholder}", original)
+            text = text.replace(f"{placeholder} ", original)
+            text = text.replace(placeholder, original)
+        return text
+    
+    def translate_text(self, text: str, target_language: str) -> str:
+        """Traduce il testo dall'italiano alla lingua target."""
+        if target_language not in LANGUAGE_CODES:
+            raise ValueError(f"Lingua non supportata: {target_language}")
+        
+        # Estrai placeholders
+        clean_text, placeholders = self._extract_placeholders(text)
+        
+        # Ottieni il translator
+        translator = self._get_translator(target_language)
+        if translator is None:
+            # Traduzione semplice di fallback (mantiene il testo originale)
+            return f"[TRANSLATION NOT AVAILABLE: {text}]"
+            
+        try:
+            # Esegui la traduzione
+            result = translator(clean_text, max_length=512)
+            
+            if isinstance(result, list) and len(result) > 0:
+                translated_text = result[0]['translation_text']
+            else:
+                translated_text = str(result)
+            
+            # Ripristina i placeholders
+            translated_text = self._restore_placeholders(translated_text, placeholders)
+            
+            return translated_text.strip()
+            
+        except Exception as e:
+            print(f"Errore durante la traduzione: {e}")
+            return f"[TRANSLATION ERROR: {text}]"
+    
+    def translate_locale_object(self, locale_data: Dict[str, Any], target_language: str) -> Dict[str, Any]:
+        """Traduce un oggetto locale completo."""
+        if target_language not in LANGUAGE_CODES:
+            raise ValueError(f"Lingua non supportata: {target_language}")
+        
+        translated_data = {}
+        
+        for key, content in locale_data.items():
+            if isinstance(content, str):
+                translated_data[key] = self.translate_text(content, target_language)
+            else:
+                # Mantieni il valore originale se non è una stringa
+                translated_data[key] = content
+                
+        return translated_data
+
+
+# Istanza globale del servizio di traduzione
+translation_service = None
+
+def get_translation_service():
+    global translation_service
+    if translation_service is None:
+        config = Config()
+        translation_service = TranslationService(device=config.DEVICE)
+    return translation_service
+
+def translate_locale(locale_data: Dict[str, Any], target_language: str) -> Dict[str, Any]:
+    """Funzione helper per tradurre un oggetto locale."""
+    service = get_translation_service()
+    return service.translate_locale_object(locale_data, target_language)
+
+def get_supported_languages():
+    """Restituisce la lista delle lingue supportate."""
+    return list(HELSINKI_MODELS.keys())

config.py

@@ -0,0 +1,10 @@
+import os
+import torch
+
+class Config:
+    PROJECT_NAME = "Local Translation Server"
+    VERSION = "1.0.0"
+    ENVIRONMENT = os.getenv("ENVIRONMENT", "development")
+    DEBUG = os.getenv("DEBUG", "true") == "true"
+    MODEL_NAME = os.getenv("MODEL_NAME", "google/mt5-small")  # Usando mT5 per traduzione multilingue
+    DEVICE = "mps" if torch.mps.is_available() else "cpu"

index.html

@@ -1,29 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-    <meta charset="UTF-8" />
-    <link rel="stylesheet" href="style.css" />
-
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Transformers.js - Object Detection</title>
-</head>
-
-<body>
-    <h1>Object Detection w/ 🤗 Transformers.js</h1>
-    <label id="container" for="upload">
-        <svg width="25" height="25" viewBox="0 0 25 25" fill="none" xmlns="http://www.w3.org/2000/svg">
-            <path fill="#000"
-                d="M3.5 24.3a3 3 0 0 1-1.9-.8c-.5-.5-.8-1.2-.8-1.9V2.9c0-.7.3-1.3.8-1.9.6-.5 1.2-.7 2-.7h18.6c.7 0 1.3.2 1.9.7.5.6.7 1.2.7 2v18.6c0 .7-.2 1.4-.7 1.9a3 3 0 0 1-2 .8H3.6Zm0-2.7h18.7V2.9H3.5v18.7Zm2.7-2.7h13.3c.3 0 .5 0 .6-.3v-.7l-3.7-5a.6.6 0 0 0-.6-.2c-.2 0-.4 0-.5.3l-3.5 4.6-2.4-3.3a.6.6 0 0 0-.6-.3c-.2 0-.4.1-.5.3l-2.7 3.6c-.1.2-.2.4 0 .7.1.2.3.3.6.3Z">
-            </path>
-        </svg>
-        Click to upload image
-        <label id="example">(or try example)</label>
-    </label>
-    <label id="status">Loading model...</label>
-    <input id="upload" type="file" accept="image/*" />
-
-    <script src="index.js" type="module"></script>
-</body>
-
-</html>

index.js

@@ -1,76 +0,0 @@
-import { pipeline } from 'https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.4.1';
-
-// Reference the elements that we will need
-const status = document.getElementById('status');
-const fileUpload = document.getElementById('upload');
-const imageContainer = document.getElementById('container');
-const example = document.getElementById('example');
-
-const EXAMPLE_URL = 'https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/city-streets.jpg';
-
-// Create a new object detection pipeline
-status.textContent = 'Loading model...';
-const detector = await pipeline('object-detection', 'Xenova/detr-resnet-50');
-status.textContent = 'Ready';
-
-example.addEventListener('click', (e) => {
-    e.preventDefault();
-    detect(EXAMPLE_URL);
-});
-
-fileUpload.addEventListener('change', function (e) {
-    const file = e.target.files[0];
-    if (!file) {
-        return;
-    }
-
-    const reader = new FileReader();
-
-    // Set up a callback when the file is loaded
-    reader.onload = e2 => detect(e2.target.result);
-
-    reader.readAsDataURL(file);
-});
-
-
-// Detect objects in the image
-async function detect(img) {
-    imageContainer.innerHTML = '';
-    imageContainer.style.backgroundImage = `url(${img})`;
-
-    status.textContent = 'Analysing...';
-    const output = await detector(img, {
-        threshold: 0.5,
-        percentage: true,
-    });
-    status.textContent = '';
-    output.forEach(renderBox);
-}
-
-// Render a bounding box and label on the image
-function renderBox({ box, label }) {
-    const { xmax, xmin, ymax, ymin } = box;
-
-    // Generate a random color for the box
-    const color = '#' + Math.floor(Math.random() * 0xFFFFFF).toString(16).padStart(6, 0);
-
-    // Draw the box
-    const boxElement = document.createElement('div');
-    boxElement.className = 'bounding-box';
-    Object.assign(boxElement.style, {
-        borderColor: color,
-        left: 100 * xmin + '%',
-        top: 100 * ymin + '%',
-        width: 100 * (xmax - xmin) + '%',
-        height: 100 * (ymax - ymin) + '%',
-    })
-
-    // Draw label
-    const labelElement = document.createElement('span');
-    labelElement.textContent = label;
-    labelElement.className = 'bounding-box-label';
-    labelElement.style.backgroundColor = color;
-
-    boxElement.appendChild(labelElement);
-    imageContainer.appendChild(boxElement);
-}

requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn[standard]
+transformers
+torch
+sentencepiece
+protobuf

start_server.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+"""
+Script per avviare il Local Translation Server
+"""
+
+import uvicorn
+from app import app
+
+if __name__ == "__main__":
+    print("🚀 Avvio Local Translation Server...")
+    print("📡 Server disponibile su: http://localhost:8000")
+    print("📚 Documentazione API: http://localhost:8000/docs")
+    print("🔍 Interfaccia Redoc: http://localhost:8000/redoc")
+    print("\n" + "="*50)
+    
+    uvicorn.run(
+        app, 
+        host="0.0.0.0", 
+        port=8000,
+        log_level="info",
+        reload=False  # Disabilita il reload automatico in produzione
+    )

style.css

@@ -1,76 +0,0 @@
-* {
-    box-sizing: border-box;
-    padding: 0;
-    margin: 0;
-    font-family: sans-serif;
-}
-
-html,
-body {
-    height: 100%;
-}
-
-body {
-    padding: 32px;
-}
-
-body,
-#container {
-    display: flex;
-    flex-direction: column;
-    justify-content: center;
-    align-items: center;
-}
-
-#container {
-    position: relative;
-    gap: 0.4rem;
-
-    width: 640px;
-    height: 640px;
-    max-width: 100%;
-    max-height: 100%;
-
-    border: 2px dashed #D1D5DB;
-    border-radius: 0.75rem;
-    overflow: hidden;
-    cursor: pointer;
-    margin: 1rem;
-
-    background-size: 100% 100%;
-    background-position: center;
-    background-repeat: no-repeat;
-    font-size: 18px;
-}
-
-#upload {
-    display: none;
-}
-
-svg {
-    pointer-events: none;
-}
-
-#example {
-    font-size: 14px;
-    text-decoration: underline;
-    cursor: pointer;
-}
-
-#example:hover {
-    color: #2563EB;
-}
-
-.bounding-box {
-    position: absolute;
-    box-sizing: border-box;
-    border: solid 2px;
-}
-
-.bounding-box-label {
-    color: white;
-    position: absolute;
-    font-size: 12px;
-    margin: -16px 0 0 -2px;
-    padding: 1px;
-}

test_api.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""
+Script di test per l'API di traduzione locale.
+Questo script testa tutti gli endpoint principali del servizio.
+"""
+
+import requests
+import json
+import time
+
+# Configurazione
+BASE_URL = "http://localhost:8000"
+
+def test_health_check():
+    """Testa l'endpoint di health check."""
+    print("🏥 Test Health Check...")
+    try:
+        response = requests.get(f"{BASE_URL}/")
+        print(f"Status: {response.status_code}")
+        print(f"Response: {response.json()}")
+        print("✅ Health check OK\n")
+        return True
+    except Exception as e:
+        print(f"❌ Health check failed: {e}\n")
+        return False
+
+def test_get_languages():
+    """Testa l'endpoint per ottenere le lingue supportate."""
+    print("🌍 Test Lingue Supportate...")
+    try:
+        response = requests.get(f"{BASE_URL}/languages")
+        data = response.json()
+        languages = data["supported_languages"]
+        print(f"Status: {response.status_code}")
+        print(f"Lingue supportate ({len(languages)}): {languages[:10]}...")
+        print("✅ Lingue supportate OK\n")
+        return True
+    except Exception as e:
+        print(f"❌ Test lingue failed: {e}\n")
+        return False
+
+def test_translate_single():
+    """Testa la traduzione di un singolo testo."""
+    print("📝 Test Traduzione Singola...")
+    try:
+        params = {
+            "text": "Ciao mondo! Come stai oggi?",
+            "target_language": "en"
+        }
+        response = requests.post(f"{BASE_URL}/translate-single", params=params)
+        data = response.json()
+        print(f"Status: {response.status_code}")
+        print(f"Testo originale: {data['original_text']}")
+        print(f"Testo tradotto: {data['translated_text']}")
+        print("✅ Traduzione singola OK\n")
+        return True
+    except Exception as e:
+        print(f"❌ Test traduzione singola failed: {e}\n")
+        return False
+
+def test_translate_locales():
+    """Testa la traduzione di oggetti locale complessi."""
+    print("🌐 Test Traduzione Locales...")
+    try:
+        locale_data = {
+            "locales": {
+                "welcome_message": "Benvenuto nella nostra applicazione!",
+                "button_save": "Salva documento",
+                "error_required": "Questo campo è obbligatorio",
+                "html_content": "<p>Clicca <a href='#'>qui</a> per continuare</p>",
+                "template_message": "Ciao {name}, hai {count} nuovi messaggi",
+                "complex_html": "<div class='alert'><strong>Attenzione:</strong> Operazione completata con successo!</div>"
+            }
+        }
+        
+        params = {"target_language": "en"}
+        response = requests.post(
+            f"{BASE_URL}/translate", 
+            json=locale_data, 
+            params=params
+        )
+        
+        data = response.json()
+        print(f"Status: {response.status_code}")
+        print("Traduzioni:")
+        for key, value in data["translated_locales"].items():
+            original = locale_data["locales"][key]
+            print(f"  {key}:")
+            print(f"    IT: {original}")
+            print(f"    EN: {value}")
+        
+        print("✅ Traduzione locales OK\n")
+        return True
+    except Exception as e:
+        print(f"❌ Test traduzione locales failed: {e}\n")
+        return False
+
+def test_multiple_languages():
+    """Testa la traduzione verso lingue diverse."""
+    print("🗣️  Test Lingue Multiple...")
+    try:
+        locale_data = {
+            "locales": {
+                "greeting": "Buongiorno!",
+                "goodbye": "Arrivederci!"
+            }
+        }
+        
+        languages_to_test = ["en", "fr", "de", "es"]
+        
+        for lang in languages_to_test:
+            params = {"target_language": lang}
+            response = requests.post(
+                f"{BASE_URL}/translate", 
+                json=locale_data, 
+                params=params
+            )
+            
+            data = response.json()
+            print(f"Traduzione in {lang}:")
+            for key, value in data["translated_locales"].items():
+                print(f"  {key}: {value}")
+        
+        print("✅ Test lingue multiple OK\n")
+        return True
+    except Exception as e:
+        print(f"❌ Test lingue multiple failed: {e}\n")
+        return False
+
+def test_error_handling():
+    """Testa la gestione degli errori."""
+    print("⚠️  Test Gestione Errori...")
+    try:
+        # Test lingua non supportata
+        locale_data = {"locales": {"test": "Ciao"}}
+        params = {"target_language": "xx"}  # Lingua inesistente
+        
+        response = requests.post(
+            f"{BASE_URL}/translate", 
+            json=locale_data, 
+            params=params
+        )
+        
+        print(f"Status per lingua inesistente: {response.status_code}")
+        if response.status_code == 400:
+            print("✅ Gestione errore lingua inesistente OK")
+        
+        # Test body malformato
+        response = requests.post(
+            f"{BASE_URL}/translate", 
+            json={"wrong_field": "test"},
+            params={"target_language": "en"}
+        )
+        
+        print(f"Status per body malformato: {response.status_code}")
+        print("✅ Test gestione errori OK\n")
+        return True
+    except Exception as e:
+        print(f"❌ Test gestione errori failed: {e}\n")
+        return False
+
+def main():
+    """Esegue tutti i test."""
+    print("🚀 Avvio test del Local Translation Server\n")
+    print("=" * 50)
+    
+    tests = [
+        test_health_check,
+        test_get_languages,
+        test_translate_single,
+        test_translate_locales,
+        test_multiple_languages,
+        test_error_handling
+    ]
+    
+    passed = 0
+    total = len(tests)
+    
+    for test in tests:
+        try:
+            if test():
+                passed += 1
+            time.sleep(1)  # Pausa tra i test
+        except Exception as e:
+            print(f"❌ Test failed with exception: {e}\n")
+    
+    print("=" * 50)
+    print(f"📊 Risultati: {passed}/{total} test passati")
+    
+    if passed == total:
+        print("🎉 Tutti i test sono passati!")
+    else:
+        print("⚠️  Alcuni test sono falliti. Controlla i log sopra.")
+
+if __name__ == "__main__":
+    main()