runway-ruby 0.1.0

data/lib/runway_ml/sound_effect.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "validators/sound_effect_validator"
+
+module RunwayML
+  class SoundEffect
+    VALID_MODELS = [ "eleven_text_to_sound_v2" ].freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    def create(model:, prompt_text:, duration: nil, loop: false)
+      errors = {}
+
+      unless VALID_MODELS.include?(model)
+        errors[:model] = "must be one of: #{VALID_MODELS.join(', ')}"
+        raise ValidationError, errors
+      end
+
+      validator = Validators::SoundEffectValidator.new
+      result = validator.validate(
+        prompt_text: prompt_text,
+        duration: duration,
+        loop: loop
+      )
+
+      errors = result[:errors]
+      raise ValidationError, errors unless errors.empty?
+
+      inputs = build_inputs(prompt_text, duration, loop)
+
+      response = client.post(
+        "sound_effect",
+        inputs.merge(model: model)
+      )
+
+      Task.new(id: response["id"], client: client)
+    end
+
+    private
+
+    attr_reader :client
+
+    def build_inputs(prompt_text, duration, loop_flag)
+      inputs = {
+        promptText: prompt_text,
+        loop: loop_flag
+      }
+
+      inputs[:duration] = duration unless duration.nil?
+
+      inputs
+    end
+  end
+end

