imago 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d295fddaf05348d473874c6f08e10b93937f27f3e4b228b68ad33e96073fde17
-  data.tar.gz: 88d463fefbb56a175ffce52504374615ddbdb61b15877a05a01ee0e7f75432c8
+  metadata.gz: 417e5a3f6b7a3d41cee0ce17ec1cc225862fcc72c2448fc1c9b1da989509afd3
+  data.tar.gz: feca98a16c48e79f386b88626d7fa5934be4637910ae250a91bf036f79a2865b
 SHA512:
-  metadata.gz: 77e736f2487e31b1fc933fb4a174b8b67a0406116be1335a270890560a09a983418f2c7c368aa10d7489f51e745e9c5c27a9b9c238e82fe6314e0bd1b3d5713b
-  data.tar.gz: bb9c1ecf14c3f911f0869c8247f80297b575a57febd299cfd3b01063dd790cae866fcc8ec18d3dbe37c4e35320ea72138a210191e7057f240416d49e8748ae81
+  metadata.gz: bb62ccf9dcb695a401f08674d68ba37e7b3f2e8cdb7ae5820735d987aa41839f95a2fd5152533016fd8a6b704fd43df26ebf9e18d8b4f64181ed4bfbea3a4a1e
+  data.tar.gz: da94d8fbd02b78cce3ab04c567fa90881752670973925254c77ed724a645c9974dbb635b810e70ebe7182e5f5b658ae83f29590adaa867844760c5501cb70027

data/.rubocop.yml

@@ -45,8 +45,21 @@ Layout/LineLength:
   Max: 120
 
 Metrics/ClassLength:
+  Max: 100
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/AbcSize:
+  Max: 10
   Exclude:
-    - 'lib/imago/providers/openai.rb'
+    - 'spec/**/*'
+
+Metrics/CyclomaticComplexity:
+  Max: 10
+
+Metrics/PerceivedComplexity:
+  Max: 10
 
 RSpec/MessageSpies:
   EnforcedStyle: receive

data/lib/imago/gemini_response_parser.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Imago
+  class GeminiResponseParser
+    def parse(body)
+      candidates = body['candidates'] || []
+      images = candidates.flat_map { |candidate| extract_images(candidate) }
+      { images: images }
+    end
+
+    private
+
+    def extract_images(candidate)
+      parts = candidate.dig('content', 'parts') || []
+      parts.filter_map { |part| parse_image_part(part) }
+    end
+
+    def parse_image_part(part)
+      return unless part['inlineData']
+
+      { base64: part['inlineData']['data'], mime_type: part['inlineData']['mimeType'] }.compact
+    end
+  end
+end

data/lib/imago/image_input.rb

@@ -31,16 +31,21 @@ module Imago
     def self.from_hash(hash)
       hash = hash.transform_keys(&:to_sym)
 
-      if hash[:base64]
-        raise ArgumentError, 'mime_type is required for base64 images' unless hash[:mime_type]
+      return from_base64_hash(hash) if hash[:base64]
+      return from_url_hash(hash) if hash[:url]
 
-        new(base64: hash[:base64], mime_type: hash[:mime_type])
-      elsif hash[:url]
-        mime_type = hash[:mime_type] || detect_mime_type(hash[:url])
-        new(url: hash[:url], mime_type: mime_type)
-      else
-        raise ArgumentError, 'Image hash must contain either :url or :base64 key'
-      end
+      raise ArgumentError, 'Image hash must contain either :url or :base64 key'
+    end
+
+    def self.from_base64_hash(hash)
+      raise ArgumentError, 'mime_type is required for base64 images' unless hash[:mime_type]
+
+      new(base64: hash[:base64], mime_type: hash[:mime_type])
+    end
+
+    def self.from_url_hash(hash)
+      mime_type = hash[:mime_type] || detect_mime_type(hash[:url])
+      new(url: hash[:url], mime_type: mime_type)
     end
 
     def self.detect_mime_type(url)
