open-source-mirrors
/
bazarr
mirror of https://github.com/morpheus65535/bazarr
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added validation for incomplete indexing of subtitles or calculation of missing subtitles before searching.

Browse Source
pull/2774/head
morpheus65535 2 months ago
parent 6fbc91289f
commit 5b3312ea4d
10 changed files with 212 additions and 191 deletions
Show Stats Download Patch File Download Diff File

4
bazarr/api/badges/badges.py
Unescape View File

@ -36,7 +36,7 @@ class Badges(Resource):
def get(self):
"""Get badges count to update the UI"""
episodes_conditions = [(TableEpisodes.missing_subtitles.is_not(None)),
(TableEpisodes.missing_subtitles != '[]')]
(TableEpisodes.missing_subtitles.is_not('[]'))]
episodes_conditions += get_exclusion_clause('series')
missing_episodes = database.execute(
select(TableEpisodes.missing_subtitles)
@ -49,7 +49,7 @@ class Badges(Resource):
missing_episodes_count += len(ast.literal_eval(episode.missing_subtitles))
movies_conditions = [(TableMovies.missing_subtitles.is_not(None)),
(TableMovies.missing_subtitles != '[]')]
(TableMovies.missing_subtitles.is_not('[]'))]
movies_conditions += get_exclusion_clause('movie')
missing_movies = database.execute(
select(TableMovies.missing_subtitles)

3
bazarr/api/episodes/wanted.py
Unescape View File

@ -48,7 +48,8 @@ class EpisodesWanted(Resource):
args = self.get_request_parser.parse_args()
episodeid = args.get('episodeid[]')
wanted_conditions = [(TableEpisodes.missing_subtitles != '[]')]
wanted_conditions = [(TableEpisodes.missing_subtitles.is_not(None)),
(TableEpisodes.missing_subtitles.is_not('[]'))]
if len(episodeid) > 0:
wanted_conditions.append((TableEpisodes.sonarrEpisodeId in episodeid))
start = 0

2
bazarr/api/movies/wanted.py
Unescape View File

@ -45,7 +45,7 @@ class MoviesWanted(Resource):
args = self.get_request_parser.parse_args()
radarrid = args.get("radarrid[]")
wanted_conditions = [(TableMovies.missing_subtitles != '[]')]
wanted_conditions = [(TableMovies.missing_subtitles.is_not('[]'))]
if len(radarrid) > 0:
wanted_conditions.append((TableMovies.radarrId.in_(radarrid)))
start = 0

29
bazarr/api/providers/providers_episodes.py
Unescape View File

@ -11,7 +11,7 @@ from subtitles.manual import manual_search, manual_download_subtitle
from sonarr.history import history_log
from app.config import settings
from app.notifier import send_notifications
from subtitles.indexer.series import store_subtitles
from subtitles.indexer.series import store_subtitles, list_missing_subtitles
from subtitles.processing import ProcessSubtitlesResult
from ..utils import authenticate
@ -50,18 +50,27 @@ class ProviderEpisodes(Resource):
"""Search manually for an episode subtitles"""
args = self.get_request_parser.parse_args()
sonarrEpisodeId = args.get('episodeid')
episodeInfo = database.execute(
select(TableEpisodes.path,
TableEpisodes.sceneName,
TableShows.title,
TableShows.profileId)
.select_from(TableEpisodes)
.join(TableShows)
.where(TableEpisodes.sonarrEpisodeId == sonarrEpisodeId)) \
.first()
stmt = select(TableEpisodes.path,
TableEpisodes.sceneName,
TableShows.title,
TableShows.profileId,
TableEpisodes.subtitles,
TableEpisodes.missing_subtitles) \
.select_from(TableEpisodes) \
.join(TableShows) \
.where(TableEpisodes.sonarrEpisodeId == sonarrEpisodeId)
episodeInfo = database.execute(stmt).first()
if not episodeInfo:
return 'Episode not found', 404
elif episodeInfo.subtitles is None:
# subtitles indexing for this episode is incomplete, we'll do it again
store_subtitles(episodeInfo.path, path_mappings.path_replace(episodeInfo.path))
episodeInfo = database.execute(stmt).first()
elif episodeInfo.missing_subtitles is None:
# missing subtitles calculation for this episode is incomplete, we'll do it again
list_missing_subtitles(epno=sonarrEpisodeId)
episodeInfo = database.execute(stmt).first()
title = episodeInfo.title
episodePath = path_mappings.path_replace(episodeInfo.path)

25
bazarr/api/providers/providers_movies.py
Unescape View File

@ -11,7 +11,7 @@ from subtitles.manual import manual_search, manual_download_subtitle
from radarr.history import history_log_movie
from app.config import settings
from app.notifier import send_notifications_movie
from subtitles.indexer.movies import store_subtitles_movie
from subtitles.indexer.movies import store_subtitles_movie, list_missing_subtitles_movies
from subtitles.processing import ProcessSubtitlesResult
from ..utils import authenticate
@ -51,16 +51,25 @@ class ProviderMovies(Resource):
"""Search manually for a movie subtitles"""
args = self.get_request_parser.parse_args()
radarrId = args.get('radarrid')
movieInfo = database.execute(
select(TableMovies.title,
TableMovies.path,
TableMovies.sceneName,
TableMovies.profileId)
.where(TableMovies.radarrId == radarrId)) \
.first()
stmt = select(TableMovies.title,
TableMovies.path,
TableMovies.sceneName,
TableMovies.profileId,
TableMovies.subtitles,
TableMovies.missing_subtitles) \
.where(TableMovies.radarrId == radarrId)
movieInfo = database.execute(stmt).first()
if not movieInfo:
return 'Movie not found', 404
elif movieInfo.subtitles is None:
# subtitles indexing for this movie is incomplete, we'll do it again
store_subtitles_movie(movieInfo.path, path_mappings.path_replace_movie(movieInfo.path))
movieInfo = database.execute(stmt).first()
elif movieInfo.missing_subtitles is None:
# missing subtitles calculation for this movie is incomplete, we'll do it again
list_missing_subtitles_movies(no=radarrId)
movieInfo = database.execute(stmt).first()
title = movieInfo.title
moviePath = path_mappings.path_replace_movie(movieInfo.path)

2
bazarr/api/series/series.py
Unescape View File

@ -73,7 +73,7 @@ class Series(Resource):
.group_by(TableShows.sonarrSeriesId)\
.subquery()
episodes_missing_conditions = [(TableEpisodes.missing_subtitles != '[]')]
episodes_missing_conditions = [(TableEpisodes.missing_subtitles.is_not('[]'))]
episodes_missing_conditions += get_exclusion_clause('series')
episodeMissingCount = select(TableShows.sonarrSeriesId,

39
bazarr/subtitles/mass_download/movies.py
Unescape View File

@ -9,7 +9,7 @@ import os
from functools import reduce
from utilities.path_mappings import path_mappings
from subtitles.indexer.movies import store_subtitles_movie
from subtitles.indexer.movies import store_subtitles_movie, list_missing_subtitles_movies
from radarr.history import history_log_movie
from app.notifier import send_notifications_movie
from app.get_providers import get_providers
@ -20,23 +20,32 @@ from ..download import generate_subtitles
def movies_download_subtitles(no):
conditions = [(TableMovies.radarrId == no)]
conditions = [(TableMovies.radarrId.is_(no))]
conditions += get_exclusion_clause('movie')
movie = database.execute(
select(TableMovies.path,
TableMovies.missing_subtitles,
TableMovies.audio_language,
TableMovies.radarrId,
TableMovies.sceneName,
TableMovies.title,
TableMovies.tags,
TableMovies.monitored,
TableMovies.profileId)
.where(reduce(operator.and_, conditions))) \
.first()
stmt = select(TableMovies.path,
TableMovies.missing_subtitles,
TableMovies.audio_language,
TableMovies.radarrId,
TableMovies.sceneName,
TableMovies.title,
TableMovies.tags,
TableMovies.monitored,
TableMovies.profileId,
TableMovies.subtitles) \
.where(reduce(operator.and_, conditions))
movie = database.execute(stmt).first()
if not movie:
logging.debug("BAZARR no movie with that radarrId can be found in database:", str(no))
logging.debug(f"BAZARR no movie with that radarrId can be found in database: {no}")
return
elif movie.subtitles is None:
# subtitles indexing for this movie is incomplete, we'll do it again
store_subtitles_movie(movie.path, path_mappings.path_replace_movie(movie.path))
movie = database.execute(stmt).first()
elif movie.missing_subtitles is None:
# missing subtitles calculation for this movie is incomplete, we'll do it again
list_missing_subtitles_movies(no=no)
movie = database.execute(stmt).first()
moviePath = path_mappings.path_replace_movie(movie.path)

186
bazarr/subtitles/mass_download/series.py
Unescape View File

@ -9,7 +9,7 @@ import os
from functools import reduce
from utilities.path_mappings import path_mappings
from subtitles.indexer.series import store_subtitles
from subtitles.indexer.series import store_subtitles, list_missing_subtitles
from sonarr.history import history_log
from app.notifier import send_notifications
from app.get_providers import get_providers
@ -29,22 +29,15 @@ def series_download_subtitles(no):
raise OSError
conditions = [(TableEpisodes.sonarrSeriesId == no),
(TableEpisodes.missing_subtitles != '[]')]
(TableEpisodes.missing_subtitles.is_not('[]'))]
conditions += get_exclusion_clause('series')
episodes_details = database.execute(
select(TableEpisodes.path,
TableEpisodes.missing_subtitles,
TableEpisodes.monitored,
TableEpisodes.sonarrEpisodeId,
TableEpisodes.sceneName,
TableShows.tags,
TableShows.seriesType,
TableEpisodes.audio_language,
select(TableEpisodes.sonarrEpisodeId,
TableShows.title,
TableEpisodes.season,
TableEpisodes.episode,
TableEpisodes.title.label('episodeTitle'),
TableShows.profileId)
TableEpisodes.missing_subtitles)
.select_from(TableEpisodes)
.join(TableShows)
.where(reduce(operator.and_, conditions))) \
@ -66,36 +59,7 @@ def series_download_subtitles(no):
value=i,
count=count_episodes_details)
audio_language_list = get_audio_profile_languages(episode.audio_language)
if len(audio_language_list) > 0:
audio_language = audio_language_list[0]['name']
else:
audio_language = 'None'
languages = []
for language in ast.literal_eval(episode.missing_subtitles):
if language is not None:
hi_ = "True" if language.endswith(':hi') else "False"
forced_ = "True" if language.endswith(':forced') else "False"
languages.append((language.split(":")[0], hi_, forced_))
if not languages:
continue
for result in generate_subtitles(path_mappings.path_replace(episode.path),
languages,
audio_language,
str(episode.sceneName),
episode.title,
'series',
episode.profileId,
check_if_still_required=True):
if result:
if isinstance(result, tuple) and len(result):
result = result[0]
store_subtitles(episode.path, path_mappings.path_replace(episode.path))
history_log(1, no, episode.sonarrEpisodeId, result)
send_notifications(no, episode.sonarrEpisodeId, result.message)
episode_download_subtitles(no=episode.sonarrEpisodeId, send_progress=False, providers_list=providers_list)
else:
logging.info("BAZARR All providers are throttled")
break
@ -103,76 +67,84 @@ def series_download_subtitles(no):
hide_progress(id=f'series_search_progress_{no}')
def episode_download_subtitles(no, send_progress=False):
def episode_download_subtitles(no, send_progress=False, providers_list=None):
conditions = [(TableEpisodes.sonarrEpisodeId == no)]
conditions += get_exclusion_clause('series')
episodes_details = database.execute(
select(TableEpisodes.path,
TableEpisodes.missing_subtitles,
TableEpisodes.monitored,
TableEpisodes.sonarrEpisodeId,
TableEpisodes.sceneName,
TableShows.tags,
TableShows.title,
TableShows.sonarrSeriesId,
TableEpisodes.audio_language,
TableShows.seriesType,
TableEpisodes.title.label('episodeTitle'),
TableEpisodes.season,
TableEpisodes.episode,
TableShows.profileId)
.select_from(TableEpisodes)
.join(TableShows)
.where(reduce(operator.and_, conditions))) \
.all()
if not episodes_details:
stmt = select(TableEpisodes.path,
TableEpisodes.missing_subtitles,
TableEpisodes.monitored,
TableEpisodes.sonarrEpisodeId,
TableEpisodes.sceneName,
TableShows.tags,
TableShows.title,
TableShows.sonarrSeriesId,
TableEpisodes.audio_language,
TableShows.seriesType,
TableEpisodes.title.label('episodeTitle'),
TableEpisodes.season,
TableEpisodes.episode,
TableShows.profileId,
TableEpisodes.subtitles) \
.select_from(TableEpisodes) \
.join(TableShows) \
.where(reduce(operator.and_, conditions))
episode = database.execute(stmt).first()
if not episode:
logging.debug("BAZARR no episode with that sonarrEpisodeId can be found in database:", str(no))
return
for episode in episodes_details:
elif episode.subtitles is None:
# subtitles indexing for this episode is incomplete, we'll do it again
store_subtitles(episode.path, path_mappings.path_replace_movie(episode.path))
episode = database.execute(stmt).first()
elif episode.missing_subtitles is None:
# missing subtitles calculation for this episode is incomplete, we'll do it again
list_missing_subtitles(epno=no)
episode = database.execute(stmt).first()
if not providers_list:
providers_list = get_providers()
if providers_list:
if send_progress:
show_progress(id=f'episode_search_progress_{no}',
header='Searching missing subtitles...',
name=f'{episode.title} - S{episode.season:02d}E{episode.episode:02d} - {episode.episodeTitle}',
value=0,
count=1)
audio_language_list = get_audio_profile_languages(episode.audio_language)
if len(audio_language_list) > 0:
audio_language = audio_language_list[0]['name']
else:
audio_language = 'None'
languages = []
for language in ast.literal_eval(episode.missing_subtitles):
if language is not None:
hi_ = "True" if language.endswith(':hi') else "False"
forced_ = "True" if language.endswith(':forced') else "False"
languages.append((language.split(":")[0], hi_, forced_))
if not languages:
continue
for result in generate_subtitles(path_mappings.path_replace(episode.path),
languages,
audio_language,
str(episode.sceneName),
episode.title,
'series',
episode.profileId,
check_if_still_required=True):
if result:
if isinstance(result, tuple) and len(result):
result = result[0]
store_subtitles(episode.path, path_mappings.path_replace(episode.path))
history_log(1, episode.sonarrSeriesId, episode.sonarrEpisodeId, result)
send_notifications(episode.sonarrSeriesId, episode.sonarrEpisodeId, result.message)
if send_progress:
hide_progress(id=f'episode_search_progress_{no}')
if providers_list:
if send_progress:
show_progress(id=f'episode_search_progress_{no}',
header='Searching missing subtitles...',
name=f'{episode.title} - S{episode.season:02d}E{episode.episode:02d} - {episode.episodeTitle}',
value=0,
count=1)
audio_language_list = get_audio_profile_languages(episode.audio_language)
if len(audio_language_list) > 0:
audio_language = audio_language_list[0]['name']
else:
logging.info("BAZARR All providers are throttled")
break
audio_language = 'None'
languages = []
for language in ast.literal_eval(episode.missing_subtitles):
if language is not None:
hi_ = "True" if language.endswith(':hi') else "False"
forced_ = "True" if language.endswith(':forced') else "False"
languages.append((language.split(":")[0], hi_, forced_))
if not languages:
return
for result in generate_subtitles(path_mappings.path_replace(episode.path),
languages,
audio_language,
str(episode.sceneName),
episode.title,
'series',
episode.profileId,
check_if_still_required=True):
if result:
if isinstance(result, tuple) and len(result):
result = result[0]
store_subtitles(episode.path, path_mappings.path_replace(episode.path))
history_log(1, episode.sonarrSeriesId, episode.sonarrEpisodeId, result)
send_notifications(episode.sonarrSeriesId, episode.sonarrEpisodeId, result.message)
if send_progress:
hide_progress(id=f'episode_search_progress_{no}')
else:
logging.info("BAZARR All providers are throttled")

