def test_process_file_size_too_low(monkeypatch):
# Monkey patch autosubliminal.MINVIDEOFILESIZE
monkeypatch.setattr('autosubliminal.MINVIDEOFILESIZE', 10)
# Test process_file
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
result_dict = process_file(dir_name, 'Southpaw.2015.1080p.BluRay.x264.mkv')
assert result_dict is None
def test_process_movie_file_special_chars(mocker):
mocker.patch.object(autosubliminal.MOVIEINDEXER, 'get_imdb_id_and_year')
autosubliminal.MOVIEINDEXER.get_imdb_id_and_year.return_value = 'tt0993789', 2008
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
wanted_item = process_file(dir_name, u'Un conte de Noël (2008).mkv')
assert wanted_item is not None
assert wanted_item.type == 'movie'
assert wanted_item.title == u'Un conte de Noël'
assert wanted_item.year == 2008
assert wanted_item.imdbid == 'tt0993789'
def test_process_movie_file_special_chars(mocker):
# Mock get_imdb_id_and_year call
mocker.patch.object(autosubliminal.MOVIEINDEXER, 'get_imdb_id_and_year')
autosubliminal.MOVIEINDEXER.get_imdb_id_and_year.return_value = '0993789', 2008
# Test process_file
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
result_dict = process_file(dir_name, u'Un conte de Noël (2008).mkv')
assert result_dict is not None
assert result_dict['type'] == 'movie'
assert result_dict['title'] == u'Un conte de Noël'
assert result_dict['year'] == 2008
assert result_dict['imdbid'] == '0993789'
def test_process_file_movie(mocker):
mocker.patch.object(autosubliminal.MOVIEINDEXER, 'get_imdb_id_and_year')
autosubliminal.MOVIEINDEXER.get_imdb_id_and_year.return_value = 'tt1798684', 2015
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
wanted_item = process_file(dir_name, 'Southpaw.2015.1080p.BluRay.x264.mkv')
assert wanted_item is not None
assert wanted_item.type == 'movie'
assert wanted_item.title == 'Southpaw'
assert wanted_item.year == 2015
assert wanted_item.source == 'Blu-ray'
assert wanted_item.quality == '1080p'
assert wanted_item.codec == 'H.264'
assert wanted_item.imdbid == 'tt1798684'
def test_process_multi_episode_file(mocker):
mocker.patch.object(autosubliminal.SHOWINDEXER, 'get_tvdb_id')
autosubliminal.SHOWINDEXER.get_tvdb_id.return_value = 263365
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
wanted_item = process_file(dir_name, 'Marvels.Agents.of.S.H.I.E.L.D.S05E01-E02.720p.HDTV.x264-AVS.mkv')
assert wanted_item is not None
assert wanted_item.type == 'episode'
assert wanted_item.title == 'Marvels Agents of S.H.I.E.L.D.'
assert wanted_item.season == 5
assert wanted_item.episode == [1, 2]
assert wanted_item.source == 'HDTV'
assert wanted_item.quality == '720p'
assert wanted_item.codec == 'H.264'
assert wanted_item.releasegrp == 'AVS'
assert wanted_item.tvdbid == 263365
def test_process_file_movie(mocker):
# Mock get_imdb_id_and_year call
mocker.patch.object(autosubliminal.MOVIEINDEXER, 'get_imdb_id_and_year')
autosubliminal.MOVIEINDEXER.get_imdb_id_and_year.return_value = '1798684', 2015
# Test process_file
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
result_dict = process_file(dir_name, 'Southpaw.2015.1080p.BluRay.x264.mkv')
assert result_dict is not None
assert result_dict['type'] == 'movie'
assert result_dict['title'] == 'Southpaw'
assert result_dict['year'] == 2015
assert result_dict['source'] == 'BluRay'
assert result_dict['quality'] == '1080p'
assert result_dict['codec'] == 'h264'
assert result_dict['imdbid'] == '1798684'
def test_process_episode_file_guess_by_filename(mocker):
mocker.patch.object(autosubliminal.SHOWINDEXER, 'get_tvdb_id')
autosubliminal.SHOWINDEXER.get_tvdb_id.return_value = 248741
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
wanted_item = process_file(dir_name, '2 Broke Girls - S01E01 - HDTV-720p Proper - x264 AC3 - IMMERSE.mkv')
assert wanted_item is not None
assert wanted_item.type == 'episode'
assert wanted_item.title == '2 Broke Girls'
assert wanted_item.season == 1
assert wanted_item.episode == 1
assert wanted_item.source == 'HDTV'
assert wanted_item.quality == '720p'
assert wanted_item.codec == 'H.264'
assert wanted_item.releasegrp == 'IMMERSE'
assert wanted_item.tvdbid == 248741
def test_process_episode_file_guess_by_filename(mocker):
# Mock get_tvdb_id call
mocker.patch.object(autosubliminal.SHOWINDEXER, 'get_tvdb_id')
autosubliminal.SHOWINDEXER.get_tvdb_id.return_value = 248741
# Test process_file
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
result_dict = process_file(dir_name, '2 Broke Girls - S01E01 - HDTV-720p Proper - x264 AC3 - IMMERSE.mkv')
assert result_dict is not None
assert result_dict['type'] == 'episode'
assert result_dict['title'] == '2 Broke Girls'
assert result_dict['season'] == 1
assert result_dict['episode'] == 1
assert result_dict['source'] == 'HDTV'
assert result_dict['quality'] == '720p'
assert result_dict['codec'] == 'h264'
assert result_dict['releasegrp'] == 'IMMERSE'
assert result_dict['tvdbid'] == 248741
def test_process_multi_episode_file(mocker):
# Mock get_tvdb_id call
mocker.patch.object(autosubliminal.SHOWINDEXER, 'get_tvdb_id')
autosubliminal.SHOWINDEXER.get_tvdb_id.return_value = 263365
# Test process_file
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
result_dict = process_file(dir_name, 'Marvels.Agents.of.S.H.I.E.L.D.S05E01-E02.720p.HDTV.x264-AVS.mkv')
assert result_dict is not None
assert result_dict['type'] == 'episode'
assert result_dict['title'] == 'Marvels Agents of S.H.I.E.L.D.'
assert result_dict['season'] == 5
assert result_dict['episode'] == '1,2'
assert result_dict['source'] == 'HDTV'
assert result_dict['quality'] == '720p'
assert result_dict['codec'] == 'h264'
assert result_dict['releasegrp'] == 'AVS'
assert result_dict['tvdbid'] == 263365
def test_process_episode_file_guess_by_file_path(mocker):
mocker.patch.object(autosubliminal.SHOWINDEXER, 'get_tvdb_id')
autosubliminal.SHOWINDEXER.get_tvdb_id.return_value = 248741
# Mock getctime (we don't want that the _enrich_dict fails since we are using a simulated dir_name)
mocker.patch.object(os.path, 'getctime')
os.path.getctime.return_value = None
dir_name = os.path.join(os.path.abspath(os.sep), 'Series', '2 Broke Girls', 'Season 1')
wanted_item = process_file(dir_name, 'S01E01.mkv')
assert wanted_item is not None
assert wanted_item.type == 'episode'
assert wanted_item.title == '2 Broke Girls'
assert wanted_item.season == 1
assert wanted_item.episode == 1
assert wanted_item.source is None
assert wanted_item.quality is None
assert wanted_item.codec is None
assert wanted_item.releasegrp is None
assert wanted_item.tvdbid == 248741
def test_process_episode_file_guess_by_file_path(mocker):
# Mock get_tvdb_id call
mocker.patch.object(autosubliminal.SHOWINDEXER, 'get_tvdb_id')
autosubliminal.SHOWINDEXER.get_tvdb_id.return_value = 248741
# Mock getctime (we don't want that the _enrich_dict fails since we are using a simulated dir_name)
mocker.patch.object(os.path, 'getctime')
os.path.getctime.return_value = None
# Test process_file (simulate dir_name)
dir_name = os.path.join(os.path.abspath(os.sep), 'Series', '2 Broke Girls', 'Season 1')
result_dict = process_file(dir_name, 'S01E01.mkv')
assert result_dict is not None
assert result_dict['type'] == 'episode'
assert result_dict['title'] == '2 Broke Girls'
assert result_dict['season'] == 1
assert result_dict['episode'] == 1
assert result_dict['source'] is None
assert result_dict['quality'] is None
assert result_dict['codec'] is None
assert result_dict['releasegrp'] is None
assert result_dict['tvdbid'] == 248741
def walk_dir(path):
log.info('Scanning video path: %s', path)
wanted_items = []
db = WantedItems()
# Check all folders and files
for dirname, dirnames, filenames in os.walk(os.path.join(path)):
log.debug('Directory: %s', dirname)
# Check folders to be skipped
if autosubliminal.SKIPHIDDENDIRS and os.path.split(
dirname)[1].startswith(u'.'):
continue
if re.search('_unpack_', dirname, re.IGNORECASE):
log.debug('Found a unpack directory, skipping')
continue
if re.search('_failed_', dirname, re.IGNORECASE):
log.debug('Found a failed directory, skipping')
continue
# Check files
for filename in filenames:
root, ext = os.path.splitext(filename)
# Check for video files
if ext and ext in subliminal.video.VIDEO_EXTENSIONS:
# Skip 'sample' videos
if re.search('sample', filename, re.IGNORECASE):
continue
log.debug('Video file found: %s', filename)
# Check if video file has already been processed before, so we don't need to process it again
wanted_item = db.get_wanted_item(
os.path.join(dirname, filename))
if wanted_item:
log.debug(
'Video found in wanted_items database, no need to scan it again'
)
else:
log.debug(
'Video not found in wanted_items database, start scanning it'
)
# Check for missing subtitles
languages = check_missing_subtitle_languages(
dirname, filename)
# Process the video file if there are missing subtitles
if len(languages) > 0:
wanted_item = fileprocessor.process_file(
dirname, filename)
if wanted_item:
# Add wanted languages and store in wanted_items database
wanted_item['languages'] = languages
db.set_wanted_item(wanted_item)
else:
continue
else:
log.debug('Video has no missing subtitles')
continue
# Check if we need to skip it and delete it from the database
log.debug('Checking if the video needs to be skipped')
if wanted_item:
# Skip episode check
if wanted_item['type'] == 'episode':
title = wanted_item['title']
season = wanted_item['season']
episode = wanted_item['episode']
if utils.skip_show(title, season, episode):
db.delete_wanted_item(wanted_item)
log.info('Skipping %s - Season %s Episode %s',
title, season, episode)
continue
# Skip movie check
elif wanted_item['type'] == 'movie':
title = wanted_item['title']
year = wanted_item['year']
if utils.skip_movie(title, year):
db.delete_wanted_item(wanted_item)
log.info('Skipping %s (%s)', title, year)
continue
# Add it to list of wanted items
log.debug('Video added to list of wanted items')
wanted_items.append(wanted_item)
return wanted_items
def test_process_episode_file_insufficient_guess():
# Test process_file
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
result_dict = process_file(dir_name, 'Insufficient.guess.series.S1.mkv')
assert result_dict is None
def test_process_file_size_too_low(monkeypatch):
monkeypatch.setattr('autosubliminal.MINVIDEOFILESIZE', 10)
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
result_dict = process_file(dir_name, 'Southpaw.2015.1080p.BluRay.x264.mkv')
assert result_dict is None
def test_guess_invalid_type(mocker):
mocker.patch('autosubliminal.fileprocessor.guessit', return_value=dict([('year', 2018), ('container', 'mkv')]))
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
assert process_file(dir_name, '2018.mkv') is None
def test_guess_exception(mocker):
mocker.patch('autosubliminal.fileprocessor.guessit', side_effect=Exception)
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
assert process_file(dir_name, 'Southpaw.2015.1080p.BluRay.x264.mkv') is None
def test_process_episode_file_insufficient_guess():
dir_name = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'resources')
result_dict = process_file(dir_name, 'Insufficient.guess.series.S1.mkv')
assert result_dict is None
def walk_dir(path):
log.info("Scanning video path: %s" % path)
for dirname, dirnames, filenames in os.walk(os.path.join(path)):
log.debug("Directory: %s" % dirname)
# Check folders to be skipped
if autosubliminal.SKIPHIDDENDIRS and os.path.split(
dirname)[1].startswith(u'.'):
continue
if re.search('_unpack_', dirname, re.IGNORECASE):
log.debug("Found a unpack directory, skipping")
continue
if re.search('_failed_', dirname, re.IGNORECASE):
log.debug("Found a failed directory, skipping")
continue
# Populate WANTEDQUEUE
for filename in filenames:
log.debug("File: %s" % filename)
root, ext = os.path.splitext(filename)
if ext and ext in subliminal.video.VIDEO_EXTENSIONS:
# Skip 'sample' videos
if re.search('sample', filename, re.IGNORECASE):
continue
# Check if there are missing subtitle languages for the video file
languages = check_missing_subtitle_languages(dirname, filename)
if len(languages) > 0:
log.debug("File is missing a subtitle")
wanted_item = fileprocessor.process_file(dirname, filename)
if wanted_item:
# Episode wanted
if wanted_item['type'] == 'episode':
title = wanted_item['title']
season = wanted_item['season']
episode = wanted_item['episode']
if utils.skip_show(title, season, episode):
log.info("Skipping %s - Season %s Episode %s" %
(title, season, episode))
continue
log.info(
"Subtitle(s) wanted for %s and added to wantedQueue"
% filename)
wanted_item[
'originalFileLocationOnDisk'] = os.path.join(
dirname, filename)
wanted_item['time'] = os.path.getctime(
wanted_item['originalFileLocationOnDisk'])
wanted_item['timestamp'] = unicode(
time.strftime(
'%Y-%m-%d %H:%M:%S',
time.localtime(wanted_item['time'])))
wanted_item['lang'] = languages
wanted_item['tvdbid'] = utils.get_tvdb_id(title)
autosubliminal.WANTEDQUEUE.append(wanted_item)
# Movie wanted
elif wanted_item['type'] == 'movie':
title = wanted_item['title']
year = wanted_item['year']
if utils.skip_movie(title, year):
log.info("Skipping %s (%s)" % (title, year))
continue
log.info(
"Subtitle(s) wanted for %s and added to wantedQueue"
% filename)
wanted_item[
'originalFileLocationOnDisk'] = os.path.join(
dirname, filename)
wanted_item['time'] = os.path.getctime(
wanted_item['originalFileLocationOnDisk'])
wanted_item['timestamp'] = unicode(
time.strftime(
'%Y-%m-%d %H:%M:%S',
time.localtime(wanted_item['time'])))
wanted_item['lang'] = languages
wanted_item['imdbid'], wanted_item[
'year'] = utils.get_imdb_info(title, year)
autosubliminal.WANTEDQUEUE.append(wanted_item)
else:
log.error("Could not process the filename: %s" %
filename)
continue
# Sort WANTEDQUEUE
autosubliminal.WANTEDQUEUE = sorted(autosubliminal.WANTEDQUEUE,
key=itemgetter('time'),
reverse=True)
def _scan_file(self, dirname, filename):
wanted_item = process_file(dirname, filename)
if wanted_item:
if wanted_item.is_episode:
# Do a force search if no tvdb id found
if not wanted_item.tvdbid:
wanted_item.tvdbid = self.show_indexer.get_tvdb_id(wanted_item.title, year=wanted_item.year,
force_search=True)
# Skip if no tvdb id is found
if not wanted_item.tvdbid:
log.warning('Skipping show episode file with unknown tvdb id: %s', os.path.join(dirname, filename))
show_path = self._get_show_path(dirname)
if not self.failed_shows_db.get_failed_show(show_path):
self.failed_shows_db.set_failed_show(show_path)
return
# Store default show settings if not yet available
if not self.show_settings_db.get_show_settings(wanted_item.tvdbid):
self.show_settings_db.set_show_settings(ShowSettings.default_settings(wanted_item.tvdbid))
show_settings = self.show_settings_db.get_show_settings(wanted_item.tvdbid)
# Get show details
show_details = self.show_db.get_show(wanted_item.tvdbid)
# Add show and episodes to db if not yet in db
if not show_details:
show_details = self.show_indexer.get_show_details(wanted_item.tvdbid)
if show_details:
show_details.path = self._get_show_path(dirname)
self.show_db.set_show(show_details)
episodes = self.show_indexer.get_show_episodes(wanted_item.tvdbid)
if episodes:
for episode in episodes:
self.show_episodes_db.set_show_episode(episode)
# Cache artwork (fullsize and thumbnail) if not yet cached
if show_details:
# Poster
if show_details.poster:
if not is_artwork_cached(self.show_indexer.name, show_details.tvdb_id, 'poster'):
cache_artwork(self.show_indexer.name, show_details.tvdb_id, 'poster',
get_artwork_url(show_details.poster))
if not is_artwork_cached(self.show_indexer.name, show_details.tvdb_id, 'poster',
thumbnail=True):
cache_artwork(self.show_indexer.name, show_details.tvdb_id, 'poster',
get_artwork_url(show_details.poster, thumbnail=True), thumbnail=True)
# Banner
if show_details.banner:
if not is_artwork_cached(self.show_indexer.name, show_details.tvdb_id, 'banner'):
cache_artwork(self.show_indexer.name, show_details.tvdb_id, 'banner',
get_artwork_url(show_details.banner))
if not is_artwork_cached(self.show_indexer.name, show_details.tvdb_id, 'banner',
thumbnail=True):
cache_artwork(self.show_indexer.name, show_details.tvdb_id, 'banner',
get_artwork_url(show_details.banner, thumbnail=True), thumbnail=True)
# Check episode details
if isinstance(wanted_item.episode, list):
for episode in wanted_item.episode:
self._update_episode_details(show_settings, dirname, filename, wanted_item.tvdbid,
wanted_item.season, episode)
else:
self._update_episode_details(show_settings, dirname, filename, wanted_item.tvdbid,
wanted_item.season, wanted_item.episode)
if wanted_item.is_movie:
# Do a force search if no imdb id found
if not wanted_item.imdbid:
wanted_item.imdbid, _ = self.movie_indexer.get_imdb_id_and_year(wanted_item.title,
year=wanted_item.year,
force_search=True)
# Skip if no imdb id is found
if not wanted_item.imdbid:
log.warning('Skipping movie file with unknown imdb id: %s', os.path.join(dirname, filename))
if not self.failed_movies_db.get_failed_movie(dirname):
self.failed_movies_db.set_failed_movie(dirname)
return
# Store default movie settings if not yet available
if not self.movie_settings_db.get_movie_settings(wanted_item.imdbid):
self.movie_settings_db.set_movie_settings(MovieSettings.default_settings(wanted_item.imdbid))
movie_settings = self.movie_settings_db.get_movie_settings(wanted_item.imdbid)
# Get movie details
movie_details = self.movie_db.get_movie(wanted_item.imdbid)
# Add movie to db if not yet in db
if not movie_details:
movie_details = self.movie_indexer.get_movie_details(wanted_item.imdbid)
if movie_details:
movie_details.path = dirname
self.movie_db.set_movie(movie_details)
# Cache artwork (fullsize and thumbnail) if not yet cached
if movie_details:
# Poster
if movie_details.poster:
if not is_artwork_cached(self.movie_indexer.name, movie_details.imdb_id, 'poster'):
cache_artwork(self.movie_indexer.name, movie_details.imdb_id, 'poster',
movie_details.poster)
if not is_artwork_cached(self.movie_indexer.name, movie_details.imdb_id, 'poster',
thumbnail=True):
cache_artwork(self.movie_indexer.name, movie_details.imdb_id, 'poster',
self.movie_indexer.get_artwork_thumbnail_url(movie_details.poster),
thumbnail=True)
# Check movie details
self._update_movie_details(movie_settings, dirname, filename, wanted_item.imdbid)
def walk_dir(path):
log.info("Scanning video path: %s" % path)
for dirname, dirnames, filenames in os.walk(os.path.join(path)):
log.debug("Directory: %s" % dirname)
# Check folders to be skipped
if autosubliminal.SKIPHIDDENDIRS and os.path.split(dirname)[1].startswith(u'.'):
continue
if re.search('_unpack_', dirname, re.IGNORECASE):
log.debug("Found a unpack directory, skipping")
continue
if re.search('_failed_', dirname, re.IGNORECASE):
log.debug("Found a failed directory, skipping")
continue
# Populate WANTEDQUEUE
for filename in filenames:
log.debug("File: %s" % filename)
root, ext = os.path.splitext(filename)
if ext and ext in subliminal.video.VIDEO_EXTENSIONS:
# Skip 'sample' videos
if re.search('sample', filename, re.IGNORECASE):
continue
# Check if there are missing subtitle languages for the video file
languages = check_missing_subtitle_languages(dirname, filename)
if len(languages) > 0:
log.debug("File is missing a subtitle")
wanted_item = fileprocessor.process_file(dirname, filename)
if wanted_item:
# Episode wanted
if wanted_item['type'] == 'episode':
title = wanted_item['title']
season = wanted_item['season']
episode = wanted_item['episode']
if utils.skip_show(title, season, episode):
log.info("Skipping %s - Season %s Episode %s" % (title, season, episode))
continue
log.info("Subtitle(s) wanted for %s and added to wantedQueue" % filename)
wanted_item['originalFileLocationOnDisk'] = os.path.join(dirname, filename)
wanted_item['time'] = os.path.getctime(wanted_item['originalFileLocationOnDisk'])
wanted_item['timestamp'] = unicode(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(
wanted_item['time'])))
wanted_item['lang'] = languages
wanted_item['tvdbid'] = utils.get_tvdb_id(title)
autosubliminal.WANTEDQUEUE.append(wanted_item)
# Movie wanted
elif wanted_item['type'] == 'movie':
title = wanted_item['title']
year = wanted_item['year']
if utils.skip_movie(title, year):
log.info("Skipping %s (%s)" % (title, year))
continue
log.info("Subtitle(s) wanted for %s and added to wantedQueue" % filename)
wanted_item['originalFileLocationOnDisk'] = os.path.join(dirname, filename)
wanted_item['time'] = os.path.getctime(wanted_item['originalFileLocationOnDisk'])
wanted_item['timestamp'] = unicode(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(
wanted_item['time'])))
wanted_item['lang'] = languages
wanted_item['imdbid'], wanted_item['year'] = utils.get_imdb_info(title, year)
autosubliminal.WANTEDQUEUE.append(wanted_item)
else:
log.error("Could not process the filename: %s" % filename)
continue
# Sort WANTEDQUEUE
autosubliminal.WANTEDQUEUE = sorted(autosubliminal.WANTEDQUEUE, key=itemgetter('time'), reverse=True)
def _scan_file(self, dirname, filename):
# Check if video file has already been processed before, so we don't need to process it again
wanted_item = self.wanted_db.get_wanted_item(os.path.join(dirname, filename))
if wanted_item:
log.debug('Video found in wanted_items database, no need to scan it again')
else:
log.debug('Video not found in wanted_items database, start scanning it')
# Process file
wanted_item = fileprocessor.process_file(dirname, filename)
if wanted_item:
# Determine wanted languages
wanted_languages = []
if wanted_item.is_episode and wanted_item.tvdbid:
settings = self.show_settings_db.get_show_settings(wanted_item.tvdbid)
if settings and settings.wanted_languages:
wanted_languages = settings.wanted_languages
elif wanted_item.is_movie and wanted_item.imdbid:
settings = self.movie_settings_db.get_movie_settings(wanted_item.imdbid)
if settings and settings.wanted_languages:
wanted_languages = settings.wanted_languages
# Check for missing subtitles (scan embedded and detect invalid if configured to do so)
languages = check_missing_subtitle_languages(dirname, filename,
scan_embedded=autosubliminal.SCANEMBEDDEDSUBS,
scan_hardcoded=autosubliminal.SCANHARDCODEDSUBS,
detect_invalid=autosubliminal.DETECTINVALIDSUBLANGUAGE,
wanted_languages=wanted_languages)
# Process the video file if there are missing subtitles
if len(languages) > 0:
# Add missing languages and store in wanted_items database
wanted_item.languages = languages
self.wanted_db.set_wanted_item(wanted_item)
else:
log.debug('Video has no missing subtitles')
return None
else:
return None
# Check if we need to skip it and delete it from the database
log.debug('Checking if the video needs to be skipped')
if wanted_item:
# Skip episode check
if wanted_item.is_episode:
title = wanted_item.title
season = wanted_item.season
if skip_show(title, season):
self.wanted_db.delete_wanted_item(wanted_item)
log.info('Skipping %s - Season %s', title, season)
return None
# Skip movie check
if wanted_item.is_movie:
title = wanted_item.title
year = wanted_item.year
if skip_movie(title, year):
self.wanted_db.delete_wanted_item(wanted_item)
log.info('Skipping %s (%s)', title, year)
return None
return wanted_item
def _scan_file(self, dirname, filename):
# Check if video file has already been processed before, so we don't need to process it again
wanted_item = self.wanted_db.get_wanted_item(
os.path.join(dirname, filename))
if wanted_item:
log.debug(
'Video found in wanted_items database, no need to scan it again'
)
else:
log.debug(
'Video not found in wanted_items database, start scanning it')
# Process file
wanted_item = fileprocessor.process_file(dirname, filename)
if wanted_item:
# Determine wanted languages
wanted_languages = []
if wanted_item.is_episode and wanted_item.tvdbid:
settings = self.show_settings_db.get_show_settings(
wanted_item.tvdbid)
if settings and settings.wanted_languages:
wanted_languages = settings.wanted_languages
elif wanted_item.is_movie and wanted_item.imdbid:
settings = self.movie_settings_db.get_movie_settings(
wanted_item.imdbid)
if settings and settings.wanted_languages:
wanted_languages = settings.wanted_languages
# Check for missing subtitles (scan embedded and detect invalid if configured to do so)
languages = check_missing_subtitle_languages(
dirname,
filename,
scan_embedded=autosubliminal.SCANEMBEDDEDSUBS,
scan_hardcoded=autosubliminal.SCANHARDCODEDSUBS,
detect_invalid=autosubliminal.DETECTINVALIDSUBLANGUAGE,
wanted_languages=wanted_languages)
# Process the video file if there are missing subtitles
if len(languages) > 0:
# Add missing languages and store in wanted_items database
wanted_item.languages = languages
self.wanted_db.set_wanted_item(wanted_item)
else:
log.debug('Video has no missing subtitles')
return None
else:
return None
# Check if we need to skip it and delete it from the database
log.debug('Checking if the video needs to be skipped')
if wanted_item:
# Skip episode check
if wanted_item.is_episode:
title = wanted_item.title
season = wanted_item.season
if skip_show(title, season):
self.wanted_db.delete_wanted_item(wanted_item)
log.info('Skipping %s - Season %s', title, season)
return None
# Skip movie check
if wanted_item.is_movie:
title = wanted_item.title
year = wanted_item.year
if skip_movie(title, year):
self.wanted_db.delete_wanted_item(wanted_item)
log.info('Skipping %s (%s)', title, year)
return None
return wanted_item
