mistral_translator 0.3.1 → 0.4.0

data/lib/mistral_translator/translator.rb

@@ -9,7 +9,6 @@ module MistralTranslator
     include TranslatorHelpers::InputValidator
     include TranslatorHelpers::RetryHandler
     include TranslatorHelpers::LoggingHelper
-    include TranslatorHelpers::PromptHandler
     include TranslatorHelpers::AnalysisHelper
     include TranslatorHelpers::RequestHelper
     include TranslatorHelpers::MultiTargetHelper
@@ -67,47 +66,49 @@ module MistralTranslator
     # Traduction vers plusieurs langues avec support du batch
     def translate_to_multiple(text, from:, to:, **options)
       validate_translation_inputs!(text, from, to)
+      Security::BasicValidator.validate_text!(text)
 
       source_locale = LocaleHelper.validate_locale!(from)
       target_locales = Array(to).map { |locale| LocaleHelper.validate_locale!(locale) }
 
+      translation_options = { context: options[:context], glossary: options[:glossary] }
+      translation_options[:preserve_html] = true if options[:preserve_html]
+
       if options[:use_batch] && target_locales.size > 3
-        translate_to_multiple_batch(text, source_locale, target_locales, context: options[:context],
-                                                                         glossary: options[:glossary])
+        translate_to_multiple_batch(text, source_locale, target_locales, **translation_options)
       else
-        translate_to_multiple_sequential(text, source_locale, target_locales, context: options[:context],
-                                                                              glossary: options[:glossary])
+        translate_to_multiple_sequential(text, source_locale, target_locales, **translation_options)
       end
     end
 
     # Traduction en lot (plusieurs textes vers une langue)
-    def translate_batch(texts, from:, to:, context: nil, glossary: nil)
+    def translate_batch(texts, from:, to:, context: nil, glossary: nil, preserve_html: false) # rubocop:disable Metrics/ParameterLists
       validated_texts = Security::BasicValidator.validate_batch!(texts)
       source_locale = LocaleHelper.validate_locale!(from)
       target_locale = LocaleHelper.validate_locale!(to)
 
       return handle_same_language_batch(validated_texts) if source_locale == target_locale
 
-      process_mixed_batch(validated_texts, source_locale, target_locale, context, glossary)
+      batch_config = { source_locale: source_locale, target_locale: target_locale, context: context,
+                       glossary: glossary, preserve_html: preserve_html }
+      process_mixed_batch(validated_texts, batch_config)
     end
 
     # Auto-détection de la langue source avec support du contexte
-    def translate_auto(text, to:, context: nil, glossary: nil)
+    def translate_auto(text, to:, context: nil, glossary: nil, preserve_html: false)
+      validated_text = Security::BasicValidator.validate_text!(text)
+      return "" if validated_text.empty?
+
       target_locale = LocaleHelper.validate_locale!(to)
 
-      # Premier appel pour détecter la langue
-      detection_prompt = build_language_detection_prompt(text)
-      detection_response = @client.complete(detection_prompt)
+      # Premier appel pour détecter la langue ; un échec lève une erreur
+      detection_response = @client.complete(build_language_detection_prompt(validated_text), json: true)
       detected_language = parse_language_detection(detection_response)
-
-      # Vérifier que la langue détectée est différente de la cible
-      if detected_language == target_locale
-        # Si même langue, retourner le texte original
-        return text
-      end
+      return validated_text if detected_language == target_locale
 
       # Puis traduction normale avec contexte
-      translate(text, from: detected_language, to: target_locale, context: context, glossary: glossary)
+      translate(validated_text, from: detected_language, to: target_locale, context: context, glossary: glossary,
+                                preserve_html: preserve_html)
     end
 
     private
@@ -118,10 +119,8 @@ module MistralTranslator
       validated_texts.each_with_index.to_h { |text, index| [index, text] }
     end
 
-    def process_mixed_batch(validated_texts, source_locale, target_locale, context, glossary)
+    def process_mixed_batch(validated_texts, batch_config)
       results = {}
