mirror of
https://github.com/StuffAnThings/qbit_manage.git
synced 2024-11-10 17:47:13 +08:00
864 lines
43 KiB
Python
864 lines
43 KiB
Python
#!/usr/bin/python3
|
|
|
|
import os
|
|
import shutil
|
|
import argparse
|
|
import logging
|
|
import logging.handlers
|
|
import urllib3
|
|
from collections import Counter
|
|
import glob
|
|
from pathlib import Path
|
|
import datetime
|
|
import time
|
|
import stat
|
|
import sys
|
|
import fnmatch
|
|
|
|
try:
|
|
from qbittorrentapi import Client
|
|
import yaml
|
|
import schedule
|
|
except ModuleNotFoundError:
|
|
print("Requirements Error: Requirements are not installed")
|
|
sys.exit(0)
|
|
|
|
if sys.version_info[0] != 3 or sys.version_info[1] < 6:
|
|
print("Version Error: Version: %s.%s.%s incompatible please use Python 3.6+" % (sys.version_info[0], sys.version_info[1], sys.version_info[2]))
|
|
sys.exit(0)
|
|
|
|
parser = argparse.ArgumentParser('qBittorrent Manager.', description='A mix of scripts combined for managing qBittorrent.')
|
|
parser.add_argument('-r', '--run', dest='run', action='store_true', default=False, help='Run without the scheduler. Script will exit after completion.')
|
|
parser.add_argument('-sch', '--schedule', dest='min', default='30', type=str, help='Schedule to run every x minutes. (Default set to 30)')
|
|
parser.add_argument('-c', '--config-file', dest='configfile', action='store', default='config.yml', type=str, help='This is used if you want to use a different name for your config.yml. Example: tv.yml')
|
|
parser.add_argument('-lf', '--log-file', dest='logfile', action='store',default='activity.log', type=str, help='This is used if you want to use a different name for your log file. Example: tv.log',)
|
|
parser.add_argument('-cs', '--cross-seed', dest='cross_seed', action="store_true", default=False, help='Use this after running cross-seed script to add torrents from the cross-seed output folder to qBittorrent')
|
|
parser.add_argument('-re', '--recheck', dest='recheck', action="store_true", default=False, help='Recheck paused torrents sorted by lowest size. Resume if Completed.')
|
|
parser.add_argument('-cu', '--cat-update', dest='cat_update', action="store_true", default=False, help='Use this if you would like to update your categories.')
|
|
parser.add_argument('-tu', '--tag-update', dest='tag_update', action="store_true", default=False, help='Use this if you would like to update your tags. (Only adds tags to untagged torrents)')
|
|
parser.add_argument('-ru', '--rem-unregistered', dest='rem_unregistered', action="store_true", default=False, help='Use this if you would like to remove unregistered torrents.')
|
|
parser.add_argument('-ro', '--rem-orphaned', dest='rem_orphaned', action="store_true", default=False, help='Use this if you would like to remove unregistered torrents.')
|
|
parser.add_argument('-tnhl', '--tag-nohardlinks', dest='tag_nohardlinks', action="store_true", default=False, help='Use this to tag any torrents that do not have any hard links associated with any of the files. This is useful for those that use Sonarr/Radarr which hard link your media files with the torrents for seeding. When files get upgraded they no longer become linked with your media therefore will be tagged with a new tag noHL. You can then safely delete/remove these torrents to free up any extra space that is not being used by your media folder.')
|
|
parser.add_argument('-sr', '--skip-recycle', dest='skip_recycle', action="store_true", default=False, help='Use this to skip emptying the Reycle Bin folder.')
|
|
parser.add_argument('-dr', '--dry-run', dest='dry_run', action="store_true", default=False, help='If you would like to see what is gonna happen but not actually move/delete or tag/categorize anything.')
|
|
parser.add_argument('-ll', '--log-level', dest='log_level', action="store", default='INFO', type=str, help='Change your log level.')
|
|
|
|
args = parser.parse_args()
|
|
|
|
def get_arg(env_str, default, arg_bool=False, arg_int=False):
|
|
env_var = os.environ.get(env_str)
|
|
if env_var:
|
|
if arg_bool:
|
|
if env_var is True or env_var is False:
|
|
return env_var
|
|
elif env_var.lower() in ["t", "true"]:
|
|
return True
|
|
else:
|
|
return False
|
|
elif arg_int:
|
|
return int(env_var)
|
|
else:
|
|
return str(env_var)
|
|
else:
|
|
return default
|
|
|
|
run = get_arg("QBT_RUN", args.run, arg_bool=True)
|
|
sch = get_arg("QBT_SCHEDULE", args.min)
|
|
config_file = get_arg("QBT_CONFIG", args.configfile)
|
|
log_file = get_arg("QBT_LOGFILE", args.logfile)
|
|
cross_seed = get_arg("QBT_CROSS_SEED", args.cross_seed, arg_bool=True)
|
|
recheck = get_arg("QBT_RECHECK", args.recheck, arg_bool=True)
|
|
cat_update = get_arg("QBT_CAT_UPDATE", args.cat_update, arg_bool=True)
|
|
tag_update = get_arg("QBT_TAG_UPDATE", args.tag_update, arg_bool=True)
|
|
rem_unregistered = get_arg("QBT_REM_UNREGISTERED", args.rem_unregistered, arg_bool=True)
|
|
rem_orphaned = get_arg("QBT_REM_ORPHANED", args.rem_orphaned, arg_bool=True)
|
|
tag_nohardlinks = get_arg("QBT_TAG_NOHARDLINKS", args.tag_nohardlinks, arg_bool=True)
|
|
skip_recycle = get_arg("QBT_TAG_SKIP_RECYCLE", args.skip_recycle, arg_bool=True)
|
|
dry_run = get_arg("QBT_DRY_RUN", args.dry_run, arg_bool=True)
|
|
log_level = get_arg("QBT_LOG_LEVEL", args.log_level)
|
|
|
|
|
|
default_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "config")
|
|
root_path = '' #Global variable
|
|
remote_path = '' #Global variable
|
|
|
|
#Check if Schedule parameter is a number
|
|
if sch.isnumeric():
|
|
sch = int(sch)
|
|
else:
|
|
print(f"Schedule Error: Schedule is not a number. Current value is set to '{sch}'")
|
|
sys.exit(0)
|
|
|
|
#Config error handling
|
|
if not os.path.exists(os.path.join(default_dir, config_file)):
|
|
print(f"Config Error: config not found at {os.path.join(os.path.abspath(default_dir),config_file)}")
|
|
sys.exit(0)
|
|
|
|
with open(os.path.join(default_dir,config_file), 'r') as cfg_file:
|
|
cfg = yaml.load(cfg_file, Loader=yaml.FullLoader)
|
|
|
|
|
|
|
|
#Set root and remote directories
|
|
def validate_path():
|
|
global root_path
|
|
global remote_path
|
|
#Assign root_dir
|
|
if 'root_dir' in cfg['directory']:
|
|
root_path = os.path.join(cfg['directory']['root_dir'], '')
|
|
else:
|
|
print('root_dir not defined in config.')
|
|
sys.exit(0)
|
|
#Assign remote_path
|
|
if ('remote_dir' in cfg['directory'] and cfg['directory']['remote_dir'] != ''):
|
|
remote_path = os.path.join(cfg['directory']['remote_dir'], '')
|
|
else:
|
|
remote_path = root_path
|
|
#Check to see if path exists
|
|
if not os.path.exists(remote_path):
|
|
print(f"Config Error: Path does not exist at '{os.path.abspath(remote_path)}'. Is your root_dir/remote_dir correctly defined in the config?")
|
|
sys.exit(0)
|
|
|
|
#Root_dir/remote_dir error handling
|
|
if cross_seed or tag_nohardlinks or rem_orphaned:
|
|
validate_path()
|
|
else:
|
|
if 'recyclebin' in cfg and cfg["recyclebin"] != None:
|
|
if 'enabled' in cfg["recyclebin"] and cfg["recyclebin"]['enabled']:
|
|
validate_path()
|
|
|
|
|
|
os.makedirs(os.path.join(default_dir, "logs"), exist_ok=True)
|
|
urllib3.disable_warnings()
|
|
|
|
file_name_format = os.path.join(default_dir, "logs", log_file)
|
|
msg_format = f"[%(asctime)s] %(levelname)-10s %(message)s"
|
|
|
|
max_bytes = 1024 * 1024 * 2
|
|
backup_count = 10
|
|
|
|
logger = logging.getLogger('qBit Manage')
|
|
logging.DRYRUN = 25
|
|
logging.addLevelName(logging.DRYRUN, 'DRY-RUN')
|
|
setattr(logger, 'dryrun', lambda dryrun, *args: logger._log(logging.DRYRUN, dryrun, args))
|
|
log_lev = getattr(logging, log_level.upper())
|
|
logger.setLevel(log_lev)
|
|
|
|
file_handler = logging.handlers.RotatingFileHandler(filename=file_name_format,
|
|
delay=True, mode="w",
|
|
maxBytes=max_bytes,
|
|
backupCount=backup_count,
|
|
encoding="utf-8")
|
|
file_handler.setLevel(log_lev)
|
|
file_formatter = logging.Formatter(msg_format)
|
|
file_handler.setFormatter(file_formatter)
|
|
logger.addHandler(file_handler)
|
|
|
|
stream_handler = logging.StreamHandler()
|
|
stream_handler.setLevel(log_lev)
|
|
stream_formatter = logging.Formatter(msg_format)
|
|
stream_handler.setFormatter(stream_formatter)
|
|
logger.addHandler(stream_handler)
|
|
|
|
version = "Unknown"
|
|
with open(os.path.join(os.path.dirname(os.path.abspath(__file__)), "VERSION")) as handle:
|
|
for line in handle.readlines():
|
|
line = line.strip()
|
|
if len(line) > 0:
|
|
version = line
|
|
break
|
|
|
|
# Actual API call to connect to qbt.
|
|
host = cfg['qbt']['host']
|
|
if 'user' in cfg['qbt']:
|
|
username = cfg['qbt']['user']
|
|
else:
|
|
username = ''
|
|
if 'pass' in cfg['qbt']:
|
|
password = cfg['qbt']['pass']
|
|
else:
|
|
password = ''
|
|
|
|
client = Client(host=host,
|
|
username=username,
|
|
password=password)
|
|
|
|
|
|
|
|
|
|
############FUNCTIONS##############
|
|
|
|
#truncate the value of the torrent url to remove sensitive information
|
|
def trunc_val(s, d, n=3):
|
|
return d.join(s.split(d, n)[:n])
|
|
|
|
|
|
#Get category from config file based on path provided
|
|
def get_category(path):
|
|
if 'cat' in cfg and cfg["cat"] != None:
|
|
cat_path = cfg["cat"]
|
|
for i, f in cat_path.items():
|
|
if f in path:
|
|
category = i
|
|
return category
|
|
else:
|
|
category = ''
|
|
return category
|
|
category = ''
|
|
logger.warning('No categories matched. Check your config.yml file. - Setting category to NULL')
|
|
return category
|
|
|
|
#Get tags from config file based on keyword
|
|
def get_tags(urls):
|
|
if 'tags' in cfg and cfg["tags"] != None:
|
|
tag_path = cfg['tags']
|
|
for i, f in tag_path.items():
|
|
for url in urls:
|
|
if i in url:
|
|
tag = f
|
|
if tag: return tag,trunc_val(url, '/')
|
|
else:
|
|
tag = ('','')
|
|
return tag
|
|
tag = ('','')
|
|
logger.warning('No tags matched. Check your config.yml file. Setting tag to NULL')
|
|
return tag
|
|
|
|
|
|
#Move files from source to destination, mod variable is to change the date modified of the file being moved
|
|
def move_files(src,dest,mod=False):
|
|
dest_path = os.path.dirname(dest)
|
|
if os.path.isdir(dest_path) == False:
|
|
os.makedirs(dest_path)
|
|
shutil.move(src, dest)
|
|
if(mod == True):
|
|
modTime = time.time()
|
|
os.utime(dest,(modTime,modTime))
|
|
|
|
|
|
#Remove any empty directories after moving files
|
|
def remove_empty_directories(pathlib_root_dir,pattern):
|
|
# list all directories recursively and sort them by path,
|
|
# longest first
|
|
L = sorted(
|
|
pathlib_root_dir.glob(pattern),
|
|
key=lambda p: len(str(p)),
|
|
reverse=True,
|
|
)
|
|
for pdir in L:
|
|
try:
|
|
pdir.rmdir() # remove directory if empty
|
|
except OSError:
|
|
continue # catch and continue if non-empty
|
|
|
|
# Will create a 2D Dictionary with the torrent name as the key
|
|
# torrentdict = {'TorrentName1' : {'Category':'TV', 'save_path':'/data/torrents/TV', 'count':1, 'msg':'[]'...},
|
|
# 'TorrentName2' : {'Category':'Movies', 'save_path':'/data/torrents/Movies'}, 'count':2, 'msg':'[]'...}
|
|
# List of dictionary key definitions
|
|
# Category = Returns category of the torrent (str)
|
|
# save_path = Returns the save path of the torrent (str)
|
|
# count = Returns a count of the total number of torrents with the same name (int)
|
|
# msg = Returns a list of torrent messages by name (list of str)
|
|
# status = Returns the list of status numbers of the torrent by name (0: Tracker is disabled (used for DHT, PeX, and LSD), 1: Tracker has not been contacted yet, 2:Tracker has been contacted and is working, 3:Tracker is updating, 4:Tracker has been contacted, but it is not working (or doesn't send proper replies)
|
|
# is_complete = Returns the state of torrent (Returns True if at least one of the torrent with the State is categorized as Complete.)
|
|
# first_hash = Returns the hash number of the original torrent (Assuming the torrent list is sorted by date added (Asc))
|
|
def get_torrent_info(t_list):
|
|
torrentdict = {}
|
|
for torrent in t_list:
|
|
save_path = torrent.save_path
|
|
category = get_category(save_path)
|
|
is_complete = False
|
|
if torrent.name in torrentdict:
|
|
t_count = torrentdict[torrent.name]['count'] + 1
|
|
msg_list = torrentdict[torrent.name]['msg']
|
|
status_list = torrentdict[torrent.name]['status']
|
|
is_complete = True if torrentdict[torrent.name]['is_complete'] == True else torrent.state_enum.is_complete
|
|
first_hash = torrentdict[torrent.name]['first_hash']
|
|
else:
|
|
t_count = 1
|
|
msg_list = []
|
|
status_list = []
|
|
is_complete = torrent.state_enum.is_complete
|
|
first_hash = torrent.hash
|
|
msg,status = [(x.msg,x.status) for x in torrent.trackers if x.url.startswith('http')][0]
|
|
msg_list.append(msg)
|
|
status_list.append(status)
|
|
torrentattr = {'Category': category, 'save_path': save_path, 'count': t_count, 'msg': msg_list, 'status': status_list, 'is_complete': is_complete, 'first_hash':first_hash}
|
|
torrentdict[torrent.name] = torrentattr
|
|
return torrentdict
|
|
|
|
# Function used to recheck paused torrents sorted by size and resume torrents that are completed
|
|
def set_recheck():
|
|
if cross_seed or recheck:
|
|
#sort by size and paused
|
|
torrent_sorted_list = client.torrents.info(status_filter='paused',sort='size')
|
|
if torrent_sorted_list:
|
|
for torrent in torrent_sorted_list:
|
|
new_tag,t_url = get_tags([x.url for x in torrent.trackers if x.url.startswith('http')])
|
|
if torrent.tags == '' or ('cross-seed' in torrent.tags and len([e for e in torrent.tags.split(",") if not 'noHL' in e]) == 1): torrent.add_tags(tags=new_tag)
|
|
#Resume torrent if completed
|
|
if torrent.progress == 1:
|
|
#Check to see if torrent meets AutoTorrentManagement criteria
|
|
logger.debug(f'Rechecking Torrent to see if torrent meets AutoTorrentManagement Criteria\n'
|
|
f' - Torrent Name: {torrent.name}\n'
|
|
f' --Ratio vs Max Ratio: {torrent.ratio} < {torrent.max_ratio}\n'
|
|
f' --Seeding Time vs Max Seed Time: {datetime.timedelta(seconds=torrent.seeding_time)} < {datetime.timedelta(minutes=torrent.max_seeding_time)}')
|
|
if torrent.ratio < torrent.max_ratio and (torrent.seeding_time < (torrent.max_seeding_time * 60)):
|
|
if dry_run:
|
|
logger.dryrun(f'\n - Not Resuming {new_tag} - {torrent.name}')
|
|
else:
|
|
logger.info(f'\n - Resuming {new_tag} - {torrent.name}')
|
|
torrent.resume()
|
|
#Recheck
|
|
elif torrent.progress == 0 and torrentdict[torrent.name]['is_complete'] and not torrent.state_enum.is_checking:
|
|
if dry_run:
|
|
logger.dryrun(f'\n - Not Rechecking {new_tag} - {torrent.name}')
|
|
else:
|
|
logger.info(f'\n - Rechecking {new_tag} - {torrent.name}')
|
|
torrent.recheck()
|
|
|
|
# Function used to move any torrents from the cross seed directory to the correct save directory
|
|
def set_cross_seed():
|
|
if cross_seed:
|
|
# List of categories for all torrents moved
|
|
categories = []
|
|
# Keep track of total torrents moved
|
|
total = 0
|
|
#Track # of torrents tagged that are not cross-seeded
|
|
t_tagged = 0
|
|
# Only get torrent files
|
|
cs_files = [f for f in os.listdir(os.path.join(cfg['directory']['cross_seed'], '')) if f.endswith('torrent')]
|
|
dir_cs = os.path.join(cfg['directory']['cross_seed'], '')
|
|
dir_cs_out = os.path.join(dir_cs,'qbit_manage_added')
|
|
os.makedirs(dir_cs_out,exist_ok=True)
|
|
for file in cs_files:
|
|
t_name = file.split(']', 2)[2].split('.torrent')[0]
|
|
# Substring Key match in dictionary (used because t_name might not match exactly with torrentdict key)
|
|
# Returned the dictionary of filtered item
|
|
torrentdict_file = dict(filter(lambda item: t_name in item[0], torrentdict.items()))
|
|
if torrentdict_file:
|
|
# Get the exact torrent match name from torrentdict
|
|
t_name = next(iter(torrentdict_file))
|
|
category = torrentdict[t_name]['Category']
|
|
dest = os.path.join(torrentdict[t_name]['save_path'], '')
|
|
src = os.path.join(dir_cs,file)
|
|
dir_cs_out = os.path.join(dir_cs,'qbit_manage_added',file)
|
|
categories.append(category)
|
|
if dry_run:
|
|
logger.dryrun(f'Not Adding {t_name} to qBittorrent with: '
|
|
f'\n - Category: {category}'
|
|
f'\n - Save_Path: {dest}'
|
|
f'\n - Paused: True')
|
|
else:
|
|
if torrentdict[t_name]['is_complete']:
|
|
client.torrents.add(torrent_files=src,
|
|
save_path=dest,
|
|
category=category,
|
|
tags='cross-seed',
|
|
is_paused=True)
|
|
shutil.move(src, dir_cs_out)
|
|
logger.info(f'Adding {t_name} to qBittorrent with: '
|
|
f'\n - Category: {category}'
|
|
f'\n - Save_Path: {dest}'
|
|
f'\n - Paused: True')
|
|
else:
|
|
logger.info(f'Found {t_name} in {dir_cs} but original torrent is not complete. Not adding to qBittorrent')
|
|
else:
|
|
if dry_run:
|
|
logger.dryrun(f'{t_name} not found in torrents.')
|
|
else:
|
|
logger.warning(f'{t_name} not found in torrents.')
|
|
numcategory = Counter(categories)
|
|
#Tag missing cross-seed torrents tags
|
|
for torrent in torrent_list:
|
|
t_name = torrent.name
|
|
if 'cross-seed' not in torrent.tags and torrentdict[t_name]['count'] > 1 and torrentdict[t_name]['first_hash'] != torrent.hash:
|
|
t_tagged += 1
|
|
if dry_run:
|
|
logger.dryrun(f'Not Adding cross-seed tag to {t_name}')
|
|
else:
|
|
logger.info(f'Adding cross-seed tag to {t_name}')
|
|
torrent.add_tags(tags='cross-seed')
|
|
|
|
|
|
if dry_run:
|
|
for c in numcategory:
|
|
total += numcategory[c]
|
|
if numcategory[c] > 0: logger.dryrun(f'{numcategory[c]} {c} cross-seed .torrents not added.')
|
|
if total > 0: logger.dryrun(f'Total {total} cross-seed .torrents not added.')
|
|
if t_tagged > 0:logger.dryrun(f'Total {t_tagged} cross-seed .torrents not tagged.')
|
|
else:
|
|
for c in numcategory:
|
|
total += numcategory[c]
|
|
if numcategory[c] > 0: logger.info(f'{numcategory[c]} {c} cross-seed .torrents not added.')
|
|
if total > 0: logger.info(f'Total {total} cross-seed .torrents not added.')
|
|
if t_tagged > 0:logger.info(f'Total {t_tagged} cross-seed .torrents not tagged.')
|
|
|
|
def set_category():
|
|
if cat_update:
|
|
num_cat = 0
|
|
for torrent in torrent_list:
|
|
if torrent.category == '':
|
|
for x in torrent.trackers:
|
|
if x.url.startswith('http'):
|
|
t_url = trunc_val(x.url, '/')
|
|
new_cat = get_category(torrent.save_path)
|
|
if dry_run:
|
|
logger.dryrun(f'\n - Torrent Name: {torrent.name}'
|
|
f'\n - New Category: {new_cat}'
|
|
f'\n - Tracker: {t_url}')
|
|
num_cat += 1
|
|
else:
|
|
logger.info(f'\n - Torrent Name: {torrent.name}'
|
|
f'\n - New Category: {new_cat}'
|
|
f'\n - Tracker: {t_url}')
|
|
torrent.set_category(category=new_cat)
|
|
num_cat += 1
|
|
if dry_run:
|
|
if num_cat >= 1:
|
|
logger.dryrun(f'Did not update {num_cat} new categories.')
|
|
else:
|
|
logger.dryrun(f'No new torrents to categorize.')
|
|
else:
|
|
if num_cat >= 1:
|
|
logger.info(f'Updated {num_cat} new categories.')
|
|
else:
|
|
logger.info(f'No new torrents to categorize.')
|
|
|
|
|
|
def set_tags():
|
|
if tag_update:
|
|
num_tags = 0
|
|
for torrent in torrent_list:
|
|
if torrent.tags == '' or ('cross-seed' in torrent.tags and len([e for e in torrent.tags.split(",") if not 'noHL' in e]) == 1):
|
|
new_tag,t_url = get_tags([x.url for x in torrent.trackers if x.url.startswith('http')])
|
|
if dry_run:
|
|
logger.dryrun(f'\n - Torrent Name: {torrent.name}'
|
|
f'\n - New Tag: {new_tag}'
|
|
f'\n - Tracker: {t_url}')
|
|
num_tags += 1
|
|
else:
|
|
logger.info(f'\n - Torrent Name: {torrent.name}'
|
|
f'\n - New Tag: {new_tag}'
|
|
f'\n - Tracker: {t_url}')
|
|
torrent.add_tags(tags=new_tag)
|
|
num_tags += 1
|
|
if dry_run:
|
|
if num_tags >= 1:
|
|
logger.dryrun(f'Did not update {num_tags} new tags.')
|
|
else:
|
|
logger.dryrun('No new torrents to tag.')
|
|
else:
|
|
if num_tags >= 1:
|
|
logger.info(f'Updated {num_tags} new tags.')
|
|
else:
|
|
logger.info('No new torrents to tag. ')
|
|
|
|
|
|
def set_rem_unregistered():
|
|
if rem_unregistered:
|
|
rem_unr = 0
|
|
del_tor = 0
|
|
pot_unr = ''
|
|
for torrent in torrent_list:
|
|
t_name = torrent.name
|
|
t_count = torrentdict[t_name]['count']
|
|
t_msg = torrentdict[t_name]['msg']
|
|
t_status = torrentdict[t_name]['status']
|
|
for x in torrent.trackers:
|
|
if x.url.startswith('http'):
|
|
t_url = trunc_val(x.url, '/')
|
|
msg_up = x.msg.upper()
|
|
n_info = (f'\n - Torrent Name: {t_name} '
|
|
f'\n - Status: {msg_up} '
|
|
f'\n - Tracker: {t_url} '
|
|
f'\n - Deleted .torrent but not content files.')
|
|
n_d_info = (f'\n - Torrent Name: {t_name} '
|
|
f'\n - Status: {msg_up} '
|
|
f'\n - Tracker: {t_url} '
|
|
f'\n - Deleted .torrent AND content files.')
|
|
if (x.status == 4 and 'DOWN' not in msg_up and 'UNREACHABLE' not in msg_up):
|
|
pot_unr += (f'\n - Torrent: {torrent.name}')
|
|
pot_unr += (f'\n - Message: {x.msg}')
|
|
if ('UNREGISTERED' in msg_up or \
|
|
'TORRENT NOT FOUND' in msg_up or \
|
|
'TORRENT IS NOT FOUND' in msg_up or \
|
|
'NOT REGISTERED' in msg_up or \
|
|
'HTTPS://BEYOND-HD.ME/TORRENTS' in msg_up or \
|
|
'NOT EXIST' in msg_up or \
|
|
'UNKNOWN TORRENT' in msg_up or \
|
|
'REDOWNLOAD' in msg_up or \
|
|
'PACKS' in msg_up or \
|
|
'REPACKED' in msg_up or \
|
|
'PACK' in msg_up or \
|
|
'TRUMP' in msg_up
|
|
) and x.status == 4 and 'DOWN' not in msg_up and 'UNREACHABLE' not in msg_up:
|
|
logger.debug(f'Torrent counts: {t_count}')
|
|
logger.debug(f'msg: {t_msg}')
|
|
logger.debug(f'status: {t_status}')
|
|
if t_count > 1:
|
|
if dry_run:
|
|
if '' in t_msg:
|
|
logger.dryrun(n_info)
|
|
rem_unr += 1
|
|
else:
|
|
logger.dryrun(n_d_info)
|
|
del_tor += 1
|
|
else:
|
|
# Checks if any of the original torrents are working
|
|
if '' in t_msg or 2 in t_status:
|
|
logger.info(n_info)
|
|
torrent.delete(hash=torrent.hash, delete_files=False)
|
|
rem_unr += 1
|
|
else:
|
|
logger.info(n_d_info)
|
|
tor_delete_recycle(torrent)
|
|
del_tor += 1
|
|
else:
|
|
if dry_run:
|
|
logger.dryrun(n_d_info)
|
|
del_tor += 1
|
|
else:
|
|
logger.info(n_d_info)
|
|
tor_delete_recycle(torrent)
|
|
del_tor += 1
|
|
if dry_run:
|
|
if rem_unr >= 1 or del_tor >= 1:
|
|
logger.dryrun(f'Did not delete {rem_unr} .torrents(s) but not content files.')
|
|
logger.dryrun(f'Did not delete {del_tor} .torrents(s) AND content files.')
|
|
else:
|
|
logger.dryrun('No unregistered torrents found.')
|
|
else:
|
|
if rem_unr >= 1 or del_tor >= 1:
|
|
logger.info(f'Deleted {rem_unr} .torrents(s) but not content files.')
|
|
logger.info(f'Deleted {del_tor} .torrents(s) AND content files.')
|
|
else:
|
|
logger.info('No unregistered torrents found.')
|
|
if (len(pot_unr) > 0):
|
|
logger.debug(f'Potential Unregistered torrents: {pot_unr}')
|
|
|
|
|
|
def set_rem_orphaned():
|
|
if rem_orphaned:
|
|
torrent_files = []
|
|
root_files = []
|
|
orphaned_files = []
|
|
|
|
if (remote_path != root_path):
|
|
root_files = [os.path.join(path.replace(remote_path,root_path), name) for path, subdirs, files in os.walk(remote_path) for name in files if os.path.join(remote_path,'orphaned_data') not in path and os.path.join(remote_path,'.RecycleBin') not in path]
|
|
else:
|
|
root_files = [os.path.join(path, name) for path, subdirs, files in os.walk(root_path) for name in files if os.path.join(root_path,'orphaned_data') not in path and os.path.join(root_path,'.RecycleBin') not in path]
|
|
|
|
for torrent in torrent_list:
|
|
for file in torrent.files:
|
|
torrent_files.append(os.path.join(torrent.save_path,file.name))
|
|
|
|
orphaned_files = set(root_files) - set(torrent_files)
|
|
orphaned_files = sorted(orphaned_files)
|
|
|
|
excluded_orphan_files = []
|
|
if 'orphaned' in cfg and cfg["orphaned"] is not None and 'exclude_patterns' in cfg['orphaned'] and cfg['orphaned']['exclude_patterns'] != '':
|
|
exclude_patterns = cfg['orphaned']['exclude_patterns']
|
|
excluded_orphan_files = [file for file in orphaned_files for exclude_pattern in exclude_patterns if fnmatch.fnmatch(file, exclude_pattern)]
|
|
|
|
orphaned_files = set(orphaned_files) - set(excluded_orphan_files)
|
|
|
|
logger.debug('----------torrent files-----------')
|
|
logger.debug("\n".join(torrent_files))
|
|
logger.debug('----------root_files-----------')
|
|
logger.debug("\n".join(root_files))
|
|
logger.debug('----------excluded_orphan_files-----------')
|
|
logger.debug("\n".join(excluded_orphan_files))
|
|
logger.debug('----------orphaned_files-----------')
|
|
logger.debug("\n".join(orphaned_files))
|
|
logger.debug('----------Deleting orphan files-----------')
|
|
if (orphaned_files):
|
|
if dry_run:
|
|
dir_out = os.path.join(remote_path,'orphaned_data')
|
|
logger.dryrun(f'\n----------{len(orphaned_files)} Orphan files found-----------'
|
|
f'\n - '+'\n - '.join(orphaned_files)+
|
|
f'\n - Did not move {len(orphaned_files)} Orphaned files to {dir_out.replace(remote_path,root_path)}')
|
|
else:
|
|
dir_out = os.path.join(remote_path,'orphaned_data')
|
|
os.makedirs(dir_out,exist_ok=True)
|
|
|
|
for file in orphaned_files:
|
|
src = file.replace(root_path,remote_path)
|
|
dest = os.path.join(dir_out,file.replace(root_path,''))
|
|
move_files(src,dest)
|
|
logger.info(f'\n----------{len(orphaned_files)} Orphan files found-----------'
|
|
f'\n - '+'\n - '.join(orphaned_files)+
|
|
f'\n - Moved {len(orphaned_files)} Orphaned files to {dir_out.replace(remote_path,root_path)}')
|
|
#Delete empty directories after moving orphan files
|
|
logger.info(f'Cleaning up any empty directories...')
|
|
remove_empty_directories(Path(remote_path),"**/*/*")
|
|
else:
|
|
if dry_run:
|
|
logger.dryrun('No Orphaned Files found.')
|
|
else:
|
|
logger.info('No Orphaned Files found.')
|
|
|
|
|
|
def set_tag_nohardlinks():
|
|
if tag_nohardlinks:
|
|
nohardlinks = cfg['nohardlinks']
|
|
n_info = ''
|
|
t_count = 0 #counter for the number of torrents that has no hard links
|
|
t_del = 0 #counter for the number of torrents that has no hard links and meets the criteria for ratio limit/seed limit for deletion
|
|
t_del_cs = 0 #counter for the number of torrents that has no hard links and meets the criteria for ratio limit/seed limit for deletion including cross-seeds
|
|
tdel_tags = 0 #counter for number of torrents that previously had no hard links but now have hard links
|
|
tdel_dict = {} #dictionary to track the torrent names and content path that meet the deletion criteria
|
|
t_excl_tags = []#list of tags to exclude based on config.yml
|
|
|
|
for category in nohardlinks:
|
|
torrent_list = client.torrents.info(category=category,filter='completed')
|
|
#Convert string to list if only one tag defined.
|
|
if ('exclude_tags' in nohardlinks[category]):
|
|
if isinstance(nohardlinks[category]['exclude_tags'],str):
|
|
t_excl_tags.append(nohardlinks[category]['exclude_tags'])
|
|
else:
|
|
t_excl_tags = nohardlinks[category]['exclude_tags']
|
|
|
|
if len(torrent_list) == 0:
|
|
logger.error('No torrents found in the category ('+category+') defined in config.yml inside the nohardlinks section. Please check if this matches with any category in qbittorrent and has 1 or more torrents.')
|
|
continue
|
|
for torrent in torrent_list:
|
|
if not dry_run:
|
|
torrent.resume()
|
|
if('exclude_tags' in nohardlinks[category] and (any(tag in torrent.tags for tag in t_excl_tags))):
|
|
#Skip to the next torrent if we find any torrents that are in the exclude tag
|
|
continue
|
|
else:
|
|
#Checks for any hard links and not already tagged
|
|
if (nohardlink(torrent['content_path'].replace(root_path,remote_path))):
|
|
#Will only tag new torrents that don't have noHL tag
|
|
if('noHL' not in torrent.tags):
|
|
t_count += 1
|
|
n_info += (f'\n - Torrent Name: {torrent.name} has no hard links found.')
|
|
n_info += (' Adding tags noHL.')
|
|
if(nohardlinks[category] != None):
|
|
#set the max seeding time for the torrent
|
|
if ('max_seeding_time' in nohardlinks[category]):
|
|
seeding_time_limit = nohardlinks[category]['max_seeding_time']
|
|
n_info += (' \n Setting max seed time to ' + str(seeding_time_limit) + '.')
|
|
else:
|
|
seeding_time_limit = -2
|
|
#set the max ratio for the torrent
|
|
if ('max_ratio' in nohardlinks[category]):
|
|
ratio_limit = nohardlinks[category]['max_ratio']
|
|
n_info += (' \n Setting max ratio to ' + str(ratio_limit)+ '.')
|
|
else:
|
|
ratio_limit = -2
|
|
else:
|
|
seeding_time_limit = -2
|
|
ratio_limit = -2
|
|
if not dry_run:
|
|
#set the tag for no hard links
|
|
torrent.add_tags(tags='noHL')
|
|
client.torrents_set_share_limits(ratio_limit,seeding_time_limit,torrent.hash)
|
|
|
|
#Cleans up previously tagged noHL torrents
|
|
else:
|
|
if(nohardlinks[category] != None):
|
|
# Deletes torrent with data if cleanup is set to true and meets the ratio/seeding requirements
|
|
if ('cleanup' in nohardlinks[category] and nohardlinks[category]['cleanup'] and torrent.state_enum.is_paused and len(nohardlinks[category])>0):
|
|
t_del += 1
|
|
n_info += (f'\n - Torrent Name: {torrent.name} has no hard links found and meets ratio/seeding requirements.')
|
|
tdel_dict[torrent.name] = torrent['content_path'].replace(root_path,remote_path)
|
|
if dry_run:
|
|
n_info += (' \n Cleanup flag set to true. NOT Deleting torrent + contents.')
|
|
else:
|
|
n_info += (' \n Cleanup flag set to true. Deleting torrent + contents.')
|
|
|
|
#Checks to see if previous noHL tagged torrents now have hard links.
|
|
if (not (nohardlink(torrent['content_path'].replace(root_path,remote_path))) and ('noHL' in torrent.tags)):
|
|
n_info += (f'\n - Previous Tagged noHL Torrent Name: {torrent.name} has hard links found now.')
|
|
n_info += (' Removing tags noHL.')
|
|
n_info += (' Removing ratio and seeding time limits.')
|
|
tdel_tags += 1
|
|
if not dry_run:
|
|
#Remove tags and share limits
|
|
torrent.remove_tags(tags='noHL')
|
|
client.torrents_set_share_limits(-2,-2,torrent.hash)
|
|
|
|
if(nohardlinks[category] != None):
|
|
#loop through torrent list again for cleanup purposes
|
|
if ('cleanup' in nohardlinks[category] and nohardlinks[category]['cleanup']):
|
|
for torrent in torrent_list:
|
|
if torrent.name in tdel_dict.keys() and 'noHL' in torrent.tags:
|
|
#Double check that the content path is the same before we delete anything
|
|
if torrent['content_path'].replace(root_path,remote_path) == tdel_dict[torrent.name]:
|
|
t_del_cs += 1
|
|
if not dry_run:
|
|
if (os.path.exists(torrent['content_path'].replace(root_path,remote_path))):
|
|
tor_delete_recycle(torrent)
|
|
else:
|
|
torrent.delete(hash=torrent.hash, delete_files=False)
|
|
|
|
if dry_run:
|
|
if t_count >= 1 or len(n_info) > 1:
|
|
logger.dryrun(n_info)
|
|
logger.dryrun(f'Did not tag/set ratio limit/seeding time for {t_count} .torrents(s)')
|
|
if t_del >= 1:
|
|
logger.dryrun(f'Did not delete {t_del} .torrents(s) or content files.')
|
|
logger.dryrun(f'Did not delete {t_del_cs} .torrents(s) (including cross-seed) or content files.')
|
|
if tdel_tags >= 1:
|
|
logger.dryrun(f'Did not delete noHL tags/ remove ratio limit/seeding time for {tdel_tags} .torrents(s)')
|
|
else:
|
|
logger.dryrun('No torrents to tag with no hard links.')
|
|
else:
|
|
if t_count >= 1 or len(n_info) > 1:
|
|
logger.info(n_info)
|
|
logger.info(f'tag/set ratio limit/seeding time for {t_count} .torrents(s)')
|
|
if t_del >= 1:
|
|
logger.info(f'Deleted {t_del} .torrents(s) AND content files.')
|
|
logger.info(f'Deleted {t_del_cs} .torrents(s) (includes cross-seed torrents) AND content files.')
|
|
if tdel_tags >= 1:
|
|
logger.info(f'Deleted noHL tags/ remove ratio limit/seeding time for {tdel_tags} .torrents(s)')
|
|
else:
|
|
logger.info('No torrents to tag with no hard links.')
|
|
|
|
|
|
#will check if there are any hard links if it passes a file or folder
|
|
def nohardlink(file):
|
|
check = True
|
|
if (os.path.isfile(file)):
|
|
if (os.stat(file).st_nlink > 1):
|
|
check = False
|
|
else:
|
|
for path, subdirs, files in os.walk(file):
|
|
for x in files:
|
|
if (os.stat(os.path.join(path,x)).st_nlink > 1):
|
|
check = False
|
|
return check
|
|
|
|
def tor_delete_recycle(torrent):
|
|
if 'recyclebin' in cfg and cfg["recyclebin"] != None:
|
|
if 'enabled' in cfg["recyclebin"] and cfg["recyclebin"]['enabled']:
|
|
tor_files = []
|
|
#Define torrent files/folders
|
|
for file in torrent.files:
|
|
tor_files.append(os.path.join(torrent.save_path,file.name))
|
|
|
|
#Create recycle bin if not exists
|
|
recycle_path = os.path.join(remote_path,'.RecycleBin')
|
|
os.makedirs(recycle_path,exist_ok=True)
|
|
|
|
#Move files from torrent contents to Recycle bin
|
|
for file in tor_files:
|
|
src = file.replace(root_path,remote_path)
|
|
dest = os.path.join(recycle_path,file.replace(root_path,''))
|
|
#move files and change date modified
|
|
move_files(src,dest,True)
|
|
logger.debug(f'\n----------Moving {len(tor_files)} files to RecycleBin -----------'
|
|
f'\n - '+'\n - '.join(tor_files)+
|
|
f'\n - Moved {len(tor_files)} files to {recycle_path.replace(remote_path,root_path)}')
|
|
#Delete torrent and files
|
|
torrent.delete(hash=torrent.hash, delete_files=False)
|
|
#Remove any empty directories
|
|
remove_empty_directories(Path(torrent.save_path.replace(root_path,remote_path)),"**/*")
|
|
else:
|
|
torrent.delete(hash=torrent.hash, delete_files=True)
|
|
else:
|
|
logger.error('recyclebin not defined in config.')
|
|
return
|
|
|
|
|
|
|
|
def set_empty_recycle():
|
|
if not skip_recycle:
|
|
num_del = 0
|
|
n_info = ''
|
|
if 'recyclebin' in cfg and cfg["recyclebin"] != None:
|
|
if 'enabled' in cfg["recyclebin"] and cfg["recyclebin"]['enabled'] and 'empty_after_x_days' in cfg["recyclebin"]:
|
|
if 'root_dir' in cfg['directory']:
|
|
root_path = os.path.join(cfg['directory']['root_dir'], '')
|
|
else:
|
|
logger.error('root_dir not defined in config. This is required to use recyclebin feature')
|
|
return
|
|
|
|
if ('remote_dir' in cfg['directory'] and cfg['directory']['remote_dir'] != ''):
|
|
remote_path = os.path.join(cfg['directory']['remote_dir'], '')
|
|
recycle_path = os.path.join(remote_path,'.RecycleBin')
|
|
else:
|
|
remote_path = root_path
|
|
recycle_path = os.path.join(root_path,'.RecycleBin')
|
|
recycle_files = [os.path.join(path, name) for path, subdirs, files in os.walk(recycle_path) for name in files]
|
|
recycle_files = sorted(recycle_files)
|
|
empty_after_x_days = cfg["recyclebin"]['empty_after_x_days']
|
|
if recycle_files:
|
|
for file in recycle_files:
|
|
fileStats = os.stat(file)
|
|
filename = file.replace(recycle_path,'')
|
|
last_modified = fileStats[stat.ST_MTIME] # in seconds (last modified time)
|
|
now = time.time() # in seconds
|
|
days = (now - last_modified) / (60 * 60 * 24)
|
|
if (empty_after_x_days <= days):
|
|
num_del += 1
|
|
if dry_run:
|
|
n_info += (f'Did not delete {filename} from the recycle bin. (Last modified {round(days)} days ago).\n')
|
|
else:
|
|
n_info += (f'Deleted {filename} from the recycle bin. (Last modified {round(days)} days ago).\n')
|
|
os.remove(file)
|
|
if num_del > 0:
|
|
if dry_run:
|
|
logger.dryrun(n_info)
|
|
logger.dryrun(f'Did not delete {num_del} files from the Recycle Bin.')
|
|
else:
|
|
remove_empty_directories(Path(recycle_path),"**/*")
|
|
logger.info(n_info)
|
|
logger.info(f'Deleted {num_del} files from the Recycle Bin.')
|
|
else:
|
|
logger.debug('No files found in "' + recycle_path + '"')
|
|
else:
|
|
logger.debug('Recycle bin has been disabled or "empty_after_x_days" var not defined in config.')
|
|
|
|
else:
|
|
logger.error('recyclebin not defined in config.')
|
|
return
|
|
|
|
|
|
#Define global parameters
|
|
torrent_list = None
|
|
torrentdict = None
|
|
def start():
|
|
#Global parameters to get the torrent dictionary
|
|
global torrent_list
|
|
global torrentdict
|
|
#Get an updated list of torrents
|
|
torrent_list = client.torrents.info(sort='added_on')
|
|
if recheck or cross_seed or rem_unregistered:
|
|
#Get an updated torrent dictionary information of the torrents
|
|
torrentdict = get_torrent_info(torrent_list)
|
|
set_category()
|
|
set_tags()
|
|
set_rem_unregistered()
|
|
set_cross_seed()
|
|
set_recheck()
|
|
set_rem_orphaned()
|
|
set_tag_nohardlinks()
|
|
set_empty_recycle()
|
|
|
|
if __name__ == '__main__':
|
|
logger.info(" _ _ _ ")
|
|
logger.info(" | | (_) | ")
|
|
logger.info(" __ _| |__ _| |_ _ __ ___ __ _ _ __ __ _ __ _ ___ ")
|
|
logger.info(" / _` | '_ \| | __| | '_ ` _ \ / _` | '_ \ / _` |/ _` |/ _ \\")
|
|
logger.info(" | (_| | |_) | | |_ | | | | | | (_| | | | | (_| | (_| | __/")
|
|
logger.info(" \__, |_.__/|_|\__| |_| |_| |_|\__,_|_| |_|\__,_|\__, |\___|")
|
|
logger.info(" | | ______ __/ | ")
|
|
logger.info(" |_| |______| |___/ ")
|
|
logger.info(f" Version: {version}")
|
|
try:
|
|
if run:
|
|
logger.info(f" Run Mode: Script will exit after completion.")
|
|
start()
|
|
else:
|
|
schedule.every(sch).minutes.do(start)
|
|
logger.info(f" Scheduled Mode: Running every {sch} minutes.")
|
|
start()
|
|
while True:
|
|
schedule.run_pending()
|
|
time.sleep(60)
|
|
except KeyboardInterrupt:
|
|
logger.info("Exiting Qbit_manage")
|