#!/usr/bin/env python3 """ DeepL Translator - Sözlük Destekli Çeviri Modülü ================================================= DeepL API ile çeviri yapar ve teknik sözlükten beslenir. Özellikler: - DeepL API ile yüksek kaliteli çeviri - Teknik sözlükten glossary oluşturma - Çeviri karşılaştırması (sözlük vs DeepL) - Hibrit mod: Sözlük + DeepL kombinasyonu Kullanım: from deepl_translator import DeepLTranslator translator = DeepLTranslator(api_key="your-deepl-api-key") result = translator.translate("hidrolik pompa arızası", "TR", "EN") """ import os import re import json import sqlite3 import requests from typing import Dict, List, Optional, Tuple from dataclasses import dataclass, field from datetime import datetime # ==================== CONFIGURATION ==================== DEEPL_API_URL = os.getenv("DEEPL_API_URL", "https://api-free.deepl.com/v2") DICTIONARY_PATH = os.getenv("DICTIONARY_PATH", "/mnt/pdfs/dictionary.db") # Desteklenen diller SUPPORTED_LANGS = {"TR": "Turkish", "EN": "English", "DE": "German", "FR": "French"} @dataclass class TranslationResult: """Çeviri sonucu""" original_text: str source_lang: str target_lang: str # Sözlük tabanlı çeviri dictionary_translation: str = "" dictionary_terms_found: Dict[str, str] = field(default_factory=dict) dictionary_confidence: float = 0.0 # DeepL çevirisi deepl_translation: str = "" deepl_detected_lang: str = "" # Hibrit çeviri (sözlük + DeepL) hybrid_translation: str = "" # Metadata translation_time_ms: int = 0 error: Optional[str] = None def to_dict(self) -> Dict: return { "original": self.original_text, "source_lang": self.source_lang, "target_lang": self.target_lang, "dictionary_translation": self.dictionary_translation, "dictionary_terms": self.dictionary_terms_found, "dictionary_confidence": self.dictionary_confidence, "deepl_translation": self.deepl_translation, "hybrid_translation": self.hybrid_translation, "time_ms": self.translation_time_ms, "error": self.error } class DeepLTranslator: """ DeepL + Sözlük Çeviri Servisi Teknik metinleri çevirirken önce sözlükten terimleri bulur, sonra DeepL ile genel çeviri yapar ve ikisini birleştirir. """ def __init__( self, api_key: str = None, dictionary_path: str = DICTIONARY_PATH, use_glossary: bool = True ): """ Args: api_key: DeepL API anahtarı dictionary_path: Sözlük DB yolu use_glossary: DeepL glossary kullanılsın mı """ self.api_key = api_key or os.getenv("DEEPL_API_KEY") self.dict_path = dictionary_path self.use_glossary = use_glossary # DeepL API URL (free vs pro) if self.api_key and ":fx" in self.api_key: self.api_url = "https://api-free.deepl.com/v2" else: self.api_url = "https://api.deepl.com/v2" # Veritabanı bağlantısı self.conn = None self._connect_db() # Sözlük cache'leri self._tr_to_en_cache = {} self._en_to_tr_cache = {} self._load_dictionary() # DeepL glossary ID (oluşturulduktan sonra) self.glossary_id = None print(f"✓ DeepL Translator başlatıldı") print(f" - API: {'✓' if self.api_key else '✗'}") print(f" - Sözlük: {len(self._tr_to_en_cache)} TR→EN, {len(self._en_to_tr_cache)} EN→TR terim") def _connect_db(self): """Sözlük veritabanına bağlan""" try: if os.path.exists(self.dict_path): self.conn = sqlite3.connect(self.dict_path) self.conn.row_factory = sqlite3.Row except Exception as e: print(f"⚠️ Sözlük bağlantı hatası: {e}") self.conn = None def _load_dictionary(self): """Sözlüğü cache'e yükle""" if not self.conn: return try: cursor = self.conn.cursor() # Kaliteli terimleri al cursor.execute(''' SELECT canonical_tr, canonical_en FROM technical_terms WHERE category IN ('parts-catalog', 'katalog-detailed', 'equipment', 'parts', 'compound') AND canonical_tr IS NOT NULL AND canonical_en IS NOT NULL AND LENGTH(canonical_tr) BETWEEN 2 AND 50 AND LENGTH(canonical_en) BETWEEN 2 AND 50 AND canonical_en NOT LIKE '%(%' AND canonical_tr NOT LIKE '%(%' ''') for row in cursor.fetchall(): tr = row['canonical_tr'].lower().strip() en = row['canonical_en'].lower().strip() # Sayı ağırlıklı değerleri atla if sum(c.isdigit() for c in en) > len(en) * 0.3: continue # TR → EN if tr not in self._tr_to_en_cache: self._tr_to_en_cache[tr] = [] if en not in self._tr_to_en_cache[tr]: self._tr_to_en_cache[tr].append(en) # EN → TR if en not in self._en_to_tr_cache: self._en_to_tr_cache[en] = [] if tr not in self._en_to_tr_cache[en]: self._en_to_tr_cache[en].append(tr) # En fazla 3 karşılık tut for k in self._tr_to_en_cache: self._tr_to_en_cache[k] = self._tr_to_en_cache[k][:3] for k in self._en_to_tr_cache: self._en_to_tr_cache[k] = self._en_to_tr_cache[k][:3] except Exception as e: print(f"⚠️ Sözlük yükleme hatası: {e}") def _tokenize(self, text: str) -> List[str]: """Metni token'lara ayır""" text = text.lower().strip() text = re.sub(r'[^\w\sğüşöçıİĞÜŞÖÇ-]', ' ', text) return [t for t in text.split() if len(t) >= 2] def _translate_with_dictionary( self, text: str, source_lang: str, target_lang: str ) -> Tuple[str, Dict[str, str], float]: """ Sözlük tabanlı çeviri. Returns: (çevrilmiş_metin, terim_eşleşmeleri, güven_skoru) """ tokens = self._tokenize(text) translated_tokens = [] found_terms = {} matches = 0 # Cache seçimi if source_lang == "TR" and target_lang == "EN": cache = self._tr_to_en_cache elif source_lang == "EN" and target_lang == "TR": cache = self._en_to_tr_cache else: return text, {}, 0.0 # Önce çok kelimeli terimleri bul (uzundan kısaya) text_lower = text.lower() multi_word_found = {} for term, translations in sorted(cache.items(), key=lambda x: -len(x[0])): if len(term.split()) > 1 and term in text_lower: found_terms[term] = translations[0] multi_word_found[term] = translations[0] matches += 1 # Tek kelime eşleşmeleri for token in tokens: # Bu token çok kelimeli bir terimin parçası mı kontrol et is_part_of_multiword = False for multi_term in multi_word_found.keys(): if token in multi_term.split(): is_part_of_multiword = True break if is_part_of_multiword: translated_tokens.append(token) # Çok kelimeli terim olarak işlenecek elif token in cache: translated = cache[token][0] # İlk karşılık translated_tokens.append(translated) found_terms[token] = translated matches += 1 else: translated_tokens.append(token) confidence = matches / max(len(tokens), 1) translated_text = ' '.join(translated_tokens) return translated_text, found_terms, confidence def apply_dictionary_to_translation(self, original_en: str, deepl_tr: str) -> str: """ DeepL çevirisine sözlük terimlerini uygula. Orijinal İngilizce metindeki teknik terimleri bul, DeepL'in yanlış çevirdiği yerleri sözlükten düzelt. """ if not deepl_tr or not original_en: return deepl_tr result = deepl_tr original_lower = original_en.lower() # ========== KRİTİK TEKNİK TERİM DÜZELTMELERİ ========== # DeepL'in yanlış çevirdiği teknik terimler critical_corrections = { # TRANSMISSION - EN ÖNEMLİ 'iletim': 'şanzıman', 'aktarım': 'şanzıman', 'nakil': 'şanzıman', 'transmisyon': 'şanzıman', # TRAVEL - YÜRÜYÜŞ 'seyahat motoru': 'yürüyüş motoru', 'seyahat ünitesi': 'yürüyüş ünitesi', 'seyahat kontrolü': 'yürüyüş kontrolü', 'seyahat': 'yürüyüş', 'gezi': 'yürüyüş', # SWING - KULE DÖNÜŞ 'salınım motoru': 'kule dönüş motoru', 'salınım': 'kule dönüş', 'sallanma': 'kule dönüş', 'savurma': 'kule dönüş', # TRACK - PALETLİ 'parça': 'palet', 'iz': 'palet', # RELIEF VALVE - EMNİYET VALFİ 'tahliye valfi': 'emniyet valfi', 'rahatlama valfi': 'emniyet valfi', 'basınç tahliye': 'basınç emniyet', 'rölyef valf': 'emniyet valfi', # REDUCTION GEAR - REDÜKSİYON DİŞLİSİ 'azaltma dişlisi': 'redüksiyon dişlisi', 'indirgeme dişlisi': 'redüksiyon dişlisi', 'düşürme dişlisi': 'redüksiyon dişlisi', # SEAL - KEÇE 'mühür': 'keçe', 'conta': 'keçe', 'sızdırmazlık': 'keçe', # BEARING - RULMAN 'yatak': 'rulman', 'mesnet': 'rulman', # TRACTION - TAHRİK 'çekiş motoru': 'tahrik motoru', 'çekiş': 'tahrik', # PARKING BRAKE - EL FRENİ 'park freni': 'el freni', # HYDRAULIC 'hidrolik pompa': 'hidrolik pompa', # Doğru, değiştirme # CYLINDER 'silindir': 'silindir', # Doğru # PISTON 'piston': 'piston', # Doğru # VALVE 'supap': 'valf', 'vana': 'valf', # FILTER 'süzgeç': 'filtre', # PRESSURE 'baskı': 'basınç', # DISASSEMBLY 'sökme ve takma': 'demontaj ve montaj', 'söküm': 'demontaj', 'takım': 'montaj', # COUNTERBALANCE 'karşı ağırlık': 'denge', 'denge valfi': 'karşı basınç valfi', } # Önce kritik düzeltmeleri uygula (uzundan kısaya) for wrong, correct in sorted(critical_corrections.items(), key=lambda x: -len(x[0])): pattern = re.compile(r'\b' + re.escape(wrong) + r'\b', re.IGNORECASE) result = pattern.sub(correct, result) # ========== SÖZLÜKTEN OTOMATİK DÜZELTME ========== # Orijinal metindeki terimleri bul ve düzelt for en_term, tr_list in sorted(self._en_to_tr_cache.items(), key=lambda x: -len(x[0])): if not tr_list: continue correct_tr = tr_list[0] # Sadece 2+ kelimeli terimleri veya önemli tek kelimeleri kontrol et if len(en_term) < 4: continue # Orijinal metinde bu terim var mı? if en_term.lower() in original_lower: # DeepL'in olası yanlış çevirilerini düzelt # Bu terim için bilinen yanlış çevirileri kontrol et pass return result def _protect_abbreviations(self, text: str) -> Tuple[str, Dict[str, str]]: """ Kısaltmaları ve çevrilmemesi gereken terimleri koruma altına al. Returns: (korumalı_metin, placeholder_map) """ import re # Korunacak pattern'ler patterns = [ r'\bFig\.?\s*\d+[-.]?\d*', # Fig 10, Fig. 3-2 r'\bFigure\s*\d+[-.]?\d*', # Figure 10 r'\bTable\s*\d+[-.]?\d*', # Table 5 r'\bSection\s*[A-Z]?\d*[-.]?\d*', # Section F, Section 3-2 r'\bStep\s*\d+', # Step 1 r'\bItem\s*#?\d+', # Item 5, Item #3 r'\bP\d{6,}', # Part numbers P014640 r'\b\d{4}/\d{4}', # Reference numbers 9813/1250 r'\b[A-Z]{2,4}-\d+', # Codes JS240, F-30 r'\(\d+\)', # Numbers in parentheses (58) r'\b\d+\s*bar\b', # Pressure values 350 bar r'\b\d+\s*psi\b', # Pressure values 5000 psi r'\b\d+\s*Nm\b', # Torque values 120 Nm r'\b\d+\s*mm\b', # Length values 25 mm ] placeholder_map = {} protected_text = text placeholder_counter = 0 for pattern in patterns: matches = re.findall(pattern, protected_text, re.IGNORECASE) for match in matches: placeholder = f"__KEEP_{placeholder_counter}__" placeholder_map[placeholder] = match protected_text = protected_text.replace(match, placeholder, 1) placeholder_counter += 1 return protected_text, placeholder_map def _restore_abbreviations(self, text: str, placeholder_map: Dict[str, str]) -> str: """Korunan kısaltmaları geri yükle""" result = text for placeholder, original in placeholder_map.items(): result = result.replace(placeholder, original) return result def _translate_with_deepl( self, text: str, source_lang: str, target_lang: str ) -> Tuple[str, str, Optional[str]]: """ DeepL API ile çeviri. Returns: (çevrilmiş_metin, algılanan_dil, hata) """ if not self.api_key: return "", "", "DeepL API key bulunamadı" try: # Kısaltmaları koru protected_text, placeholder_map = self._protect_abbreviations(text) url = f"{self.api_url}/translate" # TEKNİK TERİMLER İÇİN CONTEXT EKLEYELİM context_prefix = "" if target_lang == "TR": context_prefix = "[Technical machinery manual translation. Use Turkish technical terms: transmission=şanzıman, travel=yürüyüş, swing=kule dönüş, relief valve=emniyet valfi, seal=keçe, bearing=rulman] " data = { "text": [context_prefix + protected_text if context_prefix else protected_text], "target_lang": target_lang, "preserve_formatting": True, "formality": "prefer_more" # Teknik çeviri için formal } # Source lang belirtilmişse ekle if source_lang: data["source_lang"] = source_lang # Glossary varsa ekle if self.glossary_id: data["glossary_id"] = self.glossary_id headers = { "Authorization": f"DeepL-Auth-Key {self.api_key}", "Content-Type": "application/json" } response = requests.post(url, json=data, headers=headers, timeout=15) if response.status_code != 200: error_msg = f"DeepL API hatası: {response.status_code}" try: error_data = response.json() error_msg += f" - {error_data.get('message', '')}" except: pass return "", "", error_msg result = response.json() if "translations" in result and len(result["translations"]) > 0: translation = result["translations"][0] translated = translation.get("text", "") # Context prefix'i kaldır (eğer çeviride kaldıysa) if translated.startswith("["): bracket_end = translated.find("]") if bracket_end > 0: translated = translated[bracket_end + 1:].strip() # Korunan kısaltmaları geri yükle translated = self._restore_abbreviations(translated, placeholder_map) return ( translated, translation.get("detected_source_language", source_lang), None ) return "", "", "DeepL cevap bulunamadı" except requests.exceptions.Timeout: return "", "", "DeepL zaman aşımı" except Exception as e: return "", "", f"DeepL hatası: {str(e)}" def _create_hybrid_translation( self, original: str, dict_translation: str, dict_terms: Dict[str, str], deepl_translation: str, target_lang: str ) -> str: """ Hibrit çeviri oluştur. Strateji: 1. DeepL çevirisini temel al 2. Sözlükteki teknik terimleri bul ve DeepL'in yanlış çevirdiği yerleri düzelt """ if not deepl_translation: return dict_translation if not dict_terms: return deepl_translation result = deepl_translation if target_lang == "TR": # EN → TR çeviri: Sözlükteki İngilizce terimlerin Türkçe karşılıklarını kullan # DeepL'in yanlış çevirdiği teknik terimleri düzelt # Uzun terimlerden kısa terimlere doğru işle (daha spesifik önce) sorted_terms = sorted(dict_terms.items(), key=lambda x: -len(x[0])) for en_term, tr_term in sorted_terms: # DeepL'in bu terimi nasıl çevirdiğini bul # Önce orijinal metinde en_term var mı kontrol et original_lower = original.lower() if en_term.lower() in original_lower: # Bu terim orijinalde var, DeepL'in çevirisini sözlükle değiştir # DeepL'in olası çevirilerini bul ve değiştir # Yaygın yanlış çeviriler wrong_translations = { 'travel': ['seyahat', 'gezi', 'yolculuk'], 'swing': ['sallanma', 'salıncak'], 'boom': ['patlama', 'bom'], 'bucket': ['kova', 'kepçe'], 'track': ['iz', 'parça', 'şarkı'], 'relief': ['rahatlama', 'kabartma'], 'seal': ['mühür', 'fok'], 'bearing': ['taşıma', 'yatak'], 'gear': ['vites', 'dişli'], 'shaft': ['şaft', 'mil'], 'pump': ['pompa'], 'valve': ['valf', 'vana', 'kapak'], 'cylinder': ['silindir'], 'piston': ['piston'], 'filter': ['filtre'], 'motor': ['motor'], 'unit': ['ünite', 'birim'], 'assembly': ['montaj', 'düzenek'], 'control': ['kontrol'], 'pressure': ['basınç'], 'hydraulic': ['hidrolik'], 'brake': ['fren'], 'parking': ['park'], 'speed': ['hız'], 'reduction': ['redüksiyon', 'indirim', 'azaltma'], } # En_term içindeki kelimeleri kontrol et en_words = en_term.lower().split() for en_word in en_words: if en_word in wrong_translations: for wrong in wrong_translations[en_word]: # Case-insensitive replace pattern = re.compile(r'\b' + re.escape(wrong) + r'\b', re.IGNORECASE) # tr_term içindeki doğru karşılığı bul if tr_term: result = pattern.sub(tr_term, result, count=1) # Tam terim eşleşmesi için de kontrol et # Örnek: "travel motor" -> "yürüyüş motoru" if len(en_term.split()) > 1: # Çok kelimeli terim # DeepL'in çevirisinde bu terimin yanlış versiyonunu ara pass elif target_lang == "EN": # TR → EN çeviri: Sözlükteki Türkçe terimlerin İngilizce karşılıklarını kullan sorted_terms = sorted(dict_terms.items(), key=lambda x: -len(x[0])) for tr_term, en_term in sorted_terms: # Türkçe terimi İngilizce karşılığıyla değiştir pattern = re.compile(r'\b' + re.escape(tr_term) + r'\b', re.IGNORECASE) if pattern.search(result): result = pattern.sub(en_term, result) return result def translate( self, text: str, source_lang: str = "TR", target_lang: str = "EN", use_hybrid: bool = True ) -> TranslationResult: """ Metni çevir. Args: text: Çevrilecek metin source_lang: Kaynak dil (TR, EN) target_lang: Hedef dil (EN, TR) use_hybrid: Hibrit mod kullan Returns: TranslationResult nesnesi """ import time start_time = time.time() result = TranslationResult( original_text=text, source_lang=source_lang, target_lang=target_lang ) # 1. Sözlük çevirisi dict_trans, dict_terms, dict_conf = self._translate_with_dictionary( text, source_lang, target_lang ) result.dictionary_translation = dict_trans result.dictionary_terms_found = dict_terms result.dictionary_confidence = dict_conf # 2. DeepL çevirisi deepl_trans, detected_lang, error = self._translate_with_deepl( text, source_lang, target_lang ) result.deepl_translation = deepl_trans result.deepl_detected_lang = detected_lang if error: result.error = error # 3. Hibrit çeviri if use_hybrid and deepl_trans: # Önce genel hibrit çeviri hybrid = self._create_hybrid_translation( text, dict_trans, dict_terms, deepl_trans, target_lang ) # EN -> TR çevirisinde sözlük düzeltmelerini uygula if target_lang == "TR": hybrid = self.apply_dictionary_to_translation(text, hybrid) result.hybrid_translation = hybrid else: result.hybrid_translation = deepl_trans or dict_trans result.translation_time_ms = int((time.time() - start_time) * 1000) return result def translate_query(self, turkish_query: str) -> TranslationResult: """Türkçe sorguyu İngilizceye çevir""" return self.translate(turkish_query, "TR", "EN") def translate_answer(self, english_answer: str) -> TranslationResult: """İngilizce cevabı Türkçeye çevir""" return self.translate(english_answer, "EN", "TR") def create_glossary(self, name: str = "TechnicalTerms") -> Optional[str]: """ DeepL glossary oluştur. Teknik sözlükteki terimleri DeepL glossary'sine yükler. Bu sayede DeepL bu terimleri doğru çevirir. """ if not self.api_key: print("⚠️ DeepL API key yok, glossary oluşturulamadı") return None # Glossary formatı: TSV (tab-separated values) entries = [] # TR → EN glossary for tr, en_list in list(self._tr_to_en_cache.items())[:1000]: # DeepL limit if en_list: entries.append(f"{tr}\t{en_list[0]}") if not entries: print("⚠️ Glossary için terim bulunamadı") return None try: url = f"{self.api_url}/glossaries" data = { "name": f"{name}_{datetime.now().strftime('%Y%m%d')}", "source_lang": "TR", "target_lang": "EN", "entries": "\n".join(entries), "entries_format": "tsv" } headers = { "Authorization": f"DeepL-Auth-Key {self.api_key}", "Content-Type": "application/json" } response = requests.post(url, json=data, headers=headers, timeout=30) if response.status_code == 201: result = response.json() self.glossary_id = result.get("glossary_id") print(f"✓ DeepL glossary oluşturuldu: {self.glossary_id}") return self.glossary_id else: print(f"⚠️ Glossary oluşturma hatası: {response.status_code}") return None except Exception as e: print(f"⚠️ Glossary hatası: {e}") return None def get_api_usage(self) -> Optional[Dict]: """DeepL API kullanım bilgisini al""" if not self.api_key: return None try: url = f"{self.api_url}/usage" headers = {"Authorization": f"DeepL-Auth-Key {self.api_key}"} response = requests.get(url, headers=headers, timeout=5) if response.status_code == 200: return response.json() return None except: return None def close(self): """Kaynakları temizle""" if self.conn: self.conn.close() self.conn = None # ==================== TEST ==================== def test_translator(): """Test fonksiyonu""" api_key = os.getenv("DEEPL_API_KEY") if not api_key: print("\n⚠️ DEEPL_API_KEY ortam değişkeni ayarlanmamış!") print(" export DEEPL_API_KEY='your-api-key'") print("\n Sadece sözlük çevirisi test edilecek...\n") translator = DeepLTranslator(api_key=api_key) # Test sorguları test_queries = [ "hidrolik pompa arızası", "yürüyüş motoru basınç ayarı", "bom silindiri sızdırıyor", "motor yağ kapasitesi", "relief valve nerede", ] print("\n" + "=" * 70) print(" 🔤 DEEPL TRANSLATOR TEST") print("=" * 70) for query in test_queries: result = translator.translate_query(query) print(f"\n📝 Orijinal: {result.original_text}") print(f" 📕 Sözlük: {result.dictionary_translation}") print(f" Terimler: {result.dictionary_terms_found}") print(f" Güven: {result.dictionary_confidence:.0%}") if result.deepl_translation: print(f" 🌐 DeepL: {result.deepl_translation}") print(f" 🔀 Hibrit: {result.hybrid_translation}") elif result.error: print(f" ❌ DeepL Hata: {result.error}") print(f" ⏱️ Süre: {result.translation_time_ms}ms") # EN → TR test print("\n" + "=" * 70) print(" 🔄 İNGİLİZCE → TÜRKÇE ÇEVİRİ TESTİ") print("=" * 70) english_texts = [ "Check the hydraulic pump pressure and adjust the relief valve.", "The travel motor seal needs replacement.", "Inspect the boom cylinder for leaks.", ] for text in english_texts: result = translator.translate_answer(text) print(f"\n🇬🇧 İngilizce: {result.original_text}") print(f" 📕 Sözlük: {result.dictionary_translation}") if result.deepl_translation: print(f" 🌐 DeepL: {result.deepl_translation}") elif result.error: print(f" ❌ Hata: {result.error}") # API kullanım bilgisi if api_key: usage = translator.get_api_usage() if usage: print(f"\n📊 DeepL API Kullanımı:") print(f" Kullanılan: {usage.get('character_count', 0):,} karakter") print(f" Limit: {usage.get('character_limit', 0):,} karakter") translator.close() if __name__ == "__main__": test_translator()