mirror of
https://github.com/SickGear/SickGear.git
synced 2024-12-25 12:13:38 +00:00
1189 lines
50 KiB
Python
1189 lines
50 KiB
Python
#
|
|
# This file is part of SickGear.
|
|
#
|
|
# SickGear is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# SickGear is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with SickGear. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from datetime import datetime, timezone
|
|
from functools import partial
|
|
import os
|
|
import re
|
|
import shutil
|
|
import stat
|
|
import sys
|
|
|
|
import exceptions_helper
|
|
from exceptions_helper import ex, MultipleShowObjectsException
|
|
from json_helper import json_dumps, json_loads
|
|
|
|
import sickgear
|
|
from . import common, db, failedProcessor, helpers, logger, notifiers, postProcessor
|
|
from .common import SNATCHED_ANY
|
|
from .history import reset_status
|
|
from .name_parser.parser import InvalidNameException, InvalidShowException, NameParser
|
|
from .sgdatetime import SGDatetime
|
|
|
|
from six import iteritems, iterkeys, string_types, text_type
|
|
from sg_helpers import long_path, scantree
|
|
|
|
import lib.rarfile.rarfile as rarfile
|
|
|
|
# noinspection PyUnreachableCode
|
|
if False:
|
|
from typing import Any, AnyStr, Dict, List, Optional, Tuple
|
|
from .tv import TVShow
|
|
|
|
|
|
# noinspection PyArgumentList
|
|
class ProcessTVShow(object):
|
|
""" Process a TV Show """
|
|
|
|
def __init__(self, webhandler=None, is_basedir=True, skip_failure_processing=False, client=None):
|
|
self.files_passed = 0 # type: int
|
|
self.files_failed = 0 # type: int
|
|
self.fail_detected = False # type: bool
|
|
self.skip_failure_processing = skip_failure_processing # type: bool
|
|
self._output = [] # type: List
|
|
self.webhandler = webhandler
|
|
self.is_basedir = is_basedir # type: bool
|
|
self.client = client # type: Optional[AnyStr]
|
|
|
|
@property
|
|
def any_vid_processed(self):
|
|
"""
|
|
:rtype: bool
|
|
"""
|
|
return 0 < self.files_passed
|
|
|
|
@property
|
|
def result(self, pre=True):
|
|
# type: (bool) -> AnyStr
|
|
return (('<br>', '\n')[pre]).join(self._output)
|
|
|
|
def _buffer(self, text=None):
|
|
if None is not text:
|
|
self._output.append(text)
|
|
if self.webhandler:
|
|
logger_msg = re.sub(r'(?i)<br[\s/]+>', '\n', text)
|
|
logger_msg = re.sub('(?i)<a[^>]+>([^<]+)</a>', r'\1', logger_msg)
|
|
self.webhandler('%s%s' % (logger_msg, '\n'))
|
|
|
|
def _log_helper(self, message, log_level=logger.DEBUG):
|
|
"""
|
|
|
|
:param message: log message
|
|
:type message: AnyStr
|
|
:param log_level: log level
|
|
:type log_level: int
|
|
"""
|
|
logger_msg = re.sub(r'(?i)<br[\s/]+>\.*', '', message)
|
|
logger_msg = re.sub('(?i)<a[^>]+>([^<]+)</a>', r'\1', logger_msg)
|
|
logger.log(f'{logger_msg}', log_level)
|
|
self._buffer(message)
|
|
return
|
|
|
|
def _set_process_success(self, state=True, reset=False):
|
|
"""
|
|
|
|
:param state:
|
|
:type state: bool
|
|
:param reset:
|
|
:type reset: bool
|
|
"""
|
|
if state:
|
|
self.files_passed += 1
|
|
else:
|
|
self.files_failed += 1
|
|
if reset:
|
|
self.files_passed = 0
|
|
self.files_failed = 0
|
|
|
|
def _delete_folder(self, folder, check_empty=True):
|
|
"""
|
|
|
|
:param folder: folder
|
|
:type folder: AnyStr
|
|
:param check_empty: check if folder is empty
|
|
:type check_empty: bool
|
|
:return: success
|
|
:rtype: bool
|
|
"""
|
|
# check if it's a folder
|
|
if not folder or not os.path.isdir(folder):
|
|
return False
|
|
|
|
# make sure it isn't TV_DOWNLOAD_DIR
|
|
if sickgear.TV_DOWNLOAD_DIR and helpers.real_path(sickgear.TV_DOWNLOAD_DIR) == helpers.real_path(folder):
|
|
return False
|
|
|
|
# test if folder empty when check wanted
|
|
if check_empty and len([direntry.path for direntry in scantree(folder, recurse=False)]):
|
|
return False
|
|
|
|
# try deleting folder
|
|
try:
|
|
shutil.rmtree(folder)
|
|
except (OSError, IOError) as e:
|
|
logger.warning(f'Warning: unable to delete folder: {folder}: {ex(e)}')
|
|
return False
|
|
|
|
if os.path.isdir(folder):
|
|
logger.warning(f'Warning: unable to delete folder: {folder}')
|
|
return False
|
|
|
|
self._log_helper(f'Deleted folder {folder}', logger.MESSAGE)
|
|
return True
|
|
|
|
def _delete_files(self, process_path, notwanted_files, force=False):
|
|
# type: (AnyStr, List[AnyStr], bool) -> Optional[bool]
|
|
"""
|
|
|
|
:param process_path: path
|
|
:param notwanted_files: list of unwanted files
|
|
:param force:
|
|
"""
|
|
if not self.any_vid_processed and not force:
|
|
return
|
|
|
|
result = True
|
|
# Delete all file not needed
|
|
for cur_file in notwanted_files:
|
|
|
|
cur_file_path = os.path.join(process_path, cur_file)
|
|
|
|
if not os.path.isfile(cur_file_path):
|
|
continue # Prevent error when a notwantedfiles is an associated files
|
|
|
|
# check first the read-only attribute
|
|
file_attribute = os.stat(cur_file_path)[0]
|
|
if not file_attribute & stat.S_IWRITE:
|
|
# File is read-only, so make it writeable
|
|
self._log_helper(f'Changing ReadOnly flag for file {cur_file}')
|
|
try:
|
|
os.chmod(cur_file_path, stat.S_IWRITE)
|
|
except OSError as e:
|
|
self._log_helper(f'Cannot change permissions of {cur_file_path}: {ex(e)}')
|
|
|
|
removal_type = helpers.remove_file(cur_file_path)
|
|
|
|
if os.path.isfile(cur_file_path):
|
|
result = False
|
|
else:
|
|
self._log_helper(f'{removal_type} file {cur_file}')
|
|
|
|
return result
|
|
|
|
def check_name(self, name):
|
|
# type: (AnyStr) -> Optional[sickgear.tv.TVShow]
|
|
"""
|
|
|
|
:param name: name
|
|
:return: None or show object
|
|
"""
|
|
if self.is_basedir:
|
|
return None
|
|
|
|
show_obj = None
|
|
my_db = db.DBConnection()
|
|
# noinspection SqlResolve
|
|
sql_result = my_db.select(
|
|
'SELECT indexer, showid'
|
|
' FROM history' +
|
|
' WHERE resource = ?' +
|
|
' AND (%s)' % ' OR '.join(['action LIKE "%%%02d"' % x for x in SNATCHED_ANY]) +
|
|
' ORDER BY rowid', [name])
|
|
if sql_result:
|
|
try:
|
|
show_obj = helpers.find_show_by_id({int(sql_result[-1]['indexer']): int(sql_result[-1]['showid'])},
|
|
check_multishow=True)
|
|
if hasattr(show_obj, 'name'):
|
|
logger.debug('Found Show: %s in snatch history for: %s' % (show_obj.name, name))
|
|
except MultipleShowObjectsException:
|
|
show_obj = None
|
|
return show_obj
|
|
|
|
def show_obj_helper(self, show_obj, base_dir, dir_name, nzb_name, pp_type, alt_show_obj=None):
|
|
"""
|
|
|
|
:param show_obj: show object
|
|
:type show_obj: sickgear.tv.TVShow or None
|
|
:param base_dir: base dir
|
|
:type base_dir: AnyStr
|
|
:param dir_name: dir name
|
|
:type dir_name: AnyStr
|
|
:param nzb_name: nzb name
|
|
:type nzb_name: AnyStr
|
|
:param pp_type: post processing type
|
|
:type pp_type: AnyStr
|
|
:param alt_show_obj:
|
|
:type alt_show_obj: sickgear.tv.TVShow or None
|
|
:return: show object or None
|
|
:rtype: sickgear.tv.TVShow or None
|
|
"""
|
|
if None is show_obj and base_dir == sickgear.TV_DOWNLOAD_DIR and not nzb_name or 'manual' == pp_type:
|
|
# Scheduled Media Process Active
|
|
return self.check_name(dir_name)
|
|
return (show_obj, alt_show_obj)[None is show_obj and None is not alt_show_obj]
|
|
|
|
def check_video_filenames(self, path, videofiles):
|
|
# type: (AnyStr, List[AnyStr]) -> Optional[sickgear.tv.TVShow]
|
|
"""
|
|
|
|
:param path: path
|
|
:param videofiles: list of video files
|
|
"""
|
|
if self.is_basedir:
|
|
return
|
|
|
|
video_pick = None
|
|
video_size = 0
|
|
for cur_video_file in videofiles:
|
|
try:
|
|
cur_video_size = os.path.getsize(os.path.join(path, cur_video_file))
|
|
except (BaseException, Exception):
|
|
continue
|
|
|
|
if 0 == video_size or cur_video_size > video_size:
|
|
video_size = cur_video_size
|
|
video_pick = cur_video_file
|
|
|
|
if video_pick:
|
|
vid_filename = os.path.splitext(video_pick)[0]
|
|
# check if filename is garbage, disregard it
|
|
if re.search(r'^[a-zA-Z0-9]+$', vid_filename):
|
|
return
|
|
|
|
return self.check_name(vid_filename)
|
|
|
|
@staticmethod
|
|
def find_parent(path):
|
|
"""
|
|
Test path is inside a parent folder
|
|
|
|
:param path: Path to check
|
|
:type path: AnyStr
|
|
:return: Parent root dir that matches path, or None
|
|
:rtype: AnyStr or None
|
|
"""
|
|
build_path = (lambda old_path: '%s%s' % (helpers.real_path(old_path).rstrip(os.path.sep), os.path.sep))
|
|
|
|
process_path = build_path(path)
|
|
for parent in map(lambda p: build_path(p), sickgear.ROOT_DIRS.split('|')[1:]):
|
|
if process_path.startswith(parent):
|
|
return parent.rstrip(os.path.sep)
|
|
|
|
def process_dir(self, dir_name, nzb_name=None, process_method=None, force=False, force_replace=None,
|
|
failed=False, pp_type='auto', cleanup=False, show_obj=None):
|
|
"""
|
|
Scans through the files in dir_name and processes whatever media files it finds
|
|
|
|
:param dir_name: The folder name to look in
|
|
:type dir_name: AnyStr
|
|
:param nzb_name: The NZB name which resulted in this folder being downloaded
|
|
:type nzb_name: AnyStr or None
|
|
:param process_method: processing method
|
|
:type process_method: AnyStr
|
|
:param force: True to postprocess already postprocessed files
|
|
:type force: bool
|
|
:param force_replace:
|
|
:type force_replace: bool
|
|
:param failed: Boolean for whether or not the download failed
|
|
:type failed: bool
|
|
:param pp_type: Type of postprocessing auto or manual
|
|
:type pp_type: AnyStr
|
|
:param cleanup:
|
|
:type cleanup: bool
|
|
:param show_obj: show object
|
|
:type show_obj: sickgear.tv.TVShow or None
|
|
:return:
|
|
:rtype: AnyStr
|
|
"""
|
|
|
|
# if they passed us a real directory then assume it's the one we want
|
|
if dir_name and os.path.isdir(long_path(dir_name)):
|
|
dir_name = long_path(os.path.realpath(long_path(dir_name)))
|
|
|
|
# if the client and SickGear are not on the same machine translate the directory in a network directory
|
|
elif dir_name and sickgear.TV_DOWNLOAD_DIR and os.path.isdir(sickgear.TV_DOWNLOAD_DIR)\
|
|
and os.path.normpath(dir_name) != os.path.normpath(sickgear.TV_DOWNLOAD_DIR):
|
|
dir_name = os.path.join(sickgear.TV_DOWNLOAD_DIR, os.path.abspath(dir_name).split(os.path.sep)[-1])
|
|
self._log_helper(f'SickGear PP Config, completed TV downloads folder: {sickgear.TV_DOWNLOAD_DIR}')
|
|
|
|
if dir_name:
|
|
self._log_helper(f'Checking folder... {dir_name}')
|
|
|
|
# if we didn't find a real directory then process "failed" or just quit
|
|
if not dir_name or not os.path.isdir(dir_name):
|
|
if nzb_name and failed:
|
|
self._process_failed(dir_name, nzb_name, show_obj=show_obj)
|
|
else:
|
|
self._log_helper('Unable to figure out what folder to process. '
|
|
'If your downloader and SickGear aren\'t on the same PC then make sure '
|
|
'you fill out your completed TV download folder in the PP config.')
|
|
return self.result
|
|
|
|
parent = self.find_parent(dir_name)
|
|
if parent:
|
|
self._log_helper('Dir %s is subdir of show root dir: %s, not processing.' % (dir_name, parent))
|
|
return self.result
|
|
|
|
if dir_name == sickgear.TV_DOWNLOAD_DIR:
|
|
self.is_basedir = True
|
|
|
|
if None is show_obj:
|
|
if isinstance(nzb_name, string_types):
|
|
show_obj = self.check_name(re.sub(r'\.(nzb|torrent)$', '', nzb_name, flags=re.I))
|
|
|
|
if None is show_obj and dir_name:
|
|
show_obj = self.check_name(os.path.basename(dir_name))
|
|
|
|
path, dirs, files = self._get_path_dir_files(dir_name, nzb_name, pp_type)
|
|
|
|
if sickgear.POSTPONE_IF_SYNC_FILES and any(filter(helpers.is_sync_file, files)):
|
|
self._log_helper('Found temporary sync files, skipping post process', logger.ERROR)
|
|
return self.result
|
|
|
|
if not process_method:
|
|
process_method = sickgear.PROCESS_METHOD
|
|
|
|
self._log_helper(f'Processing folder... {path}')
|
|
|
|
work_files = []
|
|
joined = self.join(path)
|
|
if joined:
|
|
work_files += [joined]
|
|
|
|
rar_files, rarfile_history = self.unused_archives(
|
|
path, list(filter(helpers.is_first_rar_volume, files)), pp_type, process_method)
|
|
rar_content = self._unrar(path, rar_files, force)
|
|
if self.fail_detected:
|
|
self._process_failed(dir_name, nzb_name, show_obj=show_obj)
|
|
self.update_history_tab()
|
|
return self.result
|
|
rar_content = [x for x in rar_content if not helpers.is_link(os.path.join(path, x))]
|
|
path, dirs, files = self._get_path_dir_files(dir_name, nzb_name, pp_type)
|
|
files = [x for x in files if not helpers.is_link(os.path.join(path, x))]
|
|
video_files = list(filter(helpers.has_media_ext, files))
|
|
video_in_rar = list(filter(helpers.has_media_ext, rar_content))
|
|
work_files += [os.path.join(path, item) for item in rar_content]
|
|
|
|
if 0 < len(files):
|
|
self._log_helper(f'Process file{helpers.maybe_plural(files)}: {str(files)}')
|
|
if 0 < len(video_files):
|
|
self._log_helper(f'Process video file{helpers.maybe_plural(video_files)}: {str(video_files)}')
|
|
if 0 < len(rar_content):
|
|
self._log_helper(f'Process rar content: {rar_content}')
|
|
if 0 < len(video_in_rar):
|
|
self._log_helper(f'Process video{helpers.maybe_plural(video_in_rar)} in rar: {str(video_in_rar)}')
|
|
|
|
# If nzb_name is set and there's more than one videofile in the folder, files will be lost (overwritten).
|
|
nzb_name_original = nzb_name
|
|
if 2 <= len(video_files):
|
|
nzb_name = None
|
|
|
|
if None is show_obj and 0 < len(video_files):
|
|
show_obj = self.check_video_filenames(path, video_files)
|
|
|
|
# self._set_process_success()
|
|
|
|
# Don't Link media when the media is extracted from a rar in the same path
|
|
if process_method in ('hardlink', 'symlink') and video_in_rar:
|
|
soh = show_obj
|
|
if None is show_obj:
|
|
soh = self.check_video_filenames(path, video_in_rar)
|
|
self._process_media(path, video_in_rar, nzb_name, 'move', force, force_replace, show_obj=soh)
|
|
self._delete_files(path, [os.path.relpath(item, path) for item in work_files], force=True)
|
|
video_batch = set(video_files) - set(video_in_rar)
|
|
else:
|
|
video_batch = video_files
|
|
|
|
try:
|
|
while 0 < len(video_batch):
|
|
video_pick = ['']
|
|
video_size = 0
|
|
for cur_video_file in video_batch:
|
|
cur_video_size = os.path.getsize(os.path.join(path, cur_video_file))
|
|
if 0 == video_size or cur_video_size > video_size:
|
|
video_size = cur_video_size
|
|
video_pick = [cur_video_file]
|
|
|
|
video_batch = set(video_batch) - set(video_pick)
|
|
|
|
self._process_media(path, video_pick, nzb_name, process_method,
|
|
force, force_replace, use_trash=cleanup, show_obj=show_obj)
|
|
|
|
except OSError as e:
|
|
logger.warning('Batch skipped, %s%s' % (ex(e), e.filename and (' (file %s)' % e.filename) or ''))
|
|
|
|
# Process video files in TV subdirectories
|
|
for directory in [x for x in dirs if self._validate_dir(
|
|
path, x, nzb_name_original, failed,
|
|
show_obj=self.show_obj_helper(show_obj, dir_name, x, nzb_name, pp_type))]:
|
|
|
|
# self._set_process_success(reset=True)
|
|
|
|
for walk_path, walk_dir, files in os.walk(os.path.join(path, directory), topdown=False):
|
|
|
|
if sickgear.POSTPONE_IF_SYNC_FILES and any(filter(helpers.is_sync_file, files)):
|
|
self._log_helper('Found temporary sync files, skipping post process', logger.ERROR)
|
|
return self.result
|
|
|
|
parent = self.find_parent(walk_path)
|
|
if parent:
|
|
self._log_helper('Dir %s is subdir of show root dir: %s, not processing files.' %
|
|
(walk_path, parent))
|
|
continue
|
|
|
|
# Ignore any symlinks at this stage to avoid the potential for unraring a symlinked archive
|
|
files = [x for x in files if not helpers.is_link(os.path.join(walk_path, x))]
|
|
|
|
rar_files, rarfile_history = self.unused_archives(
|
|
walk_path, list(filter(helpers.is_first_rar_volume, files)), pp_type, process_method,
|
|
rarfile_history)
|
|
rar_content = self._unrar(walk_path, rar_files, force)
|
|
work_files += [os.path.join(walk_path, item) for item in rar_content]
|
|
if self.fail_detected:
|
|
self._process_failed(dir_name, nzb_name, show_obj=self.show_obj_helper(show_obj, directory))
|
|
continue
|
|
rar_content = [x for x in rar_content if not helpers.is_link(os.path.join(walk_path, x))]
|
|
files = list(set(files + rar_content))
|
|
video_files = list(filter(helpers.has_media_ext, files))
|
|
video_in_rar = list(filter(helpers.has_media_ext, rar_content))
|
|
notwanted_files = [x for x in files if x not in video_files]
|
|
|
|
# Don't Link media when the media is extracted from a rar in the same path
|
|
if process_method in ('hardlink', 'symlink') and video_in_rar:
|
|
self._process_media(walk_path, video_in_rar, nzb_name, 'move', force, force_replace,
|
|
show_obj=self.show_obj_helper(
|
|
show_obj, dir_name, directory, nzb_name, pp_type,
|
|
self.check_video_filenames(walk_dir, video_in_rar)))
|
|
video_batch = set(video_files) - set(video_in_rar)
|
|
else:
|
|
video_batch = video_files
|
|
|
|
try:
|
|
while 0 < len(video_batch):
|
|
video_pick = ['']
|
|
video_size = 0
|
|
for cur_video_file in video_batch:
|
|
cur_video_size = os.path.getsize(os.path.join(walk_path, cur_video_file))
|
|
|
|
if 0 == video_size or cur_video_size > video_size:
|
|
video_size = cur_video_size
|
|
video_pick = [cur_video_file]
|
|
|
|
video_batch = set(video_batch) - set(video_pick)
|
|
|
|
self._process_media(
|
|
walk_path, video_pick, nzb_name, process_method, force, force_replace, use_trash=cleanup,
|
|
show_obj=self.show_obj_helper(show_obj, dir_name, directory, nzb_name, pp_type,
|
|
self.check_video_filenames(walk_dir, video_pick)))
|
|
|
|
except OSError as e:
|
|
logger.warning(f'Batch skipped, {ex(e)}{e.filename and (" (file %s)" % e.filename) or ""}')
|
|
|
|
if process_method in ('hardlink', 'symlink') and video_in_rar:
|
|
self._delete_files(walk_path, rar_content)
|
|
else:
|
|
# Delete all file not needed
|
|
if not self.any_vid_processed\
|
|
or 'move' != process_method\
|
|
or ('manual' == pp_type and not cleanup): # Avoid deleting files if Manual Postprocessing
|
|
continue
|
|
|
|
self._delete_files(walk_path, notwanted_files)
|
|
|
|
if 'move' == process_method \
|
|
and os.path.normpath(sickgear.TV_DOWNLOAD_DIR) != os.path.normpath(walk_path):
|
|
self._delete_folder(walk_path, check_empty=False)
|
|
|
|
if 'copy' == process_method and work_files:
|
|
self._delete_files(path, [os.path.relpath(item, path) for item in work_files], force=True)
|
|
for f in sorted(list(set([os.path.dirname(item) for item in work_files]) - {path}), key=len, reverse=True):
|
|
self._delete_folder(f)
|
|
|
|
def _bottom_line(text, log_level=logger.MESSAGE):
|
|
self._buffer('-' * len(text))
|
|
self._log_helper(text, log_level)
|
|
|
|
notifiers.notify_update_library(ep_obj=None, flush_q=True)
|
|
|
|
self.update_history_tab()
|
|
|
|
if self.any_vid_processed:
|
|
if not self.files_failed:
|
|
_bottom_line('Successfully processed.')
|
|
else:
|
|
_bottom_line(f'Successfully processed at least one video file'
|
|
f'{(", others were skipped", " and skipped another")[1 == self.files_failed]}.')
|
|
elif sickgear.PROCESS_POSITIVE_LOG:
|
|
_bottom_line('Success, no media to process.')
|
|
else:
|
|
_bottom_line('Failed! Did not process any files.', logger.WARNING)
|
|
|
|
return self.result
|
|
|
|
@staticmethod
|
|
def update_history_tab():
|
|
from .webserve import History
|
|
sickgear.MEMCACHE['history_tab'] = History.menu_tab(sickgear.MEMCACHE['history_tab_limit'])
|
|
|
|
@staticmethod
|
|
def unused_archives(path, archives, pp_type, process_method, archive_history=None):
|
|
# type: (AnyStr, List[AnyStr], AnyStr, AnyStr, Optional[Dict]) -> Tuple[List[AnyStr], Dict]
|
|
"""
|
|
|
|
:param path: path
|
|
:param archives:
|
|
:param pp_type: process type
|
|
:param process_method: process method
|
|
:param archive_history:
|
|
"""
|
|
archive_history = (archive_history, {})[not archive_history]
|
|
if ('auto' == pp_type and sickgear.PROCESS_AUTOMATICALLY
|
|
and 'copy' == process_method and sickgear.UNPACK):
|
|
|
|
archive_history_file = os.path.join(sickgear.DATA_DIR, 'archive_history.txt')
|
|
|
|
if not archive_history:
|
|
try:
|
|
with open(archive_history_file, 'r') as fh:
|
|
archive_history = json_loads(fh.read(10 * 1024 * 1024))
|
|
except (IOError, ValueError, Exception):
|
|
pass
|
|
|
|
init_history_cnt = len(archive_history)
|
|
|
|
archive_history = {k_arc: v for k_arc, v in iteritems(archive_history) if os.path.isfile(k_arc)}
|
|
|
|
unused_files = list(set([os.path.join(path, x) for x in archives]) - set(iterkeys(archive_history)))
|
|
archives = [os.path.basename(x) for x in unused_files]
|
|
if unused_files:
|
|
for f in unused_files:
|
|
archive_history.setdefault(f, SGDatetime.timestamp_near(datetime.now(timezone.utc)))
|
|
|
|
if init_history_cnt != len(archive_history):
|
|
try:
|
|
with open(archive_history_file, 'w') as fh:
|
|
fh.write(json_dumps(archive_history))
|
|
except (IOError, Exception):
|
|
pass
|
|
|
|
return archives, archive_history
|
|
|
|
def _validate_dir(self, path, dir_name, nzb_name_original, failed, show_obj=None):
|
|
"""
|
|
|
|
:param path: path
|
|
:type path: AnyStr
|
|
:param dir_name: dir name
|
|
:type dir_name: AnyStr
|
|
:param nzb_name_original: nzb original name
|
|
:type nzb_name_original: AnyStr or None
|
|
:param failed: download failed
|
|
:type failed: bool
|
|
:param show_obj: show object opitonal
|
|
:type show_obj: sickgear.tv.TVShow or None
|
|
:return: success
|
|
:rtype: bool
|
|
"""
|
|
self._log_helper(f'Processing sub dir: {dir_name}')
|
|
|
|
if os.path.basename(dir_name).startswith('_FAILED_'):
|
|
self._log_helper('The directory name indicates it failed to extract.')
|
|
failed = True
|
|
elif os.path.basename(dir_name).startswith('_UNDERSIZED_'):
|
|
self._log_helper('The directory name indicates that it was previously rejected for being undersized.')
|
|
failed = True
|
|
elif os.path.basename(dir_name).upper().startswith('_UNPACK'):
|
|
self._log_helper('The directory name indicates that this release is in the process of being unpacked.')
|
|
return False
|
|
|
|
if failed:
|
|
self._process_failed(os.path.join(path, dir_name), nzb_name_original, show_obj=show_obj)
|
|
return False
|
|
|
|
if helpers.is_hidden_folder(dir_name):
|
|
self._log_helper(f'Ignoring hidden folder: {dir_name}')
|
|
return False
|
|
|
|
# make sure the directory isn't inside a show directory
|
|
my_db = db.DBConnection()
|
|
sql_result = my_db.select('SELECT * FROM tv_shows')
|
|
|
|
for cur_result in sql_result:
|
|
if dir_name.lower().startswith(os.path.realpath(cur_result['location']).lower() + os.sep) \
|
|
or dir_name.lower() == os.path.realpath(cur_result['location']).lower():
|
|
self._log_helper('Found an episode that has already been moved to its show dir, skipping', logger.ERROR)
|
|
return False
|
|
|
|
# Get the videofile list for the next checks
|
|
all_files = []
|
|
all_dirs = []
|
|
process_path = None
|
|
for process_path, process_dir, fileList in os.walk(os.path.join(path, dir_name), topdown=False):
|
|
all_dirs += process_dir
|
|
all_files += fileList
|
|
|
|
video_files = list(filter(helpers.has_media_ext, all_files))
|
|
all_dirs.append(dir_name)
|
|
|
|
# check if the directory have at least one tv video file
|
|
for video in video_files:
|
|
try:
|
|
NameParser(show_obj=show_obj).parse(video, cache_result=False)
|
|
return True
|
|
except (InvalidNameException, InvalidShowException):
|
|
pass
|
|
|
|
for directory in all_dirs:
|
|
try:
|
|
NameParser(show_obj=show_obj).parse(directory, cache_result=False)
|
|
return True
|
|
except (InvalidNameException, InvalidShowException):
|
|
pass
|
|
|
|
if sickgear.UNPACK and process_path and all_files:
|
|
# Search for packed release
|
|
packed_files = list(filter(helpers.is_first_rar_volume, all_files))
|
|
|
|
for packed in packed_files:
|
|
try:
|
|
NameParser(show_obj=show_obj).parse(packed, cache_result=False)
|
|
return True
|
|
except (InvalidNameException, InvalidShowException):
|
|
pass
|
|
|
|
return False
|
|
|
|
def _unrar(self, path, rar_files, force):
|
|
# type: (AnyStr, List[AnyStr], bool) -> List[AnyStr]
|
|
"""
|
|
|
|
:param path: path
|
|
:param rar_files: rar files
|
|
:param force:
|
|
:return: list of unrared files
|
|
"""
|
|
unpacked_files = []
|
|
|
|
if 'win32' == sys.platform:
|
|
rarfile.UNRAR_TOOL = os.path.join(sickgear.PROG_DIR, 'lib', 'rarfile', 'UnRAR.exe')
|
|
|
|
if sickgear.UNPACK and rar_files:
|
|
|
|
self._log_helper(f'Packed releases detected: {rar_files}')
|
|
|
|
for archive in rar_files:
|
|
|
|
self._log_helper(f'Unpacking archive: {archive}')
|
|
|
|
try:
|
|
rar_handle = rarfile.RarFile(os.path.join(path, archive))
|
|
except (BaseException, Exception):
|
|
self._log_helper(f'Failed to open archive: {archive}', logger.ERROR)
|
|
self._set_process_success(False)
|
|
continue
|
|
try:
|
|
# Skip extraction if any file in archive has previously been extracted
|
|
skip_file = False
|
|
for file_in_archive in [os.path.basename(x.filename)
|
|
for x in rar_handle.infolist() if not x.is_dir()]:
|
|
if self._already_postprocessed(path, file_in_archive, force):
|
|
self._log_helper(f'Archive file already processed, extraction skipped: {file_in_archive}')
|
|
skip_file = True
|
|
break
|
|
|
|
if not skip_file:
|
|
# need to test for password since rar4 doesn't raise PasswordRequired
|
|
if rar_handle.needs_password():
|
|
raise rarfile.PasswordRequired
|
|
|
|
rar_handle.extractall(path=path)
|
|
rar_content = [os.path.normpath(x.filename) for x in rar_handle.infolist() if not x.is_dir()]
|
|
renamed = self.cleanup_names(path, rar_content)
|
|
cur_unpacked = rar_content if not renamed else \
|
|
(list(set(rar_content) - set(iterkeys(renamed))) + list(renamed.values()))
|
|
self._log_helper('Unpacked content: ["%s"]' % '", "'.join(map(text_type, cur_unpacked)))
|
|
unpacked_files += cur_unpacked
|
|
except (rarfile.PasswordRequired, rarfile.RarWrongPassword):
|
|
self._log_helper(f'Failed to unpack archive PasswordRequired: {archive}', logger.ERROR)
|
|
self._set_process_success(False)
|
|
self.fail_detected = True
|
|
except (BaseException, Exception):
|
|
self._log_helper(f'Failed to unpack archive: {archive}', logger.ERROR)
|
|
self._set_process_success(False)
|
|
finally:
|
|
rar_handle.close()
|
|
del rar_handle
|
|
|
|
elif rar_files:
|
|
# check for passworded rar's
|
|
for archive in rar_files:
|
|
try:
|
|
rar_handle = rarfile.RarFile(os.path.join(path, archive))
|
|
except (BaseException, Exception):
|
|
self._log_helper(f'Failed to open archive: {archive}', logger.ERROR)
|
|
continue
|
|
try:
|
|
if rar_handle.needs_password():
|
|
self._log_helper(f'Failed to unpack archive PasswordRequired: {archive}', logger.ERROR)
|
|
self._set_process_success(False)
|
|
self.failure_detected = True
|
|
rar_handle.close()
|
|
del rar_handle
|
|
except (BaseException, Exception):
|
|
pass
|
|
|
|
return unpacked_files
|
|
|
|
@staticmethod
|
|
def cleanup_names(directory, files=None):
|
|
# type: (AnyStr, List[AnyStr]) -> Dict
|
|
"""
|
|
|
|
:param directory: dir
|
|
:param files: files
|
|
"""
|
|
is_renamed = {}
|
|
num_videos = 0
|
|
old_name = None
|
|
new_name = None
|
|
params = {
|
|
'base_name': os.path.basename(directory),
|
|
'reverse_pattern': re.compile('|'.join([
|
|
r'\.\d{2}e\d{2}s\.', r'\.p0(?:63|27|612)\.', r'\.[pi](?:084|675|0801)\.', r'\b[45]62[xh]\.',
|
|
r'\.yarulb\.', r'\.vtd[hp]\.', r'\.(?:ld[.-]?)?bew\.', r'\.pir.?(?:shv|dov|dvd|bew|db|rb)\.',
|
|
r'\brdvd\.', r'\.(?:vts|dcv)\.', r'\b(?:mac|pir)dh\b', r'\.(?:lanretni|reporp|kcaper|reneercs)\.',
|
|
r'\b(?:caa|3ca|3pm)\b', r'\.cstn\.', r'\.5r\.', r'\brcs\b'
|
|
]), flags=re.IGNORECASE),
|
|
'season_pattern': re.compile(r'(.*\.\d{2}e\d{2}s\.)(.*)', flags=re.IGNORECASE),
|
|
'word_pattern': re.compile(r'([^A-Z0-9]*[A-Z0-9]+)'),
|
|
'char_replace': [[r'(\w)1\.(\w)', r'\1i\2']],
|
|
'garbage_name': re.compile(r'^[a-zA-Z0-9]{3,}$'),
|
|
'media_pattern': re.compile('|'.join([
|
|
r'\.s\d{2}e\d{2}\.', r'\.(?:36|72|216)0p\.', r'\.(?:480|576|1080)[pi]\.', r'\.[xh]26[45]\b',
|
|
r'\.bluray\.', r'\.[hp]dtv\.', r'\.web(?:[.-]?dl)?\.', r'\.(?:vhs|vod|dvd|web|bd|br).?rip\.',
|
|
r'\.dvdr\b', r'\.(?:stv|vcd)\.', r'\bhd(?:cam|rip)\b', r'\.(?:internal|real|proper|repack|screener)\.',
|
|
r'\b(?:aac|ac3|mp3)\b', r'\.(?:ntsc|pal|secam)\.', r'\.r5\.', r'\bscr\b', r'\b(?:divx|xvid)\b'
|
|
]), flags=re.IGNORECASE)
|
|
}
|
|
|
|
def renamer(_dirpath, _filenames, _num_videos, _old_name, _new_name, base_name,
|
|
reverse_pattern, season_pattern, word_pattern, char_replace, garbage_name, media_pattern):
|
|
|
|
for cur_filename in _filenames:
|
|
|
|
file_name, file_extension = os.path.splitext(cur_filename)
|
|
file_path = os.path.join(_dirpath, cur_filename)
|
|
dir_name = os.path.dirname(file_path)
|
|
|
|
if None is not reverse_pattern.search(file_name):
|
|
na_parts = season_pattern.search(file_name)
|
|
if None is not na_parts:
|
|
word_p = word_pattern.findall(na_parts.group(2))
|
|
new_words = ''
|
|
for wp in word_p:
|
|
if '.' == wp[0]:
|
|
new_words += '.'
|
|
new_words += re.sub(r'\W', '', wp)
|
|
for cr in char_replace:
|
|
new_words = re.sub(cr[0], cr[1], new_words)
|
|
new_filename = new_words[::-1] + na_parts.group(1)[::-1]
|
|
else:
|
|
new_filename = file_name[::-1]
|
|
logger.log('Reversing base filename "%s" to "%s"' % (file_name, new_filename))
|
|
try:
|
|
os.rename(file_path, os.path.join(_dirpath, new_filename + file_extension))
|
|
is_renamed[os.path.relpath(file_path, directory)] = \
|
|
os.path.relpath(new_filename + file_extension, directory)
|
|
except OSError as _e:
|
|
logger.error('Error unable to rename file "%s" because %s' % (cur_filename, ex(_e)))
|
|
elif helpers.has_media_ext(cur_filename) and \
|
|
None is not garbage_name.search(file_name) and None is not media_pattern.search(base_name):
|
|
_num_videos += 1
|
|
_old_name = file_path
|
|
_new_name = os.path.join(dir_name, '%s%s' % (base_name, file_extension))
|
|
return is_renamed, _num_videos, _old_name, _new_name
|
|
|
|
if files:
|
|
is_renamed, num_videos, old_name, new_name = renamer(
|
|
directory, files, num_videos, old_name, new_name, **params)
|
|
else:
|
|
for cur_dirpath, void, cur_filenames in os.walk(directory):
|
|
is_renamed, num_videos, old_name, new_name = renamer(
|
|
cur_dirpath, cur_filenames, num_videos, old_name, new_name, **params)
|
|
|
|
if all([not is_renamed, 1 == num_videos, old_name, new_name]):
|
|
try_name = os.path.basename(new_name)
|
|
logger.log('Renaming file "%s" using dirname as "%s"' % (os.path.basename(old_name), try_name))
|
|
try:
|
|
os.rename(old_name, new_name)
|
|
is_renamed[os.path.relpath(old_name, directory)] = os.path.relpath(new_name, directory)
|
|
except OSError as e:
|
|
logger.error('Error unable to rename file "%s" because %s' % (old_name, ex(e)))
|
|
|
|
return is_renamed
|
|
|
|
def join(self, directory):
|
|
"""
|
|
|
|
:param directory: dir
|
|
:type directory: AnyStr
|
|
:return:
|
|
:rtype: bool or AnyStr
|
|
"""
|
|
result = False
|
|
chunks = {}
|
|
matcher = re.compile(r'\.[0-9]+$')
|
|
for dirpath, void, filenames in os.walk(directory):
|
|
for filename in filenames:
|
|
if None is not matcher.search(filename):
|
|
maybe_chunk = os.path.join(dirpath, filename)
|
|
base_filepath, ext = os.path.splitext(maybe_chunk)
|
|
if base_filepath not in chunks:
|
|
chunks[base_filepath] = []
|
|
chunks[base_filepath].append(maybe_chunk)
|
|
|
|
if not chunks:
|
|
return
|
|
|
|
for base_filepath in chunks:
|
|
chunks[base_filepath].sort()
|
|
chunk_set = chunks[base_filepath]
|
|
if os.path.isfile(base_filepath):
|
|
base_filesize = os.path.getsize(base_filepath)
|
|
chunk_sizes = [os.path.getsize(x) for x in chunk_set]
|
|
largest_chunk = max(chunk_sizes)
|
|
if largest_chunk >= base_filesize:
|
|
outfile = '%s.001' % base_filepath
|
|
if outfile not in chunk_set:
|
|
try:
|
|
os.rename(base_filepath, outfile)
|
|
except OSError:
|
|
logger.error('Error unable to rename file %s' % base_filepath)
|
|
return result
|
|
chunk_set.append(outfile)
|
|
chunk_set.sort()
|
|
else:
|
|
del_dir, del_file = os.path.split(base_filepath)
|
|
if not self._delete_files(del_dir, [del_file], force=True):
|
|
return result
|
|
else:
|
|
if base_filesize == sum(chunk_sizes):
|
|
logger.log('Join skipped. Total size of %s input files equal to output.. %s (%s bytes)' % (
|
|
len(chunk_set), base_filepath, base_filesize))
|
|
else:
|
|
logger.log('Join skipped. Found output file larger than input.. %s (%s bytes)' % (
|
|
base_filepath, base_filesize))
|
|
return result
|
|
|
|
with open(base_filepath, 'ab') as newfile:
|
|
for f in chunk_set:
|
|
logger.log('Joining file %s' % f)
|
|
try:
|
|
with open(f, 'rb') as part:
|
|
for wdata in iter(partial(part.read, 4096), b''):
|
|
try:
|
|
newfile.write(wdata)
|
|
except (BaseException, Exception):
|
|
logger.log('Failed write to file %s' % f)
|
|
return result
|
|
except (BaseException, Exception):
|
|
logger.log('Failed read from file %s' % f)
|
|
return result
|
|
result = base_filepath
|
|
|
|
return result
|
|
|
|
def _already_postprocessed(self, dir_name, videofile, force):
|
|
"""
|
|
|
|
:param dir_name: dir
|
|
:type dir_name: AnyStr
|
|
:param videofile: video file
|
|
:type videofile: AnyStr
|
|
:param force:
|
|
:type force: bool
|
|
:return: success
|
|
:rtype: bool
|
|
"""
|
|
if force or not self.any_vid_processed:
|
|
return False
|
|
|
|
parse_result = None
|
|
try:
|
|
parse_result = NameParser(convert=True).parse(videofile, cache_result=False)
|
|
except (InvalidNameException, InvalidShowException):
|
|
# Does not parse, move on to directory check
|
|
pass
|
|
if None is parse_result:
|
|
try:
|
|
parse_result = NameParser(convert=True).parse(dir_name, cache_result=False)
|
|
except (InvalidNameException, InvalidShowException):
|
|
# If the filename doesn't parse, then return false as last
|
|
# resort. We can assume that unparseable filenames are not
|
|
# processed in the past
|
|
return False
|
|
|
|
showlink = ('for "<a href="%s/home/view-show?tvid_prodid=%s" target="_blank">%s</a>"' % (
|
|
sickgear.WEB_ROOT, parse_result.show_obj.tvid_prodid, parse_result.show_obj.name),
|
|
parse_result.show_obj.name)[self.any_vid_processed]
|
|
|
|
ep_detail_sql = ''
|
|
if parse_result.show_obj.prodid and parse_result.show_obj.tvid and 0 < len(parse_result.episode_numbers) \
|
|
and parse_result.season_number:
|
|
ep_detail_sql = " AND tv_episodes.showid='%s' AND tv_episodes.indexer='%s'" \
|
|
" AND tv_episodes.season='%s' AND tv_episodes.episode='%s'" % \
|
|
(parse_result.show_obj.prodid, parse_result.show_obj.tvid,
|
|
parse_result.season_number, parse_result.episode_numbers[0])
|
|
|
|
# Avoid processing the same directory again if we use a process method <> move
|
|
my_db = db.DBConnection()
|
|
sql_result = my_db.select('SELECT * FROM tv_episodes WHERE release_name = ?', [dir_name])
|
|
if sql_result:
|
|
self._log_helper(f'Found a release directory {showlink} that has already been processed,<br>'
|
|
f'.. skipping: {dir_name}')
|
|
if ep_detail_sql:
|
|
reset_status(parse_result.show_obj.tvid,
|
|
parse_result.show_obj.prodid,
|
|
parse_result.season_number,
|
|
parse_result.episode_numbers[0])
|
|
return True
|
|
|
|
else:
|
|
# This is needed for video whose name differ from dir_name
|
|
|
|
sql_result = my_db.select(
|
|
'SELECT * FROM tv_episodes WHERE release_name = ?', [videofile.rpartition('.')[0]])
|
|
if sql_result:
|
|
self._log_helper(f'Found a video, but that release {showlink} was already processed,<br>'
|
|
f'.. skipping: {videofile}')
|
|
if ep_detail_sql:
|
|
reset_status(parse_result.show_obj.tvid,
|
|
parse_result.show_obj.prodid,
|
|
parse_result.season_number,
|
|
parse_result.episode_numbers[0])
|
|
return True
|
|
|
|
# Needed if we have downloaded the same episode @ different quality
|
|
# noinspection SqlResolve
|
|
search_sql = 'SELECT tv_episodes.indexerid, history.resource' \
|
|
' FROM tv_episodes INNER JOIN history'\
|
|
+ ' ON history.showid=tv_episodes.showid AND history.indexer=tv_episodes.indexer'\
|
|
+ ' WHERE history.season=tv_episodes.season and history.episode=tv_episodes.episode'\
|
|
+ ep_detail_sql\
|
|
+ ' and tv_episodes.status IN (%s)' % ','.join([str(x) for x in common.Quality.DOWNLOADED])\
|
|
+ ' and history.resource LIKE ?'
|
|
|
|
sql_result = my_db.select(search_sql, [f'%{videofile}'])
|
|
if sql_result:
|
|
self._log_helper(f'Found a video, but the episode {showlink} is already processed,<br>'
|
|
f'.. skipping: {videofile}')
|
|
if ep_detail_sql:
|
|
reset_status(parse_result.show_obj.tvid,
|
|
parse_result.show_obj.prodid,
|
|
parse_result.season_number,
|
|
parse_result.episode_numbers[0])
|
|
return True
|
|
|
|
return False
|
|
|
|
def _process_media(
|
|
self,
|
|
process_path, # type: AnyStr
|
|
video_files, # type: List[AnyStr]
|
|
nzb_name, # type: Optional[AnyStr]
|
|
process_method, # type: AnyStr
|
|
force, # type: bool
|
|
force_replace, # type: bool
|
|
use_trash=False, # type: bool
|
|
show_obj=None # type: Optional[sickgear.tv.TVShow]
|
|
):
|
|
# type: (...) -> None
|
|
"""
|
|
|
|
:param process_path: path to process
|
|
:param video_files: list of videofiles
|
|
:param nzb_name: nzb name
|
|
:param process_method: process method
|
|
:param force:
|
|
:param force_replace:
|
|
:param use_trash:
|
|
:param show_obj: show object or None
|
|
"""
|
|
processor = None
|
|
for cur_video_file in video_files:
|
|
|
|
if self._already_postprocessed(process_path, cur_video_file, force):
|
|
self._set_process_success(False)
|
|
continue
|
|
|
|
cur_video_file_path = os.path.join(process_path, cur_video_file)
|
|
|
|
parent = self.find_parent(cur_video_file_path)
|
|
if parent:
|
|
self._log_helper('Video %s is in a subdir of show root dir: %s, not processing media.' %
|
|
(cur_video_file_path, parent))
|
|
continue
|
|
|
|
try:
|
|
processor = postProcessor.PostProcessor(
|
|
cur_video_file_path, nzb_name, process_method, force_replace,
|
|
use_trash=use_trash, webhandler=self.webhandler, show_obj=show_obj)
|
|
|
|
file_success = processor.process()
|
|
process_fail_message = ''
|
|
except exceptions_helper.PostProcessingFailed:
|
|
file_success = False
|
|
process_fail_message = '<br>.. Post Processing Failed'
|
|
|
|
self._set_process_success(file_success)
|
|
|
|
if processor:
|
|
self._buffer(processor.log.strip('\n'))
|
|
|
|
if file_success:
|
|
self._log_helper(f'Successfully processed {cur_video_file}', logger.MESSAGE)
|
|
elif self.any_vid_processed:
|
|
self._log_helper(f'Warning fail for {cur_video_file_path}{process_fail_message}', logger.WARNING)
|
|
else:
|
|
self._log_helper(f'Did not use file {cur_video_file_path}{process_fail_message}', logger.WARNING)
|
|
|
|
@staticmethod
|
|
def _get_path_dir_files(dir_name, nzb_name, pp_type):
|
|
# type: (AnyStr, Optional[AnyStr], AnyStr) -> Tuple[AnyStr, List[AnyStr], List[AnyStr]]
|
|
"""
|
|
|
|
:param dir_name: dir name
|
|
:param nzb_name: nzb name
|
|
:param pp_type: process type
|
|
"""
|
|
path = ''
|
|
dirs = []
|
|
files = []
|
|
|
|
if dir_name == sickgear.TV_DOWNLOAD_DIR and not nzb_name or 'manual' == pp_type:
|
|
# Scheduled Media Process Active
|
|
# Get at first all the subdir in the dir_name
|
|
for path, dirs, files in os.walk(dir_name):
|
|
files = [x for x in files if not helpers.is_link(os.path.join(path, x))]
|
|
break
|
|
else:
|
|
path, dirs = os.path.split(dir_name) # Script Media Process
|
|
if None is not nzb_name and not nzb_name.endswith('.nzb') and \
|
|
os.path.isfile(os.path.join(dir_name, nzb_name)):
|
|
# For single torrent file without directory
|
|
dirs = []
|
|
files = [os.path.join(dir_name, nzb_name)]
|
|
else:
|
|
dirs = [dirs]
|
|
files = []
|
|
|
|
return path, dirs, files
|
|
|
|
# noinspection PyArgumentList
|
|
def _process_failed(self, dir_name, nzb_name, show_obj=None):
|
|
""" Process a download that did not complete correctly
|
|
:param dir_name: dir name
|
|
:type dir_name: AnyStr
|
|
:param nzb_name: nzb name
|
|
:type nzb_name: AnyStr or None
|
|
:param show_obj: optional show object
|
|
:type show_obj: sickgear.tv.TVShow or None
|
|
"""
|
|
|
|
if self.skip_failure_processing:
|
|
self._log_helper('Download was not added by SickGear, ignoring failure', logger.WARNING)
|
|
return
|
|
|
|
if sickgear.USE_FAILED_DOWNLOADS:
|
|
processor = None
|
|
|
|
try:
|
|
processor = failedProcessor.FailedProcessor(dir_name, nzb_name, show_obj)
|
|
self._set_process_success(processor.process())
|
|
process_fail_message = ''
|
|
except exceptions_helper.FailedProcessingFailed as e:
|
|
self._set_process_success(False)
|
|
process_fail_message = ex(e)
|
|
|
|
if processor:
|
|
self._buffer(processor.log.strip('\n'))
|
|
|
|
if sickgear.DELETE_FAILED and self.any_vid_processed:
|
|
self._delete_folder(dir_name, check_empty=False)
|
|
|
|
task = 'Failed download processing'
|
|
if self.any_vid_processed:
|
|
self._log_helper(f'Successful {task.lower()}: ({str(nzb_name)}, {dir_name})', logger.MESSAGE)
|
|
else:
|
|
self._log_helper(f'{task} failed: ({str(nzb_name)}, {dir_name}): {process_fail_message}',
|
|
logger.WARNING)
|
|
|
|
def process_minimal(self, nzb_name, show_obj, failed, webhandler):
|
|
if failed:
|
|
self._process_failed('', nzb_name=nzb_name, show_obj=show_obj)
|
|
else:
|
|
processor = postProcessor.PostProcessor('', nzb_name=nzb_name, webhandler=webhandler, show_obj=show_obj)
|
|
processor.process_minimal()
|
|
self._buffer(processor.log.strip('\n'))
|
|
|
|
|
|
def process_dir(dir_name, nzb_name=None, process_method=None, force=False, force_replace=None,
|
|
failed=False, pp_type='auto', cleanup=False, webhandler=None, show_obj=None, is_basedir=True,
|
|
skip_failure_processing=False, client=None):
|
|
"""
|
|
|
|
:param dir_name: dir name
|
|
:type dir_name: AnyStr
|
|
:param nzb_name: nzb name
|
|
:type nzb_name: AnyStr or None
|
|
:param process_method: process method
|
|
:type process_method: AnyStr or None
|
|
:param force:
|
|
:type force: bool
|
|
:param force_replace:
|
|
:type force_replace: bool
|
|
:param failed: download failed
|
|
:type failed: bool
|
|
:param pp_type: processing type
|
|
:type pp_type: AnyStr
|
|
:param cleanup:
|
|
:type cleanup: bool
|
|
:param webhandler:
|
|
:type webhandler:
|
|
:param show_obj: optional show object
|
|
:type show_obj: sickgear.tv.TVShow or None
|
|
:param is_basedir:
|
|
:type is_basedir: bool
|
|
:param skip_failure_processing:
|
|
:type skip_failure_processing: bool
|
|
:param client: string to represent the client
|
|
:type client: Optional[AnyStr]
|
|
:return:
|
|
:rtype: AnyStr
|
|
"""
|
|
# backward compatibility prevents the case of this function name from being updated to PEP8
|
|
return ProcessTVShow(webhandler, is_basedir, skip_failure_processing=skip_failure_processing,
|
|
client=client).process_dir(dir_name, nzb_name, process_method, force, force_replace, failed,
|
|
pp_type, cleanup, show_obj)
|
|
|
|
|
|
# backward compatibility
|
|
processDir = process_dir
|
|
|
|
|
|
def process_minimal(nzb_name, show_obj, failed, webhandler):
|
|
# type: (AnyStr, TVShow, bool, Any) -> None
|
|
ProcessTVShow(webhandler).process_minimal(nzb_name, show_obj, failed, webhandler)
|