ollama-ruby 0.0.0 → 0.1.0

data/spec/ollama/documents/memory_cache_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+RSpec.describe Ollama::Documents::MemoryCache do
+  let :memory_cache do
+    described_class.new prefix: 'test-'
+  end
+
+  it 'can be instantiated' do
+    expect(memory_cache).to be_a described_class
+  end
+
+  it 'can get/set a key' do
+    key, value = 'foo', { test: true }
+    expect {
+      memory_cache[key] = value
+    }.to change {
+      memory_cache[key]
+    }.from(nil).to(value)
+  end
+
+  it 'can determine if key exists' do
+    key, value = 'foo', { test: true }
+    expect {
+      memory_cache[key] = value
+    }.to change {
+      memory_cache.key?(key)
+    }.from(false).to(true)
+  end
+
+  it 'can delete' do
+    key, value = 'foo', { test: true }
+    memory_cache[key] = value
+    expect {
+      memory_cache.delete(key)
+    }.to change {
+      memory_cache.key?(key)
+    }.from(true).to(false)
+  end
+
+  it 'returns size' do
+    key, value = 'foo', { test: true }
+    expect {
+      memory_cache[key] = value
+    }.to change {
+      memory_cache.size
+    }.from(0).to(1)
+  end
+
+  it 'can clear' do
+    key, value = 'foo', { test: true }
+    memory_cache[key] = value
+    expect {
+      expect(memory_cache.clear).to eq memory_cache
+    }.to change {
+      memory_cache.size
+    }.from(1).to(0)
+  end
+
+  it 'can iterate over keys under a prefix' do
+    memory_cache['foo'] = 'bar'
+    expect(memory_cache.to_a).to eq [ %w[ test-foo bar ] ]
+  end
+end

data/spec/ollama/documents/redis_cache_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+RSpec.describe Ollama::Documents::RedisCache do
+  it 'can be instantiated' do
+    redis_cache = described_class.new prefix: 'test-', url: 'something'
+    expect(redis_cache).to be_a described_class
+  end
+
+  it 'raises ArgumentError if url is missing' do
+    expect {
+      described_class.new prefix: 'test-', url: nil
+    }.to raise_error ArgumentError
+  end
+
+  context 'test redis interactions' do
+    let :redis_cache do
+      described_class.new prefix: 'test-', url: 'something'
+    end
+
+    let :redis do
+      double('Redis')
+    end
+
+    before do
+      allow_any_instance_of(described_class).to receive(:redis).and_return(redis)
+    end
+
+    it 'has Redis client' do
+      expect(redis_cache.redis).to eq redis
+    end
+
+    it 'can get a key' do
+      key = 'foo'
+      expect(redis).to receive(:get).with('test-' + key).and_return 666
+      redis_cache[key]
+    end
+
+    it 'can set a value for a key' do
+      key, value = 'foo', { test: true }
+      expect(redis).to receive(:set).with('test-' + key, JSON(value))
+      redis_cache[key] = value
+    end
+
+    it 'can determine if key exists' do
+      key = 'foo'
+      expect(redis).to receive(:exists?).with('test-' + key).and_return(false, true)
+      expect(redis_cache.key?('foo')).to eq false
+      expect(redis_cache.key?('foo')).to eq true
+    end
+
+    it 'can delete' do
+      key = 'foo'
+      expect(redis).to receive(:del).with('test-' + key)
+      redis_cache.delete(key)
+    end
+
+    it 'returns size' do
+      allow(redis).to receive(:scan_each).with(match: 'test-*').
+        and_yield('test-foo').
+        and_yield('test-bar').
+        and_yield('test-baz')
+      expect(redis_cache.size).to eq 3
+    end
+
+    it 'can clear' do
+      expect(redis).to receive(:scan_each).with(match: 'test-*').and_yield(
+        'test-foo'
+      )
+      expect(redis).to receive(:del).with('test-foo')
+      expect(redis_cache.clear).to eq redis_cache
+    end
+
+    it 'can iterate over keys under a prefix' do
+      expect(redis).to receive(:scan_each).with(match: 'test-*')
+      redis_cache.to_a
+    end
+  end
+end

