runway-ruby 0.1.0

data/lib/runway_ml/validators/speech_to_speech_validator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "base_validators"
+require_relative "voice_validator"
+
+module RunwayML
+  module Validators
+    class SpeechToSpeechValidator
+      def initialize
+        @voice_validator = VoiceValidator.new
+      end
+
+      def validate(media:, voice:, remove_background_noise:)
+        errors = {}
+
+        validate_media(media, errors)
+        voice_validator.validate(voice, errors)
+        validate_remove_background_noise(remove_background_noise, errors)
+
+        { errors: errors }
+      end
+
+      private
+
+      attr_reader :voice_validator
+
+      def validate_media(media, errors)
+        if media.nil?
+          errors[:media] = "cannot be empty"
+          return
+        end
+
+        unless media.is_a?(Hash)
+          errors[:media] = "must be a hash"
+          return
+        end
+
+        media_type = media[:type]
+        media_uri = media[:uri]
+
+        unless SpeechToSpeech::VALID_MEDIA_TYPES.include?(media_type)
+          errors[:media] = "type must be one of: #{SpeechToSpeech::VALID_MEDIA_TYPES.join(', ')}"
+        end
+
+        if media_uri.nil? || media_uri.empty?
+          errors[:media] = "uri cannot be empty" if errors[:media].nil?
+        end
+      end
+
+      def validate_remove_background_noise(remove_background_noise, errors)
+        unless [ true, false ].include?(remove_background_noise)
+          errors[:remove_background_noise] = "must be a boolean"
+        end
+      end
+    end
+  end
+end

data/lib/runway_ml/validators/text_to_speech_validator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base_validators"
+require_relative "voice_validator"
+
+module RunwayML
+  module Validators
+    class TextToSpeechValidator
+      def initialize
+        @prompt_text_validator = PromptTextValidator.new(max_length: 1000, required: true)
+        @voice_validator = VoiceValidator.new
+      end
+
+      def validate(prompt_text:, voice:)
+        errors = {}
+
+        prompt_text_validator.validate(prompt_text, errors)
+        voice_validator.validate(voice, errors)
+
+        { errors: errors }
+      end
+
+      private
+
+      attr_reader :prompt_text_validator, :voice_validator
+    end
+  end
+end

data/lib/runway_ml/validators/text_veo3_stable_validator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "base_validators"
+
+module RunwayML
+  module Validators
+    class TextVeo3StableValidator
+      def initialize
+        @ratio_validator = RatioValidator.new(
+          valid_ratios: [ "1280:720", "720:1280", "1080:1920", "1920:1080" ]
+        )
+        @prompt_text_validator = PromptTextValidator.new(max_length: 1000, required: true)
+        @duration_validator = DurationValidator.new(exact: 8)
+      end
+
+      def validate(prompt_text:, ratio:, duration:, audio: nil)
+        errors = {}
+
+        ratio_validator.validate(ratio, errors)
+        prompt_text_validator.validate(prompt_text, errors)
+        duration_validator.validate(duration, errors)
+
+        if !audio.nil?
+          errors[:audio] = "is not supported for model veo3"
+        end
+
+        { errors: errors }
+      end
+
+      private
+
+      attr_reader :ratio_validator, :prompt_text_validator, :duration_validator
+    end
+  end
+end

data/lib/runway_ml/validators/text_veo3_validator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "base_validators"
+
+module RunwayML
+  module Validators
+    class TextVeo3Validator
+      def initialize
+        @ratio_validator = RatioValidator.new(
+          valid_ratios: [ "1280:720", "720:1280", "1080:1920", "1920:1080" ]
+        )
+        @prompt_text_validator = PromptTextValidator.new(max_length: 1000, required: true)
+        @duration_validator = DurationValidator.new(valid_values: [ 4, 6, 8 ])
+        @audio_validator = AudioValidator.new
+      end
+
+      def validate(prompt_text:, ratio:, duration:, audio: nil)
+        errors = {}
+
+        ratio_validator.validate(ratio, errors)
+        prompt_text_validator.validate(prompt_text, errors)
+        duration_validator.validate(duration, errors)
+        audio_validator.validate(audio, errors)
+
+        { errors: errors }
+      end
+
+      private
+
+      attr_reader :ratio_validator, :prompt_text_validator, :duration_validator, :audio_validator
+    end
+  end
+end