data/lib/runway_ml/spec_coverage_analyzer.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RunwayML
+  # Analyzes coverage of SDK methods against OpenAPI spec endpoints
+  class SpecCoverageAnalyzer
+    CRITICAL_ENDPOINTS = {
+      "POST /v1/text_to_video" => { class: "TextToVideo", method: "create" },
+      "POST /v1/image_to_video" => { class: "ImageToVideo", method: "create" },
+      "POST /v1/text_to_speech" => { class: "TextToSpeech", method: "create" },
+      "POST /v1/speech_to_speech" => { class: "SpeechToSpeech", method: "create" },
+      "POST /v1/sound_effect" => { class: "SoundEffect", method: "create" },
+      "POST /v1/voice_isolation" => { class: "VoiceIsolation", method: "create" },
+      "POST /v1/voice_dubbing" => { class: "VoiceDubbing", method: "create" },
+      "POST /v1/character_performance" => { class: "CharacterPerformance", method: "create" },
+      "POST /v1/video_to_video" => { class: "VideoToVideo", method: "create" },
+      "POST /v1/text_to_image" => { class: "TextToImage", method: "create" },
+      "GET /v1/tasks/{id}" => { class: "Task", method: "retrieve" },
+      "DELETE /v1/tasks/{id}" => { class: "Task", method: "delete" },
+      "GET /v1/organization" => { class: "Organization", method: "retrieve" },
+      "POST /v1/uploads" => { class: "Uploads", method: "create" }
+    }
+
+    class << self
+      def analyze
+        spec = OpenAPISpecLoader.load_spec
+        return nil unless spec
+
+        coverage = {}
+
+        CRITICAL_ENDPOINTS.each do |endpoint, info|
+          method, path = endpoint.split(" ")
+          schema = OpenAPISpecLoader.get_endpoint_schema(method, path)
+
+          coverage[endpoint] = {
+            sdk_class: info[:class],
+            sdk_method: info[:method],
+            spec_exists: !schema.nil?,
+            has_request_schema: has_request_schema_for_endpoint?(method, path),
+            has_response_schema: has_response_schema_for_endpoint?(method, path),
+            models_supported: extract_supported_models(schema, path),
+            path_object: schema
+          }
+        end
+
+        coverage
+      end
+
+      def print_coverage_report
+        coverage = analyze
+        return puts "Could not load OpenAPI spec" unless coverage
+
+        puts "\n" + "=" * 100
+        puts "SDK SPEC COVERAGE REPORT".center(100)
+        puts "=" * 100 + "\n"
+
+        total_endpoints = coverage.size
+        fully_compliant = coverage.count { |_, v| v[:spec_exists] && v[:has_request_schema] && v[:has_response_schema] }
+
+        puts "Summary:"
+        puts "  Total Critical Endpoints: #{total_endpoints}"
+        puts "  Fully Defined in Spec: #{fully_compliant}/#{total_endpoints}"
+        puts "  Compliance Rate: #{(fully_compliant.to_f / total_endpoints * 100).round(1)}%\n\n"
+
+        puts "Endpoint Details:"
+        puts "-" * 100
+
+        coverage.each do |endpoint, data|
+          status = data[:spec_exists] ? "✓" : "✗"
+          models = data[:models_supported].any? ? " [Models: #{data[:models_supported].join(', ')}]" : ""
+
+          puts "#{status} #{endpoint.ljust(35)} -> #{data[:sdk_class]}.#{data[:sdk_method]}#{models}"
+
+          unless data[:spec_exists]
+            puts "    ⚠️  Endpoint not found in OpenAPI spec"
+          else
+            unless data[:has_request_schema]
+              puts "    ⚠️  Missing request schema (expected for GET/DELETE)"
+            end
+            unless data[:has_response_schema]
+              puts "    ⚠️  Missing response schema"
+            end
+          end
+        end
+
+        puts "\n" + "=" * 100 + "\n"
+      end
+
+      private
+
+      def has_request_schema_for_endpoint?(method, path)
+        # GET and DELETE methods don't have request bodies, so skip schema check
+        return true if method.upcase == "GET" || method.upcase == "DELETE"
+
+        OpenAPISpecLoader.get_request_schema(method, path) != nil
+      end
+
+      private
+
+      def has_request_schema_for_endpoint?(method, path)
+        # GET and DELETE methods don't have request bodies, so skip schema check
+        return true if method.upcase == "GET" || method.upcase == "DELETE"
+
+        OpenAPISpecLoader.get_request_schema(method, path) != nil
+      end
+
+      def has_response_schema_for_endpoint?(method, path)
+        # 204 No Content responses are valid without a schema
+        operation = OpenAPISpecLoader.get_endpoint_schema(method, path)
+        return true unless operation
+
+        responses = operation["responses"] || {}
+
+        # Check if 204 No Content is defined (DELETE endpoints)
+        return true if responses.key?("204")
+
+        # Otherwise check for response schema
+        OpenAPISpecLoader.get_response_schema(method, path) != nil
+      end
+
+      def extract_supported_models(schema, path)
+        return [] unless schema
+
+        # For endpoints with oneOf discriminated by model
+        request_schema = schema.dig("requestBody", "content", "application/json", "schema")
+        return [] unless request_schema&.dig("oneOf")
+
+        request_schema["oneOf"].map do |variant|
+          variant.dig("properties", "model", "const") ||
+            variant.dig("title")
+        end.compact
+      end
+    end
+  end
+end

