runway-ruby 0.1.0

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+# Load custom OpenAPI validation tasks
+Dir.glob("lib/tasks/*.rake").each { |r| load r }
+
+task default: %i[spec]

data/lib/runway_ml/character_performance.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "media_processor"
+require_relative "validators/character_performance_validator"
+
+module RunwayML
+  class CharacterPerformance
+    VALID_MODELS = [ "act_two" ].freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    def create(model:, character:, reference:, ratio:, seed: nil, body_control: nil, expression_intensity: nil, public_figure_threshold: nil, auto_upload: true)
+      errors = {}
+
+      # Validate model
+      unless VALID_MODELS.include?(model)
+        errors[:model] = "must be one of: #{VALID_MODELS.join(', ')}"
+        raise ValidationError, errors
+      end
+
+      # Process character and reference with auto-upload support
+      # They can be hashes with 'uri' keys containing file paths
+      processed_character = if character.is_a?(Hash) && character[:uri]
+        processed_uri = MediaProcessor.process(
+          character[:uri],
+          errors,
+          client: client,
+          auto_upload: auto_upload
+        )
+        character.dup.tap { |h| h[:uri] = processed_uri }
+      else
+        MediaProcessor.process(
+          character,
+          errors,
+          client: client,
+          auto_upload: auto_upload
+        )
+      end
+
+      processed_reference = if reference.is_a?(Hash) && reference[:uri]
+        processed_uri = MediaProcessor.process(
+          reference[:uri],
+          errors,
+          client: client,
+          auto_upload: auto_upload
+        )
+        reference.dup.tap { |h| h[:uri] = processed_uri }
+      else
+        MediaProcessor.process(
+          reference,
+          errors,
+          client: client,
+          auto_upload: auto_upload
+        )
+      end
+
+      validator = Validators::CharacterPerformanceValidator.new
+      result = validator.validate(
+        character: processed_character,
+        reference: processed_reference,
+        ratio: ratio,
+        seed: seed,
+        body_control: body_control,
+        expression_intensity: expression_intensity,
+        public_figure_threshold: public_figure_threshold
+      )
+
+      errors = result[:errors]
+      raise ValidationError, errors unless errors.empty?
+
+      inputs = build_inputs(processed_character, processed_reference, ratio, seed, body_control, expression_intensity, public_figure_threshold)
+
+      response = client.post(
+        "character_performance",
+        inputs.merge(model: model)
+      )
+
+      Task.new(id: response["id"], client: client)
+    end
+
+    private
+
+    attr_reader :client
+
+    def build_inputs(character, reference, ratio, seed, body_control, expression_intensity, public_figure_threshold)
+      inputs = {
+        character: character,
+        reference: reference,
+        ratio: ratio
+      }
+
+      inputs[:seed] = seed unless seed.nil?
+      inputs[:bodyControl] = body_control unless body_control.nil?
+      inputs[:expressionIntensity] = expression_intensity unless expression_intensity.nil?
+
+      unless public_figure_threshold.nil?
+        inputs[:contentModeration] = { publicFigureThreshold: public_figure_threshold }
+      end
+
+      inputs
+    end
+  end
+end

data/lib/runway_ml/client.rb

