Class: Geminize::Models::ModelList

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
Enumerable
Defined in:
lib/geminize/models/model_list.rb

Overview

Represents a collection of AI models with filtering capabilities

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(models = [], next_page_token = nil) ⇒ ModelList

Create a new ModelList

Parameters:

  • models (Array<Model>) (defaults to: []) —

    Initial list of models

  • next_page_token (String, nil) (defaults to: nil) —

    Token for fetching the next page



24
25
26
27
 
# File 'lib/geminize/models/model_list.rb', line 24

def initialize(models = [], next_page_token = nil)
  @models = models
  @next_page_token = next_page_token
end

Instance Attribute Details

#models ⇒ Array<Model> (readonly)

Returns The list of models.

Returns:

  • (Array<Model>) —

    The list of models



13
14
15
 
# File 'lib/geminize/models/model_list.rb', line 13

def models
  @models
end

#next_page_token ⇒ String? (readonly)

Returns Token for fetching the next page of results.

Returns:

  • (String, nil) —

    Token for fetching the next page of results



16
17
18
 
# File 'lib/geminize/models/model_list.rb', line 16

def next_page_token
  @next_page_token
end

Class Method Details

.from_api_data(data) ⇒ ModelList

Create a ModelList from API response data

Parameters:

  • data (Hash) —

    API response containing models

Returns:



133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/geminize/models/model_list.rb', line 133

def self.from_api_data(data)
  models = []
  next_page_token = data["nextPageToken"]

  # Process model data from API response
  if data.key?("models")
    models = data["models"].map do |model_data|
      Model.from_api_data(model_data)
    end
  end

  new(models, next_page_token)
end

Instance Method Details

#add(model) ⇒ ModelList

Add a model to the list

Parameters:

  • model (Model) —

    The model to add

Returns:



38
39
40
41
 
# File 'lib/geminize/models/model_list.rb', line 38

def add(model)
  @models << model
  self
end

#chat_models ⇒ ModelList

Find all models that support chat/conversation

Returns:

  • (ModelList) —

    A new ModelList containing only chat-capable models



85
86
87
 
# File 'lib/geminize/models/model_list.rb', line 85

def chat_models
  filter_by_method("generateMessage")
end

#content_generation_models ⇒ ModelList

Find all models that support content generation

Returns:

  • (ModelList) —

    A new ModelList containing only content generation capable models



67
68
69
 
# File 'lib/geminize/models/model_list.rb', line 67

def content_generation_models
  filter_by_method("generateContent")
end

#each {|Model| ... } ⇒ Object

Implement Enumerable's required each method

Yields:

  • (Model) —

    Each model in the list



31
32
33
 
# File 'lib/geminize/models/model_list.rb', line 31

def each(&block)
  @models.each(&block)
end

#embedding_models ⇒ ModelList

Find all models that support embeddings

Returns:

  • (ModelList) —

    A new ModelList containing only embedding-capable models



79
80
81
 
# File 'lib/geminize/models/model_list.rb', line 79

def embedding_models
  filter_by_method("embedContent")
end

#filter_by_base_model_id(base_model_id) ⇒ ModelList

Filter models by base model ID

Parameters:

  • base_model_id (String) —

    The base model ID to filter by

Returns:

  • (ModelList) —

    A new ModelList containing only matching models



109
110
111
112
 
# File 'lib/geminize/models/model_list.rb', line 109

def filter_by_base_model_id(base_model_id)
  filtered = @models.select { |model| model.base_model_id == base_model_id }
  ModelList.new(filtered, nil)
end

#filter_by_display_name(pattern) ⇒ ModelList

Filter models by display name pattern

Parameters:

  • pattern (String, Regexp) —

    The pattern to match model display names against

Returns:

  • (ModelList) —

    A new ModelList containing only matching models



100
101
102
103
104
 
# File 'lib/geminize/models/model_list.rb', line 100

