ollama-ruby 0.12.1 → 0.14.0

data/lib/ollama/documents.rb

@@ -1,184 +0,0 @@
-require 'numo/narray'
-require 'digest'
-require 'kramdown/ansi'
-
-class Ollama::Documents
-end
-module Ollama::Documents::Cache
-end
-require 'ollama/documents/cache/records'
-require 'ollama/documents/cache/memory_cache'
-require 'ollama/documents/cache/redis_cache'
-require 'ollama/documents/cache/redis_backed_memory_cache'
-require 'ollama/documents/cache/sqlite_cache'
-module Ollama::Documents::Splitters
-end
-require 'ollama/documents/splitters/character'
-require 'ollama/documents/splitters/semantic'
-
-class Ollama::Documents
-  include Kramdown::ANSI::Width
-  include Ollama::Documents::Cache
-
-  Record = Class.new Ollama::Documents::Cache::Records::Record
-
-  def initialize(ollama:, model:, model_options: nil, collection: nil, embedding_length: 1_024, cache: MemoryCache, database_filename: nil, redis_url: nil, debug: false)
-    collection ||= default_collection
-    @ollama, @model, @model_options, @collection, @debug =
-      ollama, model, model_options, collection.to_sym, debug
-    database_filename ||= ':memory:'
-    @cache = connect_cache(cache, redis_url, embedding_length, database_filename)
-  end
-
-  def default_collection
-    :default
-  end
-
-  attr_reader :ollama, :model, :collection, :cache
-
-  def collection=(new_collection)
-    @collection   = new_collection.to_sym
-    @cache.prefix = prefix
-  end
-
-  def add(inputs, batch_size: nil, source: nil, tags: [])
-    inputs = Array(inputs)
-    batch_size ||= 10
-    tags = Ollama::Utils::Tags.new(tags, source:)
-    if source
-      tags.add(File.basename(source).gsub(/\?.*/, ''), source:)
-    end
-    inputs.map! { |i|
-      text = i.respond_to?(:read) ? i.read : i.to_s
-      text
-    }
-    inputs.reject! { |i| exist?(i) }
-    inputs.empty? and return self
-    if @debug
-      puts Ollama::Utils::ColorizeTexts.new(inputs)
-    end
-    batches = inputs.each_slice(batch_size).
-      with_infobar(
-        label: "Add #{truncate(tags.to_s(link: false), percentage: 25)}",
-        total: inputs.size
-      )
-    batches.each do |batch|
-      embeddings = fetch_embeddings(model:, options: @model_options, input: batch)
-      batch.zip(embeddings) do |text, embedding|
-        norm       = @cache.norm(embedding)
-        self[text] = Record[text:, embedding:, norm:, source:, tags: tags.to_a]
-      end
-      infobar.progress by: batch.size
-    end
-    infobar.newline
-    self
-  end
-  alias << add
-
-  def [](text)
-    @cache[key(text)]
-  end
-
-  def []=(text, record)
-    @cache[key(text)] = record
-  end
-
-  def exist?(text)
-    @cache.key?(key(text))
-  end
-
-  def delete(text)
-    @cache.delete(key(text))
-  end
-
-  def size
-    @cache.size
-  end
-
-  def clear(tags: nil)
-    @cache.clear(tags:)
-    self
-  end
-
-  def find(string, tags: nil, prompt: nil, max_records: nil)
-    needle = convert_to_vector(string, prompt:)
-    @cache.find_records(needle, tags:, max_records: nil)
-  end
-
-  def find_where(string, text_size: nil, text_count: nil, **opts)
-    if text_count
-      opts[:max_records] =  text_count
-    end
-    records = find(string, **opts)
-    size, count = 0, 0
-    records.take_while do |record|
-      if text_size and (size += record.text.size) > text_size
-        next false
-      end
-      if text_count and (count += 1) > text_count
-        next false
-      end
-      true
-    end
-  end
-
-  def collections
-    ([ default_collection ] + @cache.collections('%s-' % self.class)).uniq
-  end
-
-  def tags
-    @cache.tags
-  end
-
-  private
-
-  def connect_cache(cache_class, redis_url, embedding_length, database_filename)
-    cache = nil
-    if (cache_class.instance_method(:redis) rescue nil)
-      begin
-        cache = cache_class.new(prefix:, url: redis_url, object_class: Record)
-        cache.size
-      rescue Redis::CannotConnectError
-        STDERR.puts(
-          "Cannot connect to redis URL #{redis_url.inspect}, "\
-          "falling back to MemoryCache."
-        )
-      end
-    elsif cache_class == SQLiteCache
-      cache = cache_class.new(
-        prefix:,
-        embedding_length:,
-        filename: database_filename,
-        debug: @debug
-      )
-    end
-  ensure
-    cache ||= MemoryCache.new(prefix:,)
-    cache.respond_to?(:find_records) or cache.extend(Records::FindRecords)
-    cache.extend(Records::Tags)
-    if cache.respond_to?(:redis)
-      cache.extend(Records::RedisFullEach)
-    end
-    return cache
-  end
-
-  def convert_to_vector(input, prompt: nil)
-    if prompt
-      input = prompt % input
-    end
-    input.is_a?(String) and input = fetch_embeddings(model:, input:).first
-    @cache.convert_to_vector(input)
-  end
-
-  def fetch_embeddings(model:, input:, options: nil)
-    @ollama.embed(model:, input:, options:).embeddings
-  end
-
-  def prefix
-    '%s-%s-' % [ self.class, @collection ]
-  end
-
-  def key(input)
-    Digest::SHA256.hexdigest(input)
-  end
-end

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/colorize_texts.rb

