def validate_dir(process_path, release_name, failed, result): # pylint: disable=too-many-locals,too-many-branches,too-many-return-statements
"""
Check if directory is valid for processing
:param process_path: Directory to check
:param release_name: Original NZB/Torrent name
:param failed: Previously failed objects
:param result: Previous results
:return: True if dir is valid for processing, False if not
"""
result.output += log_helper("Processing folder " + process_path, logger.DEBUG)
upper_name = ek(os.path.basename, process_path).upper()
if upper_name.startswith('_FAILED_') or upper_name.endswith('_FAILED_'):
result.output += log_helper("The directory name indicates it failed to extract.", logger.DEBUG)
failed = True
elif upper_name.startswith('_UNDERSIZED_') or upper_name.endswith('_UNDERSIZED_'):
result.output += log_helper("The directory name indicates that it was previously rejected for being undersized.", logger.DEBUG)
failed = True
elif upper_name.startswith('_UNPACK') or upper_name.endswith('_UNPACK'):
result.output += log_helper("The directory name indicates that this release is in the process of being unpacked.", logger.DEBUG)
result.missed_files.append("{0} : Being unpacked".format(process_path))
return False
if failed:
process_failed(process_path, release_name, result)
result.missed_files.append("{0} : Failed download".format(process_path))
return False
if sickbeard.TV_DOWNLOAD_DIR and helpers.real_path(process_path) != helpers.real_path(sickbeard.TV_DOWNLOAD_DIR) and helpers.is_hidden_folder(process_path):
result.output += log_helper("Ignoring hidden folder: {0}".format(process_path), logger.DEBUG)
result.missed_files.append("{0} : Hidden folder".format(process_path))
return False
# make sure the dir isn't inside a show dir
main_db_con = db.DBConnection()
sql_results = main_db_con.select("SELECT location FROM tv_shows")
for sqlShow in sql_results:
if process_path.lower().startswith(ek(os.path.realpath, sqlShow[b"location"]).lower() + os.sep) or \
process_path.lower() == ek(os.path.realpath, sqlShow[b"location"]).lower():
result.output += log_helper(
"Cannot process an episode that's already been moved to its show dir, skipping " + process_path,
logger.WARNING)
return False
for current_directory, directory_names, file_names in ek(os.walk, process_path, topdown=False, followlinks=sickbeard.PROCESSOR_FOLLOW_SYMLINKS):
sync_files = filter(is_sync_file, file_names)
if sync_files and sickbeard.POSTPONE_IF_SYNC_FILES:
result.output += log_helper("Found temporary sync files: {0} in path: {1}".format(sync_files, ek(os.path.join, process_path, sync_files[0])))
result.output += log_helper("Skipping post processing for folder: {0}".format(process_path))
result.missed_files.append("{0} : Sync files found".format(ek(os.path.join, process_path, sync_files[0])))
continue
found_files = filter(helpers.is_media_file, file_names)
if sickbeard.UNPACK == 1:
found_files += filter(helpers.is_rar_file, file_names)
if current_directory != sickbeard.TV_DOWNLOAD_DIR and found_files:
found_files.append(ek(os.path.basename, current_directory))
for found_file in found_files:
try:
NameParser().parse(found_file, cache_result=False)
except (InvalidNameException, InvalidShowException) as e:
pass
else:
return True
result.output += log_helper("{0} : No processable items found in folder".format(process_path), logger.DEBUG)
return False
def validateDir(path, dirName, nzbNameOriginal, failed):
global process_result, returnStr
returnStr += logHelper(u"Processing folder " + dirName, logger.DEBUG)
if ek.ek(os.path.basename, dirName).startswith('_FAILED_'):
returnStr += logHelper(
u"The directory name indicates it failed to extract.",
logger.DEBUG)
failed = True
elif ek.ek(os.path.basename, dirName).startswith('_UNDERSIZED_'):
returnStr += logHelper(
u"The directory name indicates that it was previously rejected for being undersized.",
logger.DEBUG)
failed = True
elif ek.ek(os.path.basename, dirName).upper().startswith('_UNPACK'):
returnStr += logHelper(
u"The directory name indicates that this release is in the process of being unpacked.",
logger.DEBUG)
return False
if failed:
process_failed(os.path.join(path, dirName), nzbNameOriginal)
return False
if helpers.is_hidden_folder(dirName):
returnStr += logHelper(u"Ignoring hidden folder: " + dirName,
logger.DEBUG)
return False
# make sure the dir isn't inside a show dir
myDB = db.DBConnection()
sqlResults = myDB.select("SELECT * FROM tv_shows")
for sqlShow in sqlResults:
if dirName.lower().startswith(
ek.ek(os.path.realpath, sqlShow["location"]).lower() +
os.sep) or dirName.lower() == ek.ek(
os.path.realpath, sqlShow["location"]).lower():
returnStr += logHelper(
u"You're trying to post process an episode that's already been moved to its show dir, skipping",
logger.ERROR)
return False
# Get the videofile list for the next checks
allFiles = []
allDirs = []
for processPath, processDir, fileList in ek.ek(os.walk,
ek.ek(
os.path.join, path,
dirName),
topdown=False):
allDirs += processDir
allFiles += fileList
videoFiles = filter(helpers.isMediaFile, allFiles)
allDirs.append(dirName)
#check if the dir have at least one tv video file
for video in videoFiles:
try:
NameParser().parse(video, cache_result=False)
return True
except InvalidNameException:
pass
for dir in allDirs:
try:
NameParser().parse(dir, cache_result=False)
return True
except InvalidNameException:
pass
if sickbeard.UNPACK:
#Search for packed release
packedFiles = filter(helpers.isRarFile, allFiles)
for packed in packedFiles:
try:
NameParser().parse(packed, cache_result=False)
return True
except InvalidNameException:
pass
return False
def _validate_dir(self, path, dir_name, nzb_name_original, failed):
self._log_helper(u'Processing dir: ' + dir_name)
if ek.ek(os.path.basename, dir_name).startswith('_FAILED_'):
self._log_helper(u'The directory name indicates it failed to extract.')
failed = True
elif ek.ek(os.path.basename, dir_name).startswith('_UNDERSIZED_'):
self._log_helper(u'The directory name indicates that it was previously rejected for being undersized.')
failed = True
elif ek.ek(os.path.basename, dir_name).upper().startswith('_UNPACK'):
self._log_helper(u'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)
return False
if helpers.is_hidden_folder(dir_name):
self._log_helper(u'Ignoring hidden folder: ' + dir_name)
return False
# make sure the directory isn't inside a show directory
my_db = db.DBConnection()
sql_results = my_db.select('SELECT * FROM tv_shows')
for sqlShow in sql_results:
if dir_name.lower().startswith(ek.ek(os.path.realpath, sqlShow['location']).lower() + os.sep)\
or dir_name.lower() == ek.ek(os.path.realpath, sqlShow['location']).lower():
self._log_helper(
u'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 = []
for process_path, process_dir, fileList in ek.ek(os.walk, ek.ek(os.path.join, path, dir_name), topdown=False):
all_dirs += process_dir
all_files += fileList
video_files = filter(helpers.isMediaFile, 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().parse(video, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
for directory in all_dirs:
try:
NameParser().parse(directory, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
if sickbeard.UNPACK:
# Search for packed release
packed_files = filter(helpers.isRarFile, all_files)
for packed in packed_files:
try:
NameParser().parse(packed, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
return False
def validateDir(path, dirName, nzbNameOriginal, failed, result):
"""
Check if directory is valid for processing
:param path: Path to use
:param dirName: Directory to check
:param nzbNameOriginal: Original NZB name
:param failed: Previously failed objects
:param result: Previous results
:return: True if dir is valid for processing, False if not
"""
result.output += logHelper(u"Processing folder " + dirName, logger.DEBUG)
if ek(os.path.basename, dirName).startswith('_FAILED_'):
result.output += logHelper(u"The directory name indicates it failed to extract.", logger.DEBUG)
failed = True
elif ek(os.path.basename, dirName).startswith('_UNDERSIZED_'):
result.output += logHelper(u"The directory name indicates that it was previously rejected for being undersized.",
logger.DEBUG)
failed = True
elif ek(os.path.basename, dirName).upper().startswith('_UNPACK'):
result.output += logHelper(u"The directory name indicates that this release is in the process of being unpacked.",
logger.DEBUG)
result.missedfiles.append(dirName + " : Being unpacked")
return False
if failed:
process_failed(os.path.join(path, dirName), nzbNameOriginal, result)
result.missedfiles.append(dirName + " : Failed download")
return False
if helpers.is_hidden_folder(os.path.join(path, dirName)):
result.output += logHelper(u"Ignoring hidden folder: " + dirName, logger.DEBUG)
result.missedfiles.append(dirName + " : Hidden folder")
return False
# make sure the dir isn't inside a show dir
myDB = db.DBConnection()
sqlResults = myDB.select("SELECT * FROM tv_shows")
for sqlShow in sqlResults:
if dirName.lower().startswith(
ek(os.path.realpath, sqlShow["location"]).lower() + os.sep) or dirName.lower() == ek(
os.path.realpath, sqlShow["location"]).lower():
result.output += logHelper(
u"Cannot process an episode that's already been moved to its show dir, skipping " + dirName,
logger.WARNING)
return False
# Get the videofile list for the next checks
allFiles = []
allDirs = []
for processPath, processDir, fileList in ek(os.walk, ek(os.path.join, path, dirName), topdown=False):
allDirs += processDir
allFiles += fileList
videoFiles = filter(helpers.isMediaFile, allFiles)
allDirs.append(dirName)
#check if the dir have at least one tv video file
for video in videoFiles:
try:
NameParser().parse(video, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
for dir in allDirs:
try:
NameParser().parse(dir, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
if sickbeard.UNPACK:
#Search for packed release
packedFiles = filter(helpers.isRarFile, allFiles)
for packed in packedFiles:
try:
NameParser().parse(packed, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
result.output += logHelper(dirName + " : No processable items found in folder", logger.DEBUG)
return False
def validateDir(
path, dirName, nzbNameOriginal, failed, result
): # pylint: disable=too-many-locals,too-many-branches,too-many-return-statements
"""
Check if directory is valid for processing
:param path: Path to use
:param dirName: Directory to check
:param nzbNameOriginal: Original NZB name
:param failed: Previously failed objects
:param result: Previous results
:return: True if dir is valid for processing, False if not
"""
dirName = ss(dirName)
IGNORED_FOLDERS = [u".AppleDouble", u".@__thumb", u"@eaDir"]
folder_name = ek(os.path.basename, dirName)
if folder_name in IGNORED_FOLDERS:
return False
result.output += logHelper(u"Processing folder " + dirName, logger.DEBUG)
if folder_name.startswith(u"_FAILED_"):
result.output += logHelper(u"The directory name indicates it failed to extract.", logger.DEBUG)
failed = True
elif folder_name.startswith(u"_UNDERSIZED_"):
result.output += logHelper(
u"The directory name indicates that it was previously rejected for being undersized.", logger.DEBUG
)
failed = True
elif folder_name.upper().startswith(u"_UNPACK"):
result.output += logHelper(
u"The directory name indicates that this release is in the process of being unpacked.", logger.DEBUG
)
result.missedfiles.append(u"%s : Being unpacked" % dirName)
return False
if failed:
process_failed(ek(os.path.join, path, dirName), nzbNameOriginal, result)
result.missedfiles.append(u"%s : Failed download" % dirName)
return False
if helpers.is_hidden_folder(ek(os.path.join, path, dirName)):
result.output += logHelper(u"Ignoring hidden folder: %s" % dirName, logger.DEBUG)
result.missedfiles.append(u"%s : Hidden folder" % dirName)
return False
# make sure the dir isn't inside a show dir
main_db_con = db.DBConnection()
sql_results = main_db_con.select("SELECT location FROM tv_shows")
for sqlShow in sql_results:
if (
dirName.lower().startswith(ek(os.path.realpath, sqlShow["location"]).lower() + os.sep)
or dirName.lower() == ek(os.path.realpath, sqlShow["location"]).lower()
):
result.output += logHelper(
u"Cannot process an episode that's already been moved to its show dir, skipping " + dirName,
logger.WARNING,
)
return False
# Get the videofile list for the next checks
allFiles = []
allDirs = []
for _, processdir, fileList in ek(os.walk, ek(os.path.join, path, dirName), topdown=False):
allDirs += processdir
allFiles += fileList
videoFiles = [x for x in allFiles if helpers.isMediaFile(x)]
allDirs.append(dirName)
# check if the dir have at least one tv video file
for video in videoFiles:
try:
NameParser().parse(video, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
for proc_dir in allDirs:
try:
NameParser().parse(proc_dir, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
if sickbeard.UNPACK:
# Search for packed release
packedFiles = [x for x in allFiles if helpers.isRarFile(x)]
for packed in packedFiles:
try:
NameParser().parse(packed, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
result.output += logHelper(u"%s : No processable items found in folder" % dirName, logger.DEBUG)
return False
def validateDir(path, dirName, nzbNameOriginal, failed, result):
"""
Check if directory is valid for processing
:param path: Path to use
:param dirName: Directory to check
:param nzbNameOriginal: Original NZB name
:param failed: Previously failed objects
:param result: Previous results
:return: True if dir is valid for processing, False if not
"""
IGNORED_FOLDERS = ['.AppleDouble', '.@__thumb', '@eaDir']
folder_name = ek(os.path.basename, dirName)
if folder_name in IGNORED_FOLDERS:
return False
result.output += logHelper("Processing folder " + dirName, logging.DEBUG)
if folder_name.startswith('_FAILED_'):
result.output += logHelper(
"The directory name indicates it failed to extract.",
logging.DEBUG)
failed = True
elif folder_name.startswith('_UNDERSIZED_'):
result.output += logHelper(
"The directory name indicates that it was previously rejected for being undersized.",
logging.DEBUG)
failed = True
elif folder_name.upper().startswith('_UNPACK'):
result.output += logHelper(
"The directory name indicates that this release is in the process of being unpacked.",
logging.DEBUG)
result.missedfiles.append(dirName + " : Being unpacked")
return False
if failed:
process_failed(ek(os.path.join, path, dirName), nzbNameOriginal,
result)
result.missedfiles.append(dirName + " : Failed download")
return False
if helpers.is_hidden_folder(ek(os.path.join, path, dirName)):
result.output += logHelper("Ignoring hidden folder: " + dirName,
logging.DEBUG)
result.missedfiles.append(dirName + " : Hidden folder")
return False
# make sure the dir isn't inside a show dir
myDB = db.DBConnection()
sqlResults = myDB.select("SELECT * FROM tv_shows")
for sqlShow in sqlResults:
if dirName.lower().startswith(ek(os.path.realpath, sqlShow[b"location"]).lower() + os.sep) or \
dirName.lower() == ek(os.path.realpath, sqlShow[b"location"]).lower():
result.output += logHelper(
"Cannot process an episode that's already been moved to its show dir, skipping "
+ dirName, logging.WARNING)
return False
# Get the videofile list for the next checks
allFiles = []
allDirs = []
for _, processdir, fileList in ek(os.walk,
ek(os.path.join, path, dirName),
topdown=False):
allDirs += processdir
allFiles += fileList
videoFiles = [x for x in allFiles if helpers.isMediaFile(x)]
allDirs.append(dirName)
# check if the dir have at least one tv video file
for video in videoFiles:
try:
NameParser().parse(video, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
for proc_dir in allDirs:
try:
NameParser().parse(proc_dir, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
if sickbeard.UNPACK:
# Search for packed release
packedFiles = [x for x in allFiles if helpers.isRarFile(x)]
for packed in packedFiles:
try:
NameParser().parse(packed, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
result.output += logHelper(
dirName + " : No processable items found in folder", logging.DEBUG)
return False
def validateDir(path, dirName, nzbNameOriginal, failed):
global process_result, returnStr
returnStr += logHelper(u"Processing folder " + dirName, logger.DEBUG)
if ek.ek(os.path.basename, dirName).startswith('_FAILED_'):
returnStr += logHelper(u"The directory name indicates it failed to extract.", logger.DEBUG)
failed = True
elif ek.ek(os.path.basename, dirName).startswith('_UNDERSIZED_'):
returnStr += logHelper(u"The directory name indicates that it was previously rejected for being undersized.", logger.DEBUG)
failed = True
elif ek.ek(os.path.basename, dirName).startswith('_UNPACK_'):
returnStr += logHelper(u"The directory name indicates that this release is in the process of being unpacked.", logger.DEBUG)
return False
if failed:
process_failed(ek.ek(os.path.join, path, dirName), nzbNameOriginal)
return False
if helpers.is_hidden_folder(dirName):
returnStr += logHelper(u"Ignoring hidden folder: " + dirName, logger.DEBUG)
return False
# make sure the dir isn't inside a show dir
myDB = db.DBConnection()
sqlResults = myDB.select("SELECT * FROM tv_shows")
for sqlShow in sqlResults:
if dirName.lower().startswith(ek.ek(os.path.realpath, sqlShow["location"]).lower()+os.sep) or dirName.lower() == ek.ek(os.path.realpath, sqlShow["location"]).lower():
returnStr += logHelper(u"You're trying to post process an episode that's already been moved to its show dir, skipping", logger.ERROR)
return False
# Get the videofile list for the next checks
allFiles = []
allDirs = []
for processPath, processDir, fileList in ek.ek(os.walk, ek.ek(os.path.join, path, dirName), topdown=False):
allDirs += processDir
allFiles += fileList
videoFiles = filter(helpers.isMediaFile, allFiles)
allDirs.append(dirName)
#check if the dir have at least one tv video file
for video in videoFiles:
try:
NameParser().parse(video)
return True
except InvalidNameException:
pass
for dir in allDirs:
try:
NameParser().parse(dir)
return True
except InvalidNameException:
pass
if sickbeard.UNPACK:
#Search for packed release
packedFiles = filter(helpers.isRarFile, allFiles)
for packed in packedFiles:
try:
NameParser().parse(packed)
return True
except InvalidNameException:
pass
return False
def validate_dir(process_path, release_name, failed, result): # pylint: disable=too-many-locals,too-many-branches,too-many-return-statements
"""
Check if directory is valid for processing
:param process_path: Directory to check
:param release_name: Original NZB/Torrent name
:param failed: Previously failed objects
:param result: Previous results
:return: True if dir is valid for processing, False if not
"""
result.output += log_helper("Processing folder " + process_path, logger.DEBUG)
upper_name = ek(os.path.basename, process_path).upper()
if upper_name.startswith('_FAILED_') or upper_name.endswith('_FAILED_'):
result.output += log_helper("The directory name indicates it failed to extract.", logger.DEBUG)
failed = True
elif upper_name.startswith('_UNDERSIZED_') or upper_name.endswith('_UNDERSIZED_'):
result.output += log_helper("The directory name indicates that it was previously rejected for being undersized.", logger.DEBUG)
failed = True
elif upper_name.startswith('_UNPACK') or upper_name.endswith('_UNPACK'):
result.output += log_helper("The directory name indicates that this release is in the process of being unpacked.", logger.DEBUG)
result.missed_files.append("{0} : Being unpacked".format(process_path))
return False
if failed:
process_failed(process_path, release_name, result)
result.missed_files.append("{0} : Failed download".format(process_path))
return False
if sickbeard.TV_DOWNLOAD_DIR and helpers.real_path(process_path) != helpers.real_path(sickbeard.TV_DOWNLOAD_DIR) and helpers.is_hidden_folder(process_path):
result.output += log_helper("Ignoring hidden folder: {0}".format(process_path), logger.DEBUG)
result.missed_files.append("{0} : Hidden folder".format(process_path))
return False
# make sure the dir isn't inside a show dir
main_db_con = db.DBConnection()
sql_results = main_db_con.select("SELECT location FROM tv_shows")
for sqlShow in sql_results:
if process_path.lower().startswith(ek(os.path.realpath, sqlShow[b"location"]).lower() + os.sep) or \
process_path.lower() == ek(os.path.realpath, sqlShow[b"location"]).lower():
result.output += log_helper(
"Cannot process an episode that's already been moved to its show dir, skipping " + process_path,
logger.WARNING)
return False
for current_directory, directory_names, file_names in ek(os.walk, process_path, topdown=False, followlinks=sickbeard.PROCESSOR_FOLLOW_SYMLINKS):
sync_files = filter(is_sync_file, file_names)
if sync_files and sickbeard.POSTPONE_IF_SYNC_FILES:
result.output += log_helper("Found temporary sync files: {0} in path: {1}".format(sync_files, ek(os.path.join, process_path, sync_files[0])))
result.output += log_helper("Skipping post processing for folder: {0}".format(process_path))
result.missed_files.append("{0} : Sync files found".format(ek(os.path.join, process_path, sync_files[0])))
continue
found_files = filter(helpers.is_media_file, file_names)
if sickbeard.UNPACK == 1:
found_files += filter(helpers.is_rar_file, file_names)
if current_directory != sickbeard.TV_DOWNLOAD_DIR and found_files:
found_files.append(ek(os.path.basename, current_directory))
for found_file in found_files:
try:
NameParser().parse(found_file, cache_result=False)
except (InvalidNameException, InvalidShowException) as e:
pass
else:
return True
result.output += log_helper("{0} : No processable items found in folder".format(process_path), logger.DEBUG)
return False
def processDir(dirName, nzbName=None, method=None, recurse=False, pp_options={}):
"""
Scans through the files in dirName and processes whatever media files it finds
dirName: The folder name to look in
nzbName: The NZB name which resulted in this folder being downloaded
method: The method of postprocessing: Automatic, Script, Manual
recurse: Boolean for whether we should descend into subfolders or not
"""
returnStr = u""
returnStr += logHelper(u"Processing folder: " + dirName, logger.DEBUG)
# if they passed us a real dir then assume it's the one we want
if ek.ek(os.path.isdir, dirName):
dirName = ek.ek(os.path.realpath, dirName)
# if they've got a download dir configured then use it
elif sickbeard.TV_DOWNLOAD_DIR and ek.ek(os.path.isdir, sickbeard.TV_DOWNLOAD_DIR) \
and ek.ek(os.path.normpath, dirName) != ek.ek(os.path.normpath, sickbeard.TV_DOWNLOAD_DIR):
dirName = ek.ek(os.path.join, sickbeard.TV_DOWNLOAD_DIR, ek.ek(os.path.abspath, dirName).split(os.path.sep)[-1])
returnStr += logHelper(u"Trying to use folder: " + dirName, logger.DEBUG)
# if we didn't find a real dir then quit
if not ek.ek(os.path.isdir, dirName):
returnStr += logHelper(u"Unable to figure out what folder to process. If your downloader and Sick Beard aren't on the same PC make sure you fill out your TV download dir in the config.", logger.DEBUG)
return returnStr
# TODO: check if it's failed and deal with it if it is
if ek.ek(os.path.basename, dirName).startswith('_FAILED_'):
returnStr += logHelper(u"The directory name indicates it failed to extract, cancelling", logger.DEBUG)
return returnStr
elif ek.ek(os.path.basename, dirName).startswith('_UNDERSIZED_'):
returnStr += logHelper(u"The directory name indicates that it was previously rejected for being undersized, cancelling", logger.DEBUG)
return returnStr
elif ek.ek(os.path.basename, dirName).upper().startswith('_UNPACK'):
returnStr += logHelper(u"The directory name indicates that this release is in the process of being unpacked, skipping", logger.DEBUG)
return returnStr
# make sure the dir isn't inside a show dir
myDB = db.DBConnection()
sqlResults = myDB.select("SELECT * FROM tv_shows")
for sqlShow in sqlResults:
if dirName.lower().startswith(ek.ek(os.path.realpath, sqlShow["location"]).lower() + os.sep) or dirName.lower() == ek.ek(os.path.realpath, sqlShow["location"]).lower():
returnStr += logHelper(u"You're trying to post process an existing show directory: " + dirName, logger.ERROR)
returnStr += u"\n"
return returnStr
fileList = ek.ek(os.listdir, dirName)
# split the list into video files and folders
folders = filter(lambda x: ek.ek(os.path.isdir, ek.ek(os.path.join, dirName, x)), fileList)
# videoFiles, sorted by size, process biggest file first. Leaves smaller same named file behind
mediaFiles = filter(lambda x: ek.ek(os.path.exists, ek.ek(os.path.join, dirName, x)), filter(helpers.isMediaFile, fileList))
videoFiles = sorted(mediaFiles, key=lambda x: ek.ek(os.path.getsize, ek.ek(os.path.join, dirName, x)), reverse=True)
remaining_video_files = list(videoFiles)
num_videoFiles = len(videoFiles)
# if there are no videofiles in parent and only one subfolder, pass the nzbName to child
if num_videoFiles == 0 and len(folders) == 1:
parent_nzbName = nzbName
else:
parent_nzbName = None
# recursively process all the folders
for cur_folder in folders:
returnStr += u"\n"
# use full path
cur_folder = ek.ek(os.path.join, dirName, cur_folder)
if helpers.is_hidden_folder(cur_folder):
returnStr += logHelper(u"Ignoring hidden folder: " + cur_folder, logger.DEBUG)
else:
returnStr += logHelper(u"Recursively processing a folder: " + cur_folder, logger.DEBUG)
returnStr += processDir(cur_folder, nzbName=parent_nzbName, recurse=True, method=method, pp_options=pp_options)
remainingFolders = filter(lambda x: ek.ek(os.path.isdir, ek.ek(os.path.join, dirName, x)), fileList)
if num_videoFiles == 0:
returnStr += u"\n"
returnStr += logHelper(u"There are no videofiles in folder: " + dirName, logger.DEBUG)
# if there a no videofiles, try deleting empty folder
if method != 'Manual':
if delete_folder(dirName, check_empty=True):
returnStr += logHelper(u"Deleted empty folder: " + dirName, logger.DEBUG)
# if there's more than one videofile in the folder, files can be lost (overwritten) when nzbName contains only one episode.
if num_videoFiles >= 2:
nzbName = None
# process any files in the dir
for cur_video_file in videoFiles:
cur_video_file_path = ek.ek(os.path.join, dirName, cur_video_file)
if method == 'Automatic':
# check if we processed this video file before
cur_video_file_path_size = ek.ek(os.path.getsize, cur_video_file_path)
myDB = db.DBConnection()
search_sql = "SELECT tv_episodes.tvdbid, history.resource FROM tv_episodes INNER JOIN history ON history.showid=tv_episodes.showid"
search_sql += " WHERE history.season=tv_episodes.season and history.episode=tv_episodes.episode"
search_sql += " and tv_episodes.status IN (" + ",".join([str(x) for x in common.Quality.DOWNLOADED]) + ")"
search_sql += " and history.resource LIKE ? and tv_episodes.file_size = ?"
sql_results = myDB.select(search_sql, [cur_video_file_path, cur_video_file_path_size])
if len(sql_results):
returnStr += logHelper(u"Ignoring file: " + cur_video_file_path + " looks like it's been processed already", logger.DEBUG)
continue
try:
returnStr += u"\n"
processor = postProcessor.PostProcessor(cur_video_file_path, nzb_name=nzbName, pp_options=pp_options)
process_result = processor.process()
process_fail_message = ""
except exceptions.PostProcessingFailed, e:
process_result = False
process_fail_message = ex(e)
except Exception, e:
process_result = False
process_fail_message = "Post Processor returned unhandled exception: " + ex(e)
def _validate_dir(self, path, dir_name, nzb_name_original, failed):
self._log_helper(u'Processing dir: ' + dir_name)
if ek.ek(os.path.basename, dir_name).startswith('_FAILED_'):
self._log_helper(u'The directory name indicates it failed to extract.')
failed = True
elif ek.ek(os.path.basename, dir_name).startswith('_UNDERSIZED_'):
self._log_helper(u'The directory name indicates that it was previously rejected for being undersized.')
failed = True
elif ek.ek(os.path.basename, dir_name).upper().startswith('_UNPACK'):
self._log_helper(u'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)
return False
if helpers.is_hidden_folder(dir_name):
self._log_helper(u'Ignoring hidden folder: ' + dir_name)
return False
# make sure the directory isn't inside a show directory
my_db = db.DBConnection()
sql_results = my_db.select('SELECT * FROM tv_shows')
for sqlShow in sql_results:
if dir_name.lower().startswith(ek.ek(os.path.realpath, sqlShow['location']).lower() + os.sep)\
or dir_name.lower() == ek.ek(os.path.realpath, sqlShow['location']).lower():
self._log_helper(
u'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 = []
for process_path, process_dir, fileList in ek.ek(os.walk, ek.ek(os.path.join, path, dir_name), topdown=False):
all_dirs += process_dir
all_files += fileList
video_files = filter(helpers.isMediaFile, 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().parse(video, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
for directory in all_dirs:
try:
NameParser().parse(directory, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
if sickbeard.UNPACK:
# Search for packed release
packed_files = filter(helpers.isRarFile, all_files)
for packed in packed_files:
try:
NameParser().parse(packed, cache_result=False)
return True
except (InvalidNameException, InvalidShowException):
pass
return False
def processDir(dirName,
nzbName=None,
method=None,
recurse=False,
pp_options={}):
"""
Scans through the files in dirName and processes whatever media files it finds
dirName: The folder name to look in
nzbName: The NZB name which resulted in this folder being downloaded
method: The method of postprocessing: Automatic, Script, Manual
recurse: Boolean for whether we should descend into subfolders or not
"""
returnStr = u""
returnStr += logHelper(u"Processing folder: " + dirName, logger.DEBUG)
# if they passed us a real dir then assume it's the one we want
if ek.ek(os.path.isdir, dirName):
dirName = ek.ek(os.path.realpath, dirName)
# if they've got a download dir configured then use it
elif sickbeard.TV_DOWNLOAD_DIR and ek.ek(os.path.isdir, sickbeard.TV_DOWNLOAD_DIR) \
and ek.ek(os.path.normpath, dirName) != ek.ek(os.path.normpath, sickbeard.TV_DOWNLOAD_DIR):
dirName = ek.ek(os.path.join, sickbeard.TV_DOWNLOAD_DIR,
ek.ek(os.path.abspath, dirName).split(os.path.sep)[-1])
returnStr += logHelper(u"Trying to use folder: " + dirName,
logger.DEBUG)
# if we didn't find a real dir then quit
if not ek.ek(os.path.isdir, dirName):
returnStr += logHelper(
u"Unable to figure out what folder to process. If your downloader and Sick Beard aren't on the same PC make sure you fill out your TV download dir in the config.",
logger.DEBUG)
return returnStr
# TODO: check if it's failed and deal with it if it is
if ek.ek(os.path.basename, dirName).startswith('_FAILED_'):
returnStr += logHelper(
u"The directory name indicates it failed to extract, cancelling",
logger.DEBUG)
return returnStr
elif ek.ek(os.path.basename, dirName).startswith('_UNDERSIZED_'):
returnStr += logHelper(
u"The directory name indicates that it was previously rejected for being undersized, cancelling",
logger.DEBUG)
return returnStr
elif ek.ek(os.path.basename, dirName).startswith('_UNPACK_'):
returnStr += logHelper(
u"The directory name indicates that this release is in the process of being unpacked, skipping",
logger.DEBUG)
return returnStr
# make sure the dir isn't inside a show dir
myDB = db.DBConnection()
sqlResults = myDB.select("SELECT * FROM tv_shows")
for sqlShow in sqlResults:
if dirName.lower().startswith(
ek.ek(os.path.realpath, sqlShow["location"]).lower() +
os.sep) or dirName.lower() == ek.ek(
os.path.realpath, sqlShow["location"]).lower():
returnStr += logHelper(
u"You're trying to post process an existing show directory: " +
dirName, logger.ERROR)
returnStr += u"\n"
return returnStr
fileList = ek.ek(os.listdir, dirName)
# split the list into video files and folders
folders = filter(
lambda x: ek.ek(os.path.isdir, ek.ek(os.path.join, dirName, x)),
fileList)
# videoFiles, sorted by size, process biggest file first. Leaves smaller same named file behind
videoFiles = sorted(
filter(helpers.isMediaFile, fileList),
key=lambda x: ek.ek(os.path.getsize, ek.ek(os.path.join, dirName, x)),
reverse=True)
remaining_video_files = list(videoFiles)
num_videoFiles = len(videoFiles)
# if there are no videofiles in parent and only one subfolder, pass the nzbName to child
if num_videoFiles == 0 and len(folders) == 1:
parent_nzbName = nzbName
else:
parent_nzbName = None
# recursively process all the folders
for cur_folder in folders:
returnStr += u"\n"
# use full path
cur_folder = ek.ek(os.path.join, dirName, cur_folder)
if helpers.is_hidden_folder(cur_folder):
returnStr += logHelper(u"Ignoring hidden folder: " + cur_folder,
logger.DEBUG)
else:
returnStr += logHelper(
u"Recursively processing a folder: " + cur_folder,
logger.DEBUG)
returnStr += processDir(cur_folder,
nzbName=parent_nzbName,
recurse=True,
method=method,
pp_options=pp_options)
remainingFolders = filter(
lambda x: ek.ek(os.path.isdir, ek.ek(os.path.join, dirName, x)),
fileList)
if num_videoFiles == 0:
returnStr += logHelper(
u"There are no videofiles in folder: " + dirName, logger.DEBUG)
# if there a no videofiles, try deleting empty folder
if method != 'Manual':
if delete_folder(dirName, check_empty=True):
returnStr += logHelper(u"Deleted empty folder: " + dirName,
logger.DEBUG)
# if there's more than one videofile in the folder, files can be lost (overwritten) when nzbName contains only one episode.
if num_videoFiles >= 2:
nzbName = None
# process any files in the dir
for cur_video_file in videoFiles:
cur_video_file_path = ek.ek(os.path.join, dirName, cur_video_file)
if method == 'Automatic':
# check if we processed this video file before
cur_video_file_path_size = ek.ek(os.path.getsize,
cur_video_file_path)
myDB = db.DBConnection()
search_sql = "SELECT tv_episodes.tvdbid, history.resource FROM tv_episodes INNER JOIN history ON history.showid=tv_episodes.showid"
search_sql += " WHERE history.season=tv_episodes.season and history.episode=tv_episodes.episode"
search_sql += " and tv_episodes.status IN (" + ",".join(
[str(x) for x in common.Quality.DOWNLOADED]) + ")"
search_sql += " and history.resource LIKE ? and tv_episodes.file_size = ?"
sql_results = myDB.select(
search_sql, [cur_video_file_path, cur_video_file_path_size])
if len(sql_results):
returnStr += logHelper(
u"Ignoring file: " + cur_video_file_path +
" looks like it's been processed already", logger.DEBUG)
continue
try:
returnStr += u"\n"
processor = postProcessor.PostProcessor(cur_video_file_path,
nzb_name=nzbName,
pp_options=pp_options)
process_result = processor.process()
process_fail_message = ""
except exceptions.PostProcessingFailed, e:
process_result = False
process_fail_message = ex(e)
except Exception, e:
process_result = False
process_fail_message = "Post Processor returned unhandled exception: " + ex(
e)
