mistral_translator 0.1.0

data/lib/mistral_translator/translator.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative "logger"
+
+module MistralTranslator
+  class Translator
+    DEFAULT_RETRY_COUNT = 3
+    DEFAULT_RETRY_DELAY = 2
+
+    def initialize(client: nil)
+      @client = client || Client.new
+    end
+
+    # Traduction simple d'un texte vers une langue
+    def translate(text, from:, to:)
+      validate_inputs!(text, from, to)
+
+      source_locale = LocaleHelper.validate_locale!(from)
+      target_locale = LocaleHelper.validate_locale!(to)
+
+      translate_with_retry(text, source_locale, target_locale)
+    end
+
+    # Traduction vers plusieurs langues
+    def translate_to_multiple(text, from:, to:)
+      validate_translation_inputs!(text, from, to)
+
+      source_locale = LocaleHelper.validate_locale!(from)
+      target_locales = Array(to).map { |locale| LocaleHelper.validate_locale!(locale) }
+
+      results = {}
+
+      target_locales.each_with_index do |target_locale, index|
+        # Délai entre les requêtes, mais pas avant la première
+        sleep(DEFAULT_RETRY_DELAY) if index.positive?
+        results[target_locale] = translate_with_retry(text, source_locale, target_locale)
+      end
+
+      results
+    end
+
+    # Traduction en lot (plusieurs textes vers une langue)
+    def translate_batch(texts, from:, to:)
+      validate_batch_inputs!(texts, from, to)
+
+      source_locale = LocaleHelper.validate_locale!(from)
+      target_locale = LocaleHelper.validate_locale!(to)
+
+      # Pour des lots importants, on peut les découper
+      if texts.length > 10
+        translate_large_batch(texts, source_locale, target_locale)
+      else
+        translate_small_batch(texts, source_locale, target_locale)
+      end
+    end
+
+    # Auto-détection de la langue source (utilise l'API pour détecter)
+    def translate_auto(text, to:)
+      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)
+      detected_language = parse_language_detection(detection_response)
+
+      # Puis traduction normale
+      translate(text, from: detected_language, to: target_locale)
+    end
+
+    private
+
+    def translate_with_retry(text, source_locale, target_locale, attempt = 0)
+      prompt = PromptBuilder.translation_prompt(text, source_locale, target_locale)
+      raw_response = @client.complete(prompt)
+
+      result = ResponseParser.parse_translation_response(raw_response)
+      raise EmptyTranslationError if result.nil? || result[:translated].nil?
+
+      result[:translated]
+    rescue EmptyTranslationError, InvalidResponseError => e
+      raise e unless attempt < DEFAULT_RETRY_COUNT
+
+      wait_time = DEFAULT_RETRY_DELAY * (2**attempt) # Backoff exponentiel
+      log_retry(e, attempt + 1, wait_time)
+      sleep(wait_time)
+      translate_with_retry(text, source_locale, target_locale, attempt + 1)
+    rescue RateLimitError => e
+      log_rate_limit_hit(source_locale, target_locale)
+      sleep(DEFAULT_RETRY_DELAY)
+      retry
+    end
+
+    def translate_small_batch(texts, source_locale, target_locale)
+      prompt = PromptBuilder.bulk_translation_prompt(texts, source_locale, target_locale)
+      raw_response = @client.complete(prompt)
+
+      results = ResponseParser.parse_bulk_translation_response(raw_response)
+
+      # Retourner un hash indexé par l'ordre original
+      results.each_with_object({}) do |result, hash|
+        original_index = result[:index] - 1 # L'API retourne 1-indexed
+        hash[original_index] = result[:translated]
+      end
+    end
+
+    def translate_large_batch(texts, source_locale, target_locale)
+      results = {}
+
+      texts.each_slice(10).with_index do |batch, batch_index|
+        sleep(DEFAULT_RETRY_DELAY) if batch_index.positive? # Délai entre les batches
+
+        batch_results = translate_small_batch(batch, source_locale, target_locale)
+
+        # Ajuster les index pour le batch
+        batch_results.each do |local_index, translation|
+          global_index = (batch_index * 10) + local_index
+          results[global_index] = translation
+        end
+      end
+
+      results
+    end
+
+    def build_language_detection_prompt(text)
+      PromptBuilder.language_detection_prompt(text)
+    end
+
+    def parse_language_detection(response)
+      json_content = response.match(/\{.*\}/m)&.[](0)
+      return "en" unless json_content # Défaut en anglais si détection échoue
+
+      data = JSON.parse(json_content)
+      detected = data["detected_language"]
+
+      LocaleHelper.locale_supported?(detected) ? detected : "en"
+    rescue JSON::ParserError
+      "en" # Défaut en anglais si parsing échoue
+    end
+
+    def validate_inputs!(text, from, to)
+      raise ArgumentError, "Text cannot be nil or empty" if text.nil? || text.empty?
+      raise ArgumentError, "Source language cannot be nil" if from.nil?
+      raise ArgumentError, "Target language cannot be nil" if to.nil?
+      raise ArgumentError, "Source and target languages cannot be the same" if from == to
+    end
+
+    def validate_translation_inputs!(text, from, to)
+      # Convertir to en array pour la validation
+      target_languages = Array(to)
+      raise ArgumentError, "Target languages cannot be empty" if target_languages.empty?
+
+      validate_inputs!(text, from, target_languages.first)
+    end
+
+    def validate_batch_inputs!(texts, from, to)
+      raise ArgumentError, "Texts array cannot be nil or empty" if texts.nil? || texts.empty?
+      raise ArgumentError, "Source language cannot be nil" if from.nil?
+      raise ArgumentError, "Target language cannot be nil" if to.nil?
+
+      texts.each_with_index do |text, index|
+        raise ArgumentError, "Text at index #{index} cannot be nil or empty" if text.nil? || text.empty?
+      end
+    end
+
+    def log_retry(error, attempt, wait_time)
+      message = "#{error.class.name}: #{error.message}. Retry #{attempt}/#{DEFAULT_RETRY_COUNT} in #{wait_time}s"
+      # Log une seule fois par type d'erreur pour éviter le spam
+      Logger.warn_once(message, key: "retry_#{error.class.name}", sensitive: false, ttl: 120)
+    end
+
+    def log_rate_limit_hit(source, target)
+      message = "Rate limit hit for translation #{source} -> #{target}, retrying..."
+      # Log une seule fois par paire de langues
+      Logger.warn_once(message, key: "rate_limit_#{source}_#{target}", sensitive: false, ttl: 300)
+    end
+  end
+end

