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.

Parameters:

  • other (Object) —

    the object to compare against

Returns:

  • (TrueClass, FalseClass) —

    true if both objects have identical JSON representations, false otherwise



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.

Parameters:

  • obj (Object) —

    the object to be converted to an array

Returns:

  • (Array, nil) —

    an array containing the object or its elements, or nil if the input is nil



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.

Parameters:

  • obj (Object) —

    the object to be converted

Returns:

  • (Array<Hash>, nil) —

    an array of hashes if the conversion was possible, or nil otherwise



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.

Parameters:

  • obj (Object) —

    the object to be converted to a hash

Returns:

  • (Hash, nil) —

    the hash representation of the object or nil if the object does not respond to to_hash



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.

Parameters:

  • ignored (Array) —

    ignored arguments

Returns:

  • (Hash) —

    a fully collapsed hash containing the object's attributes



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.

Returns:

  • (TrueClass, FalseClass) —

    true if the object has no attributes, false otherwise



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.

Parameters:

  • ignored (Array) —

    ignored arguments

Returns:

  • (Hash) —

    a shallow hash containing the object's non-nil and non-empty attributes



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.

Parameters:

  • args (Array) —

    pass-through args

Returns:

  • (String) —

    a JSON string representation of the object



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

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