lllibrary 0.0.1

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    lllibrary (0.0.1)
+      activerecord
+      activesupport
+      bundler
+      plist
+      sqlite3
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.9)
+      activesupport (= 3.2.9)
+      builder (~> 3.0.0)
+    activerecord (3.2.9)
+      activemodel (= 3.2.9)
+      activesupport (= 3.2.9)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.9)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.4)
+    i18n (0.6.1)
+    multi_json (1.5.0)
+    plist (3.1.0)
+    rake (10.0.3)
+    sqlite3 (1.3.6)
+    tzinfo (0.3.35)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  lllibrary!
+  rake

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2012 Jeremy Ruten
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+#lllibrary
+
+`lllibrary` is a Ruby library that manages music libraries. It stores tracks (with metadata) and playlists in a database (using ActiveRecord), and gives you a sort of DSL to build complex playlists with ease.
+
+## Install
+
+    $ gem install lllibrary
+
+## Usage
+
+This gives you an idea. Better documentation coming soon.
+
+    # Lllibrary
+    library = Lllibrary.new(File.join(ENV["HOME"], "music.sqlite3"), "sqlite3") do |t|
+      # provide a block like this if the database doesn't exist yet.
+      # the location, created_at, and updated_at fields are always
+      # created, the rest must be specified like so.
+
+      # adds database fields for title, artist, etc.
+      t.default_metadata
+
+      # adds all the database fields that iTunes uses
+      t.itunes_metadata
+
+      # you can also specify your own custom fields
+      t.string :five_word_review
+      t.integer :popularity, null: false, default: 0
+    end
+    library.tracks
+    library.playlists
+    library.add(Dir["Music/**/*.{mp3,m4a,ogg}"], &blk)
+    library.add_playlist(:favourites, library.select { rating 100 })
+    library.import(:itunes, "/path/to/iTunes Music Library.xml", &blk)
+    library.clear_playlists
+    library.clear_all
+
+    # Lllibrary::Track
+    track.playlists
+    track.location
+    track.created_at
+    track.updated_at
+    track.send(metadata_field)
+
+    # Lllibrary::Playlist
+    playlist.name
+    playlist.tracks
+    playlist.empty?
+    playlist.length
+    playlist.add(track_or_tracks, index = nil)
+    playlist.remove(track_or_tracks)
+    playlist.total_length
+    playlist.sort(&blk)
+    playlist.shuffle
+    playlist.playlist_items
+    playlist.created_at
+    playlist.updated_at
+    playlist.clear
+
+    # Lllibrary::PlaylistItem
+    playlist_item.position
+    playlist_item.track
+    playlist_item.playlist
+    playlist_item.created_at
+    playlist_item.updated_at
+
+    # Selectors DSL
+    library.select do
+      title("blackout")                # equivalent to library.tracks.where("title LIKE '%blackout%'").all
+      title("blackout", match: :left)  # equivalent to library.tracks.where("title LIKE 'blackout%'").all
+      title("blackout", match: :exact) # equivalent to library.tracks.where("title LIKE 'blackout'").all
+      length("1:00".."2:00")           # equivalent to library.tracks.where(length: 60000...120000).all
+      rating(gte: 80)                  # equivalent to library.tracks.where("rating >= 80").all
+      none                             # []
+      all                              # library.tracks.all
+    end
+
+## TODO
+
+* Better error reporting
+* Fix bug with time selectors
+* Get metadata from tags in audio files without requiring a C library to be installed (like taglib)
+* Allow blocks to be passed to Lllibrary#add and Lllibrary#import
+* Figure out how to handle multiple database connections
+* Tests, documentation, the like
+

data/lib/lllibrary.rb