-      batch_config = { source_locale: source_locale, target_locale: target_locale, context: context,
-                       glossary: glossary }
       requests = build_batch_requests(validated_texts, batch_config, results)
 
       process_batch_requests(requests, results) if requests.any?
@@ -146,7 +145,8 @@ module MistralTranslator
     def create_batch_request(text, batch_config, index)
       {
         prompt: build_translation_prompt(text, batch_config[:source_locale], batch_config[:target_locale],
-                                         context: batch_config[:context], glossary: batch_config[:glossary]),
+                                         context: batch_config[:context], glossary: batch_config[:glossary],
+                                         preserve_html: batch_config[:preserve_html]),
         from: batch_config[:source_locale],
         to: batch_config[:target_locale],
         index: index,
@@ -171,6 +171,9 @@ module MistralTranslator
       parsed_result[:translated] if parsed_result
     rescue EmptyTranslationError
       ""
+    rescue InvalidResponseError
+      # Une réponse illisible fait échouer son élément, pas tout le lot
+      nil
     end
 
     def translate_with_retry(text, source_locale, target_locale, attempt = 0, **options)
@@ -184,9 +187,12 @@ module MistralTranslator
         translate_with_retry(text, source_locale, target_locale, attempt + 1, **options)
       end
     rescue RateLimitError
+      # Le client a déjà relancé avec backoff : quelques tentatives de plus suffisent.
+      raise if attempt >= DEFAULT_RETRY_COUNT
+
       log_rate_limit_hit(source_locale, target_locale)
       sleep(DEFAULT_RETRY_DELAY)
-      retry
+      translate_with_retry(text, source_locale, target_locale, attempt + 1, **options)
     end
 
     # Ces méthodes sont héritées via RequestHelper
@@ -194,60 +200,10 @@ module MistralTranslator
     # Log via LoggingHelper
 
     def build_translation_prompt(text, source_locale, target_locale, **options)
-      base_prompt = PromptBuilder.translation_prompt(text, source_locale, target_locale,
-                                                     preserve_html: options.fetch(:preserve_html, false))
-
-      # Enrichir le prompt avec le contexte et le glossaire
-      context_present = options[:context] && !options[:context].to_s.strip.empty?
-      glossary_present =
-        (options[:glossary].is_a?(Hash) && options[:glossary].any?) ||
-        (options[:glossary].is_a?(String) && !options[:glossary].to_s.strip.empty?)
-      if context_present || glossary_present
-        enrich_prompt_with_context(base_prompt, options[:context], options[:glossary])
-      else
-        base_prompt
-      end
-    end
-
-    def enrich_prompt_with_context(base_prompt, context, glossary)
-      enriched_parts = []
-      context_part = build_context_enrichment(context)
-      glossary_part = build_glossary_enrichment(glossary)
-      enriched_parts << context_part if context_part
-      enriched_parts << glossary_part if glossary_part
-
-      return base_prompt if enriched_parts.empty?
-
-      enriched_context = enriched_parts.join("\n")
-      base_prompt.sub("RÈGLES :", "#{enriched_context}\n\nRÈGLES :")
-    end
-
-    def build_context_enrichment(context)
-      return nil if context.nil? || context.to_s.strip.empty?
-
-      "CONTEXTE : #{context}"
-    end
-
-    def build_glossary_enrichment(glossary)
-      return nil if glossary.nil?
-      return build_glossary_hash(glossary) if glossary.is_a?(Hash)
-      return build_glossary_string(glossary) if glossary.is_a?(String)
-
-      nil
-    end
-
-    def build_glossary_hash(glossary_hash)
-      return nil if glossary_hash.empty?
-
-      glossary_text = glossary_hash.map { |key, value| "#{key} → #{value}" }.join(", ")
-      "GLOSSAIRE (à respecter strictement) : #{glossary_text}"
-    end
-
-    def build_glossary_string(glossary_string)
-      value = glossary_string.to_s.strip
-      return nil if value.empty?
-
-      "GLOSSAIRE : #{value}"
+      PromptBuilder.translation_prompt(text, source_locale, target_locale,
+                                       context: options[:context],
+                                       glossary: options[:glossary],
+                                       preserve_html: options.fetch(:preserve_html, false))
     end
   end
 end

