geminize 1.1.0 → 1.3.0

data/examples/code_execution.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "geminize"
+
+# Configure the API key
+Geminize.configure do |config|
+  config.api_key = ENV["GEMINI_API_KEY"] # Make sure to set your API key in the environment
+  config.default_model = "gemini-2.0-flash" # Use a model that supports code execution
+end
+
+puts "==========================================="
+puts "=    GEMINIZE CODE EXECUTION EXAMPLES     ="
+puts "==========================================="
+
+puts "\n=== BASIC CODE EXECUTION EXAMPLE ==="
+puts "Asking Gemini to calculate the sum of the first 50 prime numbers..."
+
+begin
+  # Generate a response with code execution enabled
+  response = Geminize.generate_with_code_execution(
+    "What is the sum of the first 50 prime numbers? Generate and run code for the calculation, and make sure you get all 50.",
+    nil,
+    {temperature: 0.2}
+  )
+
+  # Display the generated text
+  puts "\nGemini's response:"
+  puts response.text
+
+  # Display the executable code if present
+  if response.has_executable_code?
+    puts "\nGenerated code:"
+    puts "```#{response.executable_code.language.downcase}"
+    puts response.executable_code.code
+    puts "```"
+  end
+
+  # Display the code execution result if present
+  if response.has_code_execution_result?
+    puts "\nCode execution result:"
+    puts "Outcome: #{response.code_execution_result.outcome}"
+    puts "Output: #{response.code_execution_result.output}"
+  end
+rescue => e
+  puts "Error during code execution: #{e.message}"
+end
+
+puts "\n\n=== PRACTICAL CODE EXECUTION EXAMPLE ==="
+puts "Asking Gemini to analyze some text data..."
+
+begin
+  # Generate a response with code execution for data analysis
+  response = Geminize.generate_with_code_execution(
+    "I have a list of temperatures: 32, 25, 30, 22, 28, 27, 35, 31, 29, 26. " \
+    "Please write code to calculate the mean, median, and standard deviation. " \
+    "Also, create a simple histogram visualization using matplotlib.",
+    nil,
+    {temperature: 0.2}
+  )
+
+  # Display the generated text
+  puts "\nGemini's response:"
+  puts response.text
+
+  # Display the executable code if present
+  if response.has_executable_code?
+    puts "\nGenerated code:"
+    puts "```#{response.executable_code.language.downcase}"
+    puts response.executable_code.code
+    puts "```"
+  end
+
+  # Display the code execution result if present
+  if response.has_code_execution_result?
+    puts "\nCode execution result:"
+    puts "Outcome: #{response.code_execution_result.outcome}"
+    puts "Output: #{response.code_execution_result.output}"
+  end
+rescue => e
+  puts "Error during code execution: #{e.message}"
+end
+
+puts "\n\n=== ITERATIVE PROBLEM SOLVING EXAMPLE ==="
+puts "Asking Gemini to solve a complex problem using code execution..."
+
+begin
+  # Generate a response for a more complex problem
+  response = Geminize.generate_with_code_execution(
+    "Write a Python function to find the nth Fibonacci number where n is a positive integer. " \
+    "Then use this function to calculate the 50th Fibonacci number. " \
+    "Implement it efficiently using memoization to avoid redundant calculations.",
+    nil,
+    {temperature: 0.2}
+  )
+
+  # Display the generated text
+  puts "\nGemini's response:"
+  puts response.text
+
+  # Display the executable code if present
+  if response.has_executable_code?
+    puts "\nGenerated code:"
+    puts "```#{response.executable_code.language.downcase}"
+    puts response.executable_code.code
+    puts "```"
+  end
+
+  # Display the code execution result if present
+  if response.has_code_execution_result?
+    puts "\nCode execution result:"
+    puts "Outcome: #{response.code_execution_result.outcome}"
+    puts "Output: #{response.code_execution_result.output}"
+  end
+rescue => e
+  puts "Error during code execution: #{e.message}"
+  puts "\nNOTE: If you hit a quota limit, try:"
+  puts "1. Using a paid API key with higher quotas"
+  puts "2. Reducing the number of examples you run"
+  puts "3. Adding delays between API calls"
+end
+
+puts "\n==========================================="
+puts "=            END OF EXAMPLES              ="
+puts "==========================================="

data/examples/function_calling.rb