data/lib/runway_ml/speech_to_speech.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "media_processor"
+require_relative "validators/speech_to_speech_validator"
+
+module RunwayML
+  class SpeechToSpeech
+    VALID_MODELS = [ "eleven_multilingual_sts_v2" ].freeze
+    VALID_MEDIA_TYPES = [ "audio", "video" ].freeze
+    VALID_VOICE_TYPES = [ "runway-preset" ].freeze
+    VALID_PRESET_IDS = [
+      "Maya", "Arjun", "Serene", "Bernard", "Billy", "Mark", "Clint", "Mabel", "Chad", "Leslie",
+      "Eleanor", "Elias", "Elliot", "Grungle", "Brodie", "Sandra", "Kirk", "Kylie", "Lara", "Lisa",
+      "Malachi", "Marlene", "Martin", "Miriam", "Monster", "Paula", "Pip", "Rusty", "Ragnar", "Xylar",
+      "Maggie", "Jack", "Katie", "Noah", "James", "Rina", "Ella", "Mariah", "Frank", "Claudia",
+      "Niki", "Vincent", "Kendrick", "Myrna", "Tom", "Wanda", "Benjamin", "Kiana", "Rachel"
+    ].freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    def create(model:, media:, voice:, remove_background_noise: false, auto_upload: true)
+      errors = {}
+
+      unless VALID_MODELS.include?(model)
+        errors[:model] = "must be one of: #{VALID_MODELS.join(', ')}"
+        raise ValidationError, errors
+      end
+
+      # Process media with auto-upload support
+      processed_media = process_media_with_upload(media, errors, auto_upload)
+
+      validator = Validators::SpeechToSpeechValidator.new
+      result = validator.validate(
+        media: processed_media,
+        voice: voice,
+        remove_background_noise: remove_background_noise
+      )
+
+      errors = result[:errors]
+      raise ValidationError, errors unless errors.empty?
+
+      inputs = build_inputs(processed_media, voice, remove_background_noise)
+
+      response = client.post(
+        "speech_to_speech",
+        inputs.merge(model: model)
+      )
+
+      Task.new(id: response["id"], client: client)
+    end
+
+    private
+
+    attr_reader :client
+
+    def process_media_with_upload(media, errors, auto_upload)
+      return media unless media.is_a?(Hash)
+
+      media = media.dup
+      uri = media[:uri] || media["uri"]
+
+      # Process the URI with auto-upload
+      processed_uri = MediaProcessor.process(
+        uri,
+        errors,
+        client: client,
+        auto_upload: auto_upload
+      )
+
+      if media.key?(:uri)
+        media[:uri] = processed_uri
+      else
+        media["uri"] = processed_uri
+      end
+
+      media
+    end
+
+    def build_inputs(media, voice, remove_background_noise)
+      {
+        media: media,
+        voice: voice,
+        removeBackgroundNoise: remove_background_noise
+      }
+    end
+  end
+end

data/lib/runway_ml/task.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "validators/base_validators"
+
+module RunwayML
+  class Task
+    POLL_TIME = 6
+    POLL_JITTER = 3
+
+    attr_reader :id, :status, :created_at, :progress, :failure, :failure_code, :output, :data
+
+    def initialize(id:, client: nil, data: nil)
+      # Only validate UUID for real clients (not TestClient used in specs)
+      validate_task_id(id) if client && !client.is_a?(TestClient)
+      @id = id
+      @client = client
+      apply_data(data) if data
+    end
+
+    def retrieve
+      ensure_client!
+
+      response = client.get("tasks/#{id}")
+      apply_data(response)
+      self
+    end
+
+    def delete
+      ensure_client!
+
+      client.delete("tasks/#{id}")
+      true
+    rescue NotFoundError
+      false
+    end
+
+    def wait_for_output(timeout: 60 * 10)
+      ensure_client!
+
+      start_time = Time.now.to_f
+
+      loop do
+        retrieve
+
+        case status
+        when "SUCCEEDED"
+          return self
+        when "FAILED", "CANCELLED"
+          raise TaskFailedError.new(self)
+        end
+
+        if !timeout.nil? && (Time.now.to_f - start_time) > timeout
+          raise TaskTimeoutError.new(self)
+        end
+
+        sleep(POLL_TIME + (rand * POLL_JITTER) - (POLL_JITTER / 2.0))
+      end
+    end
+
+    def ==(other)
+      other.is_a?(Task) && other.id == id
+    end
+
+    def to_h
+      hash = { id: id }
+      hash[:status] = status if status
+      hash[:created_at] = created_at if created_at
+      hash[:progress] = progress if progress
+      hash[:failure] = failure if failure
+      hash[:failure_code] = failure_code if failure_code
+      hash[:output] = output if output
+      hash
+    end
+
+    def to_json
+      to_h.to_json
+    end
+
+    def to_s
+      "#<RunwayML::Task id=#{id}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    private
+
+    attr_reader :client
+
+    def ensure_client!
+      return if client
+
+      raise ArgumentError, "Task client is required to retrieve or delete tasks"
+    end
+
+    def validate_task_id(task_id)
+      validator = Validators::UUIDValidator.new
+      errors = {}
+      validator.validate(task_id, errors, field: :id)
+      raise ValidationError, errors if errors.any?
+    end
+
+    def apply_data(payload)
+      return unless payload.is_a?(Hash)
+
+      @data = payload
+      @status = payload["status"] || payload[:status]
+      @created_at = payload["createdAt"] || payload[:created_at]
+      @progress = payload["progress"] || payload[:progress]
+      @failure = payload["failure"] || payload[:failure]
+      @failure_code = payload["failureCode"] || payload[:failure_code]
+      @output = payload["output"] || payload[:output]
+    end
+  end
+end

