ruby-echonest 0.0.6 → 0.1.1

data/README.rdoc

@@ -12,14 +12,11 @@ A Ruby interface for Echo Nest Developer API
 
 === Gem Installation
 
- gem update --system
- gem install gemcutter
- gem tumble
  gem install ruby-echonest
 
 == Features/Problems
 
-Only supports the API for Track http://developer.echonest.com/pages/overview
+Only supports the API for Track http://developer.echonest.com/docs/v4/track.html
 
 == Synopsis
 
@@ -28,7 +25,14 @@ Only supports the API for Track http://developer.echonest.com/pages/overview
 
  filename = 'foo.mp3'
  echonest = Echonest('YOUR_API_KEY')
- echonest.get_beats(filename)
+
+ analysis = echonest.track.analysis(filename)
+ beats = analysis.beats
+ segments = analysis.segments
+
+ # traditional way
+ beats = echonest.get_beats(filename)
+ segments = echonest.get_segments(filename)
 
 == Thanks
 

data/Rakefile

@@ -62,6 +62,7 @@ spec = Gem::Specification.new do |s|
 
   s.add_dependency('libxml-ruby')
   s.add_dependency('httpclient')
+  s.add_dependency('hashie')
   #s.required_ruby_version = '>= 1.8.2'
 
   s.files = %w(README.rdoc ChangeLog Rakefile) +

data/lib/echonest/analysis.rb

@@ -0,0 +1,91 @@
+require 'json'
+require 'open-uri'
+
+module Echonest
+  class Analysis
+    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
+
+    def loudness
+      track_info['loudness']
+    end
+
+    def mode
+      track_info['mode']
+    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

@@ -1,12 +1,15 @@
+# -*- coding: utf-8 -*-
 require 'digest/md5'
 require 'httpclient'
+require 'json'
 
 module Echonest
   class Api
-    VERSION = '3'
-    BASE_URL = 'http://developer.echonest.com/api/'
+    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
@@ -16,182 +19,125 @@ module Echonest
       @user_agent = HTTPClient.new(:agent_name => USER_AGENT)
     end
 
-    def get_bars(filename)
-      get_analysys(:get_bars, filename) do |analysis|
-        analysis.map do |bar|
-          Bar.new(bar.content.to_f, bar['confidence'].to_f)
-        end
-      end
+    def track
+      ApiMethods::Track.new(self)
     end
 
-    def get_beats(filename)
-      get_analysys(:get_beats, filename) do |analysis|
-        analysis.map do |beat|
-          Beat.new(beat.content.to_f, beat['confidence'].to_f)
-        end
-      end
+    def build_params(params)
+      params = params.
+        merge(:format => 'json').
+        merge(:api_key => @api_key)
     end
 
-    def get_segments(filename)
-      get_analysys(:get_segments, filename) do |analysis|
-        analysis.map do |segment|
-          max_loudness = loudness = nil
+    def request(name, method, params, file = nil)
+      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('&')
 
-          segment.find('loudness/dB').map do |db|
-            if db['type'] == 'max'
-              max_loudness = Loudness.new(db['time'].to_f, db.content.to_f)
-            else
-              loudness = Loudness.new(db['time'].to_f, db.content.to_f)
-            end
-          end
-
-          pitches = segment.find('pitches/pitch').map do |pitch|
-            pitch.content.to_f
-          end
+        uri = URI.join(BASE_URL, name.to_s)
+        uri.query = query
 
-          timbre = segment.find('timbre/coeff').map do |coeff|
-            coeff.content.to_f
-          end
-
-          Segment.new(
-            segment['start'].to_f,
-            segment['duration'].to_f,
-            loudness,
-            max_loudness,
-            pitches,
-            timbre
-            )
-        end
+        response_body = @user_agent.__send__(
+          method.to_s + '_content',
+          uri,
+          file.read,
+          {
+            'Content-Type' => 'application/octet-stream'
+          })
+      else
+        response_body = @user_agent.__send__(
+          method.to_s + '_content',
+          URI.join(BASE_URL, name.to_s),
+          build_params(params))
       end
-    end
 
-    def get_tempo(filename)
-      get_analysys(:get_tempo, filename) do |analysis|
-        analysis.first.content.to_f
-      end
-    end
-
-    def get_sections(filename)
-      get_analysys(:get_sections, filename) do |analysis|
-        analysis.map do |section|
-          Section.new(
-            section['start'].to_f,
-            section['duration'].to_f
-          )
-        end
-      end
-    end
-
-    def get_duration(filename)
-      get_analysys(:get_duration, filename) do |analysis|
-        analysis.first.content.to_f
+      response = Response.new(response_body)
+      unless response.success?
+        raise Error.new(response.status.message)
       end
-    end
 
