mistral_translator 0.1.0 → 0.2.1

data/lib/mistral_translator/helpers.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+require_relative "helpers_extensions"
+require_relative "levenshtein_helpers"
+
+module MistralTranslator
+  module Helpers
+    extend HelpersExtensions::TranslationHelpers
+    extend HelpersExtensions::AnalysisHelpers
+    extend HelpersExtensions::CostHelpers
+
+    class << self
+      # Helper pour traduction par batch avec gestion d'erreurs avancée
+      def translate_batch_with_fallback(texts, from:, to:, **options)
+        # Fallback par défaut: retraduire individuellement les éléments manquants
+        options = { fallback_strategy: :individual }.merge(options)
+        translator = Translator.new
+
+        begin
+          results = attempt_batch_translation(translator, texts, from, to, options)
+          handle_missing_results({ translator: translator, texts: texts, from: from, to: to, results: results },
+                                 **options)
+          results
+        rescue StandardError => e
+          handle_batch_failure(e, { translator: translator, texts: texts, from: from, to: to }, **options)
+        end
+      end
+
+      private
+
+      def attempt_batch_translation(translator, texts, from, to, options)
+        translator.translate_batch(texts, from: from, to: to, context: options[:context], glossary: options[:glossary])
+      end
+
+      def handle_missing_results(translation_data, **options)
+        translator = translation_data[:translator]
+        texts = translation_data[:texts]
+        from = translation_data[:from]
+        to = translation_data[:to]
+        results = translation_data[:results]
+
+        missing_indices = find_missing_indices(texts, results)
+        return unless missing_indices.any? && options[:fallback_strategy] == :individual
+
+        translation_params = { translator: translator, texts: texts, from: from, to: to, results: results,
+                               missing_indices: missing_indices }
+        retry_missing_translations(translation_params, **options)
+      end
+
+      def find_missing_indices(texts, results)
+        missing_indices = []
+        texts.each_with_index do |_, index|
+          missing_indices << index unless results[index]
+        end
+        missing_indices
+      end
+
+      def retry_missing_translations(params, **options)
+        translator = params[:translator]
+        texts = params[:texts]
+        from = params[:from]
+        to = params[:to]
+        results = params[:results]
+        missing_indices = params[:missing_indices]
+
+        missing_indices.each do |index|
+          results[index] =
+            translator.translate(texts[index], from: from, to: to, context: options[:context],
+                                               glossary: options[:glossary])
+        rescue StandardError => e
+          results[index] = { error: e.message }
+        end
+      end
+
+      def handle_batch_failure(error, translation_data, **options)
+        raise error unless options[:fallback_strategy] == :individual
+
+        _translator = translation_data[:translator]
+        texts = translation_data[:texts]
+        from = translation_data[:from]
+        to = translation_data[:to]
+
+        translate_individually_with_errors(texts, from: from, to: to, context: options[:context],
+                                                  glossary: options[:glossary])
+      end
+
+      # Helper pour traduction progressive avec callback
+      public
+
+      def translate_with_progress(items, from:, to:, context: nil, glossary: nil, &progress_callback)
+        results = {}
+        total = items.size
+
+        items.each_with_index do |(key, text), index|
+          begin
+            result = MistralTranslator.translate(text, from: from, to: to, context: context, glossary: glossary)
+            results[key] = { success: true, translation: result }
+          rescue StandardError => e
+            results[key] = { success: false, error: e.message }
+          end
+
+          # Appeler le callback de progression
+          progress_callback&.call(index + 1, total, key, results[key])
+        end
+
+        results
+      end
+
+      # Helper pour résumé intelligent avec détection automatique
+      def smart_summarize(text, max_words: 250, target_language: "fr", style: nil, context: nil)
+        # Détecter si c'est du HTML/Rich Text
+        is_html = text.include?("<") && text.include?(">")
+
+        # Nettoyer pour l'analyse si nécessaire
+        analysis_text = is_html ? strip_html_for_analysis(text) : text
+
+        # Calculer la longueur optimale selon le contenu
+        optimal_words = calculate_optimal_summary_length(analysis_text, max_words)
+
+        result = MistralTranslator.summarize(
+          text,
+          language: target_language,
+          max_words: optimal_words,
+          style: style,
+          context: context
+        )
+
+        {
+          summary: result,
+          original_length: analysis_text.split.size,
+          summary_length: optimal_words,
+          compression_ratio: (optimal_words.to_f / analysis_text.split.size * 100).round(1)
+        }
+      end
+
+      # Helper pour traduction multi-style
+      def translate_multi_style(text, from:, to:, **options)
+        results = {}
+
+        styles = options[:styles] || %i[formal casual]
+        styles.each do |style|
+          style_context = options[:context] ? "#{options[:context]} (Style: #{style})" : "Style: #{style}"
+
+          begin
+            results[style] = MistralTranslator.translate(
+              text,
+              from: from,
+              to: to,
+              context: style_context,
+              glossary: options[:glossary]
+            )
+          rescue StandardError => e
+            results[style] = { error: e.message }
+          end
+        end
+
+        results
+      end
+
+      # Helper pour validation de locale avec suggestions
+
+      def validate_locale_with_suggestions(locale)
+        { valid: true, locale: LocaleHelper.validate_locale!(locale) }
+      rescue UnsupportedLanguageError => e
+        suggestions = find_locale_suggestions(locale)
+        {
+          valid: false,
+          error: e.message,
+          suggestions: suggestions,
+          supported_locales: LocaleHelper.supported_locales
+        }
+      end
+
+      # Helper pour configuration rapide Rails
+      def setup_rails_integration(api_key: nil, enable_metrics: true, setup_logging: true)
+        MistralTranslator.configure do |config|
+          config.api_key = api_key || ENV.fetch("MISTRAL_API_KEY", nil)
+          config.enable_metrics = enable_metrics
+          config.setup_rails_logging if setup_logging
+
+          # Callbacks Rails-friendly
+          if enable_metrics && defined?(Rails)
+            config.on_translation_complete = lambda { |_from, _to, _orig_len, _trans_len, _duration|
+              Rails.cache.increment("mistral_translator_translations_count", 1)
+              Rails.cache.write("mistral_translator_last_translation", Time.now)
+            }
+          end
+        end
+      end
+
+      private
+
+      def translate_individually_with_errors(texts, from:, to:, context: nil, glossary: nil)
+        # Adapter la signature aux specs tests
+
+        translator = Translator.new
+        results = {}
+
+        texts.each_with_index do |text, index|
+          results[index] = translator.translate(text, from: from, to: to, context: context, glossary: glossary)
+        rescue StandardError => e
+          results[index] = { error: e.message }
+        end
+
+        results
+      end
+
+      def strip_html_for_analysis(html_text)
+        # Suppression basique des balises HTML pour l'analyse
+        html_text.gsub(/<[^>]*>/, " ").gsub(/\s+/, " ").strip
+      end
+
+      def calculate_optimal_summary_length(text, max_words)
+        word_count = text.split.size
+
+        case word_count
+        when 0..100
+          # Texte très court, résumé minimal
+          [max_words, word_count / 2].min
+        when 101..500
+          # Texte court à moyen
+          [max_words, word_count / 3].min
+        when 501..2000
+          # Texte moyen à long
+          [max_words, word_count / 4].min
+        else
+          # Texte très long
+          [max_words, word_count / 5].min
+        end
+      end
+
+      def find_locale_suggestions(invalid_locale)
+        return [] unless invalid_locale.is_a?(String)
+
+        supported = LocaleHelper.supported_locales.map(&:to_s)
+
+        # Recherche par similarité basique
+        suggestions = supported.select do |locale|
+          locale.start_with?(invalid_locale.downcase) ||
+            invalid_locale.downcase.start_with?(locale)
+        end
+
+        # Si pas de suggestions par préfixe, chercher par distance
+        if suggestions.empty?
+          suggestions = supported.select do |locale|
+            LevenshteinHelpers.levenshtein_distance(invalid_locale.downcase, locale) <= 2
+          end
+        end
+
+        suggestions.first(3) # Limiter à 3 suggestions
+      end
+
+      # Exposer la distance de Levenshtein en privé via délégation pour les tests
+      def levenshtein_distance(source_string, target_string)
+        LevenshteinHelpers.levenshtein_distance(source_string, target_string)
+      end
+    end
+
+    # Module pour inclure dans les classes Rails si souhaité
+    module RecordHelpers
+      def translate_with_mistral(fields, from:, to:, **)
+        adapter = MistralTranslator::Adapters::AdapterFactory.build_for(self)
+        service = MistralTranslator::Adapters::RecordTranslationService.new(self, fields, adapter: adapter, from: from,
+                                                                                          to: to, **)
+        service.translate_to_all_locales
+      end
+
+      def estimate_translation_cost_for_fields(fields, from:, to:, rate_per_1k_chars: 0.02)
+        total_chars = 0
+
+        Array(fields).each do |field|
+          content = begin
+            public_send("#{field}_#{from}")
+          rescue StandardError
+            nil
+          end
+          next unless content
+
+          text = content.respond_to?(:to_plain_text) ? content.to_plain_text : content.to_s
+          total_chars += text.length
+        end
+
+        MistralTranslator::Helpers.estimate_translation_cost(
+          "x" * total_chars, # Dummy text de la bonne longueur
+          from: from,
+          to: to,
+          rate_per_1k_chars: rate_per_1k_chars
+        )
+      end
+    end
+  end
+end