@@ -0,0 +1,170 @@
+require "active_record"
+require "plist"
+
+require "lllibrary/track"
+require "lllibrary/playlist"
+require "lllibrary/playlist_item"
+
+require "lllibrary/database"
+require "lllibrary/dsl"
+
+class Lllibrary
+  def initialize(db_path, db_adapter, &schema_blk)
+    @db = Lllibrary::Database.new(db_path, db_adapter)
+    if schema_blk
+      @db.generate_schema do |t|
+        t.string :location
+        t.timestamps
+
+        schema_blk.call(t)
+      end
+    end
+    @dsl = Lllibrary::DSL.new(self)
+  end
+
+  def select(&blk)
+    @dsl.instance_eval &blk
+  end
+
+  def tracks
+    Lllibrary::Track.scoped
+  end
+
+  def playlists
+    Lllibrary::Playlist.scoped
+  end
+
+  def add(paths_to_tracks, &blk)
+    Array(paths_to_tracks).each do |path|
+      track = tracks.new(location: path)
+      track = blk.call(track) if blk
+      track.save! if track.is_a?(Track)
+    end
+  end
+
+  def add_playlist(name, tracks)
+    playlist = playlists.new(name: name)
+    playlist.save!
+    tracks.each.with_index do |track, i|
+      playlist_item = Lllibrary::PlaylistItem.new
+      playlist_item.playlist = playlist
+      playlist_item.track = track
+      playlist_item.position = i
+      playlist_item.save!
+    end
+  end
+
+  def import(type, path, options = {})
+    logger = options[:logger]
+    if type == :itunes
+      logger.("Parsing XML...") if logger
+      data = Plist::parse_xml(path)
+
+      logger.("Importing #{data['Tracks'].length} tracks...") if logger
+      num_tracks = 0
+      whitelist = tracks.new.attributes.keys
+      data["Tracks"].each do |track_id, row|
+        if row["Kind"] !~ /audio/
+          logger.("[skipping non-audio file]") if logger
+          next
+        end
+
+        # row already contains a hash of attributes almost ready to be passed to
+        # ActiveRecord. We just need to modify the keys, e.g. change "Play Count"
+        # to "play_count".
+        row["Title"] = row.delete("Name")
+        row["Play Date"] = row.delete("Play Date UTC")
+        row["Original ID"] = row.delete("Track ID")
+        attributes = row.inject({}) do |acc, (key, value)|
+          attribute = key.gsub(" ", "").underscore
+          acc[attribute] = value if whitelist.include? attribute
+          acc
+        end
+
+        # change iTunes' URL-style locations into simple paths
+        if attributes["location"] && attributes["location"] =~ /^file:\/\//
+          attributes["location"].sub! /^file:\/\/localhost/, ""
+
+          # CGI::unescape changes plus signs to spaces. This is a work around to
+          # keep the plus signs.
+          attributes["location"].gsub! "+", "%2B"
+
+          attributes["location"] = CGI::unescape(attributes["location"])
+        end
+
+        track = tracks.new(attributes)
+        if track.save
+          num_tracks += 1
+        end
+      end
+      logger.("Imported #{num_tracks} tracks successfully.") if logger
+
+      if tracks.new.attributes.keys.include? "original_id"
+        logger.("Importing #{data['Playlists'].length} playlists...") if logger
+        num_playlists = 0
+        data["Playlists"].each do |playlist_data|
+          playlist = []
+
+          if ["Library", "Music", "Movies", "TV Shows", "iTunes DJ"].include? playlist_data["Name"]
+            logger.("[skipping \"#{playlist_data['Name']}\" playlist]") if logger
+          elsif playlist_data["Playlist Items"].nil?
+            logger.("[skipping \"#{playlist_data['Name']}\" playlist (because it's empty)]") if logger
+          else
+            playlist_data["Playlist Items"].map(&:values).flatten.each do |original_id|
+              playlist << tracks.where(original_id: original_id).first
+            end
+            playlist.compact!
+            add_playlist(playlist_data["Name"], playlist)
+            num_playlists += 1
+          end
+        end
+        logger.("Imported #{num_playlists} playlists successfully.") if logger
+      else
+        logger.("Can't import playlists because tracks table doesn't have an original_id field.") if logger
+      end
+    end
+  end
+
+  def clear_playlists
+    playlists.destroy_all
+  end
+
+  def clear_all
+    tracks.destroy_all
+    clear_playlists
+  end
+
+  # Helper method to format a number of milliseconds as a string like
+  # "1:03:56.555". The only option is :include_milliseconds, true by default. If
+  # false, milliseconds won't be included in the formatted string.
+  def self.format_time(milliseconds, options = {})
+    ms = milliseconds % 1000
+    seconds = (milliseconds / 1000) % 60
+    minutes = (milliseconds / 60000) % 60
+    hours = milliseconds / 3600000
+
+    if ms.zero? || options[:include_milliseconds] == false
+      ms_string = ""
+    else
+      ms_string = ".%03d" % [ms]
+    end
+
+    if hours > 0
+      "%d:%02d:%02d%s" % [hours, minutes, seconds, ms_string]
+    else
+      "%d:%02d%s" % [minutes, seconds, ms_string]
+    end
+  end
+
+  # Helper method to parse a string like "1:03:56.555" and return the number of
+  # milliseconds that time length represents.
+  def self.parse_time(string)
+    parts = string.split(":").map(&:to_f)
+    parts = [0] + parts if parts.length == 2
+    hours, minutes, seconds = parts
+    seconds = hours * 3600 + minutes * 60 + seconds
+    milliseconds = seconds * 1000
+    milliseconds.to_i
+  end
+end
+

