625 lines
17 KiB
Clojure
625 lines
17 KiB
Clojure
(ns clj-lastfm.core
|
|
(:import (java.net URI)
|
|
(java.text SimpleDateFormat)
|
|
(java.util TimeZone))
|
|
(:use [clj-lastfm.filecache]
|
|
[clojure.contrib.def :only (defvar-)]
|
|
[clojure.contrib.json :only (read-json)]
|
|
[clojure.contrib.logging]
|
|
[clojure.contrib.math :only (ceil)]))
|
|
|
|
;;;;;;;;;; Basic ;;;;;;;;;;
|
|
|
|
(defvar- api-root-url ["http" "ws.audioscrobbler.com" "/2.0/"])
|
|
|
|
(defn- api-key []
|
|
(let [lastfm-api-key (resolve '*lastfm-api-key*)]
|
|
(if (nil? lastfm-api-key)
|
|
(throw (IllegalStateException. "lastfm API key is not set"))
|
|
lastfm-api-key)))
|
|
|
|
(defvar- guid-pattern
|
|
(let [an "[0-9a-fA-F]"]
|
|
(re-pattern
|
|
(str "^" an "{8}-" an "{4}-" an "{4}-" an "{4}-" an "{12}$"))))
|
|
|
|
(defn- mbid? [s] (if (re-matches guid-pattern s) true false))
|
|
|
|
(defvar- attr-kw (keyword "@attr"))
|
|
|
|
(defvar- text-kw (keyword "#text"))
|
|
|
|
(defn- safe-parse-int [n]
|
|
(if (nil? n)
|
|
nil
|
|
(try
|
|
(Integer/parseInt n)
|
|
(catch NumberFormatException nfe nil))))
|
|
|
|
(defn- safe-parse-double [n]
|
|
(if (nil? n)
|
|
nil
|
|
(try
|
|
(Double/parseDouble n)
|
|
(catch NumberFormatException nfe nil))))
|
|
|
|
(defn- str-1? [n] (-> n safe-parse-int (= 1)))
|
|
|
|
(defn- blank? [s] (every? #(Character/isWhitespace #^Character %) s))
|
|
|
|
(defn- struct? [obj] (instance? clojure.lang.PersistentStructMap obj))
|
|
|
|
(def #^{:private true :tag SimpleDateFormat} sdftz
|
|
(doto (SimpleDateFormat. "EEE, dd MMMM yyyy HH:mm:ss +0000")
|
|
(.setTimeZone (TimeZone/getTimeZone "GMT"))))
|
|
|
|
(def #^{:private true :tag SimpleDateFormat} sdf
|
|
(doto (SimpleDateFormat. "EEE, dd MMMM yyyy HH:mm:ss")
|
|
(.setTimeZone (TimeZone/getTimeZone "GMT"))))
|
|
|
|
(defn- parse-date [date-str]
|
|
(if (some #(% date-str) [nil? blank?])
|
|
nil
|
|
(try
|
|
(.parse sdftz date-str)
|
|
(catch java.text.ParseException e
|
|
(.parse sdf date-str)))))
|
|
|
|
(defn- remove-nil-values [m]
|
|
(apply hash-map (apply concat (filter #(-> % fnext nil? not) m))))
|
|
|
|
(defn- lastfm-url [path]
|
|
(.toString (URI. "http" "www.last.fm" path nil nil)))
|
|
|
|
(defn- create-url-query [query-params]
|
|
(apply str
|
|
(interpose
|
|
"&"
|
|
(map
|
|
#(str (name (first %)) "=" (second %))
|
|
(remove-nil-values query-params)))))
|
|
|
|
(defn- create-url [query-params]
|
|
(.toURL
|
|
(#^URI apply
|
|
#(URI. %1 %2 %3 %4 %5)
|
|
(conj
|
|
api-root-url
|
|
(create-url-query
|
|
(merge query-params {:api_key @(api-key) :format "json"}))
|
|
nil))))
|
|
|
|
(defvar- default-cache (create-file-cache))
|
|
|
|
(defn- get-url
|
|
([url] (get-url url default-cache))
|
|
([url cache]
|
|
(do
|
|
(info (str "URL: " url))
|
|
(get-file-content cache url))))
|
|
|
|
(defn- get-data [params]
|
|
(let [url (create-url params)
|
|
data (-> url get-url read-json)]
|
|
(if (-> data :error nil?)
|
|
data
|
|
(throw (IllegalArgumentException. (-> data :message str))))))
|
|
|
|
(defn- create-get-obj-fn [fixed-params parse-fn]
|
|
(fn [more-params]
|
|
(parse-fn #(get-data (merge fixed-params more-params)))))
|
|
|
|
(defn- create-paged-get-obj-fn [fixed-params parse-fn]
|
|
(fn
|
|
([more-params]
|
|
((create-get-obj-fn fixed-params parse-fn)
|
|
more-params))
|
|
([more-params page]
|
|
((create-get-obj-fn fixed-params parse-fn)
|
|
(assoc more-params :page page)))))
|
|
|
|
(defn- create-get-obj-field-fn [create-obj-fn extract-obj-id-fields-fn]
|
|
(fn [obj field-kw]
|
|
(let [field-val (obj field-kw)]
|
|
(if (nil? field-val)
|
|
((apply create-obj-fn (extract-obj-id-fields-fn obj)) field-kw)
|
|
field-val))))
|
|
|
|
(defn- create-parse-one-or-more-fn [parse-one-fn extractor-fn]
|
|
(fn [data-fn]
|
|
(lazy-seq
|
|
(let [data (data-fn) one-or-more (extractor-fn data)]
|
|
(do
|
|
(debug (str "parsing: " data))
|
|
(if (map? one-or-more)
|
|
(vector (parse-one-fn one-or-more))
|
|
(vec (map parse-one-fn one-or-more))))))))
|
|
|
|
(defn- create-parse-string-or-list-fn [obj-from-name-fn extractor-fn]
|
|
(fn [data]
|
|
(let [string-or-list (extractor-fn data)]
|
|
(if (string? string-or-list)
|
|
(vector (obj-from-name-fn string-or-list))
|
|
(vec (map obj-from-name-fn string-or-list))))))
|
|
|
|
(defn- create-paged-parse-fn
|
|
[pages-fn page-fn perpage-fn param-fn parse-unpaged-fn get-fn]
|
|
(fn [data-fn]
|
|
(lazy-seq
|
|
(let [data (data-fn)
|
|
pages (-> data pages-fn safe-parse-int)
|
|
page (-> data page-fn safe-parse-int)
|
|
limit (-> data perpage-fn safe-parse-int)
|
|
params (param-fn data)]
|
|
(if (= page pages)
|
|
(parse-unpaged-fn data-fn)
|
|
(lazy-cat
|
|
(parse-unpaged-fn data-fn)
|
|
(get-fn (merge params {:page (inc page) :limit limit}))))))))
|
|
|
|
(defn- create-paged-result-parse-fn
|
|
[page-info-fn param-fn parse-unpaged-fn get-fn]
|
|
(create-paged-parse-fn
|
|
#(-> % page-info-fn :totalPages)
|
|
#(-> % page-info-fn :page)
|
|
#(-> % page-info-fn :perPage)
|
|
param-fn parse-unpaged-fn get-fn))
|
|
|
|
(defn- create-paged-search-parse-fn
|
|
[parse-unpaged-fn search-key get-fn]
|
|
(create-paged-parse-fn
|
|
#(-> (/ (-> % :results :opensearch:totalResults safe-parse-int)
|
|
(-> % :results :opensearch:itemsPerPage safe-parse-double))
|
|
ceil int str)
|
|
#(-> % :results :opensearch:Query :startPage)
|
|
#(-> % :results :opensearch:itemsPerPage)
|
|
#(hash-map search-key (-> % :results :opensearch:Query :searchTerms))
|
|
parse-unpaged-fn get-fn))
|
|
|
|
|
|
;;;;;;;;;; record defs ;;;;;;;;;;
|
|
|
|
(defrecord Tag [name url])
|
|
|
|
(defrecord Bio [published summary content])
|
|
|
|
(defrecord Location [latitude longitude street postalcode city country])
|
|
|
|
(defrecord Venue [id name location url website phonenumber])
|
|
|
|
(defrecord Event [id title artists headliner venue start description
|
|
attendence reviews tag url website cancelled tags])
|
|
|
|
(defrecord Shout [body author date])
|
|
|
|
(defrecord Artist [name url mbid streamable listeners playcount bio])
|
|
|
|
(defrecord Album [name id url mbid artist playcount])
|
|
|
|
(defrecord Track
|
|
[name url mbid artist playcount listeners streamable])
|
|
|
|
(defrecord User [name url realname])
|
|
|
|
;;;;;;;;;; forward declaration ;;;;;;;;;;
|
|
|
|
(declare artist-from-name tag-from-name user-from-name
|
|
album-from-map user-from-map track-from-map)
|
|
|
|
;;;;;;;;;; Bio/Wiki ;;;;;;;;;;
|
|
|
|
(defn- parse-bio [data]
|
|
(do
|
|
(debug (str "parse-bio: " data))
|
|
(Bio.
|
|
(-> data :published parse-date)
|
|
(data :summary)
|
|
(data :content))))
|
|
|
|
;;;;;;;;;; Location ;;;;;;;;;;
|
|
|
|
(defn- parse-location [data]
|
|
(do
|
|
(debug (str "parse-location: " data))
|
|
(Location.
|
|
(-> data :geo:point :geo:lat safe-parse-double)
|
|
(-> data :geo:point :geo:long safe-parse-double)
|
|
(data :street)
|
|
(data :postalcode)
|
|
(data :city)
|
|
(data :country))))
|
|
|
|
;;;;;;;;;; Venue ;;;;;;;;;;
|
|
|
|
(defn- parse-venue [data]
|
|
(do
|
|
(debug (str "parse-venue: " data))
|
|
(Venue.
|
|
(data :id)
|
|
(data :name)
|
|
(-> data :location parse-location)
|
|
(data :url)
|
|
(data :website)
|
|
(data :phonenumber))))
|
|
|
|
;;;;;;;;;; Event ;;;;;;;;;;
|
|
|
|
(defvar- parse-event-artists
|
|
(create-parse-string-or-list-fn
|
|
#(artist-from-name %) #(-> % :artists :artist)))
|
|
|
|
(defvar- parse-event-tags
|
|
(create-parse-string-or-list-fn
|
|
#(tag-from-name %) #(-> % :tags :tag)))
|
|
|
|
(defn- parse-event [data]
|
|
(do
|
|
(debug (str "parse-event: " data))
|
|
(Event.
|
|
(data :id)
|
|
(data :title)
|
|
(parse-event-artists data)
|
|
(artist-from-name (-> data :artists :headliner))
|
|
(-> data :venue parse-venue)
|
|
(-> data :startDate parse-date)
|
|
(data :description)
|
|
(-> data :attendence safe-parse-int)
|
|
(-> data :reviews safe-parse-int)
|
|
(data :tag)
|
|
(data :url)
|
|
(data :website)
|
|
(-> data :cancelled str-1?)
|
|
(parse-event-tags data))))
|
|
|
|
;;;;;;;;;; Shout ;;;;;;;;;;
|
|
|
|
(defn- parse-shout [data]
|
|
(do
|
|
(debug (str "parse-shout: " data))
|
|
(Shout.
|
|
(data :body)
|
|
(-> data :author user-from-name)
|
|
(-> data :date parse-date))))
|
|
|
|
;;;;;;;;;; Artist ;;;;;;;;;;
|
|
|
|
(defn- parse-artist [data]
|
|
(do
|
|
(debug (str "parse-artist: " data))
|
|
(Artist.
|
|
(data :name)
|
|
(data :url)
|
|
(data :mbid)
|
|
(-> data :streamable str-1?)
|
|
(-> data :stats :listeners safe-parse-int)
|
|
(-> data :stats :playcount safe-parse-int)
|
|
(-> data :bio parse-bio))))
|
|
|
|
(defn- artist-from-map [field-map]
|
|
(merge (Artist. nil nil nil nil nil nil nil) field-map))
|
|
|
|
(defn- artist-from-name [artist-name] (artist-from-map {:name artist-name}))
|
|
|
|
;;;;;;;;;; artist.getinfo ;;;;;;;;;;
|
|
|
|
(defn- parse-artist-getinfo [data-fn]
|
|
(let [data (data-fn)]
|
|
(do
|
|
(debug (str "parse-artist-getinfo: " data))
|
|
(-> data :artist parse-artist))))
|
|
|
|
(defvar- get-artist
|
|
(create-get-obj-fn {:method "artist.getinfo"} parse-artist-getinfo))
|
|
|
|
(defmulti artist
|
|
(fn [artist-or-mbid & _]
|
|
(if (mbid? artist-or-mbid) :mbid :artist)))
|
|
|
|
(defmethod artist :artist
|
|
([artist-name] (artist artist-name nil nil))
|
|
([artist-name username] (artist artist-name username nil))
|
|
([artist-name username lang]
|
|
(get-artist {:artist artist-name :username username :lang lang})))
|
|
|
|
(defmethod artist :mbid
|
|
([mbid] (artist mbid nil nil))
|
|
([mbid username] (artist mbid username nil))
|
|
([mbid username lang]
|
|
(get-artist {:mbid mbid :username username :lang lang})))
|
|
|
|
(def artist-info
|
|
(create-get-obj-field-fn artist #(vector (% :name))))
|
|
|
|
;;;;;;;;;; artist.getsimilar ;;;;;;;;;;
|
|
|
|
(defn- parse-artist-similar-1 [data]
|
|
(artist-from-map
|
|
{:name (data :name)
|
|
:url (data :url)
|
|
:mbid (data :mbid)
|
|
:streamable (-> data :streamable str-1?)
|
|
:match (-> data :match safe-parse-double)}))
|
|
|
|
(defvar- parse-artist-similar
|
|
(create-parse-one-or-more-fn
|
|
parse-artist-similar-1 #(-> % :similarartists :artist)))
|
|
|
|
(defvar- get-artist-similar
|
|
(create-get-obj-fn
|
|
{:method "artist.getsimilar"} parse-artist-similar))
|
|
|
|
(defn- artist-or-name [artst-or-name & _]
|
|
(if (struct? artst-or-name) :artist :name))
|
|
|
|
(defmulti artist-similar artist-or-name)
|
|
|
|
(defmethod artist-similar :artist
|
|
([artst] (-> artst :name artist-similar))
|
|
([artst limit] (artist-similar (artst :name) limit)))
|
|
|
|
(defmethod artist-similar :name
|
|
([artist-name]
|
|
(get-artist-similar {:artist artist-name}))
|
|
([artist-name limit]
|
|
(get-artist-similar {:artist artist-name :limit limit})))
|
|
|
|
;;;;;;;;;; artist.gettoptags ;;;;;;;;;;
|
|
|
|
(defvar- parse-artist-toptags
|
|
(create-parse-one-or-more-fn
|
|
#(Tag. (% :name) (% :url))
|
|
#(-> % :toptags :tag)))
|
|
|
|
(defvar- get-artist-toptags
|
|
(create-get-obj-fn
|
|
{:method "artist.gettoptags"} parse-artist-toptags))
|
|
|
|
(defmulti artist-toptags artist-or-name)
|
|
|
|
(defmethod artist-toptags :artist [artst]
|
|
(-> artst :name artist-toptags))
|
|
|
|
(defmethod artist-toptags :name [artist-name]
|
|
(get-artist-toptags {:artist artist-name}))
|
|
|
|
;;;;;;;;;; artist.gettopalbums ;;;;;;;;;;
|
|
|
|
(defn- parse-artist-topalbums-1 [data]
|
|
(album-from-map
|
|
{:name (data :name)
|
|
:url (data :url)
|
|
:mbid (data :mbid)
|
|
:artist (artist-from-map
|
|
{:name (-> data :artist :name)
|
|
:url (-> data :artist :url)
|
|
:mbid (-> data :artist :mbid)})
|
|
:playcount (-> data :playcount safe-parse-int)
|
|
:rank (-> data attr-kw :rank safe-parse-int)}))
|
|
|
|
(defvar- parse-artist-topalbums
|
|
(create-parse-one-or-more-fn
|
|
parse-artist-topalbums-1 #(-> % :topalbums :album)))
|
|
|
|
(defvar- get-artist-topalbums
|
|
(create-get-obj-fn
|
|
{:method "artist.gettopalbums"} parse-artist-topalbums))
|
|
|
|
(defmulti artist-topalbums artist-or-name)
|
|
|
|
(defmethod artist-topalbums :artist [artst]
|
|
(-> artst :name artist-topalbums))
|
|
|
|
(defmethod artist-topalbums :name [artist-name]
|
|
(get-artist-topalbums {:artist artist-name}))
|
|
|
|
;;;;;;;;;; artist.gettopfans ;;;;;;;;;;
|
|
|
|
(defn- parse-artist-topfans-1 [data]
|
|
(user-from-map
|
|
{:name (data :name)
|
|
:url (data :url)
|
|
:realname (data :realname)
|
|
:weight (-> data :weight safe-parse-int)}))
|
|
|
|
(defvar- parse-artist-topfans
|
|
(create-parse-one-or-more-fn
|
|
parse-artist-topfans-1 #(-> % :topfans :user)))
|
|
|
|
(defvar- get-artist-topfans
|
|
(create-get-obj-fn
|
|
{:method "artist.gettopfans"} parse-artist-topfans))
|
|
|
|
(defmulti artist-topfans artist-or-name)
|
|
|
|
(defmethod artist-topfans :artist [artst]
|
|
(-> artst :name artist-topfans))
|
|
|
|
(defmethod artist-topfans :name [artist-name]
|
|
(get-artist-topfans {:artist artist-name}))
|
|
|
|
;;;;;;;;;; artist.gettoptracks ;;;;;;;;;;
|
|
|
|
(defn- parse-artist-toptracks-1 [data]
|
|
(track-from-map
|
|
{:name (data :name)
|
|
:url (data :url)
|
|
:mbid (data :mbid)
|
|
:artist (artist-from-map
|
|
{:name (-> data :artist :name)
|
|
:url (-> data :artist :url)
|
|
:mbid (-> data :artist :mbid)})
|
|
:playcount (-> data :playcount safe-parse-int)
|
|
:listeners (-> data :listeners safe-parse-int)
|
|
:streamable (-> data :streamable text-kw str-1?)
|
|
:streamable-full (-> data :streamable :fulltrack str-1?)}))
|
|
|
|
(defvar- parse-artist-toptracks
|
|
(create-parse-one-or-more-fn
|
|
parse-artist-toptracks-1 #(-> % :toptracks :track)))
|
|
|
|
(defvar- get-artist-toptracks
|
|
(create-get-obj-fn
|
|
{:method "artist.gettoptracks"} parse-artist-toptracks))
|
|
|
|
(defmulti artist-toptracks artist-or-name)
|
|
|
|
(defmethod artist-toptracks :artist [artst]
|
|
(-> artst :name artist-toptracks))
|
|
|
|
(defmethod artist-toptracks :name [artist-name]
|
|
(get-artist-toptracks {:artist artist-name}))
|
|
|
|
;;;;;;;;;; artist.getevents ;;;;;;;;;;
|
|
|
|
(defvar- parse-artist-events
|
|
(create-parse-one-or-more-fn parse-event #(-> % :events :event)))
|
|
|
|
(defvar- get-artist-events
|
|
(create-get-obj-fn
|
|
{:method "artist.getevents"} parse-artist-events))
|
|
|
|
(defmulti artist-events artist-or-name)
|
|
|
|
(defmethod artist-events :artist [artst]
|
|
(-> artst :name artist-events))
|
|
|
|
(defmethod artist-events :name [artist-name]
|
|
(get-artist-events {:artist artist-name}))
|
|
|
|
;;;;;;;;;; artist.getpastevents ;;;;;;;;;;
|
|
|
|
(declare get-artist-pastevents)
|
|
|
|
(defvar- parse-artist-pastevents
|
|
(create-paged-result-parse-fn
|
|
#(-> % :events attr-kw)
|
|
#(hash-map :artist (-> % :events attr-kw :artist))
|
|
parse-artist-events
|
|
#(get-artist-pastevents %)))
|
|
|
|
(defvar- get-artist-pastevents
|
|
(create-paged-get-obj-fn
|
|
{:method "artist.getpastevents"} parse-artist-pastevents))
|
|
|
|
(defmulti artist-pastevents artist-or-name)
|
|
|
|
(defmethod artist-pastevents :artist
|
|
([artst] (-> artst :name artist-pastevents))
|
|
([artst limit] (artist-pastevents (artst :name) limit)))
|
|
|
|
(defmethod artist-pastevents :name
|
|
([artist-name]
|
|
(get-artist-pastevents {:artist artist-name}))
|
|
([artist-name limit]
|
|
(get-artist-pastevents {:artist artist-name :limit limit})))
|
|
|
|
;;;;;;;;;; artist.getshouts ;;;;;;;;;;
|
|
|
|
(declare get-artist-shouts)
|
|
|
|
(defvar- parse-artist-shouts-unpaged
|
|
(create-parse-one-or-more-fn parse-shout #(-> % :shouts :shout)))
|
|
|
|
(defvar- parse-artist-shouts
|
|
(create-paged-result-parse-fn
|
|
#(-> % :shouts attr-kw)
|
|
#(hash-map :artist (-> % :shouts attr-kw :artist))
|
|
parse-artist-shouts-unpaged
|
|
#(get-artist-shouts %)))
|
|
|
|
(defvar- get-artist-shouts
|
|
(create-paged-get-obj-fn
|
|
{:method "artist.getshouts"} parse-artist-shouts))
|
|
|
|
(defmulti artist-shouts artist-or-name)
|
|
|
|
(defmethod artist-shouts :artist
|
|
([artst] (-> artst :name artist-shouts))
|
|
([artst limit] (artist-shouts (artst :name) limit)))
|
|
|
|
(defmethod artist-shouts :name
|
|
([artist-name]
|
|
(get-artist-shouts {:artist artist-name}))
|
|
([artist-name limit]
|
|
(get-artist-shouts {:artist artist-name :limit limit})))
|
|
|
|
;;;;;;;;;; artist.search ;;;;;;;;;;
|
|
|
|
(declare get-artist-search)
|
|
|
|
(defvar- parse-artist-search-unpaged
|
|
(create-parse-one-or-more-fn
|
|
#(artist-from-map
|
|
{:name (% :name)
|
|
:url (% :url)
|
|
:mbid (% :mbid)
|
|
:streamable (-> % :streamable str-1?)})
|
|
#(-> % :results :artistmatches :artist)))
|
|
|
|
(defvar- parse-artist-search
|
|
(create-paged-search-parse-fn
|
|
parse-artist-search-unpaged :artist #(get-artist-search %)))
|
|
|
|
(defvar- get-artist-search
|
|
(create-paged-get-obj-fn
|
|
{:method "artist.search"} parse-artist-search))
|
|
|
|
(defn artist-search [artist-name]
|
|
(get-artist-search {:artist artist-name}))
|
|
|
|
;;;;;;;;;; Album ;;;;;;;;;;
|
|
|
|
(defn- album-from-map [field-map]
|
|
(merge (Album. nil nil nil nil nil nil) field-map))
|
|
|
|
;;;;;;;;;; album.search ;;;;;;;;;;
|
|
|
|
(declare get-album-search)
|
|
|
|
(defvar- parse-album-search-unpaged
|
|
(create-parse-one-or-more-fn
|
|
#(album-from-map
|
|
{:name (% :name)
|
|
:url (% :url)
|
|
:id (-> % :id safe-parse-int)
|
|
:artist (-> % :artist artist-from-name)
|
|
:streamable (-> % :streamable str-1?)})
|
|
#(-> % :results :albummatches :album)))
|
|
|
|
(defvar- parse-album-search
|
|
(create-paged-search-parse-fn
|
|
parse-album-search-unpaged :album #(get-album-search %)))
|
|
|
|
(defvar- get-album-search
|
|
(create-paged-get-obj-fn
|
|
{:method "album.search"} parse-album-search))
|
|
|
|
(defn album-search [album-name]
|
|
(get-album-search {:album album-name}))
|
|
|
|
;;;;;;;;;; Tag ;;;;;;;;;;
|
|
|
|
(defn- tag-from-name [tag-name]
|
|
(Tag. tag-name (lastfm-url (str "/tag/" tag-name))))
|
|
|
|
;;;;;;;;;; Track ;;;;;;;;;;
|
|
|
|
(defn- track-from-map [field-map]
|
|
(merge (Track. nil nil nil nil nil nil nil) field-map))
|
|
|
|
;;;;;;;;;; User ;;;;;;;;;;
|
|
|
|
(defn- user-from-map [field-map]
|
|
(merge (User. nil nil nil) field-map))
|
|
|
|
(defn- user-from-name [user-name]
|
|
(user-from-map {:name user-name}))
|
|
|
|
(comment
|
|
|
|
(def *lastfm-api-key* "23caa86333d2cb2055fa82129802780a")
|
|
(def u2 (artist "u2"))
|
|
(println (artist-info u2 :url))
|
|
|
|
)
|