runway-ruby 0.1.0

data/lib/runway_ml/image_to_video.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "image_processor"
+require_relative "media_processor"
+require_relative "validators/gen4_turbo_validator"
+require_relative "validators/veo3_validator"
+require_relative "validators/veo3_stable_validator"
+require_relative "validators/gen3a_turbo_validator"
+
+module RunwayML
+  class ImageToVideo
+    VALID_MODELS = [ "gen4_turbo", "veo3.1", "gen3a_turbo", "veo3.1_fast", "veo3" ].freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    def create(model:, prompt_image:, prompt_text:, ratio:, duration:, seed: nil, public_figure_threshold: nil, audio: 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 prompt_image with auto-upload support
+      processed_prompt_image = MediaProcessor.process(
+        prompt_image,
+        errors,
+        client: client,
+        auto_upload: auto_upload
+      )
+
+      # 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
+
+      # Delegate to model-specific validator
+      validator = get_validator(model)
+      result = validator.validate(
+        **build_validator_params(model, processed_prompt_image, prompt_text, ratio, duration, seed, public_figure_threshold, processed_audio || audio)
+      )
+
+      errors = result[:errors]
+      processed_prompt_image = result[:processed_prompt_image]
+
+      raise ValidationError, errors unless errors.empty?
+
+      inputs = build_inputs(model, processed_prompt_image, prompt_text, ratio, duration, seed, public_figure_threshold, processed_audio || audio)
+
+      response = client.post(
+        "image_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 "gen4_turbo"
+        Validators::Gen4TurboValidator.new(image_processor: ImageProcessor.new)
+      when "veo3.1", "veo3.1_fast"
+        Validators::Veo3Validator.new(image_processor: ImageProcessor.new)
+      when "veo3"
+        Validators::Veo3StableValidator.new(image_processor: ImageProcessor.new)
+      when "gen3a_turbo"
+        Validators::Gen3aTurboValidator.new(image_processor: ImageProcessor.new)
+      else
+        raise ArgumentError, "No validator configured for model: #{model}"
+      end
+    end
+
+    def build_validator_params(model, prompt_image, prompt_text, ratio, duration, seed, public_figure_threshold, audio)
+      case model
+      when "gen4_turbo"
+        {
+          prompt_image: prompt_image,
+          prompt_text: prompt_text,
+          ratio: ratio,
+          duration: duration,
+          seed: seed,
+          public_figure_threshold: public_figure_threshold
+        }
+      when "veo3.1", "veo3.1_fast"
+        {
+          prompt_image: prompt_image,
+          prompt_text: prompt_text,
+          ratio: ratio,
+          duration: duration,
+          audio: audio
+        }
+      when "veo3"
+        {
+          prompt_image: prompt_image,
+          prompt_text: prompt_text,
+          ratio: ratio,
+          duration: duration
+        }
+      when "gen3a_turbo"
+        {
+          prompt_image: prompt_image,
+          prompt_text: prompt_text,
+          ratio: ratio,
+          duration: duration,
+          seed: seed,
+          public_figure_threshold: public_figure_threshold
+        }
+      else
+        {}
+      end
+    end
+
+    def build_inputs(model, processed_prompt_image, prompt_text, ratio, duration, seed, public_figure_threshold, audio)
+      inputs = {
+        promptImage: processed_prompt_image,
+        promptText: prompt_text,
+        ratio: ratio,
+        duration: duration
+      }
+
+      case model
+      when "gen4_turbo"
+        inputs[:seed] = seed if seed
+        if public_figure_threshold
+          inputs[:contentModeration] = {
+            publicFigureThreshold: public_figure_threshold
+          }
+        end
+      when "veo3.1", "veo3.1_fast"
+        inputs[:audio] = audio unless audio.nil?
+      when "veo3"
+        # No additional parameters for veo3
+      when "gen3a_turbo"
+        inputs[:seed] = seed if seed
+        if public_figure_threshold
+          inputs[:contentModeration] = {
+            publicFigureThreshold: public_figure_threshold
+          }
+        end
+      end
+
+      inputs
+    end
+  end
+end

data/lib/runway_ml/media_processor.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+require "base64"
+require "stringio"
+
+module RunwayML
+  class MediaProcessor
+    # Processes media files, optionally uploading them to Runway
+    # If auto_upload is true (default), local files/StringIO are uploaded and converted to runway URIs
+    # If auto_upload is false, converts them to data URIs instead
+    def self.process(media, errors, client: nil, auto_upload: true)
+      new(client: client).process(media, errors, auto_upload: auto_upload)
+    end
+
+    def initialize(client: nil)
+      @client = client
+    end
+
+    def process(media, errors, auto_upload: true)
+      return media if media.nil?
+
+      if auto_upload && @client
+        process_with_upload(media, errors)
+      else
+        process_without_upload(media, errors)
+      end
+    end
+
+    private
+
+    attr_reader :client
+
+    # ======================
+    # WITH UPLOAD PROCESSING
+    # ======================
+
+    def process_with_upload(media, errors)
+      case media
+      when Array
+        process_array_with_upload(media, errors)
+      when Hash
+        process_hash_with_upload(media, errors)
+      when String, File, StringIO
+        convert_to_runway_uri(media, errors)
+      else
+        media
+      end
+    end
+
+    def process_array_with_upload(items, errors)
+      items.map do |item|
+        case item
+        when Hash
+          process_hash_with_upload(item, errors)
+        when String, File, StringIO
+          convert_to_runway_uri(item, errors) || item
+        else
+          item
+        end
+      end
+    end
+
+    def process_hash_with_upload(item, errors)
+      return item unless item.is_a?(Hash)
+
+      item = item.dup
+      uri = item[:uri] || item["uri"]
+
+      return item unless uri.is_a?(String) || uri.respond_to?(:read) || (uri.is_a?(String) && looks_like_file_path?(uri))
+
+      converted_uri = convert_to_runway_uri(uri, errors)
+      return item unless converted_uri
+
+      if item.key?(:uri)
+        item[:uri] = converted_uri
+      else
+        item["uri"] = converted_uri
+      end
+
+      item
+    end
+
+    def convert_to_runway_uri(media, errors)
+      return media if media.nil?
+
+      # If it's already a URI, return as-is
+      if media.is_a?(String) && (media.start_with?("https://", "http://", "runway://", "data:"))
+        return media
+      end
+
+      # Check if it's a file path
+      if media.is_a?(String) && looks_like_file_path?(media)
+        upload_file(media, errors)
+      # Check if it's a file-like object
+      elsif media.respond_to?(:read)
+        upload_io(media, errors)
+      else
+        media
+      end
+    end
+
+    def upload_file(path, errors)
+      return nil if client.nil?
+
+      begin
+        uploads = Uploads.new(client: client)
+        uploads.create_ephemeral(path)
+      rescue ValidationError => e
+        errors[:media] = "Failed to upload file: #{e.message}"
+        nil
+      rescue => e
+        errors[:media] = "Error uploading file: #{e.message}"
+        nil
+      end
+    end
+
+    def upload_io(io, errors)
+      return nil if client.nil?
+
+      begin
+        # Determine a good filename
+        filename = if io.respond_to?(:path)
+          File.basename(io.path)
+        else
+          # For StringIO without a path, infer the extension from content type
+          content_type = infer_content_type_for_io(io)
+          ext = infer_extension_for_content_type(content_type)
+          "upload#{ext}"
+        end
+
+        uploads = Uploads.new(client: client)
+        uploads.create_ephemeral(io, filename: filename)
+      rescue ValidationError => e
+        errors[:media] = "Failed to upload file: #{e.message}"
+        nil
+      rescue => e
+        errors[:media] = "Error uploading file: #{e.message}"
+        nil
+      end
+    end
+
+    def infer_content_type_for_io(io)
+      io.rewind if io.respond_to?(:rewind)
+      content = io.read
+      io.rewind if io.respond_to?(:rewind)
+
+      detect_from_magic_bytes(content) || "application/octet-stream"
+    end
+
+    def infer_extension_for_content_type(content_type)
+      {
+        "image/jpeg" => ".jpg",
+        "image/png" => ".png",
+        "image/webp" => ".webp",
+        "audio/mpeg" => ".mp3",
+        "audio/wav" => ".wav",
+        "audio/flac" => ".flac",
+        "audio/mp4" => ".m4a",
+        "audio/aac" => ".aac",
+        "audio/ogg" => ".ogg",
+        "audio/webp" => ".weba",
+        "video/mp4" => ".mp4",
+        "video/quicktime" => ".mov",
+        "video/x-matroska" => ".mkv",
+        "video/webm" => ".webm",
+        "video/3gpp" => ".3gp",
+        "video/ogg" => ".ogv",
+        "video/x-msvideo" => ".avi",
+        "video/x-flv" => ".flv",
+        "video/mpeg" => ".mpg"
+      }[content_type] || ".mp3"  # Default to mp3 for unknown audio
+    end
+
+    # ========================
+    # WITHOUT UPLOAD PROCESSING
+    # ========================
+
+    def process_without_upload(media, errors)
+      case media
+      when Array
+        process_array_without_upload(media, errors)
+      when Hash
+        process_hash_without_upload(media, errors)
+      when String, File, StringIO
+        convert_to_data_uri(media, errors)
+      else
+        media
+      end
+    end
+
+    def process_array_without_upload(items, errors)
+      items.map do |item|
+        case item
+        when Hash
+          process_hash_without_upload(item, errors)
+        when String, File, StringIO
+          convert_to_data_uri(item, errors) || item
+        else
+          item
+        end
+      end
+    end
+
+    def process_hash_without_upload(item, errors)
+      return item unless item.is_a?(Hash)
+
+      item = item.dup
+      uri = item[:uri] || item["uri"]
+
+      return item unless uri.is_a?(String) || uri.respond_to?(:read) || (uri.is_a?(String) && looks_like_file_path?(uri))
+
+      converted_uri = convert_to_data_uri(uri, errors)
+      return item unless converted_uri
+
+      if item.key?(:uri)
+        item[:uri] = converted_uri
+      else
+        item["uri"] = converted_uri
+      end
+
+      item
+    end
+
+    def convert_to_data_uri(media, errors)
+      # If it's already a URI, return as-is
+      if media.is_a?(String) && (media.start_with?("https://", "http://", "runway://", "data:"))
+        return media
+      end
+
+      # Check if it's a file path
+      if media.is_a?(String) && looks_like_file_path?(media)
+        load_file_to_data_uri(media, errors)
+      # Check if it's a file-like object
+      elsif media.respond_to?(:read)
+        convert_io_to_data_uri(media, errors)
+      else
+        media
+      end
+    end
+
+    def load_file_to_data_uri(path, errors)
+      file = File.open(path, "rb")
+      result = convert_io_to_data_uri(file, errors)
+      file.close
+      result
+    rescue Errno::ENOENT
+      errors[:media] = "file not found: #{path}"
+      nil
+    rescue => e
+      errors[:media] = "error reading file: #{e.message}"
+      nil
+    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[:media] = "unable to detect media type"
+        return nil
+      end
+
+      encoded = Base64.strict_encode64(content)
+      "data:#{content_type};base64,#{encoded}"
+    end
+
+    # =======================
+    # CONTENT TYPE DETECTION
+    # =======================
+
+    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
+        mime_type = mime_type_for_extension(ext)
+        return mime_type if mime_type
+      end
+
+      # Detect from magic bytes
+      detect_from_magic_bytes(content)
+    end
+
+    def detect_from_magic_bytes(content)
+      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"
+      elsif content.start_with?("\xFF\xFB".b) || content.start_with?("\xFF\xFA".b)
+        "audio/mpeg"
+      elsif content.start_with?("RIFF".b) && content[8..11] == "WAVE".b
+        "audio/wav"
+      elsif content.start_with?("ftyp".b)
+        "video/mp4"
+      end
+    end
+
+    def mime_type_for_extension(ext)
+      {
+        ".jpg" => "image/jpeg",
+        ".jpeg" => "image/jpeg",
+        ".png" => "image/png",
+        ".webp" => "image/webp",
+        ".mp3" => "audio/mpeg",
+        ".wav" => "audio/wav",
+        ".flac" => "audio/flac",
+        ".m4a" => "audio/mp4",
+        ".aac" => "audio/aac",
+        ".ogg" => "audio/ogg",
+        ".weba" => "audio/webp",
+        ".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"
+      }[ext]
+    end
+
+    # ============
+    # HELPERS
+    # ============
+
+    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
+  end
+end

data/lib/runway_ml/openapi_spec_loader.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require "net/http"
+require "tempfile"
+require "fileutils"
+
+module RunwayML
+  # Loads and caches the OpenAPI spec from the RunwayML GitHub repository
+  class OpenAPISpecLoader
+    SPEC_URL = "https://raw.githubusercontent.com/runwayml/openapi/main/openapi.json"
+    SPEC_HASH = "9cf1febc614000f72d4332f8bee51b6873b6bce49c9bdc02daae300e6882f9dd"
+    CACHE_DIR = File.join(Dir.home, ".cache", "runway-ml-openapi")
+
+    class << self
+      attr_accessor :spec
+
+      def load_spec(force_reload: false)
+        return @spec if @spec && !force_reload
+
+        @spec = fetch_or_cache_spec(force_reload)
+        @spec
+      end
+
+      def get_endpoint_schema(method, path)
+        load_spec
+        path_item = @spec.dig("paths", path)
+        return nil unless path_item
+
+        operation = path_item[method.downcase]
+        return nil unless operation
+
+        operation
+      end
+
+      def get_request_schema(method, path)
+        operation = get_endpoint_schema(method, path)
+        return nil unless operation
+
+        request_body = operation.dig("requestBody", "content", "application/json", "schema")
+        request_body
+      end
+
+      def get_response_schema(method, path, status_code = "200")
+        operation = get_endpoint_schema(method, path)
+        return nil unless operation
+
+        response_schema = operation.dig("responses", status_code, "content", "application/json", "schema")
+        response_schema
+      end
+
+      def get_path_parameters(method, path)
+        operation = get_endpoint_schema(method, path)
+        return [] unless operation
+
+        parameters = operation["parameters"] || []
+        parameters.select { |p| p["in"] == "path" }
+      end
+
+      def get_query_parameters(method, path)
+        operation = get_endpoint_schema(method, path)
+        return [] unless operation
+
+        parameters = operation["parameters"] || []
+        parameters.select { |p| p["in"] == "query" }
+      end
+
+      private
+
+      def fetch_or_cache_spec(force_reload)
+        if force_reload
+          fetch_spec
+        else
+          cached = load_from_cache
+          cached || fetch_and_cache_spec
+        end
+      end
+
+      def load_from_cache
+        cache_file = cache_path
+        return nil unless File.exist?(cache_file)
+
+        # Check if cache is less than 24 hours old
+        if File.mtime(cache_file) > Time.now - (24 * 3600)
+          JSON.parse(File.read(cache_file))
+        else
+          nil
+        end
+      rescue StandardError
+        nil
+      end
+
+      def fetch_and_cache_spec
+        spec = fetch_spec
+        save_to_cache(spec)
+        spec
+      end
+
+      def fetch_spec
+        uri = URI(SPEC_URL)
+        response = Net::HTTP.get(uri)
+        JSON.parse(response)
+      rescue StandardError => e
+        raise "Failed to fetch OpenAPI spec: #{e.message}"
+      end
+
+      def save_to_cache(spec)
+        FileUtils.mkdir_p(CACHE_DIR)
+        File.write(cache_path, JSON.pretty_generate(spec))
+      rescue StandardError
+        # Silently fail cache writes
+      end
+
+      def cache_path
+        File.join(CACHE_DIR, "openapi.json")
+      end
+    end
+  end
+end

data/lib/runway_ml/organization.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module RunwayML
+  class Organization
+    def initialize(client:)
+      @client = client
+    end
+
+    def retrieve
+      response = client.get("organization")
+      OrganizationInfo.new(response)
+    end
+
+    def usage(start_date: nil, before_date: nil)
+      params = {}
+      params[:startDate] = start_date if start_date
+      params[:beforeDate] = before_date if before_date
+
+      response = if params.empty?
+        client.post("organization/usage", {})
+      else
+        client.post("organization/usage", params)
+      end
+
+      UsageInfo.new(response)
+    end
+
+    private
+
+    attr_reader :client
+  end
+
+  class OrganizationInfo
+    attr_reader :tier, :credit_balance, :usage
+
+    def initialize(data)
+      @data = data
+      @tier = data["tier"] || {}
+      @credit_balance = data["creditBalance"] || 0
+      @usage = data["usage"] || {}
+    end
+
+    def max_monthly_credit_spend
+      tier["maxMonthlyCreditSpend"]
+    end
+
+    def tier_models
+      tier["models"] || {}
+    end
+
+    def usage_models
+      usage["models"] || {}
+    end
+
+    def to_h
+      @data
+    end
+
+    def inspect
+      "#<RunwayML::OrganizationInfo tier=#{tier.inspect} credit_balance=#{credit_balance}>"
+    end
+  end
+
+  class UsageInfo
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+    end
+
+    def models
+      data["models"] || {}
+    end
+
+    def by_model
+      models
+    end
+
+    def to_h
+      data
+    end
+
+    def inspect
+      "#<RunwayML::UsageInfo models=#{models.keys.join(', ')}>"
+    end
+  end
+end