data/lib/lllibrary/database.rb

@@ -0,0 +1,84 @@
+class Lllibrary
+  class Database
+    def initialize(path, adapter)
+      @path, @adapter = path, adapter
+      ActiveRecord::Base.establish_connection(adapter: @adapter, database: @path)
+    end
+
+    def disconnect
+      ActiveRecord::Base.remove_connection
+    end
+
+    def exists?
+      File.exists? @path
+    end
+
+    def delete
+      FileUtils.rm @path
+    end
+
+    def connected?
+      ActiveRecord::Base.connected?
+    end
+
+    def generate_schema(&blk)
+      ActiveRecord::Schema.define do
+        create_table :tracks do |t|
+          t.string :location
+          t.timestamps
+
+          def t.default_metadata
+            string :title
+            string :artist
+            string :album
+            string :genre
+            integer :length
+            integer :track_number
+            integer :year
+          end
+
+          def t.itunes_metadata
+            integer :original_id
+            string :title
+            string :artist
+            string :composer
+            string :album
+            string :album_artist
+            string :genre
+            integer :total_time
+            integer :disc_number
+            integer :disc_count
+            integer :track_number
+            integer :track_count
+            integer :year
+            datetime :date_modified, null: false
+            datetime :date_added, null: false
+            integer :bit_rate
+            integer :sample_rate
+            text :comments
+            integer :play_count, null: false, default: 0
+            datetime :play_date
+            integer :skip_count, null: false, default: 0
+            datetime :skip_date
+            integer :rating, null: false, default: 0
+          end
+
+          blk.call(t)
+        end
+
+        create_table :playlists do |t|
+          t.string :name
+          t.datetime :created_at
+          t.datetime :updated_at
+        end
+
+        create_table :playlist_items do |t|
+          t.references :playlist, null: false
+          t.references :track, null: false
+          t.integer :position
+        end
+      end
+    end
+  end
+end
+

data/lib/lllibrary/dsl.rb

