runapi-suno 0.1.0

data/lib/runapi/suno/resources/get_timestamped_lyrics.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RunApi
+  module Suno
+    module Resources
+      class GetTimestampedLyrics
+        include RunApi::Core::ResourceHelpers
+
+        ENDPOINT = "/api/v1/suno/get_timestamped_lyrics"
+        RESPONSE_CLASS = Types::GetTimestampedLyricsResponse
+
+        def initialize(http)
+          @http = http
+        end
+
+        def run(**params)
+          params = compact_params(params)
+          validate_params!(params)
+          request(:post, ENDPOINT, body: params)
+        end
+
+        private
+
+        def validate_params!(params)
+          Validators.validate_get_timestamped_lyrics!(params, self)
+        end
+      end
+    end
+  end
+end

data/lib/runapi/suno/resources/replace_section.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RunApi
+  module Suno
+    module Resources
+      class ReplaceSection
+        include RunApi::Core::ResourceHelpers
+
+        ENDPOINT = "/api/v1/suno/replace_section"
+        RESPONSE_CLASS = Types::ReplaceSectionResponse
+        COMPLETED_RESPONSE_CLASS = Types::CompletedReplaceSectionResponse
+
+        def initialize(http)
+          @http = http
+        end
+
+        def run(**params)
+          task = create(**params)
+          poll_until_complete { get(task.id) }
+        end
+
+        def create(**params)
+          params = compact_params(params)
+          validate_params!(params)
+          request(:post, ENDPOINT, body: params)
+        end
+
+        def get(id)
+          request(:get, "#{ENDPOINT}/#{id}")
+        end
+
+        private
+
+        def validate_params!(params)
+          Validators.validate_replace_section!(params, self)
+        end
+      end
+    end
+  end
+end

data/lib/runapi/suno/resources/separate_audio_stems.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RunApi
+  module Suno
+    module Resources
+      class SeparateAudioStems
+        include RunApi::Core::ResourceHelpers
+
+        ENDPOINT = "/api/v1/suno/separate_audio_stems"
+        RESPONSE_CLASS = Types::SeparateAudioStemsResponse
+        COMPLETED_RESPONSE_CLASS = Types::CompletedSeparateAudioStemsResponse
+
+        def initialize(http)
+          @http = http
+        end
+
+        def run(**params)
+          task = create(**params)
+          poll_until_complete { get(task.id) }
+        end
+
+        def create(**params)
+          params = compact_params(params)
+          validate_params!(params)
+          request(:post, ENDPOINT, body: params)
+        end
+
+        def get(id)
+          request(:get, "#{ENDPOINT}/#{id}")
+        end
+
+        private
+
+        def validate_params!(params)
+          Validators.validate_separate_audio_stems!(params, self)
+        end
+      end
+    end
+  end
+end

data/lib/runapi/suno/resources/text_to_music.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RunApi
+  module Suno
+    module Resources
+      class TextToMusic
+        include RunApi::Core::ResourceHelpers
+
+        ENDPOINT = "/api/v1/suno/text_to_music"
+        RESPONSE_CLASS = Types::TextToMusicResponse
+        COMPLETED_RESPONSE_CLASS = Types::CompletedTextToMusicResponse
+
+        def initialize(http)
+          @http = http
+        end
+
+        def run(**params)
+          task = create(**params)
+          poll_until_complete { get(task.id) }
+        end
+
+        def create(**params)
+          params = compact_params(params)
+          validate_params!(params)
+          request(:post, ENDPOINT, body: params)
+        end
+
+        def get(id)
+          request(:get, "#{ENDPOINT}/#{id}")
+        end
+
+        private
+
+        def validate_params!(params)
+          Validators.validate_text_to_music!(params, self)
+        end
+      end
+    end
+  end
+end

data/lib/runapi/suno/resources/text_to_sound.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RunApi
+  module Suno
+    module Resources
+      class TextToSound
+        include RunApi::Core::ResourceHelpers
+
+        ENDPOINT = "/api/v1/suno/text_to_sound"
+        RESPONSE_CLASS = Types::TextToSoundResponse
+        COMPLETED_RESPONSE_CLASS = Types::CompletedTextToSoundResponse
+
+        def initialize(http)
+          @http = http
+        end
+
+        def run(**params)
+          task = create(**params)
+          poll_until_complete { get(task.id) }
+        end
+
+        def create(**params)
+          params = compact_params(params)
+          validate_params!(params)
+          request(:post, ENDPOINT, body: params)
+        end
+
+        def get(id)
+          request(:get, "#{ENDPOINT}/#{id}")
+        end
+
+        private
+
+        def validate_params!(params)
+          Validators.validate_text_to_sound!(params, self)
+        end
+      end
+    end
+  end
+end

data/lib/runapi/suno/resources/visualize_music.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RunApi
+  module Suno
+    module Resources
+      class VisualizeMusic
+        include RunApi::Core::ResourceHelpers
+
+        ENDPOINT = "/api/v1/suno/visualize_music"
+        RESPONSE_CLASS = Types::VisualizeMusicResponse
+        COMPLETED_RESPONSE_CLASS = Types::CompletedVisualizeMusicResponse
+
+        def initialize(http)
+          @http = http
+        end
+
+        def run(**params)
+          task = create(**params)
+          poll_until_complete { get(task.id) }
+        end
+
+        def create(**params)
+          params = compact_params(params)
+          validate_params!(params)
+          request(:post, ENDPOINT, body: params)
+        end
+
+        def get(id)
+          request(:get, "#{ENDPOINT}/#{id}")
+        end
+
+        private
+
+        def validate_params!(params)
+          Validators.validate_visualize_music!(params, self)
+        end
+      end
+    end
+  end
+end

data/lib/runapi/suno/types.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module RunApi
+  module Suno
+    module Types
+      MODELS = %w[V5_5 V5 V4_5PLUS V4_5ALL V4_5 V4 V3_5].freeze
+      SOUND_MODELS = %w[V5 V5_5].freeze
+      SOUND_KEYS = %w[
+        Cm C#m Dm D#m Em Fm F#m Gm G#m Am A#m Bm
+        C C# D D# E F F# G G# A A# B
+      ].freeze
+      VOCAL_GENDERS = %w[f m].freeze
+      PERSONA_MODELS = %w[style_persona voice_persona].freeze
+      SEPARATE_AUDIO_STEMS_TYPES = %w[separate_vocal split_stem].freeze
+
+      class Audio < RunApi::Core::BaseModel
+        optional :id, String
+        optional :audio_url, String
+        optional :stream_audio_url, String
+        optional :image_url, String
+        optional :prompt, String
+        optional :model_name, String
+        optional :title, String
+        optional :tags, [ String ]
+        optional :duration, Numeric
+      end
+
+      class Cover < RunApi::Core::BaseModel
+        required :url, String
+      end
+
+      class AlignedWord < RunApi::Core::BaseModel
+        required :word, String
+        required :success
+        required :start_time, Numeric
+        required :end_time, Numeric
+        required :palign, Numeric
+      end
+
+      class SeparatedAudio < RunApi::Core::BaseModel
+        optional :vocal_url, String
+        optional :instrumental_url, String
+        optional :backing_vocals_url, String
+        optional :bass_url, String
+        optional :brass_url, String
+        optional :drums_url, String
+        optional :fx_url, String
+        optional :guitar_url, String
+        optional :keyboard_url, String
+        optional :percussion_url, String
+        optional :piano_url, String
+        optional :strings_url, String
+        optional :synth_url, String
+        optional :woodwinds_url, String
+      end
+
+      class MidiNote < RunApi::Core::BaseModel
+        required :pitch, Numeric
+        required :start_time, Numeric
+        required :end_time, Numeric
+        required :velocity, Numeric
+      end
+
+      class MidiInstrument < RunApi::Core::BaseModel
+        required :name, String
+        optional :notes, [ -> { MidiNote } ]
+      end
+
+      class Lyric < RunApi::Core::BaseModel
+        optional :title, String
+        required :text, String
+      end
+
+      class Persona < RunApi::Core::BaseModel
+        required :id, String
+        required :name, String
+        required :description, String
+      end
+
+      class AsyncTaskResponse < RunApi::Core::TaskResponse
+        required :id, String
+        required :status, String, enum: -> { RunApi::Core::TaskResponse::Status::ALL }
+        optional :generation_stage, String
+        optional :error, String
+      end
+
+      class TextToMusicResponse < AsyncTaskResponse
+        optional :audios, [ -> { Audio } ]
+        optional :audio_url, String
+      end
+
+      class ExtendMusicResponse < AsyncTaskResponse
+        optional :audios, [ -> { Audio } ]
+        optional :original_task_id, String
+      end
+
+      class GenerateArtworkResponse < AsyncTaskResponse
+        optional :covers, [ -> { Cover } ]
+      end
+
+      class CoverAudioResponse < AsyncTaskResponse
+        optional :audios, [ -> { Audio } ]
+      end
+
+      class AddInstrumentalResponse < TextToMusicResponse; end
+      class AddVocalsResponse < TextToMusicResponse; end
+      class TextToSoundResponse < TextToMusicResponse; end
+
+      class SeparateAudioStemsResponse < AsyncTaskResponse
+        optional :separated_audios, -> { SeparatedAudio }
+      end
+
+      class GenerateMidiResponse < AsyncTaskResponse
+        optional :instruments, [ -> { MidiInstrument } ]
+      end
+
+      class ConvertAudioResponse < AsyncTaskResponse
+        optional :wav_url, String
+        optional :original_task_id, String
+      end
+
+      class VisualizeMusicResponse < AsyncTaskResponse
+        optional :video_url, String
+        optional :original_task_id, String
+      end
+
+      class GenerateLyricsResponse < AsyncTaskResponse
+        optional :lyrics, [ -> { Lyric } ]
+      end
+
+      class GetTimestampedLyricsResponse < RunApi::Core::BaseModel
+        optional :aligned_words, [ -> { AlignedWord } ]
+        optional :waveform_data, [ Numeric ]
+        optional :hoot_cer, Numeric
+        optional :is_streamed
+      end
+
+      class ReplaceSectionResponse < AsyncTaskResponse
+        optional :track, -> { Audio }
+        optional :audios, [ -> { Audio } ]
+      end
+
+      class GeneratePersonaResponse < RunApi::Core::BaseModel
+        required :persona, -> { Persona }
+        optional :error, String
+      end
+
+      class BoostStyleResponse < RunApi::Core::BaseModel
+        optional :style, String
+        optional :error, String
+      end
+
+      class CreateMashupResponse < AsyncTaskResponse
+        optional :audio, -> { Audio }
+        optional :audios, [ -> { Audio } ]
+      end
+
+      class CompletedTextToMusicResponse < TextToMusicResponse
+        required :audios, [ -> { Audio } ]
+      end
+
+      class CompletedExtendMusicResponse < ExtendMusicResponse
+        required :audios, [ -> { Audio } ]
+      end
+
+      class CompletedGenerateArtworkResponse < GenerateArtworkResponse
+        required :covers, [ -> { Cover } ]
+      end
+
+      class CompletedCoverAudioResponse < CoverAudioResponse
+        required :audios, [ -> { Audio } ]
+      end
+
+      class CompletedAddInstrumentalResponse < AddInstrumentalResponse
+        required :audios, [ -> { Audio } ]
+      end
+
+      class CompletedAddVocalsResponse < AddVocalsResponse
+        required :audios, [ -> { Audio } ]
+      end
+
+      class CompletedSeparateAudioStemsResponse < SeparateAudioStemsResponse
+        required :separated_audios, -> { SeparatedAudio }
+      end
+
+      class CompletedGenerateMidiResponse < GenerateMidiResponse
+        required :instruments, [ -> { MidiInstrument } ]
+      end
+
+      class CompletedConvertAudioResponse < ConvertAudioResponse
+        required :wav_url, String
+      end
+
+      class CompletedVisualizeMusicResponse < VisualizeMusicResponse
+        required :video_url, String
+      end
+
+      class CompletedGenerateLyricsResponse < GenerateLyricsResponse
+        required :lyrics, [ -> { Lyric } ]
+      end
+
+      class CompletedReplaceSectionResponse < ReplaceSectionResponse
+        required :track, -> { Audio }
+      end
+
+      class CompletedCreateMashupResponse < CreateMashupResponse
+        required :audios, [ -> { Audio } ]
+      end
+
+      class CompletedTextToSoundResponse < TextToSoundResponse
+        required :audios, [ -> { Audio } ]
+      end
+    end
+  end
+end

data/lib/runapi/suno/validators.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module RunApi
+  module Suno
+    module Validators
+      module_function
+
+      def validate_text_to_music!(params, resource)
+        if param(resource, params, :custom_mode)
+          require_param!(resource, params, :style)
+          require_param!(resource, params, :title)
+        else
+          require_param!(resource, params, :prompt)
+        end
+        require_param!(resource, params, :model)
+        validate_optional!(resource, params, :model, Types::MODELS)
+        validate_optional!(resource, params, :vocal_gender, Types::VOCAL_GENDERS)
+        validate_optional!(resource, params, :persona_model, Types::PERSONA_MODELS)
+      end
+
+      def validate_extend_music!(params, resource)
+        unless %i[task_id audio_id audio_url upload_url].any? { |key| param(resource, params, key) }
+          raise Core::ValidationError, "task_id, audio_id, audio_url, or upload_url is required"
+        end
+        require_param!(resource, params, :default_param_flag)
+        require_param!(resource, params, :model)
+
+        if truthy?(param(resource, params, :default_param_flag))
+          require_param!(resource, params, :style)
+          require_param!(resource, params, :title)
+          require_param!(resource, params, :continue_at)
+        end
+        validate_optional!(resource, params, :model, Types::MODELS)
+        validate_optional!(resource, params, :vocal_gender, Types::VOCAL_GENDERS)
+        validate_optional!(resource, params, :persona_model, Types::PERSONA_MODELS)
+      end
+
+      def validate_generate_artwork!(params, resource)
+        require_param!(resource, params, :task_id)
+      end
+
+      def validate_cover_audio!(params, resource)
+        require_param!(resource, params, :upload_url)
+        require_param!(resource, params, :model)
+        if param(resource, params, :custom_mode)
+          require_param!(resource, params, :style)
+          require_param!(resource, params, :title)
+        else
+          require_param!(resource, params, :prompt)
+        end
+        validate_optional!(resource, params, :model, Types::MODELS)
+        validate_optional!(resource, params, :vocal_gender, Types::VOCAL_GENDERS)
+        validate_optional!(resource, params, :persona_model, Types::PERSONA_MODELS)
+      end
+
+      def validate_add_instrumental!(params, resource)
+        require_all!(resource, params, :upload_url, :title, :negative_tags, :tags, :model)
+        validate_optional!(resource, params, :model, Types::MODELS)
+        validate_optional!(resource, params, :vocal_gender, Types::VOCAL_GENDERS)
+      end
+
+      def validate_add_vocals!(params, resource)
+        require_all!(resource, params, :upload_url, :prompt, :title, :negative_tags, :style, :model)
+        validate_optional!(resource, params, :model, Types::MODELS)
+        validate_optional!(resource, params, :vocal_gender, Types::VOCAL_GENDERS)
+      end
+
+      def validate_separate_audio_stems!(params, resource)
+        require_all!(resource, params, :task_id, :audio_id)
+        validate_optional!(resource, params, :type, Types::SEPARATE_AUDIO_STEMS_TYPES)
+      end
+
+      def validate_generate_midi!(params, resource)
+        require_param!(resource, params, :task_id)
+      end
+
+      def validate_convert_audio!(params, resource)
+        require_all!(resource, params, :task_id, :audio_id)
+      end
+
+      def validate_visualize_music!(params, resource)
+        require_all!(resource, params, :task_id, :audio_id)
+      end
+
+      def validate_generate_lyrics!(params, resource)
+        require_param!(resource, params, :prompt)
+      end
+
+      def validate_get_timestamped_lyrics!(params, resource)
+        require_all!(resource, params, :task_id, :audio_id)
+      end
+
+      def validate_replace_section!(params, resource)
+        require_all!(resource, params, :task_id, :audio_id, :prompt, :tags, :title, :infill_start_time, :infill_end_time)
+        if param(resource, params, :infill_end_time).to_f <= param(resource, params, :infill_start_time).to_f
+          raise Core::ValidationError, "infill_end_time must be greater than infill_start_time"
+        end
+      end
+
+      def validate_create_mashup!(params, resource)
+        upload_url_list = param(resource, params, :upload_url_list)
+        unless upload_url_list.is_a?(Array) && upload_url_list.size == 2
+          raise Core::ValidationError, "upload_url_list must contain exactly 2 URLs"
+        end
+        require_param!(resource, params, :model)
+        if param(resource, params, :custom_mode)
+          require_all!(resource, params, :style, :title)
+          require_param!(resource, params, :prompt) unless truthy?(param(resource, params, :instrumental))
+        else
+          require_param!(resource, params, :prompt)
+        end
+        validate_optional!(resource, params, :model, Types::MODELS)
+        validate_optional!(resource, params, :vocal_gender, Types::VOCAL_GENDERS)
+      end
+
+      def validate_text_to_sound!(params, resource)
+        require_all!(resource, params, :prompt, :model)
+        validate_optional!(resource, params, :model, Types::SOUND_MODELS)
+        validate_optional!(resource, params, :sound_key, Types::SOUND_KEYS)
+        tempo = param(resource, params, :sound_tempo)
+        if tempo && !(1..300).cover?(tempo.to_i)
+          raise Core::ValidationError, "sound_tempo must be between 1 and 300"
+        end
+      end
+
+      def validate_generate_persona!(params, resource)
+        require_all!(resource, params, :task_id, :audio_id, :name, :description)
+      end
+
+      def validate_boost_style!(params, resource)
+        require_param!(resource, params, :description)
+      end
+
+      def require_all!(resource, params, *keys)
+        keys.each { |key| require_param!(resource, params, key) }
+      end
+
+      def require_param!(resource, params, key)
+        raise Core::ValidationError, "#{key} is required" if param(resource, params, key).nil?
+      end
+
+      def param(resource, params, key)
+        resource.send(:param, params, key)
+      end
+
+      def validate_optional!(resource, params, key, allowed)
+        resource.send(:validate_optional!, params, key, allowed)
+      end
+
+      def truthy?(value)
+        [ true, 1, "1", "true", "TRUE", "True" ].include?(value)
+      end
+    end
+  end
+end

data/lib/runapi/suno.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "runapi/core"
+require_relative "suno/types"
+require_relative "suno/validators"
+require_relative "suno/resources/text_to_music"
+require_relative "suno/resources/extend_music"
+require_relative "suno/resources/generate_artwork"
+require_relative "suno/resources/cover_audio"
+require_relative "suno/resources/add_instrumental"
+require_relative "suno/resources/add_vocals"
+require_relative "suno/resources/separate_audio_stems"
+require_relative "suno/resources/generate_midi"
+require_relative "suno/resources/convert_audio"
+require_relative "suno/resources/visualize_music"
+require_relative "suno/resources/generate_lyrics"
+require_relative "suno/resources/get_timestamped_lyrics"
+require_relative "suno/resources/replace_section"
+require_relative "suno/resources/create_mashup"
+require_relative "suno/resources/text_to_sound"
+require_relative "suno/resources/generate_persona"
+require_relative "suno/resources/boost_style"
+require_relative "suno/client"
+
+module RunApi
+  module Suno
+    AuthenticationError = RunApi::Core::AuthenticationError
+    RateLimitError = RunApi::Core::RateLimitError
+    InsufficientCreditsError = RunApi::Core::InsufficientCreditsError
+    ValidationError = RunApi::Core::ValidationError
+    NotFoundError = RunApi::Core::NotFoundError
+    TaskFailedError = RunApi::Core::TaskFailedError
+    TaskTimeoutError = RunApi::Core::TaskTimeoutError
+  end
+end

data/lib/runapi-suno.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "runapi/suno"