@@ -1,65 +0,0 @@
-require 'term/ansicolor'
-require 'kramdown/ansi'
-
-class Ollama::Utils::ColorizeTexts
-  include Math
-  include Term::ANSIColor
-  include Kramdown::ANSI::Width
-
-  # Initializes a new instance of Ollama::Utils::ColorizeTexts
-  #
-  # @param [Array<String>] texts the array of strings to be displayed with colors
-  #
-  # @return [Ollama::Utils::ColorizeTexts] an instance of Ollama::Utils::ColorizeTexts
-  def initialize(*texts)
-    texts  = texts.map(&:to_a)
-    @texts = Array(texts.flatten)
-  end
-
-  # Returns a string representation of the object, including all texts content,
-  # colored differently and their sizes.
-  #
-  # @return [String] The formatted string.
-  def to_s
-    result = +''
-    @texts.each_with_index do |t, i|
-      color = colors[(t.hash ^ i.hash) % colors.size]
-      wrap(t, percentage: 90).each_line { |l|
-        result << on_color(color) { color(text_color(color)) { l } }
-      }
-      result << "\n##{bold{t.size.to_s}} \n\n"
-    end
-    result
-  end
-
-  private
-
-  # Returns the nearest RGB color to the given ANSI color
-  #
-  # @param [color] color The ANSI color attribute
-  #
-  # @return [Array<RGBTriple>] An array containing two RGB colors, one for black and
-  #   one for white text, where the first is the closest match to the input color
-  #   when printed on a black background, and the second is the closest match
-  #   when printed on a white background.
-  def text_color(color)
-    color = Term::ANSIColor::Attribute[color]
-    [
-      Attribute.nearest_rgb_color('#000'),
-      Attribute.nearest_rgb_color('#fff'),
-    ].max_by { |t| t.distance_to(color) }
-  end
-
-  # Returns an array of colors for each step in the gradient
-  #
-  # @return [Array<Array<Integer>>] An array of RGB color arrays
-  def colors
-    @colors ||= (0..255).map { |i|
-      [
-        128 + 128 * sin(PI * i / 32.0),
-        128 + 128 * sin(PI * i / 64.0),
-        128 + 128 * sin(PI * i / 128.0),
-      ].map { _1.clamp(0, 255).round }
-    }
-  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/lib/ollama/utils/math.rb

@@ -1,48 +0,0 @@
-module Ollama::Utils::Math
-  # Returns the cosine similarity between two vectors +a+ and +b+, 1.0 is
-  # exactly the same, 0.0 means decorrelated.
-  #
-  # @param [Vector] a The first vector
-  # @param [Vector] b The second vector
-  # @option a_norm [Float] a The Euclidean norm of vector a (default: calculated from a)
-  # @option b_norm [Float] b The Euclidean norm of vector b (default: calculated from b)
-  #
-  # @return [Float] The cosine similarity between the two vectors
-  #
-  # @example Calculate the cosine similarity between two vectors
-  #   cosine_similarity(a: [1, 2], b: [3, 4])
-  #
-  # @see #convert_to_vector
-  # @see #norm
-  def cosine_similarity(a:, b:, a_norm: norm(a), b_norm: norm(b))
-    a, b = convert_to_vector(a), convert_to_vector(b)
-    a.dot(b) / (a_norm * b_norm)
-  end
-
-  # Returns the Euclidean norm (magnitude) of a vector.
-  #
-  # @param vector [Array] The input vector.
-  #
-  # @return [Float] The magnitude of the vector.
-  #
-  # @example
-  #   norm([3, 4]) # => 5.0
-  def norm(vector)
-    s = 0.0
-    vector.each { s += _1.abs2 }
-    Math.sqrt(s)
-  end
-
-  # Converts an array to a Numo NArray.
-  #
-  # @param [Array] vector The input array to be converted.
-  #
-  # @return [Numo::NArray] The converted NArray, or the original if it's already a Numo NArray.
-  #
-  # @example Convert an array to a Numo NArray
-  #   convert_to_vector([1, 2, 3]) # => Numo::NArray[1, 2, 3]
-  def convert_to_vector(vector)
-    vector.is_a?(Numo::NArray) and return vector
-    Numo::NArray[*vector]
-  end
-end

data/lib/ollama/utils/tags.rb

@@ -1,67 +0,0 @@
-class Ollama::Utils::Tags
-  class Tag < String
-    include Term::ANSIColor
-
-    def initialize(tag, source: nil)
-      super(tag.to_s.gsub(/\A#+/, ''))
-      self.source = source
-    end
-
-    attr_accessor :source
-
-    alias_method :internal, :to_s
-
-    def to_s(link: true)
-      tag_string = start_with?(?#) ? super() : ?# + super()
-      my_source  = source
-      if link && my_source
-        unless my_source =~ %r(\A(https?|file)://)
-          my_source = 'file://%s' % File.expand_path(my_source)
-        end
-        hyperlink(my_source) { tag_string }
-      else
-        tag_string
-      end
-    end
-  end
-
-  def initialize(tags = [], source: nil)
-    tags = Array(tags)
-    @set = []
-    tags.each { |tag| add(tag, source:) }
-  end
-
-  def add(tag, source: nil)
-    unless tag.is_a?(Tag)
-      tag = Tag.new(tag, source:)
-    end
-    index = @set.bsearch_index { _1 >= tag }
-    if index == nil
-      @set.push(tag)
-    elsif @set.at(index) != tag
-      @set.insert(index, tag)
-    end
-    self
-  end
-
-  def empty?
-    @set.empty?
-  end
-
-  def size
-    @set.size
-  end
-
-  def clear
-    @set.clear
-  end
-
-  def each(&block)
-    @set.each(&block)
-  end
-  include Enumerable
-
-  def to_s(link: true)
-    @set.map { |tag| tag.to_s(link:) } * ' '
-  end
-end