data/lib/runway_ml/validators/uploads_validator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RunwayML
+  module Validators
+    class UploadsValidator
+      def initialize
+      end
+
+      def validate(filename:)
+        errors = {}
+
+        validate_filename(filename, errors)
+
+        { errors: errors }
+      end
+
+      private
+
+      def validate_filename(filename, errors)
+        unless filename.is_a?(String)
+          errors[:filename] = "must be a string"
+          return
+        end
+
+        if filename.nil? || filename.empty?
+          errors[:filename] = "cannot be empty"
+          return
+        end
+
+        if filename.length < 3 || filename.length > 255
+          errors[:filename] = "must be between 3 and 255 characters"
+          return
+        end
+
+        # Extract extension
+        extension = filename.split(".").last&.downcase
+        unless extension && Uploads::SUPPORTED_EXTENSIONS.key?(extension)
+          errors[:filename] = "must have a valid extension. Supported: #{Uploads::SUPPORTED_EXTENSIONS.keys.join(', ')}"
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/runway_ml/validators/veo3_stable_validator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "base_validators"
+require_relative "prompt_image_validator"
+
+module RunwayML
+  module Validators
+    class Veo3StableValidator
+      def initialize(image_processor:)
+        @image_processor = image_processor
+        @ratio_validator = RatioValidator.new(
+          valid_ratios: [ "1280:720", "720:1280", "1080:1920", "1920:1080" ]
+        )
+        @prompt_text_validator = PromptTextValidator.new(max_length: 1000, required: false)
+        @duration_validator = DurationValidator.new(exact: 8)
+        @prompt_image_validator = PromptImageValidator.new(
+          image_processor: image_processor,
+          array_size: 1,
+          valid_positions: [ "first" ]
+        )
+      end
+
+      def validate(prompt_image:, prompt_text:, ratio:, duration:)
+        errors = {}
+
+        ratio_validator.validate(ratio, errors)
+        prompt_text_validator.validate(prompt_text, errors)
+        duration_validator.validate(duration, errors)
+
+        # Process and validate prompt_image
+        processed_prompt_image = image_processor.process(prompt_image, errors)
+        prompt_image_validator.validate(processed_prompt_image, errors)
+
+        { errors: errors, processed_prompt_image: processed_prompt_image }
+      end
+
+      private
+
+      attr_reader :image_processor, :ratio_validator, :prompt_text_validator,
+                  :duration_validator, :prompt_image_validator
+    end
+  end
+end

data/lib/runway_ml/validators/veo3_validator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "base_validators"
+require_relative "prompt_image_validator"
+
+module RunwayML
+  module Validators
+    class Veo3Validator
+      def initialize(image_processor:)
+        @image_processor = image_processor
+        @ratio_validator = RatioValidator.new(
+          valid_ratios: [ "1280:720", "720:1280", "1080:1920", "1920:1080" ]
+        )
+        @prompt_text_validator = PromptTextValidator.new(max_length: 1000, required: true)
+        @duration_validator = DurationValidator.new(valid_values: [ 4, 6, 8 ])
+        @audio_validator = AudioValidator.new
+        @prompt_image_validator = PromptImageValidator.new(
+          image_processor: image_processor,
+          array_size: 1..2,
+          valid_positions: [ "first", "last" ],
+          only_first_frame: true
+        )
+      end
+
+      def validate(prompt_image:, prompt_text:, ratio:, duration:, audio:)
+        errors = {}
+
+        ratio_validator.validate(ratio, errors)
+        prompt_text_validator.validate(prompt_text, errors)
+        duration_validator.validate(duration, errors)
+        audio_validator.validate(audio, errors)
+
+        # Process and validate prompt_image
+        processed_prompt_image = image_processor.process(prompt_image, errors)
+        prompt_image_validator.validate(processed_prompt_image, errors)
+
+        { errors: errors, processed_prompt_image: processed_prompt_image }
+      end
+
+      private
+
+      attr_reader :image_processor, :ratio_validator, :prompt_text_validator,
+                  :duration_validator, :audio_validator, :prompt_image_validator
+    end
+  end
+end

