ruby-openai-transitory-v2 6.5.0

data/Rakefile

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default do
+  Rake::Task["test"].invoke
+  Rake::Task["lint"].invoke
+end
+
+task :test do
+  Rake::Task["spec"].invoke
+end
+
+task :lint do
+  RuboCop::RakeTask.new(:rubocop)
+  Rake::Task["rubocop"].invoke
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "openai"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/openai/assistants.rb

@@ -0,0 +1,27 @@
+module OpenAI
+  class Assistants
+    def initialize(client:)
+      @client = client.beta(assistants: "v1")
+    end
+
+    def list
+      @client.get(path: "/assistants")
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/assistants/#{id}")
+    end
+
+    def create(parameters: {})
+      @client.json_post(path: "/assistants", parameters: parameters)
+    end
+
+    def modify(id:, parameters: {})
+      @client.json_post(path: "/assistants/#{id}", parameters: parameters)
+    end
+
+    def delete(id:)
+      @client.delete(path: "/assistants/#{id}")
+    end
+  end
+end

data/lib/openai/audio.rb

@@ -0,0 +1,19 @@
+module OpenAI
+  class Audio
+    def initialize(client:)
+      @client = client
+    end
+
+    def transcribe(parameters: {})
+      @client.multipart_post(path: "/audio/transcriptions", parameters: parameters)
+    end
+
+    def translate(parameters: {})
+      @client.multipart_post(path: "/audio/translations", parameters: parameters)
+    end
+
+    def speech(parameters: {})
+      @client.json_post(path: "/audio/speech", parameters: parameters)
+    end
+  end
+end

data/lib/openai/client.rb

@@ -0,0 +1,95 @@
+module OpenAI
+  class Client
+    include OpenAI::HTTP
+
+    CONFIG_KEYS = %i[
+      api_type
+      api_version
+      access_token
+      organization_id
+      uri_base
+      request_timeout
+      extra_headers
+    ].freeze
+    attr_reader *CONFIG_KEYS, :faraday_middleware
+
+    def initialize(config = {}, &faraday_middleware)
+      CONFIG_KEYS.each do |key|
+        # Set instance variables like api_type & access_token. Fall back to global config
+        # if not present.
+        instance_variable_set("@#{key}", config[key] || OpenAI.configuration.send(key))
+      end
+      @faraday_middleware = faraday_middleware
+    end
+
+    def chat(parameters: {})
+      json_post(path: "/chat/completions", parameters: parameters)
+    end
+
+    def edits(parameters: {})
+      json_post(path: "/edits", parameters: parameters)
+    end
+
+    def embeddings(parameters: {})
+      json_post(path: "/embeddings", parameters: parameters)
+    end
+
+    def completions(parameters: {})
+      json_post(path: "/completions", parameters: parameters)
+    end
+
+    def audio
+      @audio ||= OpenAI::Audio.new(client: self)
+    end
+
+    def files
+      @files ||= OpenAI::Files.new(client: self)
+    end
+
+    def finetunes
+      @finetunes ||= OpenAI::Finetunes.new(client: self)
+    end
+
+    def images
+      @images ||= OpenAI::Images.new(client: self)
+    end
+
+    def models
+      @models ||= OpenAI::Models.new(client: self)
+    end
+
+    def assistants
+      @assistants ||= OpenAI::Assistants.new(client: self)
+    end
+
+    def threads
+      @threads ||= OpenAI::Threads.new(client: self)
+    end
+
+    def messages
+      @messages ||= OpenAI::Messages.new(client: self)
+    end
+
+    def runs
+      @runs ||= OpenAI::Runs.new(client: self)
+    end
+
+    def run_steps
+      @run_steps ||= OpenAI::RunSteps.new(client: self)
+    end
+
+    def moderations(parameters: {})
+      json_post(path: "/moderations", parameters: parameters)
+    end
+
+    def azure?
+      @api_type&.to_sym == :azure
+    end
+
+    def beta(apis)
+      dup.tap do |client|
+        client.add_headers("OpenAI-Beta": apis.map { |k, v| "#{k}=#{v}" }.join(";"))
+      end
+    end
+  end
+end

data/lib/openai/compatibility.rb

@@ -0,0 +1,10 @@
+module Ruby
+  module OpenAI
+    VERSION = ::OpenAI::VERSION
+
+    Error = ::OpenAI::Error
+    ConfigurationError = ::OpenAI::ConfigurationError
+    Configuration = ::OpenAI::Configuration
+    MiddlewareErrors = ::OpenAI::MiddlewareErrors
+  end
+end