def filter_by_display_name(pattern)
  pattern = Regexp.new(pattern.to_s, Regexp::IGNORECASE) if pattern.is_a?(String)
  filtered = @models.select { |model| model.display_name&.match?(pattern) }
  ModelList.new(filtered, nil)
end

#filter_by_method(method) ⇒ ModelList

Find all models that support a specific generation method

Parameters:

  • method (String) —

    The generation method to filter by

Returns:

  • (ModelList) —

    A new ModelList containing only matching models



60
61
62
63
 
# File 'lib/geminize/models/model_list.rb', line 60

def filter_by_method(method)
  filtered = @models.select { |model| model.supports_method?(method) }
  ModelList.new(filtered, nil)
end

#filter_by_min_input_tokens(min_limit) ⇒ ModelList

Find models with a minimum input token limit

Parameters:

  • min_limit (Integer) —

    The minimum input token limit

Returns:

  • (ModelList) —

    A new ModelList containing only matching models



117
118
119
120
 
# File 'lib/geminize/models/model_list.rb', line 117

def filter_by_min_input_tokens(min_limit)
  filtered = @models.select { |model| model.input_token_limit && model.input_token_limit >= min_limit }
  ModelList.new(filtered, nil)
end

#filter_by_min_output_tokens(min_limit) ⇒ ModelList

Find models with a minimum output token limit

Parameters:

  • min_limit (Integer) —

    The minimum output token limit

Returns:

  • (ModelList) —

    A new ModelList containing only matching models



125
126
127
128
 
# File 'lib/geminize/models/model_list.rb', line 125

def filter_by_min_output_tokens(min_limit)
  filtered = @models.select { |model| model.output_token_limit && model.output_token_limit >= min_limit }
  ModelList.new(filtered, nil)
end

#filter_by_version(version) ⇒ ModelList

Filter models by version

Parameters:

  • version (String) —

    The version to filter by

Returns:

  • (ModelList) —

    A new ModelList containing only matching models



92
93
94
95
 
# File 'lib/geminize/models/model_list.rb', line 92

def filter_by_version(version)
  filtered = @models.select { |model| model.version == version }
  ModelList.new(filtered, nil)
end

#find_by_id(id) ⇒ Model?

Find a model by its ID (last part of the resource name)

Parameters:

  • id (String) —

    The model ID to search for

Returns:

  • (Model, nil) —

    The found model or nil



53
54
55
 
# File 'lib/geminize/models/model_list.rb', line 53

def find_by_id(id)
  @models.find { |model| model.id == id }
end

#find_by_name(name) ⇒ Model?

Find a model by its resource name

Parameters:

  • name (String) —

    The model name to search for

Returns:

  • (Model, nil) —

    The found model or nil



46
47
48
 
# File 'lib/geminize/models/model_list.rb', line 46

def find_by_name(name)
  @models.find { |model| model.name == name }
end

#has_more_pages? ⇒ Boolean

Check if there are more pages of results available

Returns:

  • (Boolean) —

    True if there are more pages



149
150
151
 
# File 'lib/geminize/models/model_list.rb', line 149

def has_more_pages?
  !next_page_token.nil? && !next_page_token.empty?
end

#streaming_models ⇒ ModelList

Find all models that support streaming content generation

Returns:

  • (ModelList) —

    A new ModelList containing only streaming capable models



73
74
75
 
# File 'lib/geminize/models/model_list.rb', line 73

def streaming_models
  filter_by_method("streamGenerateContent")
end

#to_a ⇒ Array<Hash>

Convert to array of hashes representation

Returns:

  • (Array<Hash>) —

    Array of model hashes



155
156
157
 
# File 'lib/geminize/models/model_list.rb', line 155

def to_a
  @models.map(&:to_h)
end

#to_json(*args) ⇒ String

Convert to JSON string

Returns:

  • (String) —

    JSON representation



161
162
163
 
# File 'lib/geminize/models/model_list.rb', line 161

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