@@ -50,7 +55,7 @@ module Imago
       nil
     end
 
-    private_class_method :from_url_string, :from_hash, :detect_mime_type
+    private_class_method :from_url_string, :from_hash, :from_base64_hash, :from_url_hash, :detect_mime_type
 
     def initialize(url: nil, base64: nil, mime_type: nil)
       @url = url

data/lib/imago/multipart_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Imago
+  class MultipartBuilder
+    def initialize(model)
+      @model = model
+    end
+
+    def build_body(prompt, images, opts)
+      body = base_body(prompt)
+      add_images(body, images)
+      body.merge(opts.except(:images))
+    end
+
+    def build_image_part(image)
+      image.url? ? image.url : build_file_part(image)
+    end
+
+    private
+
+    def base_body(prompt)
+      { model: @model, prompt: prompt }
+    end
+
+    def add_images(body, images)
+      images.each_with_index do |image, index|
+        body["image[#{index}]"] = build_image_part(image)
+      end
+    end
+
+    def build_file_part(image)
+      io = StringIO.new(Base64.decode64(image.base64))
+      extension = extract_extension(image.mime_type)
+      Faraday::Multipart::FilePart.new(io, image.mime_type, "image.#{extension}")
+    end
+
+    def extract_extension(mime_type)
+      mime_type&.split('/')&.last || 'png'
+    end
+  end
+end

data/lib/imago/providers/gemini.rb

@@ -16,15 +16,8 @@ module Imago
 
       def generate(prompt, opts = {})
         validate_image_count!(opts[:images], max: MAX_IMAGES)
-        conn = connection(BASE_URL)
-        endpoint = "models/#{model}:generateContent"
-
-        response = conn.post(endpoint) do |req|
-          req.params['key'] = api_key
-          req.body = build_request_body(prompt, opts)
-        end
-
-        parse_generate_response(handle_response(response))
+        response = execute_generate_request(prompt, opts)
+        response_parser.parse(handle_response(response))
       end
 
       def models
@@ -43,6 +36,25 @@ module Imago
 
       private
 
+      def response_parser
+        @response_parser ||= Imago::GeminiResponseParser.new
+      end
+
+      def execute_generate_request(prompt, opts)
+        conn = connection(BASE_URL)
+        body = build_request_body(prompt, opts)
+        conn.post(generate_endpoint) { |req| configure_request(req, body) }
+      end
+
+      def generate_endpoint
+        "models/#{model}:generateContent"
+      end
+
+      def configure_request(req, body)
+        req.params['key'] = api_key
+        req.body = body
+      end
+
       def build_request_body(prompt, opts)
         body = { contents: [{ parts: build_parts(prompt, opts) }] }
         body[:generationConfig] = build_generation_config(opts) if generation_config_present?(opts)
@@ -51,71 +63,57 @@ module Imago
 
       def build_parts(prompt, opts)
         parts = [{ text: build_prompt(prompt, opts) }]
-        images = normalize_images(opts[:images])
-        images.each { |img| parts << build_image_part(img) }
+        normalize_images(opts[:images]).each { |img| parts << build_image_part(img) }
         parts
       end
 
       def build_image_part(image)
-        if image.url?
-          { fileData: { fileUri: image.url, mimeType: image.mime_type }.compact }
-        else
-          { inlineData: { data: image.base64, mimeType: image.mime_type } }
-        end
+        image.url? ? build_file_data(image) : build_inline_data(image)
       end
 
-      def build_prompt(prompt, opts)
-        return prompt unless opts[:negative_prompt]
-
-        "#{prompt}. Avoid: #{opts[:negative_prompt]}"
+      def build_file_data(image)
+        { fileData: { fileUri: image.url, mimeType: image.mime_type }.compact }
       end
 
-      def generation_config_present?(opts)
-        opts[:n] || opts[:sample_count] || opts[:aspect_ratio] || opts[:seed]
+      def build_inline_data(image)
+        { inlineData: { data: image.base64, mimeType: image.mime_type } }
       end
 
