def get_track(provider_id):
t = Track()
try:
######MediaNet######
# reqUrl = 'http://ie-api.mndigital.com?method=track.get&format=json&'\
# + urllib.urlencode({'mnetid': provider_id})\
# + '&ApiKey=%s' % MusicProvider._mnDigitalIntegrationAPIKey
reqUrl = "http://itunes.apple.com/lookup?" + urllib.urlencode({"id": provider_id})
# track_json = common.get_json(reqUrl)["Track"]
track_json = common.get_json(reqUrl)["results"][0]
t.provider_id = provider_id
t.length_seconds = 0
t.url = ""
# t.artist = track_json["Artist"]["Name"]
# t.title = track_json["Title"]
# t.length_friendly = track_json["Duration"]
# t.album = track_json["Album"]["Title"]
# t.art_url = track_json["Album"]["Images"]["Album150x150"]
t.artist = track_json["artistName"]
t.title = track_json["trackName"]
t.length_friendly = ""
t.album = track_json["collectionName"]
t.art_url = track_json["artworkUrl100"]
except Exception:
pass
return t
def create_track_from_uri(self, uri):
if 'youtube' not in uri:
return None
m = re.search('http://www.youtube.com/get_video.video_id=(.*?)&t=(.*)',uri)
client = gdata.youtube.service.YouTubeService()
client.ssl = False
entry = client.GetYouTubeVideoEntry(video_id=m.group(1))
logging.debug("Created track from uri %s in youtubesource", uri)
#PrintEntryDetails(entry)
swfuri = entry.GetSwfUrl()
video_id = m.group(1)
t = m.group(2)
track = Track(uri)
track.title = entry.media.title.text
track.artist = "YOUTUBE VIDEO"
track.album = entry.media.category[0].text
#FIXME add search for author on album?
track.album_uri = None
track.duration = int(entry.media.duration.seconds)*1000
return track
def create_track_from_uri(self, uri):
uri = SpotifySource.strip_protocol(uri)
if uri == None:
return None
url = "http://ws.spotify.com/lookup/1/?uri=" + uri
try:
e = ET.parse(urllib.urlopen(url))
except Exception as e:
return None
ns = "http://www.spotify.com/ns/music/1"
if 'album' in uri:
title = ""
artist = e.find('.//{%s}artist/{%s}name' % (ns, ns)).text
album = e.find('.//{%s}name' % ns).text
duration = 0
album_uri = uri
else:
title = e.find('.//{%s}name' % ns).text
artist = e.find('.//{%s}artist/{%s}name' % (ns, ns)).text
album = e.find('.//{%s}album/{%s}name' % (ns, ns)).text
duration = int(float(e.find('.//{%s}length' % ns).text) * 1000)
album_uri = "spotify://" + e.find('.//{%s}album' % ns).attrib['href']
track = Track("spotify://"+uri)
track.title = title
track.artist = artist
track.album = album
track.album_uri = album_uri
track.duration = duration
return track
def create_track_from_uri(self, uri):
if 'asx' not in uri:
return None
logging.debug("Created track from uri %s in srradiosource", uri)
u = urllib.urlopen(uri)
str = re.search('\"mms:.+\"', u.read())
u = open("sr.xml")
tree = ET.parse(u)
u.close()
track = Track(str.group(0)[1:-1])
for e in tree.findall('channel'):
for k in e.findall('streamingurl'):
for s in k.findall('url'):
if uri in s.text:
track.title = e.get('name')
track.artist = "SR RADIOTRACK"
track.album = "SR RADIOTRACK"
track.album_uri = None
track.duration = 1
return track
def trackFromResult(resultTrack):
localTrack = Track()
localTrack.title = resultTrack.name
localTrack.artist = resultTrack.artists[0].name
localTrack.album = resultTrack.album.name
time = resultTrack.length / 1000
localTrack.timeAudio = str(int(time / 60)) + ":" + '%02d' % int(time % 60)
image = m.library.get_images([resultTrack.album.uri])
localTrack.imageURI = image[resultTrack.album.uri][0].uri
return localTrack
def create_tracks_from_album(self, album):
tracks = []
for track in album['tracks']:
tmptrack = Track(track['uri'])
tmptrack.title = track['title']
tmptrack.artist = track['artist']
tmptrack.album = album['name']
tmptrack.album_uri = album['uri']
tmptrack.duration = track['duration']
tracks.append(tmptrack)
return tracks
def index(self, path):
for top, dirnames, filenames in os.walk(path):
for filename in filenames:
if filename.endswith('.mp3'):
full_path = os.path.join(top, filename);
f = tagpy.FileRef(full_path)
t = Track("file://" + full_path)
t.title = f.tag().title
t.artist = f.tag().artist
t.album = f.tag().album
a = f.audioProperties()
t.duration = a.length * 1000 # to msec
self.add_track(t)
def search(self, criteria):
print(f'searching Spotify with criteria of {criteria}')
results = self.sp.search(q=criteria, limit=1)
for i, t in enumerate(results['tracks']['items']):
track = Track()
track.title = t['name']
track.number = pad_track_number(t['track_number'])
album_id = t['album']['id']
album = self.get_album_old(album_id)
track.artist = album.artist
track.album = album.title
track.year = album.year
track.genres = album.genres
return track
def indexFromFile(self): self.file = open(os.getcwd() + '/options/index.txt', 'r') path = None line = self.file.readline() while line != '': code = line[0:2] if code == "NP": path = line[2:-1] line = self.file.readline() t = Track() t.path = path + "/" + line[0:-1] t.artist = self.file.readline()[0:-1] t.title = self.file.readline()[0:-1] t.album = self.file.readline()[0:-1] self.tracks.append(t) self.gui.addTrack(t) line = self.file.readline() self.file.close() self.gui.loading_finished()
def getAllUploadedTracks():
tracksSet = OrderedSet()
if not os.path.exists("library_cache.json") or \
("--rebuild-cache" in sys.argv or "-rc" in sys.argv):
print("Fetching list of uploaded songs. For a lot of songs, this may take a long time...")
tracks = ytmusic.get_library_upload_songs(limit=100000)
for yttrack in tracks:
track = Track()
if yttrack["artists"]:
track.artist = yttrack["artists"][0]["name"].strip()
if yttrack["album"]:
track.album = yttrack["album"]["name"].strip()
track.title = yttrack["title"].strip()
track.entityId = yttrack["entityId"]
tracksSet.add(track)
dumpToCache(tracksSet)
else:
print("using library_cache.json")
tracksSet = loadCache()
return tracksSet
def create_track_from_uri(self, uri):
url = "http://ws.spotify.com/lookup/1/?uri=" + uri
try:
e = ET.parse(urllib.urlopen(url))
except Exception as e:
return None
ns = "http://www.spotify.com/ns/music/1"
title = e.find('.//{%s}name' % ns).text
artist = e.find('.//{%s}artist/{%s}name' % (ns, ns)).text
album = e.find('.//{%s}album/{%s}name' % (ns, ns)).text
duration = int(float(e.find('.//{%s}length' % ns).text) * 1000)
track = Track("spotify://"+uri)
track.title = title
track.artist = artist
track.album = album
track.duration = duration
return track
def getAllLocalTracks():
print("Reading tags from local files...")
folders = []
tracks = OrderedSet()
with open("folders.json", "r") as foldersJson:
folders = json.loads(foldersJson.read())["folders"]
for folder in folders:
for root, subdirs, files in os.walk(folder):
for filename in files:
filePath = os.path.join(root, filename)
_filename, fileExtension = os.path.splitext(filename)
fileExtension = fileExtension.lower()
if fileExtension in SUPPORTED_EXTS:
try:
metadata = mutagen.File(filePath)
except mutagen.MutagenError as e:
print(f"{filename}: {e}")
continue
if not metadata:
print("no tags for " + filePath)
continue
artist = None
album = None
title = None
if (fileExtension == ".flac" or fileExtension == ".ogg"):
if metadata.get("artist"):
artist = metadata.get("artist")[0]
elif metadata.get("albumartist"):
artist = metadata.get("albumartist")[0]
if metadata.get("album"):
album = metadata.get("album")[0]
if metadata.get("title"):
title = metadata.get("title")[0]
elif fileExtension == ".mp3":
if metadata.get("TPE1"):
artist = metadata.get("TPE1")[0]
elif metadata.get("TPE2"):
artist = metadata.get("TPE2")[0]
if metadata.get("TALB"):
album = metadata.get("TALB")[0]
if metadata.get("TIT2"):
title = metadata.get("TIT2")[0]
elif fileExtension == ".m4a":
if metadata.get("\xa9ART"):
artist = metadata.get("\xa9ART")[0]
elif metadata.get("aART"):
artist = metadata.get("aART")[0]
if metadata.get("\xa9alb"):
album = metadata.get("\xa9alb")[0]
if metadata.get("\xa9nam"):
title = metadata.get("\xa9nam")[0]
elif fileExtension == ".wma":
if metadata.get("Author"):
artist = metadata.get("Author")[0].value
elif metadata.get("WM/Composer"):
artist = metadata.get("WM/Composer")[0].value
if metadata.get("WM/AlbumTitle"):
album = metadata.get("WM/AlbumTitle")[0].value
if metadata.get("Title"):
title = metadata.get("Title")[0].value
if artist:
artist = artist.strip()
if ", " in artist:
splits = []
for split in artist.split(", "):
splits.append(split.strip())
artist = ", ".join(splits)
if album:
album = album.strip()
if title:
title = title.strip()
if not title:
print("no tags for " + filePath)
else:
track = Track()
track.artist = artist
track.album = album
track.title = title
track.filePath = filePath
tracks.add(track)
return tracks