data/lib/mistral_translator/translator_helpers.rb

@@ -91,34 +91,6 @@ module MistralTranslator
       end
     end
 
-    # Helper pour la gestion des prompts
-    module PromptHandler
-      def enrich_prompt_with_context(base_prompt, context, glossary)
-        context_section = build_context_section(context, glossary)
-        base_prompt + context_section
-      end
-
-      def build_context_section(context, glossary)
-        context_section = ""
-        context_section += add_context_text(context) if context && !context.to_s.strip.empty?
-        context_section += add_glossary_text(glossary) if glossary && !glossary.to_s.strip.empty?
-        context_section
-      end
-
-      def add_context_text(context)
-        "\nCONTEXTE : #{context}\n"
-      end
-
-      def add_glossary_text(glossary)
-        if glossary.is_a?(Hash) && glossary.any?
-          glossary_text = glossary.map { |key, value| "#{key} → #{value}" }.join(", ")
-          "\nGLOSSAIRE (à respecter strictement) : #{glossary_text}\n"
-        else
-          "\nGLOSSAIRE : #{glossary}\n"
-        end
-      end
-    end
-
     # Helper pour l'analyse et la détection de langue
     module AnalysisHelper
       def calculate_confidence_score(original, translated, from_locale, to_locale)
@@ -152,16 +124,17 @@ module MistralTranslator
         PromptBuilder.language_detection_prompt(text)
       end
 
+      # Fail-closed : une détection illisible ou une langue non supportée lève une erreur,
+      # au lieu de supposer une langue et de renvoyer le texte non traduit.
       def parse_language_detection(response)
-        json_content = response.match(/\{.*\}/m)&.[](0)
-        return "en" unless json_content
-
-        data = JSON.parse(json_content)
-        detected = data.dig("metadata", "detected_language")
+        data = JSON.parse(response.to_s)
+        metadata = data["metadata"] if data.is_a?(Hash)
+        detected = LocaleHelper.normalize_locale(metadata["detected_language"]) if metadata.is_a?(Hash)
+        return detected if detected && LocaleHelper.locale_supported?(detected)
 
-        LocaleHelper.locale_supported?(detected) ? detected : "en"
+        raise InvalidResponseError.new("Language detection failed", response)
       rescue JSON::ParserError
-        "en"
+        raise InvalidResponseError.new("Language detection failed", response), cause: nil
       end
     end
 
@@ -187,31 +160,13 @@ module MistralTranslator
       end
 
       def perform_client_request(prompt, request_context)
-        if @client.respond_to?(:complete)
-          begin
-            return @client.complete(prompt, context: request_context)
-          rescue StandardError => e
-            raise e unless e.class.name.include?("MockExpectationError") && @client.respond_to?(:make_request)
-
-            return @client.make_request(prompt, nil, nil)
-          end
-        end
-
-        return @client.make_request(prompt, nil, nil) if @client.respond_to?(:make_request)
-
-        @client.complete(prompt, context: request_context)
+        @client.complete(prompt, context: request_context, json: true)
       end
 
+      # Une réponse inexploitable lève une erreur : jamais de réponse brute enregistrée comme traduction.
       def extract_translated_text!(raw_response)
-        begin
-          result = ResponseParser.parse_translation_response(raw_response)
-          return result[:translated] if result && !result[:translated].to_s.empty?
-        rescue EmptyTranslationError, InvalidResponseError
-          # Fallback: accepter une réponse texte brute non vide
-          fallback_text = raw_response.to_s.strip
-          return fallback_text unless fallback_text.empty?
-          # sinon on relance l'erreur plus bas
-        end
+        result = ResponseParser.parse_translation_response(raw_response)
+        return result[:translated] if result && !result[:translated].to_s.empty?
 
         raise EmptyTranslationError
       end