-      def build_generation_config(opts)
-        config = {}
-        config[:candidateCount] = opts[:sample_count] || opts[:n] if opts[:n] || opts[:sample_count]
-        config[:seed] = opts[:seed] if opts[:seed]
-        config[:aspectRatio] = opts[:aspect_ratio] if opts[:aspect_ratio]
-        config
+      def build_prompt(prompt, opts)
+        opts[:negative_prompt] ? "#{prompt}. Avoid: #{opts[:negative_prompt]}" : prompt
       end
 
-      def parse_generate_response(body)
-        candidates = body['candidates'] || []
-        images = candidates.flat_map { |candidate| extract_images_from_candidate(candidate) }
-        { images: images }
+      def generation_config_present?(opts)
+        opts[:n] || opts[:sample_count] || opts[:aspect_ratio] || opts[:seed]
       end
 
-      def extract_images_from_candidate(candidate)
-        parts = candidate.dig('content', 'parts') || []
-        parts.filter_map do |part|
-          next unless part['inlineData']
-
-          { base64: part['inlineData']['data'], mime_type: part['inlineData']['mimeType'] }.compact
-        end
+      def build_generation_config(opts)
+        { candidateCount: opts[:sample_count] || opts[:n], seed: opts[:seed], aspectRatio: opts[:aspect_ratio] }.compact
       end
 
       def fetch_models
-        conn = connection(BASE_URL)
-        response = conn.get('models') do |req|
-          req.params['key'] = api_key
-        end
-
-        body = handle_response(response)
-        filter_image_models(body['models'] || [])
+        response = connection(BASE_URL).get('models') { |req| req.params['key'] = api_key }
+        filter_image_models(handle_response(response)['models'] || [])
       rescue ApiError
         KNOWN_IMAGE_MODELS
       end
 
       def filter_image_models(models)
-        image_model_names = models
-                            .select { |m| m['supportedGenerationMethods']&.include?('generateContent') }
-                            .map { |m| m['name'].sub('models/', '') }
-                            .select { |name| name.include?('imagen') || name.include?('image') }
+        names = extract_image_model_names(models)
+        names.empty? ? KNOWN_IMAGE_MODELS : names
+      end
+
+      def extract_image_model_names(models)
+        content_models = models.select { |m| supports_generate_content?(m) }
+        content_models.map { |m| m['name'].sub('models/', '') }.select { |n| image_model?(n) }
+      end
+
+      def supports_generate_content?(model)
+        model['supportedGenerationMethods']&.include?('generateContent')
+      end
 
-        image_model_names.empty? ? KNOWN_IMAGE_MODELS : image_model_names
+      def image_model?(name)
+        name.include?('imagen') || name.include?('image')
       end
     end
   end

data/lib/imago/providers/openai.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'faraday/multipart'
-require 'base64'
 
 module Imago
   module Providers
@@ -9,28 +8,12 @@ module Imago
       BASE_URL = 'https://api.openai.com/v1'
       MAX_IMAGES = 16
 
-      KNOWN_IMAGE_MODELS = %w[
-        dall-e-3
-        dall-e-2
-        gpt-image-1
-        gpt-image-1.5
-        gpt-image-1-mini
-      ].freeze
-
-      MODELS_SUPPORTING_IMAGE_INPUT = %w[
-        dall-e-2
-        gpt-image-1
-        gpt-image-1.5
-        gpt-image-1-mini
-      ].freeze
+      KNOWN_IMAGE_MODELS = %w[dall-e-3 dall-e-2 gpt-image-1 gpt-image-1.5 gpt-image-1-mini].freeze
+      MODELS_SUPPORTING_IMAGE_INPUT = %w[dall-e-2 gpt-image-1 gpt-image-1.5 gpt-image-1-mini].freeze
 
       def generate(prompt, opts = {})