data/lib/runway_ml/validators/voice_dubbing_validator.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "base_validators"
+
+module RunwayML
+  module Validators
+    class VoiceDubbingValidator
+      def initialize
+        @audio_uri_validator = AudioUriValidator.new
+      end
+
+      def validate(audio_uri:, target_lang:, disable_voice_cloning:, drop_background_audio:, num_speakers:)
+        errors = {}
+
+        validate_audio_uri(audio_uri, errors)
+        validate_target_lang(target_lang, errors)
+        validate_disable_voice_cloning(disable_voice_cloning, errors)
+        validate_drop_background_audio(drop_background_audio, errors)
+        validate_num_speakers(num_speakers, errors)
+
+        { errors: errors }
+      end
+
+      private
+
+      attr_reader :audio_uri_validator
+
+      def validate_audio_uri(audio_uri, errors)
+        if audio_uri.nil? || (audio_uri.is_a?(String) && audio_uri.empty?)
+          errors[:audio_uri] = "cannot be empty"
+          return
+        end
+
+        audio_uri_validator.validate(audio_uri, errors, field: :audio_uri)
+      end
+
+      def validate_target_lang(target_lang, errors)
+        if target_lang.nil? || target_lang.empty?
+          errors[:target_lang] = "cannot be empty"
+          return
+        end
+
+        unless VoiceDubbing::VALID_TARGET_LANGS.include?(target_lang)
+          errors[:target_lang] = "must be one of: #{VoiceDubbing::VALID_TARGET_LANGS.join(', ')}"
+        end
+      end
+
+      def validate_disable_voice_cloning(disable_voice_cloning, errors)
+        return if disable_voice_cloning.nil?
+
+        unless [ true, false ].include?(disable_voice_cloning)
+          errors[:disable_voice_cloning] = "must be a boolean"
+        end
+      end
+
+      def validate_drop_background_audio(drop_background_audio, errors)
+        return if drop_background_audio.nil?
+
+        unless [ true, false ].include?(drop_background_audio)
+          errors[:drop_background_audio] = "must be a boolean"
+        end
+      end
+
+      def validate_num_speakers(num_speakers, errors)
+        return if num_speakers.nil?
+
+        unless num_speakers.is_a?(Integer)
+          errors[:num_speakers] = "must be an integer"
+          return
+        end
+
+        if num_speakers < 0 || num_speakers > 9007199254740991
+          errors[:num_speakers] = "must be between 0 and 9007199254740991"
+        end
+      end
+    end
+
+    class AudioUriValidator
+      VALID_CONTENT_TYPES = [ "audio/mpeg", "audio/mp3", "audio/wav", "audio/flac", "audio/m4a", "audio/aac", "audio/ogg", "audio/webm" ].freeze
+
+      def validate(uri, errors, field: :audio_uri)
+        return unless uri.is_a?(String)
+
+        if uri.length < 13
+          errors[field] = "URI must be at least 13 characters"
+          return
+        end
+
+        if uri.start_with?("https://")
+          validate_https_url(uri, errors, field)
+        elsif uri.start_with?("runway://")
+          validate_runway_uri(uri, errors, field)
+        elsif uri.start_with?("data:audio/")
+          validate_data_uri(uri, errors, field)
+        else
+          errors[field] = "must be a valid HTTPS URL, Runway URI (runway://), or data URI (data:audio/)"
+        end
+      end
+
+      private
+
+      def validate_https_url(uri, errors, field)
+        if uri.length > 2048
+          errors[field] = "HTTPS URL must be at most 2048 characters"
+        end
+      end
+
+      def validate_runway_uri(uri, errors, field)
+        if uri.length > 5000
+          errors[field] = "Runway URI must be at most 5000 characters"
+        end
+      end
+
+      def validate_data_uri(uri, errors, field)
+        if uri.length > 16777216
+          errors[field] = "Data URI must be at most 16777216 characters"
+          return
+        end
+
+        content_type_match = uri.match(/^data:(audio\/[^;,]+)/)
+        return unless content_type_match
+
+        content_type = content_type_match[1]
+        errors[field] = "unsupported audio type '#{content_type}'" unless VALID_CONTENT_TYPES.include?(content_type)
+      end
+    end
+  end
+end

data/lib/runway_ml/validators/voice_isolation_validator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "base_validators"
+require_relative "voice_dubbing_validator"
+
+module RunwayML
+  module Validators
+    class VoiceIsolationValidator
+      def initialize
+        @audio_uri_validator = AudioUriValidator.new
+      end
+
+      def validate(audio_uri:)
+        errors = {}
+
+        validate_audio_uri(audio_uri, errors)
+
+        { errors: errors }
+      end
+
+      private
+
+      attr_reader :audio_uri_validator
+
+      def validate_audio_uri(audio_uri, errors)
+        if audio_uri.nil? || (audio_uri.is_a?(String) && audio_uri.empty?)
+          errors[:audio_uri] = "cannot be empty"
+          return
+        end
+
+        audio_uri_validator.validate(audio_uri, errors, field: :audio_uri)
+      end
+    end
+  end
+end