-    def get_end_of_fade_in(filename)
-      get_analysys(:get_end_of_fade_in, filename) do |analysis|
-        analysis.first.content.to_f
-      end
+      response
+    rescue HTTPClient::BadResponseError => e
+      raise Error.new('%s: %s' % [name, e.message])
     end
+  end
 
-    def get_key(filename)
-      get_analysys(:get_key, filename) do |analysis|
-        ValueWithConfidence.new(analysis.first.content.to_i, analysis.first['confidence'].to_f)
+  module ApiMethods
+    class Base
+      def initialize(api)
+        @api = api
       end
     end
 
-    def get_loudness(filename)
-      get_analysys(:get_loudness, filename) do |analysis|
-        analysis.first.content.to_f
+    class Track < Base
+      def profile(options)
+        @api.request('track/profile',
+          :get,
+          options.merge(:bucket => 'audio_summary'))
       end
-    end
 
-    def get_metadata(filename)
-      get_analysys(:get_metadata, filename) do |analysis|
-        analysis.inject({}) do |memo, key|
-          memo[key.name] = key.content
-          memo
-        end
+      def analyze(options)
+        @api.request('track/analyze',
+          :post,
+          options.merge(:bucket => 'audio_summary'))
       end
-    end
 
-    def get_mode(filename)
-      get_analysys(:get_mode, filename) do |analysis|
-        ValueWithConfidence.new(analysis.first.content.to_i, analysis.first['confidence'].to_f)
-      end
-    end
+      def upload(options)
+        options.update(:bucket => 'audio_summary')
 
-    def get_start_of_fade_out(filename)
-      get_analysys(:get_start_of_fade_out, filename) do |analysis|
-        analysis.first.content.to_f
-      end
-    end
+        if options.has_key?(:filename)
+          filename = options.delete(:filename)
+          filetype = filename.to_s.match(/\.(mp3|au|ogg)$/)[1]
 
-    def get_tatums(filename)
-      get_analysys(:get_tatums, filename) do |analysis|
-        analysis.map do |tatum|
-          Tatum.new(tatum.content.to_f, tatum['confidence'].to_f)
+          open(filename) do |f|
+            @api.request('track/upload',
+              :post,
+              options.merge(:filetype => filetype),
+              f)
+          end
+        else
+          @api.request('track/upload', :post, options)
         end
       end
-    end
 
-    def get_time_signature(filename)
-      get_analysys(:get_time_signature, filename) do |analysis|
-        ValueWithConfidence.new(analysis.first.content.to_i, analysis.first['confidence'].to_f)
+      def analysis(filename)
+        analysis_url = analysis_url(filename)
+        Analysis.new_from_url(analysis_url)
       end
-    end
 
-    def build_params(params)
-      params = params.
-        merge(:version => VERSION).
-        merge(:api_key => @api_key)
-    end
+      def analysis_url(filename)
+        md5 = Digest::MD5.hexdigest(open(filename).read)
 
-    def get_analysys(method, filename)
-      get_trackinfo(method, filename) do |response|
-        yield response.xml.find_first('/response/analysis')
-      end
-    end
-
-    def get_trackinfo(method, filename, &block)
-      content = open(filename).read
-      md5 = Digest::MD5.hexdigest(content)
-
-      begin
-        response = request(method, :md5 => md5)
-
-        block.call(response)
-      rescue Echonest::Api::Error => e
-        case e.message
-        when /Analysis not ready/
-          sleep 20 # wait for serverside analysis
-          get_trackinfo(method, filename, &block)
-        when 'Invalid parameter: unknown MD5 file hash'
-          upload(filename)
-          sleep 60 # wait for serverside analysis
-          get_trackinfo(method, filename, &block)
-        else
-          raise
-        end
-      end
-    end
-
-    def upload(filename)
-      open(filename) do |f|
-        request(:upload, :file => f)
-      end
-    end
+        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
 
-    def request(name, params)
-      method = (name == :upload ? 'post' : 'get')
-      response_body = @user_agent.__send__(method + '_content', URI.join(BASE_URL, name.to_s), build_params(params))
-      response = Response.new(response_body)
+          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
 
-      unless response.success?
-        raise Error.new(response.status.message)
+          sleep 5
+        end
       end
-
-      response
     end
   end
 end

data/lib/echonest/element/bar.rb

@@ -1,5 +1,2 @@
-class Bar < ValueWithConfidence
-  def start
-    value
-  end
+class Bar < Section
 end

data/lib/echonest/element/beat.rb

@@ -1,5 +1,2 @@
-class Beat < ValueWithConfidence
-  def start
-    value
-  end
+class Beat < Section
 end

data/lib/echonest/element/section.rb

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

data/lib/echonest/element/segment.rb

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

data/lib/echonest/element/tatum.rb

@@ -1,5 +1,2 @@
-class Tatum < ValueWithConfidence
-  def start
-    value
-  end
+class Tatum < Section
 end

