fastlane-plugin-translate_gpt 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 162ac503b51db5c9395059702dfeedca75cbcd3bb26f68702059f45eb4540ffc
-  data.tar.gz: d73722901b8e2d68c3287187687761930962e4392e7016847bfc9946d57c3748
+  metadata.gz: c370098458b2bc0d453de5101fa0a1f3273947cd41bc953bb94cf74f5ad58d6f
+  data.tar.gz: 96cccf7814b8796119d08340cca72089dea6c48a177df111b52bb2b1196ee756
 SHA512:
-  metadata.gz: b260653373ca72b56e753aad327338559eeb330e64e602f905720b12d8cb6e6c35d0c5750e8be8199169d41cc7549dc19cd4f30a19caf652465ce3a6d10f54b1
-  data.tar.gz: 21df8623e7bce11bf1c3658917dd498bd95929e77236dc32509ca8f3245c8491450cecee1996f2b40147e834aa2a76582facea074dcaa17b8e916a652e964193
+  metadata.gz: 5d07f6a7c6a9351b633781d53ddd40e1a432a62bd270d9df8223d40d33b8ae5034123b430db52498a97c462baf5841f7d828df582a9e3cfd4767d83e064ef7ff
+  data.tar.gz: e5e90093831fa83665f98b302ca433f5e04e5765f74c6a0a0fd5972fcad3dbaf690657e0136acf7ab0f49f253117a5b4deb6ab23b5e209507871b1376d59de2f

data/README.md

@@ -53,6 +53,9 @@ The following options are available for `translate-gpt`:
 | `source_file` | The path to the `Localizable.strings` or `strings.xml` file to be translated. | `GPT_SOURCE_FILE` |
 | `target_file` | The path to the output file for the translated strings. | `GPT_TARGET_FILE` |
 | `context` | Common context for the translation | `GPT_COMMON_CONTEXT` |
+| `bunch_size` | Number of strings to translate in a single request.| `GPT_BUNCH_SIZE` |
+
+**Note:** __I advise using `bunch_size`. It will reduce the number of API requests and translations will be more accurate.__
 
 ## Providing context
 

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

@@ -7,73 +7,16 @@ 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] }
+        helper = Helper::TranslateGptHelper.new(params)
+        helper.prepare_hashes()
+        bunch_size = params[:bunch_size] 
+        helper.log_input(bunch_size)
+        if bunch_size.nil? || bunch_size < 1
+          helper.translate_strings()
         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
+          helper.translate_bunch_of_strings(bunch_size)
         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.write_output()
       end
 
       #####################################################
@@ -159,7 +102,14 @@ module Fastlane
             description: "Common context for the translation",
             optional: true,
             type: String
-          )                     
+          ), 
+          FastlaneCore::ConfigItem.new(
+            key: :bunch_size,
+            env_name: "GPT_BUNCH_SIZE",
+            description: "Number of strings to translate in a single request",
+            optional: true,
+            type: Integer
+          ),                    
         ]
       end
 

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

@@ -1,15 +1,226 @@
 require 'fastlane_core/ui/ui'
 require 'loco_strings'
+require 'json'
 
 module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
 
   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(bunch_size) 
+        @translation_count = @to_translate.size
+        number_of_strings = Colorizer::colorize("#{@translation_count}", :blue)
+        UI.message "Translating #{number_of_strings} strings..."
+        if bunch_size.nil? || bunch_size < 1
+          estimated_string = Colorizer::colorize("#{@translation_count * @params[:request_timeout]}", :white)
+          UI.message "Estimated time: #{estimated_string} seconds"
+        else 
+          number_of_bunches = (@translation_count / bunch_size.to_f).ceil
+          estimated_string = Colorizer::colorize("#{number_of_bunches * @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
+
+      def translate_bunch_of_strings(bunch_size)
+        bunch_index = 0
+        number_of_bunches = (@translation_count / bunch_size.to_f).ceil
+        @to_translate.each_slice(bunch_size) do |bunch|
+          prompt = prepare_bunch_prompt bunch
+          max_retries = 10
+          times_retried = 0
+
+          # translate the source string to the target language
+          begin
+            request_bunch_translate(bunch, prompt, bunch_index, number_of_bunches)
+            bunch_index += 1
+          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 bunch_index < number_of_bunches - 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
+
+      def prepare_bunch_prompt(strings)
+        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."
+        if @params[:context] && !@params[:context].empty?
+          prompt += "This app is #{@params[:context]}. "
+        end
+        prompt += "Translate next text from #{@params[:source_language]} to #{@params[:target_language]}:\n"
+
+        json_hash = []
+        strings.each do |key, string|
+          string_hash = {}
+          context = string.comment
+          if context && !context.empty?
+            string_hash["context"] = context
+          end
+          string_hash["key"] = string.key
+          string_hash["string_to_translate"] = string.value
+          json_hash << string_hash
+        end
+        prompt += "'''\n"
+        prompt += json_hash.to_json
+        prompt += "\n'''"
+        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
+
+      def request_bunch_translate(strings, prompt, index, number_of_bunches)
+        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}/#{number_of_bunches}]", :white)
+        if error
+          UI.error "#{index_log} Error translating: #{error}"
+        else
+          target_string = response.dig("choices", 0, "message", "content")
+          json_string = target_string[/\[[^\[\]]*\]/m]
+          json_hash = JSON.parse(json_string)
+          keys_to_translate = json_hash.map { |string_hash| string_hash["key"] }
+          json_hash.each do |string_hash|
+            key = string_hash["key"]
+            context = string_hash["context"]
+            string_hash.delete("key")
+            string_hash.delete("context")
+            translated_string = string_hash.values.first
+            if key && !key.empty? && translated_string && !translated_string.empty?
+              UI.message "#{index_log} Translating #{key} - #{translated_string}"
+              string = LocoStrings::LocoString.new(key, translated_string, context)
+              @output_hash[key] = string
+              keys_to_translate.delete(key)
+            end
+          end
+
+          if keys_to_translate.length > 0
+            UI.important "#{index_log} Unable to translate #{keys_to_translate.join(", ")}"
+          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 +229,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 +267,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.5"
   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.5
 platform: ruby
 authors:
 - Aleksei Cherepanov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-20 00:00:00.000000000 Z
+date: 2023-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-openai
@@ -193,7 +193,10 @@ files:
 homepage: https://github.com/ftp27/fastlane-plugin-translate_gpt
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/ftp27/fastlane-plugin-translate_gpt
+  source_code_uri: https://github.com/ftp27/fastlane-plugin-translate_gpt
+  github_repo: https://github.com/ftp27/fastlane-plugin-translate_gpt
 post_install_message:
 rdoc_options: []
 require_paths: