What is it?#

As the name suggests, a shared box means multiple users share one server, one public IP, and the same disk.

What are the downsides?#

• Most shared boxes are a big gamble. If you have a mischievous neighbor constantly hammering the disk I/O, you’re done.
• Bandwidth/traffic is often capped.
• You can’t hack around much on the server yourself.
• Most domestic trackers don’t allow shared boxes.

Below is a consolidated throttle matrix for major trackers:

https://catcat.blog/pt%e7%ab%99%e7%82%b9%e9%99%90%e7%ae%b1%e9%99%90%e9%80%9f%e8%a1%a8.html

If most domestic trackers don’t support SeedBox and there are so many drawbacks, why buy one?#

• Cheap
• Cheap
• Cheap
• For just a few dozen RMB you can get 10G or even 20G bandwidth.
• Network quality is usually excellent. For example, sh uses Leaseweb’s network. Under the same configuration, Leaseweb can guarantee higher priority, which in plain words means your ratio on a single torrent is higher.
• Very efficient for LAN cross-seeding.

Where can you buy one?#

I’ll only recommend the ones I’ve personally used.

• seedhost

Nicknamed sh. Low traffic quota, average disk size, decent for racing. After exceeding the traffic cap, it’s limited to 100 Mbps. Supports installing rTorrent/ruTorrent, starting from 6 EUR. They also offer dedicated servers for rent, but they are almost always out of stock. Their SSD plans are said to race very well and are often seen on foreign trackers. Supports credit cards and PayPal.

• hostingby.design

Formerly seedbox.io, now renamed. Servers are the same as seedhost, located at Leaseweb (previously NFOrce). They resell Leaseweb and Hetzner dedicated servers. Racing power is decent, but popular plans need to be snatched. Works extremely well on foreign trackers.

What is “partial pack” (拆包)?#

Partial pack: Only downloading some files within a big torrent. Except for Mantou’s adult mega-torrents, this is heavily cracked down on across trackers. Especially automated partial pack behavior: using a box’s high upload and low download from partial packs to get massive ratio while contributing nothing meaningful to the torrent itself.

[admonition color=“red”]!!!! Do NOT use this behavior anywhere except Mantou adult mega-torrents!!!![/admonition]

How to register#

Official site: Hetzner Cloud (using this link for your first registration or purchase gives you a 20 EUR credit valid for one month — enough to test various VPS plans.)

For 2024, the community promo code has been updated: enter HCC24-L7ST92 for another 20 EUR.

ARM instances are recommended for racing, as they’re slightly cheaper.

1
Basic System Information:
2
---------------------------------
3
Uptime     : 0 days, 0 hours, 3 minutes
4
Processor  : Neoverse-N1
5
CPU cores  : 2 @ ??? MHz
6
AES-NI     : ✔ Enabled
7
VM-x/AMD-V : ❌ Disabled
8
RAM        : 3.7 GiB
9
Swap       : 0.0 KiB
10
Disk       : 37.5 GiB
11
Distro     : Ubuntu 22.04.3 LTS
12
Kernel     : 5.15.0-79-generic
13
VM Type    : KVM
14
IPv4/IPv6  : ✔ Online / ✔ Online
15

16
IPv6 Network Information:
17
---------------------------------
18
ISP        : Hetzner Online GmbH
19
ASN        : AS24940 Hetzner Online GmbH
20
Host       : Hetzner
21
Location   : Nuremberg, Bavaria (BY)
22
Country    : Germany
23

24
fio Disk Speed Tests (Mixed R/W 50/50):
25
---------------------------------
26
Block Size | 4k            (IOPS) | 64k           (IOPS)
27
  ------ | --- ---- | ---- ----
28
Read       | 146.45 MB/s  (36.6k) | 1.22 GB/s    (19.1k)
29
Write      | 146.36 MB/s  (36.5k) | 1.26 GB/s    (19.6k)
30
Total      | 292.81 MB/s  (73.2k) | 2.48 GB/s    (38.8k)
31
           |                      |
32
Block Size | 512k          (IOPS) | 1m            (IOPS)
33
  ------ | --- ---- | ---- ----
34
Read       | 2.09 GB/s     (4.0k) | 2.10 GB/s     (2.0k)
35
Write      | 2.27 GB/s     (4.4k) | 2.34 GB/s     (2.2k)
36
Total      | 4.36 GB/s     (8.5k) | 4.44 GB/s     (4.3k)
37

38
Geekbench 6 BenchMark Test:
39
---------------------------------
40
Test            | Value
41
                |
42
Single Core     | 1074
43
Multi Core      | 1908
44
Full Test       | https://browser.geekbench.com/v6/cpu/2942919

1. Contract duration#

If you order from the official site, VPS products have a default billing period of 6 months, meaning you must prepay 6 months. You can switch to hourly billing with a one-month billing cycle, but the price is higher.

The Root-Server series also defaults to a 6-month billing period, with a minimum contract term of 12 months. In simple terms: at least a one-year commitment, paying every 6 months. You can switch to monthly billing with a minimum one-month contract term, but again at a higher price.

2. Cancellation#

To cancel a running VPS, you must submit the cancellation at least 31 days before the next renewal date—essentially at least one month in advance. If your VPS is billed monthly and you only want to use it for a single month, you must hit “Cancel product” in the control panel on the very first day after payment; otherwise, you slide into the next billing cycle and end up paying for at least 2 months.

Of course, if you’re not sure about dates, the control panel’s Cancellation page clearly shows when the contract would end if you cancel now. That’s your final usable date.

3. Legal issues#

Germans take rules very seriously—some might say rigidly. They strictly enforce contracts, but their products are solid, prices reasonable, and there’s no classic overselling. Very stable and trustworthy.

As mentioned above, some buyers overlooked cancellation rules, then refused to renew and stopped paying, and later received lawyer demand letters. Netcup reportedly has a legal team in China.

So it’s best to avoid legal issues from payment default. So far there seems to be only one widely reported case of someone getting a lawyer letter online (unclear if true), and it might be hype. But we should still avoid breach of contract and be compliant customers.

4. Datacenter locations#

There are mainly two facilities: Nuremberg and Vienna. For connectivity from mainland China, Nuremberg is generally better.

5. Bandwidth and traffic (critical)#

Regular VPS: 80 TB of traffic with 1 Gbps bandwidth. Beyond 80 TB, the bandwidth is capped at 100 Mbps, but traffic remains unlimited with no extra charges.

Root-Server series: truly unmetered. Root servers have a 2.5 Gbps port, with each VPS guaranteed at least 1 Gbps. To ensure fairness, bandwidth is limited to 200 Mbps only if both of the following conditions are met:

1. You exceed 120 TB of traffic within a month.
2. You continuously use more than 1 Gbit/s for over 60 minutes.

The first condition is easy to understand; the second feels a bit tricky, so here’s the breakdown: your VPS pushes more than 128 MB/s * 3600 s = 460,800 MB ≈ 460 GB in one hour. In other words, as long as your hourly traffic doesn’t exceed 460 GB, you can keep running at 2.5 Gbps.

For most users, especially PT racing, hitting these two thresholds, especially the second, is quite rare. (Note that the 1 Gbit/s here is up + down combined. When racing, it’s easy to get there, so use speed limits.)

If you’re worried about dropping to 200 Mbps after 120 TB, there’s a simple trick: once you reach 120 TB, cap the port at 1 Gbit/s yourself. Then you’ll always run at 1 Gbit/s indefinitely with no worries. (The limited 1 G is up + down combined.)

Deluge Optimization#

There’s no single “correct” config, but here’s a direction.

If you’re using Deluge, just enable HPS.

HPS is a preset in ltconfig, short for High Performance Seed. How to enable it? See below:

ltconfig settings

You can go here for exact details. Below is what I use. ⚠️ Note: this is my config; adjust based on your own server.

You must stop Deluge, write the config, then restart Deluge for it to take effect.

1
{
2
'active_checking': 1,
3
 'active_dht_limit': 600,
4
 'active_downloads': -1,
5
 'active_limit': -1,
6
 'active_loaded_limit': 0,
7
 'active_lsd_limit': 60,
8
 'active_seeds': -1,
9
 'active_tracker_limit': 8000,
10
 'aio_max': 300,
11
 'aio_threads': 8,
12
 'alert_mask': 861,
13
 'alert_queue_size': 10000,
14
 'allow_i2p_mixed': False,
15
 'allow_multiple_connections_per_ip': True,
16
 'allow_partial_disk_writes': True,
17
 'allowed_enc_level': 3,
18
 'allowed_fast_set_size': 0,
19
 'always_send_user_agent': False,
20
 'announce_crypto_support': True,
21
 'announce_double_nat': False,
22
 'announce_ip': '',
23
 'announce_to_all_tiers': False,
24
 'announce_to_all_trackers': False,
25
 'anonymous_mode': False,
26
 'apply_ip_filter_to_trackers': True,
27
 'auto_manage_interval': 30,
28
 'auto_manage_prefer_seeds': False,
29
 'auto_manage_startup': 60,
30
 'auto_scrape_interval': 1800,
31
 'auto_scrape_min_interval': 300,
32
 'auto_sequential': True,
33
 'ban_web_seeds': True,
34
 'broadcast_lsd': True,
35
 'cache_buffer_chunk_size': 1024,
36
 'cache_expiry': 60,
37
 'cache_size': 524288,
38
 'cache_size_volatile': 512,
39
 'checking_mem_usage': 6600,
40
 'choking_algorithm': 0,
41
 'close_file_interval': 0,
42
 'close_redundant_connections': True,
43
 'coalesce_reads': False,
44
 'coalesce_writes': False,
45
 'connect_seed_every_n_download': 5,
46
 'connection_speed': 2000,
47
 'connections_limit': 1048576,
48
 'connections_slack': 10,
49
 'contiguous_recv_buffer': True,
50
 'decrease_est_reciprocation_rate': 3,
51
 'default_cache_min_age': 1,
52
 'default_est_reciprocation_rate': 16000,
53
 'dht.aggressive_lookups': True,
54
 'dht.block_ratelimit': 5,
55
 'dht.block_timeout': 300,
56
 'dht.enforce_node_id': False,
57
 'dht.extended_routing_table': True,
58
 'dht.ignore_dark_internet': True,
59
 'dht.item_lifetime': 0,
60
 'dht.max_dht_items': 700,
61
 'dht.max_fail_count': 20,
62
 'dht.max_peers_reply': 100,
63
 'dht.max_torrent_search_reply': 20,
64
 'dht.max_torrents': 2000,
65
 'dht.privacy_lookups': False,
66
 'dht.read_only': False,
67
 'dht.restrict_routing_ips': True,
68
 'dht.restrict_search_ips': True,
69
 'dht.search_branching': 5,
70
 'dht.service_port': 0,
71
 'dht_announce_interval': 900,
72
 'dht_bootstrap_nodes': 'dht.aelitis.com:6881,router.bittorrent.com:6881,router.bitcomet.com:6881,router.utorrent.com:6881,dht.transmissionbt.com:6881,dht.libtorrent.org:25401',
73
 'dht_upload_rate_limit': 20000,
74
 'disable_hash_checks': False,
75
 'disk_io_read_mode': 0,
76
 'disk_io_write_mode': 0,
77
 'dont_count_slow_torrents': False,
78
 'dont_flush_write_cache': False,
79
 'download_rate_limit': 0,
80
 'enable_dht': True,
81
 'enable_incoming_tcp': True,
82
 'enable_incoming_utp': False,
83
 'enable_lsd': True,
84
 'enable_natpmp': False,
85
 'enable_outgoing_tcp': True,
86
 'enable_outgoing_utp': False,
87
 'enable_upnp': False,
88
 'explicit_cache_interval': 30,
89
 'explicit_read_cache': False,
90
 'file_checks_delay_per_block': 0,
91
 'file_pool_size': 1000,
92
 'force_proxy': False,
93
 'guided_read_cache': False,
94
 'half_open_limit': -1,
95
 'handshake_client_version': '',
96
 'handshake_timeout': 20,
97
 'hashing_threads': 1,
98
 'i2p_hostname': '',
99
 'i2p_port': 0,
100
 'ignore_limits_on_local_network': True,
101
 'ignore_resume_timestamps': True,
102
 'in_enc_policy': 1,
103
 'inactive_down_rate': 2048,
104
 'inactive_up_rate': 2048,
105
 'inactivity_timeout': 20,
106
 'incoming_starts_queued_torrents': False,
107
 'increase_est_reciprocation_rate': 20,
108
 'initial_picker_threshold': 4,
109
 'lazy_bitfields': False,
110
 'listen_interfaces': '0.0.0.0:31076',
111
 'listen_queue_size': 3000,
112
 'listen_system_port_fallback': False,
113
 'local_download_rate_limit': 0,
114
 'local_service_announce_interval': 300,
115
 'local_upload_rate_limit': 0,
116
 'lock_disk_cache': False,
117
 'lock_files': False,
118
 'low_prio_disk': False,
119
 'max_allowed_in_request_queue': 3000,
120
 'max_failcount': 1,
121
 'max_http_recv_buffer_size': 6291456,
122
 'max_metadata_size': 31457280,
123
 'max_out_request_queue': 3000,
124
 'max_paused_peerlist_size': 1000,
125
 'max_peerlist_size': 3000,
126
 'max_pex_peers': 200,
127
 'max_queued_disk_bytes': 58720256,
128
 'max_rejects': 5,
129
 'max_retry_port_bind': 10,
130
 'max_suggest_pieces': 32,
131
 'min_announce_interval': 4500,
132
 'min_reconnect_time': 0,
133
 'mixed_mode_algorithm': 0,
134
 'mmap_cache': '',
135
 'network_threads': 0,
136
 'no_atime_storage': True,
137
 'no_connect_privileged_ports': False,
138
 'no_recheck_incomplete_resume': False,
139
 'num_optimistic_unchoke_slots': 0,
140
 'num_outgoing_ports': 0,
141
 'num_want': 200,
142
 'optimistic_disk_retry': 600,
143
 'optimistic_unchoke_interval': 30,
144
 'out_enc_policy': 1,
145
 'outgoing_interfaces': '',
146
 'outgoing_port': 0,
147
 'peer_connect_timeout': 15,
148
 'peer_fingerprint': '-DE205s-',
149
 'peer_timeout': 30,
150
 'peer_turnover': 4,
151
 'peer_turnover_cutoff': 90,
152
 'peer_turnover_interval': 300,
153
 'piece_timeout': 20,
154
 'predictive_piece_announce': 0,
155
 'prefer_rc4': True,
156
 'prefer_udp_trackers': True,
157
 'prioritize_partial_pieces': False,
158
 'proxy_hostname': '',
159
 'proxy_hostnames': False,
160
 'proxy_password': '',
161
 'proxy_peer_connections': False,
162
 'proxy_port': 10809,
163
 'proxy_tracker_connections': False,
164
 'proxy_type': 0,
165
 'proxy_username': '',
166
 'rate_limit_ip_overhead': True,
167
 'rate_limit_utp': True,
168
 'read_cache_line_size': 1024,
169
 'recv_socket_buffer_size': 8388608,
170
 'report_redundant_bytes': True,
171
 'report_true_downloaded': False,
172
 'report_web_seed_downloads': True,
173
 'request_queue_time': 3,
174
 'request_timeout': 15,
175
 'seed_choking_algorithm': 0,
176
 'seed_time_limit': -60,
177
 'seed_time_ratio_limit': -100,
178
 'seeding_outgoing_connections': True,
179
 'seeding_piece_quota': 60,
180
 'send_buffer_low_watermark': 16777216,
181
 'send_buffer_watermark': 83886080,
182
 'send_buffer_watermark_factor': 250,
183
 'send_redundant_have': True,
184
 'send_socket_buffer_size': 16777216,
185
 'share_mode_target': 3,
186
 'share_ratio_limit': -100,
187
 'smooth_connects': False,
188
 'ssl_listen': 0,
189
 'stop_tracker_timeout': 15,
190
 'strict_end_game_mode': False,
191
 'strict_super_seeding': False,
192
 'suggest_mode': 1,
193
 'support_merkle_torrents': True,
194
 'support_share_mode': False,
195
 'tick_interval': 250,
196
 'torrent_connect_boost': 300,
197
 'tracker_backoff': 250,
198
 'tracker_completion_timeout': 60,
199
 'tracker_maximum_response_length': 1048576,
200
 'tracker_receive_timeout': 30,
201
 'udp_tracker_token_expiry': 60,
202
 'unchoke_interval': 15,
203
 'unchoke_slots_limit': -1,
204
 'upload_rate_limit': 0,
205
 'upnp_ignore_nonrouters': False,
206
 'urlseed_max_request_bytes': 16777216,
207
 'urlseed_pipeline_size': 5,
208
 'urlseed_timeout': 20,
209
 'urlseed_wait_retry': 30,
210
 'use_dht_as_fallback': False,
211
 'use_disk_cache_pool': True,
212
 'use_disk_read_ahead': True,
213
 'use_parole_mode': False,
214
 'use_read_cache': True,
215
 'use_write_cache': True,
216
 'user_agent': 'Deluge/2.0.5 libtorrent/1.1.14.0',
217
 'utp_connect_timeout': 3000,
218
 'utp_cwnd_reduce_timer': 100,
219
 'utp_delayed_ack': 0,
220
 'utp_fin_resends': 2,
221
 'utp_gain_factor': 3000,
222
 'utp_loss_multiplier': 50,
223
 'utp_min_timeout': 500,
224
 'utp_num_resends': 3,
225
 'utp_syn_resends': 2,
226
 'utp_target_delay': 100,
227
 'volatile_read_cache': False,
228
 'web_seed_name_lookup_retry': 1800,
229
 'whole_pieces_threshold': 20,
230
 'write_cache_line_size': 2048
231
}