@@ -0,0 +1,218 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "geminize"
+require "json"
+
+# Configure the API key
+Geminize.configure do |config|
+  config.api_key = ENV["GEMINI_API_KEY"] # Make sure to set your API key in the environment
+  config.default_model = "gemini-1.5-pro-latest" # Use the latest model that supports function calling
+end
+
+# Define a weather function that can handle a location and unit
+def get_weather(location, unit = "celsius")
+  puts "Getting weather for #{location} in #{unit}..."
+
+  # In a real implementation, this would call a weather API
+  # For this example, we'll return mock data
+  case location.downcase
+  when /new york/
+    {temperature: (unit == "celsius") ? 22 : 72, conditions: "Sunny", humidity: 45}
+  when /london/
+    {temperature: (unit == "celsius") ? 15 : 59, conditions: "Rainy", humidity: 80}
+  when /tokyo/
+    {temperature: (unit == "celsius") ? 26 : 79, conditions: "Partly Cloudy", humidity: 65}
+  else
+    {temperature: (unit == "celsius") ? 20 : 68, conditions: "Unknown", humidity: 50}
+  end
+end
+
+# Enhanced weather function that can handle a batch of locations
+def get_weather_batch(locations, unit = "celsius")
+  if locations.is_a?(Array)
+    results = {}
+    locations.each do |location|
+      results[location] = get_weather(location, unit)
+    end
+    results
+  else
+    {locations => get_weather(locations, unit)}
+  end
+end
+
+# Define a function schema for get_weather
+weather_function = {
+  name: "get_weather",
+  description: "Get the current weather in a location",
+  parameters: {
+    type: "object",
+    properties: {
+      location: {
+        type: "string",
+        description: "The city and state or country, e.g., 'New York, NY' or 'London, UK'"
+      },
+      unit: {
+        type: "string",
+        enum: ["celsius", "fahrenheit"],
+        description: "The unit of temperature"
+      }
+    },
+    required: ["location"]
+  }
+}
+
+# Define a batch weather function schema that can handle multiple locations
+batch_weather_function = {
+  name: "get_weather_batch",
+  description: "Get the current weather for multiple locations at once",
+  parameters: {
+    type: "object",
+    properties: {
+      locations: {
+        type: "array",
+        items: {
+          type: "string"
+        },
+        description: "List of cities, e.g., ['New York, NY', 'London, UK', 'Tokyo, Japan']"
+      },
+      unit: {
+        type: "string",
+        enum: ["celsius", "fahrenheit"],
+        description: "The unit of temperature"
+      }
+    },
+    required: ["locations"]
+  }
+}
+
+puts "==========================================="
+puts "= GEMINIZE FUNCTION CALLING & JSON EXAMPLES ="
+puts "==========================================="
+
+puts "\n=== FUNCTION CALLING EXAMPLE ==="
+puts "Asking Gemini about the weather in New York..."
+
+begin
+  # Generate a response with the function definition
+  response = Geminize.generate_with_functions(
+    "What's the weather like in New York?",
+    [weather_function],
+    nil,
+    {temperature: 0.2}
+  )
+
+  # Check if the model wants to call a function
+  if response.has_function_call?
+    function_call = response.function_call
+    puts "Model wants to call function: #{function_call.name}"
+    puts "With arguments: #{function_call.response.inspect}"
+
+    function_name = function_call.name
+    args = function_call.response
+
+    if function_name == "get_weather"
+      location = args["location"]
+      unit = args["unit"] || "celsius"
+
+      # Call our weather function
+      weather_data = get_weather(location, unit)
+      puts "Weather data for #{location}: #{weather_data.inspect}"
+
+      # Process the function result
+      final_response = Geminize.process_function_call(response) do |name, arguments|
+        get_weather(arguments["location"], arguments["unit"])
+      end
+
+      puts "\nFinal response from Gemini:"
+      puts final_response.text
+    else
+      puts "Unexpected function call: #{function_name}"
+    end
+  else
+    puts "Model did not request to call a function."
+    puts "Response: #{response.text}"
+  end
+rescue => e
+  puts "Error during function calling: #{e.message}"
+end
+
+# Example of using JSON mode
+puts "\n\n=== JSON MODE EXAMPLE ==="
+puts "Using JSON mode to get weather data in structured format..."
+
+begin
+  json_response = Geminize.generate_json(
+    "Get the current temperature and weather conditions for New York.",
+    nil,
+    {
+      system_instruction: "Return a JSON object with temperature in celsius and conditions."
+    }
+  )
+
+  if json_response.has_json_response?
+    puts "Structured JSON response:"
+    puts JSON.pretty_generate(json_response.json_response)
+  else
+    puts "Raw text response (not valid JSON):"
+    puts json_response.text
+  end
+rescue => e
+  puts "Error during JSON mode: #{e.message}"
+end
+
+puts "\n\n=== BATCH FUNCTION CALL EXAMPLE ==="
+puts "Using batch function to efficiently get weather for multiple cities at once..."
+
+begin
+  # Use a batch function to get all cities at once (more efficient)
+  response = Geminize.generate_with_functions(
+    "I need weather information for New York, Tokyo, and London. Please get all this information in a single function call.",
+    [batch_weather_function],
+    nil,
+    {temperature: 0.2}
+  )
+
+  # Check if the model wants to call the batch function
+  if response.has_function_call?
+    function_call = response.function_call
+    puts "Model wants to call function: #{function_call.name}"
+    puts "With arguments: #{function_call.response.inspect}"
+
+    function_name = function_call.name
+    args = function_call.response
+
+    if function_name == "get_weather_batch"
+      locations = args["locations"]
+      unit = args["unit"] || "celsius"
+
+      # Get weather for all locations at once
+      weather_data = get_weather_batch(locations, unit)
+      puts "Weather data for multiple locations: #{weather_data.inspect}"
+
+      # Process the function result with a single API call
+      final_response = Geminize.process_function_call(response) do |name, arguments|
+        get_weather_batch(arguments["locations"], arguments["unit"])
+      end
+
+      puts "\nFinal response from Gemini:"
+      puts final_response.text
+    else
+      puts "Unexpected function call: #{function_name}"
+    end
+  else
+    puts "Model did not request to call a function."
+    puts "Response: #{response.text}"
+  end
+rescue => e
+  puts "Error during batch function calling: #{e.message}"
+  puts "\nNOTE: If you hit a quota limit, try:"
+  puts "1. Using a paid API key with higher quotas"
+  puts "2. Reducing the number of examples you run"
+  puts "3. Adding delays between API calls"
+end
+
+puts "\n==========================================="
+puts "= END OF EXAMPLES ="
+puts "==========================================="

