def processEpisode(self, proc_dir=None, nzbName=None, jobName=None, quiet=None, process_method=None, force=None,
is_priority=None, delete_on='0', failed='0', proc_type='auto', ignore_subs=None, *args, **kwargs):
def argToBool(argument):
if isinstance(argument, string_types):
_arg = argument.strip().lower()
else:
_arg = argument
if _arg in ['1', 'on', 'true', True]:
return True
elif _arg in ['0', 'off', 'false', False]:
return False
return argument
if not proc_dir:
return self.redirect('/home/postprocess/')
else:
resource_name = ss(nzbName) if nzbName else None
result = process_tv.ProcessResult(ss(proc_dir), process_method=process_method).process(
resource_name=resource_name, force=argToBool(force), is_priority=argToBool(is_priority),
delete_on=argToBool(delete_on), failed=argToBool(failed), proc_type=type,
ignore_subs=argToBool(ignore_subs)
)
if quiet is not None and int(quiet) == 1:
return result
result = result.replace('\n', '<br>\n')
return self._genericMessage('Postprocessing results', result)
def unpack_rar_files(dirpath):
"""Unpack any existing rar files present in the specified dirpath.
:param dirpath: the directory path to be used
:type dirpath: str
"""
from medusa import process_tv
for root, _, files in os.walk(dirpath, topdown=False):
# Skip folders that are being used for unpacking
if u'_UNPACK' in root.upper():
continue
rar_files = [
rar_file for rar_file in files if is_rar_file(rar_file)
]
if rar_files and app.UNPACK:
video_files = [
video_file for video_file in files
if is_media_file(video_file)
]
if not video_files or root == app.TV_DOWNLOAD_DIR:
logger.debug(u'Found rar files in post-process folder: %s',
rar_files)
process_tv.ProcessResult(app.TV_DOWNLOAD_DIR).unrar(
root, rar_files, False)
elif rar_files and not app.UNPACK:
logger.warning(u'Unpack is disabled. Skipping: %s', rar_files)
def run(self, force=False):
"""Run the postprocessor.
:param force: Forces postprocessing run
:type force: bool
"""
from medusa import process_tv
self.amActive = True
try:
if not os.path.isdir(app.TV_DOWNLOAD_DIR):
logger.error(
u"Automatic post-processing attempted but directory doesn't exist: {folder}",
folder=app.TV_DOWNLOAD_DIR)
return
if not (force or os.path.isabs(app.TV_DOWNLOAD_DIR)):
logger.error(
u'Automatic post-processing attempted but directory is relative '
u'(and probably not what you really want to process): {folder}',
folder=app.TV_DOWNLOAD_DIR)
return
process_tv.ProcessResult(app.TV_DOWNLOAD_DIR,
app.PROCESS_METHOD).process(force=force)
finally:
self.amActive = False
def subtitles_download_in_pp(): # pylint: disable=too-many-locals, too-many-branches, too-many-statements
"""Check for needed subtitles in the post process folder."""
from medusa import process_tv
from medusa.tv import Episode
logger.info(u'Checking for needed subtitles in Post-Process folder')
# Check if PP folder is set
if not app.TV_DOWNLOAD_DIR or not os.path.isdir(app.TV_DOWNLOAD_DIR):
logger.warning(
u'You must set a valid post-process folder in "Post Processing" settings'
)
return
# Search for all wanted languages
if not wanted_languages():
return
SubtitlesFinder.unpack_rar_files(app.TV_DOWNLOAD_DIR)
run_post_process = False
for root, _, files in os.walk(app.TV_DOWNLOAD_DIR, topdown=False):
# Skip folders that are being used for unpacking
if u'_UNPACK' in root.upper():
continue
for filename in sorted(files):
# Delete unwanted subtitles before downloading new ones
delete_unwanted_subtitles(root, filename)
if not is_media_file(filename):
continue
video_path = os.path.join(root, filename)
tv_episode = Episode.from_filepath(video_path)
if not tv_episode:
logger.debug(u'%s cannot be parsed to an episode',
filename)
continue
if tv_episode.status not in (SNATCHED, SNATCHED_PROPER,
SNATCHED_BEST):
continue
if not tv_episode.series.subtitles:
logger.debug(
u'Subtitle disabled for show: %s. Running post-process to PP it',
filename)
run_post_process = True
continue
# Should not consider existing subtitles from db if it's a replacement
new_release_name = remove_extension(filename)
if tv_episode.release_name and new_release_name != tv_episode.release_name:
logger.debug(
u"As this is a release replacement I'm not going to consider existing "
u'subtitles or release name from database to refine the new release'
)
logger.debug(
u"Replacing old release name '%s' with new release name '%s'",
tv_episode.release_name, new_release_name)
tv_episode.subtitles = []
tv_episode.release_name = new_release_name
embedded_subtitles = bool(not app.IGNORE_EMBEDDED_SUBS
and video_path.endswith('.mkv'))
downloaded_languages = download_subtitles(
tv_episode,
video_path=video_path,
subtitles=False,
embedded_subtitles=embedded_subtitles)
# Don't run post processor unless at least one file has all of the needed subtitles OR
# if user don't want to ignore embedded subtitles and wants to consider 'unknown' as wanted sub,
# and .mkv has one.
if not app.PROCESS_AUTOMATICALLY and not run_post_process:
if not needs_subtitles(downloaded_languages):
run_post_process = True
elif not app.IGNORE_EMBEDDED_SUBS:
embedded_subs = get_embedded_subtitles(video_path)
run_post_process = accept_unknown(
embedded_subs) or accept_any(embedded_subs)
if run_post_process:
logger.info(
u'Starting post-process with default settings now that we found subtitles'
)
process_tv.ProcessResult(app.TV_DOWNLOAD_DIR,
app.PROCESS_METHOD).process()