data/spec/ollama/documents/splitters/character_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+RSpec.describe Ollama::Documents::Splitters::Character do
+  let :splitter do
+    described_class.new chunk_size: 23
+  end
+
+  it 'can be instantiated' do
+    expect(splitter).to be_a described_class
+  end
+
+  it 'can split' do
+    text = [ "A" * 10 ] * 10 * "\n\n"
+    result = splitter.split(text)
+    expect(result.count).to eq 5
+    expect(result.to_a.join('')).to eq ?A * 100
+  end
+
+  it 'can split including separator' do
+    splitter = described_class.new chunk_size: 25, include_separator: true
+    text = [ "A" * 10 ] * 10 * "\n\n"
+    result = splitter.split(text)
+    expect(result.count).to eq 5
+    expect(result.to_a.join('')).to eq text
+  end
+
+  it 'cannot split' do
+    text = [ "A" * 10 ] * 10 * "\n"
+    result = splitter.split(text)
+    expect(result.count).to eq 1
+    expect(result.to_a.join('').count(?A)).to eq text.count(?A)
+  end
+
+  it 'cannot split2' do
+    text = "A" * 25
+    result = splitter.split(text)
+    expect(result.count).to eq 1
+    expect(result.to_a.join('')).to eq ?A * 25
+  end
+
+  it 'can split sentences' do
+    text     = "foo.foo. bar!bar! baz?baz? quux.\nquux."
+    splitter = described_class.new(separator: /[.!?]\s*(?:\b|\z)/, chunk_size: 2)
+    result   = splitter.split(text)
+    expect(result.to_a).to eq %w[ foo foo bar bar baz baz quux quux ]
+  end
+end
+
+RSpec.describe Ollama::Documents::Splitters::RecursiveCharacter do
+  let :splitter do
+    described_class.new chunk_size: 23
+  end
+
+  it 'can be instantiated' do
+    expect(splitter).to be_a described_class
+  end
+
+  it 'can split' do
+    text = [ "A" * 10 ] * 10 * "\n\n"
+    result = splitter.split(text)
+    expect(result.count).to eq 5
+    expect(result.to_a.join('')).to eq ?A * 100
+  end
+
+  it 'cannot split' do
+    splitter = described_class.new chunk_size: 23, include_separator: true,
+      separators: described_class::DEFAULT_SEPARATORS[0..-2]
+    text = "A" * 25
+    result = splitter.split(text)
+    expect(result.count).to eq 1
+    expect(result.to_a.join('')).to eq ?A * 25
+  end
+
+  it 'can split including separator' do
+    splitter = described_class.new chunk_size: 25, include_separator: true
+    text = [ "A" * 10 ] * 10 * "\n\n"
+    result = splitter.split(text)
+    expect(result.count).to eq 5
+    expect(result.to_a.join('')).to eq text
+  end
+
+  it 'can split single newline as well' do
+    text = [ "A" * 10 ] * 10 * "\n"
+    result = splitter.split(text)
+    expect(result.count).to eq 5
+    expect(result.to_a.join('')).to eq ?A * 100
+  end
+
+  it 'can split single newline as well including separator' do
+    splitter = described_class.new chunk_size: 25, include_separator: true
+    text = [ "A" * 10 ] * 10 * "\n"
+    result = splitter.split(text)
+    expect(result.count).to eq 5
+    expect(result.to_a.join('')).to eq text
+  end
+end

data/spec/ollama/documents/splitters/semantic_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+RSpec.describe Ollama::Documents::Splitters::Semantic do
+  let :ollama do
+    double('Ollama::Client')
+  end
+
+  let :splitter do
+    described_class.new ollama:, model: 'mxbai-embed-large'
+  end
+
+  let :embeddings do
+    JSON(File.read(asset('embeddings.json')))
+  end
+
+  it 'can be instantiated' do
+    expect(splitter).to be_a described_class
+  end
+
+  before do
+    allow(ollama).to receive(:embed).and_return(double(embeddings:))
+  end
+
+  it 'can split with breakpoint :percentile' do
+    text = ([ "A" * 10 ] * 3 + [ "B" * 10 ] * 3 + [ "A" * 10 ] * 3) * ". "
+    result = splitter.split(text, breakpoint: :percentile, percentile: 75)
+    expect(result.count).to eq 3
+    expect(result.to_a.join('').count(?A)).to eq text.count(?A)
+    expect(result.to_a.join('').count(?B)).to eq text.count(?B)
+  end
+
+  it 'can split with breakpoint :percentile' do
+    described_class.new ollama:, model: 'mxbai-embed-large', chunk_size: 50
+    text = ([ "A" * 10 ] * 6 + [ "B" * 10 ] * 3 + [ "A" * 10 ] * 3) * ". "
+    result = splitter.split(text, breakpoint: :percentile, percentile: 75)
+    expect(result.count).to eq 4
+    expect(result.to_a.join('').count(?A)).to eq text.count(?A)
+    expect(result.to_a.join('').count(?B)).to eq text.count(?B)
+  end
+
+  it 'can split with breakpoint :standard_deviation' do
+    text = ([ "A" * 10 ] * 3 + [ "B" * 10 ] * 3 + [ "A" * 10 ] * 3) * ". "
+    result = splitter.split(text, breakpoint: :standard_deviation, percentage: 100)
+    expect(result.count).to eq 3
+    expect(result.to_a.join('').count(?A)).to eq text.count(?A)
+    expect(result.to_a.join('').count(?B)).to eq text.count(?B)
+  end
+
+  it 'can split with breakpoint :interquartile' do
+    text = ([ "A" * 10 ] * 3 + [ "B" * 10 ] * 3 + [ "A" * 10 ] * 3) * ". "
+    result = splitter.split(text, breakpoint: :interquartile, percentage: 75)
+    expect(result.count).to eq 3
+    expect(result.to_a.join('').count(?A)).to eq text.count(?A)
+    expect(result.to_a.join('').count(?B)).to eq text.count(?B)
+  end
+end

