monkeymusic 0.0.4 → 0.0.5

data/lib/monkey_music_generate/recommendation_loader.rb

@@ -1,6 +1,6 @@
 require 'hallon'
 
-module MonkeyMusic
+module MonkeyMusic::Generate
   class RecommendationLoader
 
     def initialize(loaded_toplists, load_factor = 5)
@@ -10,66 +10,30 @@ module MonkeyMusic
 
     def load_for_user!(user)
       @user = user
-      puts "Loading recommendations from album toplist..."
-      load_recommendations_from_albums!
-      puts "Loading recommendations from artist toplist..."
-      load_recommendations_from_artists!
-      puts "Loading recommendations from track toplist albums..."
-      load_recommendations_from_top_track_albums!
-      puts "Loading recommendations from track toplist..."
-      load_recommendations_from_already_heard!
-      puts "Loading recommendations from disliked artists..."
-      load_recommendations_from_disliked!
-    end
-
-    private
-
-    def load_recommendations_from_albums!
-      @loaded_toplists[:top_albums].each do |album|
-        puts "Browsing #{album.name}..."
-        browse = album.browse
-        browse.load unless browse.loaded?
-        browse.tracks.first(@load_factor).each do |rec|
-          @user.recommendations << parse_track(rec)
-        end
+      @loaded_toplists.each do |name, list|
+        puts "Loading #{name}..."
+        list[:items].each { |item| load_recommendations_for!(list[:type], item) }
       end
     end
 
-    def load_recommendations_from_artists!
-      @loaded_toplists[:top_artists].each do |artist|
-        puts "Browsing #{artist.name}..."
-        browse = artist.browse(:no_albums)
-        browse.load unless browse.loaded?
-        browse.top_hits.first(@load_factor).each do |rec|
-          @user.recommendations << parse_track(rec)
-        end
-      end
-    end
-
-    def load_recommendations_from_top_track_albums!
-      @loaded_toplists[:top_track_albums].each do |album|
-        puts "Browsing #{album.name}..."
-        browse = album.browse
-        browse.load unless browse.loaded?
-        browse.tracks.first(@load_factor).each do |rec|
-          @user.recommendations << parse_track(rec)
-        end
-      end
-    end
-
-    def load_recommendations_from_already_heard!
-      @loaded_toplists[:top_tracks].each do |track|
-        @user.recommendations << parse_track(track)
-      end
-    end
+    private
 
-    def load_recommendations_from_disliked!
-      @loaded_toplists[:disliked].each do |artist|
-        puts "Browsing #{artist.name}..."
-        browse = artist.browse(:no_albums)
+    def load_recommendations_for!(type, item)
+      if type == :tracks
+        @user.recommendations << parse_track(item)            
+      else
+        browse = case type
+                   when :artists then item.browse(:no_albums)
+                   when :albums then item.browse
+                 end
+        puts "Browsing #{item.name}..."
         browse.load unless browse.loaded?
-        browse.top_hits.first(@load_factor).each do |rec|
-          @user.recommendations << parse_track(rec)
+        collection = case type
+                       when :artists then browse.top_hits
+                       when :albums then browse.tracks
+                     end
+        collection.first(@load_factor).each do |track|
+          @user.recommendations << parse_track(track)            
         end
       end
     end
@@ -77,14 +41,11 @@ module MonkeyMusic
     def parse_track(track)
       album = track.album.load
       artist = track.artist.load
-      user_track = Track.new
-      user_track.uri = track.to_link.to_str
-      user_track.name = track.name
-      user_track.artist = artist.name
-      user_track.album = album.name
-      user_track.popularity = track.popularity
-      user_track.year = album.release_year
-      user_track
+      MonkeyMusic::Metadata::Track.new :uri => track.to_link.to_str,
+                                       :name => track.name,
+                                       :artist => artist.name,
+                                       :album => album.name,
+                                       :year => album.release_year
     end
 
   end

data/lib/monkey_music_generate/runner.rb