-        images = opts[:images]
-        if images && !images.empty?
-          generate_with_images(prompt, opts)
-        else
-          generate_text_only(prompt, opts)
-        end
+        has_images = opts[:images] && !opts[:images].empty?
+        has_images ? generate_with_images(prompt, opts) : generate_text_only(prompt, opts)
       end
 
       def models
@@ -50,82 +33,72 @@ module Imago
       private
 
       def generate_text_only(prompt, opts)
-        conn = connection(BASE_URL)
-        response = conn.post('images/generations') do |req|
-          req.headers['Authorization'] = "Bearer #{api_key}"
-          req.body = build_request_body(prompt, opts)
-        end
-
-        parse_generate_response(handle_response(response))
+        response = post_with_auth('images/generations', build_request_body(prompt, opts))
+        parse_response(response)
       end
 
       def generate_with_images(prompt, opts)
         validate_model_supports_images!
         validate_image_count!(opts[:images], max: MAX_IMAGES)
+        response = post_multipart_edit(prompt, opts)
+        parse_response(response)
+      end
+
+      def post_with_auth(endpoint, body)
+        connection(BASE_URL).post(endpoint) do |req|
+          req.headers['Authorization'] = auth_header
+          req.body = body
+        end
+      end
 
+      def post_multipart_edit(prompt, opts)
+        body = build_multipart_body(prompt, opts)
+        multipart_connection.post('images/edits') { |req| configure_auth_request(req, body) }
+      end
+
+      def build_multipart_body(prompt, opts)
         images = normalize_images(opts[:images])
-        conn = multipart_connection(BASE_URL)
+        multipart_builder.build_body(prompt, images, opts)
+      end
 
-        response = conn.post('images/edits') do |req|
-          req.headers['Authorization'] = "Bearer #{api_key}"
-          req.body = build_multipart_body(prompt, images, opts)
-        end
+      def configure_auth_request(req, body)
+        req.headers['Authorization'] = auth_header
+        req.body = body
+      end
 
-        parse_generate_response(handle_response(response))
+      def parse_response(response)
+        body = handle_response(response)
+        images = body['data']&.map { |img| parse_image(img) }
+        { images: images || [], created: body['created'] }
       end
 
-      def validate_model_supports_images!
-        return if MODELS_SUPPORTING_IMAGE_INPUT.include?(model)
+      def auth_header
+        "Bearer #{api_key}"
+      end
 
-        supported = MODELS_SUPPORTING_IMAGE_INPUT.join(', ')
-        raise InvalidRequestError.new(
-          "Model '#{model}' does not support image inputs. Supported models: #{supported}",
-          status_code: 400
-        )
+      def multipart_builder
+        @multipart_builder ||= Imago::MultipartBuilder.new(model)
       end
 
-      def multipart_connection(base_url)
-        Faraday.new(url: base_url) do |conn|
+      def multipart_connection
+        @multipart_connection ||= Faraday.new(url: BASE_URL) do |conn|
           conn.request :multipart
           conn.response :json
           conn.adapter Faraday.default_adapter
         end
       end
 
-      def build_multipart_body(prompt, images, opts)
-        body = {
-          model: model,
-          prompt: prompt
-        }
-
-        images.each_with_index do |image, index|
-          body["image[#{index}]"] = build_image_part(image)
-        end
-
-        clean_opts = opts.except(:images)
-        body.merge(clean_opts)
-      end
+      def validate_model_supports_images!
+        return if MODELS_SUPPORTING_IMAGE_INPUT.include?(model)
 
-      def build_image_part(image)
-        if image.url?
-          image.url
-        else
-          io = StringIO.new(Base64.decode64(image.base64))
-          extension = image.mime_type&.split('/')&.last || 'png'
-          Faraday::Multipart::FilePart.new(io, image.mime_type, "image.#{extension}")
-        end
+        raise InvalidRequestError.new(
+          "Model '#{model}' does not support image inputs. Supported: #{MODELS_SUPPORTING_IMAGE_INPUT.join(', ')}",
+          status_code: 400
+        )
       end
 
       def build_request_body(prompt, opts)
