def _list_subtitles():
# list subtitles
with AsyncProviderPool(
providers=self.config.providers,
provider_configs=self.config.provider_configs) as pool:
subtitles = pool.list_subtitles(video, self.config.languages)
# fill the subtitle liststore
subtitle_liststore = builder.get_object('subtitle_liststore')
for s in subtitles:
scaled_score = compute_score(s, video)
scores = get_scores(video)
if s.hearing_impaired == self.config.hearing_impaired:
scaled_score -= scores['hearing_impaired']
scaled_score *= 100 / scores['hash']
subtitle_liststore.append([
s.id,
nice_language(s.language), scaled_score,
s.provider_name.capitalize(), s.hearing_impaired,
s.page_link, False
])
subtitle_liststore.set_sort_column_id(2, Gtk.SortType.DESCENDING)
# stop the spinner
spinner.stop()
# connect signals
builder.connect_signals(
ChooseHandler(self.config, video, subtitles, spinner))
def download_callback(self, menuitem, files):
# scan videos
videos = []
for f in files:
# ignore non-writable locations
if not f.can_write():
continue
# directories
if f.is_directory():
try:
scanned_videos = scan_videos(f.get_location().get_path())
except:
continue
for video in scanned_videos:
if check_video(video, languages=self.config.languages, age=self.config.age,
undefined=self.config.single):
video.subtitle_languages |= set(search_external_subtitles(video.name).values())
refine(video, episode_refiners=self.config.refiners, movie_refiners=self.config.refiners,
embedded_subtitles=self.config.embedded_subtitles)
videos.append(video)
continue
# other inputs
try:
video = scan_video(f.get_location().get_path())
except:
continue
if check_video(video, languages=self.config.languages, undefined=self.config.single):
video.subtitle_languages |= set(search_external_subtitles(video.name).values())
refine(video, episode_refiners=self.config.refiners, movie_refiners=self.config.refiners,
embedded_subtitles=self.config.embedded_subtitles)
videos.append(video)
# download best subtitles
downloaded_subtitles = defaultdict(list)
with AsyncProviderPool(providers=self.config.providers, provider_configs=self.config.provider_configs) as pool:
for v in videos:
scores = get_scores(v)
subtitles = pool.download_best_subtitles(
pool.list_subtitles(v, self.config.languages - v.subtitle_languages),
v, self.config.languages, min_score=scores['hash'] * self.config.min_score / 100,
hearing_impaired=self.config.hearing_impaired, only_one=self.config.single
)
downloaded_subtitles[v] = subtitles
# save subtitles
for v, subtitles in downloaded_subtitles.items():
save_subtitles(v, subtitles, single=self.config.single)
def _list_subtitles():
# list subtitles
with AsyncProviderPool(providers=self.config.providers,
provider_configs=self.config.provider_configs) as pool:
subtitles = pool.list_subtitles(video, self.config.languages)
# fill the subtitle liststore
subtitle_liststore = builder.get_object('subtitle_liststore')
for s in subtitles:
scaled_score = compute_score(s, video)
scores = get_scores(video)
if s.hearing_impaired == self.config.hearing_impaired:
scaled_score -= scores['hearing_impaired']
scaled_score *= 100 / scores['hash']
subtitle_liststore.append([s.id, nice_language(s.language), scaled_score, s.provider_name.capitalize(),
s.hearing_impaired, s.page_link, False])
subtitle_liststore.set_sort_column_id(2, Gtk.SortType.DESCENDING)
# stop the spinner
spinner.stop()
# connect signals
builder.connect_signals(ChooseHandler(self.config, video, subtitles, spinner))
def run(self,
scan_path,
scan_age,
languages,
encoding,
min_score,
providers,
provider_configs,
max_workers,
plex_url=None,
plex_token=None,
*args,
**kwargs):
if not os.path.isdir(scan_path):
raise IOError('Path \'%s\' doesn\'t exist!' % scan_path)
if not scan_age >= 1:
raise ValueError('\'scan_age\' must by at least 1!')
if not len(languages) >= 1:
raise ValueError('\'languages\' list can\'t be empty!')
if not providers:
raise ValueError('\'providers\' argument can\'t be empty!')
if not max_workers >= 1:
raise ValueError('\'max_workers\' must be at least 1!')
if not provider_configs:
provider_configs = {}
__tree_dict = lambda: defaultdict(__tree_dict)
result = __tree_dict()
encoding = codecs.lookup(encoding).name
age = timedelta(weeks=scan_age)
languages = set([Language(l) for l in languages])
plex = None
if plex_url and plex_token:
plex = PlexServer(plex_url, plex_token)
scan_start = datetime.now()
videos = []
ignored_videos = []
if not region.is_configured:
region.configure('dogpile.cache.dbm',
expiration_time=timedelta(days=30),
arguments={
'filename': 'subliminal.dbm',
'lock_factory': MutexLock
})
# scan videos
scanned_videos = scan_videos(scan_path, age=age)
for video in scanned_videos:
video.subtitle_languages |= set(
search_external_subtitles(video.name).values())
if check_video(video,
languages=languages,
age=age,
undefined=False):
refine(video)
if languages - video.subtitle_languages:
videos.append(video)
else:
ignored_videos.append(video)
else:
ignored_videos.append(video)
if videos:
result['videos']['collected'] = [
os.path.split(v.name)[1] for v in videos
]
if ignored_videos:
result['videos']['ignored'] = len(ignored_videos)
if videos:
# download best subtitles
downloaded_subtitles = defaultdict(list)
with AsyncProviderPool(max_workers=max_workers,
providers=providers,
provider_configs=provider_configs) as p:
for video in videos:
scores = get_scores(video)
subtitles_to_download = p.list_subtitles(
video, languages - video.subtitle_languages)
downloaded_subtitles[video] = p.download_best_subtitles(
subtitles_to_download,
video,
languages,
min_score=scores['hash'] * min_score / 100)
if p.discarded_providers:
result['providers']['discarded'] = list(
p.discarded_providers)
# filter subtitles
with TinyDB('subtitle_db.json') as db:
table = db.table('downloaded')
query = Query()
for video, subtitles in downloaded_subtitles.items():
discarded_subtitles = list()
discarded_subtitles_info = list()
for s in subtitles:
subtitle_hash = hashlib.sha256(s.content).hexdigest()
subtitle_file = get_subtitle_path(
os.path.split(video.name)[1], s.language)
dbo = {'hash': subtitle_hash, 'file': subtitle_file}
if table.search((query.hash == subtitle_hash)
& (query.file == subtitle_file)):
discarded_subtitles.append(s)
discarded_subtitles_info.append(dbo)
else:
table.insert(dbo)
downloaded_subtitles[video] = [
x for x in subtitles if x not in discarded_subtitles
]
if discarded_subtitles_info:
result['subtitles'][
'discarded'] = result['subtitles'].get(
'discarded', []) + discarded_subtitles_info
downloaded_subtitles = {
k: v
for k, v in downloaded_subtitles.items() if v
}
# save subtitles
saved_subtitles = {}
for video, subtitles in downloaded_subtitles.items():
saved_subtitles[video] = save_subtitles(video,
subtitles,
directory=None,
encoding=encoding)
for key, group in groupby(saved_subtitles[video],
lambda x: x.provider_name):
subtitle_filenames = [
get_subtitle_path(
os.path.split(video.name)[1], s.language)
for s in list(group)
]
result['subtitles'][key] = result['subtitles'].get(
key, []) + subtitle_filenames
result['subtitles']['total'] = sum(
len(v) for v in saved_subtitles.values())
# refresh plex
for video, subtitles in saved_subtitles.items():
if plex and subtitles:
item_found = False
for section in plex.library.sections():
try:
if isinstance(section,
MovieSection) and isinstance(
video, Movie):
results = section.search(title=video.title,
year=video.year,
libtype='movie',
sort='addedAt:desc',
maxresults=1)
if not results:
raise NotFound
plex_item = results[0]
elif isinstance(section,
ShowSection) and isinstance(
video, Episode):
results = section.search(title=video.series,
year=video.year,
libtype='show',
sort='addedAt:desc',
maxresults=1)
if not results:
raise NotFound
plex_item = results[0].episode(
season=video.season, episode=video.episode)
else:
continue
except NotFound:
continue
except BadRequest:
continue
if plex_item:
plex_item.refresh()
result['plex']['refreshed'] = result['plex'].get(
'refreshed', []) + [
'%s%s' %
(repr(plex_item.section()), repr(video))
]
item_found = True
if not item_found:
result['plex']['failed'] = result['plex'].get(
'failed', []) + [repr(video)]
# convert subtitles
for video, subtitles in saved_subtitles.items():
target_format = aeidon.formats.SUBRIP
for s in subtitles:
subtitle_path = get_subtitle_path(video.name, s.language)
source_format = aeidon.util.detect_format(
subtitle_path, encoding)
source_file = aeidon.files.new(
source_format, subtitle_path,
aeidon.encodings.detect_bom(subtitle_path) or encoding)
if source_format != target_format:
format_info = {
'file':
get_subtitle_path(
os.path.split(video.name)[1], s.language),
'from':
source_format.label,
'to':
target_format.label
}
result['subtitles'][
'converted'] = result['subtitles'].get(
'converted', []) + [format_info]
aeidon_subtitles = source_file.read()
for f in [
aeidon.formats.SUBRIP, aeidon.formats.MICRODVD,
aeidon.formats.MPL2
]:
markup = aeidon.markups.new(f)
for s in aeidon_subtitles:
s.main_text = markup.decode(s.main_text)
markup = aeidon.markups.new(target_format)
for s in aeidon_subtitles:
s.main_text = markup.encode(s.main_text)
target_file = aeidon.files.new(target_format,
subtitle_path, encoding)
target_file.write(aeidon_subtitles, aeidon.documents.MAIN)
scan_end = datetime.now()
result['meta']['start'] = scan_start.isoformat()
result['meta']['end'] = scan_end.isoformat()
result['meta']['duration'] = str(scan_end - scan_start)
return result
def download(
obj,
provider,
language,
age,
directory,
encoding,
single,
force,
hearing_impaired,
min_score,
max_workers,
verbose,
path,
):
"""Download best subtitles.
PATH can be an directory containing videos, a video file path or a video file name. It can be used multiple times.
If an existing subtitle is detected (external or embedded) in the correct language, the download is skipped for
the associated video.
"""
# process parameters
language = set(language)
# scan videos
videos = []
ignored_videos = []
errored_paths = []
with click.progressbar(path, label="Collecting videos", item_show_func=lambda p: p or "") as bar:
for p in bar:
logger.debug("Collecting path %s", p)
# non-existing
if not os.path.exists(p):
try:
video = Video.fromname(p)
except:
logger.exception("Unexpected error while collecting non-existing path %s", p)
errored_paths.append(p)
continue
videos.append(video)
continue
# directories
if os.path.isdir(p):
try:
scanned_videos = scan_videos(
p, subtitles=not force, embedded_subtitles=not force, subtitles_dir=directory, age=age
)
except:
logger.exception("Unexpected error while collecting directory path %s", p)
errored_paths.append(p)
continue
for video in scanned_videos:
if check_video(video, languages=language, age=age, undefined=single):
videos.append(video)
else:
ignored_videos.append(video)
continue
# other inputs
try:
video = scan_video(p, subtitles=not force, embedded_subtitles=not force, subtitles_dir=directory)
except:
logger.exception("Unexpected error while collecting path %s", p)
errored_paths.append(p)
continue
if check_video(video, languages=language, age=age, undefined=single):
videos.append(video)
else:
ignored_videos.append(video)
# output errored paths
if verbose > 0:
for p in errored_paths:
click.secho("%s errored" % p, fg="red")
# output ignored videos
if verbose > 1:
for video in ignored_videos:
click.secho(
"%s ignored - subtitles: %s / age: %d day%s"
% (
os.path.split(video.name)[1],
", ".join(str(s) for s in video.subtitle_languages) or "none",
video.age.days,
"s" if video.age.days > 1 else "",
),
fg="yellow",
)
# report collected videos
click.echo(
"%s video%s collected / %s video%s ignored / %s error%s"
% (
click.style(str(len(videos)), bold=True, fg="green" if videos else None),
"s" if len(videos) > 1 else "",
click.style(str(len(ignored_videos)), bold=True, fg="yellow" if ignored_videos else None),
"s" if len(ignored_videos) > 1 else "",
click.style(str(len(errored_paths)), bold=True, fg="red" if errored_paths else None),
"s" if len(errored_paths) > 1 else "",
)
)
# exit if no video collected
if not videos:
return
# download best subtitles
downloaded_subtitles = defaultdict(list)
with AsyncProviderPool(max_workers=max_workers, providers=provider, provider_configs=obj["provider_configs"]) as p:
with click.progressbar(
videos,
label="Downloading subtitles",
item_show_func=lambda v: os.path.split(v.name)[1] if v is not None else "",
) as bar:
for v in bar:
scores = get_scores(v)
subtitles = p.download_best_subtitles(
p.list_subtitles(v, language - v.subtitle_languages),
v,
language,
min_score=scores["hash"] * min_score / 100,
hearing_impaired=hearing_impaired,
only_one=single,
)
downloaded_subtitles[v] = subtitles
# TODO: warn about discarded providers
# save subtitles
total_subtitles = 0
for v, subtitles in downloaded_subtitles.items():
saved_subtitles = save_subtitles(v, subtitles, single=single, directory=directory, encoding=encoding)
total_subtitles += len(saved_subtitles)
if verbose > 0:
click.echo(
"%s subtitle%s downloaded for %s"
% (
click.style(str(len(saved_subtitles)), bold=True),
"s" if len(saved_subtitles) > 1 else "",
os.path.split(v.name)[1],
)
)
if verbose > 1:
for s in saved_subtitles:
matches = s.get_matches(v)
score = compute_score(s, v)
# score color
score_color = None
scores = get_scores(v)
if isinstance(v, Movie):
if score < scores["title"]:
score_color = "red"
elif score < scores["title"] + scores["year"] + scores["release_group"]:
score_color = "yellow"
else:
score_color = "green"
elif isinstance(v, Episode):
if score < scores["series"] + scores["season"] + scores["episode"]:
score_color = "red"
elif score < scores["series"] + scores["season"] + scores["episode"] + scores["release_group"]:
score_color = "yellow"
else:
score_color = "green"
# scale score from 0 to 100 taking out preferences
scaled_score = score
if s.hearing_impaired == hearing_impaired:
scaled_score -= scores["hearing_impaired"]
scaled_score *= 100 / scores["hash"]
# echo some nice colored output
click.echo(
" - [{score}] {language} subtitle from {provider_name} (match on {matches})".format(
score=click.style("{:5.1f}".format(scaled_score), fg=score_color, bold=score >= scores["hash"]),
language=s.language.name
if s.language.country is None
else "%s (%s)" % (s.language.name, s.language.country.name),
provider_name=s.provider_name,
matches=", ".join(sorted(matches, key=scores.get, reverse=True)),
)
)
if verbose == 0:
click.echo(
"Downloaded %s subtitle%s"
% (click.style(str(total_subtitles), bold=True), "s" if total_subtitles > 1 else "")
)
def download(obj, provider, refiner, language, age, directory, encoding,
single, force, hearing_impaired, min_score, max_workers, archives,
verbose, path):
"""Download best subtitles.
PATH can be an directory containing videos, a video file path or a video file name. It can be used multiple times.
If an existing subtitle is detected (external or embedded) in the correct language, the download is skipped for
the associated video.
"""
# process parameters
language = set(language)
# scan videos
videos = []
ignored_videos = []
errored_paths = []
with click.progressbar(path,
label='Collecting videos',
item_show_func=lambda p: p or '') as bar:
for p in bar:
logger.debug('Collecting path %s', p)
# non-existing
if not os.path.exists(p):
try:
video = Video.fromname(p)
except:
logger.exception(
'Unexpected error while collecting non-existing path %s',
p)
errored_paths.append(p)
continue
if not force:
video.subtitle_languages |= set(
search_external_subtitles(
video.name, directory=directory).values())
refine(video,
episode_refiners=refiner,
movie_refiners=refiner,
embedded_subtitles=not force)
videos.append(video)
continue
# directories
if os.path.isdir(p):
try:
scanned_videos = scan_videos(p, age=age, archives=archives)
except:
logger.exception(
'Unexpected error while collecting directory path %s',
p)
errored_paths.append(p)
continue
for video in scanned_videos:
if check_video(video,
languages=language,
age=age,
undefined=single):
if not force:
video.subtitle_languages |= set(
search_external_subtitles(
video.name, directory=directory).values())
refine(video,
episode_refiners=refiner,
movie_refiners=refiner,
embedded_subtitles=not force)
videos.append(video)
else:
ignored_videos.append(video)
continue
# other inputs
try:
video = scan_video(p)
except:
logger.exception('Unexpected error while collecting path %s',
p)
errored_paths.append(p)
continue
if check_video(video,
languages=language,
age=age,
undefined=single):
if not force:
video.subtitle_languages |= set(
search_external_subtitles(
video.name, directory=directory).values())
refine(video,
episode_refiners=refiner,
movie_refiners=refiner,
embedded_subtitles=not force)
videos.append(video)
else:
ignored_videos.append(video)
# output errored paths
if verbose > 0:
for p in errored_paths:
click.secho('%s errored' % p, fg='red')
# output ignored videos
if verbose > 1:
for video in ignored_videos:
click.secho(
'%s ignored - subtitles: %s / age: %d day%s' %
(os.path.split(video.name)[1],
', '.join(str(s) for s in video.subtitle_languages)
or 'none', video.age.days, 's' if video.age.days > 1 else ''),
fg='yellow')
# report collected videos
click.echo('%s video%s collected / %s video%s ignored / %s error%s' % (
click.style(
str(len(videos)), bold=True, fg='green' if videos else None),
's' if len(videos) > 1 else '',
click.style(str(len(ignored_videos)),
bold=True,
fg='yellow' if ignored_videos else None),
's' if len(ignored_videos) > 1 else '',
click.style(str(len(errored_paths)),
bold=True,
fg='red' if errored_paths else None),
's' if len(errored_paths) > 1 else '',
))
# exit if no video collected
if not videos:
return
# download best subtitles
downloaded_subtitles = defaultdict(list)
with AsyncProviderPool(max_workers=max_workers,
providers=provider,
provider_configs=obj['provider_configs']) as p:
with click.progressbar(
videos,
label='Downloading subtitles',
item_show_func=lambda v: os.path.split(v.name)[1]
if v is not None else '') as bar:
for v in bar:
scores = get_scores(v)
subtitles = p.download_best_subtitles(
p.list_subtitles(v, language - v.subtitle_languages),
v,
language,
min_score=scores['hash'] * min_score / 100,
hearing_impaired=hearing_impaired,
only_one=single)
downloaded_subtitles[v] = subtitles
if p.discarded_providers:
click.secho(
'Some providers have been discarded due to unexpected errors: %s'
% ', '.join(p.discarded_providers),
fg='yellow')
# save subtitles
total_subtitles = 0
for v, subtitles in downloaded_subtitles.items():
saved_subtitles = save_subtitles(v,
subtitles,
single=single,
directory=directory,
encoding=encoding)
total_subtitles += len(saved_subtitles)
if verbose > 0:
click.echo(
'%s subtitle%s downloaded for %s' %
(click.style(str(len(saved_subtitles)), bold=True), 's' if
len(saved_subtitles) > 1 else '', os.path.split(v.name)[1]))
if verbose > 1:
for s in saved_subtitles:
matches = s.get_matches(v)
score = compute_score(s, v)
# score color
score_color = None
scores = get_scores(v)
if isinstance(v, Movie):
if score < scores['title']:
score_color = 'red'
elif score < scores['title'] + scores['year'] + scores[
'release_group']:
score_color = 'yellow'
else:
score_color = 'green'
elif isinstance(v, Episode):
if score < scores['series'] + scores['season'] + scores[
'episode']:
score_color = 'red'
elif score < scores['series'] + scores['season'] + scores[
'episode'] + scores['release_group']:
score_color = 'yellow'
else:
score_color = 'green'
# scale score from 0 to 100 taking out preferences
scaled_score = score
if s.hearing_impaired == hearing_impaired:
scaled_score -= scores['hearing_impaired']
scaled_score *= 100 / scores['hash']
# echo some nice colored output
click.echo(
' - [{score}] {language} subtitle from {provider_name} (match on {matches})'
.format(score=click.style('{:5.1f}'.format(scaled_score),
fg=score_color,
bold=score >= scores['hash']),
language=s.language.name
if s.language.country is None else '%s (%s)' %
(s.language.name, s.language.country.name),
provider_name=s.provider_name,
matches=', '.join(
sorted(matches, key=scores.get,
reverse=True))))
if verbose == 0:
click.echo('Downloaded %s subtitle%s' %
(click.style(str(total_subtitles), bold=True),
's' if total_subtitles > 1 else ''))
def download_callback(self, menuitem, files):
# scan videos
videos = []
for f in files:
# ignore non-writable locations
if not f.can_write():
continue
# directories
if f.is_directory():
try:
scanned_videos = scan_videos(f.get_location().get_path())
except:
continue
for video in scanned_videos:
if check_video(video,
languages=self.config.languages,
age=self.config.age,
undefined=self.config.single):
video.subtitle_languages |= set(
search_external_subtitles(video.name).values())
refine(
video,
episode_refiners=self.config.refiners,
movie_refiners=self.config.refiners,
embedded_subtitles=self.config.embedded_subtitles)
videos.append(video)
continue
# other inputs
try:
video = scan_video(f.get_location().get_path())
except:
continue
if check_video(video,
languages=self.config.languages,
undefined=self.config.single):
video.subtitle_languages |= set(
search_external_subtitles(video.name).values())
refine(video,
episode_refiners=self.config.refiners,
movie_refiners=self.config.refiners,
embedded_subtitles=self.config.embedded_subtitles)
videos.append(video)
# download best subtitles
downloaded_subtitles = defaultdict(list)
with AsyncProviderPool(
providers=self.config.providers,
provider_configs=self.config.provider_configs) as pool:
for v in videos:
scores = get_scores(v)
subtitles = pool.download_best_subtitles(
pool.list_subtitles(
v, self.config.languages - v.subtitle_languages),
v,
self.config.languages,
min_score=scores['hash'] * self.config.min_score / 100,
hearing_impaired=self.config.hearing_impaired,
only_one=self.config.single)
downloaded_subtitles[v] = subtitles
# save subtitles
for v, subtitles in downloaded_subtitles.items():
save_subtitles(v, subtitles, single=self.config.single)
def download(obj, provider, refiner, language, age, directory, encoding, single, force, hearing_impaired, min_score,
max_workers, archives, verbose, path):
"""Download best subtitles.
PATH can be an directory containing videos, a video file path or a video file name. It can be used multiple times.
If an existing subtitle is detected (external or embedded) in the correct language, the download is skipped for
the associated video.
"""
# process parameters
language = set(language)
# scan videos
videos = []
ignored_videos = []
errored_paths = []
with click.progressbar(path, label='Collecting videos', item_show_func=lambda p: p or '') as bar:
for p in bar:
logger.debug('Collecting path %s', p)
# non-existing
if not os.path.exists(p):
try:
video = Video.fromname(p)
except:
logger.exception('Unexpected error while collecting non-existing path %s', p)
errored_paths.append(p)
continue
if not force:
video.subtitle_languages |= set(search_external_subtitles(video.name, directory=directory).values())
refine(video, episode_refiners=refiner, movie_refiners=refiner, embedded_subtitles=not force)
videos.append(video)
continue
# directories
if os.path.isdir(p):
try:
scanned_videos = scan_videos(p, age=age, archives=archives)
except:
logger.exception('Unexpected error while collecting directory path %s', p)
errored_paths.append(p)
continue
for video in scanned_videos:
if not force:
video.subtitle_languages |= set(search_external_subtitles(video.name,
directory=directory).values())
if check_video(video, languages=language, age=age, undefined=single):
refine(video, episode_refiners=refiner, movie_refiners=refiner, embedded_subtitles=not force)
videos.append(video)
else:
ignored_videos.append(video)
continue
# other inputs
try:
video = scan_video(p)
except:
logger.exception('Unexpected error while collecting path %s', p)
errored_paths.append(p)
continue
if not force:
video.subtitle_languages |= set(search_external_subtitles(video.name, directory=directory).values())
if check_video(video, languages=language, age=age, undefined=single):
refine(video, episode_refiners=refiner, movie_refiners=refiner, embedded_subtitles=not force)
videos.append(video)
else:
ignored_videos.append(video)
# output errored paths
if verbose > 0:
for p in errored_paths:
click.secho('%s errored' % p, fg='red')
# output ignored videos
if verbose > 1:
for video in ignored_videos:
click.secho('%s ignored - subtitles: %s / age: %d day%s' % (
os.path.split(video.name)[1],
', '.join(str(s) for s in video.subtitle_languages) or 'none',
video.age.days,
's' if video.age.days > 1 else ''
), fg='yellow')
# report collected videos
click.echo('%s video%s collected / %s video%s ignored / %s error%s' % (
click.style(str(len(videos)), bold=True, fg='green' if videos else None),
's' if len(videos) > 1 else '',
click.style(str(len(ignored_videos)), bold=True, fg='yellow' if ignored_videos else None),
's' if len(ignored_videos) > 1 else '',
click.style(str(len(errored_paths)), bold=True, fg='red' if errored_paths else None),
's' if len(errored_paths) > 1 else '',
))
# exit if no video collected
if not videos:
return
# download best subtitles
downloaded_subtitles = defaultdict(list)
with AsyncProviderPool(max_workers=max_workers, providers=provider, provider_configs=obj['provider_configs']) as p:
with click.progressbar(videos, label='Downloading subtitles',
item_show_func=lambda v: os.path.split(v.name)[1] if v is not None else '') as bar:
for v in bar:
scores = get_scores(v)
subtitles = p.download_best_subtitles(p.list_subtitles(v, language - v.subtitle_languages),
v, language, min_score=scores['hash'] * min_score / 100,
hearing_impaired=hearing_impaired, only_one=single)
downloaded_subtitles[v] = subtitles
if p.discarded_providers:
click.secho('Some providers have been discarded due to unexpected errors: %s' %
', '.join(p.discarded_providers), fg='yellow')
# save subtitles
total_subtitles = 0
for v, subtitles in downloaded_subtitles.items():
saved_subtitles = save_subtitles(v, subtitles, single=single, directory=directory, encoding=encoding)
total_subtitles += len(saved_subtitles)
if verbose > 0:
click.echo('%s subtitle%s downloaded for %s' % (click.style(str(len(saved_subtitles)), bold=True),
's' if len(saved_subtitles) > 1 else '',
os.path.split(v.name)[1]))
if verbose > 1:
for s in saved_subtitles:
matches = s.get_matches(v)
score = compute_score(s, v)
# score color
score_color = None
scores = get_scores(v)
if isinstance(v, Movie):
if score < scores['title']:
score_color = 'red'
elif score < scores['title'] + scores['year'] + scores['release_group']:
score_color = 'yellow'
else:
score_color = 'green'
elif isinstance(v, Episode):
if score < scores['series'] + scores['season'] + scores['episode']:
score_color = 'red'
elif score < scores['series'] + scores['season'] + scores['episode'] + scores['release_group']:
score_color = 'yellow'
else:
score_color = 'green'
# scale score from 0 to 100 taking out preferences
scaled_score = score
if s.hearing_impaired == hearing_impaired:
scaled_score -= scores['hearing_impaired']
scaled_score *= 100 / scores['hash']
# echo some nice colored output
click.echo(' - [{score}] {language} subtitle from {provider_name} (match on {matches})'.format(
score=click.style('{:5.1f}'.format(scaled_score), fg=score_color, bold=score >= scores['hash']),
language=s.language.name if s.language.country is None else '%s (%s)' % (s.language.name,
s.language.country.name),
provider_name=s.provider_name,
matches=', '.join(sorted(matches, key=scores.get, reverse=True))
))
if verbose == 0:
click.echo('Downloaded %s subtitle%s' % (click.style(str(total_subtitles), bold=True),
's' if total_subtitles > 1 else ''))