data/lib/runway_ml/test_client.rb

@@ -0,0 +1,62 @@
+module RunwayML
+  class TestClient
+    def initialize(api_secret: nil, base_url: nil, api_version: nil)
+      reset!
+    end
+
+    def post(path, params)
+      record_request(:post, path, params)
+      fetch_response(:post, path, params)
+    end
+
+    def get(path)
+      record_request(:get, path, nil)
+      fetch_response(:get, path)
+    end
+
+    def delete(path)
+      record_request(:delete, path, nil)
+      fetch_response(:delete, path)
+    end
+
+    # Inject a response for a given method/path/params
+    def inject_response(method, path, params: nil, response:)
+      key = response_key(method, path, params)
+      @responses[key] = response
+    end
+
+    def requests
+      @requests.dup
+    end
+
+    def reset!
+      @responses = {}
+      @requests = []
+    end
+
+    private
+
+    def fetch_response(method, path, params = nil)
+      key = response_key(method, path, params)
+      unless @responses.key?(key)
+        raise "No injected response for #{method.upcase} #{path} with params: #{params.inspect}"
+      end
+      response = @responses[key]
+      if response.is_a?(Array)
+        raise "No injected response remaining for #{method.upcase} #{path} with params: #{params.inspect}" if response.empty?
+        response = response.shift
+      end
+      raise response if response.is_a?(Exception)
+
+      response
+    end
+
+    def record_request(method, path, params)
+      @requests << { method: method, path: path, params: params }
+    end
+
+    def response_key(method, path, params)
+      [ method, path, params ]
+    end
+  end
+end

data/lib/runway_ml/text_to_speech.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "validators/text_to_speech_validator"
+
+module RunwayML
+  class TextToSpeech
+    VALID_MODELS = [ "eleven_multilingual_v2" ].freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    def create(model:, prompt_text:, voice:)
+      errors = {}
+
+      unless VALID_MODELS.include?(model)
+        errors[:model] = "must be one of: #{VALID_MODELS.join(', ')}"
+        raise ValidationError, errors
+      end
+
+      validator = Validators::TextToSpeechValidator.new
+      result = validator.validate(
+        prompt_text: prompt_text,
+        voice: voice
+      )
+
+      errors = result[:errors]
+      raise ValidationError, errors unless errors.empty?
+
+      inputs = build_inputs(prompt_text, voice)
+
+      response = client.post(
+        "text_to_speech",
+        inputs.merge(model: model)
+      )
+
+      Task.new(id: response["id"], client: client)
+    end
+
+    private
+
+    attr_reader :client
+
+    def build_inputs(prompt_text, voice)
+      {
+        promptText: prompt_text,
+        voice: voice
+      }
+    end
+  end
+end