data/lib/runway_ml/validators/voice_validator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base_validators"
+
+module RunwayML
+  module Validators
+    class VoiceValidator
+      def validate(voice, errors)
+        if voice.nil?
+          errors[:voice] = "cannot be empty"
+          return
+        end
+
+        unless voice.is_a?(Hash)
+          errors[:voice] = "must be a hash"
+          return
+        end
+
+        voice_type = voice[:type]
+        preset_id = voice[:presetId]
+
+        unless SpeechToSpeech::VALID_VOICE_TYPES.include?(voice_type)
+          errors[:voice] = "type must be one of: #{SpeechToSpeech::VALID_VOICE_TYPES.join(', ')}"
+        end
+
+        unless SpeechToSpeech::VALID_PRESET_IDS.include?(preset_id)
+          errors[:voice] = "presetId must be one of: #{SpeechToSpeech::VALID_PRESET_IDS.join(', ')}" if errors[:voice].nil?
+        end
+      end
+    end
+  end
+end

data/lib/runway_ml/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RunwayML
+  VERSION = "0.1.0"
+end

data/lib/runway_ml/voice_dubbing.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "media_processor"
+require_relative "validators/voice_dubbing_validator"
+
+module RunwayML
+  class VoiceDubbing
+    VALID_MODELS = [ "eleven_voice_dubbing" ].freeze
+    VALID_TARGET_LANGS = [
+      "en", "hi", "pt", "zh", "es", "fr", "de", "ja", "ar", "ru", "ko", "id", "it", "nl", "tr",
+      "pl", "sv", "fil", "ms", "ro", "uk", "el", "cs", "da", "fi", "bg", "hr", "sk", "ta"
+    ].freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    def create(model:, audio_uri:, target_lang:, disable_voice_cloning: nil, drop_background_audio: nil, num_speakers: 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_uri with auto-upload support
+      processed_audio_uri = MediaProcessor.process(
+        audio_uri,
+        errors,
+        client: client,
+        auto_upload: auto_upload
+      )
+
+      validator = Validators::VoiceDubbingValidator.new
+      result = validator.validate(
+        audio_uri: processed_audio_uri,
+        target_lang: target_lang,
+        disable_voice_cloning: disable_voice_cloning,
+        drop_background_audio: drop_background_audio,
+        num_speakers: num_speakers
+      )
+
+      errors = result[:errors]
+      raise ValidationError, errors unless errors.empty?
+
+      inputs = build_inputs(processed_audio_uri, target_lang, disable_voice_cloning, drop_background_audio, num_speakers)
+
+      response = client.post(
+        "voice_dubbing",
+        inputs.merge(model: model)
+      )
+
+      Task.new(id: response["id"], client: client)
+    end
+
+    private
+
+    attr_reader :client
+
+    def build_inputs(audio_uri, target_lang, disable_voice_cloning, drop_background_audio, num_speakers)
+      inputs = {
+        audioUri: audio_uri,
+        targetLang: target_lang
+      }
+
+      inputs[:disableVoiceCloning] = disable_voice_cloning unless disable_voice_cloning.nil?
+      inputs[:dropBackgroundAudio] = drop_background_audio unless drop_background_audio.nil?
+      inputs[:numSpeakers] = num_speakers unless num_speakers.nil?
+
+      inputs
+    end
+  end
+end

data/lib/runway_ml/voice_isolation.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "media_processor"
+require_relative "validators/voice_isolation_validator"
+
+module RunwayML
+  class VoiceIsolation
+    VALID_MODELS = [ "eleven_voice_isolation" ].freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    def create(model:, audio_uri:, auto_upload: true)
+      errors = {}
+
+      unless VALID_MODELS.include?(model)
+        errors[:model] = "must be one of: #{VALID_MODELS.join(', ')}"
+        raise ValidationError, errors
+      end
+
+      # Process audio_uri with auto-upload support
+      processed_audio_uri = MediaProcessor.process(
+        audio_uri,
+        errors,
+        client: client,
+        auto_upload: auto_upload
+      )
+
+      validator = Validators::VoiceIsolationValidator.new
+      result = validator.validate(audio_uri: processed_audio_uri)
+
+      errors = result[:errors]
+      raise ValidationError, errors unless errors.empty?
+
+      inputs = build_inputs(processed_audio_uri)
+
+      response = client.post(
+        "voice_isolation",
+        inputs.merge(model: model)
+      )
+
+      Task.new(id: response["id"], client: client)
+    end
+
+    private
+
+    attr_reader :client
+
+    def build_inputs(audio_uri)
+      {
+        audioUri: audio_uri
+      }
+    end
+  end
+end