def series_download_subtitles(no):
if get_general_settings()[24] is True:
monitored_only_query_string = ' AND monitored = "True"'
else:
monitored_only_query_string = ""
conn_db = sqlite3.connect(os.path.join(config_dir, 'db/bazarr.db'),
timeout=30)
c_db = conn_db.cursor()
episodes_details = c_db.execute(
'SELECT path, missing_subtitles, sonarrEpisodeId, scene_name FROM table_episodes WHERE sonarrSeriesId = ? AND missing_subtitles != "[]"'
+ monitored_only_query_string, (no, )).fetchall()
series_details = c_db.execute(
"SELECT hearing_impaired FROM table_shows WHERE sonarrSeriesId = ?",
(no, )).fetchone()
c_db.close()
providers_list = get_providers()
providers_auth = get_providers_auth()
for episode in episodes_details:
for language in ast.literal_eval(episode[1]):
if language is not None:
message = download_subtitle(path_replace(episode[0]),
str(alpha3_from_alpha2(language)),
series_details[0],
providers_list, providers_auth,
str(episode[3]), 'series')
if message is not None:
store_subtitles(path_replace(episode[0]))
history_log(1, no, episode[2], message)
send_notifications(no, episode[2], message)
list_missing_subtitles(no)
def series_download_subtitles(no):
if settings.sonarr.getboolean('only_monitored'):
monitored_only_query_string = ' AND monitored = "True"'
else:
monitored_only_query_string = ""
conn_db = sqlite3.connect(os.path.join(args.config_dir, 'db', 'bazarr.db'),
timeout=30)
c_db = conn_db.cursor()
episodes_details = c_db.execute(
'SELECT path, missing_subtitles, sonarrEpisodeId, scene_name FROM table_episodes WHERE sonarrSeriesId = ? AND missing_subtitles != "[]"'
+ monitored_only_query_string, (no, )).fetchall()
series_details = c_db.execute(
"SELECT hearing_impaired, title FROM table_shows WHERE sonarrSeriesId = ?",
(no, )).fetchone()
c_db.close()
providers_list = get_providers()
providers_auth = get_providers_auth()
count_episodes_details = len(episodes_details)
for i, episode in enumerate(episodes_details, 1):
for language in ast.literal_eval(episode[1]):
if language is not None:
notifications.write(msg='Searching for series subtitles...',
queue='get_subtitle',
item=i,
length=count_episodes_details)
result = download_subtitle(path_replace(episode[0]),
str(alpha3_from_alpha2(language)),
series_details[0],
providers_list, providers_auth,
str(episode[3]), series_details[1],
'series')
if result is not None:
message = result[0]
path = result[1]
language_code = result[2]
provider = result[3]
score = result[4]
store_subtitles(path_replace(episode[0]))
history_log(1, no, episode[2], message, path,
language_code, provider, score)
send_notifications(no, episode[2], message)
list_missing_subtitles(no)
if count_episodes_details:
notifications.write(msg='Searching completed. Please reload the page.',
type='success',
duration='permanent',
button='refresh',
queue='get_subtitle')
def wanted_download_subtitles(path):
conn_db = sqlite3.connect(os.path.join(config_dir, 'db/bazarr.db'),
timeout=30)
c_db = conn_db.cursor()
episodes_details = c_db.execute(
"SELECT table_episodes.path, table_episodes.missing_subtitles, table_episodes.sonarrEpisodeId, table_episodes.sonarrSeriesId, table_shows.hearing_impaired, table_episodes.scene_name, table_episodes.failedAttempts FROM table_episodes INNER JOIN table_shows on table_shows.sonarrSeriesId = table_episodes.sonarrSeriesId WHERE table_episodes.path = ? AND missing_subtitles != '[]'",
(path_replace_reverse(path), )).fetchall()
c_db.close()
providers_list = get_providers()
providers_auth = get_providers_auth()
for episode in episodes_details:
attempt = episode[6]
if type(attempt) == unicode:
attempt = ast.literal_eval(attempt)
for language in ast.literal_eval(episode[1]):
if attempt is None:
attempt = []
attempt.append([language, time.time()])
else:
att = zip(*attempt)[0]
if language not in att:
attempt.append([language, time.time()])
conn_db = sqlite3.connect(os.path.join(config_dir, 'db/bazarr.db'),
timeout=30)
c_db = conn_db.cursor()
c_db.execute(
'UPDATE table_episodes SET failedAttempts = ? WHERE sonarrEpisodeId = ?',
(unicode(attempt), episode[2]))
conn_db.commit()
c_db.close()
for i in range(len(attempt)):
if attempt[i][0] == language:
if search_active(attempt[i][1]) is True:
message = download_subtitle(
path_replace(episode[0]),
str(alpha3_from_alpha2(language)),
episode[4], providers_list, providers_auth,
str(episode[5]), 'series')
if message is not None:
store_subtitles(path_replace(episode[0]))
list_missing_subtitles(episode[3])
history_log(1, episode[3], episode[2], message)
send_notifications(episode[3], episode[2], message)
else:
logging.debug(
'BAZARR Search is not active for episode ' +
episode[0] + ' Language: ' + attempt[i][0])
def clean_desired_languages():
from list_subtitles import list_missing_subtitles, list_missing_subtitles_movies
enabled_languages = []
enabled_languages_temp = database.execute(
"SELECT code2 FROM table_settings_languages WHERE enabled=1")
for language in enabled_languages_temp:
enabled_languages.append(language['code2'])
series_languages = database.execute(
"SELECT sonarrSeriesId, languages FROM table_shows")
movies_languages = database.execute(
"SELECT radarrId, languages FROM table_movies")
for item in series_languages:
if item['languages'] != 'None':
try:
languages_list = ast.literal_eval(item['languages'])
except:
pass
else:
cleaned_languages_list = []
for language in languages_list:
if language in enabled_languages:
cleaned_languages_list.append(language)
if cleaned_languages_list != languages_list:
database.execute(
"UPDATE table_shows SET languages=? WHERE sonarrSeriesId=?",
(str(cleaned_languages_list), item['sonarrSeriesId']))
list_missing_subtitles(no=item['sonarrSeriesId'])
for item in movies_languages:
if item['languages'] != 'None':
try:
languages_list = ast.literal_eval(item['languages'])
except:
pass
else:
cleaned_languages_list = []
for language in languages_list:
if language in enabled_languages:
cleaned_languages_list.append(language)
if cleaned_languages_list != languages_list:
database.execute(
"UPDATE table_movies SET languages=? WHERE radarrId=?",
(str(cleaned_languages_list), item['radarrId']))
list_missing_subtitles_movies(no=item['radarrId'])
def episode_download_subtitles(no):
if settings.sonarr.getboolean('only_monitored'):
monitored_only_query_string = ' AND monitored = "True"'
else:
monitored_only_query_string = ""
conn_db = sqlite3.connect(os.path.join(args.config_dir, 'db', 'bazarr.db'),
timeout=30)
c_db = conn_db.cursor()
episodes_details = c_db.execute(
'SELECT table_episodes.path, table_episodes.missing_subtitles, table_episodes.sonarrEpisodeId, table_episodes.scene_name, table_shows.hearing_impaired, table_shows.title, table_shows.sonarrSeriesId FROM table_episodes INNER JOIN table_shows on table_shows.sonarrSeriesId = table_episodes.sonarrSeriesId WHERE table_episodes.sonarrEpisodeId = ?'
+ monitored_only_query_string, (no, )).fetchall()
c_db.close()
providers_list = get_providers()
providers_auth = get_providers_auth()
for episode in episodes_details:
for language in ast.literal_eval(episode[1]):
if language is not None:
notifications.write(msg='Searching for ' +
str(language_from_alpha2(language)) +
' subtitles for this episode: ' +
path_replace(episode[0]),
queue='get_subtitle')
result = download_subtitle(path_replace(episode[0]),
str(alpha3_from_alpha2(language)),
episode[4],
providers_list, providers_auth,
str(episode[3]), episode[5],
'series')
if result is not None:
message = result[0]
path = result[1]
language_code = result[2]
provider = result[3]
score = result[4]
store_subtitles(path_replace(episode[0]))
history_log(1, episode[6], episode[2], message, path,
language_code, provider, score)
send_notifications(episode[6], episode[2], message)
list_missing_subtitles(episode[6])
def post(self):
seriesIdList = request.form.getlist('seriesid')
profileIdList = request.form.getlist('profileid')
for idx in range(len(seriesIdList)):
seriesId = seriesIdList[idx]
profileId = profileIdList[idx]
if profileId in None_Keys:
profileId = None
else:
try:
profileId = int(profileId)
except Exception:
return '', 400
TableShows.update({
TableShows.profileId: profileId
}) \
.where(TableShows.sonarrSeriesId == seriesId) \
.execute()
list_missing_subtitles(no=seriesId, send_event=False)
event_stream(type='series', payload=seriesId)
episode_id_list = TableEpisodes \
.select(TableEpisodes.sonarrEpisodeId) \
.where(TableEpisodes.sonarrSeriesId == seriesId) \
.dicts()
for item in episode_id_list:
event_stream(type='episode-wanted', payload=item['sonarrEpisodeId'])
event_stream(type='badges')
return '', 204
def update_series():
apikey_sonarr = settings.sonarr.apikey
if apikey_sonarr is None:
return
sonarr_version = get_sonarr_version()
serie_default_enabled = settings.general.getboolean(
'serie_default_enabled')
if serie_default_enabled is True:
serie_default_profile = settings.general.serie_default_profile
if serie_default_profile == '':
serie_default_profile = None
else:
serie_default_profile = None
audio_profiles = get_profile_list()
tagsDict = get_tags()
# Get shows data from Sonarr
url_sonarr_api_series = url_sonarr(
) + "/api/series?apikey=" + apikey_sonarr
try:
r = requests.get(url_sonarr_api_series, timeout=60, verify=False)
r.raise_for_status()
except requests.exceptions.HTTPError:
logging.exception(
"BAZARR Error trying to get series from Sonarr. Http error.")
return
except requests.exceptions.ConnectionError:
logging.exception(
"BAZARR Error trying to get series from Sonarr. Connection Error.")
return
except requests.exceptions.Timeout:
logging.exception(
"BAZARR Error trying to get series from Sonarr. Timeout Error.")
return
except requests.exceptions.RequestException:
logging.exception("BAZARR Error trying to get series from Sonarr.")
return
# Get current shows in DB
current_shows_db = database.execute(
"SELECT sonarrSeriesId FROM table_shows")
current_shows_db_list = [x['sonarrSeriesId'] for x in current_shows_db]
current_shows_sonarr = []
series_to_update = []
series_to_add = []
series_list_length = len(r.json())
for i, show in enumerate(r.json(), 1):
overview = show['overview'] if 'overview' in show else ''
poster = ''
fanart = ''
for image in show['images']:
if image['coverType'] == 'poster':
poster_big = image['url'].split('?')[0]
poster = os.path.splitext(
poster_big)[0] + '-250' + os.path.splitext(poster_big)[1]
if image['coverType'] == 'fanart':
fanart = image['url'].split('?')[0]
alternate_titles = None
if show['alternateTitles'] is not None:
alternate_titles = str(
[item['title'] for item in show['alternateTitles']])
audio_language = []
if sonarr_version.startswith('2'):
audio_language = profile_id_to_language(show['qualityProfileId'],
audio_profiles)
else:
audio_language = profile_id_to_language(show['languageProfileId'],
audio_profiles)
tags = [d['label'] for d in tagsDict if d['id'] in show['tags']]
imdbId = show['imdbId'] if 'imdbId' in show else None
# Add shows in Sonarr to current shows list
current_shows_sonarr.append(show['id'])
if show['id'] in current_shows_db_list:
series_to_update.append({
'title': show["title"],
'path': show["path"],
'tvdbId': int(show["tvdbId"]),
'sonarrSeriesId': int(show["id"]),
'overview': overview,
'poster': poster,
'fanart': fanart,
'audio_language': str(audio_language),
'sortTitle': show['sortTitle'],
'year': str(show['year']),
'alternateTitles': alternate_titles,
'tags': str(tags),
'seriesType': show['seriesType'],
'imdbId': imdbId
})
else:
series_to_add.append({
'title': show["title"],
'path': show["path"],
'tvdbId': show["tvdbId"],
'sonarrSeriesId': show["id"],
'overview': overview,
'poster': poster,
'fanart': fanart,
'audio_language': str(audio_language),
'sortTitle': show['sortTitle'],
'year': str(show['year']),
'alternateTitles': alternate_titles,
'tags': str(tags),
'seriesType': show['seriesType'],
'imdbId': imdbId,
'profileId': serie_default_profile
})
# Remove old series from DB
removed_series = list(
set(current_shows_db_list) - set(current_shows_sonarr))
for series in removed_series:
database.execute("DELETE FROM table_shows WHERE sonarrSeriesId=?",
(series, ))
event_stream(type='series', action='delete', series=series)
# Update existing series in DB
series_in_db_list = []
series_in_db = database.execute(
"SELECT title, path, tvdbId, sonarrSeriesId, overview, poster, fanart, "
"audio_language, sortTitle, year, alternateTitles, tags, seriesType, imdbId FROM table_shows"
)
for item in series_in_db:
series_in_db_list.append(item)
series_to_update_list = [
i for i in series_to_update if i not in series_in_db_list
]
for updated_series in series_to_update_list:
query = dict_converter.convert(updated_series)
database.execute(
'''UPDATE table_shows SET ''' + query.keys_update +
''' WHERE sonarrSeriesId = ?''',
query.values + (updated_series['sonarrSeriesId'], ))
event_stream(type='series',
action='update',
series=updated_series['sonarrSeriesId'])
# Insert new series in DB
for added_series in series_to_add:
query = dict_converter.convert(added_series)
result = database.execute(
'''INSERT OR IGNORE INTO table_shows(''' + query.keys_insert +
''') VALUES(''' + query.question_marks + ''')''', query.values)
if result:
list_missing_subtitles(no=added_series['sonarrSeriesId'])
else:
logging.debug(
'BAZARR unable to insert this series into the database:',
path_mappings.path_replace(added_series['path']))
event_stream(type='series',
action='insert',
series=added_series['sonarrSeriesId'])
logging.debug(
'BAZARR All series synced from Sonarr into database.')
def update_series():
notifications.write(msg="Update series list from Sonarr is running...",
queue='get_series')
apikey_sonarr = settings.sonarr.apikey
serie_default_enabled = settings.general.getboolean(
'serie_default_enabled')
serie_default_language = settings.general.serie_default_language
serie_default_hi = settings.general.serie_default_hi
serie_default_forced = settings.general.serie_default_forced
if apikey_sonarr is None:
pass
else:
get_profile_list()
# Get shows data from Sonarr
url_sonarr_api_series = url_sonarr + "/api/series?apikey=" + apikey_sonarr
try:
r = requests.get(url_sonarr_api_series, timeout=60, verify=False)
r.raise_for_status()
except requests.exceptions.HTTPError as errh:
logging.exception(
"BAZARR Error trying to get series from Sonarr. Http error.")
except requests.exceptions.ConnectionError as errc:
logging.exception(
"BAZARR Error trying to get series from Sonarr. Connection Error."
)
except requests.exceptions.Timeout as errt:
logging.exception(
"BAZARR Error trying to get series from Sonarr. Timeout Error."
)
except requests.exceptions.RequestException as err:
logging.exception("BAZARR Error trying to get series from Sonarr.")
else:
# Open database connection
db = sqlite3.connect(os.path.join(args.config_dir, 'db',
'bazarr.db'),
timeout=30)
c = db.cursor()
# Get current shows in DB
current_shows_db = c.execute(
'SELECT tvdbId FROM table_shows').fetchall()
# Close database connection
db.close()
current_shows_db_list = [x[0] for x in current_shows_db]
current_shows_sonarr = []
series_to_update = []
series_to_add = []
seriesListLength = len(r.json())
for i, show in enumerate(r.json(), 1):
notifications.write(msg="Getting series data from Sonarr...",
queue='get_series',
item=i,
length=seriesListLength)
try:
overview = unicode(show['overview'])
except:
overview = ""
try:
poster_big = show['images'][2]['url'].split('?')[0]
poster = os.path.splitext(poster_big)[
0] + '-250' + os.path.splitext(poster_big)[1]
except:
poster = ""
try:
fanart = show['images'][0]['url'].split('?')[0]
except:
fanart = ""
if show['alternateTitles'] != None:
alternateTitles = str(
[item['title'] for item in show['alternateTitles']])
# Add shows in Sonarr to current shows list
current_shows_sonarr.append(show['tvdbId'])
if show['tvdbId'] in current_shows_db_list:
series_to_update.append(
(show["title"], show["path"], show["tvdbId"],
show["id"], overview, poster, fanart,
profile_id_to_language(
(show['qualityProfileId'] if sonarr_version == 2
else show['languageProfileId'])),
show['sortTitle'], show['year'], alternateTitles,
show["tvdbId"]))
else:
if serie_default_enabled is True:
series_to_add.append(
(show["title"], show["path"], show["tvdbId"],
serie_default_language, serie_default_hi,
show["id"], overview, poster, fanart,
profile_id_to_language(show['qualityProfileId']),
show['sortTitle'], show['year'], alternateTitles,
serie_default_forced))
else:
series_to_add.append(
(show["title"], show["path"], show["tvdbId"],
show["tvdbId"], show["tvdbId"], show["id"],
overview, poster, fanart,
profile_id_to_language(show['qualityProfileId']),
show['sortTitle'], show['year'], alternateTitles,
show["id"]))
# Update or insert series in DB
db = sqlite3.connect(os.path.join(args.config_dir, 'db',
'bazarr.db'),
timeout=30)
c = db.cursor()
updated_result = c.executemany(
'''UPDATE table_shows SET title = ?, path = ?, tvdbId = ?, sonarrSeriesId = ?, overview = ?, poster = ?, fanart = ?, `audio_language` = ? , sortTitle = ?, year = ?, alternateTitles = ? WHERE tvdbid = ?''',
series_to_update)
db.commit()
if serie_default_enabled is True:
added_result = c.executemany(
'''INSERT OR IGNORE INTO table_shows(title, path, tvdbId, languages,`hearing_impaired`, sonarrSeriesId, overview, poster, fanart, `audio_language`, sortTitle, year, alternateTitles, forced) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
series_to_add)
db.commit()
else:
added_result = c.executemany(
'''INSERT OR IGNORE INTO table_shows(title, path, tvdbId, languages,`hearing_impaired`, sonarrSeriesId, overview, poster, fanart, `audio_language`, sortTitle, year, alternateTitles, forced) VALUES (?,?,?,(SELECT languages FROM table_shows WHERE tvdbId = ?),(SELECT `hearing_impaired` FROM table_shows WHERE tvdbId = ?), ?, ?, ?, ?, ?, ?, ?, ?, (SELECT `forced` FROM table_shows WHERE tvdbId = ?))''',
series_to_add)
db.commit()
db.close()
for show in series_to_add:
list_missing_subtitles(show[5])
# Delete shows not in Sonarr anymore
deleted_items = []
for item in current_shows_db_list:
if item not in current_shows_sonarr:
deleted_items.append(tuple([item]))
db = sqlite3.connect(os.path.join(args.config_dir, 'db',
'bazarr.db'),
timeout=30)
c = db.cursor()
c.executemany('DELETE FROM table_shows WHERE tvdbId = ?',
deleted_items)
db.commit()
db.close()
def update_series(send_event=True):
check_sonarr_rootfolder()
apikey_sonarr = settings.sonarr.apikey
if apikey_sonarr is None:
return
serie_default_enabled = settings.general.getboolean('serie_default_enabled')
if serie_default_enabled is True:
serie_default_profile = settings.general.serie_default_profile
if serie_default_profile == '':
serie_default_profile = None
else:
serie_default_profile = None
audio_profiles = get_profile_list()
tagsDict = get_tags()
# Get shows data from Sonarr
series = get_series_from_sonarr_api(url=url_sonarr(), apikey_sonarr=apikey_sonarr)
if not series:
return
else:
# Get current shows in DB
current_shows_db = TableShows.select(TableShows.sonarrSeriesId).dicts()
current_shows_db_list = [x['sonarrSeriesId'] for x in current_shows_db]
current_shows_sonarr = []
series_to_update = []
series_to_add = []
series_count = len(series)
for i, show in enumerate(series):
if send_event:
show_progress(id='series_progress',
header='Syncing series...',
name=show['title'],
value=i,
count=series_count)
# Add shows in Sonarr to current shows list
current_shows_sonarr.append(show['id'])
if show['id'] in current_shows_db_list:
series_to_update.append(seriesParser(show, action='update', tags_dict=tagsDict,
serie_default_profile=serie_default_profile,
audio_profiles=audio_profiles))
else:
series_to_add.append(seriesParser(show, action='insert', tags_dict=tagsDict,
serie_default_profile=serie_default_profile,
audio_profiles=audio_profiles))
if send_event:
hide_progress(id='series_progress')
# Remove old series from DB
removed_series = list(set(current_shows_db_list) - set(current_shows_sonarr))
for series in removed_series:
try:
TableShows.delete().where(TableShows.sonarrSeriesId == series).execute()
except Exception as e:
logging.error(f"BAZARR cannot delete series with sonarrSeriesId {series} because of {e}")
continue
else:
if send_event:
event_stream(type='series', action='delete', payload=series)
# Update existing series in DB
series_in_db_list = []
series_in_db = TableShows.select(TableShows.title,
TableShows.path,
TableShows.tvdbId,
TableShows.sonarrSeriesId,
TableShows.overview,
TableShows.poster,
TableShows.fanart,
TableShows.audio_language,
TableShows.sortTitle,
TableShows.year,
TableShows.alternateTitles,
TableShows.tags,
TableShows.seriesType,
TableShows.imdbId).dicts()
for item in series_in_db:
series_in_db_list.append(item)
series_to_update_list = [i for i in series_to_update if i not in series_in_db_list]
for updated_series in series_to_update_list:
try:
TableShows.update(updated_series).where(TableShows.sonarrSeriesId ==
updated_series['sonarrSeriesId']).execute()
except IntegrityError as e:
logging.error(f"BAZARR cannot update series {updated_series['path']} because of {e}")
continue
else:
if send_event:
event_stream(type='series', payload=updated_series['sonarrSeriesId'])
# Insert new series in DB
for added_series in series_to_add:
try:
result = TableShows.insert(added_series).on_conflict(action='IGNORE').execute()
except IntegrityError as e:
logging.error(f"BAZARR cannot insert series {added_series['path']} because of {e}")
continue
else:
if result:
list_missing_subtitles(no=added_series['sonarrSeriesId'])
else:
logging.debug('BAZARR unable to insert this series into the database:',
path_mappings.path_replace(added_series['path']))
if send_event:
event_stream(type='series', action='update', payload=added_series['sonarrSeriesId'])
logging.debug('BAZARR All series synced from Sonarr into database.')
def update_series():
from get_settings import get_sonarr_settings
url_sonarr = get_sonarr_settings()[6]
apikey_sonarr = get_sonarr_settings()[4]
serie_default_enabled = get_general_settings()[15]
serie_default_language = get_general_settings()[16]
serie_default_hi = get_general_settings()[17]
if apikey_sonarr == None:
pass
else:
get_profile_list()
# Get shows data from Sonarr
url_sonarr_api_series = url_sonarr + "/api/series?apikey=" + apikey_sonarr
try:
r = requests.get(url_sonarr_api_series, timeout=15, verify=False)
r.raise_for_status()
except requests.exceptions.HTTPError as errh:
logging.exception(
"Error trying to get series from Sonarr. Http error.")
except requests.exceptions.ConnectionError as errc:
logging.exception(
"Error trying to get series from Sonarr. Connection Error.")
except requests.exceptions.Timeout as errt:
logging.exception(
"Error trying to get series from Sonarr. Timeout Error.")
except requests.exceptions.RequestException as err:
logging.exception("Error trying to get series from Sonarr.")
else:
# Open database connection
db = sqlite3.connect(os.path.join(config_dir, 'db/bazarr.db'),
timeout=30)
c = db.cursor()
# Get current shows in DB
current_shows_db = c.execute(
'SELECT tvdbId FROM table_shows').fetchall()
# Close database connection
db.close()
current_shows_db_list = [x[0] for x in current_shows_db]
current_shows_sonarr = []
series_to_update = []
series_to_add = []
for show in r.json():
try:
overview = unicode(show['overview'])
except:
overview = ""
try:
poster_big = show['images'][2]['url'].split('?')[0]
poster = os.path.splitext(poster_big)[
0] + '-250' + os.path.splitext(poster_big)[1]
except:
poster = ""
try:
fanart = show['images'][0]['url'].split('?')[0]
except:
fanart = ""
# Add shows in Sonarr to current shows list
current_shows_sonarr.append(show['tvdbId'])
if show['tvdbId'] in current_shows_db_list:
series_to_update.append(
(show["title"], show["path"], show["tvdbId"],
show["id"], overview, poster, fanart,
profile_id_to_language(
(show['qualityProfileId'] if sonarr_version == 2
else show['languageProfileId'])),
show['sortTitle'], show["tvdbId"]))
else:
if serie_default_enabled is True:
series_to_add.append(
(show["title"], show["path"], show["tvdbId"],
serie_default_language, serie_default_hi,
show["id"], overview, poster, fanart,
profile_id_to_language(show['qualityProfileId']),
show['sortTitle']))
else:
series_to_add.append(
(show["title"], show["path"], show["tvdbId"],
show["tvdbId"], show["tvdbId"], show["id"],
overview, poster, fanart,
profile_id_to_language(show['qualityProfileId']),
show['sortTitle']))
# Update or insert series in DB
db = sqlite3.connect(os.path.join(config_dir, 'db/bazarr.db'),
timeout=30)
c = db.cursor()
updated_result = c.executemany(
'''UPDATE table_shows SET title = ?, path = ?, tvdbId = ?, sonarrSeriesId = ?, overview = ?, poster = ?, fanart = ?, `audio_language` = ? , sortTitle = ? WHERE tvdbid = ?''',
series_to_update)
db.commit()
if serie_default_enabled is True:
added_result = c.executemany(
'''INSERT OR IGNORE INTO table_shows(title, path, tvdbId, languages,`hearing_impaired`, sonarrSeriesId, overview, poster, fanart, `audio_language`, sortTitle) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
series_to_add)
db.commit()
else:
added_result = c.executemany(
'''INSERT OR IGNORE INTO table_shows(title, path, tvdbId, languages,`hearing_impaired`, sonarrSeriesId, overview, poster, fanart, `audio_language`, sortTitle) VALUES (?,?,?,(SELECT languages FROM table_shows WHERE tvdbId = ?),(SELECT `hearing_impaired` FROM table_shows WHERE tvdbId = ?), ?, ?, ?, ?, ?, ?)''',
series_to_add)
db.commit()
db.close()
for show in series_to_add:
list_missing_subtitles(show[5])
# Delete shows not in Sonarr anymore
deleted_items = []
for item in current_shows_db_list:
if item not in current_shows_sonarr:
deleted_items.append(tuple([item]))
db = sqlite3.connect(os.path.join(config_dir, 'db/bazarr.db'),
timeout=30)
c = db.cursor()
c.executemany('DELETE FROM table_shows WHERE tvdbId = ?',
deleted_items)
db.commit()
db.close()
def update_all_episodes():
series_full_scan_subtitles()
logging.info('BAZARR All existing episode subtitles indexed from disk.')
list_missing_subtitles()
logging.info('BAZARR All missing episode subtitles updated in database.')
def update_series():
notifications.write(msg="Update series list from Sonarr is running...",
queue='get_series')
apikey_sonarr = settings.sonarr.apikey
sonarr_version = get_sonarr_version()
serie_default_enabled = settings.general.getboolean(
'serie_default_enabled')
serie_default_language = settings.general.serie_default_language
serie_default_hi = settings.general.serie_default_hi
serie_default_forced = settings.general.serie_default_forced
if apikey_sonarr is None:
pass
else:
audio_profiles = get_profile_list()
# Get shows data from Sonarr
url_sonarr_api_series = url_sonarr(
) + "/api/series?apikey=" + apikey_sonarr
try:
r = requests.get(url_sonarr_api_series, timeout=60, verify=False)
r.raise_for_status()
except requests.exceptions.HTTPError as errh:
logging.exception(
"BAZARR Error trying to get series from Sonarr. Http error.")
return
except requests.exceptions.ConnectionError as errc:
logging.exception(
"BAZARR Error trying to get series from Sonarr. Connection Error."
)
return
except requests.exceptions.Timeout as errt:
logging.exception(
"BAZARR Error trying to get series from Sonarr. Timeout Error."
)
return
except requests.exceptions.RequestException as err:
logging.exception("BAZARR Error trying to get series from Sonarr.")
return
else:
# Get current shows in DB
current_shows_db = database.execute(
"SELECT sonarrSeriesId FROM table_shows")
current_shows_db_list = [
x['sonarrSeriesId'] for x in current_shows_db
]
current_shows_sonarr = []
series_to_update = []
series_to_add = []
altered_series = []
seriesListLength = len(r.json())
for i, show in enumerate(r.json(), 1):
notifications.write(msg="Getting series data from Sonarr...",
queue='get_series',
item=i,
length=seriesListLength)
try:
overview = six.text_type(show['overview'])
except:
overview = ""
try:
poster_big = show['images'][2]['url'].split('?')[0]
poster = os.path.splitext(poster_big)[
0] + '-250' + os.path.splitext(poster_big)[1]
except:
poster = ""
try:
fanart = show['images'][0]['url'].split('?')[0]
except:
fanart = ""
if show['alternateTitles'] != None:
alternateTitles = str(
[item['title'] for item in show['alternateTitles']])
else:
alternateTitles = None
# Add shows in Sonarr to current shows list
current_shows_sonarr.append(show['id'])
if show['tvdbId'] in current_shows_db_list:
series_to_update.append({
'title':
six.text_type(show["title"]),
'path':
six.text_type(show["path"]),
'tvdbId':
int(show["tvdbId"]),
'sonarrSeriesId':
int(show["id"]),
'overview':
six.text_type(overview),
'poster':
six.text_type(poster),
'fanart':
six.text_type(fanart),
'audio_language':
six.text_type(
profile_id_to_language(
(show['qualityProfileId']
if get_sonarr_version().startswith('2') else
show['languageProfileId']), audio_profiles)),
'sortTitle':
six.text_type(show['sortTitle']),
'year':
six.text_type(show['year']),
'alternateTitles':
six.text_type(alternateTitles)
})
else:
if serie_default_enabled is True:
series_to_add.append({
'title':
show["title"],
'path':
show["path"],
'tvdbId':
show["tvdbId"],
'languages':
serie_default_language,
'hearing_impaired':
serie_default_hi,
'sonarrSeriesId':
show["id"],
'overview':
overview,
'poster':
poster,
'fanart':
fanart,
'audio_language':
profile_id_to_language(
(show['qualityProfileId']
if sonarr_version.startswith('2') else
show['languageProfileId']), audio_profiles),
'sortTitle':
show['sortTitle'],
'year':
show['year'],
'alternateTitles':
alternateTitles,
'forced':
serie_default_forced
})
else:
series_to_add.append({
'title':
show["title"],
'path':
show["path"],
'tvdbId':
show["tvdbId"],
'sonarrSeriesId':
show["id"],
'overview':
overview,
'poster':
poster,
'fanart':
fanart,
'audio_language':
profile_id_to_language(
(show['qualityProfileId']
if sonarr_version.startswith('2') else
show['languageProfileId']), audio_profiles),
'sortTitle':
show['sortTitle'],
'year':
show['year'],
'alternateTitles':
alternateTitles
})
# Remove old series from DB
removed_series = list(
set(current_shows_db_list) - set(current_shows_sonarr))
for series in removed_series:
database.execute(
"DELETE FROM table_shows WHERE sonarrSEriesId=?",
(series, ))
# Update existing series in DB
series_in_db_list = []
series_in_db = database.execute(
"SELECT title, path, tvdbId, sonarrSeriesId, overview, poster, fanart, "
"audio_language, sortTitle, year, alternateTitles FROM table_shows"
)
for item in series_in_db:
series_in_db_list.append(item)
series_to_update_list = [
i for i in series_to_update if i not in series_in_db_list
]
for updated_series in series_to_update_list:
query = dict_converter.convert(updated_series)
database.execute(
'''UPDATE table_shows SET ''' + query.keys_update +
''' WHERE sonarrSeriesId = ?''',
query.values + (updated_series['sonarrSeriesId'], ))
# Insert new series in DB
for added_series in series_to_add:
query = dict_converter.convert(added_series)
result = database.execute(
'''INSERT OR IGNORE INTO table_shows(''' +
query.keys_insert + ''') VALUES(''' +
query.question_marks + ''')''', query.values)
if result:
list_missing_subtitles(no=added_series['sonarrSeriesId'])
else:
logging.debug(
'BAZARR unable to insert this series into the database:',
path_replace(added_series['path']))
logging.debug(
'BAZARR All series synced from Sonarr into database.')
def sync_episodes():
notifications.write(msg='Episodes sync from Sonarr started...',
queue='get_episodes')
logging.debug('BAZARR Starting episodes sync from Sonarr.')
apikey_sonarr = settings.sonarr.apikey
# Get current episodes id in DB
current_episodes_db = TableEpisodes.select(TableEpisodes.sonarr_episode_id,
TableEpisodes.path,
TableEpisodes.sonarr_series_id)
current_episodes_db_list = [
x.sonarr_episode_id for x in current_episodes_db
]
current_episodes_sonarr = []
episodes_to_update = []
episodes_to_add = []
altered_episodes = []
# Get sonarrId for each series from database
seriesIdList = TableShows.select(TableShows.sonarr_series_id,
TableShows.title)
seriesIdListLength = seriesIdList.count()
for i, seriesId in enumerate(seriesIdList, 1):
notifications.write(msg='Getting episodes data from Sonarr...',
queue='get_episodes',
item=i,
length=seriesIdListLength)
# Get episodes data for a series from Sonarr
url_sonarr_api_episode = url_sonarr + "/api/episode?seriesId=" + str(
seriesId.sonarr_series_id) + "&apikey=" + apikey_sonarr
try:
r = requests.get(url_sonarr_api_episode, timeout=60, verify=False)
r.raise_for_status()
except requests.exceptions.HTTPError as errh:
logging.exception(
"BAZARR Error trying to get episodes from Sonarr. Http error.")
return
except requests.exceptions.ConnectionError as errc:
logging.exception(
"BAZARR Error trying to get episodes from Sonarr. Connection Error."
)
return
except requests.exceptions.Timeout as errt:
logging.exception(
"BAZARR Error trying to get episodes from Sonarr. Timeout Error."
)
return
except requests.exceptions.RequestException as err:
logging.exception(
"BAZARR Error trying to get episodes from Sonarr.")
return
else:
for episode in r.json():
if 'hasFile' in episode:
if episode['hasFile'] is True:
if 'episodeFile' in episode:
if episode['episodeFile']['size'] > 20480:
# Add shows in Sonarr to current shows list
if 'sceneName' in episode['episodeFile']:
sceneName = episode['episodeFile'][
'sceneName']
else:
sceneName = None
try:
format, resolution = episode[
'episodeFile']['quality']['quality'][
'name'].split('-')
except:
format = episode['episodeFile']['quality'][
'quality']['name']
try:
resolution = str(
episode['episodeFile']['quality']
['quality']['resolution']) + 'p'
except:
resolution = None
if 'mediaInfo' in episode['episodeFile']:
if 'videoCodec' in episode['episodeFile'][
'mediaInfo']:
videoCodec = episode['episodeFile'][
'mediaInfo']['videoCodec']
videoCodec = SonarrFormatVideoCodec(
videoCodec)
else:
videoCodec = None
if 'audioCodec' in episode['episodeFile'][
'mediaInfo']:
audioCodec = episode['episodeFile'][
'mediaInfo']['audioCodec']
audioCodec = SonarrFormatAudioCodec(
audioCodec)
else:
audioCodec = None
else:
videoCodec = None
audioCodec = None
# Add episodes in sonarr to current episode list
current_episodes_sonarr.append(episode['id'])
if episode['id'] in current_episodes_db_list:
episodes_to_update.append({
'sonarr_series_id':
episode['seriesId'],
'sonarr_episode_id':
episode['id'],
'title':
episode['title'],
'path':
episode['episodeFile']['path'],
'season':
episode['seasonNumber'],
'episode':
episode['episodeNumber'],
'scene_name':
sceneName,
'monitored':
str(bool(episode['monitored'])),
'format':
format,
'resolution':
resolution,
'video_codec':
videoCodec,
'audio_codec':
audioCodec,
'episode_file_id':
episode['episodeFile']['id']
})
else:
episodes_to_add.append({
'sonarr_series_id':
episode['seriesId'],
'sonarr_episode_id':
episode['id'],
'title':
episode['title'],
'path':
episode['episodeFile']['path'],
'season':
episode['seasonNumber'],
'episode':
episode['episodeNumber'],
'scene_name':
sceneName,
'monitored':
str(bool(episode['monitored'])),
'format':
format,
'resolution':
resolution,
'video_codec':
videoCodec,
'audio_codec':
audioCodec,
'episode_file_id':
episode['episodeFile']['id']
})
# Update existing episodes in DB
episode_in_db_list = []
episodes_in_db = TableEpisodes.select(
TableEpisodes.sonarr_series_id, TableEpisodes.sonarr_episode_id,
TableEpisodes.title, TableEpisodes.path, TableEpisodes.season,
TableEpisodes.episode, TableEpisodes.scene_name,
TableEpisodes.monitored, TableEpisodes.format,
TableEpisodes.resolution, TableEpisodes.video_codec,
TableEpisodes.audio_codec, TableEpisodes.episode_file_id).dicts()
for item in episodes_in_db:
episode_in_db_list.append(item)
episodes_to_update_list = [
i for i in episodes_to_update if i not in episode_in_db_list
]
for updated_episode in episodes_to_update_list:
TableEpisodes.update(updated_episode).where(
TableEpisodes.sonarr_episode_id ==
updated_episode['sonarr_episode_id']).execute()
altered_episodes.append([
updated_episode['sonarr_episode_id'], updated_episode['path'],
updated_episode['sonarr_series_id']
])
# Insert new episodes in DB
for added_episode in episodes_to_add:
TableEpisodes.insert(added_episode).on_conflict_ignore().execute()
altered_episodes.append([
added_episode['sonarr_episode_id'], added_episode['path'],
added_episode['sonarr_series_id']
])
# Remove old episodes from DB
removed_episodes = list(
set(current_episodes_db_list) - set(current_episodes_sonarr))
for removed_episode in removed_episodes:
TableEpisodes.delete().where(
TableEpisodes.sonarr_episode_id == removed_episode).execute()
# Store subtitles for added or modified episodes
for i, altered_episode in enumerate(altered_episodes, 1):
notifications.write(msg='Indexing episodes embedded subtitles...',
queue='get_episodes',
item=i,
length=len(altered_episodes))
store_subtitles(path_replace(altered_episode[1]))
list_missing_subtitles(altered_episode[2])
logging.debug('BAZARR All episodes synced from Sonarr into database.')
# Search for desired subtitles if no more than 5 episodes have been added.
if len(altered_episodes) <= 5:
logging.debug(
"BAZARR No more than 5 episodes were added during this sync then we'll search for subtitles."
)
for altered_episode in altered_episodes:
episode_download_subtitles(altered_episode[0])
else:
logging.debug(
"BAZARR More than 5 episodes were added during this sync then we wont search for subtitles right now."
)
def update_series():
notifications.write(msg="Update series list from Sonarr is running...", queue='get_series')
apikey_sonarr = settings.sonarr.apikey
sonarr_version = get_sonarr_version()
serie_default_enabled = settings.general.getboolean('serie_default_enabled')
serie_default_language = settings.general.serie_default_language
serie_default_hi = settings.general.serie_default_hi
serie_default_forced = settings.general.serie_default_forced
if apikey_sonarr is None:
pass
else:
audio_profiles = get_profile_list()
# Get shows data from Sonarr
url_sonarr_api_series = url_sonarr + "/api/series?apikey=" + apikey_sonarr
try:
r = requests.get(url_sonarr_api_series, timeout=60, verify=False)
r.raise_for_status()
except requests.exceptions.HTTPError as errh:
logging.exception("BAZARR Error trying to get series from Sonarr. Http error.")
return
except requests.exceptions.ConnectionError as errc:
logging.exception("BAZARR Error trying to get series from Sonarr. Connection Error.")
return
except requests.exceptions.Timeout as errt:
logging.exception("BAZARR Error trying to get series from Sonarr. Timeout Error.")
return
except requests.exceptions.RequestException as err:
logging.exception("BAZARR Error trying to get series from Sonarr.")
return
else:
# Get current shows in DB
current_shows_db = TableShows.select(
TableShows.tvdb_id
)
current_shows_db_list = [x.tvdb_id for x in current_shows_db]
current_shows_sonarr = []
series_to_update = []
series_to_add = []
altered_series = []
seriesListLength = len(r.json())
for i, show in enumerate(r.json(), 1):
notifications.write(msg="Getting series data from Sonarr...", queue='get_series', item=i, length=seriesListLength)
try:
overview = unicode(show['overview'])
except:
overview = ""
try:
poster_big = show['images'][2]['url'].split('?')[0]
poster = os.path.splitext(poster_big)[0] + '-250' + os.path.splitext(poster_big)[1]
except:
poster = ""
try:
fanart = show['images'][0]['url'].split('?')[0]
except:
fanart = ""
if show['alternateTitles'] != None:
alternateTitles = str([item['title'] for item in show['alternateTitles']])
else:
alternateTitles = None
# Add shows in Sonarr to current shows list
current_shows_sonarr.append(show['tvdbId'])
if show['tvdbId'] in current_shows_db_list:
series_to_update.append({'title': unicode(show["title"]),
'path': unicode(show["path"]),
'tvdb_id': int(show["tvdbId"]),
'sonarr_series_id': int(show["id"]),
'overview': unicode(overview),
'poster': unicode(poster),
'fanart': unicode(fanart),
'audio_language': unicode(profile_id_to_language((show['qualityProfileId'] if sonarr_version.startswith('2') else show['languageProfileId']), audio_profiles)),
'sort_title': unicode(show['sortTitle']),
'year': unicode(show['year']),
'alternate_titles': unicode(alternateTitles)})
else:
if serie_default_enabled is True:
series_to_add.append({'title': show["title"],
'path': show["path"],
'tvdb_id': show["tvdbId"],
'languages': serie_default_language,
'hearing_impaired': serie_default_hi,
'sonarr_series_id': show["id"],
'overview': overview,
'poster': poster,
'fanart': fanart,
'audio_language': profile_id_to_language((show['qualityProfileId'] if sonarr_version.startswith('2') else show['languageProfileId']), audio_profiles),
'sort_title': show['sortTitle'],
'year': show['year'],
'alternate_titles': alternateTitles,
'forced': serie_default_forced})
else:
series_to_add.append({'title': show["title"],
'path': show["path"],
'tvdb_id': show["tvdbId"],
'sonarr_series_id': show["id"],
'overview': overview,
'poster': poster,
'fanart': fanart,
'audio_language': profile_id_to_language((show['qualityProfileId'] if sonarr_version.startswith('2') else show['languageProfileId']), audio_profiles),
'sort_title': show['sortTitle'],
'year': show['year'],
'alternate_titles': alternateTitles})
# Update existing series in DB
series_in_db_list = []
series_in_db = TableShows.select(
TableShows.title,
TableShows.path,
TableShows.tvdb_id,
TableShows.sonarr_series_id,
TableShows.overview,
TableShows.poster,
TableShows.fanart,
TableShows.audio_language,
TableShows.sort_title,
TableShows.year,
TableShows.alternate_titles
).dicts()
for item in series_in_db:
series_in_db_list.append(item)
series_to_update_list = [i for i in series_to_update if i not in series_in_db_list]
for updated_series in series_to_update_list:
TableShows.update(
updated_series
).where(
TableShows.sonarr_series_id == updated_series['sonarr_series_id']
).execute()
# Insert new series in DB
for added_series in series_to_add:
TableShows.insert(
added_series
).on_conflict_ignore().execute()
list_missing_subtitles(added_series['sonarr_series_id'])
# Remove old series from DB
removed_series = list(set(current_shows_db_list) - set(current_shows_sonarr))
for series in removed_series:
TableShows.delete().where(
TableShows.tvdb_id == series
).execute()
logging.debug('BAZARR All series synced from Sonarr into database.')
def update_all_movies():
movies_full_scan_subtitles()
logging.info('All existing movie subtitles indexed from disk.')
list_missing_subtitles()
logging.info('All missing movie subtitles updated in database.')
def sync_episodes():
logging.debug('Starting episode sync from Sonarr.')
from get_settings import get_sonarr_settings
url_sonarr = get_sonarr_settings()[6]
apikey_sonarr = get_sonarr_settings()[4]
# Open database connection
db = sqlite3.connect(os.path.join(config_dir, 'db/bazarr.db'), timeout=30)
c = db.cursor()
# Get current episodes id in DB
current_episodes_db = c.execute(
'SELECT sonarrEpisodeId FROM table_episodes').fetchall()
current_episodes_db_list = [x[0] for x in current_episodes_db]
current_episodes_sonarr = []
episodes_to_update = []
episodes_to_add = []
# Get sonarrId for each series from database
seriesIdList = c.execute(
"SELECT sonarrSeriesId FROM table_shows").fetchall()
# Close database connection
c.close()
for seriesId in seriesIdList:
# Get episodes data for a series from Sonarr
url_sonarr_api_episode = url_sonarr + "/api/episode?seriesId=" + str(
seriesId[0]) + "&apikey=" + apikey_sonarr
try:
r = requests.get(url_sonarr_api_episode, timeout=15, verify=False)
r.raise_for_status()
except requests.exceptions.HTTPError as errh:
logging.exception(
"Error trying to get episodes from Sonarr. Http error.")
except requests.exceptions.ConnectionError as errc:
logging.exception(
"Error trying to get episodes from Sonarr. Connection Error.")
except requests.exceptions.Timeout as errt:
logging.exception(
"Error trying to get episodes from Sonarr. Timeout Error.")
except requests.exceptions.RequestException as err:
logging.exception("Error trying to get episodes from Sonarr.")
else:
for episode in r.json():
if 'hasFile' in episode:
if episode['hasFile'] is True:
if 'episodeFile' in episode:
if episode['episodeFile']['size'] > 20480:
# Add shows in Sonarr to current shows list
if 'sceneName' in episode['episodeFile']:
sceneName = episode['episodeFile'][
'sceneName']
else:
sceneName = None
# Add episodes in sonarr to current episode list
current_episodes_sonarr.append(episode['id'])
if episode['id'] in current_episodes_db_list:
episodes_to_update.append(
(episode['title'],
episode['episodeFile']['path'],
episode['seasonNumber'],
episode['episodeNumber'], sceneName,
str(bool(episode['monitored'])),
episode['id']))
else:
episodes_to_add.append(
(episode['seriesId'], episode['id'],
episode['title'],
episode['episodeFile']['path'],
episode['seasonNumber'],
episode['episodeNumber'], sceneName,
str(bool(episode['monitored']))))
removed_episodes = list(
set(current_episodes_db_list) - set(current_episodes_sonarr))
# Update or insert movies in DB
db = sqlite3.connect(os.path.join(config_dir, 'db/bazarr.db'), timeout=30)
c = db.cursor()
updated_result = c.executemany(
'''UPDATE table_episodes SET title = ?, path = ?, season = ?, episode = ?, scene_name = ?, monitored = ? WHERE sonarrEpisodeId = ?''',
episodes_to_update)
db.commit()
added_result = c.executemany(
'''INSERT OR IGNORE INTO table_episodes(sonarrSeriesId, sonarrEpisodeId, title, path, season, episode, scene_name, monitored) VALUES (?, ?, ?, ?, ?, ?, ?, ?)''',
episodes_to_add)
db.commit()
for removed_episode in removed_episodes:
c.execute('DELETE FROM table_episodes WHERE sonarrEpisodeId = ?',
(removed_episode, ))
db.commit()
# Close database connection
c.close()
for added_episode in episodes_to_add:
store_subtitles(path_replace(added_episode[3]))
logging.debug('All episodes synced from Sonarr into database.')
list_missing_subtitles()
logging.debug('All missing subtitles updated in database.')
def sync_episodes():
notifications.write(msg='Episodes sync from Sonarr started...', queue='get_episodes')
logging.debug('BAZARR Starting episodes sync from Sonarr.')
apikey_sonarr = settings.sonarr.apikey
# Open database connection
db = sqlite3.connect(os.path.join(args.config_dir, 'db', 'bazarr.db'), timeout=30)
c = db.cursor()
# Get current episodes id in DB
current_episodes_db = c.execute('SELECT sonarrEpisodeId, path, sonarrSeriesId FROM table_episodes').fetchall()
current_episodes_db_list = [x[0] for x in current_episodes_db]
current_episodes_sonarr = []
episodes_to_update = []
episodes_to_add = []
# Get sonarrId for each series from database
seriesIdList = c.execute("SELECT sonarrSeriesId, title FROM table_shows").fetchall()
# Close database connection
c.close()
seriesIdListLength = len(seriesIdList)
for i, seriesId in enumerate(seriesIdList, 1):
notifications.write(msg='Getting episodes data from Sonarr...', queue='get_episodes', item=i, length=seriesIdListLength)
# Get episodes data for a series from Sonarr
url_sonarr_api_episode = url_sonarr + "/api/episode?seriesId=" + str(seriesId[0]) + "&apikey=" + apikey_sonarr
try:
r = requests.get(url_sonarr_api_episode, timeout=60, verify=False)
r.raise_for_status()
except requests.exceptions.HTTPError as errh:
logging.exception("BAZARR Error trying to get episodes from Sonarr. Http error.")
except requests.exceptions.ConnectionError as errc:
logging.exception("BAZARR Error trying to get episodes from Sonarr. Connection Error.")
except requests.exceptions.Timeout as errt:
logging.exception("BAZARR Error trying to get episodes from Sonarr. Timeout Error.")
except requests.exceptions.RequestException as err:
logging.exception("BAZARR Error trying to get episodes from Sonarr.")
else:
for episode in r.json():
if 'hasFile' in episode:
if episode['hasFile'] is True:
if 'episodeFile' in episode:
if episode['episodeFile']['size'] > 20480:
# Add shows in Sonarr to current shows list
if 'sceneName' in episode['episodeFile']:
sceneName = episode['episodeFile']['sceneName']
else:
sceneName = None
try:
format, resolution = episode['episodeFile']['quality']['quality']['name'].split('-')
except:
format = episode['episodeFile']['quality']['quality']['name']
try:
resolution = str(episode['episodeFile']['quality']['quality']['resolution']) + 'p'
except:
resolution = None
if 'mediaInfo' in episode['episodeFile']:
if 'videoCodec' in episode['episodeFile']['mediaInfo']:
videoCodec = episode['episodeFile']['mediaInfo']['videoCodec']
videoCodec = SonarrFormatVideoCodec(videoCodec)
else: videoCodec = None
if 'audioCodec' in episode['episodeFile']['mediaInfo']:
audioCodec = episode['episodeFile']['mediaInfo']['audioCodec']
audioCodec = SonarrFormatAudioCodec(audioCodec)
else: audioCodec = None
else:
videoCodec = None
audioCodec = None
# Add episodes in sonarr to current episode list
current_episodes_sonarr.append(episode['id'])
if episode['id'] in current_episodes_db_list:
episodes_to_update.append((episode['title'], episode['episodeFile']['path'],
episode['seasonNumber'], episode['episodeNumber'],
sceneName, str(bool(episode['monitored'])),
format, resolution,
videoCodec, audioCodec, episode['id']))
else:
episodes_to_add.append((episode['seriesId'], episode['id'], episode['title'],
episode['episodeFile']['path'], episode['seasonNumber'],
episode['episodeNumber'], sceneName,
str(bool(episode['monitored'])), format, resolution,
videoCodec, audioCodec))
removed_episodes = list(set(current_episodes_db_list) - set(current_episodes_sonarr))
# Update or insert movies in DB
db = sqlite3.connect(os.path.join(args.config_dir, 'db', 'bazarr.db'), timeout=30)
c = db.cursor()
updated_result = c.executemany(
'''UPDATE table_episodes SET title = ?, path = ?, season = ?, episode = ?, scene_name = ?, monitored = ?, format = ?, resolution = ?, video_codec = ?, audio_codec = ? WHERE sonarrEpisodeId = ?''',
episodes_to_update)
db.commit()
added_result = c.executemany(
'''INSERT OR IGNORE INTO table_episodes(sonarrSeriesId, sonarrEpisodeId, title, path, season, episode, scene_name, monitored, format, resolution, video_codec, audio_codec) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
episodes_to_add)
db.commit()
for removed_episode in removed_episodes:
c.execute('DELETE FROM table_episodes WHERE sonarrEpisodeId = ?', (removed_episode,))
db.commit()
# Get episodes list after INSERT and UPDATE
episodes_now_in_db = c.execute('SELECT sonarrEpisodeId, path, sonarrSeriesId FROM table_episodes').fetchall()
# Close database connection
c.close()
# Get only episodes added or modified and store subtitles for them
altered_episodes = set(episodes_now_in_db).difference(set(current_episodes_db))
for altered_episode in altered_episodes:
store_subtitles(path_replace(altered_episode[1]))
list_missing_subtitles(altered_episode[2])
logging.debug('BAZARR All episodes synced from Sonarr into database.')
# Search for desired subtitles if no more than 5 episodes have been added.
if len(altered_episodes) <= 5:
logging.debug("BAZARR No more than 5 episodes were added during this sync then we'll search for subtitles.")
for altered_episode in altered_episodes:
episode_download_subtitles(altered_episode[0])
else:
logging.debug("BAZARR More than 5 episodes were added during this sync then we wont search for subtitles.")
