mirror of
https://git.deluge-torrent.org/deluge
synced 2025-04-05 20:07:47 +03:00
253eb2240b
Use the new maybe_coroutine decorator to replace callbacks with inline async/await for cleaner code.
726 lines
24 KiB
Python
726 lines
24 KiB
Python
#
|
|
# Copyright (C) 2008-2009 Ido Abramovich <ido.deluge@gmail.com>
|
|
# Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
|
|
#
|
|
# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
|
|
# the additional special exception to link portions of this program with the OpenSSL library.
|
|
# See LICENSE for more details.
|
|
#
|
|
|
|
import locale
|
|
import logging
|
|
import os
|
|
import sys
|
|
import time
|
|
|
|
from twisted.internet import defer, error, reactor
|
|
|
|
import deluge.common
|
|
import deluge.component as component
|
|
from deluge.configmanager import ConfigManager
|
|
from deluge.decorators import maybe_coroutine, overrides
|
|
from deluge.ui.client import client
|
|
from deluge.ui.console.modes.addtorrents import AddTorrents
|
|
from deluge.ui.console.modes.basemode import TermResizeHandler
|
|
from deluge.ui.console.modes.cmdline import CmdLine
|
|
from deluge.ui.console.modes.eventview import EventView
|
|
from deluge.ui.console.modes.preferences import Preferences
|
|
from deluge.ui.console.modes.torrentdetail import TorrentDetail
|
|
from deluge.ui.console.modes.torrentlist.torrentlist import TorrentList
|
|
from deluge.ui.console.utils import colors
|
|
from deluge.ui.console.widgets import StatusBars
|
|
from deluge.ui.coreconfig import CoreConfig
|
|
from deluge.ui.sessionproxy import SessionProxy
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
DEFAULT_CONSOLE_PREFS = {
|
|
'ring_bell': False,
|
|
'first_run': True,
|
|
'language': '',
|
|
'torrentview': {
|
|
'sort_primary': 'queue',
|
|
'sort_secondary': 'name',
|
|
'show_sidebar': True,
|
|
'sidebar_width': 25,
|
|
'separate_complete': True,
|
|
'move_selection': True,
|
|
'columns': {},
|
|
},
|
|
'addtorrents': {
|
|
'show_misc_files': False, # TODO: Showing/hiding this
|
|
'show_hidden_folders': False, # TODO: Showing/hiding this
|
|
'sort_column': 'date',
|
|
'reverse_sort': True,
|
|
'last_path': '~',
|
|
},
|
|
'cmdline': {
|
|
'ignore_duplicate_lines': False,
|
|
'third_tab_lists_all': False,
|
|
'torrents_per_tab_press': 15,
|
|
'save_command_history': True,
|
|
},
|
|
}
|
|
|
|
|
|
class MockConsoleLog:
|
|
def write(self, data):
|
|
pass
|
|
|
|
def flush(self):
|
|
pass
|
|
|
|
|
|
class ConsoleUI(component.Component, TermResizeHandler):
|
|
def __init__(self, options, cmds, log_stream):
|
|
component.Component.__init__(self, 'ConsoleUI')
|
|
TermResizeHandler.__init__(self)
|
|
self.options = options
|
|
self.log_stream = log_stream
|
|
|
|
# keep track of events for the log view
|
|
self.events = []
|
|
self.torrents = []
|
|
self.statusbars = None
|
|
self.modes = {}
|
|
self.active_mode = None
|
|
self.initialized = False
|
|
|
|
try:
|
|
locale.setlocale(locale.LC_ALL, '')
|
|
self.encoding = locale.getpreferredencoding()
|
|
except locale.Error:
|
|
self.encoding = sys.getdefaultencoding()
|
|
|
|
log.debug('Using encoding: %s', self.encoding)
|
|
|
|
# start up the session proxy
|
|
self.sessionproxy = SessionProxy()
|
|
|
|
client.set_disconnect_callback(self.on_client_disconnect)
|
|
|
|
# Set the interactive flag to indicate where we should print the output
|
|
self.interactive = True
|
|
self._commands = cmds
|
|
self.coreconfig = CoreConfig()
|
|
|
|
def start_ui(self):
|
|
"""Start the console UI.
|
|
|
|
Note: When running console UI reactor.run() will be called which
|
|
effectively blocks this function making the return value
|
|
insignificant. However, when running unit tests, the reacor is
|
|
replaced by a mock object, leaving the return deferred object
|
|
necessary for the tests to run properly.
|
|
|
|
Returns:
|
|
Deferred: If valid commands are provided, a deferred that fires when
|
|
all commands are executed. Else None is returned.
|
|
"""
|
|
if self.options.parsed_cmds:
|
|
# Non-Interactive mode
|
|
self.interactive = False
|
|
if not self._commands:
|
|
print('No valid console commands found')
|
|
return
|
|
|
|
deferred = self.exec_args(self.options)
|
|
reactor.run()
|
|
return deferred
|
|
|
|
# Interactive
|
|
|
|
# We use the curses.wrapper function to prevent the console from getting
|
|
# messed up if an uncaught exception is experienced.
|
|
try:
|
|
from curses import wrapper
|
|
except ImportError:
|
|
wrapper = None
|
|
|
|
if deluge.common.windows_check() and not wrapper:
|
|
print(
|
|
"""\nDeluge-console does not run in interactive mode on Windows. \n
|
|
Please use commands from the command line, e.g.:\n
|
|
deluge-console.exe help
|
|
deluge-console.exe info
|
|
deluge-console.exe "add --help"
|
|
deluge-console.exe "add -p c:\\mytorrents c:\\new.torrent"
|
|
"""
|
|
)
|
|
|
|
# We don't ever want log output to terminal when running in
|
|
# interactive mode, so insert a dummy here
|
|
self.log_stream.out = MockConsoleLog()
|
|
|
|
# Set Esc key delay to 0 to avoid a very annoying delay
|
|
# due to curses waiting in case of other key are pressed
|
|
# after ESC is pressed
|
|
os.environ.setdefault('ESCDELAY', '0')
|
|
|
|
wrapper(self.run)
|
|
|
|
@maybe_coroutine
|
|
async def quit(self):
|
|
if client.connected():
|
|
await client.disconnect()
|
|
|
|
try:
|
|
reactor.stop()
|
|
except error.ReactorNotRunning:
|
|
pass
|
|
|
|
@maybe_coroutine
|
|
async def exec_args(self, options):
|
|
"""Execute console commands from command line."""
|
|
from deluge.ui.console.cmdline.command import Commander
|
|
|
|
commander = Commander(self._commands)
|
|
try:
|
|
if not self.interactive and options.parsed_cmds[0].command == 'connect':
|
|
await commander.exec_command(options.parsed_cmds.pop(0))
|
|
else:
|
|
daemon_options = (
|
|
options.daemon_addr,
|
|
options.daemon_port,
|
|
options.daemon_user,
|
|
options.daemon_pass,
|
|
)
|
|
log.info(
|
|
'Connect: host=%s, port=%s, username=%s',
|
|
*daemon_options[0:3],
|
|
)
|
|
await client.connect(*daemon_options)
|
|
except Exception as reason:
|
|
print(
|
|
'Could not connect to daemon: %s:%s\n %s'
|
|
% (options.daemon_addr, options.daemon_port, reason)
|
|
)
|
|
commander.do_command('quit')
|
|
|
|
await self.start_console()
|
|
# Wait for RPCs in start() to finish before processing commands.
|
|
await self.started_deferred
|
|
|
|
for cmd in options.parsed_cmds:
|
|
if cmd.command in ('quit', 'exit'):
|
|
break
|
|
await commander.exec_command(cmd)
|
|
|
|
commander.do_command('quit')
|
|
|
|
def run(self, stdscr):
|
|
"""This method is called by the curses.wrapper to start the mainloop and screen.
|
|
|
|
Args:
|
|
stdscr (_curses.curses window): curses screen passed in from curses.wrapper.
|
|
|
|
"""
|
|
# We want to do an interactive session, so start up the curses screen and
|
|
# pass it the function that handles commands
|
|
colors.init_colors()
|
|
self.stdscr = stdscr
|
|
self.config = ConfigManager(
|
|
'console.conf', defaults=DEFAULT_CONSOLE_PREFS, file_version=2
|
|
)
|
|
self.config.run_converter((0, 1), 2, self._migrate_config_1_to_2)
|
|
|
|
self.statusbars = StatusBars()
|
|
from deluge.ui.console.modes.connectionmanager import ConnectionManager
|
|
|
|
self.register_mode(ConnectionManager(stdscr, self.encoding), set_mode=True)
|
|
|
|
torrentlist = self.register_mode(TorrentList(self.stdscr, self.encoding))
|
|
self.register_mode(CmdLine(self.stdscr, self.encoding))
|
|
self.register_mode(EventView(torrentlist, self.stdscr, self.encoding))
|
|
self.register_mode(
|
|
TorrentDetail(torrentlist, self.stdscr, self.config, self.encoding)
|
|
)
|
|
self.register_mode(
|
|
Preferences(torrentlist, self.stdscr, self.config, self.encoding)
|
|
)
|
|
self.register_mode(
|
|
AddTorrents(torrentlist, self.stdscr, self.config, self.encoding)
|
|
)
|
|
|
|
self.eventlog = EventLog()
|
|
|
|
self.active_mode.topbar = (
|
|
'{!status!}Deluge ' + deluge.common.get_version() + ' Console'
|
|
)
|
|
self.active_mode.bottombar = '{!status!}'
|
|
self.active_mode.refresh()
|
|
# Start the twisted mainloop
|
|
reactor.run()
|
|
|
|
@overrides(TermResizeHandler)
|
|
def on_terminal_size(self, *args):
|
|
rows, cols = super().on_terminal_size(args)
|
|
for mode in self.modes:
|
|
self.modes[mode].on_resize(rows, cols)
|
|
|
|
def register_mode(self, mode, set_mode=False):
|
|
self.modes[mode.mode_name] = mode
|
|
if set_mode:
|
|
self.set_mode(mode.mode_name)
|
|
return mode
|
|
|
|
def set_mode(self, mode_name, refresh=False):
|
|
log.debug('Setting console mode: %s', mode_name)
|
|
mode = self.modes.get(mode_name, None)
|
|
if mode is None:
|
|
log.error('Non-existent mode requested: %s', mode_name)
|
|
return
|
|
self.stdscr.erase()
|
|
|
|
if self.active_mode:
|
|
self.active_mode.pause()
|
|
d = component.pause([self.active_mode.mode_name])
|
|
|
|
def on_mode_paused(result, mode, *args):
|
|
from deluge.ui.console.widgets.popup import PopupsHandler
|
|
|
|
if isinstance(mode, PopupsHandler):
|
|
if mode.popup is not None:
|
|
# If popups are not removed, they are still referenced in the memory
|
|
# which can cause issues as the popup's screen will not be destroyed.
|
|
# This can lead to the popup border being visible for short periods
|
|
# while the current modes' screen is repainted.
|
|
log.error(
|
|
'Mode "%s" still has popups available after being paused.'
|
|
' Ensure all popups are removed on pause!',
|
|
mode.popup.title,
|
|
)
|
|
|
|
d.addCallback(on_mode_paused, self.active_mode)
|
|
reactor.removeReader(self.active_mode)
|
|
|
|
self.active_mode = mode
|
|
self.statusbars.screen = self.active_mode
|
|
|
|
# The Screen object is designed to run as a twisted reader so that it
|
|
# can use twisted's select poll for non-blocking user input.
|
|
reactor.addReader(self.active_mode)
|
|
self.stdscr.clear()
|
|
|
|
if self.active_mode._component_state == 'Stopped':
|
|
component.start([self.active_mode.mode_name])
|
|
else:
|
|
component.resume([self.active_mode.mode_name])
|
|
|
|
mode.resume()
|
|
if refresh:
|
|
mode.refresh()
|
|
return mode
|
|
|
|
def switch_mode(self, func, error_smg):
|
|
def on_stop(arg):
|
|
if arg and True in arg[0]:
|
|
func()
|
|
else:
|
|
self.messages.append(('Error', error_smg))
|
|
|
|
component.stop(['TorrentList']).addCallback(on_stop)
|
|
|
|
def is_active_mode(self, mode):
|
|
return mode == self.active_mode
|
|
|
|
@maybe_coroutine
|
|
async def start_components(self):
|
|
if not self.interactive:
|
|
return await component.start(['SessionProxy', 'ConsoleUI', 'CoreConfig'])
|
|
|
|
await component.start()
|
|
component.pause(
|
|
[
|
|
'TorrentList',
|
|
'EventView',
|
|
'AddTorrents',
|
|
'TorrentDetail',
|
|
'Preferences',
|
|
]
|
|
)
|
|
|
|
@maybe_coroutine
|
|
async def start_console(self):
|
|
self.started_deferred = defer.Deferred()
|
|
|
|
if self.initialized:
|
|
await component.stop(['SessionProxy'])
|
|
await component.start(['SessionProxy'])
|
|
else:
|
|
self.initialized = True
|
|
await self.start_components()
|
|
|
|
@maybe_coroutine
|
|
async def start(self):
|
|
result = await client.core.get_session_state()
|
|
# Maintain a list of (torrent_id, name) for use in tab completion
|
|
self.torrents = []
|
|
self.events = []
|
|
|
|
torrents = await client.core.get_torrents_status({'id': result}, ['name'])
|
|
for torrent_id, status in torrents.items():
|
|
self.torrents.append((torrent_id, status['name']))
|
|
|
|
self.started_deferred.callback(True)
|
|
|
|
# Register event handlers to keep the torrent list up-to-date
|
|
client.register_event_handler('TorrentAddedEvent', self.on_torrent_added_event)
|
|
client.register_event_handler(
|
|
'TorrentRemovedEvent', self.on_torrent_removed_event
|
|
)
|
|
|
|
def on_torrent_added_event(self, event, from_state=False):
|
|
def on_torrent_status(status):
|
|
self.torrents.append((event, status['name']))
|
|
|
|
client.core.get_torrent_status(event, ['name']).addCallback(on_torrent_status)
|
|
|
|
def on_torrent_removed_event(self, event):
|
|
for index, (tid, name) in enumerate(self.torrents):
|
|
if event == tid:
|
|
del self.torrents[index]
|
|
|
|
def match_torrents(self, strings):
|
|
torrent_ids = []
|
|
for s in strings:
|
|
torrent_ids.extend(self.match_torrent(s))
|
|
return list(set(torrent_ids))
|
|
|
|
def match_torrent(self, string):
|
|
"""
|
|
Returns a list of torrent_id matches for the string. It will search both
|
|
torrent_ids and torrent names, but will only return torrent_ids.
|
|
|
|
:param string: str, the string to match on
|
|
|
|
:returns: list of matching torrent_ids. Will return an empty list if
|
|
no matches are found.
|
|
|
|
"""
|
|
deluge.common.decode_bytes(string, self.encoding)
|
|
|
|
if string == '*' or string == '':
|
|
return [tid for tid, name in self.torrents]
|
|
|
|
match_func = '__eq__'
|
|
if string.startswith('*'):
|
|
string = string[1:]
|
|
match_func = 'endswith'
|
|
if string.endswith('*'):
|
|
match_func = '__contains__' if match_func == 'endswith' else 'startswith'
|
|
string = string[:-1]
|
|
|
|
matches = []
|
|
for tid, name in self.torrents:
|
|
deluge.common.decode_bytes(name, self.encoding)
|
|
if getattr(tid, match_func, None)(string) or getattr(
|
|
name, match_func, None
|
|
)(string):
|
|
matches.append(tid)
|
|
return matches
|
|
|
|
def get_torrent_name(self, torrent_id):
|
|
for tid, name in self.torrents:
|
|
if torrent_id == tid:
|
|
return name
|
|
return None
|
|
|
|
def set_batch_write(self, batch):
|
|
if self.interactive and isinstance(
|
|
self.active_mode, deluge.ui.console.modes.cmdline.CmdLine
|
|
):
|
|
return self.active_mode.set_batch_write(batch)
|
|
|
|
def tab_complete_torrent(self, line):
|
|
if self.interactive and isinstance(
|
|
self.active_mode, deluge.ui.console.modes.cmdline.CmdLine
|
|
):
|
|
return self.active_mode.tab_complete_torrent(line)
|
|
|
|
def tab_complete_path(
|
|
self, line, path_type='file', ext='', sort='name', dirs_first=True
|
|
):
|
|
if self.interactive and isinstance(
|
|
self.active_mode, deluge.ui.console.modes.cmdline.CmdLine
|
|
):
|
|
return self.active_mode.tab_complete_path(
|
|
line, path_type=path_type, ext=ext, sort=sort, dirs_first=dirs_first
|
|
)
|
|
|
|
def on_client_disconnect(self):
|
|
component.stop()
|
|
|
|
def write(self, s):
|
|
if self.interactive:
|
|
if isinstance(self.active_mode, deluge.ui.console.modes.cmdline.CmdLine):
|
|
self.active_mode.write(s)
|
|
else:
|
|
component.get('CmdLine').add_line(s, False)
|
|
self.events.append(s)
|
|
else:
|
|
print(colors.strip_colors(s))
|
|
|
|
def write_event(self, s):
|
|
if self.interactive:
|
|
if isinstance(self.active_mode, deluge.ui.console.modes.cmdline.CmdLine):
|
|
self.events.append(s)
|
|
self.active_mode.write(s)
|
|
else:
|
|
component.get('CmdLine').add_line(s, False)
|
|
self.events.append(s)
|
|
else:
|
|
print(colors.strip_colors(s))
|
|
|
|
def _migrate_config_1_to_2(self, config):
|
|
"""Create better structure by moving most settings out of dict root
|
|
and into sub categories. Some keys are also renamed to be consistent
|
|
with other UIs.
|
|
"""
|
|
|
|
def move_key(source, dest, source_key, dest_key=None):
|
|
if dest_key is None:
|
|
dest_key = source_key
|
|
dest[dest_key] = source[source_key]
|
|
del source[source_key]
|
|
|
|
# These are moved to 'torrentview' sub dict
|
|
for k in [
|
|
'sort_primary',
|
|
'sort_secondary',
|
|
'move_selection',
|
|
'separate_complete',
|
|
]:
|
|
move_key(config, config['torrentview'], k)
|
|
|
|
# These are moved to 'addtorrents' sub dict
|
|
for k in [
|
|
'show_misc_files',
|
|
'show_hidden_folders',
|
|
'sort_column',
|
|
'reverse_sort',
|
|
'last_path',
|
|
]:
|
|
move_key(config, config['addtorrents'], 'addtorrents_%s' % k, dest_key=k)
|
|
|
|
# These are moved to 'cmdline' sub dict
|
|
for k in [
|
|
'ignore_duplicate_lines',
|
|
'torrents_per_tab_press',
|
|
'third_tab_lists_all',
|
|
]:
|
|
move_key(config, config['cmdline'], k)
|
|
|
|
move_key(
|
|
config,
|
|
config['cmdline'],
|
|
'save_legacy_history',
|
|
dest_key='save_command_history',
|
|
)
|
|
|
|
# Add key for localization
|
|
config['language'] = DEFAULT_CONSOLE_PREFS['language']
|
|
|
|
# Migrate column settings
|
|
columns = [
|
|
'queue',
|
|
'size',
|
|
'state',
|
|
'progress',
|
|
'seeds',
|
|
'peers',
|
|
'downspeed',
|
|
'upspeed',
|
|
'eta',
|
|
'ratio',
|
|
'avail',
|
|
'added',
|
|
'tracker',
|
|
'savepath',
|
|
'downloaded',
|
|
'uploaded',
|
|
'remaining',
|
|
'owner',
|
|
'downloading_time',
|
|
'seeding_time',
|
|
'completed',
|
|
'seeds_peers_ratio',
|
|
'complete_seen',
|
|
'down_limit',
|
|
'up_limit',
|
|
'shared',
|
|
'name',
|
|
]
|
|
column_name_mapping = {
|
|
'downspeed': 'download_speed',
|
|
'upspeed': 'upload_speed',
|
|
'added': 'time_added',
|
|
'savepath': 'download_location',
|
|
'completed': 'completed_time',
|
|
'complete_seen': 'last_seen_complete',
|
|
'down_limit': 'max_download_speed',
|
|
'up_limit': 'max_upload_speed',
|
|
'downloading_time': 'active_time',
|
|
}
|
|
|
|
from deluge.ui.console.modes.torrentlist.torrentview import default_columns
|
|
|
|
# These are moved to 'torrentview.columns' sub dict
|
|
for k in columns:
|
|
column_name = column_name_mapping.get(k, k)
|
|
config['torrentview']['columns'][column_name] = {}
|
|
if k == 'name':
|
|
config['torrentview']['columns'][column_name]['visible'] = True
|
|
else:
|
|
move_key(
|
|
config,
|
|
config['torrentview']['columns'][column_name],
|
|
'show_%s' % k,
|
|
dest_key='visible',
|
|
)
|
|
move_key(
|
|
config,
|
|
config['torrentview']['columns'][column_name],
|
|
'%s_width' % k,
|
|
dest_key='width',
|
|
)
|
|
config['torrentview']['columns'][column_name]['order'] = default_columns[
|
|
column_name
|
|
]['order']
|
|
|
|
return config
|
|
|
|
|
|
class EventLog(component.Component):
|
|
"""
|
|
Prints out certain events as they are received from the core.
|
|
"""
|
|
|
|
def __init__(self):
|
|
component.Component.__init__(self, 'EventLog')
|
|
self.console = component.get('ConsoleUI')
|
|
self.prefix = '{!event!}* [%H:%M:%S] '
|
|
self.date_change_format = 'On {!yellow!}%a, %d %b %Y{!input!} %Z:'
|
|
|
|
client.register_event_handler('TorrentAddedEvent', self.on_torrent_added_event)
|
|
client.register_event_handler(
|
|
'PreTorrentRemovedEvent', self.on_torrent_removed_event
|
|
)
|
|
client.register_event_handler(
|
|
'TorrentStateChangedEvent', self.on_torrent_state_changed_event
|
|
)
|
|
client.register_event_handler(
|
|
'TorrentFinishedEvent', self.on_torrent_finished_event
|
|
)
|
|
client.register_event_handler(
|
|
'NewVersionAvailableEvent', self.on_new_version_available_event
|
|
)
|
|
client.register_event_handler(
|
|
'SessionPausedEvent', self.on_session_paused_event
|
|
)
|
|
client.register_event_handler(
|
|
'SessionResumedEvent', self.on_session_resumed_event
|
|
)
|
|
client.register_event_handler(
|
|
'ConfigValueChangedEvent', self.on_config_value_changed_event
|
|
)
|
|
client.register_event_handler(
|
|
'PluginEnabledEvent', self.on_plugin_enabled_event
|
|
)
|
|
client.register_event_handler(
|
|
'PluginDisabledEvent', self.on_plugin_disabled_event
|
|
)
|
|
|
|
self.previous_time = time.localtime(0)
|
|
|
|
def on_torrent_added_event(self, torrent_id, from_state):
|
|
if from_state:
|
|
return
|
|
|
|
def on_torrent_status(status):
|
|
self.write(
|
|
'{!green!}Torrent Added: {!info!}%s ({!cyan!}%s{!info!})'
|
|
% (status['name'], torrent_id)
|
|
)
|
|
# Write out what state the added torrent took
|
|
self.on_torrent_state_changed_event(torrent_id, status['state'])
|
|
|
|
client.core.get_torrent_status(torrent_id, ['name', 'state']).addCallback(
|
|
on_torrent_status
|
|
)
|
|
|
|
def on_torrent_removed_event(self, torrent_id):
|
|
self.write(
|
|
'{!red!}Torrent Removed: {!info!}%s ({!cyan!}%s{!info!})'
|
|
% (self.console.get_torrent_name(torrent_id), torrent_id)
|
|
)
|
|
|
|
def on_torrent_state_changed_event(self, torrent_id, state):
|
|
# It's probably a new torrent, ignore it
|
|
if not state:
|
|
return
|
|
# Modify the state string color
|
|
if state in colors.state_color:
|
|
state = colors.state_color[state] + state
|
|
|
|
t_name = self.console.get_torrent_name(torrent_id)
|
|
|
|
# Again, it's most likely a new torrent
|
|
if not t_name:
|
|
return
|
|
|
|
self.write(f'{state}: {{!info!}}{t_name} ({{!cyan!}}{torrent_id}{{!info!}})')
|
|
|
|
def on_torrent_finished_event(self, torrent_id):
|
|
if component.get('TorrentList').config['ring_bell']:
|
|
import curses.beep
|
|
|
|
curses.beep()
|
|
self.write(
|
|
'{!info!}Torrent Finished: %s ({!cyan!}%s{!info!})'
|
|
% (self.console.get_torrent_name(torrent_id), torrent_id)
|
|
)
|
|
|
|
def on_new_version_available_event(self, version):
|
|
self.write('{!input!}New Deluge version available: {!info!}%s' % (version))
|
|
|
|
def on_session_paused_event(self):
|
|
self.write('{!input!}Session Paused')
|
|
|
|
def on_session_resumed_event(self):
|
|
self.write('{!green!}Session Resumed')
|
|
|
|
def on_config_value_changed_event(self, key, value):
|
|
color = '{!white,black,bold!}'
|
|
try:
|
|
color = colors.type_color[type(value)]
|
|
except KeyError:
|
|
pass
|
|
|
|
self.write(f'ConfigValueChanged: {{!input!}}{key}: {color}{value}')
|
|
|
|
def write(self, s):
|
|
current_time = time.localtime()
|
|
|
|
date_different = False
|
|
for field in ['tm_mday', 'tm_mon', 'tm_year']:
|
|
c = getattr(current_time, field)
|
|
p = getattr(self.previous_time, field)
|
|
if c != p:
|
|
date_different = True
|
|
|
|
if date_different:
|
|
string = time.strftime(self.date_change_format)
|
|
self.console.write_event(' ')
|
|
self.console.write_event(string)
|
|
|
|
p = time.strftime(self.prefix)
|
|
|
|
self.console.write_event(p + s)
|
|
self.previous_time = current_time
|
|
|
|
def on_plugin_enabled_event(self, name):
|
|
self.write('PluginEnabled: {!info!}%s' % name)
|
|
|
|
def on_plugin_disabled_event(self, name):
|
|
self.write('PluginDisabled: {!info!}%s' % name)
|