data/lib/mistral_translator/helpers_extensions.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module MistralTranslator
+  module HelpersExtensions
+    # Extensions pour les helpers de traduction
+    module TranslationHelpers
+      def translate_with_quality_check(text, from:, to:, **options)
+        client = Client.new
+
+        # Unique requête avec validation de qualité intégrée
+        qp_options = { context: options[:context], glossary: options[:glossary] }
+        quality_prompt = PromptBuilder.translation_with_validation_prompt(text, from, to, **qp_options)
+        quality_response = client.complete(quality_prompt, context: { from_locale: from, to_locale: to })
+
+        quality_data = ResponseParser.parse_quality_check_response(quality_response)
+
+        {
+          translation: quality_data[:translation],
+          quality_check: quality_data[:quality_check],
+          metadata: quality_data[:metadata]
+        }
+      end
+
+      def translate_rich_text(text, from:, to:, **options)
+        opts = { context: options[:context], glossary: options[:glossary] }
+        MistralTranslator.translate(text, from: from, to: to, preserve_html: true, **opts)
+      end
+
+      def translate_with_progress(items, from:, to:, **options)
+        results = {}
+        total = items.size
+        processed = 0
+
+        items.each do |key, text|
+          results[key] = MistralTranslator.translate(text, from: from, to: to, **options)
+          processed += 1
+          yield(processed, total, key) if block_given?
+        end
+
+        results
+      end
+
+      def translate_multi_style(text, from:, to:, **options)
+        results = {}
+
+        styles = options[:styles] || %i[formal casual]
+        styles.each do |style|
+          style_context = options[:context] ? "#{options[:context]} (Style: #{style})" : "Style: #{style}"
+
+          begin
+            results[style] = MistralTranslator.translate(
+              text,
+              from: from,
+              to: to,
+              context: style_context,
+              glossary: options[:glossary]
+            )
+          rescue StandardError => e
+            results[style] = { error: e.message }
+          end
+        end
+
+        results
+      end
+    end
+
+    # Extensions pour les helpers d'analyse
+    module AnalysisHelpers
+      def analyze_text_complexity(text)
+        words = text.split
+        sentences = text.split(/[.!?]+/)
+        paragraphs = text.split(/\n\s*\n/)
+
+        {
+          word_count: words.size,
+          sentence_count: sentences.size,
+          paragraph_count: paragraphs.size,
+          average_words_per_sentence: words.size.to_f / sentences.size,
+          average_sentences_per_paragraph: sentences.size.to_f / paragraphs.size,
+          complexity_score: calculate_complexity_score(words, sentences)
+        }
+      end
+
+      def calculate_complexity_score(words, sentences)
+        # Score basique basé sur la longueur moyenne des mots et phrases
+        avg_word_length = words.map(&:length).sum.to_f / words.size
+        avg_sentence_length = words.size.to_f / sentences.size
+
+        # Normalisation simple (0-100)
+        word_score = [avg_word_length * 10, 50].min
+        sentence_score = [avg_sentence_length * 2, 50].min
+
+        (word_score + sentence_score).round(1)
+      end
+
+      def suggest_optimal_summary_length(text, target_compression: 0.3)
+        word_count = text.split.size
+        optimal_words = (word_count * target_compression).round
+
+        {
+          original_words: word_count,
+          suggested_words: optimal_words,
+          compression_ratio: (optimal_words.to_f / word_count * 100).round(1)
+        }
+      end
+
+      def find_locale_suggestions(invalid_locale)
+        return [] unless invalid_locale.is_a?(String)
+
+        supported = LocaleHelper.supported_locales.map(&:to_s)
+
+        # Recherche par similarité basique
+        suggestions = supported.select do |locale|
+          locale.start_with?(invalid_locale.downcase) ||
+            invalid_locale.downcase.start_with?(locale)
+        end
+
+        # Si pas de suggestions par préfixe, chercher par distance
+        if suggestions.empty?
+          suggestions = supported.select do |locale|
+            levenshtein_distance(invalid_locale.downcase, locale) <= 2
+          end
+        end
+
+        suggestions.first(3) # Limiter à 3 suggestions
+      end
+    end
+
+    # Extensions pour les helpers de coût
+    module CostHelpers
+      def estimate_translation_cost(text, from: nil, to: nil, rate_per_1k_chars: 0.02)
+        # from et to sont conservés pour l'interface mais pas utilisés dans le calcul
+        _ = from
+        _ = to
+        char_count = text.length
+        estimated_cost = (char_count / 1000.0) * rate_per_1k_chars
+
+        {
+          character_count: char_count,
+          estimated_cost: estimated_cost.round(4),
+          rate_per_1k_chars: rate_per_1k_chars,
+          currency: "USD",
+          supported_locales: LocaleHelper.supported_locales,
+          disclaimer: "Estimation basique, coûts réels selon le modèle et le contexte",
+          rate_used: rate_per_1k_chars
+        }
+      end
+    end
+  end
+end

