def test_add_song_from_path_and_get_song_by_id(self):
with mock.patch.object(config, 'paths', testing_utils.MOCK_CONFIG_PATHS):
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
new_song_id = song_manager.add_song_from_path(self.test_song_1_path)
file_uri = testing_utils.TEST_STATIC_URI + 'music/1.mp3'
art_path = \
os.path.join(testing_utils.TEST_TEMP_PATH, 'album-art', '1.jpg')
art_uri = testing_utils.TEST_STATIC_URI + 'album-art/1.jpg'
expected_row = {
'id': 1,
'title': u'test_title',
'artist': u'test_artist',
'album': u'test_album',
'trackno': u'1',
'date': u'2014',
'genre': u'test_genre',
'duration': u'184.32',
'file_path': unicode(self.test_song_1_path),
'file_uri': unicode(file_uri),
'art_path': unicode(art_path),
'art_uri': unicode(art_uri),
'tags': None,
'play_count': 0,
'fave_count': 0,
}
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
added_song = song_manager.get_song_by_id(new_song_id)
added_song_datetime = added_song.pop('datetime_added')
assert datetime.datetime == type(added_song_datetime)
assert expected_row == added_song
self.assertIsImage(art_path)
def test_get_ordered_playlist_and_pop_first_song(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
playlist_manager.add_song_by_id(1)
playlist_manager.add_song_by_id(2, True)
playlist_manager.add_song_by_id(3)
playlist_manager.add_song_by_id(4, True)
ordered_playlist = playlist_manager.get_ordered_playlist()
ordered_playlist_as_list = playlist_manager.get_ordered_playlist(as_list=True)
assert type(list()) == type(ordered_playlist_as_list)
expected_playlist = {}
expected_song_ids = [2, 4, 1, 3]
expected_requested_state = [True, True, False, False]
for ii in range(len(expected_song_ids)):
expected_playlist[unicode(ii)] = {
'song_id' : expected_song_ids[ii],
'user_requested' : expected_requested_state[ii]
}
assert expected_playlist == ordered_playlist
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
playlist_manager.pop_first_song()
ordered_playlist = playlist_manager.get_ordered_playlist()
expected_playlist = {}
expected_song_ids.pop(0)
expected_requested_state.pop(0)
for ii in range(len(expected_song_ids)):
expected_playlist[unicode(ii)] = {
'song_id' : expected_song_ids[ii],
'user_requested' : expected_requested_state[ii]
}
assert expected_playlist == ordered_playlist
def test_add_song_from_path_and_get_song_by_id(self):
with mock.patch.object(config, 'paths',
testing_utils.MOCK_CONFIG_PATHS):
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
new_song_id = song_manager.add_song_from_path(
self.test_song_1_path)
file_uri = testing_utils.TEST_STATIC_URI + 'music/1.mp3'
art_path = \
os.path.join(testing_utils.TEST_TEMP_PATH, 'album-art', '1.jpg')
art_uri = testing_utils.TEST_STATIC_URI + 'album-art/1.jpg'
expected_row = {
'id': 1,
'title': u'test_title',
'artist': u'test_artist',
'album': u'test_album',
'trackno': u'1',
'date': u'2014',
'genre': u'test_genre',
'duration': u'184.32',
'file_path': unicode(self.test_song_1_path),
'file_uri': unicode(file_uri),
'art_path': unicode(art_path),
'art_uri': unicode(art_uri),
'tags': None,
'play_count': 0,
'fave_count': 0,
}
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
added_song = song_manager.get_song_by_id(new_song_id)
added_song_datetime = added_song.pop('datetime_added')
assert datetime.datetime == type(added_song_datetime)
assert expected_row == added_song
self.assertIsImage(art_path)
def test_add_song_by_id(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
playlist_manager.add_song_by_id(1)
playlist_manager.add_song_by_id(2, True)
expected_row_1 = {
'id' : 1,
'song_id' : 1,
'user_requested' : False,
'currently_playing' : False
}
expected_row_2 = {
'id' : 2,
'song_id' : 2,
'user_requested' : True,
'currently_playing' : False
}
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
playlist_song_1 = session.query(stream_playlist.Playlist).filter_by(id=1).first()
playlist_song_2 = session.query(stream_playlist.Playlist).filter_by(id=2).first()
playlist_song_1_contents = \
playlist_manager.format_query_rows_to_dict(playlist_song_1)
playlist_song_2_contents = \
playlist_manager.format_query_rows_to_dict(playlist_song_2)
playlist_song_1_time = playlist_song_1_contents.pop('datetime_added')
playlist_song_2_time = playlist_song_2_contents.pop('datetime_added')
assert expected_row_1 == playlist_song_1_contents
assert type(datetime.datetime.now()) == type(playlist_song_1_time)
assert expected_row_2 == playlist_song_2_contents
assert type(datetime.datetime.now()) == type(playlist_song_2_time)
def test_get_ordered_playlist_and_pop_first_song(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
playlist_manager.add_song_by_id(1)
playlist_manager.add_song_by_id(2, True)
playlist_manager.add_song_by_id(3)
playlist_manager.add_song_by_id(4, True)
ordered_playlist = playlist_manager.get_ordered_playlist()
ordered_playlist_as_list = playlist_manager.get_ordered_playlist(
as_list=True)
assert type(list()) == type(ordered_playlist_as_list)
expected_playlist = {}
expected_song_ids = [2, 4, 1, 3]
expected_requested_state = [True, True, False, False]
for ii in range(len(expected_song_ids)):
expected_playlist[unicode(ii)] = {
'song_id': expected_song_ids[ii],
'user_requested': expected_requested_state[ii]
}
assert expected_playlist == ordered_playlist
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
playlist_manager.pop_first_song()
ordered_playlist = playlist_manager.get_ordered_playlist()
expected_playlist = {}
expected_song_ids.pop(0)
expected_requested_state.pop(0)
for ii in range(len(expected_song_ids)):
expected_playlist[unicode(ii)] = {
'song_id': expected_song_ids[ii],
'user_requested': expected_requested_state[ii]
}
assert expected_playlist == ordered_playlist
def test_set_first_song_as_currently_playing(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
playlist_manager.add_song_by_id(1)
playlist_manager.set_first_song_as_currently_playing()
with db_operations.session_scope() as session:
first_song = session.query(stream_playlist.Playlist).filter_by(id=1).one()
assert True == first_song.currently_playing
def test_set_first_song_as_currently_playing(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
playlist_manager.add_song_by_id(1)
playlist_manager.set_first_song_as_currently_playing()
with db_operations.session_scope() as session:
first_song = session.query(
stream_playlist.Playlist).filter_by(id=1).one()
assert True == first_song.currently_playing
def _add_song_and_check_song_count(self, song_path, expected_song_count):
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
assert expected_song_count-1 == song_manager.get_song_count()
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
song_manager.add_song_from_path(song_path)
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
assert expected_song_count == song_manager.get_song_count()
def _add_song_and_check_song_count(self, song_path, expected_song_count):
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
assert expected_song_count - 1 == song_manager.get_song_count()
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
song_manager.add_song_from_path(song_path)
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
assert expected_song_count == song_manager.get_song_count()
def add_random_song_with_user_request_to_playlist(self, user_requested=False):
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
random_song = self._get_random_unblocked_song(song_manager)
self.add_song_with_user_request_to_playlist(
random_song.id, user_requested
)
def test_update_song_db(self):
with mock.patch.object(config, 'paths',
testing_utils.MOCK_CONFIG_PATHS):
self._database_controller.update_song_db()
with db_operations.session_scope() as session:
all_songs = session.query(song.Song).all()
assert 3 == len(all_songs)
def test_add_random_songs_to_playlist_until_max_length(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
assert 0 == playlist_manager.get_playlist_length()
self._stream_controller.add_random_songs_to_playlist_until_max_length()
playlist_size = config.stream_options['playlist_size']
assert playlist_size == playlist_manager.get_playlist_length()
def test_load_song_library(self, mock_stream_player_update):
with mock.patch.object(config, 'paths', testing_utils.MOCK_CONFIG_PATHS):
self._stream_controller.load_song_library()
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
assert 3 == song_manager.get_song_count()
assert True == mock_stream_player_update.called
def add_random_song_with_user_request_to_playlist(self,
user_requested=False):
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
random_song = self._get_random_unblocked_song(song_manager)
self.add_song_with_user_request_to_playlist(
random_song.id, user_requested)
def test_get_playlist_length(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
songs_to_add = 5
for ii in range(songs_to_add):
assert ii == playlist_manager.get_playlist_length()
playlist_manager.add_song_by_id(ii)
assert songs_to_add == playlist_manager.get_playlist_length()
def test_load_song_library(self, mock_stream_player_update):
with mock.patch.object(config, 'paths',
testing_utils.MOCK_CONFIG_PATHS):
self._stream_controller.load_song_library()
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
assert 3 == song_manager.get_song_count()
assert True == mock_stream_player_update.called
def test_add_random_songs_to_playlist_until_max_length(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
assert 0 == playlist_manager.get_playlist_length()
self._stream_controller.add_random_songs_to_playlist_until_max_length(
)
playlist_size = config.stream_options['playlist_size']
assert playlist_size == playlist_manager.get_playlist_length()
def get(self):
song_id = self.request.arguments['song-id'][0]
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
song_data = song_manager.get_song_by_id(song_id)
song_data['datetime_added'] = \
song_data['datetime_added'].strftime(config.TIME_FORMAT)
self.write(song_data)
def test_get_playlist_length(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
songs_to_add = 5
for ii in range(songs_to_add):
assert ii == playlist_manager.get_playlist_length()
playlist_manager.add_song_by_id(ii)
assert songs_to_add == playlist_manager.get_playlist_length()
def add_song_with_user_request_to_playlist(self, song_id, user_requested=False):
with db_operations.session_scope() as session:
playlist_maanger = stream_playlist.PlaylistManager(session)
playlist_maanger.add_song_by_id(song_id, user_requested)
if user_requested:
self._song_cache.set_song_request_block_with_ttl(
song_id, config.stream_options['song_request_cooldown']
)
def get(self):
song_id = self.request.arguments['song-id'][0]
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
song_data = song_manager.get_song_by_id(song_id)
song_data['datetime_added'] = \
song_data['datetime_added'].strftime(config.TIME_FORMAT)
self.write(song_data)
def setup_method(self, method):
testing_utils.connect_to_temporary_test_db()
with db_operations.session_scope() as session:
self.user_manager = user.UserManager(session)
self.session = session
test_user = user.User('test_username', 'test_password',
'*****@*****.**')
session.add(test_user)
session.commit()
def setup_method(self, method):
testing_utils.connect_to_temporary_test_db()
with db_operations.session_scope() as session:
self.user_manager = user.UserManager(session)
self.session = session
test_user = user.User('test_username', 'test_password',
'*****@*****.**')
session.add(test_user)
session.commit()
def add_song_with_user_request_to_playlist(self,
song_id,
user_requested=False):
with db_operations.session_scope() as session:
playlist_maanger = stream_playlist.PlaylistManager(session)
playlist_maanger.add_song_by_id(song_id, user_requested)
if user_requested:
self._song_cache.set_song_request_block_with_ttl(
song_id, config.stream_options['song_request_cooldown'])
def test_transition_to_next_song(self, mock_add, mock_crop):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
prev_playlist = playlist_manager.get_ordered_playlist()
self._stream_controller.transition_to_next_song()
after_playlist = playlist_manager.get_ordered_playlist()
assert prev_playlist != after_playlist
self._stream_controller.transition_to_next_song()
assert True == mock_add.called
assert True == mock_crop.called
def test_find_artist_by_name(self):
artist_name = 'test_artist'
url = '/api/artist/find?name={0}'.format(artist_name)
response = self._fetch_response_data_from_url(url)
assert response.code == 200
json_data = json.loads(response.body)
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
expected_data = song_manager.get_artist_by_name(artist_name)
assert expected_data == json_data
def test_get_random_song(self):
test_song_paths = [
self.test_song_1_path, self.test_song_2_path, self.test_song_3_path
]
with mock.patch.object(config, 'paths', testing_utils.MOCK_CONFIG_PATHS):
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
for test_song_path in test_song_paths:
song_manager.add_song_from_path(test_song_path)
song_access_count = {1: 0, 2: 0, 3: 0}
total_random_queries = 50
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
for random_query in range(total_random_queries):
random_song = song_manager.get_random_song()
song_access_count[random_song.id] += 1
query_count_threshold = total_random_queries//len(song_access_count)//1.4
for song_id, access_count in song_access_count.iteritems():
assert access_count >= query_count_threshold
def test_transition_to_next_song(self, mock_add, mock_crop):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
prev_playlist = playlist_manager.get_ordered_playlist()
self._stream_controller.transition_to_next_song()
after_playlist = playlist_manager.get_ordered_playlist()
assert prev_playlist != after_playlist
self._stream_controller.transition_to_next_song()
assert True == mock_add.called
assert True == mock_crop.called
def test_find_artist_by_name(self):
artist_name = 'test_artist'
url = '/api/artist/find?name={0}'.format(artist_name)
response = self._fetch_response_data_from_url(url)
assert response.code == 200
json_data = json.loads(response.body)
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
expected_data = song_manager.get_artist_by_name(artist_name)
assert expected_data == json_data
def test_find_song_by_id(self):
song_id = 1
url = '/api/song/find?song-id={0}'.format(song_id)
response = self._fetch_response_data_from_url(url)
assert response.code == 200
json_data = json.loads(response.body)
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
expected_data = song_manager.get_song_by_id(song_id)
expected_data['datetime_added'] = \
expected_data['datetime_added'].strftime(config.TIME_FORMAT)
assert expected_data == json_data
def test_get_random_song(self):
test_song_paths = [
self.test_song_1_path, self.test_song_2_path, self.test_song_3_path
]
with mock.patch.object(config, 'paths',
testing_utils.MOCK_CONFIG_PATHS):
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
for test_song_path in test_song_paths:
song_manager.add_song_from_path(test_song_path)
song_access_count = {1: 0, 2: 0, 3: 0}
total_random_queries = 50
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
for random_query in range(total_random_queries):
random_song = song_manager.get_random_song()
song_access_count[random_song.id] += 1
query_count_threshold = total_random_queries // len(
song_access_count) // 1.4
for song_id, access_count in song_access_count.iteritems():
assert access_count >= query_count_threshold
def get(self):
if song_cache.get_playlist():
current_playlist = json.loads(song_cache.get_playlist())
else:
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
current_playlist = playlist_manager.get_ordered_playlist()
song_manager = song.SongManager(session)
for playlist_order, playlist_data in current_playlist.iteritems():
self._add_song_data_to_playlist_data(playlist_data, song_manager)
song_cache.set_playlist(json.dumps(current_playlist))
self.write(current_playlist)
def test_find_song_by_id(self):
song_id = 1
url = '/api/song/find?song-id={0}'.format(song_id)
response = self._fetch_response_data_from_url(url)
assert response.code == 200
json_data = json.loads(response.body)
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
expected_data = song_manager.get_song_by_id(song_id)
expected_data['datetime_added'] = \
expected_data['datetime_added'].strftime(config.TIME_FORMAT)
assert expected_data == json_data
def transition_to_next_song(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
song_manager = song.SongManager(session)
playlist_manager.pop_first_song()
playlist_manager.set_first_song_as_currently_playing()
ordered_playlist = playlist_manager.get_ordered_playlist(as_list=True)
next_two_songs = ordered_playlist[1:3]
self._stream_player.crop()
for coming_song in next_two_songs:
song_data = song_manager.get_song_by_id(coming_song['song_id'])
self._stream_player.add(song_data['file_path'])
self.add_random_songs_to_playlist_until_max_length()
def transition_to_next_song(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
song_manager = song.SongManager(session)
playlist_manager.pop_first_song()
playlist_manager.set_first_song_as_currently_playing()
ordered_playlist = playlist_manager.get_ordered_playlist(
as_list=True)
next_two_songs = ordered_playlist[1:3]
self._stream_player.crop()
for coming_song in next_two_songs:
song_data = song_manager.get_song_by_id(coming_song['song_id'])
self._stream_player.add(song_data['file_path'])
self.add_random_songs_to_playlist_until_max_length()
def test_add_song_by_id(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
playlist_manager.add_song_by_id(1)
playlist_manager.add_song_by_id(2, True)
expected_row_1 = {
'id': 1,
'song_id': 1,
'user_requested': False,
'currently_playing': False
}
expected_row_2 = {
'id': 2,
'song_id': 2,
'user_requested': True,
'currently_playing': False
}
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
playlist_song_1 = session.query(
stream_playlist.Playlist).filter_by(id=1).first()
playlist_song_2 = session.query(
stream_playlist.Playlist).filter_by(id=2).first()
playlist_song_1_contents = \
playlist_manager.format_query_rows_to_dict(playlist_song_1)
playlist_song_2_contents = \
playlist_manager.format_query_rows_to_dict(playlist_song_2)
playlist_song_1_time = playlist_song_1_contents.pop(
'datetime_added')
playlist_song_2_time = playlist_song_2_contents.pop(
'datetime_added')
assert expected_row_1 == playlist_song_1_contents
assert type(datetime.datetime.now()) == type(playlist_song_1_time)
assert expected_row_2 == playlist_song_2_contents
assert type(datetime.datetime.now()) == type(playlist_song_2_time)
def test_add_song_with_user_request_to_playlist(self):
with db_operations.session_scope() as session:
test_songs = session.query(song.Song).all()
self._stream_controller.add_song_with_user_request_to_playlist(
test_songs[0].id, user_requested=False)
assert 1 == session.query(stream_playlist.Playlist.id).count()
self._stream_controller.add_song_with_user_request_to_playlist(
test_songs[1].id, user_requested=True)
assert 2 == session.query(stream_playlist.Playlist.id).count()
first_song = session.query(
stream_playlist.Playlist).filter_by(id=1).one()
assert False == first_song.user_requested
second_song = session.query(
stream_playlist.Playlist).filter_by(id=2).one()
assert True == second_song.user_requested
def test_add_song_with_user_request_to_playlist(self):
with db_operations.session_scope() as session:
test_songs = session.query(song.Song).all()
self._stream_controller.add_song_with_user_request_to_playlist(
test_songs[0].id, user_requested=False
)
assert 1 == session.query(stream_playlist.Playlist.id).count()
self._stream_controller.add_song_with_user_request_to_playlist(
test_songs[1].id, user_requested=True
)
assert 2 == session.query(stream_playlist.Playlist.id).count()
first_song = session.query(stream_playlist.Playlist).filter_by(id=1).one()
assert False == first_song.user_requested
second_song = session.query(stream_playlist.Playlist).filter_by(id=2).one()
assert True == second_song.user_requested
def test_get_artist_by_name(self):
with mock.patch.object(config, 'paths', testing_utils.MOCK_CONFIG_PATHS):
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
song_manager.add_song_from_path(self.test_song_1_path)
artist_name = 'test_artist'
artist_data = song_manager.get_artist_by_name(artist_name)
expected_artist_data = {
u'0': {
'title': u'test_title',
'id': 1,
'trackno': u'1',
'date': u'2014',
'album': u'test_album',
'fave_count': 0,
'play_count': 0
}
}
assert expected_artist_data == artist_data
def test_get_artist_by_name(self):
with mock.patch.object(config, 'paths',
testing_utils.MOCK_CONFIG_PATHS):
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
song_manager.add_song_from_path(self.test_song_1_path)
artist_name = 'test_artist'
artist_data = song_manager.get_artist_by_name(artist_name)
expected_artist_data = {
u'0': {
'title': u'test_title',
'id': 1,
'trackno': u'1',
'date': u'2014',
'album': u'test_album',
'fave_count': 0,
'play_count': 0
}
}
assert expected_artist_data == artist_data
def test_update_song_db(self):
with mock.patch.object(config, 'paths', testing_utils.MOCK_CONFIG_PATHS):
self._database_controller.update_song_db()
with db_operations.session_scope() as session:
all_songs = session.query(song.Song).all()
assert 3 == len(all_songs)
def test_add_random_song_with_user_request_to_playlist(self):
self._stream_controller.add_random_song_with_user_request_to_playlist()
with db_operations.session_scope() as session:
assert 1 == session.query(stream_playlist.Playlist).count()
def add_random_songs_to_playlist_until_max_length(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
max_playlist_size = config.stream_options['playlist_size']
while playlist_manager.get_playlist_length() < max_playlist_size:
self.add_random_song_with_user_request_to_playlist()
def add_random_songs_to_playlist_until_max_length(self):
with db_operations.session_scope() as session:
playlist_manager = stream_playlist.PlaylistManager(session)
max_playlist_size = config.stream_options['playlist_size']
while playlist_manager.get_playlist_length() < max_playlist_size:
self.add_random_song_with_user_request_to_playlist()
def test_add_random_song_with_user_request_to_playlist(self):
self._stream_controller.add_random_song_with_user_request_to_playlist()
with db_operations.session_scope() as session:
assert 1 == session.query(stream_playlist.Playlist).count()
def get(self):
artist_name = self.request.arguments['name'][0]
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
artist_name = song_manager.get_artist_by_name(artist_name)
self.write(artist_name)
def update_song_db(self):
song_directory = config.paths['song_directory']
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
self._traverse_and_add_all_songs_in_directory(song_manager, song_directory)
def get(self):
artist_name = self.request.arguments['name'][0]
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
artist_name = song_manager.get_artist_by_name(artist_name)
self.write(artist_name)
def update_song_db(self):
song_directory = config.paths['song_directory']
with db_operations.session_scope() as session:
song_manager = song.SongManager(session)
self._traverse_and_add_all_songs_in_directory(
song_manager, song_directory)
