openai.rb 0.0.0 → 0.0.3

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+RSpec.describe OpenAI::API::Response do
+  before do
+    user_class = Class.new(described_class) do
+      field :username, path: %i[handle]
+    end
+
+    stub_const('OpenAISpec::SampleResponse::User', user_class)
+
+    comment_class = Class.new(described_class) do
+      field :body
+      field :user, wrapper: OpenAISpec::SampleResponse::User
+    end
+
+    stub_const('OpenAISpec::SampleResponse::Comment', comment_class)
+
+    post_class = Class.new(described_class) do
+      field :created_at, path: %i[meta birth created]
+      field :text
+      field :comments, wrapper: OpenAISpec::SampleResponse::Comment
+      field :author, wrapper: OpenAISpec::SampleResponse::User
+      optional_field :co_author, wrapper: OpenAISpec::SampleResponse::User
+      optional_field :subtitle
+
+      # For demonstrating that we can use the instance method without specifying
+      # a wrapper class
+      define_method(:other_author) do
+        optional_field([:co_author])
+      end
+    end
+
+    stub_const('OpenAISpec::SampleResponse::Post', post_class)
+  end
+
+  let(:sample_response) do
+    OpenAISpec::SampleResponse::Post.new(sample_response_payload)
+  end
+
+  let(:sample_response_payload) do
+    {
+      meta: {
+        birth: {
+          created: Time.utc(2023).to_i
+        }
+      },
+      text: 'This is a post',
+      comments: [
+        {
+          body: 'This is a comment',
+          user: {
+            handle: 'alice'
+          }
+        },
+        {
+          body: 'This is a spicy comment',
+          user: {
+            handle: 'bob'
+          }
+        }
+      ],
+      author: {
+        handle: 'carl'
+      }
+    }
+  end
+
+  context 'when inspecting the response' do
+    # Define a smaller response payload so this is less annoying to test
+    let(:sample_response_payload) do
+      {
+        meta: { birth: { created: 1234 } },
+        text: 'This is a post',
+        comments: [],
+        author: { handle: 'carl' }
+      }
+    end
+
+    before do
+      # Mark a field as private so we can prove that the #inspect method
+      # should use __send__ in case a response class chooses to make a
+      # field private.
+      OpenAISpec::SampleResponse::Post.class_eval do
+        private(:created_at)
+      end
+    end
+
+    it 'defines a nice clean inspect method' do
+      expect(sample_response.inspect).to eql(
+        '#<OpenAISpec::SampleResponse::Post '                           \
+          'created_at=1234 '                                            \
+          'text="This is a post" '                                      \
+          'comments=[] '                                                \
+          'author=#<OpenAISpec::SampleResponse::User username="carl"> ' \
+          'co_author=nil '                                              \
+          'subtitle=nil>'
+      )
+    end
+
+    it 'tracks the fields on a class for the sake of the #inspect method' do
+      expect(OpenAISpec::SampleResponse::Comment.__send__(:field_registry))
+        .to eql(%i[body user])
+    end
+  end
+
+  it 'can parse a JSON response' do
+    expect(
+      OpenAISpec::SampleResponse::Post.from_json(
+        JSON.dump(sample_response_payload)
+      )
+    ).to eql(sample_response)
+  end
+
+  it 'exposes the original payload' do
+    expect(sample_response.original_payload).to eql(sample_response_payload)
+  end
+
+  it 'deep freezes the original payload' do
+    original = sample_response.original_payload
+    expect(original).to be_frozen
+    expect(original[:comments]).to be_frozen
+    expect(original[:comments].first).to be_frozen
+    expect(original[:comments].first[:user]).to be_frozen
+  end
+
+  describe '.field' do
+    it 'exposes the field' do
+      expect(sample_response.text).to eql('This is a post')
+      expect(sample_response.created_at).to eql(1_672_531_200)
+    end
+
+    it 'can expose fields under a different name than the key path' do
+      expect(sample_response.author.username).to eql('carl')
+    end
+
+    it 'wraps the field if a wrapper is provided' do
+      expect(sample_response.author).to eql(
+        OpenAISpec::SampleResponse::User.new(handle: 'carl')
+      )
+    end
+
+    it 'wraps each element in a the wrapper if the value is an array' do
+      expect(sample_response.comments).to all(
+        be_an_instance_of(OpenAISpec::SampleResponse::Comment)
+      )
+      expect(sample_response.comments[0].user).to eql(
+        OpenAISpec::SampleResponse::User.new(handle: 'alice')
+      )
+      expect(sample_response.comments[1].user).to eql(
+        OpenAISpec::SampleResponse::User.new(handle: 'bob')
+      )
+    end
+
+    context 'when a required field is not present' do
+      let(:sample_response_payload) do
+        { meta: { error: 'you did something wrong bro' } }
+      end
+
+      it 'raises an error when the field is accessed' do
+        expect { sample_response.text }.to raise_error(
+          described_class::MissingFieldError, <<~ERROR
+            Missing field :text in response payload!
+            Was attempting to access value at path `[:text]`.
+            Payload: {
+              "meta": {
+                "error": "you did something wrong bro"
+              }
+            }
+          ERROR
+        )
+
+        expect { sample_response.created_at }.to raise_error(
+          described_class::MissingFieldError, <<~ERROR
+            Missing field :birth in response payload!
+            Was attempting to access value at path `[:meta, :birth, :created]`.
+            Payload: {
+              "meta": {
+                "error": "you did something wrong bro"
+              }
+            }
+          ERROR
+        )
+      end
+    end
+  end
+
+  describe '.optional_field' do
+    it 'does not raise an error when a field is not present' do
+      expect(sample_response.co_author).to be_nil
+      expect(sample_response.other_author).to be_nil
+    end
+
+    context 'when the optional field is present' do
+      let(:sample_response_payload) do
+        super().merge(co_author: { handle: 'dave' })
+      end
+
+      it 'exposes the field' do
+        expect(sample_response.co_author.username).to eql('dave')
+      end
+    end
+  end
+end

