ollama-ruby 0.13.0 → 0.14.1

data/config/redis.conf

@@ -1,5 +0,0 @@
-save 60 1000
-dbfilename dump.rdb
-appendonly yes
-appendfilename "appendonly.aof"
-appendfsync always

data/docker-compose.yml

@@ -1,10 +0,0 @@
-services:
-  redis:
-    image: valkey/valkey:7.2.7-alpine
-    restart: unless-stopped
-    ports: [ "127.0.0.1:9736:6379" ]
-    volumes:
-      - "redis-data:/data:delegated"
-      - "./config/redis.conf:/etc/redis.conf"
-volumes:
-  redis-data:

data/lib/ollama/utils/cache_fetcher.rb

@@ -1,38 +0,0 @@
-require 'digest/md5'
-
-class Ollama::Utils::CacheFetcher
-  def initialize(cache)
-    @cache = cache
-  end
-
-  def get(url, &block)
-    block or raise ArgumentError, 'require block argument'
-    body         = @cache[key(:body, url)]
-    content_type = @cache[key(:content_type, url)]
-    content_type = MIME::Types[content_type].first
-    if body && content_type
-      io = StringIO.new(body)
-      io.rewind
-      io.extend(Ollama::Utils::Fetcher::HeaderExtension)
-      io.content_type = content_type
-      block.(io)
-    end
-  end
-
-  def put(url, io)
-    io.rewind
-    body = io.read
-    body.empty? and return
-    content_type = io.content_type
-    content_type.nil? and return
-    @cache.set(key(:body, url), body, ex: io.ex)
-    @cache.set(key(:content_type,  url), content_type.to_s, ex: io.ex)
-    self
-  end
-
-  private
-
-  def key(type, url)
-    [ type, Digest::MD5.hexdigest(url) ] * ?-
-  end
-end

data/lib/ollama/utils/chooser.rb

@@ -1,52 +0,0 @@
-require 'amatch'
-require 'search_ui'
-require 'term/ansicolor'
-
-module Ollama::Utils::Chooser
-  include SearchUI
-  include Term::ANSIColor
-
-  module_function
-
-  # The choose method presents a list of entries and prompts the user
-  # for input, allowing them to select one entry based on their input.
-  #
-  # @param entries [Array] the list of entries to present to the user
-  # @param prompt [String] the prompt message to display when asking for input (default: 'Search? %s')
-  # @param return_immediately [Boolean] whether to immediately return the first entry if there is only one or nil when there is none (default: false)
-  #
-  # @return [Object] the selected entry, or nil if no entry was chosen
-  #
-  # @example
-  #   choose(['entry1', 'entry2'], prompt: 'Choose an option:')
-  def choose(entries, prompt: 'Search? %s', return_immediately: false)
-    if return_immediately && entries.size <= 1
-      return entries.first
-    end
-    entry = Search.new(
-      prompt:,
-      match: -> answer {
-        matcher = Amatch::PairDistance.new(answer.downcase)
-        matches = entries.map { |n| [ n, -matcher.similar(n.to_s.downcase) ] }.
-          select { |_, s| s < 0 }.sort_by(&:last).map(&:first)
-        matches.empty? and matches = entries
-        matches.first(Tins::Terminal.lines - 1)
-      },
-      query: -> _answer, matches, selector {
-        matches.each_with_index.map { |m, i|
-          i == selector ? "#{blue{?⮕}} #{on_blue{m}}" : "  #{m.to_s}"
-        } * ?\n
-      },
-      found: -> _answer, matches, selector {
-        matches[selector]
-      },
-      output: STDOUT
-    ).start
-    if entry
-      entry
-    else
-      print clear_screen, move_home
-      nil
-    end
-  end
-end

data/lib/ollama/utils/fetcher.rb

