mirror of
https://github.com/StuffAnThings/qbit_manage.git
synced 2024-09-20 23:36:13 +08:00
1192 lines
64 KiB
Python
Executable file
1192 lines
64 KiB
Python
Executable file
import os
|
|
import sys
|
|
from collections import Counter
|
|
from datetime import timedelta
|
|
from fnmatch import fnmatch
|
|
|
|
from alive_progress import alive_it
|
|
from alive_progress import config_handler
|
|
from qbittorrentapi import APIConnectionError
|
|
from qbittorrentapi import Client
|
|
from qbittorrentapi import Conflict409Error
|
|
from qbittorrentapi import LoginFailed
|
|
from qbittorrentapi import NotFound404Error
|
|
from qbittorrentapi import Version
|
|
|
|
from modules import util
|
|
from modules.util import Failed
|
|
from modules.util import list_in_text
|
|
|
|
logger = util.logger
|
|
|
|
|
|
class Qbt:
|
|
def __init__(self, config, params):
|
|
self.config = config
|
|
config_handler.set_global(bar=None, receipt=False)
|
|
self.host = params["host"]
|
|
self.username = params["username"]
|
|
self.password = params["password"]
|
|
logger.secret(self.username)
|
|
logger.secret(self.password)
|
|
logger.debug(f"Host: {self.host}, Username: {self.username}, Password: {self.password}")
|
|
e = ""
|
|
try:
|
|
self.client = Client(host=self.host, username=self.username, password=self.password, VERIFY_WEBUI_CERTIFICATE=False)
|
|
self.client.auth_log_in()
|
|
|
|
SUPPORTED_VERSION = Version.latest_supported_app_version()
|
|
CURRENT_VERSION = self.client.app.version
|
|
MIN_SUPPORTED_VERSION = "v4.3.0"
|
|
logger.debug(f"qBittorrent: {self.client.app.version}")
|
|
logger.debug(f"qBittorrent Web API: {self.client.app.web_api_version}")
|
|
logger.debug(f"qbit_manage support versions: {MIN_SUPPORTED_VERSION} - {SUPPORTED_VERSION}")
|
|
if CURRENT_VERSION < MIN_SUPPORTED_VERSION:
|
|
e = (
|
|
f"Qbittorrent Error: qbit_manage is only comaptible with {MIN_SUPPORTED_VERSION} or higher. "
|
|
f"You are currently on {CURRENT_VERSION}."
|
|
+ "\n"
|
|
+ f"Please upgrade to your Qbittorrent version to {MIN_SUPPORTED_VERSION} or higher to use qbit_manage."
|
|
)
|
|
elif not Version.is_app_version_supported(CURRENT_VERSION):
|
|
e = (
|
|
f"Qbittorrent Error: qbit_manage is only comaptible with {SUPPORTED_VERSION} or lower. "
|
|
f"You are currently on {CURRENT_VERSION}."
|
|
+ "\n"
|
|
+ f"Please downgrade to your Qbittorrent version to {SUPPORTED_VERSION} to use qbit_manage."
|
|
)
|
|
if e:
|
|
self.config.notify(e, "Qbittorrent")
|
|
logger.print_line(e, "CRITICAL")
|
|
sys.exit(0)
|
|
else:
|
|
logger.info("Qbt Connection Successful")
|
|
except LoginFailed:
|
|
e = "Qbittorrent Error: Failed to login. Invalid username/password."
|
|
self.config.notify(e, "Qbittorrent")
|
|
raise Failed(e)
|
|
except APIConnectionError:
|
|
e = "Qbittorrent Error: Unable to connect to the client."
|
|
self.config.notify(e, "Qbittorrent")
|
|
raise Failed(e)
|
|
except Exception:
|
|
e = "Qbittorrent Error: Unable to connect to the client."
|
|
self.config.notify(e, "Qbittorrent")
|
|
raise Failed(e)
|
|
logger.separator("Getting Torrent List", space=False, border=False)
|
|
self.torrent_list = self.get_torrents({"sort": "added_on"})
|
|
|
|
# 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(torrent_list):
|
|
torrentdict = {}
|
|
t_obj_unreg = []
|
|
t_obj_valid = []
|
|
t_obj_list = []
|
|
settings = self.config.settings
|
|
logger.separator("Checking Settings", space=False, border=False)
|
|
if settings["force_auto_tmm"]:
|
|
logger.print_line(
|
|
"force_auto_tmm set to True. Will force Auto Torrent Management for all torrents.", self.config.loglevel
|
|
)
|
|
logger.separator("Gathering Torrent Information", space=True, border=True)
|
|
for torrent in alive_it(torrent_list):
|
|
is_complete = False
|
|
msg = None
|
|
status = None
|
|
working_tracker = None
|
|
issue = {"potential": False}
|
|
if (
|
|
torrent.auto_tmm is False
|
|
and settings["force_auto_tmm"]
|
|
and torrent.category != ""
|
|
and not self.config.dry_run
|
|
):
|
|
torrent.set_auto_management(True)
|
|
try:
|
|
torrent_name = torrent.name
|
|
torrent_hash = torrent.hash
|
|
torrent_is_complete = torrent.state_enum.is_complete
|
|
save_path = torrent.save_path
|
|
category = torrent.category
|
|
torrent_trackers = torrent.trackers
|
|
except Exception as e:
|
|
self.config.notify(e, "Get Torrent Info", False)
|
|
logger.warning(e)
|
|
if torrent_name in torrentdict:
|
|
t_obj_list.append(torrent)
|
|
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"] is True else torrent_is_complete
|
|
first_hash = torrentdict[torrent_name]["first_hash"]
|
|
else:
|
|
t_obj_list = [torrent]
|
|
t_count = 1
|
|
msg_list = []
|
|
status_list = []
|
|
is_complete = torrent_is_complete
|
|
first_hash = torrent_hash
|
|
for x in torrent_trackers:
|
|
if x.url.startswith("http"):
|
|
status = x.status
|
|
msg = x.msg.upper()
|
|
exception = [
|
|
"DOWN",
|
|
"DOWN.",
|
|
"IT MAY BE DOWN,",
|
|
"UNREACHABLE",
|
|
"(UNREACHABLE)",
|
|
"BAD GATEWAY",
|
|
"TRACKER UNAVAILABLE",
|
|
]
|
|
if x.status == 2:
|
|
working_tracker = True
|
|
break
|
|
# Add any potential unregistered torrents to a list
|
|
if x.status == 4 and not list_in_text(msg, exception):
|
|
issue["potential"] = True
|
|
issue["msg"] = msg
|
|
issue["status"] = status
|
|
if working_tracker:
|
|
status = 2
|
|
msg = ""
|
|
t_obj_valid.append(torrent)
|
|
elif issue["potential"]:
|
|
status = issue["status"]
|
|
msg = issue["msg"]
|
|
t_obj_unreg.append(torrent)
|
|
if msg is not None:
|
|
msg_list.append(msg)
|
|
if status is not None:
|
|
status_list.append(status)
|
|
torrentattr = {
|
|
"torrents": t_obj_list,
|
|
"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, t_obj_unreg, t_obj_valid
|
|
|
|
self.torrentinfo = None
|
|
self.torrentissue = None
|
|
self.torrentvalid = None
|
|
if (
|
|
config.commands["recheck"]
|
|
or config.commands["cross_seed"]
|
|
or config.commands["rem_unregistered"]
|
|
or config.commands["tag_tracker_error"]
|
|
or config.commands["tag_nohardlinks"]
|
|
):
|
|
# Get an updated torrent dictionary information of the torrents
|
|
self.torrentinfo, self.torrentissue, self.torrentvalid = get_torrent_info(self.torrent_list)
|
|
|
|
def get_torrents(self, params):
|
|
return self.client.torrents.info(**params)
|
|
|
|
def category(self):
|
|
num_cat = 0
|
|
|
|
def update_cat(new_cat, cat_change):
|
|
nonlocal torrent, num_cat
|
|
tracker = self.config.get_tags([x.url for x in torrent.trackers if x.url.startswith("http")])
|
|
old_cat = torrent.category
|
|
if not self.config.dry_run:
|
|
try:
|
|
torrent.set_category(category=new_cat)
|
|
if torrent.auto_tmm is False and self.config.settings["force_auto_tmm"]:
|
|
torrent.set_auto_management(True)
|
|
except Conflict409Error:
|
|
e = logger.print_line(
|
|
f'Existing category "{new_cat}" not found for save path {torrent.save_path}, category will be created.',
|
|
self.config.loglevel,
|
|
)
|
|
self.config.notify(e, "Update Category", False)
|
|
self.client.torrent_categories.create_category(name=new_cat, save_path=torrent.save_path)
|
|
torrent.set_category(category=new_cat)
|
|
body = []
|
|
body += logger.print_line(logger.insert_space(f"Torrent Name: {torrent.name}", 3), self.config.loglevel)
|
|
if cat_change:
|
|
body += logger.print_line(logger.insert_space(f"Old Category: {old_cat}", 3), self.config.loglevel)
|
|
title = "Moving Categories"
|
|
else:
|
|
title = "Updating Categories"
|
|
body += logger.print_line(logger.insert_space(f"New Category: {new_cat}", 3), self.config.loglevel)
|
|
body += logger.print_line(logger.insert_space(f'Tracker: {tracker["url"]}', 8), self.config.loglevel)
|
|
attr = {
|
|
"function": "cat_update",
|
|
"title": title,
|
|
"body": "\n".join(body),
|
|
"torrent_name": torrent.name,
|
|
"torrent_category": new_cat,
|
|
"torrent_tracker": tracker["url"],
|
|
"notifiarr_indexer": tracker["notifiarr"],
|
|
}
|
|
self.config.send_notifications(attr)
|
|
num_cat += 1
|
|
|
|
if self.config.commands["cat_update"]:
|
|
logger.separator("Updating Categories", space=False, border=False)
|
|
torrent_list = self.get_torrents({"category": "", "filter": "completed"})
|
|
for torrent in torrent_list:
|
|
new_cat = self.config.get_category(torrent.save_path)
|
|
update_cat(new_cat, False)
|
|
|
|
# Change categories
|
|
if self.config.cat_change:
|
|
for old_cat in self.config.cat_change:
|
|
torrent_list = self.get_torrents({"category": old_cat, "filter": "completed"})
|
|
for torrent in torrent_list:
|
|
new_cat = self.config.cat_change[old_cat]
|
|
update_cat(new_cat, True)
|
|
|
|
if num_cat >= 1:
|
|
logger.print_line(
|
|
f"{'Did not update' if self.config.dry_run else 'Updated'} {num_cat} new categories.", self.config.loglevel
|
|
)
|
|
else:
|
|
logger.print_line("No new torrents to categorize.", self.config.loglevel)
|
|
return num_cat
|
|
|
|
def tags(self):
|
|
num_tags = 0
|
|
ignore_tags = self.config.settings["ignoreTags_OnUpdate"]
|
|
if self.config.commands["tag_update"]:
|
|
logger.separator("Updating Tags", space=False, border=False)
|
|
for torrent in self.torrent_list:
|
|
check_tags = util.get_list(torrent.tags)
|
|
if torrent.tags == "" or (len([x for x in check_tags if x not in ignore_tags]) == 0):
|
|
tracker = self.config.get_tags([x.url for x in torrent.trackers if x.url.startswith("http")])
|
|
if tracker["tag"]:
|
|
num_tags += len(tracker["tag"])
|
|
body = []
|
|
body += logger.print_line(logger.insert_space(f"Torrent Name: {torrent.name}", 3), self.config.loglevel)
|
|
body += logger.print_line(
|
|
logger.insert_space(
|
|
f'New Tag{"s" if len(tracker["tag"]) > 1 else ""}: {", ".join(tracker["tag"])}', 8
|
|
),
|
|
self.config.loglevel,
|
|
)
|
|
body += logger.print_line(logger.insert_space(f'Tracker: {tracker["url"]}', 8), self.config.loglevel)
|
|
body.extend(
|
|
self.set_tags_and_limits(
|
|
torrent,
|
|
tracker["max_ratio"],
|
|
tracker["max_seeding_time"],
|
|
tracker["limit_upload_speed"],
|
|
tracker["tag"],
|
|
)
|
|
)
|
|
category = self.config.get_category(torrent.save_path) if torrent.category == "" else torrent.category
|
|
attr = {
|
|
"function": "tag_update",
|
|
"title": "Updating Tags",
|
|
"body": "\n".join(body),
|
|
"torrent_name": torrent.name,
|
|
"torrent_category": category,
|
|
"torrent_tag": ", ".join(tracker["tag"]),
|
|
"torrent_tracker": tracker["url"],
|
|
"notifiarr_indexer": tracker["notifiarr"],
|
|
"torrent_max_ratio": tracker["max_ratio"],
|
|
"torrent_max_seeding_time": tracker["max_seeding_time"],
|
|
"torrent_limit_upload_speed": tracker["limit_upload_speed"],
|
|
}
|
|
self.config.send_notifications(attr)
|
|
if num_tags >= 1:
|
|
logger.print_line(
|
|
f"{'Did not update' if self.config.dry_run else 'Updated'} {num_tags} new tags.", self.config.loglevel
|
|
)
|
|
else:
|
|
logger.print_line("No new torrents to tag.", self.config.loglevel)
|
|
return num_tags
|
|
|
|
def set_tags_and_limits(self, torrent, max_ratio, max_seeding_time, limit_upload_speed=None, tags=None, restore=False):
|
|
body = []
|
|
if limit_upload_speed:
|
|
if limit_upload_speed == -1:
|
|
body += logger.print_line(logger.insert_space("Limit UL Speed: Infinity", 1), self.config.loglevel)
|
|
else:
|
|
body += logger.print_line(
|
|
logger.insert_space(f"Limit UL Speed: {limit_upload_speed} kB/s", 1), self.config.loglevel
|
|
)
|
|
if max_ratio or max_seeding_time:
|
|
if (max_ratio == -2 or max_seeding_time == -2) and not restore:
|
|
body += logger.print_line(logger.insert_space("Share Limit: Use Global Share Limit", 4), self.config.loglevel)
|
|
elif (max_ratio == -1 or max_seeding_time == -1) and not restore:
|
|
body += logger.print_line(logger.insert_space("Share Limit: Set No Share Limit", 4), self.config.loglevel)
|
|
else:
|
|
if max_ratio != torrent.max_ratio and (not max_seeding_time or max_seeding_time < 0):
|
|
body += logger.print_line(
|
|
logger.insert_space(f"Share Limit: Max Ratio = {max_ratio}", 4), self.config.loglevel
|
|
)
|
|
elif max_seeding_time != torrent.max_seeding_time and (not max_ratio or max_ratio < 0):
|
|
body += logger.print_line(
|
|
logger.insert_space(f"Share Limit: Max Seed Time = {max_seeding_time} min", 4), self.config.loglevel
|
|
)
|
|
elif max_ratio != torrent.max_ratio and max_seeding_time != torrent.max_seeding_time:
|
|
body += logger.print_line(
|
|
logger.insert_space(f"Share Limit: Max Ratio = {max_ratio}, Max Seed Time = {max_seeding_time} min", 4),
|
|
self.config.loglevel,
|
|
)
|
|
# Update Torrents
|
|
if not self.config.dry_run:
|
|
if tags:
|
|
torrent.add_tags(tags)
|
|
if limit_upload_speed:
|
|
if limit_upload_speed == -1:
|
|
torrent.set_upload_limit(-1)
|
|
else:
|
|
torrent.set_upload_limit(limit_upload_speed * 1024)
|
|
if (max_ratio or max_seeding_time) and not restore:
|
|
if max_ratio == -2 or max_seeding_time == -2:
|
|
torrent.set_share_limits(-2, -2)
|
|
return body
|
|
elif max_ratio == -1 or max_seeding_time == -1:
|
|
torrent.set_share_limits(-1, -1)
|
|
return body
|
|
if not max_ratio:
|
|
max_ratio = torrent.max_ratio
|
|
if not max_seeding_time:
|
|
max_seeding_time = torrent.max_seeding_time
|
|
torrent.set_share_limits(max_ratio, max_seeding_time)
|
|
return body
|
|
|
|
def tag_nohardlinks(self):
|
|
num_tags = 0 # counter for the number of torrents that has no hard links
|
|
del_tor = 0 # counter for the number of torrents that has no hard links and \
|
|
# meets the criteria for ratio limit/seed limit for deletion
|
|
del_tor_cont = 0 # counter for the number of torrents that has no hard links and \
|
|
# meets the criteria for ratio limit/seed limit for deletion including contents
|
|
num_untag = 0 # counter for number of torrents that previously had no hard links but now have hard links
|
|
|
|
if self.config.commands["tag_nohardlinks"]:
|
|
logger.separator("Tagging Torrents with No Hardlinks", space=False, border=False)
|
|
nohardlinks = self.config.nohardlinks
|
|
tdel_dict = {} # dictionary to track the torrent names and content path that meet the deletion criteria
|
|
root_dir = self.config.root_dir
|
|
remote_dir = self.config.remote_dir
|
|
for category in nohardlinks:
|
|
torrent_list = self.get_torrents({"category": category, "filter": "completed"})
|
|
if len(torrent_list) == 0:
|
|
e = (
|
|
"No torrents found in the category ("
|
|
+ category
|
|
+ ") defined under nohardlinks attribute in the config. "
|
|
+ "Please check if this matches with any category in qbittorrent and has 1 or more torrents."
|
|
)
|
|
# self.config.notify(e, 'Tag No Hard Links', False)
|
|
logger.warning(e)
|
|
continue
|
|
for torrent in torrent_list:
|
|
tracker = self.config.get_tags([x.url for x in torrent.trackers if x.url.startswith("http")])
|
|
if any(tag in torrent.tags for tag in nohardlinks[category]["exclude_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 util.nohardlink(torrent["content_path"].replace(root_dir, remote_dir)):
|
|
# Will only tag new torrents that don't have noHL tag
|
|
if "noHL" not in torrent.tags:
|
|
num_tags += 1
|
|
body = []
|
|
body += logger.print_line(
|
|
logger.insert_space(f"Torrent Name: {torrent.name}", 3), self.config.loglevel
|
|
)
|
|
body += logger.print_line(logger.insert_space("Added Tag: noHL", 6), self.config.loglevel)
|
|
body += logger.print_line(
|
|
logger.insert_space(f'Tracker: {tracker["url"]}', 8), self.config.loglevel
|
|
)
|
|
body.extend(
|
|
self.set_tags_and_limits(
|
|
torrent,
|
|
nohardlinks[category]["max_ratio"],
|
|
nohardlinks[category]["max_seeding_time"],
|
|
nohardlinks[category]["limit_upload_speed"],
|
|
tags="noHL",
|
|
)
|
|
)
|
|
attr = {
|
|
"function": "tag_nohardlinks",
|
|
"title": "Tagging Torrents with No Hardlinks",
|
|
"body": "\n".join(body),
|
|
"torrent_name": torrent.name,
|
|
"torrent_category": torrent.category,
|
|
"torrent_tag": "noHL",
|
|
"torrent_tracker": tracker["url"],
|
|
"notifiarr_indexer": tracker["notifiarr"],
|
|
"torrent_max_ratio": nohardlinks[category]["max_ratio"],
|
|
"torrent_max_seeding_time": nohardlinks[category]["max_seeding_time"],
|
|
"torrent_limit_upload_speed": nohardlinks[category]["limit_upload_speed"],
|
|
}
|
|
self.config.send_notifications(attr)
|
|
# Cleans up previously tagged noHL torrents
|
|
else:
|
|
# Determine min_seeding_time. noHl > Tracker w/ default 0
|
|
min_seeding_time = 0
|
|
tracker = self.config.get_tags([x.url for x in torrent.trackers if x.url.startswith("http")])
|
|
if nohardlinks[category]["min_seeding_time"]:
|
|
min_seeding_time = nohardlinks[category]["min_seeding_time"]
|
|
elif tracker["min_seeding_time"]:
|
|
min_seeding_time = tracker["min_seeding_time"]
|
|
|
|
# Deletes torrent with data if cleanup is set to true and meets the ratio/seeding requirements
|
|
if (
|
|
nohardlinks[category]["cleanup"]
|
|
and torrent.state_enum.is_paused
|
|
and len(nohardlinks[category]) > 0
|
|
and torrent.seeding_time > (min_seeding_time * 60)
|
|
):
|
|
tdel_dict[torrent.name] = torrent["content_path"].replace(root_dir, root_dir)
|
|
# Checks to see if previous noHL tagged torrents now have hard links.
|
|
if not (util.nohardlink(torrent["content_path"].replace(root_dir, root_dir))) and ("noHL" in torrent.tags):
|
|
num_untag += 1
|
|
body = []
|
|
body += logger.print_line(
|
|
f"Previous Tagged noHL Torrent Name: {torrent.name} has hard links found now.", self.config.loglevel
|
|
)
|
|
body += logger.print_line(logger.insert_space("Removed Tag: noHL", 6), self.config.loglevel)
|
|
body += logger.print_line(logger.insert_space(f'Tracker: {tracker["url"]}', 8), self.config.loglevel)
|
|
body += logger.print_line(
|
|
f"{'Not Reverting' if self.config.dry_run else 'Reverting'} share limits.", self.config.loglevel
|
|
)
|
|
restore_max_ratio = tracker["max_ratio"]
|
|
restore_max_seeding_time = tracker["max_seeding_time"]
|
|
restore_limit_upload_speed = tracker["limit_upload_speed"]
|
|
if restore_max_ratio is None:
|
|
restore_max_ratio = -2
|
|
if restore_max_seeding_time is None:
|
|
restore_max_seeding_time = -2
|
|
if restore_limit_upload_speed is None:
|
|
restore_limit_upload_speed = -1
|
|
if not self.config.dry_run:
|
|
torrent.remove_tags(tags="noHL")
|
|
body.extend(
|
|
self.set_tags_and_limits(
|
|
torrent, restore_max_ratio, restore_max_seeding_time, restore_limit_upload_speed, restore=True
|
|
)
|
|
)
|
|
if torrent.state == "pausedUP" and nohardlinks[category]["resume_torrent_after_untagging_noHL"]:
|
|
torrent.resume()
|
|
attr = {
|
|
"function": "untag_nohardlinks",
|
|
"title": "Untagging Previous Torrents that now have Hard Links",
|
|
"body": "\n".join(body),
|
|
"torrent_name": torrent.name,
|
|
"torrent_category": torrent.category,
|
|
"torrent_tag": "noHL",
|
|
"torrent_tracker": tracker["url"],
|
|
"notifiarr_indexer": tracker["notifiarr"],
|
|
"torrent_max_ratio": restore_max_ratio,
|
|
"torrent_max_seeding_time": restore_max_seeding_time,
|
|
"torrent_limit_upload_speed": restore_limit_upload_speed,
|
|
}
|
|
self.config.send_notifications(attr)
|
|
# loop through torrent list again for cleanup purposes
|
|
if nohardlinks[category]["cleanup"]:
|
|
for torrent in torrent_list:
|
|
t_name = torrent.name
|
|
if t_name in tdel_dict.keys() and "noHL" in torrent.tags:
|
|
t_count = self.torrentinfo[t_name]["count"]
|
|
t_msg = self.torrentinfo[t_name]["msg"]
|
|
t_status = self.torrentinfo[t_name]["status"]
|
|
# Double check that the content path is the same before we delete anything
|
|
if torrent["content_path"].replace(root_dir, root_dir) == tdel_dict[t_name]:
|
|
tracker = self.config.get_tags([x.url for x in torrent.trackers if x.url.startswith("http")])
|
|
body = []
|
|
body += logger.print_line(logger.insert_space(f"Torrent Name: {t_name}", 3), self.config.loglevel)
|
|
body += logger.print_line(
|
|
logger.insert_space(f'Tracker: {tracker["url"]}', 8), self.config.loglevel
|
|
)
|
|
body += logger.print_line(
|
|
logger.insert_space("Cleanup: True [No hard links found and meets Share Limits.]", 8),
|
|
self.config.loglevel,
|
|
)
|
|
attr = {
|
|
"function": "cleanup_tag_nohardlinks",
|
|
"title": "Removing NoHL Torrents and meets Share Limits",
|
|
"torrent_name": t_name,
|
|
"torrent_category": torrent.category,
|
|
"cleanup": "True",
|
|
"torrent_tracker": tracker["url"],
|
|
"notifiarr_indexer": tracker["notifiarr"],
|
|
}
|
|
if os.path.exists(torrent["content_path"].replace(root_dir, root_dir)):
|
|
# Checks if any of the original torrents are working
|
|
if t_count > 1 and ("" in t_msg or 2 in t_status):
|
|
del_tor += 1
|
|
attr["torrents_deleted_and_contents"] = False
|
|
if not self.config.dry_run:
|
|
self.tor_delete_recycle(torrent, attr)
|
|
body += logger.print_line(
|
|
logger.insert_space("Deleted .torrent but NOT content files.", 8),
|
|
self.config.loglevel,
|
|
)
|
|
else:
|
|
del_tor_cont += 1
|
|
attr["torrents_deleted_and_contents"] = True
|
|
if not self.config.dry_run:
|
|
self.tor_delete_recycle(torrent, attr)
|
|
body += logger.print_line(
|
|
logger.insert_space("Deleted .torrent AND content files.", 8), self.config.loglevel
|
|
)
|
|
else:
|
|
del_tor += 1
|
|
attr["torrents_deleted_and_contents"] = False
|
|
if not self.config.dry_run:
|
|
self.tor_delete_recycle(torrent, attr)
|
|
body += logger.print_line(
|
|
logger.insert_space("Deleted .torrent but NOT content files.", 8), self.config.loglevel
|
|
)
|
|
attr["body"] = "\n".join(body)
|
|
self.config.send_notifications(attr)
|
|
self.torrentinfo[t_name]["count"] -= 1
|
|
if num_tags >= 1:
|
|
logger.print_line(
|
|
f"{'Did not Tag/set' if self.config.dry_run else 'Tag/set'} share limits for {num_tags} "
|
|
f".torrent{'s.' if num_tags > 1 else '.'}",
|
|
self.config.loglevel,
|
|
)
|
|
else:
|
|
logger.print_line("No torrents to tag with no hard links.", self.config.loglevel)
|
|
if num_untag >= 1:
|
|
logger.print_line(
|
|
f"{'Did not delete' if self.config.dry_run else 'Deleted'} noHL tags / share limits for {num_untag} "
|
|
f".torrent{'s.' if num_untag > 1 else '.'}",
|
|
self.config.loglevel,
|
|
)
|
|
if del_tor >= 1:
|
|
logger.print_line(
|
|
f"{'Did not delete' if self.config.dry_run else 'Deleted'} {del_tor} "
|
|
f".torrent{'s' if del_tor > 1 else ''} but not content files.",
|
|
self.config.loglevel,
|
|
)
|
|
if del_tor_cont >= 1:
|
|
logger.print_line(
|
|
f"{'Did not delete' if self.config.dry_run else 'Deleted'} {del_tor_cont} "
|
|
f".torrent{'s' if del_tor_cont > 1 else ''} AND content files.",
|
|
self.config.loglevel,
|
|
)
|
|
return num_tags, num_untag, del_tor, del_tor_cont
|
|
|
|
def rem_unregistered(self):
|
|
del_tor = 0
|
|
del_tor_cont = 0
|
|
num_tor_error = 0
|
|
num_untag = 0
|
|
tor_error_summary = ""
|
|
tag_error = self.config.settings["tracker_error_tag"]
|
|
cfg_rem_unregistered = self.config.commands["rem_unregistered"]
|
|
cfg_tag_error = self.config.commands["tag_tracker_error"]
|
|
|
|
def tag_tracker_error():
|
|
nonlocal t_name, msg_up, msg, tracker, t_cat, torrent, tag_error, tor_error_summary, num_tor_error
|
|
tor_error = ""
|
|
tor_error += logger.insert_space(f"Torrent Name: {t_name}", 3) + "\n"
|
|
tor_error += logger.insert_space(f"Status: {msg}", 9) + "\n"
|
|
tor_error += logger.insert_space(f'Tracker: {tracker["url"]}', 8) + "\n"
|
|
tor_error += logger.insert_space(f"Added Tag: {tag_error}", 6) + "\n"
|
|
tor_error_summary += tor_error
|
|
num_tor_error += 1
|
|
attr = {
|
|
"function": "tag_tracker_error",
|
|
"title": "Tag Tracker Error Torrents",
|
|
"body": tor_error,
|
|
"torrent_name": t_name,
|
|
"torrent_category": t_cat,
|
|
"torrent_tag": tag_error,
|
|
"torrent_status": msg,
|
|
"torrent_tracker": tracker["url"],
|
|
"notifiarr_indexer": tracker["notifiarr"],
|
|
}
|
|
self.config.send_notifications(attr)
|
|
if not self.config.dry_run:
|
|
torrent.add_tags(tags=tag_error)
|
|
|
|
def del_unregistered():
|
|
nonlocal del_tor, del_tor_cont, t_name, msg_up, msg, tracker, t_cat, t_msg, t_status, torrent
|
|
body = []
|
|
body += logger.print_line(logger.insert_space(f"Torrent Name: {t_name}", 3), self.config.loglevel)
|
|
body += logger.print_line(logger.insert_space(f"Status: {msg}", 9), self.config.loglevel)
|
|
body += logger.print_line(logger.insert_space(f'Tracker: {tracker["url"]}', 8), self.config.loglevel)
|
|
attr = {
|
|
"function": "rem_unregistered",
|
|
"title": "Removing Unregistered Torrents",
|
|
"torrent_name": t_name,
|
|
"torrent_category": t_cat,
|
|
"torrent_status": msg,
|
|
"torrent_tracker": tracker["url"],
|
|
"notifiarr_indexer": tracker["notifiarr"],
|
|
}
|
|
if t_count > 1:
|
|
# Checks if any of the original torrents are working
|
|
if "" in t_msg or 2 in t_status:
|
|
attr["torrents_deleted_and_contents"] = False
|
|
if not self.config.dry_run:
|
|
self.tor_delete_recycle(torrent, attr)
|
|
body += logger.print_line(
|
|
logger.insert_space("Deleted .torrent but NOT content files.", 8), self.config.loglevel
|
|
)
|
|
del_tor += 1
|
|
else:
|
|
attr["torrents_deleted_and_contents"] = True
|
|
if not self.config.dry_run:
|
|
self.tor_delete_recycle(torrent, attr)
|
|
body += logger.print_line(logger.insert_space("Deleted .torrent AND content files.", 8), self.config.loglevel)
|
|
del_tor_cont += 1
|
|
else:
|
|
attr["torrents_deleted_and_contents"] = True
|
|
if not self.config.dry_run:
|
|
self.tor_delete_recycle(torrent, attr)
|
|
body += logger.print_line(logger.insert_space("Deleted .torrent AND content files.", 8), self.config.loglevel)
|
|
del_tor_cont += 1
|
|
attr["body"] = "\n".join(body)
|
|
self.config.send_notifications(attr)
|
|
self.torrentinfo[t_name]["count"] -= 1
|
|
|
|
if cfg_rem_unregistered or cfg_tag_error:
|
|
if cfg_tag_error:
|
|
logger.separator("Tagging Torrents with Tracker Errors", space=False, border=False)
|
|
elif cfg_rem_unregistered:
|
|
logger.separator("Removing Unregistered Torrents", space=False, border=False)
|
|
unreg_msgs = [
|
|
"UNREGISTERED",
|
|
"TORRENT NOT FOUND",
|
|
"TORRENT IS NOT FOUND",
|
|
"NOT REGISTERED",
|
|
"NOT EXIST",
|
|
"UNKNOWN TORRENT",
|
|
"TRUMP",
|
|
"RETITLED",
|
|
"TRUNCATED",
|
|
"TORRENT IS NOT AUTHORIZED FOR USE ON THIS TRACKER",
|
|
]
|
|
ignore_msgs = [
|
|
"YOU HAVE REACHED THE CLIENT LIMIT FOR THIS TORRENT",
|
|
"MISSING PASSKEY",
|
|
"MISSING INFO_HASH",
|
|
"PASSKEY IS INVALID",
|
|
"INVALID PASSKEY",
|
|
"EXPECTED VALUE (LIST, DICT, INT OR STRING) IN BENCODED STRING",
|
|
"COULD NOT PARSE BENCODED DATA",
|
|
"STREAM TRUNCATED",
|
|
]
|
|
for torrent in self.torrentvalid:
|
|
check_tags = util.get_list(torrent.tags)
|
|
# Remove any error torrents Tags that are no longer unreachable.
|
|
if tag_error in check_tags:
|
|
tracker = self.config.get_tags([x.url for x in torrent.trackers if x.url.startswith("http")])
|
|
num_untag += 1
|
|
body = []
|
|
body += logger.print_line(
|
|
f"Previous Tagged {tag_error} torrent currently has a working tracker.", self.config.loglevel
|
|
)
|
|
body += logger.print_line(logger.insert_space(f"Torrent Name: {torrent.name}", 3), self.config.loglevel)
|
|
body += logger.print_line(logger.insert_space(f"Removed Tag: {tag_error}", 4), self.config.loglevel)
|
|
body += logger.print_line(logger.insert_space(f'Tracker: {tracker["url"]}', 8), self.config.loglevel)
|
|
if not self.config.dry_run:
|
|
torrent.remove_tags(tags=tag_error)
|
|
attr = {
|
|
"function": "untag_tracker_error",
|
|
"title": "Untagging Tracker Error Torrent",
|
|
"body": "\n".join(body),
|
|
"torrent_name": torrent.name,
|
|
"torrent_category": torrent.category,
|
|
"torrent_tag": tag_error,
|
|
"torrent_tracker": tracker["url"],
|
|
"notifiarr_indexer": tracker["notifiarr"],
|
|
}
|
|
self.config.send_notifications(attr)
|
|
for torrent in self.torrentissue:
|
|
t_name = torrent.name
|
|
t_cat = self.torrentinfo[t_name]["Category"]
|
|
t_count = self.torrentinfo[t_name]["count"]
|
|
t_msg = self.torrentinfo[t_name]["msg"]
|
|
t_status = self.torrentinfo[t_name]["status"]
|
|
check_tags = util.get_list(torrent.tags)
|
|
try:
|
|
for x in torrent.trackers:
|
|
if x.url.startswith("http"):
|
|
tracker = self.config.get_tags([x.url])
|
|
msg_up = x.msg.upper()
|
|
msg = x.msg
|
|
# Tag any error torrents
|
|
if cfg_tag_error:
|
|
if x.status == 4 and tag_error not in check_tags:
|
|
tag_tracker_error()
|
|
if cfg_rem_unregistered:
|
|
# Tag any error torrents that are not unregistered
|
|
if not list_in_text(msg_up, unreg_msgs) and x.status == 4 and tag_error not in check_tags:
|
|
# Check for unregistered torrents using BHD API if the tracker is BHD
|
|
if (
|
|
"tracker.beyond-hd.me" in tracker["url"]
|
|
and self.config.BeyondHD is not None
|
|
and not list_in_text(msg_up, ignore_msgs)
|
|
):
|
|
json = {"info_hash": torrent.hash}
|
|
response = self.config.BeyondHD.search(json)
|
|
if response["total_results"] == 0:
|
|
del_unregistered()
|
|
break
|
|
tag_tracker_error()
|
|
if list_in_text(msg_up, unreg_msgs) and not list_in_text(msg_up, ignore_msgs) and x.status == 4:
|
|
del_unregistered()
|
|
break
|
|
except NotFound404Error:
|
|
continue
|
|
except Exception as e:
|
|
logger.stacktrace()
|
|
self.config.notify(e, "Remove Unregistered Torrents", False)
|
|
logger.error(f"Unknown Error: {e}")
|
|
if cfg_rem_unregistered:
|
|
if del_tor >= 1 or del_tor_cont >= 1:
|
|
if del_tor >= 1:
|
|
logger.print_line(
|
|
f"{'Did not delete' if self.config.dry_run else 'Deleted'} {del_tor} "
|
|
f".torrent{'s' if del_tor > 1 else ''} but not content files.",
|
|
self.config.loglevel,
|
|
)
|
|
if del_tor_cont >= 1:
|
|
logger.print_line(
|
|
f"{'Did not delete' if self.config.dry_run else 'Deleted'} {del_tor_cont} "
|
|
f".torrent{'s' if del_tor_cont > 1 else ''} AND content files.",
|
|
self.config.loglevel,
|
|
)
|
|
else:
|
|
logger.print_line("No unregistered torrents found.", self.config.loglevel)
|
|
if num_untag >= 1:
|
|
logger.print_line(
|
|
f"{'Did not delete' if self.config.dry_run else 'Deleted'} {tag_error} tags for {num_untag} "
|
|
f".torrent{'s.' if num_untag > 1 else '.'}",
|
|
self.config.loglevel,
|
|
)
|
|
if num_tor_error >= 1:
|
|
logger.separator(
|
|
f"{num_tor_error} Torrents with tracker errors found",
|
|
space=False,
|
|
border=False,
|
|
loglevel=self.config.loglevel,
|
|
)
|
|
logger.print_line(tor_error_summary.rstrip(), self.config.loglevel)
|
|
return del_tor, del_tor_cont, num_tor_error, num_untag
|
|
|
|
# Function used to move any torrents from the cross seed directory to the correct save directory
|
|
def cross_seed(self):
|
|
added = 0 # Keep track of total torrents tagged
|
|
tagged = 0 # Track # of torrents tagged that are not cross-seeded
|
|
if self.config.commands["cross_seed"]:
|
|
logger.separator("Checking for Cross-Seed Torrents", space=False, border=False)
|
|
# List of categories for all torrents moved
|
|
categories = []
|
|
|
|
# Only get torrent files
|
|
cs_files = [f for f in os.listdir(self.config.cross_seed_dir) if f.endswith("torrent")]
|
|
dir_cs = self.config.cross_seed_dir
|
|
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]
|
|
t_tracker = file.split("]", 2)[1][1:]
|
|
# 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], self.torrentinfo.items()))
|
|
if torrentdict_file:
|
|
# Get the exact torrent match name from torrentdict
|
|
t_name = next(iter(torrentdict_file))
|
|
dest = os.path.join(self.torrentinfo[t_name]["save_path"], "")
|
|
src = os.path.join(dir_cs, file)
|
|
dir_cs_out = os.path.join(dir_cs, "qbit_manage_added", file)
|
|
category = self.config.get_category(dest)
|
|
# Only add cross-seed torrent if original torrent is complete
|
|
if self.torrentinfo[t_name]["is_complete"]:
|
|
categories.append(category)
|
|
body = []
|
|
body += logger.print_line(
|
|
f"{'Not Adding' if self.config.dry_run else 'Adding'} to qBittorrent:", self.config.loglevel
|
|
)
|
|
body += logger.print_line(logger.insert_space(f"Torrent Name: {t_name}", 3), self.config.loglevel)
|
|
body += logger.print_line(logger.insert_space(f"Category: {category}", 7), self.config.loglevel)
|
|
body += logger.print_line(logger.insert_space(f"Save_Path: {dest}", 6), self.config.loglevel)
|
|
body += logger.print_line(logger.insert_space(f"Tracker: {t_tracker}", 8), self.config.loglevel)
|
|
attr = {
|
|
"function": "cross_seed",
|
|
"title": "Adding New Cross-Seed Torrent",
|
|
"body": "\n".join(body),
|
|
"torrent_name": t_name,
|
|
"torrent_category": category,
|
|
"torrent_save_path": dest,
|
|
"torrent_tag": "cross-seed",
|
|
"torrent_tracker": t_tracker,
|
|
}
|
|
self.config.send_notifications(attr)
|
|
added += 1
|
|
if not self.config.dry_run:
|
|
self.client.torrents.add(
|
|
torrent_files=src, save_path=dest, category=category, tags="cross-seed", is_paused=True
|
|
)
|
|
util.move_files(src, dir_cs_out)
|
|
else:
|
|
logger.print_line(
|
|
f"Found {t_name} in {dir_cs} but original torrent is not complete.", self.config.loglevel
|
|
)
|
|
logger.print_line("Not adding to qBittorrent", self.config.loglevel)
|
|
else:
|
|
error = f"{t_name} not found in torrents. Cross-seed Torrent not added to qBittorrent."
|
|
if self.config.dry_run:
|
|
logger.print_line(error, self.config.loglevel)
|
|
else:
|
|
logger.print_line(error, "WARNING")
|
|
self.config.notify(error, "cross-seed", False)
|
|
# Tag missing cross-seed torrents tags
|
|
for torrent in self.torrent_list:
|
|
t_name = torrent.name
|
|
t_cat = torrent.category
|
|
if (
|
|
"cross-seed" not in torrent.tags
|
|
and self.torrentinfo[t_name]["count"] > 1
|
|
and self.torrentinfo[t_name]["first_hash"] != torrent.hash
|
|
):
|
|
tracker = self.config.get_tags([x.url for x in torrent.trackers if x.url.startswith("http")])
|
|
tagged += 1
|
|
body = logger.print_line(
|
|
f"{'Not Adding' if self.config.dry_run else 'Adding'} 'cross-seed' tag to {t_name}", self.config.loglevel
|
|
)
|
|
attr = {
|
|
"function": "tag_cross_seed",
|
|
"title": "Tagging Cross-Seed Torrent",
|
|
"body": body,
|
|
"torrent_name": t_name,
|
|
"torrent_category": t_cat,
|
|
"torrent_tag": "cross-seed",
|
|
"torrent_tracker": tracker,
|
|
}
|
|
self.config.send_notifications(attr)
|
|
if not self.config.dry_run:
|
|
torrent.add_tags(tags="cross-seed")
|
|
|
|
numcategory = Counter(categories)
|
|
for c in numcategory:
|
|
if numcategory[c] > 0:
|
|
logger.print_line(
|
|
f"{numcategory[c]} {c} cross-seed .torrents {'not added' if self.config.dry_run else 'added'}.",
|
|
self.config.loglevel,
|
|
)
|
|
if added > 0:
|
|
logger.print_line(
|
|
f"Total {added} cross-seed .torrents {'not added' if self.config.dry_run else 'added'}.", self.config.loglevel
|
|
)
|
|
if tagged > 0:
|
|
logger.print_line(
|
|
f"Total {tagged} cross-seed .torrents {'not tagged' if self.config.dry_run else 'tagged'}.",
|
|
self.config.loglevel,
|
|
)
|
|
return added, tagged
|
|
|
|
# Function used to recheck paused torrents sorted by size and resume torrents that are completed
|
|
def recheck(self):
|
|
resumed = 0
|
|
rechecked = 0
|
|
if self.config.commands["recheck"]:
|
|
logger.separator("Rechecking Paused Torrents", space=False, border=False)
|
|
# sort by size and paused
|
|
torrent_list = self.get_torrents({"status_filter": "paused", "sort": "size"})
|
|
if torrent_list:
|
|
for torrent in torrent_list:
|
|
tracker = self.config.get_tags([x.url for x in torrent.trackers if x.url.startswith("http")])
|
|
# Resume torrent if completed
|
|
if torrent.progress == 1:
|
|
if torrent.max_ratio < 0 and torrent.max_seeding_time < 0:
|
|
resumed += 1
|
|
body = logger.print_line(
|
|
f"{'Not Resuming' if self.config.dry_run else 'Resuming'} [{tracker['tag']}] - {torrent.name}",
|
|
self.config.loglevel,
|
|
)
|
|
attr = {
|
|
"function": "recheck",
|
|
"title": "Resuming Torrent",
|
|
"body": body,
|
|
"torrent_name": torrent.name,
|
|
"torrent_category": torrent.category,
|
|
"torrent_tracker": tracker["url"],
|
|
"notifiarr_indexer": tracker["notifiarr"],
|
|
}
|
|
self.config.send_notifications(attr)
|
|
if not self.config.dry_run:
|
|
torrent.resume()
|
|
else:
|
|
# Check to see if torrent meets AutoTorrentManagement criteria
|
|
logger.debug("DEBUG: Torrent to see if torrent meets AutoTorrentManagement Criteria")
|
|
logger.debug(logger.insert_space(f"- Torrent Name: {torrent.name}", 2))
|
|
logger.debug(
|
|
logger.insert_space(f"-- Ratio vs Max Ratio: {torrent.ratio:.2f} < {torrent.max_ratio:.2f}", 4)
|
|
)
|
|
logger.debug(
|
|
logger.insert_space(
|
|
f"-- Seeding Time vs Max Seed Time: {timedelta(seconds=torrent.seeding_time)} < "
|
|
f"{timedelta(minutes=torrent.max_seeding_time)}",
|
|
4,
|
|
)
|
|
)
|
|
if (
|
|
(torrent.max_ratio >= 0 and torrent.ratio < torrent.max_ratio and torrent.max_seeding_time < 0)
|
|
or (
|
|
torrent.max_seeding_time >= 0
|
|
and (torrent.seeding_time < (torrent.max_seeding_time * 60))
|
|
and torrent.max_ratio < 0
|
|
)
|
|
or (
|
|
torrent.max_ratio >= 0
|
|
and torrent.max_seeding_time >= 0
|
|
and torrent.ratio < torrent.max_ratio
|
|
and (torrent.seeding_time < (torrent.max_seeding_time * 60))
|
|
)
|
|
):
|
|
resumed += 1
|
|
body = logger.print_line(
|
|
f"{'Not Resuming' if self.config.dry_run else 'Resuming'} [{tracker['tag']}] - "
|
|
f"{torrent.name}",
|
|
self.config.loglevel,
|
|
)
|
|
attr = {
|
|
"function": "recheck",
|
|
"title": "Resuming Torrent",
|
|
"body": body,
|
|
"torrent_name": torrent.name,
|
|
"torrent_category": torrent.category,
|
|
"torrent_tracker": tracker["url"],
|
|
"notifiarr_indexer": tracker["notifiarr"],
|
|
}
|
|
self.config.send_notifications(attr)
|
|
if not self.config.dry_run:
|
|
torrent.resume()
|
|
# Recheck
|
|
elif (
|
|
torrent.progress == 0
|
|
and self.torrentinfo[torrent.name]["is_complete"]
|
|
and not torrent.state_enum.is_checking
|
|
):
|
|
rechecked += 1
|
|
body = logger.print_line(
|
|
f"{'Not Rechecking' if self.config.dry_run else 'Rechecking'} [{tracker['tag']}] - {torrent.name}",
|
|
self.config.loglevel,
|
|
)
|
|
attr = {
|
|
"function": "recheck",
|
|
"title": "Rechecking Torrent",
|
|
"body": body,
|
|
"torrent_name": torrent.name,
|
|
"torrent_category": torrent.category,
|
|
"torrent_tracker": tracker["url"],
|
|
"notifiarr_indexer": tracker["notifiarr"],
|
|
}
|
|
self.config.send_notifications(attr)
|
|
if not self.config.dry_run:
|
|
torrent.recheck()
|
|
return resumed, rechecked
|
|
|
|
def rem_orphaned(self):
|
|
orphaned = 0
|
|
if self.config.commands["rem_orphaned"]:
|
|
logger.separator("Checking for Orphaned Files", space=False, border=False)
|
|
torrent_files = []
|
|
root_files = []
|
|
orphaned_files = []
|
|
excluded_orphan_files = []
|
|
orphaned_parent_path = set()
|
|
remote_path = self.config.remote_dir
|
|
root_path = self.config.root_dir
|
|
orphaned_path = self.config.orphaned_dir
|
|
if remote_path != root_path:
|
|
root_files = [
|
|
os.path.join(path.replace(remote_path, root_path), name)
|
|
for path, subdirs, files in alive_it(os.walk(remote_path))
|
|
for name in files
|
|
if orphaned_path.replace(remote_path, root_path) not in path
|
|
]
|
|
else:
|
|
root_files = [
|
|
os.path.join(path, name)
|
|
for path, subdirs, files in alive_it(os.walk(root_path))
|
|
for name in files
|
|
if orphaned_path.replace(root_path, remote_path) not in path
|
|
]
|
|
|
|
# Get an updated list of torrents
|
|
torrent_list = self.get_torrents({"sort": "added_on"})
|
|
for torrent in alive_it(torrent_list):
|
|
for file in torrent.files:
|
|
fullpath = os.path.join(torrent.save_path, file.name)
|
|
# Replace fullpath with \\ if qbm is runnig in docker (linux) but qbt is on windows
|
|
fullpath = fullpath.replace(r"/", "\\") if ":\\" in fullpath else fullpath
|
|
torrent_files.append(fullpath)
|
|
|
|
orphaned_files = set(root_files) - set(torrent_files)
|
|
orphaned_files = sorted(orphaned_files)
|
|
|
|
if self.config.orphaned["exclude_patterns"]:
|
|
exclude_patterns = self.config.orphaned["exclude_patterns"]
|
|
excluded_orphan_files = [
|
|
file
|
|
for file in orphaned_files
|
|
for exclude_pattern in exclude_patterns
|
|
if fnmatch(file, exclude_pattern.replace(remote_path, root_path))
|
|
]
|
|
|
|
orphaned_files = set(orphaned_files) - set(excluded_orphan_files)
|
|
|
|
if orphaned_files:
|
|
os.makedirs(orphaned_path, exist_ok=True)
|
|
body = []
|
|
num_orphaned = len(orphaned_files)
|
|
logger.print_line(f"{num_orphaned} Orphaned files found", self.config.loglevel)
|
|
body += logger.print_line("\n".join(orphaned_files), self.config.loglevel)
|
|
body += logger.print_line(
|
|
f"{'Did not move' if self.config.dry_run else 'Moved'} {num_orphaned} Orphaned files "
|
|
f"to {orphaned_path.replace(remote_path,root_path)}",
|
|
self.config.loglevel,
|
|
)
|
|
|
|
attr = {
|
|
"function": "rem_orphaned",
|
|
"title": f"Removing {num_orphaned} Orphaned Files",
|
|
"body": "\n".join(body),
|
|
"orphaned_files": list(orphaned_files),
|
|
"orphaned_directory": orphaned_path.replace(remote_path, root_path),
|
|
"total_orphaned_files": num_orphaned,
|
|
}
|
|
self.config.send_notifications(attr)
|
|
# Delete empty directories after moving orphan files
|
|
logger.info("Cleaning up any empty directories...")
|
|
if not self.config.dry_run:
|
|
for file in alive_it(orphaned_files):
|
|
src = file.replace(root_path, remote_path)
|
|
dest = os.path.join(orphaned_path, file.replace(root_path, ""))
|
|
util.move_files(src, dest, True)
|
|
orphaned_parent_path.add(os.path.dirname(file).replace(root_path, remote_path))
|
|
for parent_path in orphaned_parent_path:
|
|
util.remove_empty_directories(parent_path, "**/*")
|
|
else:
|
|
logger.print_line("No Orphaned Files found.", self.config.loglevel)
|
|
return orphaned
|
|
|
|
def tor_delete_recycle(self, torrent, info):
|
|
if self.config.recyclebin["enabled"]:
|
|
tor_files = []
|
|
try:
|
|
info_hash = torrent.hash
|
|
save_path = torrent.save_path.replace(self.config.root_dir, self.config.remote_dir)
|
|
# Define torrent files/folders
|
|
for file in torrent.files:
|
|
tor_files.append(os.path.join(save_path, file.name))
|
|
except NotFound404Error:
|
|
return
|
|
|
|
if self.config.recyclebin["split_by_category"]:
|
|
recycle_path = os.path.join(save_path, os.path.basename(self.config.recycle_dir.rstrip(os.sep)))
|
|
else:
|
|
recycle_path = self.config.recycle_dir
|
|
# Create recycle bin if not exists
|
|
torrent_path = os.path.join(recycle_path, "torrents")
|
|
torrents_json_path = os.path.join(recycle_path, "torrents_json")
|
|
|
|
os.makedirs(recycle_path, exist_ok=True)
|
|
if self.config.recyclebin["save_torrents"]:
|
|
if os.path.isdir(torrent_path) is False:
|
|
os.makedirs(torrent_path)
|
|
if os.path.isdir(torrents_json_path) is False:
|
|
os.makedirs(torrents_json_path)
|
|
torrent_json_file = os.path.join(torrents_json_path, f"{info['torrent_name']}.json")
|
|
torrent_json = util.load_json(torrent_json_file)
|
|
if not torrent_json:
|
|
logger.info(f"Saving Torrent JSON file to {torrent_json_file}")
|
|
torrent_json["torrent_name"] = info["torrent_name"]
|
|
torrent_json["category"] = info["torrent_category"]
|
|
else:
|
|
logger.info(f"Adding {info['torrent_tracker']} to existing {os.path.basename(torrent_json_file)}")
|
|
dot_torrent_files = []
|
|
for File in os.listdir(self.config.torrents_dir):
|
|
if File.startswith(info_hash):
|
|
dot_torrent_files.append(File)
|
|
try:
|
|
util.copy_files(os.path.join(self.config.torrents_dir, File), os.path.join(torrent_path, File))
|
|
except Exception as e:
|
|
logger.stacktrace()
|
|
self.config.notify(e, "Deleting Torrent", False)
|
|
logger.warning(f"RecycleBin Warning: {e}")
|
|
if "tracker_torrent_files" in torrent_json:
|
|
tracker_torrent_files = torrent_json["tracker_torrent_files"]
|
|
else:
|
|
tracker_torrent_files = {}
|
|
tracker_torrent_files[info["torrent_tracker"]] = dot_torrent_files
|
|
if dot_torrent_files:
|
|
backup_str = "Backing up "
|
|
for idx, val in enumerate(dot_torrent_files):
|
|
if idx == 0:
|
|
backup_str += val
|
|
else:
|
|
backup_str += f" and {val.replace(info_hash,'')}"
|
|
backup_str += f" to {torrent_path}"
|
|
logger.info(backup_str)
|
|
torrent_json["tracker_torrent_files"] = tracker_torrent_files
|
|
if "files" not in torrent_json:
|
|
files_cleaned = [f.replace(self.config.remote_dir, "") for f in tor_files]
|
|
torrent_json["files"] = files_cleaned
|
|
if "deleted_contents" not in torrent_json:
|
|
torrent_json["deleted_contents"] = info["torrents_deleted_and_contents"]
|
|
else:
|
|
if torrent_json["deleted_contents"] is False and info["torrents_deleted_and_contents"] is True:
|
|
torrent_json["deleted_contents"] = info["torrents_deleted_and_contents"]
|
|
logger.debug("")
|
|
logger.debug(f"JSON: {torrent_json}")
|
|
util.save_json(torrent_json, torrent_json_file)
|
|
if info["torrents_deleted_and_contents"] is True:
|
|
logger.separator(f"Moving {len(tor_files)} files to RecycleBin", space=False, border=False, loglevel="DEBUG")
|
|
if len(tor_files) == 1:
|
|
logger.print_line(tor_files[0], "DEBUG")
|
|
else:
|
|
logger.print_line("\n".join(tor_files), "DEBUG")
|
|
logger.debug(
|
|
f"Moved {len(tor_files)} files to {recycle_path.replace(self.config.remote_dir,self.config.root_dir)}"
|
|
)
|
|
|
|
# Move files from torrent contents to Recycle bin
|
|
for file in tor_files:
|
|
src = file
|
|
dest = os.path.join(recycle_path, file.replace(self.config.remote_dir, ""))
|
|
# Move files and change date modified
|
|
try:
|
|
toDelete = util.move_files(src, dest, True)
|
|
except FileNotFoundError:
|
|
e = logger.print_line(f"RecycleBin Warning - FileNotFound: No such file or directory: {src} ", "WARNING")
|
|
self.config.notify(e, "Deleting Torrent", False)
|
|
# Delete torrent and files
|
|
torrent.delete(delete_files=toDelete)
|
|
# Remove any empty directories
|
|
util.remove_empty_directories(save_path, "**/*")
|
|
else:
|
|
torrent.delete(delete_files=False)
|
|
else:
|
|
if info["torrents_deleted_and_contents"] is True:
|
|
torrent.delete(delete_files=True)
|
|
else:
|
|
torrent.delete(delete_files=False)
|