@@ -0,0 +1,100 @@
+require 'optparse'
+require 'hallon'
+
+module MonkeyMusic
+  module Generate
+    class Runner
+
+      def initialize
+        OptionParser.new do |opts|
+          opts.banner = 'Usage: monkeymusic-generate [options]'
+
+          opts.on('-g',
+                  '--generate TOPLIST_FILE',
+                  'Generate a user from a toplist file.') do |user|
+            @toplist_file = File.join(Dir.getwd, user)
+          end
+
+          opts.on('-o',
+                  '--out OUT_FILE',
+                  'The file to dump a generated user to.') do |file|
+            @out_file = File.join(Dir.getwd, file)
+          end
+
+          opts.on('-k', 
+                  '--app-key KEY', 
+                  'Path to libspotify application key.') do |key|
+            @spotify_appkey_file = File.join(Dir.getwd, key)
+          end
+
+          opts.on('-a', 
+                  '--account ACCOUNT', 
+                  'Username for a Spotify premium account.') do |account|
+            @spotify_account = account
+          end
+
+          opts.on('-w', '--password PASSWORD', 
+                  'Password for a Spotify premium account.') do |password|
+            @spotify_password = password
+          end
+
+          opts.on_tail('-h',
+                       '--help', 
+                       'Show this message.') do 
+            puts opts
+            exit
+          end
+        end.parse!
+      end
+
+      def run
+        if generate_user?
+          # Create user
+          user = User.new
+          # Connect to libspotify
+          Hallon.load_timeout = 0
+          session = Hallon::Session.initialize(IO.read(@spotify_appkey_file))
+          session.login!(@spotify_account, @spotify_password)
+          # Load toplists
+          puts "Loading toplists from #{@toplist_file}..."
+          toplist_loader = ToplistLoader.new(@toplist_file)
+          toplist_loader.load_for_user!(user)
+          # Generate recommendations
+          puts "Loading recommendations..."
+          loaded_toplists = toplist_loader.loaded_toplists
+          recommendation_loader = RecommendationLoader.new(loaded_toplists)
+          recommendation_loader.load_for_user!(user)
+          ## Disconnect from libspotify
+          session.logout!
+          # Evaluate recommendations
+          puts "Evaluating recommendations..."
+          score_system = ScoreSystem.new
+          score_system.evaluate_user_recommendations!(user)
+          # Dump and print the user
+          File.open(@out_file, 'w') do |f|
+            f.write(user.dump)
+          end
+          puts "====="
+          puts "DONE!"
+          puts "====="
+          #puts "Loaded tracks:"
+          #user.recommendations.group_by(&:multiplier).sort.each do |k,v| 
+            #puts "#Multiplier #{k}:\t#{v.length}"
+          #end
+          exit
+        end
+      end
+    
+      private
+
+      def generate_user?
+        (defined? @toplist_file) &&
+          (defined? @out_file) &&
+          (defined? @spotify_appkey_file) &&
+          (defined? @spotify_account) &&
+          (defined? @spotify_password)
+      end
+
+    end
+  end
+end

data/lib/monkey_music_generate/score_system.rb

@@ -1,34 +1,49 @@
-module MonkeyMusic
+module MonkeyMusic::Generate
   class ScoreSystem
 
     def evaluate_user_recommendations!(user)
       @user = user
-      @user.recommendations.each { |track| evaluate!(track) }
+      @top_decade = calc_top_decade(user)
+      @user.recommendations.each {|track| evaluate!(track) }
+      puts "The user's top decade is: #{@top_decade}."
     end
 
     def evaluate!(track)
       multiplier = 0
-      if @user.toplists[:top_tracks].include? track.name
+      if @user.toplists[:top_tracks].any? {|t| t.name == track.name }
         multiplier = -1
-      elsif @user.toplists[:disliked].include? track.artist
+      elsif @user.toplists[:disliked_artists].any? {|ar| ar.name == track.artist }
         multiplier = -2
       else
-        if @user.toplists[:top_albums].include? track.album
+        if @user.toplists[:top_albums].any? {|al| al.name == track.album }
           multiplier += 1
         end
-        if @user.toplists[:top_artists].include? track.artist
+        if @user.toplists[:top_artists].any? {|ar| ar.name == track.artist }
           multiplier += 1
         end
-        if @user.toplists[:top_track_albums].include? track.album
+        if @top_decade == decade_of(track.year)
           multiplier += 1
         end
       end
-      track.multiplier = multiplier
-      track.value = 4**multiplier.abs * sign(multiplier)
+      track.set_value(multiplier, 4**multiplier.abs * sign(multiplier))
     end
 
     private
 
+    def calc_top_decade(user)
+      decades = {}
+      (user.toplists[:top_tracks] + user.toplists[:top_albums]).each do |t|
+        decade = decade_of(t.year)
+        decades[decade] ||= 0
+        decades[decade] += 1
+      end
+      (decades.max_by {|k,v| v }).first
+    end
+
+    def decade_of(year)
+      (year % 100) / 10
+    end
+
     def sign(num)
       num < 0 ? -1 : 1
     end

data/lib/monkey_music_generate/toplist_loader.rb

@@ -1,67 +1,83 @@
 require 'hallon'
 
-module MonkeyMusic
+module MonkeyMusic::Generate
   class ToplistLoader
     attr_reader :loaded_toplists
 
     def initialize(toplist_file)