data/examples/safety_settings.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "geminize"
+
+# Configure the API key
+Geminize.configure do |config|
+  config.api_key = ENV["GEMINI_API_KEY"] # Make sure to set your API key in the environment
+  config.default_model = "gemini-1.5-pro-latest" # Use the latest model
+end
+
+# A prompt that might trigger safety filters
+POTENTIALLY_SENSITIVE_PROMPT = "Describe a violent conflict scene from a movie"
+
+puts "1. Generating with default safety settings:"
+begin
+  response = Geminize.generate_text(POTENTIALLY_SENSITIVE_PROMPT, nil, temperature: 0.2)
+  puts "Default response:\n#{response.text}\n\n"
+rescue Geminize::GeminizeError => e
+  puts "Error with default settings: #{e.message}\n\n"
+end
+
+puts "2. Generating with maximum safety (blocking most potentially harmful content):"
+begin
+  response = Geminize.generate_text_safe(POTENTIALLY_SENSITIVE_PROMPT, nil, temperature: 0.2)
+  puts "Maximum safety response:\n#{response.text}\n\n"
+rescue Geminize::GeminizeError => e
+  puts "Error with maximum safety: #{e.message}\n\n"
+end
+
+puts "3. Generating with minimum safety (blocking only high-risk content):"
+begin
+  response = Geminize.generate_text_permissive(POTENTIALLY_SENSITIVE_PROMPT, nil, temperature: 0.2)
+  puts "Minimum safety response:\n#{response.text}\n\n"
+rescue Geminize::GeminizeError => e
+  puts "Error with minimum safety: #{e.message}\n\n"
+end
+
+puts "4. Generating with custom safety settings:"
+begin
+  # Custom safety settings:
+  # - Block medium and above for dangerous content
+  # - Block low and above for hate speech
+  # - Block only high for sexually explicit content
+  # - No blocks for harassment
+  custom_safety_settings = [
+    {category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_MEDIUM_AND_ABOVE"},
+    {category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_LOW_AND_ABOVE"},
+    {category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "BLOCK_ONLY_HIGH"},
+    {category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_NONE"}
+  ]
+
+  response = Geminize.generate_with_safety_settings(
+    POTENTIALLY_SENSITIVE_PROMPT,
+    custom_safety_settings,
+    nil,
+    temperature: 0.2
+  )
+  puts "Custom safety response:\n#{response.text}\n\n"
+rescue Geminize::GeminizeError => e
+  puts "Error with custom safety: #{e.message}\n\n"
+end
+
+# Demonstrate direct usage of safety settings in a ContentRequest
+puts "5. Using safety settings directly in a ContentRequest:"
+begin
+  generator = Geminize::TextGeneration.new
+  content_request = Geminize::Models::ContentRequest.new(
+    POTENTIALLY_SENSITIVE_PROMPT,
+    nil,
+    temperature: 0.2
+  )
+
+  # Add specific safety settings
+  content_request.add_safety_setting("HARM_CATEGORY_DANGEROUS_CONTENT", "BLOCK_MEDIUM_AND_ABOVE")
+
+  response = generator.generate(content_request)
+  puts "ContentRequest safety response:\n#{response.text}\n\n"
+rescue Geminize::GeminizeError => e
+  puts "Error with ContentRequest safety: #{e.message}\n\n"
+end

data/lib/geminize/models/code_execution/code_execution_result.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Models
+    module CodeExecution
+      # Represents the result of executed code
+      class CodeExecutionResult
+        # Valid outcome values for code execution
+        VALID_OUTCOMES = ["OUTCOME_OK", "OUTCOME_ERROR"].freeze
+
+        # @return [String] The outcome of the code execution (e.g., "OUTCOME_OK", "OUTCOME_ERROR")
+        attr_reader :outcome
+
+        # @return [String] The output from the code execution
+        attr_reader :output
+
+        # Initialize a new code execution result
+        # @param outcome [String] The outcome of the code execution
+        # @param output [String] The output from the code execution
+        # @raise [Geminize::ValidationError] If the code execution result is invalid
+        def initialize(outcome, output)
+          @outcome = outcome
+          @output = output
+          validate!
+        end
+
+        # Validate the code execution result
+        # @raise [Geminize::ValidationError] If the code execution result is invalid
+        # @return [Boolean] true if validation passes
+        def validate!
+          unless @outcome.is_a?(String)
+            raise Geminize::ValidationError.new(
+              "Outcome must be a string, got #{@outcome.class}",
+              "INVALID_ARGUMENT"
+            )
+          end
+
+          unless VALID_OUTCOMES.include?(@outcome)
+            raise Geminize::ValidationError.new(
+              "Invalid outcome: #{@outcome}. Must be one of: #{VALID_OUTCOMES.join(", ")}",
+              "INVALID_ARGUMENT"
+            )
+          end
+
+          unless @output.is_a?(String)
+            raise Geminize::ValidationError.new(
+              "Output must be a string, got #{@output.class}",
+              "INVALID_ARGUMENT"
+            )
+          end
+
+          true
+        end
+
+        # Convert the code execution result to a hash
+        # @return [Hash] The code execution result as a hash
+        def to_hash
+          {
+            outcome: @outcome,
+            output: @output
+          }
+        end
+
+        # Alias for to_hash
+        # @return [Hash] The code execution result as a hash
+        def to_h
+          to_hash
+        end
+      end
+    end
+  end
+end

data/lib/geminize/models/code_execution/executable_code.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Models
+    module CodeExecution
+      # Represents executable code generated by the model
+      class ExecutableCode
+        # Valid language options for executable code
+        VALID_LANGUAGES = ["PYTHON"].freeze
+
+        # @return [String] The language of the code (e.g., "PYTHON")
+        attr_reader :language
+
+        # @return [String] The code content
+        attr_reader :code
+
+        # Initialize a new executable code object
+        # @param language [String] The programming language of the code (e.g., "PYTHON")
+        # @param code [String] The code content
+        # @raise [Geminize::ValidationError] If the executable code is invalid
+        def initialize(language, code)
+          @language = language
+          @code = code
+          validate!
+        end
+
+        # Validate the executable code
+        # @raise [Geminize::ValidationError] If the executable code is invalid
+        # @return [Boolean] true if validation passes
+        def validate!
+          unless @language.is_a?(String)
+            raise Geminize::ValidationError.new(
+              "Language must be a string, got #{@language.class}",
+              "INVALID_ARGUMENT"
+            )
+          end
+
+          unless VALID_LANGUAGES.include?(@language)
+            raise Geminize::ValidationError.new(
+              "Invalid language: #{@language}. Must be one of: #{VALID_LANGUAGES.join(", ")}",
+              "INVALID_ARGUMENT"
+            )
+          end
+
+          unless @code.is_a?(String)
+            raise Geminize::ValidationError.new(
+              "Code must be a string, got #{@code.class}",
+              "INVALID_ARGUMENT"
+            )
+          end
+
+          true
+        end
+
+        # Convert the executable code to a hash
+        # @return [Hash] The executable code as a hash
+        def to_hash
+          {
+            language: @language,
+            code: @code
+          }
+        end
+
+        # Alias for to_hash
+        # @return [Hash] The executable code as a hash
+        def to_h
+          to_hash
+        end
+      end
+    end
+  end
+end