openai.rb 0.0.0 → 0.0.1

data/lib/openai.rb

@@ -2,380 +2,51 @@
 
 require 'concord'
 require 'anima'
+require 'abstract_type'
 require 'http'
 require 'addressable'
-
+require 'ice_nine'
+require 'tiktoken_ruby'
+
+require 'openai/tokenizer'
+require 'openai/chat'
+require 'openai/api'
+require 'openai/api/cache'
+require 'openai/api/client'
+require 'openai/api/resource'
+require 'openai/api/response'
 require 'openai/version'
 
 class OpenAI
-  include Concord.new(:api_key, :http)
-
-  ResponseError = Class.new(StandardError)
+  include Concord.new(:api_client)
 
-  HOST = Addressable::URI.parse('https://api.openai.com/v1')
-
-  def initialize(api_key, http: HTTP)
-    super(api_key, http)
-  end
+  ROOT = Pathname.new(__dir__).parent.expand_path.freeze
 
-  def create_completion(model:, **kwargs)
-    Response::Completion.from_json(
-      post('/v1/completions', model: model, **kwargs)
-    )
-  end
-
-  def create_chat_completion(model:, messages:, **kwargs)
-    Response::ChatCompletion.from_json(
-      post('/v1/chat/completions', model: model, messages: messages, **kwargs)
-    )
-  end
-
-  def create_embedding(model:, input:, **kwargs)
-    Response::Embedding.from_json(
-      post('/v1/embeddings', model: model, input: input, **kwargs)
-    )
-  end
-
-  def list_models
-    Response::ListModel.from_json(get('/v1/models'))
-  end
-
-  def get_model(model_id)
-    Response::Model.from_json(
-      get("/v1/models/#{model_id}")
-    )
-  end
-
-  def create_edit(model:, instruction:, **kwargs)
-    Response::Edit.from_json(
-      post('/v1/edits', model: model, instruction: instruction, **kwargs)
-    )
-  end
-
-  def create_image_generation(prompt:, **kwargs)
-    Response::ImageGeneration.from_json(
-      post('/v1/images/generations', prompt: prompt, **kwargs)
-    )
-  end
-
-  def create_file(file:, purpose:)
-    absolute_path = Pathname.new(file).expand_path.to_s
-    form_file = HTTP::FormData::File.new(absolute_path)
-    Response::File.from_json(
-      post_form_multipart('/v1/files', file: form_file, purpose: purpose)
-    )
-  end
-
-  def list_files
-    Response::FileList.from_json(
-      get('/v1/files')
-    )
-  end
-
-  def delete_file(file_id)
-    Response::File.from_json(
-      delete("/v1/files/#{file_id}")
-    )
-  end
-
-  def get_file(file_id)
-    Response::File.from_json(
-      get("/v1/files/#{file_id}")
-    )
-  end
+  def self.create(api_key, cache: nil)
+    client = API::Client.new(api_key)
 
