Module: Ollama::DTO

Extended by:
Tins::Concern
Includes:
Tins::DeepTransform
Included in:
Client::Configuration::Config, Commands::Chat, Commands::Copy, Commands::Create, Commands::Delete, Commands::Embed, Commands::Embeddings, Commands::Generate, Commands::Pull, Commands::Push, Commands::Show, Message, Options, Tool, Tool::Function, Tool::Function::Parameters, Tool::Function::Parameters::Property
Defined in:
lib/ollama/dto.rb

Overview

A module that provides a foundation for data transfer objects (DTOs) within the Ollama library.

The DTO module includes common functionality for converting objects to and from JSON, handling attribute management, and providing utility methods for processing arrays and hashes. It serves as a base class for various command and data structures used in communicating with the Ollama API.

Examples:

Using DTO functionality in a command class

class MyCommand
  include Ollama::DTO
  attr_reader :name, :value
  def initialize(name:, value:)
    @name, @value = name, value
  end
end

Instance Method Summary collapse

Instance Method Details

#==(other) ⇒ TrueClass, FalseClass

The == method compares two objects for equality based on their JSON representation.

This method checks if the JSON representation of the current object is equal to the JSON representation of another object.



157
158
159
 
# File 'lib/ollama/dto.rb', line 157

def ==(other)
  as_json == other.as_json
end

#as_array(obj) ⇒ Array?

The as_array method converts an object into an array representation.

If the object is nil, it returns nil. If the object responds to to_ary, it calls to_ary and returns the result. Otherwise, it wraps the object in an array and returns it.



110
111
112
113
114
115
116
117
118
 
# File 'lib/ollama/dto.rb', line 110

def as_array(obj)
  if obj.nil?
    obj
  elsif obj.respond_to?(:to_ary)
    obj.to_ary
  else
    [ obj ]
  end
end

#as_array_of_hashes(obj) ⇒ Array<Hash>?

The as_array_of_hashes method converts an object into an array of hashes.

If the object responds to to_hash, it wraps the result in an array. If the object responds to to_ary, it maps each element to a hash and returns the resulting array.



79
80
81
82
83
84
85
 
# File 'lib/ollama/dto.rb', line 79

def as_array_of_hashes(obj)
  if obj.respond_to?(:to_hash)
    [ obj.to_hash ]
  elsif obj.respond_to?(:to_ary)
    obj.to_ary.map(&:to_hash)
  end
end

#as_hash(obj) ⇒ Hash?

The as_hash method converts an object to a hash representation.

If the object responds to to_hash, it returns the result of that method call. If the object does not respond to to_hash, it returns nil.



96
97
98
 
# File 'lib/ollama/dto.rb', line 96

def as_hash(obj)
  obj&.to_hash
end

#as_json(*ignored) ⇒ Hash

The as_json method converts the object's attributes into a JSON-compatible hash.

This method leverages Tins::HashTransform to recursively collapse the DTO tree into pure Ruby primitives (Hashes and Arrays), ensuring that no DTO objects remain in the final output.



143
144
145
 
# File 'lib/ollama/dto.rb', line 143

def as_json(*ignored)
  deep_transform(circular: "[Circular Reference]")
end

#empty? ⇒ TrueClass, FalseClass

The empty? method checks whether the object has any attributes defined.

This method determines if the object contains no attributes by checking if its hash representation is empty. This is typically used to verify if an object, such as a DTO, has been initialized with any values.



169
170
171
 
# File 'lib/ollama/dto.rb', line 169

def empty?
  to_hash.empty?
end

#to_hash(*ignored) ⇒ Hash

The to_hash method converts the object's attributes into a JSON-compatible hash representation without recursing into child objects.

This provides a "shallow" view of the DTO, excluding any nil values or empty collections.



129
130
131
132
 
# File 'lib/ollama/dto.rb', line 129

def to_hash(*ignored)
  self.class.attributes.each_with_object({}) { |a, h| h[a] = send(a) }.
    reject { _2.nil? || _2.ask_and_send(:size) == 0 }
end

#to_json(*args) ⇒ String

The to_json method converts the object's JSON representation into a JSON string format.

This method utilizes the object's existing as_json representation and applies the standard JSON serialization to produce a formatted JSON string output.



182
183
184
 
# File 'lib/ollama/dto.rb', line 182

def to_json(*args)
  as_json.to_json(*args)
end