gpt-function 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f08f33db34e0ff129539ed7a41b244d2866be076f5fc562ed327ff880a852014
-  data.tar.gz: 2a9913da1af1d6ab5ea10602aa5c073c113b6d45d6cdd761eedb4399b32615fc
+  metadata.gz: cdeb301d12f6247b694accec4654d4d65bab0ca071cb4bf7ae73631bf540bc56
+  data.tar.gz: dd5cb067931ac6411a545641b96f40ef81d929bd1d388cfe93808d5c76b6e2ec
 SHA512:
-  metadata.gz: 79b7276238753eb6613c7896a796b1501dd6b3059af1e9d1b8d4c0f01cc42a4fe64210833f5f088846aa2b098d1f516c906b62056e0ff739d6cea2f87874e7a3
-  data.tar.gz: 6590b337edb6edc2215ad3a6192363dfe852c0735c3af75c4fd0662c7ab2219221a7e49be88037968d858c2d55ba5f72a37b259e63b00a703df7498320c77f91
+  metadata.gz: 665474c59064f7ae3401b0fea4e8ca562cfa2e91ff285523bbcdff9b367480f2d137b619b15d30c396df92a07c506bd73ed121bd8c54292d301785957486aa37
+  data.tar.gz: f1072362a33e579c4f52eda7b8abbadc3970807eaca91c5aa39010ca130c3e935a9ee5194b207a8c4de8b11c2079a68bbc3675d63ddeb74d811f9c2de7c33aac

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gpt-function (0.1.2)
+    gpt-function (0.4.0)
 
 GEM
   remote: https://rubygems.org/
@@ -13,6 +13,7 @@ GEM
     crack (0.4.5)
       rexml
     diff-lcs (1.5.0)
+    dotenv (3.1.2)
     hashdiff (1.0.1)
     json (2.6.3)
     language_server-protocol (3.17.0.3)
@@ -64,6 +65,7 @@ PLATFORMS
 
 DEPENDENCIES
   byebug (~> 11.1)
+  dotenv
   gpt-function!
   rake (~> 13.0)
   rspec (~> 3.0)

data/README.md

@@ -2,7 +2,7 @@
 
 這個套件支援你在 Ruby 程式中使用 GPT 函數。
 
-你可以確保每次呼叫 GPT 函數時，都會得到相同的結果。
+你可以確保每次呼叫 GPT 函數時，接近 100% 都會得到相同的結果。
 
 目前能夠使用的模型有：
 
@@ -12,7 +12,13 @@
 
 ## Installation
 
-...
+在你的 Gemfile 中加入下面這行：
+
+```ruby
+gem 'gpt-function'
+```
+
+就可以使用 `bundle install` 安裝這個套件。
 
 ## Usage
 
@@ -21,29 +27,92 @@
 require 'gpt-function'
 
 # 你需要設定你的 api key 和 model name
-Gpt::Function.configure(api_key: '...', model: 'gpt-3.5-turbo-1106')
-
-# 創建一個簡單的 GPT 函數，你需要描述這個函數的功能，以及提供一些範例
-translater = Gpt::Function.new("請翻譯成繁體中文", [["apple", "蘋果"]])
+GptFunction.configure(api_key: '...', model: 'gpt-4o-mini', batch_storage: MyBatchStorage)
 
-# 然後就可以使用這個函數了
-result = translater.call("apple")
+# 使用內建的翻譯方法
+p GptFunctions.翻譯成中文.call("banana") # "香蕉"
 
-# 回傳的結果型別會參考範例的型別
-puts result # "蘋果"
+# 使用內建的擷取關鍵字方法
+p GptFunctions.擷取關鍵字.call("臺北市政府推動綠色交通計劃，鼓勵民眾使用公共運輸和自行車")  # ["臺北市政府", "綠色交通計劃", "民眾", "公共運輸", "自行車"]
 
