fastlane-plugin-translate_gpt 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 162ac503b51db5c9395059702dfeedca75cbcd3bb26f68702059f45eb4540ffc
-  data.tar.gz: d73722901b8e2d68c3287187687761930962e4392e7016847bfc9946d57c3748
+  metadata.gz: 8389bf90c62946cf66e3abb95d1fc9422a622146488f56c83985270a692c91f3
+  data.tar.gz: 9980483ba5032745071ad8f04ec9227c10385626cc678d5655b861294b2e2520
 SHA512:
-  metadata.gz: b260653373ca72b56e753aad327338559eeb330e64e602f905720b12d8cb6e6c35d0c5750e8be8199169d41cc7549dc19cd4f30a19caf652465ce3a6d10f54b1
-  data.tar.gz: 21df8623e7bce11bf1c3658917dd498bd95929e77236dc32509ca8f3245c8491450cecee1996f2b40147e834aa2a76582facea074dcaa17b8e916a652e964193
+  metadata.gz: 4da07c2656000de7cbfa28333fbf2c7949d9211166a89624a928f734cdfe4a2ece7ecacdd3aedc265cff9241a9998b2b722906b5bbeda43ff50e54a772620c83
+  data.tar.gz: a91b4055259f18d927cb0d1a2ec29ccf39e7385b646821018f462bea16afba69f03450ecb2b54c118a011c90b2a64bf4caefc41243c5188e2455dd8cf394c84b

data/lib/fastlane/plugin/translate_gpt/actions/translate_gpt_action.rb

@@ -7,73 +7,11 @@ module Fastlane
   module Actions
     class TranslateGptAction < Action
       def self.run(params)
-        client = OpenAI::Client.new(
-          access_token: params[:api_token],
-          request_timeout: params[:request_timeout]
-        )
-        
-        input_hash = Helper::TranslateGptHelper.get_strings(params[:source_file])
-        output_hash = Helper::TranslateGptHelper.get_strings(params[:target_file])
-
-        if params[:skip_translated]
-          to_translate = input_hash.reject { |k, v| output_hash[k] }
-        else 
-          to_translate = input_hash
-        end
-
-        UI.message "Translating #{to_translate.size} strings..."
-
-        to_translate.each_with_index do |(key, string), index|
-          prompt = "I want you to act as a translator for a mobile application strings. " + \
-            "You need to answer only with translation and nothing else. No commentaries. " + \
-            "Try to keep length of the translated text. " + \
-            "I will send you a text and you translate it from #{params[:source_language]} to #{params[:target_language]}. "
-          if params[:context] && !params[:context].empty?
-            prompt += "This app is #{params[:context]}. "
-          end 
-          context = string.comment
-          if context && !context.empty?
-            prompt += "Additional context is #{context}. "
-          end
-          prompt += "Source text:\n#{string.value}"
-
-          # translate the source string to the target language
-          response = client.chat(
-            parameters: {
-              model: params[:model_name], 
-              messages: [
-                { role: "user", content: prompt }
-              ], 
-              temperature: params[:temperature],
-            }
-          )
-          # extract the translated string from the response
-          error = response.dig("error", "message")
-          if error
-            UI.error "Error translating #{key}: #{error}"
-          else
-            target_string = response.dig("choices", 0, "message", "content")
-            if target_string && !target_string.empty?
-              UI.message "Translating #{key} - #{string.value} -> #{target_string}"
-              string.value = target_string
-              output_hash[key] = string
-            else
-              UI.warning "Unable to translate #{key} - #{string.value}"
-            end
-          end
-          if index < to_translate.size - 1
-            Helper::TranslateGptHelper.timeout params[:request_timeout]
-          end
-        end
-
-        UI.message "Writing #{output_hash.size} strings to #{params[:target_file]}..."
-
-        file = LocoStrings.load(params[:target_file])
-        file.read
-        output_hash.each do |key, value|
-          file.update(key, value.value, value.comment)
-        end
-        file.write
+        helper = Helper::TranslateGptHelper.new(params)
+        helper.prepare_hashes()
+        helper.log_input()
+        helper.translate_strings()
+        helper.write_output()
       end
 
       #####################################################

data/lib/fastlane/plugin/translate_gpt/helper/translate_gpt_helper.rb

@@ -6,10 +6,122 @@ module Fastlane
 
   module Helper
     class TranslateGptHelper