@@ -0,0 +1,84 @@
+require "net/http"
+require "json"
+require "uri"
+require "openssl"
+
+module RunwayML
+  class Client
+    def initialize(api_secret:, base_url: "https://api.dev.runwayml.com/v1/", api_version: "2024-11-06")
+      @api_secret = api_secret
+      @base_url = base_url
+      @api_version = api_version
+    end
+
+    def post(path, params)
+      request(:post, path, params)
+    end
+
+    def get(path)
+      request(:get, path)
+    end
+
+    def delete(path)
+      request(:delete, path)
+    end
+
+    private
+
+    attr_reader :api_secret, :base_url, :api_version
+
+    def request(method, path, params = nil)
+      uri = URI("#{base_url}#{path}")
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        request = build_request(method, uri, params)
+        response = http.request(request)
+        body = parse_body(response)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          headers = response.to_hash.transform_keys(&:downcase)
+          error_message = body.is_a?(Hash) ? body["error"] : nil
+          raise APIError.generate(response.code.to_i, body, error_message, headers)
+        end
+
+        body
+      end
+    rescue OpenSSL::SSL::SSLError => e
+      raise SSLError.new(message: e.message, cause: e)
+    rescue SocketError, Net::OpenTimeout, Net::ReadTimeout => e
+      raise APIConnectionError.new(message: e.message, cause: e)
+    end
+
+    def build_request(method, uri, params)
+      request_class = case method
+      when :get
+        Net::HTTP::Get
+      when :post
+        Net::HTTP::Post
+      when :delete
+        Net::HTTP::Delete
+      else
+        raise ArgumentError, "Unsupported HTTP method: #{method}"
+      end
+
+      request = request_class.new(uri)
+      request["Authorization"] = "Bearer #{api_secret}"
+      request["X-Runway-Version"] = api_version
+
+      if method == :post
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate(params || {})
+      end
+
+      request
+    end
+
+    def parse_body(response)
+      return nil if response.body.nil? || response.body.strip.empty?
+
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/runway_ml/contract_validator.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "openapi_spec_loader"
+
+module RunwayML
+  # Helps validate SDK requests and responses against the OpenAPI spec
+  class ContractValidator
+    def initialize
+      @spec = OpenAPISpecLoader.load_spec
+    end
+
+    # Validates that a request body conforms to the OpenAPI spec
+    def validate_request(method, path, request_body)
+      schema = OpenAPISpecLoader.get_request_schema(method, path)
+      return { valid: true } unless schema
+
+      # Try to validate using JSON Schema
+      errors = validate_against_schema(request_body, schema, "Request")
+      errors.empty? ? { valid: true } : { valid: false, errors: errors }
+    rescue StandardError => e
+      { valid: false, errors: [ e.message ] }
+    end
+
+    # Validates that a response body conforms to the OpenAPI spec
+    def validate_response(method, path, response_body, status_code = 200)
+      schema = OpenAPISpecLoader.get_response_schema(method, path, status_code.to_s)
+      return { valid: true } unless schema
+
+      errors = validate_against_schema(response_body, schema, "Response")
+      errors.empty? ? { valid: true } : { valid: false, errors: errors }
+    rescue StandardError => e
+      { valid: false, errors: [ e.message ] }
+    end
+
+    # Validates a value against a schema with discriminator support
+    def validate_discriminated_oneOf(value, schema, discriminator_field)
+      return { valid: true } unless schema.dig("oneOf")
+
+      discriminator_value = value[discriminator_field]
+      return { valid: false, errors: [ "Missing discriminator field: #{discriminator_field}" ] } unless discriminator_value
+
+      matching_schemas = schema["oneOf"].select do |s|
+        s.dig("properties", discriminator_field, "const") == discriminator_value ||
+          s["title"] == discriminator_value
+      end
+
+      return { valid: false, errors: [ "No matching schema for #{discriminator_field}: #{discriminator_value}" ] } if matching_schemas.empty?
+
+      # Validate against the first matching schema
+      errors = validate_against_schema(value, matching_schemas.first, "Discriminated Schema")
+      errors.empty? ? { valid: true } : { valid: false, errors: errors }
+    end
+
+    def validate_against_schema(data, schema, context = "Schema")
+      return [] if schema.nil?
+
+      errors = []
+
+      # Handle oneOf schemas (discriminated unions)
+      if schema["oneOf"]
+        model_value = data[schema["discriminator"]["propertyName"]] if schema["discriminator"]
+        matching_schemas = schema["oneOf"].select do |s|
+          s.dig("properties", schema["discriminator"]["propertyName"], "const") == model_value ||
+            s["title"] == model_value
+        end
+
+        if matching_schemas.any?
+          errors.concat(validate_against_schema(data, matching_schemas.first, context))
+          return errors
+        else
+          return [ "#{context}: No matching schema for model: #{model_value}" ]
+        end
+      end
+
+      # Basic type checking
+      if schema["type"]
+        unless matches_type?(data, schema["type"])
+          errors << "#{context}: Expected type #{schema['type']}, got #{data.class.name.downcase}"
+        end
+      end
+
+      # String constraints
+      if schema["type"] == "string" && data.is_a?(String)
+        if schema["minLength"] && data.length < schema["minLength"]
+          errors << "#{context}: String too short (minimum #{schema['minLength']} characters)"
+        end
+        if schema["maxLength"] && data.length > schema["maxLength"]
+          errors << "#{context}: String too long (maximum #{schema['maxLength']} characters)"
+        end
+        if schema["pattern"] && !data.match?(Regexp.new(schema["pattern"]))
+          errors << "#{context}: String does not match pattern #{schema['pattern']}"
+        end
+      end
+
+      # Numeric constraints
+      if (schema["type"] == "number" || schema["type"] == "integer") && data.is_a?(Numeric)
+        if schema["minimum"] && data < schema["minimum"]
+          errors << "#{context}: Number below minimum #{schema['minimum']}"
+        end
+        if schema["maximum"] && data > schema["maximum"]
+          errors << "#{context}: Number above maximum #{schema['maximum']}"
+        end
+      end
+
+      # Enum validation
+      if schema["enum"] && !schema["enum"].include?(data)
+        errors << "#{context}: #{data.inspect} not in enum #{schema['enum']}"
+      end
+
+      # Required fields for objects
+      if schema["type"] == "object" && data.is_a?(Hash)
+        required_fields = schema["required"] || []
+        missing_fields = required_fields.reject { |f| data.key?(f) || data.key?(f.to_sym) }
+        if missing_fields.any?
+          errors << "#{context}: Missing required fields: #{missing_fields.join(', ')}"
+        end
+
+        # Validate properties if defined
+        properties = schema["properties"] || {}
+        properties.each do |prop_name, prop_schema|
+          value = data[prop_name] || data[prop_name.to_sym]
+          next unless value
+
+          prop_errors = validate_against_schema(value, prop_schema, "#{context}.#{prop_name}")
+          errors.concat(prop_errors)
+        end
+      end
+
+      errors
+    end
+
+    def matches_type?(data, type)
+      case type
+      when "string"
+        data.is_a?(String)
+      when "number"
+        data.is_a?(Numeric)
+      when "integer"
+        data.is_a?(Integer)
+      when "boolean"
+        data.is_a?(TrueClass) || data.is_a?(FalseClass)
+      when "object"
+        data.is_a?(Hash)
+      when "array"
+        data.is_a?(Array)
+      else
+        true
+      end
+    end
+  end
+end

