def set_season_info(self):
"""Sets the info for the current season in the display window"""
series_id = dbTV.get_series_id(self.series_name)
season_list = dbTV.make_episodes_list(series_id, self.season_number)
model = SeasonListModel(season_list)
self.ui.listView_season_episode_full.setModel(model)
self.selected_season_poster = dbTV.get_selected_banner_url(\
series_id, 'season', self.season_number)
if not self.selected_season_poster == "":
filename = TVDB.retrieve_banner(self.selected_season_poster)
season_poster_pixmap = QtGui.QPixmap(filename).scaled(300, 450,\
QtCore.Qt.KeepAspectRatio)
self.ui.label_season_poster.setPixmap(season_poster_pixmap)
else:
self.ui.label_season_poster.clear()
self.ui.label_season_poster.setText("No season poster selected")
self.selected_season_banner_wide = dbTV.get_selected_banner_url(\
series_id, 'seasonwide', self.season_number)
if not self.selected_season_banner_wide == "":
filename = TVDB.retrieve_banner(self.selected_season_banner_wide)
season_banner_wide_pixmap = \
QtGui.QPixmap(filename).scaledToHeight(140)
self.ui.label_season_banner_wide.setPixmap(\
season_banner_wide_pixmap)
else:
self.ui.label_season_banner_wide.clear()
self.ui.label_season_banner_wide.setText(\
"No season wide banner selected")
def test_search_and_grab(self):
tv = TVDB(lang='en', wait=0.2, search_and_grab=True)
tv.search('x', onfinished=partial(process_series, tv))
tv.search('aria the animation', onfinished=partial(process_series, tv))
tv.search('nichijou', onfinished=partial(process_series, tv))
tv.search('legend of the galactic heroes',
onfinished=partial(process_series, tv))
def list_tvshow(force_rescan=False):
tvdb = TVDB("9ec9de2268745b801af7c5f21d2a16b8")
tvshow_model = TVShowsModel(DB_NAME)
tvshow_list = TVShowList(TVSHOW_PATH)
for tvshow_name in tvshow_list:
if tvshow_model.get_tvshow_by_name(
tvshow_name) and force_rescan is False:
continue
tvshow_name_decoded = unidecode.unidecode(tvshow_name)
print(tvshow_name_decoded)
yield tvshow_name, tvdb.search_tv_shows(tvshow_name_decoded)
def test_backend_search(self):
tv = TVDB(lang='en', backend='ddg', wait=0.1)
tv.search('x',
onfinished=partial(search_finished, 'x'),
backend='no',
episode_summary=True)
tv.search('aria the animation',
onfinished=search_finished,
backend='no',
episode_summary=True)
tv.search('nichijou', onfinished=search_finished)
tv.search('legend galactic heroes',
onfinished=search_finished,
backend='g')
def test_get_urlopen(self):
url = 'http://some.url.com'
ret_val = tvdb._get(url)
self.assertEqual(ret_val, self.returned_xml)
self.mock_urlopen.assert_called_once_with(url)
self.assertEqual(self.mock_urlopen_result.close.call_count, 1)
def update_series_from_tvdb(self):
series_id = dbTV.get_series_id(self.series_name)
series = TVDB.get_series_info(series_id)
dom = dom_from_series(series)
self.set_series_info_from_dom(dom, 0)
self.ui.pushButton_save_series_changes.setEnabled(1)
self.ui.pushButton_revert_series_changes.setEnabled(1)
def update_episode_from_tvdb(self):
episode_id = dbTV.get_episode_id(self.series_name, \
self.season_number, \
self.episode_number)
episode = TVDB.get_episode_info(episode_id)
dom = dom_from_episode(episode)
self.set_episode_info_from_dom(dom)
self.ui.pushButton_save_episode_changes.setEnabled(1)
self.ui.pushButton_revert_episode_changes.setEnabled(1)
def test_get_urlopen_with_httperror(self, mock_urlopen):
mock_urlopen.side_effect = urllib2.HTTPError(
'http://url.com',
code=404,
msg="Not Found",
hdrs='',
fp=None,
)
ret_val = tvdb._get('http://url.com')
self.assertEqual(ret_val, '')
def __init__(self, path):
self.logger = logging.getLogger('pymetadatamanager.scanner')
self.config = Config()
self.dbTV = TVShowDB(self.config.tvshowdb)
self.dbTV.init_db()
self.TVDB = TVDB()
self.FP = FileParser()
self.nfo_reader = NfoReader()
self.new_time = self.TVDB.get_server_time()
self.dbTV.clean_db_files()
self.series_list = []
self.set_file_list(path)
def set_season_banners_wide(self):
"""Downloads the wide banners for a season and displays them"""
#Season Wide Banners Tab
season_banners_wide = []
self.progress.setLabelText("Downloading Season Wide Banners...")
self.progress.setMaximum(len(self.season_banners_wide_url))
for banner_url in self.season_banners_wide_url:
self.progress.setValue( \
self.season_banners_wide_url.index(banner_url))
filename = TVDB.retrieve_banner(str(banner_url))
banner_pixmap = QtGui.QPixmap(filename).scaledToHeight(140)
season_banners_wide.append((banner_pixmap, banner_url))
banner_model_season_wide = BannerWideModel(season_banners_wide)
self.ui.tableView.setModel(banner_model_season_wide)
self.ui.tableView.resizeColumnsToContents()
self.ui.tableView.resizeRowsToContents()
self.ui.tableView.verticalHeader().hide()
self.ui.tableView.horizontalHeader().hide()
self.progress.setValue(len(self.season_banners_wide_url))
def set_season_banners(self):
"""Downloads the posters for a season and displays them"""
#Season Posters Tab
season_banners = []
self.progress.setLabelText("Downloading Season Posters...")
self.progress.setMaximum(len(self.season_banners_url))
for banner_url in self.season_banners_url:
self.progress.setValue(self.season_banners_url.index(banner_url))
filename = TVDB.retrieve_banner(str(banner_url).replace( \
'banners/', 'banners/_cache/'))
banner_pixmap = QtGui.QPixmap(filename).scaledToHeight(450)
season_banners.append((banner_pixmap, banner_url))
banner_model_season = BannerModel(season_banners)
self.ui.tableView.setModel(banner_model_season)
self.ui.tableView.resizeColumnsToContents()
self.ui.tableView.resizeRowsToContents()
self.ui.tableView.verticalHeader().hide()
self.ui.tableView.horizontalHeader().hide()
self.progress.setValue(len(self.season_banners_url))
def set_series_fanart(self):
"""Downloads the series fanart and displays it"""
#Fanart
series_fanart_banners = []
self.progress.setLabelText("Downloading Series Fanart...")
self.progress.setMaximum(len(self.series_fanart_banners_url))
for banner_url in self.series_fanart_banners_url:
self.progress.setValue( \
self.series_fanart_banners_url.index(banner_url))
filename = TVDB.retrieve_banner(str(banner_url))
banner_pixmap = QtGui.QPixmap(filename)
series_fanart_banners.append((banner_pixmap, banner_url))
banner_model_series_fanart = BannerModel(series_fanart_banners)
self.ui.tableView.setModel(banner_model_series_fanart)
self.ui.tableView.resizeColumnsToContents()
self.ui.tableView.resizeRowsToContents()
self.ui.tableView.verticalHeader().hide()
self.ui.tableView.horizontalHeader().hide()
self.progress.setValue(len(self.series_fanart_banners_url))
def list_movie():
tvdb = TVDB("9ec9de2268745b801af7c5f21d2a16b8")
for movie_name, movie_filename, extension, duration in MovieList(
MOVIE_PATH):
movie_propositions = tvdb.search_movies(movie_name)
for movie_proposition in movie_propositions:
movie_proposition.directors = tvdb.get_movie_directors_by_movie_id(
movie_proposition.id)
movie_proposition.cast = tvdb.get_movie_cast_by_movie_id(
movie_proposition.id)
movie_proposition.runtime = tvdb.get_movie_runtime_by_id(
movie_proposition.id)
yield movie_name, movie_filename, movie_propositions, extension, duration
def get_tvshow_episode_details(tvshow_id, episode_path):
season, ep_number = None, None
try:
season, ep_number = re.search("S([0-9]{1,2})E([0-9]{1,2})",
episode_path.name).groups()
except AttributeError:
pass
try:
season, ep_number = re.search("s([0-9]{1,2})e([0-9]{1,2})",
episode_path.name).groups()
except AttributeError:
pass
try:
season, ep_number = re.search("([0-9]{1,2})x([0-9]{1,2})",
episode_path.name).groups()
except AttributeError:
pass
if not season and not ep_number:
return {}
return TVDB("9ec9de2268745b801af7c5f21d2a16b8", "en")\
.get_tvshow_episode_detail_by_id_and_episode_number(str(tvshow_id), season, ep_number)
def test_get_urlopen_with_urlerror(self, mock_urlopen):
mock_urlopen.side_effect = urllib2.URLError('Error Reason')
ret_val = tvdb._get('http://url.com')
self.assertEqual(ret_val, '')
def set_episode_info_from_dom(self, dom):
"""Sets the info for the show in the display window"""
episode_root = dom.firstChildElement('episodedetails')
#Extract the details and fill in the display
elem_episode_title = episode_root.firstChildElement('title')
episode_title = elem_episode_title.text()
self.ui.line_episode_name.setText(episode_title)
elem_episode_plot = episode_root.firstChildElement('plot')
episode_plot = QtCore.QString(elem_episode_plot.text())
self.ui.text_episode_plot.setPlainText(episode_plot)
elem_episode_thumb = episode_root.firstChildElement('thumb')
if not elem_episode_thumb.isNull():
episode_thumb = elem_episode_thumb.text()
else:
episode_thumb = "none"
#Set the preview image
image_file = TVDB.retrieve_banner(str(episode_thumb))
if image_file is not None:
image = QtGui.QPixmap(image_file)
self.ui.label_episode_thumb.setPixmap(image)
elem_episode_airdate = episode_root.firstChildElement('aired')
episode_airdate = elem_episode_airdate.text()
self.ui.line_airdate.setText(episode_airdate)
elem_episode_id = episode_root.firstChildElement('id')
episode_id = elem_episode_id.text()
self.ui.line_tvdb_id.setText(episode_id)
elem_episode_rating = episode_root.firstChildElement('rating')
episode_rating = elem_episode_rating.text()
self.ui.line_tvdb_rating.setText(episode_rating)
elem_episode_directors = episode_root.firstChildElement('director')
episode_directors = unicode(elem_episode_directors.text(), \
"latin-1").split('|')
self.ui.combo_directors.clear()
for director in episode_directors:
self.ui.combo_directors.addItem(director)
elem_episode_writers = episode_root.firstChildElement('credits')
episode_writers = unicode(elem_episode_writers.text(), \
"latin-1").split('|')
self.ui.combo_writers.clear()
for writer in episode_writers:
self.ui.combo_writers.addItem(writer)
episode_actors = []
elem_episode_actor = episode_root.firstChildElement('actor')
self.ui.combo_guests.clear()
while not elem_episode_actor.isNull():
elem_episode_actor_name = \
elem_episode_actor.firstChildElement('name')
episode_actor_name = elem_episode_actor_name.text()
episode_actors.append(episode_actor_name)
elem_episode_actor = elem_episode_actor.nextSiblingElement('actor')
episode_actors = set(episode_actors)
for episode_actor in episode_actors:
if self.ui.combo_actors.findText(episode_actor) < 0:
self.ui.combo_guests.addItem(episode_actor)
self.ui.tabWidget_tv_info.setCurrentIndex(3)
def set_series_info_from_dom(self, series_doc, tab_index):
"""Sets the info for the current series in the display window"""
series_root = series_doc.firstChildElement('tvshow')
#Extract the details and fill in the display
elem_series_name = series_root.firstChildElement('title')
series_name = elem_series_name.text()
self.ui.lineEdit_series_name.setText(series_name)
elem_series_plot = series_root.firstChildElement('plot')
series_plot = QtCore.QString(elem_series_plot.text())
self.ui.plainTextEdit_overview.setPlainText(series_plot)
series_actors = []
self.ui.combo_actors.clear()
elem_series_actor = series_root.firstChildElement('actor')
while not elem_series_actor.isNull():
elem_series_actor_name = \
elem_series_actor.firstChildElement('name')
series_actor_name = elem_series_actor_name.text()
if not series_actor_name in series_actors:
series_actors.append(series_actor_name)
elem_series_actor = elem_series_actor.nextSiblingElement('actor')
series_actors.sort()
for series_actor in series_actors:
self.ui.combo_actors.addItem(series_actor)
elem_series_network = series_root.firstChildElement('network')
series_network = elem_series_network.text()
self.ui.lineEdit_network.setText(series_network)
elem_series_airs_day = series_root.firstChildElement('airsday')
series_airs_day = elem_series_airs_day.text()
elem_series_airs_time = series_root.firstChildElement('airstime')
series_airs_time = elem_series_airs_time.text()
if not series_airs_day == '':
series_airtime = series_airs_day + " at " + series_airs_time
else:
series_airtime = ''
self.ui.lineEdit_airtime.setText(series_airtime)
elem_series_runtime = series_root.firstChildElement('runtime')
series_runtime = elem_series_runtime.text()
self.ui.lineEdit_runtime.setText(series_runtime)
elem_series_status = series_root.firstChildElement('status')
series_status = elem_series_status.text()
self.ui.lineEdit_status.setText(series_status)
series_id = dbTV.get_series_id(self.series_name)
self.ui.lineEdit_tvdb_series_id.setText(str(series_id))
self.selected_series_poster = \
dbTV.get_selected_banner_url(series_id, 'poster', '')
if not self.selected_series_poster == "":
filename = TVDB.retrieve_banner(self.selected_series_poster)
series_poster_pixmap = QtGui.QPixmap(filename).scaledToHeight(450)
self.ui.label_series_banner.setPixmap(series_poster_pixmap)
else:
self.ui.label_series_banner.clear()
self.ui.label_series_banner.setText("No series poster selected")
self.selected_series_wide_banner = \
dbTV.get_selected_banner_url(series_id, 'series', '')
if not self.selected_series_wide_banner == "":
filename = TVDB.retrieve_banner(self.selected_series_wide_banner)
series_wide_pixmap = QtGui.QPixmap(filename).scaledToHeight(140)
self.ui.label_banner_wide.setPixmap(series_wide_pixmap)
else:
self.ui.label_banner_wide.clear()
self.ui.label_banner_wide.setText("No series wide banner selected")
self.selected_series_fanart = \
dbTV.get_selected_banner_url(series_id, 'fanart', '')
if not self.selected_series_fanart == "":
filename = TVDB.retrieve_banner(self.selected_series_fanart)
series_fanart_pixmap = QtGui.QPixmap(filename).scaledToHeight(480)
self.ui.label_series_fanart.setPixmap(series_fanart_pixmap)
else:
self.ui.label_series_fanart.clear()
self.ui.label_series_fanart.setText("No fanart selected")
self.ui.tabWidget_tv_info.setCurrentIndex(tab_index)
def test_search(self):
tvdb.search('The Simpsons')
self.mock_et.fromstring.assert_called_once_with(self.returned_xml)
self.mock_search_result.assert_called_once_with(
tvdb, 'The%20Simpsons', self.mock_et.fromstring.return_value)
def test_series(self):
tvdb.series('71663')
self.mock_et.fromstring.assert_called_once_with(self.returned_xml)
self.mock_series.assert_called_once_with(
self.mock_et.fromstring.return_value)
class Scanner(object):
"""
Methods for scanning files into the database.
"""
def __init__(self, path):
self.logger = logging.getLogger('pymetadatamanager.scanner')
self.config = Config()
self.dbTV = TVShowDB(self.config.tvshowdb)
self.dbTV.init_db()
self.TVDB = TVDB()
self.FP = FileParser()
self.nfo_reader = NfoReader()
self.new_time = self.TVDB.get_server_time()
self.dbTV.clean_db_files()
self.series_list = []
self.set_file_list(path)
def __del__(self):
try:
self.dbTV.set_update_time(self.new_time)
except AttributeError:
self.logger.error("Error setting update time.")
def set_file_list(self, path):
self.file_list = self.FP.parse_files_by_path(path)
def set_series_list(self):
for file in self.file_list:
dir = file[0]
filename = file[1]
series_name = file[2]
if not series_name in self.series_list:
self.series_list.append(series_name)
def get_series_id_list(self, series_name):
series_id = self.dbTV.check_db_for_series(series_name)
if not series_id:
match_list = self.TVDB.find_series(series_name)
else:
match_list = [(series_id, match_list)]
return match_list
def add_series_to_db_by_id(self, series_id):
if not self.dbTV.check_db_for_series(series_id):
series = self.TVDB.get_all_series_info(series_id)
episodes = self.TVDB.get_series_episodes(series_id)
actors = self.TVDB.get_series_actors(series_id)
banners = self.TVDB.get_series_banners(series_id)
if series is not None:
self.dbTV.write_series_to_db(series)
series_name = self.dbTV.get_series_name(series_id)
self.logger.info("Adding series %s to DB" % (series_name,))
if episodes is not None:
self.dbTV.write_episodes_to_db(episodes, series_id)
if actors is not None:
self.dbTV.write_actors_to_db(actors)
if banners is not None:
self.dbTV.write_banners_to_db(banners)
def add_series_to_db_by_nfo(self, series_name):
episodes = []
episode_nfos = []
for file in self.file_list:
name = file[2]
if name == series_name:
episode_nfos.append(file[6])
series_nfo = file[5]
series = self.nfo_reader.get_series(series_nfo)
for episode_nfo in episode_nfos:
if not episode_nfo == '':
episodes.append(self.nfo_reader.get_episode(episode_nfo))
actors = self.nfo_reader.get_actors(series_nfo)
self.logger.debug(actors)
banners = self.nfo_reader.get_banners(series_nfo)
self.logger.info("Adding series %s to DB" % (series_name,))
if series is not None:
self.dbTV.write_series_to_db(series)
if episodes is not None:
series_id = self.dbTV.get_series_id(series_name)
self.dbTV.write_episodes_to_db(episodes, series_id)
if actors is not None:
self.dbTV.write_actors_to_db(actors)
if banners is not None:
self.dbTV.write_banners_to_db(banners)
def add_files_to_db(self, series_id, series_name):
#Create a list of files from this series
series_file_list = []
for file in self.file_list:
if file[2] == series_name:
if not self.dbTV.check_db_for_file(file[1], file[0]):
series_file_list.append(file)
#Add any new files to the DB
if len(series_file_list):
self.logger.info("Adding files from %s to DB" % (series_name,))
self.dbTV.write_files_to_db(series_file_list, series_id)
unlinked = self.dbTV.find_unlinked_files()
unlinked_list = []
for unlinked_file in unlinked:
for file in self.file_list:
file_path = file[0]
file_name = file[1]
if unlinked_file[1] == file_name \
and unlinked_file[2] == file_path:
unlinked_list.append(file)
if len(unlinked_list):
self.dbTV.write_files_to_db(series_file_list, series_id)
def test_only_search(self):
tv = TVDB(lang='en', wait=0.2, search_and_grab=False)
tv.search('x', onfinished=search_finished)
tv.search('aria the animation', onfinished=search_finished)
tv.search('nichijou', onfinished=search_finished)
tv.search('legend of the galactic heroes', onfinished=search_finished)
