--- /dev/null
+---------------------------------------------------------------------------
+-- @author Alexander Yakushev <yakushev.alex@gmail.com>
+-- @copyright 2011-2013 Alexander Yakushev
+-- @release v1.2.4
+---------------------------------------------------------------------------
+
+-- Grab environment
+local awful = require('awful')
+
+local jamendo = {}
+
+-- UTILITY STUFF
+-- Checks whether file specified by filename exists.
+local function file_exists(filename, mode)
+ mode = mode or 'r'
+ f = io.open(filename, mode)
+ if f then
+ f:close()
+ return true
+ else
+ return false
+ end
+end
+
+local function str_interpose(coll, sep)
+ if #coll == 0 then
+ return ""
+ end
+ local result = coll[1]
+ for i = 2, #coll do
+ result = result .. sep .. coll[i]
+ end
+ print(result)
+ return result
+end
+
+-- Global variables
+jamendo.FORMAT_MP3 = { display = "MP3 (128k)",
+ short_display = "MP3",
+ value = "mp31" }
+jamendo.FORMAT_OGG = { display = "Ogg Vorbis (q4)",
+ short_display = "Ogg",
+ value = "ogg2" }
+jamendo.ORDER_RATINGDAILY = { display = "Daily rating",
+ short_display = "daily rating",
+ value = "ratingday_desc" }
+jamendo.ORDER_RATINGWEEKLY = { display = "Weekly rating",
+ short_display = "weekly rating",
+ value = "ratingweek_desc" }
+jamendo.ORDER_RATINGTOTAL = { display = "All time rating",
+ short_display = "all time rating",
+ value = "ratingtotal_desc" }
+jamendo.ORDER_RANDOM = { display = "Random",
+ short_display = "random",
+ value = "random_desc" }
+jamendo.ORDER_RELEVANCE = { display = "None (consecutive)",
+ short_display = "none",
+ value = "searchweight_desc" }
+jamendo.SEARCH_ARTIST = { display = "Artist",
+ unit = "artist",
+ value = "artist_id" }
+jamendo.SEARCH_ALBUM = { display = "Album",
+ unit = "album",
+ value = "album_id" }
+jamendo.SEARCH_TAG = { display = "Tag",
+ unit = "tag",
+ value = "tag_id" }
+jamendo.ALL_FORMATS = { jamendo.FORMAT_MP3, jamendo.FORMAT_OGG }
+jamendo.ALL_ORDERS = { ORDER_RELEVANCE, ORDER_RANDOM, ORDER_RATINGDAILY,
+ ORDER_RATINGWEEKLY, ORDER_RATINGTOTAL }
+
+jamendo.current_request_table = { unit = "track",
+ fields = {"id", "artist_url", "artist_name", "name",
+ "stream", "album_image", "album_name" },
+ joins = { "track_album", "album_artist" },
+ params = { streamencoding = jamendo.FORMAT_MP3,
+ order = jamendo.ORDER_RATINGWEEKLY,
+ n = 100 }}
+
+-- Local variables
+local jamendo_list = {}
+local cache_file = awful.util.getdir ("cache").."/jamendo_cache"
+local cache_header = "[version=1.1.0]"
+local album_covers_folder = awful.util.getdir("cache") .. "/jamendo_covers/"
+local default_mp3_stream = nil
+local search_template = { fields = { "id", "name" },
+ joins = {},
+ params = { order = ORDER_RELEVANCE,
+ n = 1}}
+
+-- DEPRECATED. Will be removed in the next major release.
+-- Returns default stream number for MP3 format. Requests API for it
+-- not more often than every hour.
+local function get_default_mp3_stream()
+ if not default_mp3_stream or
+ (os.time() - default_mp3_stream.last_checked) > 3600 then
+ local trygetlink =
+ jamendo.perform_request("echo $(curl -w %{redirect_url} " ..
+ "'http://api.jamendo.com/get2/stream/track/redirect/" ..
+ "?streamencoding="..jamendo.FORMAT_MP3.value.."&id=729304')")
+ local _, _, prefix = string.find(trygetlink, "stream(%d+)%.jamendo%.com")
+ default_mp3_stream = { id = prefix, last_checked = os.time() }
+ end
+ return default_mp3_stream.id
+end
+
+-- Returns the track ID from the given link to Jamendo stream. If the
+-- given text is not the Jamendo stream returns nil.
+function jamendo.get_id_from_link(link)
+ local _, _, id = string.find(link,"storage%-new.newjamendo.com/%?trackid=(%d+)")
+ return id
+end
+
+-- Returns link to music stream for the given track ID. Uses MP3
+-- format and the default stream for it.
+local function get_link_by_id(id)
+ -- This function is subject to change in the future.
+ return string.format("http://storage-new.newjamendo.com?trackid=%s&format=mp31&u=0", id)
+end
+
+-- -- Returns the album id for given music stream.
+-- function get_album_id_by_link(link)
+-- local id = get_id_from_link(link, true)
+-- if id and jamendo_list[id] then
+-- return jamendo_list[id].album_id
+-- end
+-- end
+
+-- Returns the track table for the given music stream.
+function jamendo.get_track_by_link(link)
+ local id = jamendo.get_id_from_link(link, true)
+ if id and jamendo_list[id] then
+ return jamendo_list[id]
+ end
+end
+
+-- If a track is actually a Jamendo stream, replace it with normal
+-- track name.
+function jamendo.replace_link(track_name)
+ local track = jamendo.get_track_by_link(track_name)
+ if track then
+ return track.display_name
+ else
+ return track_name
+ end
+end
+
+-- Returns table of track IDs, names and other things based on the
+-- request table.
+function jamendo.return_track_table(request_table)
+ local req_string = jamendo.form_request(request_table)
+ local response = jamendo.perform_request(req_string)
+ if not response then
+ return nil -- Bad internet connection
+ end
+ local parse_table = jamendo.parse_json(response)
+ for i = 1, #parse_table do
+ if parse_table[i].stream == "" then
+ -- Some songs don't have Ogg stream, use MP3 instead
+ parse_table[i].stream = get_link_by_id(parse_table[i].id)
+ end
+ _, _, parse_table[i].artist_link_name =
+ string.find(parse_table[i].artist_url, "\\/artist\\/(.+)")
+ -- Remove Jamendo escape slashes
+ parse_table[i].artist_name =
+ string.gsub(parse_table[i].artist_name, "\\/", "/")
+ parse_table[i].name = string.gsub(parse_table[i].name, "\\/", "/")
+
+ parse_table[i].display_name =
+ parse_table[i].artist_name .. " - " .. parse_table[i].name
+ -- Do Jamendo a favor, extract album_id for the track yourself
+ -- from album_image link :)
+ local _, _, album_id =
+ string.find(parse_table[i].album_image, "\\/(%d+)\\/covers")
+ parse_table[i].album_id = album_id or 0
+ -- Save fetched tracks for further caching
+ jamendo_list[parse_table[i].id] = parse_table[i]
+ end
+ jamendo.save_cache()
+ return parse_table
+end
+
+-- Generates the request to Jamendo API based on provided request
+-- table. If request_table is nil, uses current_request_table instead.
+-- For all values that do not exist in request_table use ones from
+-- current_request_table.
+-- return - HTTP-request
+function jamendo.form_request(request_table)
+ local curl_str = "curl -A 'Mozilla/4.0' -fsm 5 \"%s\""
+ local url = "http://api.jamendo.com/get2/%s/%s/json/%s/?%s"
+ request_table = request_table or jamendo.current_request_table
+
+ local fields = request_table.fields or jamendo.current_request_table.fields
+ local joins = request_table.joins or jamendo.current_request_table.joins
+ local unit = request_table.unit or jamendo.current_request_table.unit
+
+ -- Form fields string (like field1+field2+fieldN)
+ local f_string = str_interpose(fields, "+")
+ -- Form joins string
+ local j_string = str_interpose(joins, "+")
+
+ local params = {}
+ -- If parameters where supplied in request_table, add them to the
+ -- parameters in current_request_table.
+ if request_table.params and
+ request_table.params ~= jamendo.current_request_table.params then
+ -- First fill params with current_request_table parameters
+ for k, v in pairs(jamendo.current_request_table.params) do
+ params[k] = v
+ end
+ -- Then add and overwrite them with request_table parameters
+ for k, v in pairs(request_table.params) do
+ params[k] = v
+ end
+ else -- Or just use current_request_table.params
+ params = jamendo.current_request_table.params
+ end
+ -- Form parameter string (like param1=value1¶m2=value2)
+ local param_string = ""
+ for k, v in pairs(params) do
+ if type(v) == "table" then
+ v = v.value
+ end
+ v = string.gsub(v, " ", "+")
+ param_string = param_string .. "&" .. k .. "=" .. v
+ end
+
+ return string.format(curl_str, string.format(url, f_string, unit, j_string, param_string))
+end
+
+-- Primitive function for parsing Jamendo API JSON response. Does not
+-- support arrays. Supports only strings and numbers as values.
+-- Provides basic safety (correctly handles special symbols like comma
+-- and curly brackets inside strings)
+-- text - JSON text
+function jamendo.parse_json(text)
+ local parse_table = {}
+ local block = {}
+ local i = 0
+ local inblock = false
+ local instring = false
+ local curr_key = nil
+ local curr_val = nil
+ while i and i < string.len(text) do
+ if not inblock then -- We are not inside the block, find next {
+ i = string.find(text, "{", i+1)
+ inblock = true
+ block = {}
+ else
+ if not curr_key then -- We haven't found key yet
+ if not instring then -- We are not in string, check for more tags
+ local j = string.find(text, '"', i+1)
+ local k = string.find(text, '}', i+1)
+ if j and j < k then -- There are more tags in this block
+ i = j
+ instring = true
+ else -- Block is over, we found its ending
+ i = k
+ inblock = false
+ table.insert(parse_table, block)
+ end
+ else -- We are in string, find its ending
+ _, i, curr_key = string.find(text,'(.-[^%\\])"', i+1)
+ instring = false
+ end
+ else -- We have the key, let's find the value
+ if not curr_val then -- Value is not found yet
+ if not instring then -- Not in string, check if value is string
+ local j = string.find(text, '"', i+1)
+ local k = string.find(text, '[,}]', i+1)
+ if j and j < k then -- Value is string
+ i = j
+ instring = true
+ else -- Value is int
+ _, i, curr_val = string.find(text,'(%d+)', i+1)
+ end
+ else -- We are in string, find its ending
+ local j = string.find(text, '"', i+1)
+ if j == i+1 then -- String is empty
+ i = j
+ curr_val = ""
+ else
+ _, i, curr_val = string.find(text,'(.-[^%\\])"', i+1)
+ curr_val = jamendo.utf8_codes_to_symbols(curr_val)
+ end
+ instring = false
+ end
+ else -- We have both key and value, add it to table
+ block[curr_key] = curr_val
+ curr_key = nil
+ curr_val = nil
+ end
+ end
+ end
+ end
+ return parse_table
+end
+
+-- Jamendo returns Unicode symbols as \uXXXX. Lua does not transform
+-- them into symbols so we need to do it ourselves.
+function jamendo.utf8_codes_to_symbols (s)
+ local hexnums = "[%dabcdefABCDEF]"
+ local pattern = string.format("\\u(%s%s%s%s?)",
+ hexnums, hexnums, hexnums, hexnums)
+ local decode = function(code)
+ code = tonumber(code, 16)
+ if code < 128 then -- one-byte symbol
+ return string.char(code)
+ elseif code < 2048 then -- two-byte symbol
+ -- Grab high and low bytes
+ local hi = math.floor(code / 64)
+ local lo = math.fmod(code, 64)
+ -- Return symbol as \hi\lo
+ return string.char(hi + 192, lo + 128)
+ elseif code < 65536 then
+ -- Grab high, middle and low bytes
+ local hi = math.floor(code / 4096)
+ local leftover = code - hi * 4096
+ local mi = math.floor(leftover / 64)
+ leftover = leftover - mi * 64
+ local lo = math.fmod(leftover, 64)
+ -- Return symbol as \hi\mi\lo
+ return string.char(hi + 224, mi + 160, lo + 128)
+ elseif code < 1114112 then
+ -- Grab high, highmiddle, lowmiddle and low bytes
+ local hi = math.floor(code / 262144)
+ local leftover = code - hi * 262144
+ local hm = math.floor(leftover / 4096)
+ leftover = leftover - hm * 4096
+ local lm = math.floor(leftover / 64)
+ local lo = math.fmod(leftover, 64)
+ -- Return symbol as \hi\hm\lm\lo
+ return string.char(hi + 240, hm + 128, lm + 128, lo + 128)
+ else -- It is not Unicode symbol at all
+ return tostring(code)
+ end
+ end
+ return string.gsub(s, pattern, decode)
+end
+
+-- Retrieves mapping of track IDs to track names and album IDs to
+-- avoid redundant queries when Awesome gets restarted.
+local function retrieve_cache()
+ local bus = io.open(cache_file)
+ local track = {}
+ if bus then
+ local header = bus:read("*line")
+ if header == cache_header then
+ for l in bus:lines() do
+ local _, _, id, artist_link_name, album_name, album_id, track_name =
+ string.find(l,"(%d+)-([^-]+)-([^-]+)-(%d+)-(.+)")
+ track = {}
+ track.id = id
+ track.artist_link_name = string.gsub(artist_link_name, '\\_', '-')
+ track.album_name = string.gsub(album_name, '\\_', '-')
+ track.album_id = album_id
+ track.display_name = track_name
+ jamendo_list[id] = track
+ end
+ else
+ -- We encountered an outdated version of the cache
+ -- file. Let's just remove it.
+ awful.util.spawn("rm -f " .. cache_file)
+ end
+ end
+end
+
+-- Saves track IDs to track names and album IDs mapping into the cache
+-- file.
+function jamendo.save_cache()
+ local bus = io.open(cache_file, "w")
+ bus:write(cache_header .. "\n")
+ for id,track in pairs(jamendo_list) do
+ bus:write(string.format("%s-%s-%s-%s-%s\n", id,
+ string.gsub(track.artist_link_name, '-', '\\_'),
+ string.gsub(track.album_name, '-', '\\_'),
+ track.album_id, track.display_name))
+ end
+ bus:flush()
+ bus:close()
+end
+
+-- Retrieve cache on initialization
+retrieve_cache()
+
+-- Returns a filename of the album cover and formed wget request that
+-- downloads the album cover for the given track name. If the album
+-- cover already exists returns nil as the second argument.
+function jamendo.fetch_album_cover_request(track_id)
+ local track = jamendo_list[track_id]
+ local album_id = track.album_id
+
+ if album_id == 0 then -- No cover for tracks without album!
+ return nil
+ end
+ local file_path = album_covers_folder .. album_id .. ".jpg"
+
+ if not file_exists(file_path) then -- We need to download it
+ -- First check if cache directory exists
+ f = io.popen('test -d ' .. album_covers_folder .. ' && echo t')
+ if f:read("*line") ~= 't' then
+ awful.util.spawn("mkdir " .. album_covers_folder)
+ end
+ f:close()
+
+ if not track.album_image then -- Wow! We have album_id, but
+ local a_id = tostring(album_id) --don't have album_image. Well,
+ local prefix = --it happens.
+ string.sub(a_id, 1, #a_id - 3)
+ track.album_image =
+ string.format("http://imgjam.com/albums/s%s/%s/covers/1.100.jpg",
+ prefix == "" and 0 or prefix, a_id)
+ end
+
+ return file_path, string.format("wget %s -O %s 2> /dev/null",
+ track.album_image, file_path)
+ else -- Cover already downloaded, return its filename and nil
+ return file_path, nil
+ end
+end
+
+-- Returns a file containing an album cover for given track id. First
+-- searches in the cache folder. If file is not there, fetches it from
+-- the Internet and saves into the cache folder.
+function jamendo.get_album_cover(track_id)
+ local file_path, fetch_req = jamendo.fetch_album_cover_request(track_id)
+ if fetch_req then
+ local f = io.popen(fetch_req)
+ f:close()
+
+ -- Let's check if file is finally there, just in case
+ if not file_exists(file_path) then
+ return nil
+ end
+ end
+ return file_path
+end
+
+-- Same as get_album_cover, but downloads (if necessary) the cover
+-- asynchronously.
+function jamendo.get_album_cover_async(track_id)
+ local file_path, fetch_req = jamendo.fetch_album_cover_request(track_id)
+ if fetch_req then
+ asyncshell.request(fetch_req)
+ end
+end
+
+-- Checks if track_name is actually a link to Jamendo stream. If true
+-- returns the file with album cover for the track.
+function jamendo.try_get_cover(track_name)
+ local id = jamendo.get_id_from_link(track_name)
+ if id then
+ return jamendo.get_album_cover(id)
+ end
+end
+
+-- Same as try_get_cover, but calls get_album_cover_async inside.
+function jamendo.try_get_cover_async(track_name)
+ local id = jamendo.get_id_from_link(track_name)
+ if id then
+ return jamendo.get_album_cover_async(id)
+ end
+end
+
+-- Returns the track table for given query and search method.
+-- what - search method - SEARCH_ARTIST, ALBUM or TAG
+-- s - string to search
+function jamendo.search_by(what, s)
+ -- Get a default request and set unit and query
+ local req = search_template
+ req.unit = what.unit
+ req.params.searchquery = s
+ local resp = jamendo.perform_request(jamendo.form_request(req))
+ if resp then
+ local search_res = jamendo.parse_json(resp)[1]
+
+ if search_res then
+ -- Now when we got the search result, find tracks filtered by
+ -- this result.
+ local params = {}
+ params[what.value] = search_res.id
+ req = { params = params }
+ local track_table = jamendo.return_track_table(req)
+ return { search_res = search_res, tracks = track_table }
+ end
+ end
+end
+
+-- Executes request_string with io.popen and returns the response.
+function jamendo.perform_request(request_string)
+ local bus = assert(io.popen(request_string,'r'))
+ local response = bus:read("*all")
+ bus:close()
+ -- Curl with popen can sometimes fail to fetch data when the
+ -- connection is slow. Let's try again if it fails.
+ if #response == 0 then
+ bus = assert(io.popen(request_string,'r'))
+ response = bus:read("*all")
+ bus:close()
+ -- If it still can't read anything, return nil
+ if #response ~= 0 then
+ return nil
+ end
+ end
+ return response
+end
+
+-- Sets default streamencoding in current_request_table.
+function jamendo.set_current_format(format)
+ jamendo.current_request_table.params.streamencoding = format
+end
+
+-- Sets default order in current_request_table.
+function jamendo.set_current_order(order)
+ jamendo.current_request_table.params.order = order
+end
+
+return jamendo
repos / dotfiles.git / blobdiff