data/lib/openai/files.rb

@@ -0,0 +1,42 @@
+module OpenAI
+  class Files
+    def initialize(client:)
+      @client = client
+    end
+
+    def list
+      @client.get(path: "/files")
+    end
+
+    def upload(parameters: {})
+      validate(file: parameters[:file]) if parameters[:file].include?(".jsonl")
+
+      @client.multipart_post(
+        path: "/files",
+        parameters: parameters.merge(file: File.open(parameters[:file]))
+      )
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/files/#{id}")
+    end
+
+    def content(id:)
+      @client.get(path: "/files/#{id}/content")
+    end
+
+    def delete(id:)
+      @client.delete(path: "/files/#{id}")
+    end
+
+    private
+
+    def validate(file:)
+      File.open(file).each_line.with_index do |line, index|
+        JSON.parse(line)
+      rescue JSON::ParserError => e
+        raise JSON::ParserError, "#{e.message} - found on line #{index + 1} of #{file}"
+      end
+    end
+  end
+end

data/lib/openai/finetunes.rb

@@ -0,0 +1,27 @@
+module OpenAI
+  class Finetunes
+    def initialize(client:)
+      @client = client
+    end
+
+    def list
+      @client.get(path: "/fine_tuning/jobs")
+    end
+
+    def create(parameters: {})
+      @client.json_post(path: "/fine_tuning/jobs", parameters: parameters)
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/fine_tuning/jobs/#{id}")
+    end
+
+    def cancel(id:)
+      @client.json_post(path: "/fine_tuning/jobs/#{id}/cancel", parameters: {})
+    end
+
+    def list_events(id:)
+      @client.get(path: "/fine_tuning/jobs/#{id}/events")
+    end
+  end
+end

data/lib/openai/http.rb

@@ -0,0 +1,127 @@
+require "event_stream_parser"
+
+require_relative "http_headers"
+
+module OpenAI
+  module HTTP
+    include HTTPHeaders
+
+    def get(path:)
+      parse_jsonl(conn.get(uri(path: path)) do |req|
+        req.headers = headers
+      end&.body)
+    end
+
+    def post(path:)
+      parse_jsonl(conn.post(uri(path: path)) do |req|
+        req.headers = headers
+      end&.body)
+    end
+
+    def json_post(path:, parameters:)
+      conn.post(uri(path: path)) do |req|
+        configure_json_post_request(req, parameters)
+      end&.body
+    end
+
+    def multipart_post(path:, parameters: nil)
+      conn(multipart: true).post(uri(path: path)) do |req|
+        req.headers = headers.merge({ "Content-Type" => "multipart/form-data" })
+        req.body = multipart_parameters(parameters)
+      end&.body
+    end
+
+    def delete(path:)
+      conn.delete(uri(path: path)) do |req|
+        req.headers = headers
+      end&.body
+    end
+
+    private
+
+    def parse_jsonl(response)
+      return unless response
+      return response unless response.is_a?(String)
+
+      # Convert a multiline string of JSON objects to a JSON array.
+      response = response.gsub("}\n{", "},{").prepend("[").concat("]")
+
+      JSON.parse(response)
+    end
+
+    # Given a proc, returns an outer proc that can be used to iterate over a JSON stream of chunks.
+    # For each chunk, the inner user_proc is called giving it the JSON object. The JSON object could
+    # be a data object or an error object as described in the OpenAI API documentation.
+    #
+    # @param user_proc [Proc] The inner proc to call for each JSON object in the chunk.
+    # @return [Proc] An outer proc that iterates over a raw stream, converting it to JSON.
+    def to_json_stream(user_proc:)
+      parser = EventStreamParser::Parser.new
+
+      proc do |chunk, _bytes, env|
+        if env && env.status != 200
+          raise_error = Faraday::Response::RaiseError.new
+          raise_error.on_complete(env.merge(body: try_parse_json(chunk)))
+        end
+
+        parser.feed(chunk) do |_type, data|
+          user_proc.call(JSON.parse(data)) unless data == "[DONE]"
+        end
+      end
+    end
+
+    def conn(multipart: false)
+      connection = Faraday.new do |f|
+        f.options[:timeout] = @request_timeout
+        f.request(:multipart) if multipart
+        f.use MiddlewareErrors
+        f.response :raise_error
+        f.response :json
+      end
+
+      @faraday_middleware&.call(connection)
+
+      connection
+    end
+
+    def uri(path:)
+      if azure?
+        base = File.join(@uri_base, path)
+        "#{base}?api-version=#{@api_version}"
+      else
+        File.join(@uri_base, @api_version, path)
+      end
+    end
+
+    def multipart_parameters(parameters)
+      parameters&.transform_values do |value|
+        next value unless value.respond_to?(:close) # File or IO object.
+
+        # Doesn't seem like OpenAI needs mime_type yet, so not worth
+        # the library to figure this out. Hence the empty string
+        # as the second argument.
+        Faraday::UploadIO.new(value, "", value.path)
+      end
+    end
+
+    def configure_json_post_request(req, parameters)
+      req_parameters = parameters.dup
+
+      if parameters[:stream].respond_to?(:call)
+        req.options.on_data = to_json_stream(user_proc: parameters[:stream])
+        req_parameters[:stream] = true # Necessary to tell OpenAI to stream.
+      elsif parameters[:stream]
+        raise ArgumentError, "The stream parameter must be a Proc or have a #call method"
+      end
+
+      req.headers = headers
+      req.body = req_parameters.to_json
+    end
+
+    def try_parse_json(maybe_json)
+      JSON.parse(maybe_json)
+    rescue JSON::ParserError
+      maybe_json
+    end
+  end
+end

