fastlane-plugin-translate_gpt 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d78d5a0107d725ae3b713c7e44f1b3aaca9eff005b1d5d2fb7e4ab75dbca40aa
-  data.tar.gz: 3b45a4747d8222ed5d0d9b7d04f178728e679609940e60dff556cbc7b65e1e99
+  metadata.gz: 8389bf90c62946cf66e3abb95d1fc9422a622146488f56c83985270a692c91f3
+  data.tar.gz: 9980483ba5032745071ad8f04ec9227c10385626cc678d5655b861294b2e2520
 SHA512:
-  metadata.gz: e57f34690dea08a9eb24f7d1f975646c9500fccd983d933ff0b3a8809af91ce3b875e75691dfe7845f9aad88fcaeace425e8ead8dff3e09316c61d03ce5be682
-  data.tar.gz: e6e76c62b2ac4fe8b3b16d756bdd2acf4adb8d5ed35a626b9c0e5be3fb4e94511868e961f5261570af63640dafe714cf0d47fc8cc69f520b8e5b552ce27f67b2
+  metadata.gz: 4da07c2656000de7cbfa28333fbf2c7949d9211166a89624a928f734cdfe4a2ece7ecacdd3aedc265cff9241a9998b2b722906b5bbeda43ff50e54a772620c83
+  data.tar.gz: a91b4055259f18d927cb0d1a2ec29ccf39e7385b646821018f462bea16afba69f03450ecb2b54c118a011c90b2a64bf4caefc41243c5188e2455dd8cf394c84b

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

@@ -7,66 +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 = "Translate the following string from #{params[:source_language]} to #{params[:target_language]}: #{string.value}"
-          context = string.comment
-          if context && !context.empty?
-            prompt += "\n\nAdditional context:\n#{context}"
-          end
-          if params[:context] && !params[:context].empty?
-            prompt += "\n\nCommon context:\n#{params[:context]}"
-          end
-          # 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
 
       #####################################################
@@ -97,6 +42,7 @@ module Fastlane
             key: :request_timeout,
             env_name: "GPT_REQUEST_TIMEOUT",
             description: "Timeout for the request in seconds",
+            type: Integer,
             default_value: 30
           ),
           FastlaneCore::ConfigItem.new(

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.2"
+    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.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Aleksei Cherepanov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-02 00:00:00.000000000 Z
+date: 2023-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-openai
@@ -209,7 +209,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.13
 signing_key:
 specification_version: 4
 summary: This fastlane plugin provides an easy way to use the OpenAI GPT language