54
bazarr/subtitles/wanted/movies.py
Unescape View File

@ -8,7 +8,7 @@ import operator
from functools import reduce
from utilities.path_mappings import path_mappings
from subtitles.indexer.movies import store_subtitles_movie
from subtitles.indexer.movies import store_subtitles_movie, list_missing_subtitles_movies
from radarr.history import history_log_movie
from app.notifier import send_notifications_movie
from app.get_providers import get_providers
@ -63,30 +63,40 @@ def _wanted_movie(movie):
def wanted_download_subtitles_movie(radarr_id):
movies_details = database.execute(
select(TableMovies.path,
TableMovies.missing_subtitles,
TableMovies.radarrId,
TableMovies.audio_language,
TableMovies.sceneName,
TableMovies.failedAttempts,
TableMovies.title,
TableMovies.profileId)
.where(TableMovies.radarrId == radarr_id)) \
.all()
for movie in movies_details:
providers_list = get_providers()
if providers_list:
_wanted_movie(movie)
else:
logging.info("BAZARR All providers are throttled")
break
stmt = select(TableMovies.path,
TableMovies.missing_subtitles,
TableMovies.radarrId,
TableMovies.audio_language,
TableMovies.sceneName,
TableMovies.failedAttempts,
TableMovies.title,
TableMovies.profileId,
TableMovies.subtitles) \
.where(TableMovies.radarrId == radarr_id)
movie = database.execute(stmt).first()
if not movie:
logging.debug(f"BAZARR no movie with that radarrId can be found in database: {radarr_id}")
return
elif movie.subtitles is None:
# subtitles indexing for this movie is incomplete, we'll do it again
store_subtitles_movie(movie.path, path_mappings.path_replace_movie(movie.path))
movie = database.execute(stmt).first()
elif movie.missing_subtitles is None:
# missing subtitles calculation for this movie is incomplete, we'll do it again
list_missing_subtitles_movies(no=radarr_id)
movie = database.execute(stmt).first()
providers_list = get_providers()
if providers_list:
_wanted_movie(movie)
else:
logging.info("BAZARR All providers are throttled")
def wanted_search_missing_subtitles_movies():
conditions = [(TableMovies.missing_subtitles != '[]')]
conditions = [(TableMovies.missing_subtitles.is_not('[]'))]
conditions += get_exclusion_clause('movie')
movies = database.execute(
select(TableMovies.radarrId,

59
bazarr/subtitles/wanted/series.py
Unescape View File

@ -8,6 +8,7 @@ import operator
from functools import reduce
from utilities.path_mappings import path_mappings
from subtitles.indexer.series import store_subtitles, list_missing_subtitles
from subtitles.indexer.series import store_subtitles
from sonarr.history import history_log
from app.notifier import send_notifications
@ -64,33 +65,43 @@ def _wanted_episode(episode):
def wanted_download_subtitles(sonarr_episode_id):
episodes_details = database.execute(
select(TableEpisodes.path,
TableEpisodes.missing_subtitles,
TableEpisodes.sonarrEpisodeId,
TableEpisodes.sonarrSeriesId,
TableEpisodes.audio_language,
TableEpisodes.sceneName,
TableEpisodes.failedAttempts,
TableShows.title,
TableShows.profileId)
.select_from(TableEpisodes)
.join(TableShows)
.where((TableEpisodes.sonarrEpisodeId == sonarr_episode_id))) \
.all()
for episode in episodes_details:
providers_list = get_providers()
if providers_list:
_wanted_episode(episode)
else:
logging.info("BAZARR All providers are throttled")
break
stmt = select(TableEpisodes.path,
TableEpisodes.missing_subtitles,
TableEpisodes.sonarrEpisodeId,
TableEpisodes.sonarrSeriesId,
TableEpisodes.audio_language,
TableEpisodes.sceneName,
TableEpisodes.failedAttempts,
TableShows.title,
TableShows.profileId,
TableEpisodes.subtitles) \
.select_from(TableEpisodes) \
.join(TableShows) \
.where((TableEpisodes.sonarrEpisodeId == sonarr_episode_id))
episode_details = database.execute(stmt).first()
if not episode_details:
logging.debug(f"BAZARR no episode with that sonarrId can be found in database: {sonarr_episode_id}")
return
elif episode_details.subtitles is None:
# subtitles indexing for this episode is incomplete, we'll do it again
store_subtitles(episode_details.path, path_mappings.path_replace(episode_details.path))
episode_details = database.execute(stmt).first()
elif episode_details.missing_subtitles is None:
# missing subtitles calculation for this episode is incomplete, we'll do it again
list_missing_subtitles(epno=sonarr_episode_id)
episode_details = database.execute(stmt).first()
providers_list = get_providers()
if providers_list:
_wanted_episode(episode_details)
else:
logging.info("BAZARR All providers are throttled")
def wanted_search_missing_subtitles_series():
conditions = [(TableEpisodes.missing_subtitles != '[]')]
conditions = [(TableEpisodes.missing_subtitles.is_not('[]'))]
conditions += get_exclusion_clause('series')
episodes = database.execute(
select(TableEpisodes.sonarrSeriesId,

Write Preview
Loading…
Cancel
Save