data/lib/openai/http_headers.rb

@@ -0,0 +1,36 @@
+module OpenAI
+  module HTTPHeaders
+    def add_headers(headers)
+      @extra_headers = extra_headers.merge(headers.transform_keys(&:to_s))
+    end
+
+    private
+
+    def headers
+      if azure?
+        azure_headers
+      else
+        openai_headers
+      end.merge(extra_headers)
+    end
+
+    def openai_headers
+      {
+        "Content-Type" => "application/json",
+        "Authorization" => "Bearer #{@access_token}",
+        "OpenAI-Organization" => @organization_id
+      }
+    end
+
+    def azure_headers
+      {
+        "Content-Type" => "application/json",
+        "api-key" => @access_token
+      }
+    end
+
+    def extra_headers
+      @extra_headers ||= {}
+    end
+  end
+end

data/lib/openai/images.rb

@@ -0,0 +1,27 @@
+module OpenAI
+  class Images
+    def initialize(client: nil)
+      @client = client
+    end
+
+    def generate(parameters: {})
+      @client.json_post(path: "/images/generations", parameters: parameters)
+    end
+
+    def edit(parameters: {})
+      @client.multipart_post(path: "/images/edits", parameters: open_files(parameters))
+    end
+
+    def variations(parameters: {})
+      @client.multipart_post(path: "/images/variations", parameters: open_files(parameters))
+    end
+
+    private
+
+    def open_files(parameters)
+      parameters = parameters.merge(image: File.open(parameters[:image]))
+      parameters = parameters.merge(mask: File.open(parameters[:mask])) if parameters[:mask]
+      parameters
+    end
+  end
+end

data/lib/openai/messages.rb