By the way, you may find some options in the list that don’t exist on your machine. That’s just due to libtorrent version differences; ignore them.

Disk optimization

This touches on disk scheduling algorithms; if you want to go deeper, read up on relevant papers and articles. Prefer NVMe SSDs for racing.

Note that not all Linux kernels ship with mq-deadline. If you can’t enable mq-deadline, you may need to compile that module yourself.

qBittorrent Optimization#

• Cache size should be about 1/4 of your available RAM. If you’re on qBittorrent 4.3.x, consider potential memory leaks and set it to 1/8.

• aio_threads defaults to 4, which is okay for HDDs. For SSD or NVMe servers, you can increase it to 8 or even 16.

  • For qBittorrent 4.3.x–4.6.x, you can change this in the Advanced settings tab.

  • For qBittorrent 4.1.x, you can set it in /home/$username/.config/qBittorrent/qBittorrent.conf by adding under the [BitTorrent] section:

    • Session\AsyncIOThreadsCount=8
    • Make sure qBittorrent is closed before editing.

  • For Deluge, install ltconfig and edit via the plugin: aio_threads=8.

• On machines with poor I/O, set send_buffer_low_watermark, send_buffer_watermark, and send_buffer_watermark_factor to lower values.

  • For qBittorrent 4.3.x, adjust in Advanced settings.

  • For qBittorrent 4.1.x, edit /home/$username/.config/qBittorrent/qBittorrent.conf and add under [BitTorrent]:

    • Session\SendBufferWatermark=5120
    • Session\SendBufferLowWatermark=1024
    • Session\SendBufferWatermarkFactor=150
    • Again, close qBittorrent before editing.

  • For Deluge, use ltconfig and set:

    • send_buffer_low_watermark=1048576
    • send_buffer_watermark=5242880
    • send_buffer_watermark_factor=150