@@ -1,175 +0,0 @@
-require 'tempfile'
-require 'tins/unit'
-require 'infobar'
-require 'mime-types'
-require 'stringio'
-require 'ollama/utils/cache_fetcher'
-
-class Ollama::Utils::Fetcher
-  module HeaderExtension
-    attr_accessor :content_type
-
-    attr_accessor :ex
-
-    def self.failed
-      object = StringIO.new.extend(self)
-      object.content_type = MIME::Types['text/plain'].first
-      object
-    end
-  end
-
-  class RetryWithoutStreaming < StandardError; end
-
-  def self.get(url, **options, &block)
-    cache = options.delete(:cache) and
-      cache = Ollama::Utils::CacheFetcher.new(cache)
-    if result = cache&.get(url, &block)
-      infobar.puts "Getting #{url.to_s.inspect} from cache."
-      return result
-    else
-      new(**options).send(:get, url) do |tmp|
-        result = block.(tmp)
-        if cache && !tmp.is_a?(StringIO)
-          tmp.rewind
-          cache.put(url, tmp)
-        end
-        result
-      end
-    end
-  end
-
-  def self.normalize_url(url)
-    url = url.to_s
-    url = URI.decode_uri_component(url)
-    url = url.sub(/#.*/, '')
-    URI::Parser.new.escape(url).to_s
-  end
-
-  def self.read(filename, &block)
-    if File.exist?(filename)
-      File.open(filename) do |file|
-        file.extend(Ollama::Utils::Fetcher::HeaderExtension)
-        file.content_type = MIME::Types.type_for(filename).first
-        block.(file)
-      end
-    else
-      STDERR.puts "File #{filename.to_s.inspect} doesn't exist."
-    end
-  end
-
-  def self.execute(command, &block)
-    Tempfile.open do |tmp|
-      IO.popen(command) do |command|
-        until command.eof?
-          tmp.write command.read(1 << 14)
-        end
-        tmp.rewind
-        tmp.extend(Ollama::Utils::Fetcher::HeaderExtension)
-        tmp.content_type = MIME::Types['text/plain'].first
-        block.(tmp)
-      end
-    end
-  rescue => e
-    STDERR.puts "Cannot execute #{command.inspect} (#{e})"
-    if @debug && !e.is_a?(RuntimeError)
-      STDERR.puts "#{e.backtrace * ?\n}"
-    end
-    yield HeaderExtension.failed
-  end
-
-  def initialize(debug: false, http_options: {})
-    @debug        = debug
-    @started      = false
-    @streaming    = true
-    @http_options = http_options
-  end
-
-  private
-
-  def excon(url, **options)
-    url = self.class.normalize_url(url)
-    Excon.new(url, options.merge(@http_options))
-  end
-
-  def get(url, &block)
-    response = nil
-    Tempfile.open do |tmp|
-      infobar.label = 'Getting'
-      if @streaming
-        response = excon(url, headers:, response_block: callback(tmp)).request(method: :get)
-        response.status != 200 || !@started and raise RetryWithoutStreaming
-        decorate_io(tmp, response)
-        infobar.finish
-        block.(tmp)
-      else
-        response = excon(url, headers:, middlewares:).request(method: :get)
-        if response.status != 200
-          raise "invalid response status code"
-        end
-        body = response.body
-        tmp.print body
-        infobar.update(message: message(body.size, body.size), force: true)
-        decorate_io(tmp, response)
-        infobar.finish
-        block.(tmp)
-      end
-    end
-  rescue RetryWithoutStreaming
-    @streaming = false
-    retry
-  rescue => e
-    STDERR.puts "Cannot get #{url.to_s.inspect} (#{e}): #{response&.status_line || 'n/a'}"
-    if @debug && !e.is_a?(RuntimeError)
-      STDERR.puts "#{e.backtrace * ?\n}"
-    end
-    yield HeaderExtension.failed
-  end
-
-  def headers
-    {
-      'User-Agent' => Ollama::Client.user_agent,
-    }
-  end
-
-  def middlewares
-    (Excon.defaults[:middlewares] + [ Excon::Middleware::RedirectFollower ]).uniq
-  end
-
-  private
-
-  def decorate_io(tmp, response)
-    tmp.rewind
-    tmp.extend(HeaderExtension)
-    if content_type = MIME::Types[response.headers['content-type']].first
-      tmp.content_type = content_type
-    end
-    if cache_control = response.headers['cache-control'] and
-        cache_control !~ /no-store|no-cache/ and
-        ex = cache_control[/s-maxage\s*=\s*(\d+)/, 1] || cache_control[/max-age\s*=\s*(\d+)/, 1]
-    then
-      tmp.ex = ex.to_i
-    end
-  end
-
-  def callback(tmp)
-    -> chunk, remaining_bytes, total_bytes do
-      total   = total_bytes or next
-      current = total_bytes - remaining_bytes
-      if @started
-        infobar.counter.progress(by: total - current)
-      else
-        @started = true
-        infobar.counter.reset(total:, current:)
-      end
-      infobar.update(message: message(current, total), force: true)
-      tmp.print(chunk)
-    end
-  end
-
-  def message(current, total)
-    progress = '%s/%s' % [ current, total ].map {
-      Tins::Unit.format(_1, format: '%.2f %U')
-    }
-    '%l ' + progress + ' in %te, ETA %e @%E'
-  end
-end

data/lib/ollama/utils/file_argument.rb

@@ -1,34 +0,0 @@
-module Ollama::Utils::FileArgument
-  module_function
-
-  # Returns the contents of a file or string, or a default value if neither is provided.
-  #
-  # @param [String] path_or_content The path to a file or a string containing
-  #                 the content.
-  #
-  # @param [String] default The default value to return if no valid input is
-  #                 given. Defaults to nil.
-  #
-  # @return [String] The contents of the file, the string, or the default value.
-  #
-  # @example Get the contents of a file
-  #   get_file_argument('path/to/file')
-  #
-  # @example Use a string as content
-  #   get_file_argument('string content')
-  #
-  # @example Return a default value if no valid input is given
-  #   get_file_argument(nil, default: 'default content')
-  def get_file_argument(path_or_content, default: nil)
-    if path_or_content.present? && path_or_content.size < 2 ** 15 &&
-        File.basename(path_or_content).size < 2 ** 8 &&
-        File.exist?(path_or_content)
-    then
-      File.read(path_or_content)
-    elsif path_or_content.present?
-      path_or_content
-    else
-      default
-    end
-  end
-end

data/spec/assets/prompt.txt

@@ -1 +0,0 @@
-You are a test prompt just used for testing.

data/spec/ollama/utils/cache_fetcher_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Ollama::Utils::CacheFetcher do
-  let :url do
-    'https://www.example.com/hello'
-  end
-
-  let :cache do
-    double('RedisCache')
-  end
-
-  let :fetcher do
-    described_class.new(cache).expose
-  end
-
-  it 'can be instantiated' do
-    expect(fetcher).to be_a described_class
-  end
-
-  it 'has #get' do
-    expect(cache).to receive(:[]).with('body-69ce405ab83f42dffa9fd22bbd47783f').and_return 'world'
-    expect(cache).to receive(:[]).with('content_type-69ce405ab83f42dffa9fd22bbd47783f').and_return 'text/plain'
-    yielded_io = nil
-    block = -> io { yielded_io = io }
-    fetcher.get(url, &block)
-    expect(yielded_io).to be_a StringIO
-    expect(yielded_io.read).to eq 'world'
-  end
-
-  it '#get needs block' do
-    expect { fetcher.get(url) }.to raise_error(ArgumentError)
-  end
-
-  it 'has #put' do
-    io = StringIO.new('world')
-    io.extend(Ollama::Utils::Fetcher::HeaderExtension)
-    io.content_type = MIME::Types['text/plain'].first
-    io.ex = 666
-    expect(cache).to receive(:set).with('body-69ce405ab83f42dffa9fd22bbd47783f', 'world', ex: 666)
-    expect(cache).to receive(:set).with('content_type-69ce405ab83f42dffa9fd22bbd47783f', 'text/plain', ex: 666)
-    fetcher.put(url, io)
-  end
-end

data/spec/ollama/utils/fetcher_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Ollama::Utils::Fetcher do
-  let :url do
-    'https://www.example.com/hello'
-  end
-
-  let :fetcher do
-    described_class.new.expose
-  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, url).
-      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 without ssl peer verification' do
-    fetcher = described_class.new(
-      http_options: { ssl_verify_peer: false }
-    ).expose
-    stub_request(:get, url).
-      with(headers: fetcher.headers).
-      to_return(
-        status: 200,
-        body: 'world',
-        headers: { 'Content-Type' => 'text/plain' },
-      )
-    expect(Excon).to receive(:new).with(
-      url,
-      hash_including(ssl_verify_peer: false)
-    ).and_call_original
-    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, url).
-      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, url).
-      with(headers: fetcher.headers).
-      to_return(status: 500)
-    expect(STDERR).to receive(:puts).with(/cannot.*get.*#{url}/i)
-      fetcher.get(url) do |tmp|
-        expect(tmp).to be_a StringIO
-        expect(tmp.read).to eq ''
-        expect(tmp.content_type).to eq 'text/plain'
-      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
-
-  it 'can .execute' do
-    described_class.execute('echo -n hello world') do |file|
-      expect(file).to be_a Tempfile
-      expect(file.read).to eq 'hello world'
-      expect(file.content_type).to eq 'text/plain'
-    end
-  end
-
-  it 'can .execute and fail' do
-    expect(IO).to receive(:popen).and_raise StandardError
-    expect(STDERR).to receive(:puts).with(/cannot.*execute.*foobar/i)
-    described_class.execute('foobar') do |file|
-      expect(file).to be_a StringIO
-      expect(file.read).to be_empty
-      expect(file.content_type).to eq 'text/plain'
-    end
-  end
-
-  describe '.normalize_url' do
-    it 'can handle umlauts' do
-      expect(described_class.normalize_url('https://foo.de/bär')).to eq(
-        'https://foo.de/b%C3%A4r'
-      )
-    end
-
-    it 'can handle escaped umlauts' do
-      expect(described_class.normalize_url('https://foo.de/b%C3%A4r')).to eq(
-        'https://foo.de/b%C3%A4r'
-      )
-    end
-
-    it 'can remove #anchors' do
-      expect(described_class.normalize_url('https://foo.de#bar')).to eq(
-        'https://foo.de'
-      )
-    end
-  end
-end

data/spec/ollama/utils/file_argument_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Ollama::Utils::FileArgument do
-  it 'it can return content' do
-    expect(described_class.get_file_argument('foo')).to eq 'foo'
-  end
-
-  it 'it can return content at path' do
-    expect(described_class.get_file_argument(asset('prompt.txt'))).to include\
-      'test prompt'
-  end
-
-  it 'it can return default content' do
-    expect(described_class.get_file_argument('', default: 'foo')).to eq 'foo'
-    expect(described_class.get_file_argument(nil, default: 'foo')).to eq 'foo'
-  end
-end