Class: Geminize::ModelInfo

Inherits:
Object
  • Object
show all
Defined in:
lib/geminize/model_info.rb

Overview

Handles retrieving model information from the Gemini API

Constant Summary collapse

DEFAULT_PAGE_SIZE =

Default page size for listing models

50

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(client = nil, options = {}) ⇒ ModelInfo

Initialize a new ModelInfo instance

Parameters:

  • client (Geminize::Client, nil) (defaults to: nil) —

    The HTTP client to use

  • options (Hash) (defaults to: {}) —

    Additional options for the client



18
19
20
21
22
23
 
# File 'lib/geminize/model_info.rb', line 18

def initialize(client = nil, options = {})
  @client = client || Client.new(options)
  @cache = {}
  @cache_expiry = {}
  @cache_ttl = options[:cache_ttl] || 3600 # Default to 1 hour
end

Instance Attribute Details

#cache_ttl=(value) (writeonly)

This method returns an undefined value.

Set the cache time-to-live (TTL)

Parameters:

  • seconds (Integer) —

    TTL in seconds



168
169
170
 
# File 'lib/geminize/model_info.rb', line 168

def cache_ttl=(value)
  @cache_ttl = value
end

#client ⇒ Geminize::Client (readonly)

Returns The HTTP client.

Returns:



10
11
12
 
# File 'lib/geminize/model_info.rb', line 10

def client
  @client
end

Instance Method Details

#clear_cache

This method returns an undefined value.

Clear all cached model information



159
160
161
162
163
 
# File 'lib/geminize/model_info.rb', line 159

def clear_cache
  @cache = {}
  @cache_expiry = {}
  nil
end

#get_model(model_name, force_refresh: false) ⇒ Geminize::Models::Model

Get information about a specific model

Parameters:

  • model_name (String) —

    The model name to retrieve (models/model)

  • force_refresh (Boolean) (defaults to: false) —

    Force a refresh from the API instead of using cache

Returns:

Raises:



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/geminize/model_info.rb', line 106

def get_model(model_name, force_refresh: false)
  # Handle both formats: "models/gemini-2.0-flash" or just "gemini-2.0-flash"
  unless model_name.start_with?("models/")
    model_name = "models/#{model_name}"
  end

  cache_key = "model_#{model_name}"

  # Check if we have a valid cached result
  if !force_refresh && @cache[cache_key] && @cache_expiry[cache_key] > Time.now
    return @cache[cache_key]
  end

  # Make the API request
  begin
    response = client.get(model_name)

    # Create a Model from the response
    model = Models::Model.from_api_data(response)

    # Cache the result
    @cache[cache_key] = model
    @cache_expiry[cache_key] = Time.now + @cache_ttl

    model
  rescue Geminize::NotFoundError => e
    # Re-raise with a more descriptive message
    raise Geminize::NotFoundError.new("Model '#{model_name}' not found", e.code, e.http_status)
  end
end

#get_models_by_base_id(base_model_id, force_refresh: false) ⇒ Geminize::Models::ModelList

Get models by base model ID

Parameters:

  • base_model_id (String) —

    The base model ID to filter by

  • force_refresh (Boolean) (defaults to: false) —

    Force a refresh from the API instead of using cache

Returns:

Raises:



152
153
154
155
 
# File 'lib/geminize/model_info.rb', line 152

def get_models_by_base_id(base_model_id, force_refresh: false)
  all_models = list_all_models(force_refresh: force_refresh)
  all_models.filter_by_base_model_id(base_model_id)
end

#get_models_by_method(method, force_refresh: false) ⇒ Geminize::Models::ModelList

Get models that support a specific generation method

Parameters:

  • method (String) —

    The generation method (e.g., "generateContent", "embedContent")

  • force_refresh (Boolean) (defaults to: false) —

    Force a refresh from the API instead of using cache

Returns:

Raises:



142
143
144
145
 
# File 'lib/geminize/model_info.rb', line 142

def get_models_by_method(method, force_refresh: false)
  all_models = list_all_models(force_refresh: force_refresh)
  all_models.filter_by_method(method)
end

#list_all_models(force_refresh: false) ⇒ Geminize::Models::ModelList

Get all available models, handling pagination automatically

Parameters:

  • force_refresh (Boolean) (defaults to: false) —

    Force a refresh from the API instead of using cache

Returns:

Raises:



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/geminize/model_info.rb', line 61

def list_all_models(force_refresh: false)
  cache_key = "all_models_list"

  # Check if we have a valid cached result
  if !force_refresh && @cache[cache_key] && @cache_expiry[cache_key] > Time.now
    return @cache[cache_key]
  end

  all_models = []
  page_token = nil

  # Fetch first page
  model_list = list_models(
    page_size: DEFAULT_PAGE_SIZE,
    page_token: page_token,
    force_refresh: force_refresh
  )
  all_models.concat(model_list.models)

  # Fetch additional pages if available
  while model_list.has_more_pages?
    page_token = model_list.next_page_token
    model_list = list_models(
      page_size: DEFAULT_PAGE_SIZE,
      page_token: page_token,
      force_refresh: force_refresh
    )
    all_models.concat(model_list.models)
  end

  # Create a consolidated model list
  result = Models::ModelList.new(all_models)

  # Cache the result
  @cache[cache_key] = result
  @cache_expiry[cache_key] = Time.now + @cache_ttl

  result
end

#list_models(page_size: nil, page_token: nil, force_refresh: false) ⇒ Geminize::Models::ModelList

List available models from the Gemini API

Parameters:

  • page_size (Integer, nil) (defaults to: nil) —

    Number of models to return per page (max 1000)

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

    Token for retrieving a specific page

  • force_refresh (Boolean) (defaults to: false) —

    Force a refresh from the API instead of using cache

Returns:

Raises:



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/geminize/model_info.rb', line 31

def list_models(page_size: nil, page_token: nil, force_refresh: false)
  cache_key = "models_list_#{page_size}_#{page_token}"

  # Check if we have a valid cached result
  if !force_refresh && @cache[cache_key] && @cache_expiry[cache_key] > Time.now
    return @cache[cache_key]
  end

  # Prepare query parameters
  params = {}
  params[:pageSize] = page_size if page_size
  params[:pageToken] = page_token

  # Make the API request
  response = client.get("models", params)

  # Create a ModelList from the response
  model_list = Models::ModelList.from_api_data(response)

  # Cache the result
  @cache[cache_key] = model_list
  @cache_expiry[cache_key] = Time.now + @cache_ttl

  model_list
end