data/lib/runway_ml/errors.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module RunwayML
+  class Error < StandardError
+  end
+
+  class APIError < Error
+    attr_reader :status, :headers, :error
+
+    def initialize(status, error, message, headers)
+      @status = status
+      @headers = headers
+      @error = error
+      super(make_message(status, error, message))
+    end
+
+    def self.generate(status, error_response, message, headers)
+      return APIConnectionError.new(message: message) unless status && headers
+
+      case status
+      when 400
+        BadRequestError.new(status, error_response, message, headers)
+      when 401
+        AuthenticationError.new(status, error_response, message, headers)
+      when 403
+        PermissionDeniedError.new(status, error_response, message, headers)
+      when 404
+        NotFoundError.new(status, error_response, message, headers)
+      when 409
+        ConflictError.new(status, error_response, message, headers)
+      when 422
+        UnprocessableEntityError.new(status, error_response, message, headers)
+      when 429
+        RateLimitError.new(status, error_response, message, headers)
+      when 500..599
+        InternalServerError.new(status, error_response, message, headers)
+      else
+        new(status, error_response, message, headers)
+      end
+    end
+
+    private
+
+    def make_message(status, error, message)
+      msg = if error.is_a?(Hash) && error["message"]
+              error["message"]
+      elsif error
+              error.to_s
+      else
+              message
+      end
+
+      if status && msg
+        "#{status} #{msg}"
+      elsif status
+        "#{status} status code (no body)"
+      elsif msg
+        msg
+      else
+        "(no status code or body)"
+      end
+    end
+  end
+
+  class APIConnectionError < APIError
+    def initialize(message: nil, cause: nil)
+      @cause = cause
+      super(nil, nil, message || "Connection error.", nil)
+    end
+
+    attr_reader :cause
+  end
+
+  class APIConnectionTimeoutError < APIConnectionError
+    def initialize(message: nil)
+      super(message: message || "Request timed out.")
+    end
+  end
+
+  class SSLError < APIConnectionError
+    def initialize(message: nil, cause: nil)
+      ssl_message = "SSL verification failed: #{message}. " \
+                    "This may be due to outdated SSL certificates on your system. " \
+                    "Try updating your system's SSL certificates or OpenSSL installation."
+      super(message: ssl_message, cause: cause)
+    end
+  end
+
+  class BadRequestError < APIError
+    def initialize(status, error, message, headers)
+      @validation_issues = extract_validation_issues(error) if error.is_a?(Hash)
+      super
+    end
+
+    attr_reader :validation_issues
+
+    private
+
+    def extract_validation_issues(error)
+      return [] unless error["issues"].is_a?(Array)
+
+      error["issues"].map do |issue|
+        {
+          path: issue["path"]&.join(".") || "unknown",
+          message: issue["message"] || "Invalid value",
+          code: issue["code"]
+        }
+      end
+    end
+
+    def make_message(status, error, message)
+      return super unless @validation_issues&.any?
+
+      base = "400 Bad Request - Validation failed:\n"
+      issues_msg = @validation_issues.map do |issue|
+        "  - #{issue[:path]}: #{issue[:message]}"
+      end.join("\n")
+
+      base + issues_msg
+    end
+  end
+
+  class AuthenticationError < APIError
+  end
+
+  class PermissionDeniedError < APIError
+  end
+
+  class NotFoundError < APIError
+  end
+
+  class ConflictError < APIError
+  end
+
+  class UnprocessableEntityError < APIError
+  end
+
+  class RateLimitError < APIError
+    def retry_after
+      headers&.[]("retry-after")&.to_i || headers&.[]("x-ratelimit-reset")&.to_i
+    end
+  end
+
+  class InternalServerError < APIError
+  end
+
+  class ValidationError < Error
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+      super(format_message)
+    end
+
+    private
+
+    def format_message
+      "Validation failed:\n" + errors.map { |field, message| "  - #{field}: #{message}" }.join("\n")
+    end
+  end
+
+  class TaskFailedError < Error
+    attr_reader :task
+
+    def initialize(task)
+      @task = task
+      super("Task failed")
+    end
+  end
+
+  class TaskTimeoutError < Error
+    attr_reader :task
+
+    def initialize(task)
+      @task = task
+      super("Task timed out")
+    end
+  end
+end