data/lib/mistral_translator/levenshtein_helpers.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module MistralTranslator
+  module LevenshteinHelpers
+    class << self
+      def levenshtein_distance(str1, str2)
+        return str2.length if str1.empty?
+        return str1.length if str2.empty?
+
+        matrix = initialize_levenshtein_matrix(str1, str2)
+        fill_levenshtein_matrix(matrix, str1, str2)
+        matrix[str1.length][str2.length]
+      end
+
+      def initialize_levenshtein_matrix(str1, str2)
+        matrix = Array.new(str1.length + 1) { Array.new(str2.length + 1) }
+        (0..str1.length).each { |i| matrix[i][0] = i }
+        (0..str2.length).each { |j| matrix[0][j] = j }
+        matrix
+      end
+
+      def fill_levenshtein_matrix(matrix, str1, str2)
+        (1..str1.length).each do |i|
+          (1..str2.length).each do |j|
+            cost = str1[i - 1] == str2[j - 1] ? 0 : 1
+            matrix[i][j] = calculate_minimum_cost(matrix, i, j, cost)
+          end
+        end
+      end
+
+      def calculate_minimum_cost(matrix, row_idx, col_idx, cost)
+        [
+          matrix[row_idx - 1][col_idx] + 1,     # deletion
+          matrix[row_idx][col_idx - 1] + 1,     # insertion
+          matrix[row_idx - 1][col_idx - 1] + cost # substitution
+        ].min
+      end
+    end
+  end
+end