data/spec/unit/openai/chat_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+RSpec.describe OpenAI::Chat do
+  let(:messages) { [{ role: 'user', content: 'Hello' }] }
+  let(:settings) { { model: 'gpt-3' } }
+  let(:openai) { double('OpenAI') }
+
+  describe 'initialization and adding messages' do
+    it 'initializes with messages and adds user, system, and assistant messages' do
+      chat = OpenAI::Chat.new(messages: messages, settings: settings, openai: openai)
+
+      expect(chat.messages.count).to eq(1)
+      expect(chat.messages.first.role).to eq('user')
+      expect(chat.messages.first.content).to eq('Hello')
+
+      chat = chat.add_user_message('How are you?')
+      expect(chat.messages.count).to eq(2)
+      expect(chat.messages.last.role).to eq('user')
+      expect(chat.messages.last.content).to eq('How are you?')
+
+      chat = chat.add_system_message('System message')
+      expect(chat.messages.count).to eq(3)
+      expect(chat.messages.last.role).to eq('system')
+      expect(chat.messages.last.content).to eq('System message')
+
+      chat = chat.add_assistant_message('I am fine, thank you.')
+      expect(chat.messages.count).to eq(4)
+      expect(chat.messages.last.role).to eq('assistant')
+      expect(chat.messages.last.content).to eq('I am fine, thank you.')
+    end
+  end
+end

data/spec/unit/openai/tokenizer_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+RSpec.describe OpenAI::Tokenizer do
+  let(:tokenizer) { described_class.new }
+
+  it 'can get an encoder by model name' do
+    expect(tokenizer.for_model('gpt-4')).to eql(
+      OpenAI::Tokenizer::Encoding.new(:cl100k_base)
+    )
+  end
+
+  it 'can get an encoder by name' do
+    expect(tokenizer.get(:cl100k_base)).to eql(
+      OpenAI::Tokenizer::Encoding.new(:cl100k_base)
+    )
+  end
+
+  it 'raises an error if the model name is not valid' do
+    expect { tokenizer.for_model('gpt-42') }.to raise_error(
+      'Invalid model name or not recognized by Tiktoken: "gpt-42"'
+    )
+  end
+
+  it 'raises an error if the encoding name is not valid' do
+    expect { tokenizer.get('aaaaaaaaaaaa') }.to raise_error(
+      'Invalid encoding name or not recognized by Tiktoken: "aaaaaaaaaaaa"'
+    )
+  end
+
+  it 'can encode text' do
+    expect(tokenizer.for_model('gpt-4').encode('Hello, world!')).to eql(
+      [9906, 11, 1917, 0]
+    )
+  end
+
+  it 'can decode tokens' do
+    expect(tokenizer.for_model('gpt-4').decode([9906, 11, 1917, 0])).to eql(
+      'Hello, world!'
+    )
+  end
+
+  it 'can count the number of tokens in text' do
+    expect(tokenizer.for_model('gpt-4').num_tokens('Hello, world!')).to eql(4)
+  end
+end