-# 一個較複雜的 GPT 函數，用於擷取關鍵字
-keywords_extractor = Gpt::Function.new("請擷取出所有關鍵字", [
+# 你也可以自己定義方法
+def 擷取關鍵字
+  # 創建一個簡單的 GPT 函數，你需要描述這個函數的功能，以及提供一些範例
+  GptFunction.new("Extract all keywords",
+  [
     [
-      "藍白合「難產」！游盈隆認定「平手」 稱解套辦法就是「再做一次民調」",
-      ["藍白合", "難產", "游盈隆", "解套", "民調"]
+      "臺灣最新5G網路覆蓋率達95%，推動智慧城市發展，領先亞洲多國",
+      ["臺灣", "5G網路", "覆蓋率", "智慧城市", "亞洲"]
     ]
-  ]
-)
-result = keywords_extractor.call("藍白「3％各表」翻臉倒數？學者曝1關鍵指標")
+  ])
+end
+```
+
+Batch Storage 是一個用來儲存 GPT 函數的結果的類別，你可以自己定義一個類似的類別，並且在 `GptFunction.configure` 中設定。
+
+```ruby
+class MyBatchStorage
+  def initialize
+    @queue = []
+  end
+
+  def enqueue(value)
+    @queue << value
+    true
+  end
+
+  def dequeue
+    @queue.shift
+  end
+end
+
+GptFunction.configure(api_key: '...', model: 'gpt-4o-mini', batch_storage: MyBatchStorage)
+```
+
+你可以用 Batch.create 建立一個新的 Batch, 在 create 成功時，會自動將 Batch 存入 BatchStorage 中。
+
+```ruby
+request1 = GptFunctions.翻譯成中文.to_request_body("apple")
+request2 = GptFunctions.翻譯成中文.to_request_body("tesla")
+batch = GptFunction::Batch.create([request1, request2])
+```
+
+你可以用 Batch.process 來處理 Batch，如果 Batch 的 status 在 "failed", "completed", "expired", "cancelled" 當中，Batch 會被從 queue 中移除，如果是其他狀態，Batch 會自動重新加入 queue 中，你只需要定期持續呼叫 process 就可以。
+
+```ruby
+GptFunction::Batch.process do |batch|
+  puts "batch id: #{batch.id}, status: #{batch.status}, progress: #{batch.request_counts_completed}/#{batch.request_counts_total}"
+  batch.pairs.each do |input, output|
+    puts "input: #{input}, output: #{output}"
+  end
+end
+```
 
-# 可以看到回傳的型別是陣列
-puts result # ["藍白", "3％各表", "翻臉", "關鍵指標"]
+可以用 count 參數來限制每次處理的數量，預設值為 1。
+
+```ruby
+GptFunction::Batch.process(count: 2) do |batch|
+  ...
+end
+```
+
+Batch Storage 整合 Active Record 的範例：
+
+```ruby
+class Model < ApplicationRecord
+  class << self
+    def enqueue(hash)
+      create!(hash)
+      true
+    end
+
+    def dequeue
+      first&.destroy
+    end
+  end
+end
+
+GptFunction.configure(api_key: '...', model: 'gpt-4o-mini', batch_storage: Model)
 ```
 
 ## License

data/gpt-function.gemspec

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "lib/gpt/function/version"
+require_relative "lib/gpt_function/version"
 
 Gem::Specification.new do |spec|
   spec.name = "gpt-function"
-  spec.version = Gpt::Function::VERSION
+  spec.version = GptFunction::VERSION
   spec.authors = ["etrex kuo"]
   spec.email = ["et284vu065k3@gmail.com"]
 
@@ -32,6 +32,8 @@ Gem::Specification.new do |spec|
   # Uncomment to register a new dependency of your gem
   # spec.add_dependency "example-gem", "~> 1.0"
 
+  spec.add_development_dependency "dotenv"
+
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html
 end

data/lib/gpt-function.rb

@@ -1,4 +1,125 @@
 # frozen_string_literal: true
 
-require_relative "gpt/function"
-require_relative "gpt/functions"
+require "net/http"
+require "json"
+
+require_relative "gpt_function/version"
+require_relative "gpt_function/file"
+require_relative "gpt_function/storage"
+require_relative "gpt_function/simple_queue"
+require_relative "gpt_function/batch"
+require_relative "gpt_functions"
+
+class GptFunction
+  class Error < StandardError; end
+
+  @api_key = nil
+  @model = nil
+
+  class << self
+    attr_accessor :api_key, :model
+
+    def configure(api_key:, model:, batch_storage: GptFunction::SimpleQueue.new)
+      @api_key = api_key
+      @model = model
+      GptFunction::Storage.batch_storage = batch_storage
+    end
+  end
+
+  def initialize(prompt, examples = [], temperature = 0)
+    @temperature = temperature
+    @messages = [
+      {
+        role: "system",
+        content: "#{prompt}\n Note: The response format is always a JSON with the key output like this:{output: ...}"
+      },
+      *examples.flat_map do |example|
+        [
+          {
+            role: "user",
+            content: example[0]
+          },
+          {
+            role: "assistant",
+            content: { output: example[1] }.to_json
+          }
+        ]
+      end
+    ]
+  end
+
+  def call(input)
+    # 使用類別級別的變量來發送請求
+    response = send_request(input)
+    body = response.body.force_encoding("UTF-8")
+    json = JSON.parse(body)
+    # 處理可能的錯誤回應
+    raise StandardError, json.dig("error", "message") if json.dig("error", "code")
+
+    # 處理正常的回應
+    JSON.parse(json.dig("choices", 0, "message", "content"))["output"]
+  end
+
+  def to_request_body(input)
+    {
+      model: GptFunction.model,
+      response_format: {
+        type: "json_object"
+      },
+      seed: 42,
+      messages: [
+        *@messages,
+        {
+          "role": "user",
+          "content": input
+        }
+      ],
+      temperature: @temperature
+    }
+  end
+
+  def batch(inputs, post_processor_class)
+    file_content = inputs.map.with_index do |input, index|
+      {
+        "custom_id": "request-#{index + 1}",
+        "method": "POST",
+        "url": "/v1/chat/completions",
+        "body": to_request_body(input)
+      }
+    end
+
+    batch_instance = Batch.new(GptFunction.api_key)
+    batch_id = batch_instance.request(file_content)
+    puts "Batch created with ID: #{batch_id}"
+
+    # 創建 BatchRequest 並啟動 ProcessBatchJob
+    batch_request = BatchRequest.create(
+      batch_id: batch_id,
+      status: 'created',
+      total_request_counts: inputs.size,
+      completed_request_counts: 0,
+      post_processor_class: post_processor_class.to_s
+    )
+    ProcessBatchJob.perform_later(batch_request.id)
+  end
+
+  private
+
+  def send_request(input)
+    uri = URI.parse("https://api.openai.com/v1/chat/completions")
+    request = Net::HTTP::Post.new(uri)
+    request.content_type = "application/json"
+    request["Authorization"] = "Bearer #{GptFunction.api_key}"
+    request.body = to_request_body(input).to_json
+
+    req_options = {
+      use_ssl: uri.scheme == "https",
+      open_timeout: 60, # opening a connection timeout
+      read_timeout: 300 # reading one block of response timeout
+    }
+
+    Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
+      http.request(request)
+    end
+  end
+end

data/lib/gpt_function/batch.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+class GptFunction
+  class Batch
+    attr_reader :id
+    attr_reader :object
+    attr_reader :endpoint
+    attr_reader :errors
+    attr_reader :input_file_id
+    attr_reader :completion_window
+    attr_reader :status
+    attr_reader :output_file_id
+    attr_reader :error_file_id
+    attr_reader :created_at
+    attr_reader :in_progress_at
+    attr_reader :expires_at
+    attr_reader :finalizing_at
+    attr_reader :completed_at
+    attr_reader :failed_at
+    attr_reader :expired_at
+    attr_reader :cancelling_at
+    attr_reader :cancelled_at
+
+    attr_reader :request_counts_total
+    attr_reader :request_counts_completed
+    attr_reader :request_counts_failed
+
+    attr_reader :metadata_customer_id
+    attr_reader :metadata_batch_description
+
+    def initialize(hash)
+      @id = hash["id"]
+      @object = hash["object"]
+      @endpoint = hash["endpoint"]
+      @errors = hash["errors"]
+      @input_file_id = hash["input_file_id"]
+      @completion_window = hash["completion_window"]
+      @status = hash["status"]
+      @output_file_id = hash["output_file_id"]
+      @error_file_id = hash["error_file_id"]
+      @created_at = hash["created_at"]
+      @in_progress_at = hash["in_progress_at"]
+      @expires_at = hash["expires_at"]
+      @finalizing_at = hash["finalizing_at"]
+      @completed_at = hash["completed_at"]
+      @failed_at = hash["failed_at"]
+      @expired_at = hash["expired_at"]
+      @cancelling_at = hash["cancelling_at"]
+      @cancelled_at = hash["cancelled_at"]
+
+      @request_counts_total = hash.dig("request_counts", "total")
+      @request_counts_completed = hash.dig("request_counts", "completed")
+      @request_counts_failed = hash.dig("request_counts", "failed")
+
+      @metadata_customer_id = hash.dig("metadata", "customer_id")
+      @metadata_batch_description = hash.dig("metadata", "batch_description")
+    end
+
+    def to_hash
+      {
+        id: id,
+        object: object,
+        endpoint: endpoint,
+        errors: errors,
+        input_file_id: input_file_id,
+        completion_window: completion_window,
+        status: status,
+        output_file_id: output_file_id,
+        error_file_id: error_file_id,
+        created_at: created_at,
+        in_progress_at: in_progress_at,
+        expires_at: expires_at,
+        finalizing_at: finalizing_at,
+        completed_at: completed_at,
+        failed_at: failed_at,
+        expired_at: expired_at,
+        cancelling_at: cancelling_at,
+        cancelled_at: cancelled_at,
+        request_counts_total: request_counts_total,
+        request_counts_completed: request_counts_completed,
+        request_counts_failed: request_counts_failed,
+        metadata_customer_id: metadata_customer_id,
+        metadata_batch_description: metadata_batch_description,
+      }
+    end
+
+    def to_s
+      to_hash.to_json
+    end
+
+    def inspect
+      to_hash.to_json
+    end
+
+    def input_file
+      return nil if input_file_id.nil?
+      @input_file ||= File.from_id(input_file_id)
+    end
+
+    def output_file
+      return nil if output_file_id.nil?
+      @output_file ||= File.from_id(output_file_id)
+    end
+
+    def input_jsonl
+      @input_jsonl ||= input_file&.jsonl || []
+    end
+
+    def output_jsonl
+      @output_jsonl ||= output_file&.jsonl || []
+    end
+
+    def inputs
+      @inputs ||= input_jsonl.map do |hash|
+        {
+          "custom_id" => hash.dig("custom_id"),
+          "content" => hash.dig("body", "messages", -1, "content")
+        }
+      end
+    end
+
+    def outputs
+      @outputs ||= output_jsonl.map do |hash|
+        content = hash.dig("response", "body", "choices", 0, "message", "content")
+        content = JSON.parse(content)["output"] rescue content
+        {
+          "custom_id" => hash.dig("custom_id"),
+          "content" => content
+        }
+      end
+    end
+
+    def pairs
+      hash = {}
+
+      outputs.each do |output|
+        hash[output["custom_id"]] = [nil ,output["content"]]
+      end
+
+      inputs.each do |input|
+        next if hash[input["custom_id"]].nil?
+        hash[input["custom_id"]][0] = input["content"]
+      end
+
+      hash.values
+    end
+
+    def cancel
+      Batch.cancel(id)
+    end
+
+    def enqueue
+      return false if GptFunction::Storage.batch_storage.nil?
+
+      GptFunction::Storage.batch_storage.enqueue(self.to_hash)
+    end
+
+    # validating	the input file is being validated before the batch can begin
+    # failed	the input file has failed the validation process
+    # in_progress	the input file was successfully validated and the batch is currently being run
+    # finalizing	the batch has completed and the results are being prepared
+    # completed	the batch has been completed and the results are ready
+    # expired	the batch was not able to be completed within the 24-hour time window
+    # cancelling	the batch is being cancelled (may take up to 10 minutes)
+    # cancelled	the batch was cancelled
+    def is_processed
+      ["failed", "completed", "expired", "cancelled"].include? status
+    end
+
+    class << self
+      def list(limit: 20, after: nil)
+        # 創建批次請求
+        uri = URI('https://api.openai.com/v1/batches')
+        request = Net::HTTP::Get.new(uri, 'Content-Type' => 'application/json')
+        request['Authorization'] = "Bearer #{GptFunction.api_key}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "Batch creation failed: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        body_hash = JSON.parse(response.body)
+        body_hash.dig("data").map do |hash|
+          Batch.new(hash)
+        end
+      end
+
+      def create(requests)
+        requests = requests.each_with_index.map do |request, index|
+          {
+            custom_id: "request-#{index + 1}",
+            method: "POST",
+            url: "/v1/chat/completions",
+            body: request,
+          }
+        end
+
+        # 上傳資料
+        file = File.create(requests)
+
+        # 創建批次請求
+        uri = URI('https://api.openai.com/v1/batches')
+        request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
+        request['Authorization'] = "Bearer #{GptFunction.api_key}"
+        request.body = {
+          input_file_id: file.id,
+          endpoint: '/v1/chat/completions',
+          completion_window: '24h'
+        }.to_json
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "Batch creation failed: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        hash = JSON.parse(response.body)
+        batch = Batch.new(hash)
+        batch.enqueue
+        batch
+      rescue => e
+        file&.delete
+        raise e
+      end
+
+      def from_id(batch_id)
+        # 檢查批次狀態
+        uri = URI("https://api.openai.com/v1/batches/#{batch_id}")
+        request = Net::HTTP::Get.new(uri)
+        request['Authorization'] = "Bearer #{GptFunction.api_key}"
+        request['Content-Type'] = 'application/json'
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "Batch status check failed: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        hash = JSON.parse(response.body)
+        Batch.new(hash)
+      end
+
+      def cancel(batch_id)
+        uri = URI("https://api.openai.com/v1/batches/#{batch_id}/cancel")
+        request = Net::HTTP::Post.new(uri)
+        request['Authorization'] = "Bearer #{GptFunction.api_key}"
+        request['Content-Type'] = 'application/json'
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        # {
+        #   "error": {
+        #     "message": "Cannot cancel a batch with status 'completed'.",
+        #     "type": "invalid_request_error",
+        #     "param": null,
+        #     "code": null
+        #   }
+        # }
+        raise "Batch cancel failed: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        response.body
+      end
+
+      def dequeue
+        hash = GptFunction::Storage.batch_storage&.dequeue
+        id = hash&.dig("id") || hash&.dig(:id)
+        from_id(id) if id
+      end
+
+      # 進行批次請求處理
+      # count: 處理批次請求的數量
+      # block: 處理批次請求的 block
+      # 返回值: 是否還有批次請求需要處理
+      def process(count: 1, &block)
+        # 從 Storage 取出 count 個批次請求
+        count.times do
+          batch = dequeue
+
+          # 如果沒有批次請求，則跳出迴圈
+          return false if batch.nil?
+
+          yield batch
+
+          # 如果 batch 還未處理完成，將批次請求重新加入 Storage
+          batch.enqueue unless batch.is_processed
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/gpt_function/file.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+class GptFunction
+  class File
+    attr_reader :object
+    attr_reader :id
+    attr_reader :purpose
+    attr_reader :filename
+    attr_reader :bytes
+    attr_reader :created_at
+    attr_reader :status
+    attr_reader :status_details
+
+    def initialize(hash)
+      @object = hash["object"]
+      @id = hash["id"]
+      @purpose = hash["purpose"]
+      @filename = hash["filename"]
+      @bytes = hash["bytes"]
+      @created_at = hash["created_at"]
+      @status = hash["status"]
+      @status_details = hash["status_details"]
+    end
+
+    def to_hash
+      {
+        object: object,
+        id: id,
+        purpose: purpose,
+        filename: filename,
+        bytes: bytes,
+        created_at: created_at,
+        status: status,
+        status_details: status_details,
+      }
+    end
+
+    def content
+      File.content(id)
+    end
+
+    def jsonl
+      File.jsonl(id)
+    end
+
+    def delete
+      File.delete(id)
+    end
+
+    def to_s
+      to_hash.to_json
+    end
+
+    def inspect
+      to_hash.to_json
+    end
+
+    class << self
+      def list
+        uri = URI("https://api.openai.com/v1/files")
+        request = Net::HTTP::Get.new(uri)
+        request['Authorization'] = "Bearer #{GptFunction.api_key}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "File retrieval failed: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        # example response body
+        # {
+        #   "object": "list",
+        #   "data": [
+        #     {
+        #       "object": "file",
+        #       "id": "file-uYu4HIFAoq0OeZDGBD5Ci8wL",
+        #       "purpose": "batch_output",
+        #       "filename": "batch_YMZbhJWcBYETMTfOfEf041qF_output.jsonl",
+        #       "bytes": 1934,
+        #       "created_at": 1722327874,
+        #       "status": "processed",
+        #       "status_details": null
+        #     },
+        #     {
+        #       "object": "file",
+        #       "id": "file-5AW0tCvRFKomu5s5G90yfWhs",
+        #       "purpose": "batch",
+        #       "filename": "batchinput.jsonl",
+        #       "bytes": 728,
+        #       "created_at": 1722327858,
+        #       "status": "processed",
+        #       "status_details": null
+        #     },
+        #   ]
+        # }
+        body_hash = JSON.parse(response.body)
+        body_hash.dig("data").map do |hash|
+          File.new(hash)
+        end
+      end
+
+      def create(hash_array)
+        # 將請求資料轉換為 JSONL 格式的字串
+        jsonl = hash_array.map(&:to_json).join("\n")
+
+        # 上傳資料
+        uri = URI('https://api.openai.com/v1/files')
+        request = Net::HTTP::Post.new(uri)
+        request['Authorization'] = "Bearer #{GptFunction.api_key}"
+        request['Content-Type'] = 'multipart/form-data'
+
+        # 創建 multipart form data
+        boundary = "CustomBoundary"
+        post_body = []
+        post_body << "--#{boundary}\r\n"
+        post_body << "Content-Disposition: form-data; name=\"purpose\"\r\n\r\n"
+        post_body << "batch\r\n"
+        post_body << "--#{boundary}\r\n"
+        post_body << "Content-Disposition: form-data; name=\"file\"; filename=\"batchinput.jsonl\"\r\n"
+        post_body << "Content-Type: application/json\r\n\r\n"
+        post_body << jsonl
+        post_body << "\r\n--#{boundary}--\r\n"
+
+        request.body = post_body.join
+        request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "File upload failed: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        hash = JSON.parse(response.body)
+        File.new(hash)
+      end
+
+      def from_id(file_id)
+        uri = URI("https://api.openai.com/v1/files/#{file_id}")
+        request = Net::HTTP::Get.new(uri)
+        request['Authorization'] = "Bearer #{GptFunction.api_key}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "File retrieval failed: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        hash = JSON.parse(response.body)
+        File.new(hash)
+      end
+
+      def content(file_id)
+        uri = URI("https://api.openai.com/v1/files/#{file_id}/content")
+        request = Net::HTTP::Get.new(uri)
+        request['Authorization'] = "Bearer #{GptFunction.api_key}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        # {
+        #   "error": {
+        #     "message": "No such File object: #{file_id}",
+        #     "type": "invalid_request_error",
+        #     "param": "id",
+        #     "code": null
+        #   }
+        # }
+        raise "File retrieval failed: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+        response.body
+      end
+
+      def jsonl(file_id)
+        content(file_id).split("\n").map { |line| JSON.parse(line) }
+      end
+
+      def delete(file_id)
+        uri = URI("https://api.openai.com/v1/files/#{file_id}")
+        request = Net::HTTP::Delete.new(uri)
+        request['Authorization'] = "Bearer #{GptFunction.api_key}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+      #   {
+      #    "error": {
+      #      "message": "No such File object: file-5m1Cn4M36GOfd7bEVAoTCmcC",
+      #      "type": "invalid_request_error",
+      #      "param": "id",
+      #      "code": null
+      #    }
+      #  }
+        raise "File deletion failed: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        # {"object"=>"file", "deleted"=>true, "id"=>"file-vsCH6lJkiFzi6gF9B8un3ZLT"}
+        JSON.parse(response.body)
+      end
+    end
+  end
+end

data/lib/gpt_function/simple_queue.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class GptFunction
+  class SimpleQueue
+    def initialize
+      @queue = []
+    end
+
+    def enqueue(value)
+      @queue << value
+      true
+    end
+
+    def dequeue
+      @queue.shift
+    end
+  end
+end

data/lib/gpt_function/storage.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class GptFunction
+  module Storage
+    class << self
+      def batch_storage=(value)
+        # 檢查 value 有實作 enqueue 方法
+        raise "Invalid batch storage: should respond to #enqueue" unless value.respond_to?(:enqueue)
+
+        # 檢查 value 有實作 dequeue 方法
+        raise "Invalid batch storage: should respond to #dequeue" unless value.respond_to?(:dequeue)
+        @batch_storage = value
+      end
+
+      def batch_storage
+        @batch_storage
+      end
+    end
+  end
+end

data/lib/gpt_function/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class GptFunction
+  VERSION = "0.4.0"
+end

data/lib/gpt_functions.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# 這是一個簡單的 GPT 函數類別
+module GptFunctions
+  class << self
+    def 翻譯成中文
+      GptFunction.new("Translate into Taiwanese traditional Chinese", [%w[apple 蘋果]])
+    end
+
+    def 擷取關鍵字
+      GptFunction.new("Extract all keywords",
+        [
+          [
+            "臺灣最新5G網路覆蓋率達95%，推動智慧城市發展，領先亞洲多國",
+            ["臺灣", "5G網路", "覆蓋率", "95%", "智慧城市", "發展", "領先", "亞洲", "多國"]
+          ]
+        ]
+      )
+    end
+
+    def 擷取文章標題
+      document = <<~DOCUMENT
+        今日頭條
+        科技日報｜臺灣科技業最新突破，AI技術大躍進
+        科技日報
+        科技日報
+        2023-11-17
+        102
+        生活新聞｜臺北市最新公共交通計畫公開
+        生活日報
+        生活日報
+        2023-11-16
+        89
+        健康專欄｜最新研究：日常運動對心臟健康的重要性
+        健康雜誌
+        健康雜誌
+        2023-11-15
+        76
+        旅遊特輯｜探索臺灣東部的隱藏美食與景點
+        旅遊週刊
+        旅遊週刊
+        2023-11-14
+        65
+      DOCUMENT
+
+      keywords = [
+        "科技日報｜臺灣科技業最新突破，AI技術大躍進",
+        "生活新聞｜臺北市最新公共交通計畫公開",
+        "健康專欄｜最新研究：日常運動對心臟健康的重要性",
+        "旅遊特輯｜探索臺灣東部的隱藏美食與景點"
+      ]
+
+      GptFunction.new("Extract all titles", [[document, keywords]])
+    end
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: gpt-function
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - etrex kuo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-19 00:00:00.000000000 Z
-dependencies: []
+date: 2024-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: This gem allows users to create simple and complex GPT functions for
   various applications such as translation and keyword extraction.
 email:
@@ -27,9 +41,12 @@ files:
 - Rakefile
 - gpt-function.gemspec
 - lib/gpt-function.rb
-- lib/gpt/function.rb
-- lib/gpt/function/version.rb
-- lib/gpt/functions.rb
+- lib/gpt_function/batch.rb
+- lib/gpt_function/file.rb
+- lib/gpt_function/simple_queue.rb
+- lib/gpt_function/storage.rb
+- lib/gpt_function/version.rb
+- lib/gpt_functions.rb
 - workflows/main.yml
 homepage: https://github.com/etrex/gpt-function
 licenses:
@@ -52,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: A Ruby gem for creating simple GPT-based functions.

data/lib/gpt/function/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Gpt
-  class Function
-    VERSION = "0.2.0"
-  end
-end

data/lib/gpt/function.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "json"
-require_relative "function/version"
-
-module Gpt
-  # 這是一個簡單的 GPT 函數類別
-  class Function
-    @api_key = nil
-    @model = nil
-
-    class << self
-      attr_accessor :api_key, :model
-
-      def configure(api_key:, model:)
-        @api_key = api_key
-        @model = model
-      end
-    end
-
-    def initialize(prompt, examples = [], temperature = 0)
-      @temperature = temperature
-      @messages = [
-        {
-          role: "system",
-          content: "#{prompt}\n Note: The response format is always a JSON with the key output like this:{output: ...}"
-        },
-        *examples.flat_map do |example|
-          [
-            {
-              role: "user",
-              content: example[0]
-            },
-            {
-              role: "assistant",
-              content: { output: example[1] }.to_json
-            }
-          ]
-        end
-      ]
-    end
-
-    def call(input)
-      # 使用類別級別的變量來發送請求
-      response = send_request(input)
-      body = response.body.force_encoding("UTF-8")
-      json = JSON.parse(body)
-      # 處理可能的錯誤回應
-      raise StandardError, json.dig("error", "message") if json.dig("error", "code")
-
-      # 處理正常的回應
-      JSON.parse(json.dig("choices", 0, "message", "content"))["output"]
-    end
-
-    private
-
-    def send_request(input)
-      uri = URI.parse("https://api.openai.com/v1/chat/completions")
-      request = Net::HTTP::Post.new(uri)
-      request.content_type = "application/json"
-      request["Authorization"] = "Bearer #{Function.api_key}"
-      request.body = {
-        model: Function.model,
-        response_format: {
-          type: "json_object"
-        },
-        seed: 0,
-        messages: [
-          *@messages,
-          {
-            "role": "user",
-            "content": input
-          }
-        ],
-        temperature: @temperature
-      }.to_json
-
-      req_options = {
-        use_ssl: uri.scheme == "https",
-        open_timeout: 60, # opening a connection timeout
-        read_timeout: 300 # reading one block of response timeout
-      }
-
-      Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
-        http.request(request)
-      end
-    end
-  end
-end

data/lib/gpt/functions.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Gpt
-  # 這是一個簡單的 GPT 函數類別
-  module Functions
-    class << self
-      def 翻譯成中文(input)
-        Gpt::Function.new("Translate into Taiwanese traditional Chinese", [%w[apple 蘋果]]).call(input)
-      end
-
-      def 擷取關鍵字(input)
-        Gpt::Function.new("Extract all keywords",
-                          [
-                            [
-                              "臺灣最新5G網路覆蓋率達95%，推動智慧城市發展，領先亞洲多國",
-                              %w[臺灣 5G網路 覆蓋率 智慧城市 亞洲]
-                            ]
-                          ]).call(input)
-      end
-
-      def 擷取文章標題(input)
-        document = <<~DOCUMENT
-          今日頭條
-          科技日報｜臺灣科技業最新突破，AI技術大躍進
-          科技日報
-          科技日報
-          2023-11-17
-          102
-          生活新聞｜臺北市最新公共交通計畫公開
-          生活日報
-          生活日報
-          2023-11-16
-          89
-          健康專欄｜最新研究：日常運動對心臟健康的重要性
-          健康雜誌
-          健康雜誌
-          2023-11-15
-          76
-          旅遊特輯｜探索臺灣東部的隱藏美食與景點
-          旅遊週刊
-          旅遊週刊
-          2023-11-14
-          65
-        DOCUMENT
-
-        keywords = [
-          "科技日報｜臺灣科技業最新突破，AI技術大躍進",
-          "生活新聞｜臺北市最新公共交通計畫公開",
-          "健康專欄｜最新研究：日常運動對心臟健康的重要性",
-          "旅遊特輯｜探索臺灣東部的隱藏美食與景點"
-        ]
-
-        Gpt::Function.new("Extract all titles", [[document, keywords]]).call(input)
-      end
-    end
-  end
-end