data/lib/echonest/response.rb

@@ -1,23 +1,24 @@
-require "xml"
+require 'json'
+require 'hashie'
 
 module Echonest
   class Response
-    attr_reader :xml
+    attr_reader :json
 
     def initialize(body)
-      @xml = XML::Document.string(body)
+      @json = Hashie::Mash.new(JSON.parse(body))
     end
 
     def status
-      @status ||= Status.new(@xml)
+      @status ||= Status.new(body)
     end
 
     def success?
       status.code == Status::SUCCESS
     end
 
-    def query
-      @query ||= Query.new(@xml)
+    def body
+      json.response
     end
 
     class Status
@@ -31,23 +32,9 @@ module Echonest
 
       attr_reader :code, :message
 
-      def initialize(xml)
-        @code = xml.find('/response/status/code').first.content.to_s.to_i
-        @message = xml.find('/response/status/message').first.content.to_s
-      end
-    end
-
-    class Query
-      def initialize(xml)
-        @parameters = {}
-
-        xml.find('/response/query/parameter').each do |parameter|
-          @parameters[parameter['name'].to_sym] = parameter.content
-        end
-      end
-
-      def [](parameter_name)
-        @parameters[parameter_name]
+      def initialize(response_body)
+        @code = response_body.status.code
+        @message = response_body.status.message
       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

@@ -1,3 +1,3 @@
 module Echonest
-  VERSION = '0.0.6'
+  VERSION = '0.1.1'
 end

data/lib/echonest.rb

@@ -1,10 +1,11 @@
 require 'echonest/version'
+require 'echonest/traditional_api_methods'
 require 'echonest/api'
+require 'echonest/analysis'
 require 'echonest/response'
-require 'echonest/element/value_with_confidence'
+require 'echonest/element/section'
 require 'echonest/element/bar'
 require 'echonest/element/beat'
-require 'echonest/element/section'
 require 'echonest/element/segment'
 require 'echonest/element/loudness'
 require 'echonest/element/tatum'

data/spec/analysis_spec.rb

@@ -0,0 +1,98 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'spec_helper'
+
+include SpecHelper
+
+describe Echonest::Analysis do
+  before do
+    @analysis = Echonest::Analysis.new(open(fixture('analysis.json')).read)
+  end
+
+  it "should have beats" do
+    beats = @analysis.beats
+
+    beats.size.should eql(324)
+    beats.first.start.should eql(0.27661)
+    beats.first.duration.should eql(0.36476)
+    beats.first.confidence.should eql(0.468)
+  end
+
+  it "should have segments" do
+    segments = @analysis.segments
+    segment = segments.first
+
+    segments.size.should eql(274)
+    segment.start.should eql(0.0)
+    segment.duration.should eql(0.43909)
+    segment.confidence.should eql(1.0)
+    segment.loudness.time.should eql(0.0)
+    segment.loudness.value.should eql(-60.0)
+    segment.max_loudness.time.should eql(0.11238)
+    segment.max_loudness.value.should eql(-33.563)
+    segment.pitches.size.should eql(12)
+    segment.pitches.first.should eql(0.138)
+    segment.timbre.size.should eql(12)
+    segment.timbre.first.should eql(11.525)
+  end
+
+  it "should have bars" do
+    bars = @analysis.bars
+
+    bars.size.should eql(80)
+    bars.first.start.should eql(1.00704)
+    bars.first.duration.should eql(1.48532)
+    bars.first.confidence.should eql(0.188)
+  end
+
+  it "should have tempo" do
+    @analysis.tempo.should eql(168.460)
+  end
+
+  it "should have sections" do
+    sections = @analysis.sections
+    section = sections.first
+
+    sections.size.should eql(7)
+    section.start.should eql(0.0)
+    section.duration.should eql(20.04271)
+    section.confidence.should eql(1.0)
+  end
+
+  it "should have durtion" do
+    @analysis.duration.should eql(120.68526)
+  end
+
+  it "should have end of fade in" do
+    @analysis.end_of_fade_in.should eql(0.0)
+  end
+
+  it "should have start of fade out" do
+    @analysis.start_of_fade_out.should eql(113.557)
+  end
+
+  it "should have key" do
+    @analysis.key.should eql(7)
+  end
+
+  it "should have loudness" do
+    @analysis.loudness.should eql(-19.140)
+  end
+
+  it "should have mode" do
+    @analysis.mode.should eql(1)
+  end
+
+  it "should have time signature" do
+    @analysis.time_signature.should eql(4)
+  end
+
+  it "should have tatums" do
+    tatums = @analysis.tatums
+
+    tatums.size.should eql(648)
+    tatums.first.start.should eql(0.09469)
+    tatums.first.duration.should eql(0.18193)
+    tatums.first.confidence.should eql(0.286)
+  end
+end