-      @toplist_file = IO.read(toplist_file)
+      @toplist_file = toplist_file
       @toplists = {}
+      @loaded_toplists = {}
     end
 
     def load_for_user!(user)
       @user = user
       # Load toplists URI:s from file
-      self.instance_eval(@toplist_file)
+      self.instance_eval(IO.read @toplist_file)
       # Load toplist contents from libspotify
       load_toplists!
-      load_top_track_albums!
     end
 
     private
 
     # User toplist DSL
 
-    def toplist(type, uri)
-      @toplists[type] = uri
+    def toplist(type, name, uri)
+      @toplists[name] = { :type => type, :uri => uri }
     end
 
     # Toplist loading
 
     def load_toplists!
-      @loaded_toplists = {}
-      @toplists.each do |type, uri|
-        @loaded_toplists[type] = load_from_list(type, uri)
-        @user.toplists[type] = parse_toplist(@loaded_toplists[type])
+      @toplists.each do |name, list|
+        @loaded_toplists[name] = { 
+          :type => list[:type],
+          :items => load_from_list(list[:type], list[:uri])
+        }
+        @user.toplists[name] = parse_toplist(list[:type], @loaded_toplists[name][:items])
       end
     end
 
-    def load_top_track_albums!
-      @loaded_toplists[:top_track_albums] = 
-        @loaded_toplists[:top_tracks].map(&:album).each(&:load)
-      @user.toplists[:top_track_albums] = 
-        parse_toplist(@loaded_toplists[:top_track_albums])
-    end
-
     def load_from_list(type, uri)
       playlist = Hallon::Playlist.new(uri).load
       tracks = playlist.tracks.to_a
       tracks.each(&:load)
-      if type == :top_tracks
+      if type == :tracks
         tracks
-      elsif type == :top_artists || type == :disliked
+      elsif type == :artists
         tracks.map(&:artist).each(&:load)
-      elsif type == :top_albums
+      elsif type == :albums
         tracks.map(&:album).each(&:load)
       end
     end
 
-    def parse_toplist(list)
-      result = []
-      list.each do |item|
-        result << item.name
+    def parse_toplist(type, list)
+      case type
+        when :tracks  then list.map { |track| load_track track }
+        when :albums  then list.map { |album| load_album album }
+        when :artists then list.map { |artist| load_artist artist }
       end
-      result
+    end
+
+    def load_album(album)
+      artist = album.artist.load
+      MonkeyMusic::Metadata::Album.new :name => album.name, 
+                                       :artist => artist.name, 
+                                       :year => album.release_year
+    end
+
+    def load_artist(artist)
+      MonkeyMusic::Metadata::Artist.new :name => artist.name
+    end
+
+    def load_track(track)
+      album = track.album.load
+      artist = track.artist.load
+      MonkeyMusic::Metadata::Track.new :uri => track.to_link.to_str,
+                                       :name => track.name,
+                                       :artist => artist.name,
+                                       :album => album.name,
+                                       :year => album.release_year
     end
 
   end

data/lib/monkey_music_generate.rb

@@ -1,6 +1,6 @@
 $: << File.dirname(__FILE__)
 
-require 'monkey_music_generate/generator'
+require 'monkey_music_generate/runner'
 require 'monkey_music_generate/toplist_loader'
 require 'monkey_music_generate/recommendation_loader'
 require 'monkey_music_generate/score_system'

data/users/synth.rb

@@ -1,7 +1,11 @@
-toplist :top_tracks, "spotify:user:poscar%21:playlist:4yIhuHviCmTYjcFqunPxsa"
+toplist :tracks, :top_tracks, 
+  "spotify:user:poscar%21:playlist:4yIhuHviCmTYjcFqunPxsa"
 
-toplist :top_artists, "spotify:user:poscar%21:playlist:6MjfrIbeCKQMVCU9JQNf1u"
+toplist :albums, :top_albums, 
+  "spotify:user:poscar%21:playlist:6MjfrIbeCKQMVCU9JQNf1u"
 
-toplist :top_albums, "spotify:user:poscar%21:playlist:1ZXPeNHa8YYvY0VzxRdv3q"
+toplist :artists, :top_artists, 
+  "spotify:user:poscar%21:playlist:1ZXPeNHa8YYvY0VzxRdv3q"
 
-toplist :disliked, "spotify:user:poscar%21:playlist:5IEx3cooSMgrtftvw5B9Ug"
+toplist :artists, :disliked_artists,
+  "spotify:user:poscar%21:playlist:5IEx3cooSMgrtftvw5B9Ug"