def set_max_track():
data = Song.objects().order_by("-track_n")[0]
print data.track_n
songsMeta = SongsMeta.objects().all()
if (len(songsMeta) > 0):
m = songsMeta[0]
else:
m = SongsMeta()
m.n = data.track_n
m.save()
def set_max_track():
data = Song.objects().order_by("-track_n")[0]
print data.track_n
songsMeta = SongsMeta.objects().all()
if(len(songsMeta)>0):
m = songsMeta[0]
else:
m = SongsMeta()
m.n = data.track_n
m.save()
def get_songs(song_id: str):
songs = []
if song_id:
try:
songs.append(Song.objects.get(id=song_id))
except DoesNotExist:
return make_response('', 404)
else:
songs = Song.objects()
return make_response(jsonify(_resolve_songs(*songs)), 200)
def get_highest_poll_song(cls, stream_id):
poll = cls.get_current_poll(stream_id)
mx = -1
mx_song = None
for poll_item in poll.poll_items:
poll_item.song = Song.objects(id=poll_item.song.id).get()
print poll_item.song.title , poll_item.poll_count
if(poll_item.poll_count>=mx):
if(poll_item.poll_count==mx):
if(random.randint(0,1)==1):
continue
mx = poll_item.poll_count
mx_song = poll_item.song
return mx_song
def process_song(self, song):
source.track('processing_song')
if (SeenRecording.objects(mbid=song.mbid)):
source.track('seen_song')
return
SeenRecording(mbid=song.mbid).save()
if Song.objects(mbid=song.mbid):
source.track('already_present')
# We already have the song
return
lyric = scraper.get_lyrics(artist=song.artist, title=song.title)
source.track('searching_for_lyric')
if lyric:
source.track('found_lyric')
song.add_lyric(lyric['string'], lyric['source'])
song.save()
def get_init_data(stream_id, user=None):
from requests import stream_events_handler
song = Song.objects().order_by("-last_played")[0]
poll = Poll.get_current_poll(stream_id)
init_data = InitData()
if(user):
init_data.user = user
poll_item = user.get_poll_item(poll)
if(poll_item):
init_data.user_poll_item_id = str(poll_item.id)#string
init_data.poll = poll
init_data.n_user = len( stream_events_handler.event_listeners[stream_id])
init_data.current_song = song
return init_data
def get_init_data(stream_id, user=None):
from requests import stream_events_handler
song = Song.objects().order_by("-last_played")[0]
poll = Poll.get_current_poll(stream_id)
init_data = InitData()
if (user):
init_data.user = user
poll_item = user.get_poll_item(poll)
if (poll_item):
init_data.user_poll_item_id = str(poll_item.id) #string
init_data.poll = poll
init_data.n_user = len(stream_events_handler.event_listeners[stream_id])
init_data.current_song = song
return init_data
def create_next_poll(cls, stream_id , save_in_db = True):
#pick , 7 songs,
# create poll items ,
# create poll item with the stream Id
#return
total_songs = SongsMeta.objects().get().n
poll = Poll()
poll.stream_id = stream_id
if(save_in_db):
poll.save()
poll_items = []
try:
temp_track_hash = {}
while(len(poll_items)<7):
try:
random_track_n = random.randint(0,total_songs)
if(temp_track_hash.get(random_track_n, None)): continue# dont repeat tracks
song = Song.objects(track_n=random_track_n).get()
poll_item = PollItem(song = song , poll_count =0 , poll= poll)
poll_items.append(poll_item)
temp_track_hash[random_track_n] = True
except (MultipleObjectsReturned, DoesNotExist) as ex:
pass
for poll_item in poll_items:
if(save_in_db):
poll_item.save()
poll.poll_items = poll_items
if(save_in_db):
poll.save()#again with updates pollItems
except Exception as ex:
print ex
poll.delete()
poll = None
for poll_item in poll_items:
if(save_in_db):
poll_item.delete()
return poll
from pymongo import MongoClient
from models.song import Song
from mongoengine import connect
connect('test')
client = MongoClient()
db = client.test
print('hello')
for n_song in db.target.find():
mbid = n_song.get('mbid', None)
if not mbid:
continue
song = Song.objects(mbid=mbid)
if not song:
song = Song(
mbid=mbid,
title=n_song['title'],
artist=n_song['artist']
)
song.add_lyric(n_song.get('lyric', None), 'target')
song.save()
def get(self, _id):
"""Get a song by id.
"""
song = Song.objects(id=_id)[0]
return song
from pymongo import MongoClient
from models.song import Song
from mongoengine import connect
connect('test')
client = MongoClient()
db = client.test
print('hello')
for n_song in db.target.find():
mbid = n_song.get('mbid', None)
if not mbid:
continue
song = Song.objects(mbid=mbid)
if not song:
song = Song(mbid=mbid, title=n_song['title'], artist=n_song['artist'])
song.add_lyric(n_song.get('lyric', None), 'target')
song.save()
def test2():
song = Song.objects().get()
data = SON()
data["song"] = song.to_son()
print json_util.dumps(data)
def _run(self):
print "loading audio stream :: ", self.stream_id
while(True):
song_url_path = None
current_poll = Poll.get_current_poll(self.stream_id)
if(current_poll):
if(not IS_TEST_BUILD):
song = current_poll.get_highest_poll_song(self.stream_id)
else:
song = Song.objects(track_n=158).get()
if(song):
song_url_path = song.path
retry_poll_creation = 3
while(retry_poll_creation>0):
poll = Poll.create_next_poll(self.stream_id , not IS_TEST_BUILD)
if(poll!=None):
break
retry_poll_creation-=1
if(poll==None):
continue
if(not song_url_path):
song_url_path = "http://storage.googleapis.com/telugubeats_files/music/Telugu/devisri%20prasad/arya/amalapuram.mp3"
if(song_url_path.startswith("/Users/abhinav/Desktop/Telugu//")):
song_url_path="http://storage.googleapis.com/telugubeats_files/music/Telugu/"+urllib.quote(song_url_path[31:])
print "playing::", song_url_path
self.fd = RemoteUrlFileObject(song_url_path)
#spawn greenlet, keep reading into buffer
#block calls to seek and read if buffer is not sufficient enough
reset_data = InitData()
reset_data.poll = poll
reset_data.n_user = 1000+len( stream_events_handler.event_listeners[self.stream_id])
reset_data.current_song = song
song.last_played = datetime.utcnow()
if(not IS_TEST_BUILD):
song.save()
event_data = json_util.dumps(reset_data.to_son())
stream_events_handler.publish_event(self.stream_id, Event.RESET_POLLS_AND_SONG, event_data, from_user = None)
# if there is valid ID3 data, read it out of the file first,
# so we can skip sending it to the client
try:
self.id3 = id3reader.Reader(self.fd)
if isinstance(self.id3.header.size, int): # read out the id3 data
self.fd.seek(self.id3.header.size)
while(True):
try:
cur_time = time.time()
if(cur_time- self.last_time_stamp > self.sleep_time):
self.last_time_stamp = cur_time
self.buffer.queue_chunk(self.fd.read(self.buffer.chunk_byte_size))
gevent.sleep(self.sleep_time- time.time()+self.last_time_stamp)
except EOFError:
self.fd.close()
break
except Exception as e:
print e