data/lib/mistral_translator/logger.rb

@@ -36,15 +36,39 @@ module MistralTranslator
       private
 
       def log(level, message, sensitive)
+        # Sanitiser le message si sensible
+        sanitized_message = sensitive ? sanitize_log_data(message) : message
+
         # En mode Rails, utiliser le logger Rails
         if defined?(Rails) && Rails.respond_to?(:logger)
-          Rails.logger.public_send(level, "[MistralTranslator] #{message}")
-        # Sinon, utiliser puts seulement si pas sensible et debug activé
-        elsif !sensitive && ENV["MISTRAL_TRANSLATOR_DEBUG"] == "true"
-          puts "[MistralTranslator] #{message}"
+          Rails.logger.public_send(level, "[MistralTranslator] #{sanitized_message}")
+        # Sinon, utiliser puts si debug activé (même pour les messages sensibles, ils sont déjà sanitisés)
+        elsif ENV["MISTRAL_TRANSLATOR_DEBUG"] == "true"
+          puts "[MistralTranslator] #{sanitized_message}"
         end
       end
 
+      def sanitize_log_data(data)
+        return data unless data.is_a?(String)
+
+        # Masquer les clés API Bearer
+        data = data.gsub(/Bearer\s+[A-Za-z0-9_-]+/, "Bearer [REDACTED]")
+
+        # Masquer les clés API dans les URLs
+        data = data.gsub(/[?&]api_key=[A-Za-z0-9_-]+/, "?api_key=[REDACTED]")
+
+        # Masquer les tokens d'authentification
+        data = data.gsub(/token=\s*[A-Za-z0-9_-]+/, "token=[REDACTED]")
+        data = data.gsub(/token:\s*[A-Za-z0-9_-]+/, "token: [REDACTED]")
+
+        # Masquer les mots de passe
+        data = data.gsub(/password=\s*[^\s&]+/, "password=[REDACTED]")
+        data = data.gsub(/password:\s*[^\s&]+/, "password: [REDACTED]")
+
+        # Masquer les secrets
+        data.gsub(/secret[=:]\s*[A-Za-z0-9_-]+/, "secret=[REDACTED]")
+      end
+
       def should_log_warning?(key, ttl)
         return true unless @warn_cache[key]