@@ -0,0 +1,23 @@
+module OpenAI
+  class Messages
+    def initialize(client:)
+      @client = client.beta(assistants: "v1")
+    end
+
+    def list(thread_id:)
+      @client.get(path: "/threads/#{thread_id}/messages")
+    end
+
+    def retrieve(thread_id:, id:)
+      @client.get(path: "/threads/#{thread_id}/messages/#{id}")
+    end
+
+    def create(thread_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/messages", parameters: parameters)
+    end
+
+    def modify(id:, thread_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/messages/#{id}", parameters: parameters)
+    end
+  end
+end

data/lib/openai/models.rb

@@ -0,0 +1,15 @@
+module OpenAI
+  class Models
+    def initialize(client:)
+      @client = client
+    end
+
+    def list
+      @client.get(path: "/models")
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/models/#{id}")
+    end
+  end
+end

data/lib/openai/run_steps.rb

@@ -0,0 +1,15 @@
+module OpenAI
+  class RunSteps
+    def initialize(client:)
+      @client = client.beta(assistants: "v1")
+    end
+
+    def list(thread_id:, run_id:)
+      @client.get(path: "/threads/#{thread_id}/runs/#{run_id}/steps")
+    end
+
+    def retrieve(thread_id:, run_id:, id:)
+      @client.get(path: "/threads/#{thread_id}/runs/#{run_id}/steps/#{id}")
+    end
+  end
+end

data/lib/openai/runs.rb

@@ -0,0 +1,32 @@
+module OpenAI
+  class Runs
+    def initialize(client:)
+      @client = client.beta(assistants: "v1")
+    end
+
+    def list(thread_id:)
+      @client.get(path: "/threads/#{thread_id}/runs")
+    end
+
+    def retrieve(thread_id:, id:)
+      @client.get(path: "/threads/#{thread_id}/runs/#{id}")
+    end
+
+    def create(thread_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/runs", parameters: parameters)
+    end
+
+    def modify(id:, thread_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/runs/#{id}", parameters: parameters)
+    end
+
+    def cancel(id:, thread_id:)
+      @client.post(path: "/threads/#{thread_id}/runs/#{id}/cancel")
+    end
+
+    def submit_tool_outputs(thread_id:, run_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/runs/#{run_id}/submit_tool_outputs",
+                        parameters: parameters)
+    end
+  end
+end

data/lib/openai/threads.rb

@@ -0,0 +1,23 @@
+module OpenAI
+  class Threads
+    def initialize(client:)
+      @client = client.beta(assistants: "v1")
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/threads/#{id}")
+    end
+
+    def create(parameters: {})
+      @client.json_post(path: "/threads", parameters: parameters)
+    end
+
+    def modify(id:, parameters: {})
+      @client.json_post(path: "/threads/#{id}", parameters: parameters)
+    end
+
+    def delete(id:)
+      @client.delete(path: "/threads/#{id}")
+    end
+  end
+end

data/lib/openai/version.rb

@@ -0,0 +1,3 @@
+module OpenAI
+  VERSION = "6.5.0".freeze
+end

data/lib/openai.rb

@@ -0,0 +1,88 @@
+require "faraday"
+require "faraday/multipart"
+
+require_relative "openai/http"
+require_relative "openai/client"
+require_relative "openai/files"
+require_relative "openai/finetunes"
+require_relative "openai/images"
+require_relative "openai/models"
+require_relative "openai/assistants"
+require_relative "openai/threads"
+require_relative "openai/messages"
+require_relative "openai/runs"
+require_relative "openai/run_steps"
+require_relative "openai/audio"
+require_relative "openai/version"
+
+module OpenAI
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+
+  class MiddlewareErrors < Faraday::Middleware
+    def call(env)
+      @app.call(env)
+    rescue Faraday::Error => e
+      raise e unless e.response.is_a?(Hash)
+
+      logger = Logger.new($stdout)
+      logger.formatter = proc do |_severity, _datetime, _progname, msg|
+        "\033[31mOpenAI HTTP Error (spotted in ruby-openai #{VERSION}): #{msg}\n\033[0m"
+      end
+      logger.error(e.response[:body])
+
+      raise e
+    end
+  end
+
+  class Configuration
+    attr_writer :access_token
+    attr_accessor :api_type, :api_version, :organization_id, :uri_base, :request_timeout,
+                  :extra_headers
+
+    DEFAULT_API_VERSION = "v2".freeze
+    DEFAULT_URI_BASE = "https://api.openai.com/".freeze
+    DEFAULT_REQUEST_TIMEOUT = 120
+
+    def initialize
+      @access_token = nil
+      @api_type = nil
+      @api_version = DEFAULT_API_VERSION
+      @organization_id = nil
+      @uri_base = DEFAULT_URI_BASE
+      @request_timeout = DEFAULT_REQUEST_TIMEOUT
+      @extra_headers = {}
+    end
+
+    def access_token
+      return @access_token if @access_token
+
+      error_text = "OpenAI access token missing! See https://github.com/alexrudall/ruby-openai#usage"
+      raise ConfigurationError, error_text
+    end
+  end
+
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= OpenAI::Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  # Estimate the number of tokens in a string, using the rules of thumb from OpenAI:
+  # https://help.openai.com/en/articles/4936856-what-are-tokens-and-how-to-count-them
+  def self.rough_token_count(content = "")
+    raise ArgumentError, "rough_token_count requires a string" unless content.is_a? String
+    return 0 if content.empty?
+
+    count_by_chars = content.size / 4.0
+    count_by_words = content.split.size * 4.0 / 3
+    estimate = ((count_by_chars + count_by_words) / 2.0).round
+    [1, estimate].max
+  end
+end

data/lib/ruby/openai.rb

@@ -0,0 +1,2 @@
+require_relative "../openai"
+require_relative "../openai/compatibility"

data/pull_request_template.md

@@ -0,0 +1,5 @@
+## All Submissions:
+
+* [ ] Have you followed the guidelines in our [Contributing document](../blob/main/CONTRIBUTING.md)?
+* [ ] Have you checked to ensure there aren't other open [Pull Requests](../pulls) for the same update/change?
+* [ ] Have you added an explanation of what your changes do and why you'd like us to include them?