@@ -0,0 +1,144 @@
+class Lllibrary
+  class DSL
+    def initialize(library)
+      @library = library
+    end
+
+    def method_missing(field, *args)
+      if Lllibrary::Track.column_names.include? field.to_s
+        type = Lllibrary::Track.columns_hash[field.to_s].type
+        case type
+        when :integer, :float, :decimal, :boolean, :datetime, :timestamp, :date, :time
+          numeric_selector(field, *args)
+        when :string, :text
+          string_selector(field, *args)
+        else
+          raise ArgumentError, "lllibrary: selectors aren't supported for #{field}'s type '#{type}'"
+        end
+      else
+        super
+      end
+    end
+
+    # Selects all the tracks in the library.
+    def all
+      @library.tracks.all
+    end
+
+    # Selects no tracks, returning an empty playlist.
+    def none
+      []
+    end
+
+    # Makes a playlist out of tracks that match the string query on the given
+    # column. It's SQL underneath, so you can use % and _ as wildcards in the
+    # query. By default, % wildcards are inserted on the left and right of your
+    # query. Use the :match option to change this:
+    #
+    #   :match => :middle   "%query%"   (default)
+    #   :match => :left     "query%"
+    #   :match => :right    "%query"
+    #   :match => :exact    "query"
+    #
+    def string_selector(column, *queries)
+      options = queries.last.is_a?(Hash) ? queries.pop : {}
+      options[:match] ||= :middle
+
+      tracks = @library.tracks.arel_table
+      queries.map do |query|
+        query = {
+          exact: "#{query}",
+          left: "#{query}%",
+          right: "%#{query}",
+          middle: "%#{query}%"
+        }[options[:match]]
+
+        @library.tracks.where(tracks[column].matches(query)).all
+      end.flatten
+    end
+
+    # Makes a playlist out of tracks that satisfy certain conditions on the given
+    # numeric column. You can pass an exact value to check for equality, a range,
+    # or a hash that specifies greater-than and less-than options like this:
+    #
+    #   numeric_selector :year, greater_than: 2000
+    #
+    # The possible operators, with their shortcuts, are:
+    #
+    #   :greater_than / :gt
+    #   :less_than / :lt
+    #   :greater_than_or_equal / :gte
+    #   :less_than_or_equal / :lte
+    #   :not_equal / :ne
+    #
+    # Note: You can only use one of these operators at a time. If you want a
+    # range, use a Range.
+    #
+    def numeric_selector(column, *values_or_hash)
+      parse = lambda do |x|
+        if x.is_a? String
+          ms = Lllibrary.parse_time(x)
+          if ms % 1000 == 0
+            ms...(ms + 1000)
+          else
+            ms
+          end
+        elsif x.is_a? Range
+          left = x.begin.is_a?(String) ? Lllibrary.parse_time(x.begin) : x.begin
+          right = x.end.is_a?(String) ? Lllibrary.parse_time(x.end) : x.end
+          Range.new(left, right, x.exclude_end?)
+        else
+          x
+        end
+      end
+
+      if values_or_hash.last.is_a? Hash
+        operator = values_or_hash.last.keys.first.to_sym
+        value = parse.(values_or_hash.last.values.first)
+        case operator
+        when :greater_than, :gt
+          op = ">"
+          if value.is_a? Range
+            op = ">=" if value.exclude_end?
+            value = value.end
+          end
+          @library.tracks.where("tracks.#{column} #{op} ?", value).all
+        when :less_than, :lt
+          value = value.begin if value.is_a? Range
+          @library.tracks.where("tracks.#{column} < ?", value).all
+        when :greater_than_or_equal, :gte
+          value = value.begin if value.is_a? Range
+          @library.tracks.where("tracks.#{column} >= ?", value).all
+        when :less_than_or_equal, :lte
+          op = "<="
+          if value.is_a? Range
+            op = "<" if value.exclude_end?
+            value = value.end
+          end
+          @library.tracks.where("tracks.#{column} #{op} ?", value)
+        when :not_equal, :ne
+          if value.is_a? Range
+            op = value.exclude_end? ? ">=" : ">"
+            @library.tracks.where("tracks.#{column} < ? AND tracks.#{column} #{op} ?", value.begin, value.end)
+          else
+            @library.tracks.where("tracks.#{column} != ?", value)
+          end
+        else
+          raise ArgumentError, "'#{operator}' isn't a valid operator"
+        end
+      else
+        @library.tracks.where(column => parse.(values_or_hash)).all
+      end
+    end
+
+    def playlist(*names)
+      names.map do |name|
+        playlists = @library.playlists.arel_table
+        if playlist = @library.playlists.where(playlists[:name].matches(name.to_s)).first
+          playlist.tracks.all
+        end
+      end.flatten
+    end
+  end
+end
+