• tick_internal defaults to 100, which might be too aggressive for weaker CPUs. Consider 250 or 500.

  • Unfortunately qBittorrent doesn’t expose this.

  • For Deluge, again via ltconfig plugin: tick_interval=250.

Automatic Torrent Removal#

For auto-removing torrents there are two options: a Deluge plugin, or AutoRemoveTorrents.

I mainly use AutoRemoveTorrents (ART). Here’s a quick install and config overview.

ART can be installed in two ways.

First, via pip:

1
pip3 install autoremove-torrents

Second, from GitHub:

1
git clone https://github.com/jerrymakesjelly/autoremove-torrents.git
2
cd autoremove-torrents
3
python3 setup.py install

autoremove-torrents looks for config.yml in the current working directory. For more CLI arguments, see the table below.

For example:

1
autoremove-torrents --view --conf=/home/myserver/autoremove-torrents/config.yml

is equivalent to:

1
autoremove-torrents -v -c /home/myserver/autoremove-torrents/config.yml

To enable automatic deletion, we first need to create the config file and the log directory.

1
# Create the art directory
2
mkdir -p /root/.config/art/artlogs

Then use vi /root/.config/art/config.yml to create the ART config.

After creation, write your configuration, save, and exit. For config details, see ART’s documentation.

Here’s my own config as a small reference:

delete_task: client: your client type, e.g. deluge qbittorrent host: 127.0.0.1:58846 username: your client username password: your client password strategies: bhd: trackers: - landof.tv stats: - Uploading remove: (ratio > 1.1 and seeding_time > 3600 ) delete_data: true

Next, run crontab -e:

1
*/15 * * * * /usr/local/bin/autoremove-torrents -c /root/.config/art/config.yml -l /root/.config/art/artlogs`

Add the line above to your crontab. ART will then run every 15 minutes, apply the rules in /root/.config/art/config.yml, remove torrents accordingly, and put logs under /root/.config/art/artlogs.

After this, ART setup is complete.

Deluge Plugin-Based Auto Removal#

Below is the script:

1
"""
2
deluge 删种脚本，优先保留体积大、下载人数多、上传速度高、做种时间少的种子。
3
用过一些删种工具，逻辑都比较粗暴，所以自己写了一个，
4
每个种子综合考虑各项情况，分配加权把各项加起来，从低到高删除直到剩余空间大于指定值。
5
40% 取当前速度和平均速度的平均值，20% 取做种中种子的上传速度按做种时间权重分配的值，
6
剩下的 40% 中其中一部分为取做种中种子的上传速度按下载上传人数权重分配的值，另一部分为按做种人数分配的值
7
比例取决于参数 KS，同时有考虑体积，体积越大加权越高（大约是 0.2 次方）
8
"""
9

10
from time import sleep
11
from deluge_client import LocalDelugeRPCClient, FailedToReconnectException
12
from loguru import logger
13
from ssl import SSLError
14
from collections import deque
15
from typing import Union, Any, Tuple, List
16
import os
17

18
MIN_FREE_SPACE = 3725  # type: Union[int, float]
19
'最小剩余空间(GiB)，当下载速度未超过临界值 MAX_DR 时小于这个值删种'
20
MIN_FREE_SPACE_LOWER = 3725 / 3  # type: Union[int, float]
21
'''当下载速度超过临界值 MAX_DR 时小于这个值删种。
22
硬盘空间足够的话建议两个值的差 1024(1TB) 以上'''
23
MAX_DR = 10 * 1024 ** 2  # type: Union[int, float]
24
'下载速度临界值'
25
MODE = 1  # type: Any
26
'为 1 时先删除做种中的种子，删完后再删下载中的种子；否则综合考虑一起删'
27
KS = 0.5  # type: Union[int, float]
28
'按做种人数分配的权重占 40% 的比例，取值范围 [0, 1]，为 0 代表不考虑做种人数，这个参数的目的在于延长孤种的保种时间'
29
INTERVAL = 600  # type: Union[int, float]
30
'删种的时间间隔'
31
MIN_DOWN_TIME = 3600  # type: Union[int, float]
32
'下载时间小于这个值不删'
33
S0 = 300  # type: Union[int, float]
34
LOG_PATH = ''  # type: str
35
EXCLUDE_LABELS = ['seed', 'public']  # type: Union[Tuple[Any, ...], List[str]]
36
'如果种子有这些标签，删种时会跳过'
37

38
class Deluge(LocalDelugeRPCClient):
39
    timeout = 10
40

41
    def __init__(self,
42
                 host: str = '127.0.0.1',
43
                 port: int = 58846,
44
                 username: str = '',
45
                 password: str = '',
46
                 decode_utf8: bool = True,
47
                 automatic_reconnect: bool = True,
48
                 ):
49
        super().__init__(host, port, username, password, decode_utf8, automatic_reconnect)
50

51
    def call(self, method, *args, **kwargs):
52
        if not self.connected and method != 'daemon.login':
53
            for i in range(5):
54
                try:
55
                    self.reconnect()
56
                    logger.debug(f'Connected to deluge client on {self.host}')
57
                    break
58
                except SSLError:
59
                    sleep(0.3 * 2 ** i)
60
        try:
61
            return super().call(method, *args, **kwargs)
62
        except FailedToReconnectException:
63
            logger.error(f'Failed to reconnect to deluge client on {self.host}')
64
        except:
65
            raise
66

67
class AutoDel:
68
    def __init__(self, client: Deluge):
69
        self.client = client
70
        self.sur = deque(maxlen=100)
71
        self.free_space = MIN_FREE_SPACE * 1024 ** 3
72
        self.torrent_status = {}
73
        self.ses_dr = 0
74
        self.torrent_keys = ['active_time', 'download_payload_rate', 'name', 'state',
75
                             'seeding_time', 'total_peers', 'total_seeds', 'total_size',
76
                             'total_done', 'total_uploaded', 'upload_payload_rate', 'label'
77
                             ]
78

79
    def update_session(self):
80
        self.free_space = self.client.core.get_free_space()
81
        if not isinstance(self.free_space, int):
82
            raise
83

84
        seed_ur = 0
85
        up_status = self.client.core.get_torrents_status({'state': 'Seeding'}, ['upload_payload_rate'])
86
        if not isinstance(up_status, dict):
87
            raise
88
        for _id, data in up_status.items():
89
            seed_ur += data['upload_payload_rate']
90
        self.sur.append(seed_ur)
91

92
        self.ses_dr = self.client.core.get_session_status(['download_rate'])['download_rate']
93

94
        if self.free_space < MIN_FREE_SPACE * 1024 ** 3:
95
            self.torrent_status = self.client.core.get_torrents_status({}, self.torrent_keys)
96
            if not isinstance(self.torrent_status, dict):
97
                raise
98

99
    def run(self):
100
        while True:
101
            try:
102
                while True:
103
                    try:
104
                        self.update_session()
105
                        break
106
                    except:
107
                        pass
108
                min_space = (MIN_FREE_SPACE if self.ses_dr < MAX_DR else MIN_FREE_SPACE_LOWER) * 1024 ** 3
109
                if self.free_space >= min_space:
110
                    logger.debug(f'There is free space {self.free_space / 1024 ** 3:.3f} GiB. '
111
                                 f'No need to del any torrents.')
112
                else:
113
                    indicator, info = self.weight()
114
                    while self.free_space < min_space:
115
                        if not indicator:
116
                            break
117
                        i = indicator.index(min(indicator))
118
                        state = 'Failed to delete'
119
                        try:
120
                            self.client.core.remove_torrent(info[i]['_id'], True)
121
                            state = 'Successfully deleted'
122
                        except TimeoutError as e:
123
                            # 正常操作，一般实际上是已经删了
124
                            logger.error(f'{e.__class__.__name__}: {e}')
125
                        except Exception as e:
126
                            if e.__class__.__name__ == 'InvalidTorrentError':
127
                                # 正常操作，基本上也是删了
128
                                logger.error(f"{e.__module__}.{e.__class__.__name__}: "
129
                                             f"Torrent_id {info[i]['_id']} not in session")
130
                            else:
131
                                logger.exception(e)
132
                        self.free_space += info[i]['done']
133
                        logger.warning(f"{state} {info[i]['state'].lower()} torrent {info[i]['_id']}, "
134
                                       f"name | {info[i]['name']}. ")
135
                        if state == 'Successfully deleted':
136
                            logger.info(f"{info[i]['done'] / 1024 ** 3:.3f} GiB space released. "
137
                                        f"Free space {self.free_space / 1024 ** 3:.3f} GiB.")
138
                        sleep(info[i]['done'] / 1024 ** 3 / 10)
139
                        del indicator[i]
140
                        del info[i]
141
            except Exception as e:
142
                logger.exception(e)
143
            finally:
144
                sleep(INTERVAL)
145

146
    @staticmethod
147
    def torrent_filter(state):
148
        return lambda tup: tup[1]['label'] not in EXCLUDE_LABELS and tup[1]['state'] == state
149

150
    def weight(self):
151
        total_peer_weight = 0
152
        total_time_weight = 0
153
        total_peers = 0
154
        num = 0
155
        indicator = []
156
        info = []
157
        e_m = 0.0
158
        av_ur = sum(self.sur) / len(self.sur)
159
        if av_ur == 0:
160
            av_ur = 1048576
161

162
        for _id, data in filter(self.torrent_filter('Seeding'), self.torrent_status.items()):
163
            total_peers += data['total_peers']
164
            num += 1
165

166
        av_peer_num = total_peers / num if num > 0 else 0
167

168
        for _id, data in filter(self.torrent_filter('Seeding'), self.torrent_status.items()):
169
            data['peer_weight'] = (data['total_peers'] * (1 - KS) + av_peer_num * KS) / (
170
                data['total_seeds'] if data['total_seeds'] > 0 else 1) * data['total_size']
171
            total_peer_weight += data['peer_weight']
172
            k_time = data['seeding_time'] / 3600
173
            k_size = data['total_size'] / (S0 * 1024 ** 3)
174
            data['time_weight'] = pow(1 + pow((k_time / k_size), 2), -0.5)
175
            total_time_weight += data['time_weight']
176

177
        if total_time_weight > 0:
178
            for _id, data in filter(self.torrent_filter('Seeding'), self.torrent_status.items()):
179
                ur_e = data['upload_payload_rate'] * 0.4
180
                ur_tm_p = av_ur * data['time_weight'] / total_time_weight
181
                if total_peer_weight > 0:
182
                    ur_pr_p = av_ur * data['peer_weight'] / total_peer_weight
183
                    ur_e += ur_pr_p * 0.4 + ur_tm_p * 0.2
184
                else:
185
                    ur_e += ur_tm_p * 0.6
186
                sz_e = data['total_done'] / 1024 ** 3
187
                e = ur_e * pow(sz_e, -0.8)
188
                indicator.append(e)
189
                info.append({'_id': _id, 'name': data['name'], 'done': data['total_done'], 'state': data['state']})
190
            if MODE == 1 or av_ur == 0:
191
                e_m = max(indicator) + 1
192

193
        for _id, data in filter(self.torrent_filter('Downloading'), self.torrent_status.items()):
194
            if data['active_time'] < MIN_DOWN_TIME:
195
                continue
196
            au = data['total_uploaded'] / (data['active_time'] + 1)
197
            ur = data['upload_payload_rate']
198
            ur_e = au * 0.5 + ur * 0.5
199
            sz_a = data['download_payload_rate'] * INTERVAL / 2
200
            if sz_a < data['total_size'] - data['total_done']:
201
                sz_e = data['total_size'] / 1024 ** 3
202
            else:
203
                sz_e = (sz_a + data['total_done']) / 1024 ** 3
204
            if sz_e == 0:
205
                continue
206
            e = ur_e * pow(sz_e, -0.8) + e_m
207
            indicator.append(e)
208
            info.append({'_id': _id, 'name': data['name'], 'done': data['total_done'], 'state': data['state']})
209

210
        return indicator, info
211

212
log_path = LOG_PATH or f'{os.path.splitext(__file__)[0]}.log'
213
logger.add(level='DEBUG', sink=log_path, encoding='utf-8', rotation="5 MB")
214

215
AutoDel(Deluge()).run()

You need to install Deluge’s Label plugin, tag the categories you want to auto-delete, create a scheduled task, and run this script:

1
python3 xx.py