openai.rb 0.0.0 → 0.0.1

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+RSpec.describe OpenAI::API, '#chat_completions' do
+  include_context 'an API Resource'
+
+  let(:resource) { api.chat_completions }
+  let(:response_body) do
+    {
+      "id": 'chatcmpl-123',
+      "object": 'chat.completion',
+      "created": 1_677_652_288,
+      "choices": [
+        {
+          "index": 0,
+          "message": {
+            "role": 'assistant',
+            "content": "\n\nHello there, how may I assist you today?"
+          },
+          "finish_reason": 'stop'
+        }
+      ],
+      "usage": {
+        "prompt_tokens": 9,
+        "completion_tokens": 12,
+        "total_tokens": 21
+      }
+    }
+  end
+
+  it 'can create a chat completion' do
+    messages = [
+      { "text": 'Hello there!', "user": 'customer' },
+      { "text": 'Can you help me with my order?', "user": 'customer' },
+      { "text": 'Sure, what would you like to do?', "user": 'assistant' }
+    ]
+    completion = resource.create(model: 'text-davinci-002', messages: messages)
+
+    expect(completion.id).to eql('chatcmpl-123')
+    expect(completion.choices.first.index).to eql(0)
+    expect(completion.choices.first.message.role).to eql('assistant')
+    expect(completion.choices.first.message.content).to eql("\n\nHello there, how may I assist you today?")
+    expect(completion.choices.first.finish_reason).to eql('stop')
+    expect(completion.usage.prompt_tokens).to eql(9)
+    expect(completion.usage.completion_tokens).to eql(12)
+    expect(completion.usage.total_tokens).to eql(21)
+  end
+
+  it 'raises when a block is given for a non-streaming request' do
+    expect { resource.create(model: 'text-davinci-002', messages: []) { print 'noop' } }
+      .to raise_error('Non-streaming responses do not support blocks')
+  end
+
+  context 'when streaming is enabled' do
+    let(:response_chunks) do
+      [
+        chunk(role: 'assistant'),
+        chunk(content: 'He'),
+        chunk(content: 'llo,'),
+        chunk(content: ' world'),
+        chunk({ content: '!' }, finish_reason: 'stop')
+      ]
+    end
+
+    let(:response) do
+      instance_double(
+        HTTP::Response,
+        status: HTTP::Response::Status.new(response_status_code),
+        body: response_body
+      )
+    end
+
+    let(:response_body) do
+      instance_double(HTTP::Response::Body).tap do |double|
+        allow(double).to receive(:each)
+          .and_yield(response_chunks.first)
+          .and_yield(response_chunks[1])
+          .and_yield(response_chunks[2])
+          .and_yield(response_chunks[3])
+          .and_yield(response_chunks[4])
+          .and_yield('data: [DONE]')
+      end
+    end
+
+    before do
+      allow(http).to receive(:persistent).and_yield(http)
+    end
+
+    def chunk(delta, finish_reason: nil)
+      data = {
+        id: 'chatcmpl-6y5rBH2fvMeGqAAH81Wkp8QdqESEx',
+        object: 'chat.completion.chunk',
+        created: 1_679_780_213,
+        model: 'gpt-3.5-turbo-0301',
+        choices: [delta: delta, index: 0, finish_reason: finish_reason]
+      }
+
+      "data: #{JSON.dump(data)}"
+    end
+
+    it 'yields chunks as they are served' do
+      chunks = []
+      resource.create(model: 'text-davinci-002', messages: [], stream: true) do |chunk|
+        chunks << chunk
+      end
+
+      expect(chunks).to all(be_an_instance_of(OpenAI::API::Response::ChatCompletionChunk))
+      texts = chunks.map { |chunk| chunk.choices.first.delta.content }
+      expect(texts.join('')).to eql('Hello, world!')
+    end
+
+    it 'raises when a block is not given' do
+      expect { resource.create(model: 'text-davinci-002', messages: [], stream: true) }
+        .to raise_error('Streaming responses require a block')
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+RSpec.describe OpenAI::API, '#completions' do
+  include_context 'an API Resource'
+
+  let(:resource) { api.completions }
+
+  let(:response_body) do
+    {
+      "id": 'cmpl-uqkvlQyYK7bGYrRHQ0eXlWi7',
+      "object": 'text_completion',
+      "created": 1_589_478_378,
+      "model": 'text-davinci-003',
+      "choices": [
+        {
+          "text": "\n\nThis is indeed a test",
+          "index": 0,
+          "logprobs": nil,
+          "finish_reason": 'length'
+        }
+      ],
+      "usage": {
+        "prompt_tokens": 5,
+        "completion_tokens": 7,
+        "total_tokens": 12
+      }
+    }
+  end
+
+  it 'can create a completion' do
+    completion = resource.create(model: 'text-davinci-002', prompt: 'Hello, world!')
+
+    expect(http)
+      .to have_received(:post)
+      .with('https://api.openai.com/v1/completions', hash_including(:json))
+
+    expect(completion.id).to eql('cmpl-uqkvlQyYK7bGYrRHQ0eXlWi7')
+    expect(completion.model).to eql('text-davinci-003')
+    expect(completion.choices.first.text).to eql("\n\nThis is indeed a test")
+    expect(completion.choices.first.index).to eql(0)
+    expect(completion.choices.first.logprobs).to be_nil
+    expect(completion.choices.first.finish_reason).to eql('length')
+    expect(completion.usage.prompt_tokens).to eql(5)
+    expect(completion.usage.completion_tokens).to eql(7)
+    expect(completion.usage.total_tokens).to eql(12)
+  end
+
+  it 'raises when a block is given for a non-streaming request' do
+    expect { resource.create(model: 'text-davinci-002', prompt: 'Hello, world!') { print 'noop' } }
+      .to raise_error('Non-streaming responses do not support blocks')
+  end
+
+  context 'when streaming is enabled' do
+    let(:response_chunks) do
+      [
+        chunk('He'),
+        chunk('llo,'),
+        chunk(' world'),
+        chunk('!', finish_reason: 'stop')
+      ]
+    end
+
+    let(:response) do
+      instance_double(
+        HTTP::Response,
+        status: HTTP::Response::Status.new(response_status_code),
+        body: response_body
+      )
+    end
+
+    let(:response_body) do
+      instance_double(HTTP::Response::Body).tap do |double|
+        allow(double).to receive(:each)
+          .and_yield(response_chunks.first)
+          .and_yield(response_chunks[1])
+          .and_yield(response_chunks[2])
+          .and_yield(response_chunks[3])
+          .and_yield('data: [DONE]')
+      end
+    end
+
+    before do
+      allow(http).to receive(:persistent).and_yield(http)
+    end
+
+    def chunk(text, finish_reason: nil)
+      data = {
+        "id": 'cmpl-6y5B6Ak8wBk2nKsqVtSlFeJAG1dUM',
+        "object": 'text_completion',
+        "created": 1_679_777_604,
+        "choices": [{
+          "text": text,
+          "index": 0,
+          "logprobs": nil,
+          "finish_reason": finish_reason
+        }],
+        "model": 'text-davinci-002'
+      }
+
+      "data: #{JSON.dump(data)}"
+    end
+
+    it 'yields chunks as they are served' do
+      chunks = []
+      resource.create(model: 'text-davinci-002', prompt: 'Hello, world!', stream: true) do |chunk|
+        chunks << chunk
+      end
+
+      expect(chunks).to all(be_an_instance_of(OpenAI::API::Response::Completion))
+      texts = chunks.map { |chunk| chunk.choices.first.text }
+      expect(texts.join('')).to eql('Hello, world!')
+    end
+
+    it 'raises when a block is not given' do
+      expect { resource.create(model: 'text-davinci-002', prompt: 'Hello, world!', stream: true) }
+        .to raise_error('Streaming responses require a block')
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe OpenAI::API, '#edits' do
+  include_context 'an API Resource'
+
+  let(:resource) { api.edits }
+  let(:response_body) do
+    {
+      "object": 'edit',
+      "created": 1_589_478_378,
+      "choices": [
+        {
+          "text": 'What day of the week is it?',
+          "index": 0
+        }
+      ],
+      "usage": {
+        "prompt_tokens": 25,
+        "completion_tokens": 32,
+        "total_tokens": 57
+      }
+    }
+  end
+
+  it 'can create an edit' do
+    edit = resource.create(model: 'text-davinci-002',
+                           instruction: 'Change "world" to "solar system" in the following text: "Hello, world!"')
+
+    expect(http)
+      .to have_received(:post)
+      .with('https://api.openai.com/v1/edits', hash_including(:json))
+
+    expect(edit.object).to eql('edit')
+    expect(edit.choices.first.text).to eql('What day of the week is it?')
+    expect(edit.choices.first.index).to eql(0)
+    expect(edit.usage.prompt_tokens).to eql(25)
+    expect(edit.usage.completion_tokens).to eql(32)
+    expect(edit.usage.total_tokens).to eql(57)
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+RSpec.describe OpenAI::API, '#embeddings' do
+  include_context 'an API Resource'
+
+  let(:resource) { api.embeddings }
+  let(:response_body) do
+    {
+      "object": 'list',
+      "data": [
+        {
+          "object": 'embedding',
+          "embedding": [
+            0.0023064255,
+            -0.009327292,
+            -0.0028842222
+          ],
+          "index": 0
+        }
+      ],
+      "model": 'text-embedding-ada-002',
+      "usage": {
+        "prompt_tokens": 8,
+        "total_tokens": 8
+      }
+    }
+  end
+
+  it 'can create an embedding' do
+    embedding = resource.create(model: 'text-embedding-ada-002', input: 'Hello, world!')
+
+    expect(http)
+      .to have_received(:post)
+      .with('https://api.openai.com/v1/embeddings', hash_including(:json))
+
+    expect(embedding.object).to eql('list')
+    expect(embedding.data.first.object).to eql('embedding')
+    expect(embedding.data.first.embedding.length).to eql(3)
+    expect(embedding.data.first.embedding.first).to eql(0.0023064255)
+    expect(embedding.data.first.index).to eql(0)
+    expect(embedding.model).to eql('text-embedding-ada-002')
+    expect(embedding.usage.prompt_tokens).to eql(8)
+    expect(embedding.usage.total_tokens).to eql(8)
+  end
+end

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+RSpec.describe OpenAI::API, '#files' do
+  include_context 'an API Resource'
+
+  let(:resource) { api.files }
+  let(:sample_file) { OpenAISpec::SPEC_ROOT.join('data/sample.jsonl') }
+
+  context 'when creating a file' do
+    let(:response_body) do
+      {
+        "id": 'file-XjGxS3KTG0uNmNOK362iJua3',
+        "object": 'file',
+        "bytes": 140,
+        "created_at": 1_613_779_121,
+        "filename": 'sample.jsonl',
+        "purpose": 'fine-tune'
+      }
+    end
+
+    it 'can create a file' do
+      file = resource.create(
+        file: sample_file,
+        purpose: 'fine-tune'
+      )
+
+      expect(http)
+        .to have_received(:post)
+        .with(
+          'https://api.openai.com/v1/files',
+          hash_including(
+            form: hash_including(
+              {
+                file: instance_of(HTTP::FormData::File),
+                purpose: 'fine-tune'
+              }
+            )
+          )
+        )
+
+      expect(file.id).to eql('file-XjGxS3KTG0uNmNOK362iJua3')
+      expect(file.object).to eql('file')
+      expect(file.bytes).to eql(140)
+      expect(file.created_at).to eql(1_613_779_121)
+      expect(file.filename).to eql('sample.jsonl')
+      expect(file.purpose).to eql('fine-tune')
+      expect(file.deleted?).to be(nil)
+    end
+  end
+
+  context 'when listing a file' do
+    let(:response_body) do
+      {
+        "data": [
+          {
+            "id": 'file-ccdDZrC3iZVNiQVeEA6Z66wf',
+            "object": 'file',
+            "bytes": 175,
+            "created_at": 1_613_677_385,
+            "filename": 'train.jsonl',
+            "purpose": 'search'
+          },
+          {
+            "id": 'file-XjGxS3KTG0uNmNOK362iJua3',
+            "object": 'file',
+            "bytes": 140,
+            "created_at": 1_613_779_121,
+            "filename": 'puppy.jsonl',
+            "purpose": 'search'
+          }
+        ],
+        "object": 'list'
+      }
+    end
+
+    it 'can get a list of files' do
+      files = resource.list
+
+      expect(http)
+        .to have_received(:get)
+        .with('https://api.openai.com/v1/files')
+
+      expect(files.data.size).to eql(2)
+      expect(files.data.first.id).to eql('file-ccdDZrC3iZVNiQVeEA6Z66wf')
+      expect(files.data.first.object).to eql('file')
+      expect(files.data.first.bytes).to eql(175)
+      expect(files.data.first.created_at).to eql(1_613_677_385)
+      expect(files.data.first.filename).to eql('train.jsonl')
+      expect(files.data.first.purpose).to eql('search')
+      expect(files.object).to eql('list')
+    end
+  end
+
+  context 'when deleting a file' do
+    let(:response_body) do
+      {
+        "id": 'file-XjGxS3KTG0uNmNOK362iJua3',
+        "object": 'file',
+        "deleted": true
+      }
+    end
+
+    it 'can delete a file' do
+      file = resource.delete('file-XjGxS3KTG0uNmNOK362iJua3')
+
+      expect(http)
+        .to have_received(:delete)
+        .with('https://api.openai.com/v1/files/file-XjGxS3KTG0uNmNOK362iJua3')
+
+      expect(file.id).to eql('file-XjGxS3KTG0uNmNOK362iJua3')
+      expect(file.object).to eql('file')
+      expect(file.deleted?).to be_truthy
+    end
+  end
+
+  context 'when fetching a file' do
+    let(:response_body) do
+      {
+        "id": 'file-XjGxS3KTG0uNmNOK362iJua3',
+        "object": 'file',
+        "bytes": 140,
+        "created_at": 1_613_779_657,
+        "filename": 'mydata.jsonl',
+        "purpose": 'fine-tune'
+      }
+    end
+
+    it 'can get a file' do
+      file = resource.fetch('file-XjGxS3KTG0uNmNOK362iJua3')
+
+      expect(http)
+        .to have_received(:get)
+        .with('https://api.openai.com/v1/files/file-XjGxS3KTG0uNmNOK362iJua3')
+
+      expect(file.id).to eql('file-XjGxS3KTG0uNmNOK362iJua3')
+      expect(file.object).to eql('file')
+      expect(file.bytes).to eql(140)
+      expect(file.created_at).to eql(1_613_779_657)
+      expect(file.filename).to eql('mydata.jsonl')
+      expect(file.purpose).to eql('fine-tune')
+    end
+  end
+
+  context 'when fetching a file contents' do
+    let(:response) do
+      instance_double(
+        HTTP::Response,
+        status: HTTP::Response::Status.new(200),
+        body: '(raw)'
+      )
+    end
+
+    it 'can get a file contents' do
+      response = resource.get_content('file-XjGxS3KTG0uNmNOK362iJua3')
+
+      expect(http)
+        .to have_received(:get)
+        .with('https://api.openai.com/v1/files/file-XjGxS3KTG0uNmNOK362iJua3/content')
+
+      expect(response).to eql('(raw)')
+    end
+  end
+end