data/lib/lllibrary/playlist.rb

@@ -0,0 +1,62 @@
+class Lllibrary
+  class Playlist < ActiveRecord::Base
+    has_many :playlist_items, order: "playlist_items.position ASC", dependent: :destroy
+    has_many :tracks, through: :playlist_items, order: "playlist_items.position ASC"
+
+    def add(track_or_tracks, at = nil)
+      base_position = nil
+      if at
+        at_track = playlist_items.offset(at).first
+        base_position = at_track.position if at_track
+      end
+      base_position ||= empty? ? 0 : playlist_items.last.position + 1
+
+      playlist_items.where("playlist_items.position >= ?", base_position).update_all("position = position + #{Array(track_or_tracks).length}")
+
+      Array(track_or_tracks).each.with_index do |track, i|
+        playlist_item = Lllibrary::PlaylistItem.new
+        playlist_item.track = track
+        playlist_item.playlist = self
+        playlist_item.position = base_position + i
+        playlist_item.save!
+      end
+
+      reload
+    end
+
+    def remove(track_or_tracks)
+      playlist_items.where(track_id: track_or_tracks).destroy_all
+      reload
+    end
+
+    def empty?
+      playlist_items.empty?
+    end
+
+    def length
+      playlist_items.count
+    end
+
+    def total_length(options = {})
+      tracks.sum(options[:field] || :length)
+    end
+
+    def sort(&blk)
+      sorted_tracks = tracks.sort(&blk)
+      clear
+      add(sorted_tracks)
+    end
+
+    def shuffle
+      shuffled_tracks = tracks.shuffle
+      clear
+      add(shuffled_tracks)
+    end
+
+    def clear
+      playlist_items.destroy_all
+      reload
+    end
+  end
+end
+

data/lib/lllibrary/playlist_item.rb

@@ -0,0 +1,6 @@
+class Lllibrary
+  class PlaylistItem < ActiveRecord::Base
+    belongs_to :playlist
+    belongs_to :track
+  end
+end

data/lib/lllibrary/track.rb

@@ -0,0 +1,8 @@
+class Lllibrary
+  class Track < ActiveRecord::Base
+    has_many :playlist_items, dependent: :destroy
+    has_many :playlists, through: :playlist_items
+
+    validates :location, presence: true, uniqueness: true
+  end
+end

data/lllibrary.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name = "lllibrary"
+  s.version = "0.0.1"
+  s.date = "2012-12-17"
+  s.summary = "A library for managing and querying a music library."
+  s.description = "lllibrary is a Ruby library for managing and querying a music library."
+  s.author = "Jeremy Ruten"
+  s.email = "jeremy.ruten@gmail.com"
+  s.homepage = "http://github.com/yjerem/lllibrary"
+  s.license = "MIT"
+  s.required_ruby_version = ">= 1.9.2"
+
+  s.files = ["Gemfile", "Gemfile.lock", "LICENSE", "lllibrary.gemspec", "README.md"]
+  s.files += Dir["lib/**/*.rb"]
+
+  %w(bundler plist sqlite3 activerecord activesupport).each do |gem_name|
+    s.add_runtime_dependency gem_name
+  end
+
+  %w(rake).each do |gem_name|
+    s.add_development_dependency gem_name
+  end
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: lllibrary
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jeremy Ruten
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: plist
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: lllibrary is a Ruby library for managing and querying a music library.
+email: jeremy.ruten@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- lllibrary.gemspec
+- README.md
+- lib/lllibrary/database.rb
+- lib/lllibrary/dsl.rb
+- lib/lllibrary/playlist.rb
+- lib/lllibrary/playlist_item.rb
+- lib/lllibrary/track.rb
+- lib/lllibrary.rb
+homepage: http://github.com/yjerem/lllibrary
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A library for managing and querying a music library.
+test_files: []