fastlane-plugin-translate_gpt 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8389bf90c62946cf66e3abb95d1fc9422a622146488f56c83985270a692c91f3
-  data.tar.gz: 9980483ba5032745071ad8f04ec9227c10385626cc678d5655b861294b2e2520
+  metadata.gz: c370098458b2bc0d453de5101fa0a1f3273947cd41bc953bb94cf74f5ad58d6f
+  data.tar.gz: 96cccf7814b8796119d08340cca72089dea6c48a177df111b52bb2b1196ee756
 SHA512:
-  metadata.gz: 4da07c2656000de7cbfa28333fbf2c7949d9211166a89624a928f734cdfe4a2ece7ecacdd3aedc265cff9241a9998b2b722906b5bbeda43ff50e54a772620c83
-  data.tar.gz: a91b4055259f18d927cb0d1a2ec29ccf39e7385b646821018f462bea16afba69f03450ecb2b54c118a011c90b2a64bf4caefc41243c5188e2455dd8cf394c84b
+  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

@@ -9,8 +9,13 @@ module Fastlane
       def self.run(params)
         helper = Helper::TranslateGptHelper.new(params)
         helper.prepare_hashes()
-        helper.log_input()
-        helper.translate_strings()
+        bunch_size = params[:bunch_size] 
+        helper.log_input(bunch_size)
+        if bunch_size.nil? || bunch_size < 1
+          helper.translate_strings()
+        else 
+          helper.translate_bunch_of_strings(bunch_size)
+        end
         helper.write_output()
       end
 
@@ -97,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,5 +1,6 @@
 require 'fastlane_core/ui/ui'
 require 'loco_strings'
+require 'json'
 
 module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
@@ -23,13 +24,17 @@ module Fastlane
       end
 
       # Log information about the input strings
-      def log_input() 
+      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 @translation_count > 0 
+        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
 
@@ -58,6 +63,32 @@ module Fastlane
         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. " + \
@@ -75,6 +106,32 @@ module Fastlane
         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(
@@ -104,6 +161,48 @@ module Fastlane
         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)  

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

@@ -1,5 +1,5 @@
 module Fastlane
   module TranslateGpt
-    VERSION = "0.1.4"
+    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.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Aleksei Cherepanov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-29 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: