bassnode-ruby-echonest 0.1.2

data/.gitignore

@@ -0,0 +1,5 @@
+pkg
+coverage
+*.gem
+/example*
+*~

data/ChangeLog

@@ -0,0 +1,4 @@
+== 0.0.1 / 2009-04-14
+
+* initial release
+

data/README.rdoc

@@ -0,0 +1,45 @@
+= echonest
+
+A Ruby interface for Echo Nest Developer API
+
+== Description
+
+== Installation
+
+=== Archive Installation
+
+ rake install
+
+=== Gem Installation
+
+ gem install ruby-echonest
+
+== Features/Problems
+
+Only supports the API for Track http://developer.echonest.com/docs/v4/track.html
+
+== Synopsis
+
+ require 'rubygems'
+ require 'echonest'
+
+ filename = 'foo.mp3'
+ echonest = Echonest('YOUR_API_KEY')
+
+ analysis = echonest.track.analysis(filename)
+ beats = analysis.beats
+ segments = analysis.segments
+
+ # traditional way
+ beats = echonest.get_beats(filename)
+ segments = echonest.get_segments(filename)
+
+== Thanks
+
+{koyachi}[http://github.com/koyachi] for original idea http://gist.github.com/87086
+
+== Copyright
+
+Author::    youpy <youpy@buycheapviagraonlinenow.com>
+Copyright:: Copyright (c) 2009 youpy
+License::   MIT

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/sshpublisher'
+require 'spec/rake/spectask'
+require 'fileutils'
+include FileUtils
+
+$LOAD_PATH.unshift "lib"
+require "echonest"
+
+
+task :default => [:spec]
+task :package => [:clean]
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/*_spec.rb']
+  t.rcov = true
+end
+
+spec = eval(File.read("bassnode-ruby-echonest.gemspec"))
+Rake::GemPackageTask.new(spec) do |p|
+  p.need_tar = true
+  p.gem_spec = spec
+end
+
+
+desc "Show information about the gem"
+task :debug_gem do
+  puts spec.to_ruby
+end

data/bassnode-ruby-echonest.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{bassnode-ruby-echonest}
+  s.version = "0.1.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["youpy", "bassnode"]
+  s.date = %q{2011-04-24}
+  s.description = %q{An Ruby interface for Echo Nest Developer API}
+  s.summary = %q{An Ruby interface for Echo Nest Developer API}
+  s.email = %q{youpy@buycheapviagraonlinenow.com}
+  s.homepage = %q{http://github.com/bassnode/ruby-echonest}
+  s.rubyforge_project = %q{bassnode-ruby-echonest}
+  s.rubygems_version = %q{1.3.6}
+  s.platform = Gem::Platform::RUBY
+
+  s.require_paths = ["lib"]
+  s.extra_rdoc_files = ["README.rdoc", "ChangeLog"]
+  s.rdoc_options = ["--title", "ruby-echonest documentation", "--charset", "utf-8", "--opname", "index.html", "--line-numbers", "--main", "README.rdoc", "--inline-source", "--exclude", "^(examples|extras)/"]
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+
+
+  s.add_dependency(%q<libxml-ruby>, [">= 0"])
+  s.add_dependency(%q<httpclient>, [">= 0"])
+  s.add_dependency(%q<hashie>, [">= 0"])
+  s.add_development_dependency('rspec')
+end

data/lib/echonest/analysis.rb

@@ -0,0 +1,106 @@
+require 'json'
+require 'open-uri'
+
+module Echonest
+  class Analysis
+    CHROMATIC = %w(C C# D D# E F F# G G# A A# B).freeze
+    
+    def initialize(json)
+      @body = JSON.parse(json)
+    end
+
+    def self.new_from_url(url)
+      new(open(url).read)
+    end
+    
+    def tempo
+      track_info['tempo']
+    end
+
+    def duration
+      track_info['duration']
+    end
+
+    def end_of_fade_in
+      track_info['end_of_fade_in']
+    end
+
+    def key
+      track_info['key']
+    end
+    
+    # Returns the corresponding letter for the key number value.
+    def key_letter
+      CHROMATIC[key]
+    end
+
+    def loudness
+      track_info['loudness']
+    end
+
+    def mode
+      track_info['mode']
+    end
+    
+    def minor?
+      mode == 0
+    end
+
+    def major?
+      !minor?
+    end
+
+    def start_of_fade_out
+      track_info['start_of_fade_out']
+    end
+
+    def time_signature
+      track_info['time_signature']
+    end
+
+    def bars
+      @body['bars'].map do |bar|
+        Bar.new(bar['start'], bar['duration'], bar['confidence'])
+      end
+    end
+
+    def beats
+      @body['beats'].map do |beat|
+        Beat.new(beat['start'], beat['duration'], beat['confidence'])
+      end
+    end
+
+    def sections
+      @body['sections'].map do |section|
+        Section.new(section['start'], section['duration'], section['confidence'])
+      end
+    end
+
+    def tatums
+      @body['tatums'].map do |tatum|
+        Tatum.new(tatum['start'], tatum['duration'], tatum['confidence'])
+      end
+    end
+
+    def segments
+      @body['segments'].map do |segment|
+        loudness = Loudness.new(0.0, segment['loudness_start'])
+        max_loudness = Loudness.new(segment['loudness_max_time'], segment['loudness_max'])
+
+        Segment.new(
+          segment['start'],
+          segment['duration'],
+          segment['confidence'],
+          loudness,
+          max_loudness,
+          segment['pitches'],
+          segment['timbre']
+          )
+      end
+    end
+
+    def track_info
+      @body['track']
+    end
+  end
+end

data/lib/echonest/api.rb

@@ -0,0 +1,336 @@
+require 'digest/md5'
+require 'httpclient'
+require 'json'
+# For streaming output
+STDOUT.sync = true
+
+module Echonest
+  class Api
+    VERSION = '4.2'
+    BASE_URL = 'http://developer.echonest.com/api/v4/'
+    USER_AGENT = '%s/%s' % ['ruby-echonest', ::Echonest::VERSION]
+
+    include TraditionalApiMethods
+
+    class Error < StandardError; end
+
+    attr_reader :user_agent
+
+    def initialize(api_key)
+      @api_key = api_key
+      @user_agent = HTTPClient.new(:agent_name => USER_AGENT)
+      # for big files
+      @user_agent.send_timeout = 60 * 30
+      @user_agent.receive_timeout = 60 * 10
+    end
+
+    def track
+      ApiMethods::Track.new(self)
+    end
+
+    def artist(name=nil)
+      if name
+        ApiMethods::Artist.new_from_name(self, name)
+      else
+        ApiMethods::Artist.new(self)
+      end
+    end
+
+    def song
+      ApiMethods::Song.new(self)
+    end
+
+    def playlist
+      ApiMethods::Playlist.new(self)
+    end
+
+    def default_params
+      {
+        :format => 'json',
+        :api_key => @api_key
+      }
+    end
+
+    def build_params(params)
+      params = params.
+        merge(default_params)
+    end
+
+    def build_params_to_list(params)
+      result = []
+      hash_to_list = lambda{|kv| [kv[0].to_s, kv[1]]}
+      params.each do |param|
+        if param.instance_of? Array
+          param[1].map do |p1|
+            result << [param[0].to_s, p1]
+          end
+        else
+          result << hash_to_list.call(params)
+        end
+      end
+      default_params.each do |kv|
+        result << hash_to_list.call(kv) unless params.include? kv[0]
+      end
+      result
+    end
+
+    def request(name, method, params, file = nil)
+      uri = URI.join(BASE_URL, name.to_s)
+      if file
+        query = build_params(params).sort_by do |param|
+          param[0].to_s
+        end.inject([]) do |m, param|
+          m << [URI.encode(param[0].to_s), URI.encode(param[1])].join('=')
+        end.join('&')
+
+        uri.query = query
+        file = file.read unless file.is_a?(String)
+        connection = @user_agent.__send__(
+          method.to_s + '_async',
+          uri,
+          file,
+          {
+            'Content-Type' => 'application/octet-stream'
+          })
+
+          # Show some feedback for big ole' POSTs
+          n=0
+          print "8"
+          begin
+            sleep 2
+            n+=2
+            print (n%6==0 ? "D 8" : "=")
+          end while !connection.finished?
+
+          res = connection.pop
+          response_body = res.content.read
+      else
+        response_body = @user_agent.__send__(
+          method.to_s + '_content',
+          uri,
+          build_params_to_list(params))
+      end
+
+      response = Response.new(response_body)
+      unless response.success?
+        raise Error.new(response.status.message)
+      end
+
+      response
+    rescue HTTPClient::BadResponseError => e
+      raise Error.new('%s: %s' % [name, e.message])
+    end
+  end
+
+  module ApiMethods
+    class Base
+      def initialize(api)
+        @api = api
+      end
+
+      def request(*args)
+        name, http_method, params = args
+        @api.request(name, http_method, params)
+      end
+
+      class << self
+        def method_with_required_any(category, method_id, http_method, required, required_any, option, proc, block=nil)
+          unless block
+            block = Proc.new {|response| response.body}
+          end
+          method = :request
+          required ||= %w[api_key]
+          define_method(method_id) do |*args|
+            name = "#{category.downcase}/#{method_id.to_s}"
+            if args.length > 0
+              param_required = {}
+              required.each do |k|
+                k = k.to_sym
+                param_required[k] = args[0].delete(k) if args[0][k]
+              end
+              param_option = args[0]
+            end
+            params = ApiMethods::Base.validator(required, required_any, option).call(
+              :required => param_required,
+              :required_any => proc.call(self),
+              :option => param_option)
+            block.call(send(method, name, http_method, params))
+          end
+        end
+
+        def method_with_option(id, option, &block)
+          unless block
+            block = Proc.new {|response| response.body}
+          end
+          required = %w[]
+          required_any = %w[]
+          method = :request
+          http_method = :get
+          define_method(id) do |*args|
+            name = "#{self.class.to_s.split('::')[-1].downcase}/#{id.to_s}"
+            block.call(send(method, name, http_method, ApiMethods::Base.validator(required, required_any, option).call(
+                  :option => args.length > 0 ? args[0] : {})))
+
+          end
+        end
+
+        def validator(required, required_any, option)
+          Proc.new do |args|
+            ApiMethods::Base.build_params_with_validation(args, required, required_any, option)
+          end
+        end
+
+        def build_params_with_validation(args, required, required_any, option)
+          options = {}
+          # api_key is common parameter.
+          required -= %w[api_key]
+          required.each do |name|
+            name = name.to_sym
+            raise ArgumentError.new("%s is required" % name) unless args[:required][name]
+            options[name] = args[:required][name]
+          end
+          if required_any.length > 0
+            unless required_any.inject(false){|r,i| r || args[:required_any].include?(i.to_sym)}
+              raise ArgumentError.new("%s is required" % required_any.join(' or '))
+            end
+            key = required_any.find {|name| args[:required_any].include?(name.to_sym)}
+            options[key.to_sym] = args[:required_any][key.to_sym] if key
+          end
+          if args[:option] && !args[:option].empty?
+            option.each do |name|
+              name = name.to_sym
+              options[name] = args[:option][name] if args[:option][name]
+            end
+          end
+          options
+        end
+      end
+    end
+
+    class Track < Base
+      def profile(options)
+        @api.request('track/profile',
+          :get,
+          options.merge(:bucket => 'audio_summary'))
+      end
+
+      def analyze(options)
+        @api.request('track/analyze',
+          :post,
+          options.merge(:bucket => 'audio_summary'))
+      end
+
+      def upload(options)
+        options.update(:bucket => 'audio_summary')
+
+        if options.has_key?(:filename)
+          filename = options.delete(:filename)
+          filetype = filename.match(/\.(mp3|au|ogg)$/)[1]
+
+          open(filename) do |f|
+            @api.request('track/upload',
+              :post,
+              options.merge(:filetype => filetype),
+              f)
+          end
+        else
+          @api.request('track/upload', :post, options)
+        end
+      end
+
+      def analysis(filename)
+        analysis_url = analysis_url(filename)
+        Analysis.new_from_url(analysis_url)
+      end
+
+      def analysis_url(filename)
+        md5 = Digest::MD5.hexdigest(open(filename).read)
+
+        while true
+          begin
+            response = profile(:md5 => md5)
+          rescue Api::Error => e
+            if e.message =~ /^The Identifier specified does not exist/
+             response = upload(:filename => filename)
+           else
+             raise
+           end
+         end
+
+          case response.body.track.status
+          when 'unknown'
+            upload(:filename => filename)
+          when 'pending'
+            sleep 60
+          when 'complete'
+            return response.body.track.audio_summary.analysis_url
+          when 'error'
+            raise Error.new(response.body.track.status)
+          when 'unavailable'
+            analyze(:md5 => md5)
+          end
+
+          sleep 5
+        end
+      end
+    end
+
+    class Artist < Base
+      class << self
+        def new_from_name(echonest, artist_name)
+          instance = new(echonest)
+          instance.artist_name = artist_name
+          instance
+        end
+
+        def method_with_artist_id(method_id, option, &block)
+          required_any = %w[id name]
+          http_method = :get
+          proc = lambda {|s| s.artist_name ? {:name => s.artist_name} : {:id => s.artist_id} }
+          method_with_required_any('artist', method_id, http_method, [], required_any, option, proc, block)
+        end
+      end
+
+      attr_accessor :artist_name, :artist_id
+
+      method_with_artist_id(:audio, %w[format results start])
+      method_with_artist_id(:biographies, %w[format results start license])
+      method_with_artist_id(:blogs, %w[format results start])
+      method_with_artist_id(:familiarity, %w[format results start])
+      method_with_artist_id(:hotttnesss, %w[format results start])
+      method_with_artist_id(:images, %w[format results start license])
+      method_with_artist_id(:news, %w[format results start])
+      method_with_artist_id(:profile, %w[format results start bucket])
+      method_with_artist_id(:reviews, %w[format results start])
+      method_with_option(:search, %w[format results bucket limit name description fuzzy_match max_familiarity min_familiarity max_hotttnesss min_hotttnesss sort])
+      method_with_artist_id(:songs, %w[format results bucket limit])
+      method_with_artist_id(:similar, %w[format results start bucket max_familiarity min_familiarity max_hotttnesss min_hotttnesss reverse limit])
+      method_with_artist_id(:terms, %w[format sort])
+      method_with_option(:top_hottt, %w[format results start bucket limit type])
+      method_with_option(:top_terms, %w[format results])
+      method_with_artist_id(:urls, %w[format])
+      method_with_artist_id(:video, %w[format results start])
+    end
+
+    class Song < Base
+      method_with_option(:search, %w[format title artist combined description artist_id results max_tempo min_tempo max_duration min_duration max_loudness min_loudness max_familiarity min_familiarity max_hotttnesss min_hotttnesss min_longitude max_longitude min_latitude max_latitude mode key bucket sort limitt])
+      method_with_required_any('song', :profile, :get, %w[api_key id], [], %w[format bucket limit], lambda{})
+      # method_with_option(:identify, %w[query code artist title release duration genre bucket])
+      def identify(opts)
+        file = opts.delete(:code)
+        @api.request('song/identify', :post, opts, file).body
+      end
+    end
+
+    class Playlist < Base
+      method_with_option(:static, %w[format type artist_pick variety artist_id artist song_id description results max_tempo min_tempo max_duration min_duration max_loudness min_loudness artist_max_familiarity artist_min_familiarity artist_max_hotttnesss artist_min_hotttnesss song_max_hotttnesss song_min_hotttnesss artist_min_longitude aritst_max_longitude artist_min_latitude arist_max_latitude mode key bucket sort limit audio])
+      method_with_option(:dynamic, %w[format type artist_pick variety artist_id artist song_id description results max_tempo min_tempo max_duration min_duration max_loudness min_loudness artist_max_familiarity artist_min_familiarity artist_max_hotttnesss artist_min_hotttnesss song_max_hotttnesss song_min_hotttnesss artist_min_longitude aritst_max_longitude artist_min_latitude arist_max_latitude mode key bucket sort limit audio session_id dmca rating chain_xspf])
+    end
+  end
+end
+
+class HTTPClient
+  def agent_name
+    @session_manager.agent_name
+  end
+end

data/lib/echonest/element/bar.rb

@@ -0,0 +1,2 @@
+class Bar < Section
+end

data/lib/echonest/element/beat.rb

@@ -0,0 +1,2 @@
+class Beat < Section
+end

data/lib/echonest/element/loudness.rb

@@ -0,0 +1,8 @@
+class Loudness
+  attr_reader :time, :value
+
+  def initialize(time, value)
+    @time = time
+    @value = value
+  end
+end

data/lib/echonest/element/section.rb

@@ -0,0 +1,9 @@
+class Section
+  attr_reader :start, :duration, :confidence
+
+  def initialize(start, duration, confidence)
+    @start = start
+    @duration = duration
+    @confidence = confidence
+  end
+end

data/lib/echonest/element/segment.rb

@@ -0,0 +1,12 @@
+class Segment < Section
+  attr_reader :loudness, :max_loudness, :pitches, :timbre
+
+  def initialize(start, duration, confidence, loudness, max_loudness, pitches, timbre)
+    super(start, duration, confidence)
+
+    @loudness = loudness
+    @max_loudness = max_loudness
+    @pitches = pitches
+    @timbre = timbre
+  end
+end

data/lib/echonest/element/tatum.rb

@@ -0,0 +1,2 @@
+class Tatum < Section
+end

data/lib/echonest/response.rb

@@ -0,0 +1,41 @@
+require 'json'
+require 'hashie'
+
+module Echonest
+  class Response
+    attr_reader :json
+
+    def initialize(body)
+      @json = Hashie::Mash.new(JSON.parse(body))
+    end
+
+    def status
+      @status ||= Status.new(body)
+    end
+
+    def success?
+      status.code == Status::SUCCESS
+    end
+
+    def body
+      json.response
+    end
+
+    class Status
+      UNKNOWN_ERROR = -1
+      SUCCESS = 0
+      INVALID_API_KEY = 1
+      PERMISSION_DENIED = 2
+      RATE_LIMIT_EXCEEDED = 3
+      MISSING_PARAMETER = 4
+      INVALID_PARAMETER = 5
+
+      attr_reader :code, :message
+
+      def initialize(response_body)
+        @code = response_body.status.code
+        @message = response_body.status.message
+      end
+    end
+  end
+end

data/lib/echonest/traditional_api_methods.rb

@@ -0,0 +1,14 @@
+module Echonest
+  module TraditionalApiMethods
+    def self.included(c)
+      %w/tempo duration end_of_fade_in key loudness mode start_of_fade_out time_signature bars beats sections tatums segments/.
+        each do |method|
+        c.module_eval %Q{
+          def get_%s(filename)
+            track.analysis(filename).%s
+          end
+        } % [method, method]
+      end
+    end
+  end
+end

data/lib/echonest/version.rb

@@ -0,0 +1,3 @@
+module Echonest
+  VERSION = '0.1.2'
+end

data/lib/echonest.rb

@@ -0,0 +1,16 @@
+require 'echonest/version'
+require 'echonest/traditional_api_methods'
+require 'echonest/api'
+require 'echonest/analysis'
+require 'echonest/response'
+require 'echonest/element/section'
+require 'echonest/element/bar'
+require 'echonest/element/beat'
+require 'echonest/element/segment'
+require 'echonest/element/loudness'
+require 'echonest/element/tatum'
+
+def Echonest(api_key) Echonest::Api.new(api_key) end
+
+module Echonest
+end