translation_api 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d36a40c0d987797c40e7ab34cf32d270a5b26b0b2d9372d62bbbd0ede73ca5e
-  data.tar.gz: d05a8271c9fa12105651eacbbfbfd04253da239c89932cdec9a2e64d7b5d7895
+  metadata.gz: fd0bf92d0abd7ee5ece885abaf35110441d86e35c5b7c56126928781aafe4ca3
+  data.tar.gz: 394ffe1c9ad32ca3e7806e1ae6e14236fe17b3dcb021dc628141b6851590ebe4
 SHA512:
-  metadata.gz: bcc16101336a524fd635c23f4028202a2f4fed6215936df5787da62ea07a902298b4cc63eb41f3351555f41ac72c293ea3498bcbc6f699fbc0605311f4288a69
-  data.tar.gz: 5d13abeeb461a92952f1c34715ae0e0b84dd43d65136584e409520b6021d392a849a5853cced542ab613aca7e6c8d93c8b110ee58d9b82006bbf22f826cc6c3e
+  metadata.gz: eaa97abc650985f580c6de3cdbf8eb872cca14e78d7625875b004c1b7e6ca4a2b9090444086c93c353eea0ec4b2ba695eef4e7b22e0c6ac1fae6c7cbbb5af5c9
+  data.tar.gz: 79e67af130d3d290e01c89392e1abe094b5eab77ca0a71f845d1f2c6590a5b78a70c1873fa246ea6a1b41aaa59a76390b992c4396bf681006c3a011a6872007b

data/CHANGELOG.md

@@ -44,3 +44,11 @@
 ## [1.1.0] - 2025-11-23
 
 - カスタムプロンプトを設定できる機能を追加
+
+## [1.1.1] - 2025-11-23
+
+- configの設定順序を逆に変更
+
+## [1.2.0] - 2025-11-23
+
+- Gemini対応

data/README.md

@@ -6,22 +6,28 @@ Requires api key.
 ## For OpenAI
 
 1. `touch .env`
-2. Add `OPENAI_API_KEY=YOUR_API_KEY`  
-3. Optional: `ENV["OPENAI_MODEL"]`
+2. Add `OPENAI_API_KEY=YOUR_API_KEY` or `GEMINI_API_KEY=YOUR_API_KEY` or `DEEPL_API_KEY=YOUR_API_KEY` to `.env`
+3. Optional: `ENV["OPENAI_MODEL"]` or `ENV["GEMINI_MODEL"]`
 4. `TranslationAPI.translate("text")`
 
 ### Configuration Options
 
-* output_logs (default: true)  
 * language (default: "japanese")  
 * provider (default: :openai)  
+* output_logs (default: true)  
 * except_words (default: [])  
+* custom_prompt (default: nil)
+  * Only for OpenAI and Gemini
+* deepl_pro (default: false)
+  * Only for DeepL
 
-### Output
+### Output(Only for OpenAI and Gemini)
 
 * Translated_text
 * Used Tokens