-  def get_file_content(file_id)
-    get("/v1/files/#{file_id}/content")
-  end
-
-  def list_fine_tunes
-    Response::FineTuneList.from_json(
-      get('/v1/fine-tunes')
-    )
-  end
-
-  def create_fine_tune(training_file:, **kwargs)
-    Response::FineTune.from_json(
-      post('/v1/fine-tunes', training_file: training_file, **kwargs)
-    )
-  end
-
-  def get_fine_tune(fine_tune_id)
-    Response::FineTune.from_json(
-      get("/v1/fine-tunes/#{fine_tune_id}")
-    )
-  end
-
-  def cancel_fine_tune(fine_tune_id)
-    Response::FineTune.from_json(
-      post("/v1/fine-tunes/#{fine_tune_id}/cancel")
-    )
-  end
-
-  def transcribe_audio(file:, model:, **kwargs)
-    absolute_path = Pathname.new(file).expand_path.to_s
-    form_file = HTTP::FormData::File.new(absolute_path)
-    Response::Transcription.from_json(
-      post_form_multipart(
-        '/v1/audio/transcriptions',
-        file: form_file,
-        model: model,
-        **kwargs
+    if cache.is_a?(Pathname) && cache.directory?
+      client = API::Cache.new(
+        client,
+        API::Cache::Strategy::FileSystem.new(cache)
       )
-    )
-  end
-
-  def inspect
-    "#<#{self.class}>"
-  end
-
-  private
-
-  def get(route)
-    unwrap_response(json_http_client.get(url_for(route)))
-  end
-
-  def delete(route)
-    unwrap_response(json_http_client.delete(url_for(route)))
-  end
-
-  def post(route, **body)
-    unwrap_response(json_http_client.post(url_for(route), json: body))
-  end
-
-  def post_form_multipart(route, **body)
-    unwrap_response(http_client.post(url_for(route), form: body))
-  end
-
-  def url_for(route)
-    HOST.join(route).to_str
-  end
-
-  def unwrap_response(response)
-    unless response.status.success?
-      raise ResponseError, "Unexpected response #{response.status}\nBody:\n#{response.body}"
     end
 
-    response.body.to_s
+    new(client)
   end
 
-  def json_http_client
-    http_client.headers('Content-Type' => 'application/json')
-  end
+  private_class_method :new
 
-  def http_client
-    http.headers('Authorization' => "Bearer #{api_key}")
+  def api
+    API.new(api_client)
   end
 
-  class Response
-    class JSONPayload
-      include Concord.new(:internal_data)
-
-      def self.from_json(raw_json)
-        new(JSON.parse(raw_json, symbolize_names: true))
-      end
-
-      def self.field(name, path: [name], wrapper: nil)
-        given_wrapper = wrapper
-        define_method(name) do
-          field(path, wrapper: given_wrapper)
-        end
-      end
-
-      def self.optional_field(name, path: name)
-        define_method(name) do
-          optional_field(path)
-        end
-      end
-
-      def original_payload
-        internal_data
-      end
-
-      private
-
-      def optional_field(key_path)
-        *head, tail = key_path
-
-        field(head)[tail]
-      end
-
-      def field(key_path, wrapper: nil)
-        value = key_path.reduce(internal_data, :fetch)
-        return value unless wrapper
-
-        if value.is_a?(Array)
-          value.map { |item| wrapper.new(item) }
-        else
-          wrapper.new(value)
-        end
-      end
-    end
-
-    class Completion < JSONPayload
-      class Choice < JSONPayload
-        field :text
-        field :index
-        field :logprobs
-        field :finish_reason
-      end
-
-      class Usage < JSONPayload
-        field :prompt_tokens
-        field :completion_tokens
-        field :total_tokens
-      end
-
-      field :id
-      field :object
-      field :created
-      field :model
-      field :choices, wrapper: Choice
-      field :usage, wrapper: Usage
-    end
-
-    class ChatCompletion < JSONPayload
-      class Choice < JSONPayload
-        class Message < JSONPayload
-          field :role
-          field :content
-        end
-
-        field :index
-        field :message, wrapper: Message
-        field :finish_reason
-      end
-
-      class Usage < JSONPayload
-        field :prompt_tokens
-        field :completion_tokens
-        field :total_tokens
-      end
-
-      field :id
-      field :object
-      field :created
-      field :choices, wrapper: Choice
-      field :usage, wrapper: Usage
-    end
-
-    class Embedding < JSONPayload
-      class EmbeddingData < JSONPayload
-        field :object
-        field :embedding
-        field :index
-      end
-
-      class Usage < JSONPayload
-        field :prompt_tokens
-        field :total_tokens
-      end
-
-      field :object
-      field :data, wrapper: EmbeddingData
-      field :model
-      field :usage, wrapper: Usage
-    end
-
-    class Model < JSONPayload
-      field :id
-      field :object
-      field :owned_by
-      field :permission
-    end
-
-    class ListModel < JSONPayload
-      field :data, wrapper: Model
-    end
-
-    class Edit < JSONPayload
-      class Choice < JSONPayload
-        field :text
-        field :index
-      end
-
-      class Usage < JSONPayload
-        field :prompt_tokens
-        field :completion_tokens
-        field :total_tokens
-      end
-
-      field :object
-      field :created
-      field :choices, wrapper: Choice
-      field :usage, wrapper: Usage
-    end
-
-    class ImageGeneration < JSONPayload
-      class Image < JSONPayload
-        field :url
-      end
-
-      field :created
-      field :data, wrapper: Image
-    end
-
-    class File < JSONPayload
-      field :id
-      field :object
-      field :bytes
-      field :created_at
-      field :filename
-      field :purpose
-      optional_field :deleted?, path: :deleted
-    end
-
-    class FileList < JSONPayload
-      field :data, wrapper: File
-      field :object
-    end
-
-    class FineTune < JSONPayload
-      class Event < JSONPayload
-        field :object
-        field :created_at
-        field :level
-        field :message
-      end
-
-      class Hyperparams < JSONPayload
-        field :batch_size
-        field :learning_rate_multiplier
-        field :n_epochs
-        field :prompt_loss_weight
-      end
-
-      class File < JSONPayload
-        field :id
-        field :object
-        field :bytes
-        field :created_at
-        field :filename
-        field :purpose
-      end
-
-      field :id
-      field :object
-      field :model
-      field :created_at
-      field :events, wrapper: Event
-      field :fine_tuned_model
-      field :hyperparams, wrapper: Hyperparams
-      field :organization_id
-      field :result_files, wrapper: File
-      field :status
-      field :validation_files, wrapper: File
-      field :training_files, wrapper: File
-      field :updated_at
-    end
-
-    class FineTuneList < JSONPayload
-      field :object
-      field :data, wrapper: FineTune
-    end
+  def tokenizer
+    Tokenizer.new
+  end
+  alias tokens tokenizer
 
-    class Transcription < JSONPayload
-      field :text
-    end
+  def chat(model:, history: [], **kwargs)
+    Chat.new(api: api, settings: kwargs.merge(model: model), messages: history)
   end
 end

data/openai.gemspec

@@ -16,7 +16,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = %w[lib]
   spec.executables   = []
 
-  spec.add_dependency 'anima',    '~> 0.3'
-  spec.add_dependency 'concord',  '~> 0.1'
-  spec.add_dependency 'http',     '~> 5.1'
+  spec.add_dependency 'anima',         '~> 0.3'
+  spec.add_dependency 'concord',       '~> 0.1'
+  spec.add_dependency 'http',          '~> 5.1'
+  spec.add_dependency 'memoizable',    '~> 0.4.2'
+  spec.add_dependency 'abstract_type', '~> 0.0.7'
+  spec.add_dependency 'ice_nine',      '~> 0.11.x'
+  spec.add_dependency 'tiktoken_ruby', '~> 0.0.3'
 end

data/spec/shared/api_resource_context.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+RSpec.shared_context 'an API Resource' do
+  let(:api)                  { OpenAI::API.new(api_client)                   }
+  let(:api_client)           { OpenAI::API::Client.new('sk-123', http: http) }
+  let(:http)                 { class_spy(HTTP)                               }
+  let(:response_status_code) { 200                                           }
+
+  let(:response) do
+    instance_double(
+      HTTP::Response,
+      status: HTTP::Response::Status.new(response_status_code),
+      body: JSON.dump(response_body)
+    )
+  end
+
+  before do
+    allow(http).to receive(:post).and_return(response)
+    allow(http).to receive(:get).and_return(response)
+    allow(http).to receive(:delete).and_return(response)
+  end
+end

data/spec/spec_helper.rb

@@ -9,6 +9,10 @@ module OpenAISpec
   SPEC_ROOT = ROOT.join('spec')
 end
 
+OpenAISpec::SPEC_ROOT.glob('shared/*.rb').shuffle.each do |shared_spec|
+  require(shared_spec)
+end
+
 RSpec.configure do |config|
   # Enable focused tests and run all tests if nothing is focused
   config.filter_run_when_matching(:focus)

data/spec/unit/openai/api/audio_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+RSpec.describe OpenAI::API, '#audio' do
+  include_context 'an API Resource'
+
+  let(:resource) { api.audio }
+  let(:sample_audio) { OpenAISpec::SPEC_ROOT.join('data/sample.mp3') }
+
+  context 'when transcribing audio' do
+    let(:response_body) do
+      {
+        "text": "Imagine the wildest idea that you've ever had, and you're curious about how it might scale to something that's a 100, a 1,000 times bigger. This is a place where you can get to do that."
+      }
+    end
+
+    it 'can transcribe audio' do
+      transcription = resource.transcribe(
+        file: sample_audio,
+        model: 'model-1234'
+      )
+
+      expect(http)
+        .to have_received(:post)
+        .with(
+          'https://api.openai.com/v1/audio/transcriptions',
+          hash_including(
+            form: hash_including(
+              {
+                file: instance_of(HTTP::FormData::File),
+                model: 'model-1234'
+              }
+            )
+          )
+        )
+
+      expect(transcription.text).to eql("Imagine the wildest idea that you've ever had, and you're curious about how it might scale to something that's a 100, a 1,000 times bigger. This is a place where you can get to do that.")
+    end
+  end
+
+  context 'when translating audio' do
+    let(:sample_audio) { OpenAISpec::SPEC_ROOT.join('data/sample_french.mp3') }
+
+    let(:response_body) do
+      {
+        "text": 'Hello, my name is Wolfgang and I come from Germany. Where are you heading today?'
+      }
+    end
+
+    it 'can translate audio' do
+      translation = resource.translate(
+        file: sample_audio,
+        model: 'model-id',
+        prompt: 'Hello, my name is Wolfgang and I come from Germany. Where are you heading today?',
+        response_format: 'text',
+        temperature: 0.5
+      )
+
+      expect(http)
+        .to have_received(:post)
+        .with(
+          'https://api.openai.com/v1/audio/translations',
+          hash_including(
+            form: hash_including(
+              {
+                file: instance_of(HTTP::FormData::File),
+                model: 'model-id',
+                prompt: 'Hello, my name is Wolfgang and I come from Germany. Where are you heading today?',
+                response_format: 'text',
+                temperature: 0.5
+              }
+            )
+          )
+        )
+
+      expect(translation.text).to eql('Hello, my name is Wolfgang and I come from Germany. Where are you heading today?')
+    end
+  end
+end

data/spec/unit/openai/api/cache_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+RSpec.describe OpenAI::API::Cache do
+  let(:cached_client) do
+    described_class.new(client, cache_strategy)
+  end
+
+  let(:client) do
+    instance_double(OpenAI::API::Client, api_key: 'sk-123').tap do |double|
+      %i[get post post_form_multipart delete].each do |method|
+        allow(double).to receive(method).and_return(api_resource)
+      end
+    end
+  end
+
+  let(:api_resource) do
+    JSON.dump(text: 'Wow neat')
+  end
+
+  let(:cache_strategy) do
+    described_class::Strategy::Memory.new
+  end
+
+  it 'wraps the public API of API::Client' do
+    client_public_api =
+      OpenAI::API::Client.public_instance_methods(false) - %i[api_key inspect]
+
+    client_public_api.each do |client_method|
+      expect(cached_client).to respond_to(client_method)
+    end
+  end
+
+  it 'can cache get requests' do
+    cached_client.get('/v1/foo')
+    cached_client.get('/v1/foo')
+    cached_client.get('/v1/bar')
+
+    expect(client).to have_received(:get).with('/v1/foo').once
+    expect(client).to have_received(:get).with('/v1/bar').once
+  end
+
+  it 'can cache JSON post requests' do
+    cached_client.post('/v1/foo', model: 'model1', prompt: 'prompt1')                # miss
+    cached_client.post('/v1/foo', model: 'model1', prompt: 'prompt1')                # hit
+    cached_client.post('/v1/foo', model: 'model1', prompt: 'prompt2')                # miss
+    cached_client.post('/v1/bar', model: 'model1', prompt: 'prompt2')                # miss
+    cached_client.post_form_multipart('/v1/foo', model: 'model1', prompt: 'prompt1') # miss
+
+    expect(client).to have_received(:post).thrice
+    expect(client).to have_received(:post_form_multipart).once
+  end
+
+  it 'does not cache delete requests' do
+    cached_client.delete('/v1/foo')
+    cached_client.delete('/v1/foo')
+
+    expect(client).to have_received(:delete).twice
+  end
+
+  it 'can cache multipart form post requests' do
+    cached_client.post_form_multipart('/v1/foo', model: 'model1', prompt: 'prompt1') # miss
+    cached_client.post_form_multipart('/v1/foo', model: 'model1', prompt: 'prompt1') # hit
+    cached_client.post_form_multipart('/v1/foo', model: 'model1', prompt: 'prompt2') # miss
+    cached_client.post_form_multipart('/v1/bar', model: 'model1', prompt: 'prompt2') # miss
+    cached_client.post('/v1/foo', model: 'model1', prompt: 'prompt1')                # miss
+
+    expect(client).to have_received(:post_form_multipart).thrice
+  end
+
+  it 'writes unique and somewhat human readable cache keys' do
+    expect(cache_strategy.cached?('get_foo_9bfe1439')).to be(false)
+    cached_client.get('/v1/foo')
+    expect(cache_strategy.cached?('get_foo_9bfe1439')).to be(true)
+  end
+
+  it 'returns identical values for cache hits and misses' do
+    miss = cached_client.get('/v1/foo')
+    hit  = cached_client.get('/v1/foo')
+
+    expect(miss).to eq(hit)
+  end
+
+  context 'when the API key changes' do
+    before do
+      allow(client).to receive(:api_key).and_return('sk-123', 'sk-123', 'sk-456')
+    end
+
+    it 'factors the API key into the cache calculation' do
+      cached_client.get('/v1/foo')
+      cached_client.get('/v1/foo')
+      cached_client.get('/v1/foo')
+
+      expect(client).to have_received(:get).with('/v1/foo').twice
+    end
+  end
+
+  context 'when using the filesystem cache strategy' do
+    let(:cache_strategy) do
+      described_class::Strategy::FileSystem.new(cache_dir)
+    end
+
+    let(:cache_dir) do
+      Pathname.new(Dir.mktmpdir)
+    end
+
+    it 'writes JSON files' do
+      cache_path = cache_dir.join('get_foo_9bfe1439.json')
+      expect(cache_path.exist?).to be(false)
+      cached_client.get('/v1/foo')
+      expect(cache_path.exist?).to be(true)
+
+      expect(cache_strategy.read('get_foo_9bfe1439')).to eq(api_resource)
+    end
+  end
+end