+      def initialize(params)
+        @params = params
+        @client = OpenAI::Client.new(
+          access_token: params[:api_token],
+          request_timeout: params[:request_timeout]
+        )
+        @timeout = params[:request_timeout]
+      end
+
+      # Get the strings from a file
+      def prepare_hashes() 
+        @input_hash = get_strings(@params[:source_file])
+        @output_hash = get_strings(@params[:target_file])
+        @to_translate = filter_translated(@params[:skip_translated], @input_hash, @output_hash)
+      end
+
+      # Log information about the input strings
+      def log_input() 
+        @translation_count = @to_translate.size
+        number_of_strings = Colorizer::colorize("#{@translation_count}", :blue)
+        UI.message "Translating #{number_of_strings} strings..."
+        if @translation_count > 0 
+          estimated_string = Colorizer::colorize("#{@translation_count * @params[:request_timeout]}", :white)
+          UI.message "Estimated time: #{estimated_string} seconds"
+        end
+      end
+
+      # Cycle through the input strings and translate them
+      def translate_strings()
+        @to_translate.each_with_index do |(key, string), index|
+          prompt = prepare_prompt string
+
+          max_retries = 10
+          times_retried = 0
+
+          # translate the source string to the target language
+          begin
+            request_translate(key, string, prompt, index)
+          rescue Net::ReadTimeout => error
+            if times_retried < max_retries
+              times_retried += 1
+              UI.important "Failed to request translation, retry #{times_retried}/#{max_retries}"
+              wait 1
+              retry
+            else
+              UI.error "Can't translate #{key}: #{error}"
+            end
+          end
+          if index < @translation_count - 1 then wait end
+        end
+      end
+
+      # Prepare the prompt for the GPT API
+      def prepare_prompt(string) 
+        prompt = "I want you to act as a translator for a mobile application strings. " + \
+            "Try to keep length of the translated text. " + \
+            "You need to answer only with the translation and nothing else until I say to stop it.  No commentaries." 
+        if @params[:context] && !@params[:context].empty?
+          prompt += "This app is #{@params[:context]}. "
+        end 
+        context = string.comment
+        if context && !context.empty?
+          prompt += "Additional context is #{context}. "
+        end
+        prompt += "Translate next text from #{@params[:source_language]} to #{@params[:target_language]}:\n" +
+          "#{string.value}"
+        return prompt
+      end
+
+      # Request a translation from the GPT API
+      def request_translate(key, string, prompt, index)
+        response = @client.chat(
+          parameters: {
+            model: @params[:model_name], 
+            messages: [
+              { role: "user", content: prompt }
+            ], 
+            temperature: @params[:temperature],
+          }
+        )
+        # extract the translated string from the response
+        error = response.dig("error", "message")
+        key_log = Colorizer::colorize(key, :blue)
+        index_log = Colorizer::colorize("[#{index + 1}/#{@translation_count}]", :white)
+        if error
+          UI.error "#{index_log} Error translating #{key_log}: #{error}"
+        else
+          target_string = response.dig("choices", 0, "message", "content")
+          if target_string && !target_string.empty?
+            UI.message "#{index_log} Translating #{key_log} - #{string.value} -> #{target_string}"
+            string.value = target_string
+            @output_hash[key] = string
+          else
+            UI.important "#{index_log} Unable to translate #{key_log} - #{string.value}"
+          end
+        end
+      end
+
+      # Write the translated strings to the target file
+      def write_output()
+        number_of_strings = Colorizer::colorize("#{@output_hash.size}", :blue)  
+        target_string = Colorizer::colorize(@params[:target_file], :white)
+        UI.message "Writing #{number_of_strings} strings to #{target_string}..."
+
+        file = LocoStrings.load(@params[:target_file])
+        file.read
+        @output_hash.each do |key, value|
+          file.update(key, value.value, value.comment)
+        end
+        file.write
+      end
+
       # Read the strings file into a hash
       # @param localization_file [String] The path to the strings file
       # @return [Hash] The strings file as a hash
-      def self.get_strings(localization_file)
+      def get_strings(localization_file)
         file = LocoStrings.load(localization_file)
         return file.read
       end
@@ -18,25 +130,36 @@ module Fastlane
       # @param localization_file [String] The path to the strings file
       # @param localization_key [String] The localization key
       # @return [String] The context associated with the localization key
-      def self.get_context(localization_file, localization_key)
+      def get_context(localization_file, localization_key)
         file = LocoStrings.load(localization_file)
         string = file.read[localization_key]
         return string.comment
       end
 
+      def filter_translated(need_to_skip, base, target) 
+        if need_to_skip
+          return base.reject { |k, v| target[k] }
+        else 
+          return base
+        end
+      end
+
       # Sleep for a specified number of seconds, displaying a progress bar
       # @param seconds [Integer] The number of seconds to sleep
-      def self.timeout(total)
+      def wait(seconds = @timeout)
         sleep_time = 0
-        while sleep_time < total
-          percent_complete = (sleep_time.to_f / total.to_f) * 100.0
+        while sleep_time < seconds
+          percent_complete = (sleep_time.to_f / seconds.to_f) * 100.0
           progress_bar_width = 20
           completed_width = (progress_bar_width * percent_complete / 100.0).round
           remaining_width = progress_bar_width - completed_width
-          print "\rTimeout ["
+          print "\rTimeout [" 
+          print Colorizer::code(:green)
           print "=" * completed_width
           print " " * remaining_width
-          print "] %.2f%%" % percent_complete
+          print Colorizer::code(:reset)
+          print "]"
+          print " %.2f%%" % percent_complete
           $stdout.flush
           sleep(1)
           sleep_time += 1
@@ -45,5 +168,28 @@ module Fastlane
         $stdout.flush
       end
     end
+
+    # Helper class for bash colors
+    class Colorizer
+      COLORS = {
+        black:   30,
+        red:     31,
+        green:   32,
+        yellow:  33,
+        blue:    34,
+        magenta: 35,
+        cyan:    36,
+        white:   37,
+        reset:   0,
+      }
+    
+      def self.colorize(text, color)
+        color_code = COLORS[color.to_sym]
+        "\e[#{color_code}m#{text}\e[0m"
+      end
+      def self.code(color)
+        "\e[#{COLORS[color.to_sym]}m"
+      end
+    end
   end
 end

data/lib/fastlane/plugin/translate_gpt/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module TranslateGpt
-    VERSION = "0.1.3"
+    VERSION = "0.1.4"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-translate_gpt
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Aleksei Cherepanov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-20 00:00:00.000000000 Z
+date: 2023-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-openai