-* Cost Spent(https://openai.com/api/pricing/)
+* Cost Spent
+  * https://openai.com/api/pricing/
+  * https://ai.google.dev/gemini-api/docs/pricing/
 
 ## Example
 
@@ -29,10 +35,11 @@ Exec `ruby example.rb "text"`
 
 ```ruby
 TranslationAPI.configure do |config|
-  config.language     = "english"
-  config.provider     = :deepl
-  config.output_logs  = false
-  config.except_words = %w[hoge fuga]
+  config.language      = "english"
+  config.provider      = :gemini
+  config.output_logs   = false
+  config.except_words  = %w[hoge fuga]
+  config.custom_prompt = "Please Samurai style."
 end
 
 TranslationAPI.translate("text")

data/example.rb

@@ -16,5 +16,10 @@ TranslationAPI.configure do |config|
   config.custom_prompt = "Please Samurai style."
 end
 
-translated_text = TranslationAPI.translate(text)
-p translated_text
+begin
+  translated_text = TranslationAPI.translate(text)
+  p translated_text
+rescue StandardError => e
+  puts e
+  puts e.backtrace
+end

data/lib/translation_api/llm/log.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+class TranslationAPI
+  module Llm
+    class Log
+      def initialize(provider:, response:, cost:)
+        @provider = provider
+        @response = response
+        @cost     = cost
+      end
+
+      def write
+        write_translated_text
+        write_used_tokens
+        write_total_cost
+      end
+
+      private
+
+      def write_translated_text
+        log_file_path = text_path("translated_text.txt")
+
+        File.open(log_file_path, "a") do |file|
+          file.puts(@response.translated_text)
+        end
+      end
+
+      def write_used_tokens
+        log_file_path = text_path("tokens.txt")
+
+        existing_input_tokens, existing_output_tokens = read_existing_tokens
+        tokens => { input_tokens:, output_tokens: }
+
+        total_input_tokens  = existing_input_tokens + input_tokens
+        total_output_tokens = existing_output_tokens + output_tokens
+
+        File.open(log_file_path, "w") do |file|
+          file.puts("input: #{total_input_tokens}")
+          file.puts("output: #{total_output_tokens}")
+        end
+      end
+
+      def read_existing_tokens
+        log_file_path = text_path("tokens.txt")
+        input_tokens, output_tokens = 0, 0
+
+        if File.exist?(log_file_path)
+          File.readlines(log_file_path).each do |line|
+            tokens = line.split(":").last.strip.to_i
+            input_tokens  = tokens if line.start_with?("input:")
+            output_tokens = tokens if line.start_with?("output:")
+          end
+        end
+
+        [input_tokens, output_tokens]
+      end
+
+      def write_total_cost
+        log_file_path = text_path("cost.txt")
+        tokens => { input_tokens:, output_tokens: }
+
+        this_cost = @cost.input_cost(input_tokens) + @cost.output_cost(output_tokens)
+        total_cost = this_cost + existing_cost
+
+        File.open(log_file_path, "w") do |file|
+          file.puts(format_cost(total_cost))
+        end
+      end
+
+      def format_cost(cost)
+        "$#{format("%.8f", cost)}"
+      end
+
+      def existing_cost
+        log_file_path = text_path("cost.txt")
+
+        File.exist?(log_file_path) ? File.read(log_file_path).gsub("$", "").to_f : 0.0
+      end
+
+      def tokens
+        {
+          input_tokens: @response.dig_used_tokens(type: :input),
+          output_tokens: @response.dig_used_tokens(type: :output)
+        }
+      end
+
+      def text_path(under_logs_path)
+        output_dir = "translator_logs/#{@provider.name}"
+        FileUtils.mkdir_p(output_dir) unless File.directory?(output_dir)
+
+        File.join(output_dir, under_logs_path)
+      end
+    end
+  end
+end

data/lib/translation_api/llm/model.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class TranslationAPI
+  module Llm
+    class Model
+      MODEL_ERROR_MESSAGE =
+        "Specified model is not supported. Please check the model name."
+
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+        validate_model!
+      end
+
+      private
+
+      def validate_model!
+        supported_models =
+          self.class.const_defined?(:SUPPORTED_MODELS) ? self.class::SUPPORTED_MODELS : []
+
+        raise ArgumentError, MODEL_ERROR_MESSAGE unless supported_models.include?(@name)
+      end
+    end
+  end
+end

data/lib/translation_api/llm/prompt.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class TranslationAPI
+  module Llm
+    class Prompt
+      SYSTEM_PROMPT_BASE = <<~TEXT
+        Translate only.
+        Return result only, no extra info
+        Keep symbols
+      TEXT
+
+      def initialize(except_words:, language:, custom_prompt:)
+        @except_words  = except_words
+        @language      = language
+        @custom_prompt = custom_prompt
+      end
+
+      def system_prompt
+        SYSTEM_PROMPT_BASE + except_option_text
+      end
+
+      def user_prompt
+        <<~TEXT
+          #{@custom_prompt || ""}
+          Please translate this text to #{@language}:
+        TEXT
+      end
+
+      private
+
+      def except_option_text
+        return "" if @except_words.empty?
+
+        <<~TEXT
+          Words listed next are not translated: [#{@except_words.join(", ")}]
+        TEXT
+      end
+    end
+  end
+end

data/lib/translation_api/provider/deepl.rb

@@ -43,11 +43,11 @@ class TranslationAPI
       end
 
       def validate_api_key!
-        raise API_KEY_ERROR_MESSAGE unless ENV["DEEPL_API_KEY"] || ENV["DEEPL_AUTH_KEY"]
+        raise ArgumentError, API_KEY_ERROR_MESSAGE unless ENV["DEEPL_API_KEY"] || ENV["DEEPL_AUTH_KEY"]
       end
 
       def validate_supported_language!
-        raise LANGUAGE_UNSUPPORTED_MESSAGE unless supported_language?
+        raise ArgumentError, LANGUAGE_UNSUPPORTED_MESSAGE unless supported_language?
       end
 
       def supported_languages

data/lib/translation_api/provider/gemini/chat.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require_relative "response"
+
+class TranslationAPI
+  module Provider
+    class Gemini
+      class Chat
+        API_KEY_ERROR_MESSAGE = "API key is not found."
+
+        def initialize(model:, prompt:)
+          validate_api_key!
+
+          @model  = model
+          @prompt = prompt
+        end
+
+        def call(text)
+          Response.new(request(text))
+        end
+
+        private
+
+        def request(text)
+          connection.post("/v1beta/models/#{@model.name}:generateContent") do |request|
+            request.body = body(text)
+          end
+        end
+
+        def connection
+          Faraday.new(
+            url: "https://generativelanguage.googleapis.com",
+            headers: {
+              "Content-Type" => "application/json",
+              "x-goog-api-key" => ENV["GEMINI_API_KEY"]
+            }
+          )
+        end
+
+        def body(text)
+          {
+            contents: [
+              {
+                parts: [
+                  {
+                    text: @prompt.system_prompt + @prompt.user_prompt + text
+                  }
+                ]
+              }
+            ]
+          }.to_json
+        end
+
+        def validate_api_key!
+          raise ArgumentError, API_KEY_ERROR_MESSAGE unless ENV["GEMINI_API_KEY"]
+        end
+      end
+    end
+  end
+end

data/lib/translation_api/provider/gemini/cost.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class TranslationAPI
+  module Provider
+    class Gemini
+      class Cost
+        ONE_MILLION = 1_000_000
+
+        def initialize(model)
+          @model = model
+        end
+
+        def input_cost(used_tokens)
+          calculate_cost(used_tokens, :input)
+        end
+
+        def output_cost(used_tokens)
+          calculate_cost(used_tokens, :output)
+        end
+
+        private
+
+        def calculate_cost(used_tokens, type)
+          used_tokens * token_rates[@model.name][type]
+        end
+
+        def token_rates
+          three_pro.merge(two_five_pro).merge(two_five_flash).merge(two_five_flash_lite)
+        end
+
+        def three_pro
+          {
+            @model.class.three_pro => {
+              input: 2.0 / ONE_MILLION,
+              output: (2.0 * pro_cost_diff_ratio) / ONE_MILLION
+            }
+          }
+        end
+
+        def two_five_pro
+          {
+            @model.class.two_five_pro => {
+              input: 1.25 / ONE_MILLION,
+              output: (1.25 * pro_cost_diff_ratio) / ONE_MILLION
+            }
+          }
+        end
+
+        def two_five_flash
+          {
+            @model.class.two_five_flash => {
+              input: 0.3 / ONE_MILLION,
+              output: 2.5 / ONE_MILLION
+            }
+          }
+        end
+
+        def two_five_flash_lite
+          {
+            @model.class.two_five_flash_lite => {
+              input: 0.1 / ONE_MILLION,
+              output: 0.4 / ONE_MILLION
+            }
+          }
+        end
+
+        def pro_cost_diff_ratio
+          2.0
+        end
+      end
+    end
+  end
+end

data/lib/translation_api/provider/gemini/model.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../../llm/model"
+
+class TranslationAPI
+  module Provider
+    class Gemini
+      class Model < Llm::Model
+        SUPPORTED_MODELS = [
+          "gemini-3-pro-preview",
+          "gemini-2.5-pro",
+          "gemini-2.5-flash",
+          "gemini-2.5-flash-lite"
+        ].freeze
+
+        def self.three_pro
+          SUPPORTED_MODELS[0]
+        end
+
+        def self.two_five_pro
+          SUPPORTED_MODELS[1]
+        end
+
+        def self.two_five_flash
+          SUPPORTED_MODELS[2]
+        end
+
+        def self.two_five_flash_lite
+          SUPPORTED_MODELS[3]
+        end
+      end
+    end
+  end
+end

data/lib/translation_api/provider/gemini/response.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "json"
+
+class TranslationAPI
+  module Provider
+    class Gemini
+      class Response
+        REQUEST_FAILED_MESSAGE = "Request failed with status"
+
+        attr_reader :response
+
+        def initialize(response)
+          @response = response
+        end
+
+        def translated_text
+          failed_message = "#{REQUEST_FAILED_MESSAGE} #{@response.status}"
+          raise ArgumentError, failed_message unless @response.status == 200
+
+          body_json.dig("candidates", 0, "content", "parts", 0, "text")
+        end
+
+        def dig_used_tokens(type:)
+          case type
+          when :input
+            body_json.dig("usageMetadata", "promptTokenCount")
+          when :output
+            body_json.dig("usageMetadata", "candidatesTokenCount")
+          else
+            raise ArgumentError, "Invalid token type: #{type}"
+          end
+        end
+
+        private
+
+        def body_json
+          @body_json ||= JSON.parse(@response.body)
+        end
+      end
+    end
+  end
+end

data/lib/translation_api/provider/gemini.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../llm/prompt"
+require_relative "../llm/log"
+require_relative "gemini/model"
+require_relative "gemini/chat"
+require_relative "gemini/cost"
+
+class TranslationAPI
+  module Provider
+    class Gemini
+      def initialize(output_logs:, except_words:, language:, custom_prompt: nil)
+        @model  = Model.new(ENV["GEMINI_MODEL"] || Model.two_five_flash)
+        @prompt = Llm::Prompt.new(except_words:, language:, custom_prompt:)
+        @chat   = Chat.new(model: @model, prompt: @prompt)
+        @output_logs = output_logs
+      end
+
+      def translate(text)
+        return text if text.strip.empty?
+
+        @response = @chat.call(text)
+        log.write if @output_logs
+
+        @response.translated_text
+      end
+
+      def name
+        "gemini"
+      end
+
+      private
+
+      def log
+        Llm::Log.new(provider: self, response: @response, cost: Cost.new(@model))
+      end
+    end
+  end
+end

data/lib/translation_api/provider/openai/chat.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "openai"
+require_relative "response"
+
+class TranslationAPI
+  module Provider
+    class OpenAI
+      class Chat
+        API_KEY_ERROR_MESSAGE = "API key is not found."
+
+        def initialize(model:, prompt:)
+          validate_api_key!
+
+          @model  = model
+          @prompt = prompt
+          @client = init_client
+        end
+
+        def call(text)
+          Response.new(request(text))
+        end
+
+        private
+
+        def request(text)
+          @client.chat(
+            parameters: {
+              model: @model.name,
+              messages: [
+                { role: "system", content: @prompt.system_prompt },
+                { role: "user", content: @prompt.user_prompt + text }
+              ]
+            }
+          )
+        end
+
+        def init_client
+          ::OpenAI::Client.new(access_token: ENV["OPENAI_API_KEY"])
+        end
+
+        def validate_api_key!
+          raise ArgumentError, API_KEY_ERROR_MESSAGE unless ENV["OPENAI_API_KEY"]
+        end
+      end
+    end
+  end
+end

data/lib/translation_api/provider/openai/cost.rb

@@ -4,12 +4,11 @@ class TranslationAPI
   module Provider
     class OpenAI
       class Cost
-        BASE_MODEL_NAME = "gpt-5"
         ONE_MILLION = 1_000_000
         BASE_MODEL_COST = 1.25 / ONE_MILLION
 
-        def initialize(provider)
-          @provider = provider
+        def initialize(model)
+          @model = model
         end
 
         def input_cost(used_tokens)
@@ -23,48 +22,38 @@ class TranslationAPI
         private
 
         def calculate_cost(used_tokens, type)
-          used_tokens * token_rates[@provider.using_model][type]
+          used_tokens * token_rates[@model.name][type]
         end
 
         def token_rates
-          normal_models = base_model.merge(mini_model).merge(nano_model)
-          normal_models.merge(other_models)
+          base.merge(mini).merge(nano)
         end
 
-        def base_model
+        def base
           {
-            BASE_MODEL_NAME => {
+            @model.class.base => {
               input: BASE_MODEL_COST,
               output: BASE_MODEL_COST * normal_io_ratio[:output]
             }
           }
         end
 
-        def mini_model
+        def mini
           {
-            "#{BASE_MODEL_NAME}-mini" => {
+            @model.class.mini => {
               input: BASE_MODEL_COST / normal_cost_diff_ratio,
               output: (BASE_MODEL_COST * normal_io_ratio[:output]) / normal_cost_diff_ratio
             }
           }
         end
 
-        def nano_model
-          mini_model_cost = mini_model.values[0][:input]
+        def nano
+          mini_cost = mini.values[0][:input]
 
           {
-            "#{BASE_MODEL_NAME}-nano" => {
-              input: mini_model_cost / normal_cost_diff_ratio,
-              output: (mini_model_cost * normal_io_ratio[:output]) / normal_cost_diff_ratio
-            }
-          }
-        end
-
-        def other_models
-          {
-            "#{BASE_MODEL_NAME}-chat-latest" => {
-              input: 1.25 / ONE_MILLION,
-              output: (1.25 * normal_io_ratio[:output]) / ONE_MILLION
+            @model.class.nano => {
+              input: mini_cost / normal_cost_diff_ratio,
+              output: (mini_cost * normal_io_ratio[:output]) / normal_cost_diff_ratio
             }
           }
         end

data/lib/translation_api/provider/openai/model.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../../llm/model"
+
+class TranslationAPI
+  module Provider
+    class OpenAI
+      class Model < Llm::Model
+        SUPPORTED_MODELS = [
+          "gpt-5",
+          "gpt-5-mini",
+          "gpt-5-nano"
+        ].freeze
+
+        def self.base
+          SUPPORTED_MODELS[0]
+        end
+
+        def self.mini
+          SUPPORTED_MODELS[1]
+        end
+
+        def self.nano
+          SUPPORTED_MODELS[2]
+        end
+      end
+    end
+  end
+end

data/lib/translation_api/provider/openai/response.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class TranslationAPI
+  module Provider
+    class OpenAI
+      class Response
+        def initialize(response)
+          @response = response
+        end
+
+        def translated_text
+          @response.dig("choices", 0, "message", "content")
+        end
+
+        def dig_used_tokens(type:)
+          case type
+          when :input
+            @response.dig("usage", "prompt_tokens")
+          when :output
+            @response.dig("usage", "completion_tokens")
+          else
+            raise ArgumentError, "Invalid token type: #{type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/translation_api/provider/openai.rb

@@ -1,97 +1,38 @@
 # frozen_string_literal: true
 
-require "openai"
-require_relative "openai/log"
+require_relative "../llm/prompt"
+require_relative "../llm/log"
+require_relative "openai/model"
+require_relative "openai/chat"
+require_relative "openai/cost"
 
 class TranslationAPI
   module Provider
     class OpenAI
-      SYSTEM_PROMPT_BASE = <<~TEXT
-        Translate only.
-        Return result only, no extra info
-        Keep symbols
-      TEXT
-
-      API_KEY_ERROR_MESSAGE = "API key is not found."
-
-      MODEL_ERROR_MESSAGE =
-        "Specified model is not supported. Please check the model name."
-
       def initialize(output_logs:, except_words:, language:, custom_prompt: nil)
-        validate_api_key!
-
-        @client = init_client
-        @output_logs   = output_logs
-        @system_prompt = SYSTEM_PROMPT_BASE + except_option_text(except_words)
-        @user_prompt   = user_prompt_text(language, custom_prompt)
+        @model  = Model.new(ENV["OPENAI_MODEL"] || Model.nano)
+        @prompt = Llm::Prompt.new(except_words:, language:, custom_prompt:)
+        @chat   = Chat.new(model: @model, prompt: @prompt)
+        @output_logs = output_logs
       end
 
       def translate(text)
         return text if text.strip.empty?
 
-        @response = chat_to_api(text)
-        Log.new(self).write if @output_logs
+        @response = @chat.call(text)
+        log.write if @output_logs
 
-        translated_text
+        @response.translated_text
       end
 
-      def translated_text
-        @response["choices"][0]["message"]["content"]
-      end
-
-      def using_model
-        ENV["OPENAI_MODEL"] || "gpt-5-mini"
-      end
-
-      def dig_used_tokens(type:)
-        case type
-        when :input
-          @response["usage"]["prompt_tokens"]
-        when :output
-          @response["usage"]["completion_tokens"]
-        else
-          raise ArgumentError, "Invalid token type: #{type}"
-        end
+      def name
+        "openai"
       end
 
       private
 
-      def validate_api_key!
-        raise API_KEY_ERROR_MESSAGE unless ENV["OPENAI_API_KEY"]
-      end
-
-      def init_client
-        ::OpenAI::Client.new(
-          access_token: ENV["OPENAI_API_KEY"],
-          log_errors: true
-        )
-      end
-
-      def chat_to_api(text)
-        @client.chat(
-          parameters: {
-            model: using_model,
-            messages: [
-              { role: "system", content: @system_prompt },
-              { role: "user", content: @user_prompt + text }
-            ]
-          }
-        )
-      end
-
-      def except_option_text(except_words)
-        return "" if except_words.empty?
-
-        <<~TEXT
-          Words listed next are not translated: [#{except_words.join(", ")}]
-        TEXT
-      end
-
-      def user_prompt_text(language, custom_prompt)
-        <<~TEXT
-          #{custom_prompt || ""}
-          Please translate this text to #{language}:
-        TEXT
+      def log
+        Llm::Log.new(provider: self, response: @response, cost: Cost.new(@model))
       end
     end
   end

data/lib/translation_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class TranslationAPI
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/translation_api.rb

@@ -4,6 +4,7 @@ require "dotenv"
 require_relative "translation_api/version"
 require_relative "translation_api/config"
 require_relative "translation_api/provider/openai"
+require_relative "translation_api/provider/gemini"
 require_relative "translation_api/provider/deepl"
 
 class TranslationAPI
@@ -24,8 +25,8 @@ class TranslationAPI
   end
 
   def initialize(**options)
-    use_provided_options(options)
     use_default_options
+    use_provided_options(options)
 
     @provider = init_provider(@provider)
   end
@@ -62,6 +63,13 @@ class TranslationAPI
         language: @language,
         custom_prompt: @custom_prompt
       )
+    when :gemini
+      Provider::Gemini.new(
+        output_logs: @output_logs,
+        except_words: @except_words,
+        language: @language,
+        custom_prompt: @custom_prompt
+      )
     when :deepl
       Provider::DeepL.new(
         pro: config.deepl_pro,
@@ -69,7 +77,7 @@ class TranslationAPI
         language: @language
       )
     else
-      raise UNSUPPORTED_PROVIDER_MESSAGE
+      raise ArgumentError, UNSUPPORTED_PROVIDER_MESSAGE
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: translation_api
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - milkeclair
@@ -37,6 +37,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ruby-openai
   requirement: !ruby/object:Gem::Requirement
@@ -68,10 +82,20 @@ files:
 - how_to_publish.txt
 - lib/translation_api.rb
 - lib/translation_api/config.rb
+- lib/translation_api/llm/log.rb
+- lib/translation_api/llm/model.rb
+- lib/translation_api/llm/prompt.rb
 - lib/translation_api/provider/deepl.rb
+- lib/translation_api/provider/gemini.rb
+- lib/translation_api/provider/gemini/chat.rb
+- lib/translation_api/provider/gemini/cost.rb
+- lib/translation_api/provider/gemini/model.rb
+- lib/translation_api/provider/gemini/response.rb
 - lib/translation_api/provider/openai.rb
+- lib/translation_api/provider/openai/chat.rb
 - lib/translation_api/provider/openai/cost.rb
-- lib/translation_api/provider/openai/log.rb
+- lib/translation_api/provider/openai/model.rb
+- lib/translation_api/provider/openai/response.rb
 - lib/translation_api/version.rb
 - rake_helper.rb
 homepage: https://github.com/milkeclair/translation_api

data/lib/translation_api/provider/openai/log.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require_relative "cost"
-
-class TranslationAPI
-  module Provider
-    class OpenAI
-      class Log
-        def initialize(provider)
-          @provider = provider
-          @cost = Cost.new(@provider)
-        end
-
-        def write
-          write_translated_text
-          write_used_tokens
-          write_total_cost
-        end
-
-        private
-
-        def write_translated_text
-          log_file_path = text_path("translated_text.txt")
-
-          File.open(log_file_path, "a") do |file|
-            file.puts(@provider.translated_text)
-          end
-        end
-
-        def write_used_tokens
-          log_file_path = text_path("tokens.txt")
-
-          existing_input_tokens, existing_output_tokens = read_existing_tokens
-          tokens => { input_tokens:, output_tokens: }
-
-          total_input_tokens  = existing_input_tokens + input_tokens
-          total_output_tokens = existing_output_tokens + output_tokens
-
-          File.open(log_file_path, "w") do |file|
-            file.puts("input: #{total_input_tokens}")
-            file.puts("output: #{total_output_tokens}")
-          end
-        end
-
-        def read_existing_tokens
-          log_file_path = text_path("tokens.txt")
-          input_tokens, output_tokens = 0, 0
-
-          if File.exist?(log_file_path)
-            File.readlines(log_file_path).each do |line|
-              tokens = line.split(":").last.strip.to_i
-              input_tokens  = tokens if line.start_with?("input:")
-              output_tokens = tokens if line.start_with?("output:")
-            end
-          end
-
-          [input_tokens, output_tokens]
-        end
-
-        def write_total_cost
-          log_file_path = text_path("cost.txt")
-          tokens => { input_tokens:, output_tokens: }
-
-          this_cost = @cost.input_cost(input_tokens) + @cost.output_cost(output_tokens)
-          total_cost = this_cost + existing_cost
-
-          File.open(log_file_path, "w") do |file|
-            file.puts(format_cost(total_cost))
-          end
-        end
-
-        def format_cost(cost)
-          "$#{format("%.8f", cost)}"
-        end
-
-        def existing_cost
-          log_file_path = text_path("cost.txt")
-
-          File.exist?(log_file_path) ? File.read(log_file_path).gsub("$", "").to_f : 0.0
-        end
-
-        def tokens
-          {
-            input_tokens: @provider.dig_used_tokens(type: :input),
-            output_tokens: @provider.dig_used_tokens(type: :output)
-          }
-        end
-
-        def text_path(under_logs_path)
-          output_dir = "translator_logs/openai"
-          FileUtils.mkdir_p(output_dir) unless File.directory?(output_dir)
-
-          File.join(output_dir, under_logs_path)
-        end
-      end
-    end
-  end
-end