mr_eko 0.2.4.1 → 0.3.0

data/lib/mr_eko/song.rb

@@ -1,109 +1,180 @@
+# TODO: Refactor this so everything's not in class methods
 class MrEko::Song < Sequel::Model
   include MrEko::Core
   plugin :validation_helpers
   many_to_many :playlists
 
-  # IDEA: This probably won't work since it's creating a new file,
-  # but could try uploading a sample of the song (faster).
-  # ffmpeg -y -i mogwai.mp3 -ar 22050 -ac 1 -ss 30 -t 30 output.mp3
-  # or
-  # sox mogwai.mp3 output.mp3 30 60
+  REQUIRED_ID3_TAGS = [:artist, :title]
 
-  # Using the Echonest Musical Fingerprint lib in the hopes
-  # of sidestepping the mp3 upload process.
-  def self.enmfp_data(filename, md5)
-    unless File.exists?(fp_location(md5))
-      log 'Running ENMFP'
-      `#{File.join(MrEko::HOME_DIR, 'ext', 'enmfp', enmfp_binary)} "#{File.expand_path(filename)}" > #{fp_location(md5)}`
-    end
+  class EnmfpError < Exception; end
 
-    File.read fp_location(md5)
-  end
+  # A wrapper which gets called by the bin file.
+  # By default will try to extract the needed song info from the ID3 tags and
+  # if fails, will analyze via ENMFP/upload.
+  #
+  # @param [String] file path of the MP3
+  # @param [Hash] options hash
+  # @option options [Boolean] :tags_only If passed, skip ENMFP
+  # @return [MrEko::Song]
+  def self.create_from_file!(filename, opts={})
+    md5 = MrEko.md5(filename)
+    existing = where(:md5 => md5).first
+    return existing unless existing.nil?
+
+    if song = catalog_via_tags(filename, :md5 => md5)
+      song
+    elsif !opts[:tags_only]
+      catalog_via_enmfp(filename, :md5 => md5)
+    end
 
-  # Return the file path of the EN fingerprint JSON file
-  def self.fp_location(md5)
-    File.expand_path File.join(MrEko::FINGERPRINTS_DIR, "#{md5}.json")
   end
 
-  # Use the platform-specific binary.
-  def self.enmfp_binary
-    case RUBY_PLATFORM
-    when /darwin/
-      'codegen.Darwin'
-    when /686/
-      'codegen.Linux-i686'
-    when /x86/
-      'codegen.Linux-x86_64'
+  # Run local analysis (ENMFP) on the passed file, send that identifier code
+  # to EN and store the returned details in our DB.
+  # If the local analysis fails, upload the MP3 to EN for server-side analysis.
+  #
+  # @param [String] location of the audio file
+  # @param [Hash] opts
+  # @option opts [String] :md5 pre-calculated MD5 of file
+  # @return [MrEko::Song] the created Song
+  def self.catalog_via_enmfp(filename, opts={})
+    md5 = opts[:md5] || MrEko.md5(filename)
+    fingerprint_json = enmfp_data(filename, md5)
+
+    if fingerprint_json.keys.include?('error')
+      raise EnmfpError, "Errors returned in the ENMFP fingerprint data: #{fingerprint_json.error.inspect}"
     else