data/lib/mistral_translator/version.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MistralTranslator
+  VERSION = "0.1.0"
+
+  # Informations additionnelles sur la gem
+  API_VERSION = "v1"
+  SUPPORTED_MODEL = "mistral-small"
+
+  # Méthode pour obtenir des informations complètes sur la version
+  def self.version_info
+    {
+      gem_version: VERSION,
+      api_version: API_VERSION,
+      supported_model: SUPPORTED_MODEL,
+      ruby_version: RUBY_VERSION,
+      platform: RUBY_PLATFORM
+    }
+  end
+end

data/lib/mistral_translator.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "mistral_translator/version"
+require_relative "mistral_translator/errors"
+require_relative "mistral_translator/configuration"
+require_relative "mistral_translator/locale_helper"
+require_relative "mistral_translator/prompt_builder"
+require_relative "mistral_translator/response_parser"
+require_relative "mistral_translator/client"
+require_relative "mistral_translator/translator"
+require_relative "mistral_translator/summarizer"
+
+module MistralTranslator
+  class << self
+    # Méthodes de convenance pour accès direct
+    def translate(text, from:, to:)
+      translator.translate(text, from: from, to: to)
+    end
+
+    def translate_to_multiple(text, from:, to:)
+      translator.translate_to_multiple(text, from: from, to: to)
+    end
+
+    def translate_batch(texts, from:, to:)
+      translator.translate_batch(texts, from: from, to: to)
+    end
+
+    def translate_auto(text, to:)
+      translator.translate_auto(text, to: to)
+    end
+
+    def summarize(text, language: "fr", max_words: 250)
+      summarizer.summarize(text, language: language, max_words: max_words)
+    end
+
+    def summarize_and_translate(text, from:, to:, max_words: 250)
+      summarizer.summarize_and_translate(text, from: from, to: to, max_words: max_words)
+    end
+
+    def summarize_to_multiple(text, languages:, max_words: 250)
+      summarizer.summarize_to_multiple(text, languages: languages, max_words: max_words)
+    end
+
+    def summarize_tiered(text, language: "fr", short: 50, medium: 150, long: 300)
+      summarizer.summarize_tiered(text, language: language, short: short, medium: medium, long: long)
+    end
+
+    # Méthodes utilitaires
+    def supported_languages
+      LocaleHelper.supported_languages_list
+    end
+
+    def supported_locales
+      LocaleHelper.supported_locales
+    end
+
+    def locale_supported?(locale)
+      LocaleHelper.locale_supported?(locale)
+    end
+
+    # Configuration
+    def configure
+      yield(configuration) if block_given?
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+      @translator = nil
+      @summarizer = nil
+      @client = nil
+    end
+
+    # Version info
+    def version
+      VERSION
+    end
+
+    # Health check
+    def health_check
+      client.complete("Hello", max_tokens: 10)
+      { status: :ok, message: "API connection successful" }
+    rescue AuthenticationError
+      { status: :error, message: "Authentication failed - check your API key" }
+    rescue ApiError => e
+      { status: :error, message: "API error: #{e.message}" }
+    rescue StandardError => e
+      { status: :error, message: "Unexpected error: #{e.message}" }
+    end
+
+    private
+
+    def translator
+      @translator ||= Translator.new(client: client)
+    end
+
+    def summarizer
+      @summarizer ||= Summarizer.new(client: client)
+    end
+
+    def client
+      @client ||= Client.new
+    end
+  end
+
+  # Alias pour compatibilité
+  module Convenience
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def mistral_translate(text, from:, to:)
+        MistralTranslator.translate(text, from: from, to: to)
+      end
+
+      def mistral_summarize(text, language: "fr", max_words: 250)
+        MistralTranslator.summarize(text, language: language, max_words: max_words)
+      end
+    end
+  end
+end
+
+# Extensions optionnelles pour String
+if ENV["MISTRAL_TRANSLATOR_EXTEND_STRING"]
+  class String
+    def mistral_translate(from:, to:)
+      MistralTranslator.translate(self, from: from, to: to)
+    end
+
+    def mistral_summarize(language: "fr", max_words: 250)
+      MistralTranslator.summarize(self, language: language, max_words: max_words)
+    end
+  end
+end

data/sig/mistral_translator.rbs

@@ -0,0 +1,4 @@
+module MistralTranslator
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: mistral_translator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peyochanchan
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+description: Allows translating text into different languages and generating summaries
+  using the MistralAI API
+email:
+- cameleon24@outlook.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/basic_usage.rb
+- lib/mistral_translator.rb
+- lib/mistral_translator/client.rb
+- lib/mistral_translator/configuration.rb
+- lib/mistral_translator/errors.rb
+- lib/mistral_translator/locale_helper.rb
+- lib/mistral_translator/logger.rb
+- lib/mistral_translator/prompt_builder.rb
+- lib/mistral_translator/response_parser.rb
+- lib/mistral_translator/summarizer.rb
+- lib/mistral_translator/translator.rb
+- lib/mistral_translator/version.rb
+- sig/mistral_translator.rbs
+homepage: https://github.com/Peyochanchan/mistral_translator
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/Peyochanchan/mistral_translator
+  changelog_uri: https://github.com/Peyochanchan/mistral_translator/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.1
+specification_version: 4
+summary: Gem to translate and summarize text with Mistral API
+test_files: []