data/lib/runway_ml/image_processor.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "base64"
+require "stringio"
+
+module RunwayML
+  class ImageProcessor
+    def self.process(prompt_image, errors)
+      new.process(prompt_image, errors)
+    end
+
+    def process(prompt_image, errors)
+      return prompt_image if prompt_image.nil?
+
+      if io_like?(prompt_image)
+        convert_io_to_data_uri(prompt_image, errors)
+      elsif prompt_image.is_a?(String) && looks_like_file_path?(prompt_image)
+        load_file_path(prompt_image, errors)
+      elsif prompt_image.is_a?(Array)
+        process_array_format(prompt_image, errors)
+      else
+        prompt_image
+      end
+    end
+
+    private
+
+    def process_array_format(prompt_image, errors)
+      return prompt_image unless prompt_image.is_a?(Array)
+
+      processed_items = prompt_image.map do |item|
+        next item unless item.is_a?(Hash)
+
+        uri = item[:uri] || item["uri"]
+        next item unless uri
+
+        converted_uri = if io_like?(uri)
+          convert_io_to_data_uri(uri, errors)
+        elsif uri.is_a?(String) && looks_like_file_path?(uri)
+          load_file_path(uri, errors)
+        else
+          uri
+        end
+
+        next item unless converted_uri
+
+        item = item.dup
+        if item.key?(:uri)
+          item[:uri] = converted_uri
+        else
+          item["uri"] = converted_uri
+        end
+        item
+      end
+
+      processed_items
+    end
+
+    def load_file_path(path, errors)
+      file = File.open(path, "rb")
+      result = convert_io_to_data_uri(file, errors)
+      file.close
+      result
+    rescue Errno::ENOENT
+      errors[:prompt_image] = "file not found: #{path}"
+      nil
+    rescue => e
+      errors[:prompt_image] = "error reading file: #{e.message}"
+      nil
+    end
+
+    def looks_like_file_path?(string)
+      return false unless string.is_a?(String)
+
+      # If it starts with a known URI scheme, it's not a file path
+      return false if string.start_with?("https://", "http://", "runway://", "data:")
+
+      # Check if it's a file that exists
+      File.exist?(string)
+    end
+
+    def io_like?(object)
+      object.is_a?(File) || object.is_a?(StringIO) ||
+        (object.respond_to?(:read) && object.respond_to?(:rewind))
+    end
+
+    def convert_io_to_data_uri(io, errors)
+      io.rewind if io.respond_to?(:rewind)
+      content = io.read
+      io.rewind if io.respond_to?(:rewind)
+
+      content_type = detect_content_type(io, content)
+      unless content_type
+        errors[:prompt_image] = "unable to detect image type. Supported formats: JPEG, PNG, WebP"
+        return nil
+      end
+
+      encoded = Base64.strict_encode64(content)
+      "data:#{content_type};base64,#{encoded}"
+    end
+
+    def detect_content_type(io, content)
+      # Try to detect from file path if it's a File object
+      if io.is_a?(File) && io.respond_to?(:path)
+        ext = File.extname(io.path).downcase
+        case ext
+        when ".jpg", ".jpeg"
+          return "image/jpeg"
+        when ".png"
+          return "image/png"
+        when ".webp"
+          return "image/webp"
+        end
+      end
+
+      # Detect from magic bytes
+      return nil if content.nil? || content.empty?
+
+      if content.start_with?("\xFF\xD8\xFF".b)
+        "image/jpeg"
+      elsif content.start_with?("\x89PNG\r\n\x1A\n".b)
+        "image/png"
+      elsif content.start_with?("RIFF".b) && content[8..11] == "WEBP".b
+        "image/webp"
+      end
+    end
+  end
+end