-      'codegen.windows.exe'
+      begin
+        log "Identifying with ENMFP code"
+
+        identify_options = {}.tap do |opts|
+          opts[:code]    = fingerprint_json.raw_data
+          opts[:artist]  = fingerprint_json.metadata.artist
+          opts[:title]   = fingerprint_json.metadata.title
+          opts[:release] = fingerprint_json.metadata.release
+          opts[:bucket]  = 'audio_summary'
+        end
+
+        profile = MrEko.nest.song.identify(identify_options)
+
+        raise EnmfpError, "Nothing returned" if profile.songs.empty?
+        profile = profile.songs.first
+
+        # Get the extended audio data from the profile
+        analysis = MrEko.nest.song.profile(:id => profile.id, :bucket => 'audio_summary').songs.first.audio_summary
+      rescue Exception => e
+        log %Q{Issues using ENMFP data "(#{e})" #{e.backtrace.join("\n")}}
+        analysis, profile = get_datapoints_by_upload(filename)
+      end
+    end
+
+    create do |song|
+      song.filename       = File.expand_path(filename)
+      song.md5            = md5
+      song.code           = fingerprint_json.code
+      song.tempo          = analysis.tempo
+      song.duration       = analysis.duration
+      song.fade_in        = analysis.end_of_fade_in
+      song.fade_out       = analysis.start_of_fade_out
+      song.key            = analysis.key
+      song.mode           = analysis.mode
+      song.loudness       = analysis.loudness
+      song.time_signature = analysis.time_signature
+      song.echonest_id    = profile.id
+      song.bitrate        = profile.bitrate
+      song.title          = profile.title
+      song.artist         = profile.artist || profile.artist_name
+      song.album          = profile.release
+      song.danceability   = profile.audio_summary? ? profile.audio_summary.danceability : analysis.danceability
+      song.energy         = profile.audio_summary? ? profile.audio_summary.energy       : analysis.energy
     end
   end
 
-  # Returns the analysis and profile data from Echonest for the given track.
-  def self.get_datapoints_by_filename(filename)
-    analysis = MrEko.nest.track.analysis(filename)
-    profile  = MrEko.nest.track.profile(:md5 => MrEko.md5(filename)).body.track
+  # Parses the file's ID3 tags and converts and strange encoding.
+  #
+  # @param [String] The file path
+  # @return [ID3Lib::Tag]
+  def self.parse_id3_tags(filename)
+    log "Parsing ID3 tags"
 
-    return [analysis, profile]
+    clean_tags ID3Lib::Tag.new(filename, ID3Lib::V_ALL)
   end
 
-  # TODO: Cleanup - This method is prety ugly now.
-  def self.create_from_file!(filename)
-    md5 = MrEko.md5(filename)
-    existing = where(:md5 => md5).first
-    return existing unless existing.nil?
 
-    fingerprint_data = enmfp_data(filename, md5)
-    fingerprint_json_data = Hashie::Mash.new(JSON.parse(fingerprint_data).first)
+  # Uses ID3 tags to query Echonest and then store the resultant data.
+  #
+  # @see Song.catalog_via_enmfp for options
+  # @return [MrEko::Song]
+  def self.catalog_via_tags(filename, opts={})
+    tags = parse_id3_tags(filename)
+    return unless has_required_tags? tags
+
+    md5 = opts[:md5] || MrEko.md5(filename)
+    analysis = MrEko.nest.song.search(:artist => tags.artist,
+                                      :title => tags.title,
+                                      :bucket => 'audio_summary',
+                                      :limit => 1).songs.first
+
+    create do |song|
+      song.filename       = File.expand_path(filename)
+      song.md5            = md5
+      song.tempo          = analysis.audio_summary.tempo
+      song.duration       = analysis.audio_summary.duration
+      song.key            = analysis.audio_summary.key
+      song.mode           = analysis.audio_summary.mode
+      song.loudness       = analysis.audio_summary.loudness
+      song.time_signature = analysis.audio_summary.time_signature
+      song.echonest_id    = analysis.id
+      song.title          = tags.title
+      song.artist         = tags.artist
+      song.danceability   = analysis.audio_summary.danceability
+      song.energy         = analysis.audio_summary.energy
+      # XXX: Won't have these from tags - worth getting from EN?
+      # song.code           = fingerprint_json.code
+      # song.album          = album
+      # song.fade_in        = analysis.end_of_fade_in
+      # song.fade_out       = analysis.start_of_fade_out
+      # XXX: ID3Lib doesn't return these - worth parsing?
+      # song.bitrate        =  profile.bitrate
+    end if analysis
+  end
 
-    if fingerprint_json_data.keys.include?('error')
-      analysis, profile = get_datapoints_by_filename(filename)
-    else
-      log "Identifying with ENMFP code"
-      identify_options = {:code => fingerprint_data}
-      identify_options[:artist]   = fingerprint_json_data.metadata.artist  if fingerprint_json_data.metadata.artist
-      identify_options[:title]    = fingerprint_json_data.metadata.title   if fingerprint_json_data.metadata.title
-      identify_options[:release]  = fingerprint_json_data.metadata.release if fingerprint_json_data.metadata.release
-      profile = MrEko.nest.song.identify(identify_options)
-
-      if profile.songs.empty? 
-        # ENMFP wasn't recognized, so upload.
-        log "ENMP returned nothing, uploading"
-        analysis, profile = get_datapoints_by_filename(filename)
-      else
-        begin
-          profile = profile.songs.first
-          analysis = MrEko.nest.song.profile(:id => profile.id, :bucket => 'audio_summary').songs.first.audio_summary
-        rescue Exception => e
-          log "Issues using ENMP data, uploading \"(#{e})\""
-          analysis, profile = get_datapoints_by_filename(filename)
-        end
-      end
+  def self.has_required_tags?(tags)
+    found = REQUIRED_ID3_TAGS.inject([]) do |present, meth|
+      present << tags.send(meth)
+    end
+
+    found.compact.size == REQUIRED_ID3_TAGS.size ? true : false
+  end
+
+  # Using the Echonest Musical Fingerprint lib in the hopes
+  # of sidestepping the mp3 upload process.
+  #
+  # @param [String] file path of the MP3
+  # @param [String] MD5 hash of the file
+  # @return [Hash] data from the ENMFP process
+  def self.enmfp_data(filename, md5)
+    unless File.exists?(fp_location(md5))
+      log 'Running ENMFP'
+      `#{File.join(MrEko::HOME_DIR, 'ext', 'enmfp', MrEko.enmfp_binary)} "#{File.expand_path(filename)}" > #{fp_location(md5)}`
     end
 
-    # TODO: add ruby-mp3info as fallback for parsing ID3 tags
-    # since Echonest seems a bit flaky in that dept.
-    song                = new()
-    song.filename       = File.expand_path(filename)
-    song.md5            = md5
-    song.code           = fingerprint_json_data.code
-    song.tempo          = analysis.tempo
-    song.duration       = analysis.duration
-    song.fade_in        = analysis.end_of_fade_in
-    song.fade_out       = analysis.start_of_fade_out
-    song.key            = analysis.key
-    song.mode           = analysis.mode
-    song.loudness       = analysis.loudness
-    song.time_signature = analysis.time_signature
-    song.echonest_id    = profile.id
-    song.bitrate        = profile.bitrate
-    song.title          = profile.title
-    song.artist         = profile.artist || profile.artist_name
-    song.album          = profile.release
-    song.danceability   = profile.audio_summary? ? profile.audio_summary.danceability : analysis.danceability
-    song.energy         = profile.audio_summary? ? profile.audio_summary.energy       : analysis.energy
-
-    song.save
+    raw_json = File.read fp_location(md5)
+    hash = Hashie::Mash.new(JSON.parse(raw_json).first)
+    hash.raw_data = raw_json
+    hash
+  end
+
+  # Returns the analysis and profile data from Echonest for the given track.
+  #
+  # @param [String] file path of the MP3
+  # @return [Array] Analysis and profile data from EN
+  def self.get_datapoints_by_upload(filename)
+    log "Uploading data to EN for analysis"
+    analysis = MrEko.nest.track.analysis(filename)
+    profile  = MrEko.nest.track.profile(:md5 => MrEko.md5(filename), :bucket => 'audio_summary').body.track
+
+    return [analysis, profile]
   end
 
   def validate
@@ -117,6 +188,31 @@ class MrEko::Song < Sequel::Model
     self.md5 ||= MrEko.md5(filename)
   end
 
+  # Return the file path of the EN fingerprint JSON file
+  #
+  # @param [String] MD5 hash of the file
+  # @return [String] full path of file with passed MP5
+  def self.fp_location(md5)
+    File.expand_path File.join(MrEko::FINGERPRINTS_DIR, "#{md5}.json")
+  end
+
+  # @param [ID3Lib::Tag]
+  # @return [ID3Lib::Tag]
+  def self.clean_tags(tags)
+    ic = Iconv.new("utf-8", "ucs-2")
+
+    REQUIRED_ID3_TAGS.each do |rt|
+      decoded = begin
+        ic.iconv(tags.send(rt))
+      rescue Iconv::InvalidCharacter
+        tags.send(rt)
+      end
+      decoded = nil if decoded.blank?
+      tags.send("#{rt}=", decoded)
+    end
+
+    tags
+  end
 end
 
 MrEko::Song.plugin :timestamps

data/lib/mr_eko/timed_playlist.rb

@@ -0,0 +1,149 @@
+class MrEko::TimedPlaylist
+
+  #
+  attr_reader :songs
+
+  # The number of seconds the playlist should be.
+  attr_reader :length
+
+  attr_reader :name
+
+  # The hash which holds all the controlling parameters for the Playlist.
+  attr_reader :attributes
+
+  # Hash keyed by the attribute w/ a value of the number of steps to reach the
+  # final setting.
+  attr_reader :step_map
+
+  class InvalidAttributes < Exception; end
+
+
+  def initialize(opts={})
+    @attributes = Hash.new{ |hsh, key| hsh[key] = {} }
+    @step_map   = Hash.new
+    @songs = []
+
+    handle_opts(opts)
+
+    yield self if block_given?
+
+  end
+
+  def save
+    validate_attributes
+    determine_steps
+    find_songs
+
+    self
+  end
+
+  def initial(opt, value)
+    add_attribute(:initial, opt, value)
+  end
+
+  def final(opt, value)
+    add_attribute(:final, opt, value)
+  end
+
+  def static(opt, value)
+    add_attribute(:static, opt, value)
+  end
+
+
+  private
+
+  def handle_opts(opts)
+    @length = opts.delete(:length)
+    @name   = opts.delete(:name)
+  end
+
+  def add_attribute(att_type, opt, value)
+    attributes[att_type][opt] = value
+  end
+
+  def validate_attributes
+    init_atts  = attributes[:initial]
+    final_atts = attributes[:final]
+
+    unless init_atts.keys.map(&:to_s).sort == final_atts.keys.map(&:to_s).sort
+      raise InvalidAttributes, "You must provide values for both the initial and final settings, not just one."
+    end
+  end
+
+  def determine_steps
+
+    attributes[:initial].each_pair do |attr, val|
+
+      denominator = case attr
+      when :tempo, :loudness
+        attributes[:final][attr] - attributes[:initial][attr]
+      when :danceability, :energy
+        ( ( attributes[:final][attr] - attributes[:initial][attr] ) * 10 ).round
+      when :mode
+        2
+      when :key
+        MrEko.key_lookup(attributes[:final][attr]) - MrEko.key_lookup(attributes[:initial][attr])
+      end
+
+      step_length = @length.to_f / denominator
+      step_length = 4.minutes if step_length.in_minutes < 4
+
+      step_map[attr] = [denominator, step_length.round]
+    end
+
+    step_map
+  end
+
+  # XXX Just sketching this part out at the moment...
+  # needs tests (and complete logic!)
+  def find_songs
+    step_count, step_length = step_map[:tempo]
+    return unless step_count && step_length
+    direction = step_count > 0 ? :asc : :desc
+    sorted_tempos = [attributes[:initial][:tempo], attributes[:final][:tempo]].sort
+    tempo_range = Range.new(*sorted_tempos)
+    all_songs = MrEko::Song.where(:tempo => tempo_range).order("tempo #{direction}".lit).all
+
+    songs_to_examine_per_step = step_count > all_songs.size ? 1 : all_songs.size / step_count
+
+    overall_seconds_used = 0
+    all_songs.each_slice(songs_to_examine_per_step).each do |songs|
+      break if overall_seconds_used >= @length
+
+      song_length_proximity = 0
+      length_map = songs.inject({}) do |hsh, song|
+        song_length_proximity = (song.duration - step_length).abs
+        hsh[song_length_proximity] = song
+        hsh
+      end
+
+      step_seconds_used = 0
+      length_map.sort_by{ |key, song| key }.each do |length, song|
+        @songs << song
+        step_seconds_used += song.duration
+        overall_seconds_used += song.duration
+        break if step_seconds_used >= step_length
+      end
+
+    end
+    # Might need to make a cluster map here instead of just choosing enough
+    # songs to fulfill the step_length.  This is because the over
+    # Playlist#length can be fulfilled even before we reach the target/final
+    # target.  I think a better rule would be to pluck a song having the
+    # initial and final values and then try to evenly spread out the remaining
+    # time with the songs in the middle...hence the map of the clusters of
+    # songs.  Then we can make selections more intelliegently.
+
+    @songs
+  end
+end
+
+# @length = 3600 # 1hr
+# tempo range 20bpm
+#
+# get count of all songs with the params, eg: tempo => 120..140
+# => 100
+
+# so take 100songs / 20steps = 5 songs per step
+# out of the first 5 songs, select 3min worth using the first
+

data/lib/mr_eko.rb

@@ -7,7 +7,12 @@ require "sequel"
 require "logger"
 require "hashie"
 require "digest/md5"
+require 'id3lib'
 require "echonest"
+begin
+  require 'ruby-debug'
+rescue LoadError
+end
 
 STDOUT.sync = true
 
@@ -15,12 +20,13 @@ EKO_ENV = ENV['EKO_ENV'] || 'development'
 Sequel.default_timezone = :utc
 
 module MrEko
-  VERSION = '0.2.4.1'
+  VERSION = '0.3.0'
   USER_DIR = File.join(ENV['HOME'], ".mreko")
   FINGERPRINTS_DIR = File.join(USER_DIR, 'fingerprints')
+  LOG_DIR = File.join(USER_DIR, 'logs')
   HOME_DIR = File.join(File.dirname(__FILE__), '..')
 
-  MODES = %w(minor major)
+  MODES = %w(minor major).freeze
   CHROMATIC_SCALE = %w(C C# D D# E F F# G G# A A# B).freeze
 
   class << self
@@ -43,15 +49,22 @@ module MrEko
     end
 
     def setup!
-      @logger ||= Logger.new(STDOUT)
       setup_directories!
+      setup_logger!
       setup_db!
       setup_echonest!
     end
 
+    # Output to STDOUT in development, otherwise, save to logfile
+    def setup_logger!
+      out = env == 'development' ? STDOUT : File.join(LOG_DIR, "#{env}.log")
+      @logger ||= Logger.new(out)
+    end
+
     def setup_directories!
       Dir.mkdir(USER_DIR) unless File.directory?(USER_DIR)
       Dir.mkdir(FINGERPRINTS_DIR) unless File.directory?(FINGERPRINTS_DIR)
+      Dir.mkdir(LOG_DIR) unless File.directory?(LOG_DIR)
     end
 
     def setup_db!
@@ -65,7 +78,7 @@ module MrEko
     end
 
     def db_name
-      env == 'test' ? 'db/eko_test.db' : 'db/eko.db'
+      env == 'test' ? File.join('db', 'eko_test.db') : File.join('db', 'eko.db')
     end
 
     def api_key
@@ -77,7 +90,7 @@ module MrEko
 
     # Takes 'minor' or 'major' and returns its integer representation.
     def mode_lookup(mode)
-      MODES.index(mode.downcase)
+      MODES.index(mode.to_s.downcase)
     end
 
     # Takes a chromatic key (eg: G#) and returns its integer representation.
@@ -89,13 +102,35 @@ module MrEko
     def key_letter(key)
       CHROMATIC_SCALE[key]
     end
+
+    # Use the platform-specific binary.
+    def enmfp_binary
+      case ruby_platform
+      when /darwin/
+        'codegen.Darwin'
+      when /686/
+        'codegen.Linux-i686'
+      when /x86/
+        'codegen.Linux-x86_64'
+      else
+        'codegen.windows.exe'
+      end
+    end
+
+    def ruby_platform
+      RUBY_PLATFORM
+    end
+
   end
 end
 
 
 MrEko.setup!
 
+require "lib/mr_eko/ext/numeric"
+require "lib/mr_eko/ext/object"
 require "lib/mr_eko/core"
 require "lib/mr_eko/presets"
 require "lib/mr_eko/playlist"
+require "lib/mr_eko/timed_playlist"
 require "lib/mr_eko/song"

data/mr_eko.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'mr_eko'
-  s.version           = '0.2.4.1'
-  s.date              = '2011-02-08'
+  s.version           = '0.3.0'
+  s.date              = '2011-11-30'
   s.rubyforge_project = 'mr_eko'
 
   ## Make sure your summary is short. The description may be as long
@@ -49,15 +49,18 @@ Gem::Specification.new do |s|
   s.add_dependency('sqlite3-ruby', "~> 1.3")
   s.add_dependency('hashie')
   s.add_dependency('httpclient', "~> 2.1")
+  s.add_dependency('bassnode-ruby-echonest')
   s.add_dependency('json', "= 1.4.6")
+  s.add_dependency('id3lib-ruby')
 
   ## List your development dependencies here. Development dependencies are
   ## those that are only needed during development
   s.add_development_dependency('mocha', "= 0.9.8")
   s.add_development_dependency('shoulda', "~> 2.11")
   s.add_development_dependency('test-unit', "~> 2.1")
-  s.add_development_dependency("ruby-debug", "~> 0.10.3")
-  
+  s.add_development_dependency("ruby-debug")
+  s.add_development_dependency("autotest")
+
   ## Leave this section as-is. It will be automatically generated from the
   ## contents of your Git repository via the gemspec task. DO NOT REMOVE
   ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
@@ -79,15 +82,24 @@ Gem::Specification.new do |s|
     ext/enmfp/codegen.Linux-i686
     ext/enmfp/codegen.Linux-x86_64
     ext/enmfp/codegen.windows.exe
+    ext/enmfp/old/codegen.Darwin
+    ext/enmfp/old/codegen.Linux-i686
+    ext/enmfp/old/codegen.Linux-x86_64
+    ext/enmfp/old/codegen.windows.exe
     lib/mr_eko.rb
     lib/mr_eko/core.rb
+    lib/mr_eko/ext/numeric.rb
+    lib/mr_eko/ext/object.rb
     lib/mr_eko/playlist.rb
     lib/mr_eko/presets.rb
     lib/mr_eko/song.rb
+    lib/mr_eko/timed_playlist.rb
     mr_eko.gemspec
     test/mr_eko_test.rb
     test/playlist_test.rb
+    test/song_test.rb
     test/test.rb
+    test/timed_playlist_test.rb
   ]
   # = MANIFEST =
 

data/test/mr_eko_test.rb

@@ -1,25 +1,54 @@
-class MrEkoTest < Test::Unit::TestCase  
+class MrEkoTest < Test::Unit::TestCase
 
   context "the module" do
-    
+
     should "return an Echonest API instance for nest" do
       assert_instance_of Echonest::Api, MrEko.nest
     end
-    
+
     should "return a Sequel instance for connection" do
       assert_instance_of Sequel::SQLite::Database, MrEko.connection
     end
-    
-    # should "raise an error when there is no api.key found" do
-      # File.expects(:exists?).with(File.join(MrEko::USER_DIR, 'echonest_api.key')).returns(false)
-      # File.expects(:exists?).with(File.join(MrEko::HOME_DIR, 'echonest_api.key')).returns(false)
-      # assert_raise(RuntimeError){ MrEko.setup_echonest! }
-    # end
-    
+
     should "return the MD5 of the passed filename" do
       md5 = Digest::MD5.hexdigest(open(__FILE__).read)
       assert_equal md5, MrEko.md5(__FILE__)
     end
+
+    context 'db_name' do
+
+      should 'return the test DB when in that env' do
+        assert_equal 'db/eko_test.db', MrEko.db_name
+      end
+
+      should 'return the main DB when not in the test env' do
+        MrEko.stubs(:env).returns('development')
+        assert_equal 'db/eko.db', MrEko.db_name
+      end
+    end
+
+    context 'enmfp_binary' do
+
+      should 'return proper Darwin bin' do
+        MrEko.stubs(:ruby_platform).returns("i686-darwin10.6.0")
+        assert_equal 'codegen.Darwin', MrEko.enmfp_binary
+      end
+
+      should 'return proper Windows bin' do
+        MrEko.stubs(:ruby_platform).returns("Win32")
+        assert_equal 'codegen.windows.exe', MrEko.enmfp_binary
+      end
+
+      should 'return proper 686 bin' do
+        MrEko.stubs(:ruby_platform).returns("i686-linux")
+        assert_equal 'codegen.Linux-i686', MrEko.enmfp_binary
+      end
+
+      should 'return proper x86 bin' do
+        MrEko.stubs(:ruby_platform).returns("x86_64-linux")
+        assert_equal 'codegen.Linux-x86_64', MrEko.enmfp_binary
+      end
+    end
   end
 
-end
+end