data/lib/runway_ml/text_to_video.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "media_processor"
+require_relative "validators/text_veo3_validator"
+require_relative "validators/text_veo3_stable_validator"
+
+module RunwayML
+  class TextToVideo
+    VALID_MODELS = [ "veo3.1", "veo3.1_fast", "veo3" ].freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    def create(model:, prompt_text:, ratio:, duration:, audio: nil, auto_upload: true)
+      errors = {}
+
+      unless VALID_MODELS.include?(model)
+        errors[:model] = "must be one of: #{VALID_MODELS.join(', ')}"
+        raise ValidationError, errors
+      end
+
+      # Process audio with auto-upload support if provided
+      processed_audio = if audio && audio != false
+        MediaProcessor.process(
+          audio,
+          errors,
+          client: client,
+          auto_upload: auto_upload
+        )
+      end
+
+      validator = get_validator(model)
+      result = validator.validate(**build_validator_params(model, prompt_text, ratio, duration, processed_audio || audio))
+
+      errors = result[:errors]
+      raise ValidationError, errors unless errors.empty?
+
+      inputs = build_inputs(model, prompt_text, ratio, duration, processed_audio || audio)
+
+      response = client.post(
+        "text_to_video",
+        inputs.merge(model: model)
+      )
+
+      Task.new(id: response["id"], client: client)
+    end
+
+    private
+
+    attr_reader :client
+
+    def get_validator(model)
+      case model
+      when "veo3.1", "veo3.1_fast"
+        Validators::TextVeo3Validator.new
+      when "veo3"
+        Validators::TextVeo3StableValidator.new
+      else
+        raise ArgumentError, "No validator configured for model: #{model}"
+      end
+    end
+
+    def build_validator_params(model, prompt_text, ratio, duration, audio)
+      case model
+      when "veo3.1", "veo3.1_fast"
+        {
+          prompt_text: prompt_text,
+          ratio: ratio,
+          duration: duration,
+          audio: audio
+        }
+      when "veo3"
+        {
+          prompt_text: prompt_text,
+          ratio: ratio,
+          duration: duration,
+          audio: audio
+        }
+      else
+        {}
+      end
+    end
+
+    def build_inputs(model, prompt_text, ratio, duration, audio)
+      inputs = {
+        promptText: prompt_text,
+        ratio: ratio,
+        duration: duration
+      }
+
+      case model
+      when "veo3.1", "veo3.1_fast"
+        inputs[:audio] = audio unless audio.nil?
+      when "veo3"
+        # audio not supported for veo3
+      end
+
+      inputs
+    end
+  end
+end

data/lib/runway_ml/uploads.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "validators/uploads_validator"
+
+module RunwayML
+  class Uploads
+    VALID_TYPES = [ "ephemeral" ].freeze
+    SUPPORTED_EXTENSIONS = {
+      # Image extensions
+      "jpg" => "image/jpeg",
+      "jpeg" => "image/jpeg",
+      "png" => "image/png",
+      "webp" => "image/webp",
+      # Video extensions
+      "mp4" => "video/mp4",
+      "mov" => "video/quicktime",
+      "mkv" => "video/x-matroska",
+      "webm" => "video/webm",
+      "3gp" => "video/3gpp",
+      "ogv" => "video/ogg",
+      "avi" => "video/x-msvideo",
+      "flv" => "video/x-flv",
+      "mpg" => "video/mpeg",
+      "mpeg" => "video/mpeg",
+      # Audio extensions
+      "mp3" => "audio/mpeg",
+      "wav" => "audio/wav",
+      "flac" => "audio/flac",
+      "m4a" => "audio/mp4",
+      "aac" => "audio/aac",
+      "ogg" => "audio/ogg",
+      "weba" => "audio/webp"
+    }.freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    def create_ephemeral(file_or_path, filename: nil)
+      if file_or_path.is_a?(String)
+        # It's a file path
+        unless File.exist?(file_or_path)
+          raise ValidationError, { file_path: "file does not exist" }
+        end
+        file_path = file_or_path
+        filename ||= File.basename(file_path)
+      elsif file_or_path.respond_to?(:read)
+        # It's a File object or StringIO
+        filename ||= file_or_path.respond_to?(:path) ? File.basename(file_or_path.path) : "upload"
+      else
+        raise ValidationError, { file: "must be a file path string or File-like object" }
+      end
+
+      errors = {}
+
+      # Validate filename
+      validator = Validators::UploadsValidator.new
+      result = validator.validate(filename: filename)
+      errors.merge!(result[:errors])
+
+      raise ValidationError, errors unless errors.empty?
+
+      # Request upload URL from API
+      response = client.post("uploads", { filename: filename, type: "ephemeral" })
+
+      response["runwayUri"]
+    end
+
+    private
+
+    attr_reader :client
+  end
+end