data/spec/ollama/documents_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+RSpec.describe Ollama::Documents do
+  let :ollama do
+    double('Ollama::Client')
+  end
+
+  let :model do
+    'mxbai-embed-large'
+  end
+
+  let :documents do
+    described_class.new ollama:, model:
+  end
+
+  it 'can be instantiated' do
+    expect(documents).to be_a described_class
+  end
+
+  it 'no texts can be added to it' do
+    expect(documents.add([])).to eq documents
+  end
+
+  it 'texts can be added to it' do
+    expect(ollama).to receive(:embed).
+      with(model:, input: %w[ foo bar ], options: nil).
+      and_return(double(embeddings: [ [ 0.1 ], [ 0.2 ] ]))
+    expect(documents.add(%w[ foo bar ])).to eq documents
+    expect(documents.exist?('foo')).to eq true
+    expect(documents.exist?('bar')).to eq true
+    expect(documents['foo']).to be_a Ollama::Documents::Record
+  end
+
+  it 'a text can be added to it' do
+    expect(ollama).to receive(:embed).
+      with(model:, input: %w[ foo ], options: nil).
+      and_return(double(embeddings: [ [ 0.1 ] ]))
+    expect(documents << 'foo').to eq documents
+    expect(documents.exist?('foo')).to eq true
+    expect(documents.exist?('bar')).to eq false
+    expect(documents['foo']).to be_a Ollama::Documents::Record
+  end
+
+  it 'can find strings' do
+    allow(ollama).to receive(:embed).
+      with(model:, input: [ 'foo' ], options: nil).
+      and_return(double(embeddings: [ [ 0.1 ] ]))
+    expect(documents << 'foo').to eq documents
+    expect(ollama).to receive(:embed).
+      with(model:, input: 'foo', options: nil).
+      and_return(double(embeddings: [ [ 0.1 ] ]))
+    records = documents.find('foo')
+    expect(records).to eq [
+      Ollama::Documents::Record[text: 'foo', embedding: [ 0.1 ], similarity: 1.0 ]
+    ]
+    expect(records[0].to_s).to eq '#<Ollama::Documents::Record "foo" 1.0>'
+  end
+
+  it 'can find only tagged strings' do
+    allow(ollama).to receive(:embed).
+      with(model:, input: [ 'foo' ], options: nil).
+      and_return(double(embeddings: [ [ 0.1 ] ]))
+    expect(documents.add('foo', tags: %i[ test ])).to eq documents
+    expect(ollama).to receive(:embed).
+      with(model:, input: 'foo', options: nil).
+      and_return(double(embeddings: [ [ 0.1 ] ]))
+    records = documents.find('foo', tags: %i[ nix ])
+    expect(records).to eq []
+    expect(ollama).to receive(:embed).
+      with(model:, input: 'foo', options: nil).
+      and_return(double(embeddings: [ [ 0.1 ] ]))
+    records = documents.find('foo', tags: %i[ test ])
+    expect(records).to eq [
+      Ollama::Documents::Record[text: 'foo', embedding: [ 0.1 ], similarity: 1.0 ]
+    ]
+    expect(records[0].to_s).to eq '#<Ollama::Documents::Record "foo" #test 1.0>'
+  end
+
+  context 'it uses cache' do
+    before do
+      allow(ollama).to receive(:embed).
+        with(model:, input: %w[ foo ], options: nil).
+        and_return(double(embeddings: [ [ 0.1 ] ]))
+    end
+
+    it 'can delete texts' do
+      expect(documents << 'foo').to eq documents
+      expect {
+        documents.delete('foo')
+      }.to change { documents.exist?('foo') }.from(true).to(false)
+    end
+
+    it 'tracks size' do
+      expect {
+        expect(documents << 'foo').to eq documents
+      }.to change { documents.size }.from(0).to(1)
+    end
+
+    it 'can clear texts' do
+      expect(documents << 'foo').to eq documents
+      expect {
+        documents.clear
+      }.to change { documents.size }.from(1).to(0)
+    end
+
+    it 'returns collections' do
+      expect(documents.collections).to eq [ :default ]
+    end
+
+    it 'can change collection' do
+      expect(documents.instance_eval { @cache }).to receive(:prefix=).
+        with(/#@collection/).and_call_original
+      expect { documents.collection = :new_collection }.
+        to change { documents.collection }.
+        from(:default).
+        to(:new_collection)
+    end
+  end
+end

data/spec/ollama/handlers/progress_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe Ollama::Handlers::Progress do
   end
 
   it 'can display progress' do
-    response = double('response', status: 'testing', completed: 23, total: 666)
+    response = double('response', status: 'testing', completed: 23, total: 666, error: nil)
     expect(infobar.counter).to receive(:progress).with(by: 23).and_call_original
     expect(infobar.display).to receive(:update).and_call_original
     described_class.new.call(response)
@@ -16,7 +16,7 @@ RSpec.describe Ollama::Handlers::Progress do
   it 'can display errors in progress' do
     response = double('response', error: 'foo', status: nil, completed: nil, total: nil)
     progress = described_class.new
-    expect(progress.output).to receive(:puts).with(/Error: .*foo/)
+    expect(infobar).to receive(:puts).with(/Error: .*foo/)
     progress.call(response)
   end
 end

data/spec/ollama/image_spec.rb

@@ -20,4 +20,8 @@ RSpec.describe Ollama::Image do
     expect(image.to_s.sum).to eq 42460
     expect(image.to_s[0, 40]).to eq '/9j/4AAQSkZJRgABAQAASABIAAD/4QBYRXhpZgAA'
   end
+
+  it 'tracks path of file' do
+    expect(image.path).to eq asset('kitten.jpg')
+  end
 end

data/spec/ollama/utils/fetcher_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+RSpec.describe Ollama::Utils::Fetcher do
+  let :url do
+    'https://www.example.com/hello'
+  end
+
+  let :fetcher do
+    described_class.new
+  end
+
+  it 'can be instantiated' do
+    expect(fetcher).to be_a described_class
+  end
+
+  it 'has .get' do
+    expect(described_class).to receive(:new).and_return double(get: true)
+    described_class.get(url)
+  end
+
+  it 'can #get with streaming' do
+    stub_request(:get, 'https://www.example.com/hello').
+      with(headers: fetcher.headers).
+      to_return(
+        status: 200,
+        body: 'world',
+        headers: { 'Content-Type' => 'text/plain' },
+      )
+    fetcher.get(url) do |tmp|
+      expect(tmp).to be_a Tempfile
+      expect(tmp.read).to eq 'world'
+      expect(tmp.content_type).to eq 'text/plain'
+    end
+  end
+
+  it 'can #get and fallback from streaming' do
+    stub_request(:get, 'https://www.example.com/hello').
+      with(headers: fetcher.headers).
+      to_return(
+        { status: 501 },
+        {
+          status: 200,
+          body: 'world',
+          headers: { 'Content-Type' => 'text/plain' },
+        }
+      )
+    fetcher.get(url) do |tmp|
+      expect(tmp).to be_a Tempfile
+      expect(tmp.read).to eq 'world'
+      expect(tmp.content_type).to eq 'text/plain'
+    end
+  end
+
+  it 'can #get and finally fail' do
+    stub_request(:get, 'https://www.example.com/hello').
+      with(headers: fetcher.headers).
+      to_return(status: 500)
+    fetcher.get(url) do |tmp|
+      expect(tmp).to be_nil
+    end
+  end
+
+  it 'can redirect' do
+    expect(fetcher.middlewares).to include Excon::Middleware::RedirectFollower
+  end
+
+  it 'can .read' do
+    described_class.read(__FILE__) do |file|
+      expect(file).to be_a File
+      expect(file.read).to include 'can .read'
+      expect(file.content_type).to eq 'application/x-ruby'
+    end
+  end
+end

data/spec/ollama/utils/tags_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+RSpec.describe Ollama::Utils::Tags do
+  it 'can be instantiated' do
+    expect(described_class.new).to be_a described_class
+  end
+
+  it 'can contain unique tags and is sorted' do
+    tags = described_class.new([ 'bar', 'foo'])
+    expect(tags.to_a).to eq %w[ bar foo ]
+  end
+
+  it 'tags can be added to it' do
+    tags = described_class.new([ 'foo' ])
+    tags.add 'bar'
+    expect(tags.to_a).to eq %w[ bar foo ]
+    tags.merge [ 'baz', 'baz2' ]
+    expect(tags.to_a).to eq %w[ bar baz baz2 foo ]
+  end
+
+  it 'can be output nicely' do
+    expect(described_class.new(%w[foo bar]).to_s).to eq '#bar #foo'
+  end
+end

data/spec/spec_helper.rb

@@ -9,8 +9,16 @@ begin
   require 'debug'
 rescue LoadError
 end
+require 'webmock/rspec'
+WebMock.disable_net_connect!
 require 'ollama'
 
 def asset(name)
   File.join(__dir__, 'assets', name)
 end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    infobar.show = nil
+  end
+end