-        {
-          model: model,
-          prompt: prompt
-        }.merge(opts)
-      end
-
-      def parse_generate_response(body)
-        images = body['data']&.map { |img| parse_image(img) }
-        { images: images || [], created: body['created'] }
+        { model: model, prompt: prompt }.merge(opts)
       end
 
       def parse_image(img)
@@ -133,23 +106,15 @@ module Imago
       end
 
       def fetch_models
-        conn = connection(BASE_URL)
-        response = conn.get('models') do |req|
-          req.headers['Authorization'] = "Bearer #{api_key}"
-        end
-
-        body = handle_response(response)
-        filter_image_models(body['data'] || [])
+        response = connection(BASE_URL).get('models') { |req| req.headers['Authorization'] = auth_header }
+        filter_image_models(handle_response(response)['data'] || [])
       rescue ApiError
         KNOWN_IMAGE_MODELS
       end
 
       def filter_image_models(models)
-        image_model_ids = models
-                          .map { |m| m['id'] }
-                          .select { |id| id.include?('dall-e') || id.include?('image') }
-
-        image_model_ids.empty? ? KNOWN_IMAGE_MODELS : image_model_ids
+        ids = models.map { |m| m['id'] }.select { |id| id.include?('dall-e') || id.include?('image') }
+        ids.empty? ? KNOWN_IMAGE_MODELS : ids
       end
     end
   end

data/lib/imago/providers/xai.rb

@@ -12,13 +12,7 @@ module Imago
 
       def generate(prompt, opts = {})
         raise_if_images_provided(opts)
-
-        conn = connection(BASE_URL)
-        response = conn.post('images/generations') do |req|
-          req.headers['Authorization'] = "Bearer #{api_key}"
-          req.body = build_request_body(prompt, opts)
-        end
-
+        response = execute_generate_request(prompt, opts)
         parse_generate_response(handle_response(response))
       end
 
@@ -38,6 +32,21 @@ module Imago
 
       private
 
+      def execute_generate_request(prompt, opts)
+        conn = connection(BASE_URL)
+        body = build_request_body(prompt, opts)
+        conn.post('images/generations') { |req| configure_request(req, body) }
+      end
+
+      def configure_request(req, body)
+        req.headers['Authorization'] = auth_header
+        req.body = body
+      end
+
+      def auth_header
+        "Bearer #{api_key}"
+      end
+
       def build_request_body(prompt, opts)
         {
           model: model,
@@ -48,17 +57,8 @@ module Imago
       end
 
       def parse_generate_response(body)
-        images = body['data']&.map do |img|
-          {
-            url: img['url'],
-            base64: img['b64_json']
-          }.compact
-        end
-
-        {
-          images: images || [],
-          created: body['created']
-        }
+        images = body['data']&.map { |img| { url: img['url'], base64: img['b64_json'] }.compact }
+        { images: images || [], created: body['created'] }
       end
 
       def raise_if_images_provided(opts)

data/lib/imago/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Imago
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/lib/imago.rb

@@ -6,6 +6,8 @@ require 'json'
 require_relative 'imago/version'
 require_relative 'imago/errors'
 require_relative 'imago/image_input'
+require_relative 'imago/multipart_builder'
+require_relative 'imago/gemini_response_parser'
 require_relative 'imago/providers/base'
 require_relative 'imago/providers/openai'
 require_relative 'imago/providers/gemini'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: imago
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - NEETzsche
@@ -67,7 +67,9 @@ files:
 - lib/imago.rb
 - lib/imago/client.rb
 - lib/imago/errors.rb
+- lib/imago/gemini_response_parser.rb
 - lib/imago/image_input.rb
+- lib/imago/multipart_builder.rb
 - lib/imago/providers/base.rb
 - lib/imago/providers/gemini.rb
 - lib/imago/providers/openai.rb