@@ -228,10 +183,14 @@ module MistralTranslator
 
     # Helper pour traductions multi-cibles
     module MultiTargetHelper
-      def translate_to_multiple_batch(text, source_locale, target_locales, context: nil, glossary: nil)
+      DEFAULT_MULTI_TARGET_OPTIONS = { context: nil, glossary: nil }.freeze
+
+      # options : context, glossary, preserve_html
+      def translate_to_multiple_batch(text, source_locale, target_locales, **options)
+        options = DEFAULT_MULTI_TARGET_OPTIONS.merge(options)
         requests = target_locales.map do |target_locale|
           {
-            prompt: build_translation_prompt(text, source_locale, target_locale, context: context, glossary: glossary),
+            prompt: build_translation_prompt(text, source_locale, target_locale, **options),
             from: source_locale,
             to: target_locale,
             original_text: text
@@ -244,21 +203,28 @@ module MistralTranslator
         batch_results.each do |result|
           next unless result[:success]
 
-          target_locale = result[:original_request][:to]
-          parsed_result = ResponseParser.parse_translation_response(result[:result])
-          results[target_locale] = parsed_result[:translated] if parsed_result
+          translated = parse_batch_translation(result[:result])
+          results[result[:original_request][:to]] = translated if translated
         end
 
         results
       end
 
-      def translate_to_multiple_sequential(text, source_locale, target_locales, context: nil, glossary: nil)
+      # Une réponse illisible fait échouer sa langue, pas tout le lot
+      def parse_batch_translation(response)
+        ResponseParser.parse_translation_response(response)&.fetch(:translated)
+      rescue EmptyTranslationError, InvalidResponseError
+        nil
+      end
+
+      def translate_to_multiple_sequential(text, source_locale, target_locales, **options)
+        options = DEFAULT_MULTI_TARGET_OPTIONS.merge(options)
         results = {}
 
         target_locales.each_with_index do |target_locale, index|
           sleep(MistralTranslator::Translator::DEFAULT_RETRY_DELAY) if index.positive?
           results[target_locale] =
-            translate_with_retry(text, source_locale, target_locale, context: context, glossary: glossary)
+            translate_with_retry(text, source_locale, target_locale, **options)
         end
 
         results

data/lib/mistral_translator/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MistralTranslator
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 
   # Informations additionnelles sur la gem
   API_VERSION = "v1"

data/lib/mistral_translator.rb

@@ -107,7 +107,7 @@ module MistralTranslator
 
     # Health check
     def health_check
-      client.complete("Hello", max_tokens: 10, context: {})
+      client.chat("Hello", max_tokens: 10)
       { status: :ok, message: "API connection successful" }
     rescue AuthenticationError
       { status: :error, message: "Authentication failed - check your API key" }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mistral_translator
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Pierre Cherbero
@@ -159,15 +159,18 @@ files:
 - lib/mistral_translator/client.rb
 - lib/mistral_translator/client_helpers.rb
 - lib/mistral_translator/configuration.rb
+- lib/mistral_translator/data/languages.json
 - lib/mistral_translator/errors.rb
 - lib/mistral_translator/helpers.rb
 - lib/mistral_translator/helpers_extensions.rb
 - lib/mistral_translator/levenshtein_helpers.rb
 - lib/mistral_translator/locale_helper.rb
 - lib/mistral_translator/logger.rb
+- lib/mistral_translator/prompt.rb
 - lib/mistral_translator/prompt_builder.rb
 - lib/mistral_translator/prompt_helpers.rb
 - lib/mistral_translator/prompt_metadata_helpers.rb
+- lib/mistral_translator/proxy.rb
 - lib/mistral_translator/response_parser.rb
 - lib/mistral_translator/security.rb
 - lib/mistral_translator/summarizer.rb