codex-storage
/
deluge
mirror of https://github.com/codex-storage/deluge.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of deluge-torrent.org:/deluge

This commit is contained in:
Nick Lanham 2011-02-23 20:05:48 +01:00
parent 4c2f9a1a0a 64e38eac20
commit db46a97263
13 changed files with 105 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
deluge/event.py
View File

@ -243,12 +243,13 @@ class PluginEnabledEvent(DelugeEvent):
"""
Emitted when a plugin is enabled in the Core.
"""
def __init__(self, name):
self._args = [name]
def __init__(self, plugin_name):
self._args = [plugin_name]
class PluginDisabledEvent(DelugeEvent):
"""
Emitted when a plugin is disabled in the Core.
"""
def __init__(self, name):
self._args = [name]
def __init__(self, plugin_name):
self._args = [plugin_name]

24
deluge/plugins/autoadd/autoadd/core.py
View File

@ -59,7 +59,7 @@ OPTIONS_AVAILABLE = { #option: builtin
"enabled":False,
"path":False,
"append_extension":False,
"abspath":False,
"abspath":False,
"download_location":True,
"max_download_speed":True,
"max_upload_speed":True,
@ -81,6 +81,8 @@ MAX_NUM_ATTEMPTS = 10
class AutoaddOptionsChangedEvent(DelugeEvent):
"""Emitted when the options for the plugin are changed."""
def __init__(self):
pass
def CheckInput(cond, message):
if not cond:
@ -88,7 +90,7 @@ def CheckInput(cond, message):
class Core(CorePluginBase):
def enable(self):
#reduce typing, assigning some values to self...
self.config = deluge.configmanager.ConfigManager("autoadd.conf", DEFAULT_PREFS)
self.watchdirs = self.config["watchdirs"]
@ -127,7 +129,7 @@ class Core(CorePluginBase):
def update(self):
pass
@export()
def set_options(self, watchdir_id, options):
"""Update the options for a watch folder."""
@ -147,14 +149,14 @@ class Core(CorePluginBase):
#disable the watch loop if it was active
if watchdir_id in self.update_timers:
self.disable_watchdir(watchdir_id)
self.watchdirs[watchdir_id].update(options)
#re-enable watch loop if appropriate
if self.watchdirs[watchdir_id]['enabled']:
self.enable_watchdir(watchdir_id)
self.config.save()
component.get("EventManager").emit(AutoaddOptionsChangedEvent())
def load_torrent(self, filename):
try:
log.debug("Attempting to open %s for add.", filename)
@ -171,7 +173,7 @@ class Core(CorePluginBase):
info = lt.torrent_info(lt.bdecode(filedump))
return filedump
def update_watchdir(self, watchdir_id):
"""Check the watch folder for new torrents to add."""
watchdir_id = str(watchdir_id)
@ -185,7 +187,7 @@ class Core(CorePluginBase):
log.warning("Invalid AutoAdd folder: %s", watchdir["abspath"])
self.disable_watchdir(watchdir_id)
return
# Generate options dict for watchdir
opts = {}
if 'stop_at_ratio_toggle' in watchdir:
@ -246,7 +248,7 @@ class Core(CorePluginBase):
"""Disables any watch folders with unhandled exceptions."""
self.disable_watchdir(watchdir_id)
log.error("Disabling '%s', error during update: %s" % (self.watchdirs[watchdir_id]["path"], failure))
@export
def enable_watchdir(self, watchdir_id):
watchdir_id = str(watchdir_id)
@ -259,7 +261,7 @@ class Core(CorePluginBase):
self.watchdirs[watchdir_id]['enabled'] = True
self.config.save()
component.get("EventManager").emit(AutoaddOptionsChangedEvent())
@export
def disable_watchdir(self, watchdir_id):
watchdir_id = str(watchdir_id)
@ -287,7 +289,7 @@ class Core(CorePluginBase):
def get_config(self):
"""Returns the config dictionary."""
return self.config.config
@export()
def get_watchdirs(self):
return self.watchdirs.keys()
@ -319,7 +321,7 @@ class Core(CorePluginBase):
self.config.save()
component.get("EventManager").emit(AutoaddOptionsChangedEvent())
return watchdir_id
@export
def remove(self, watchdir_id):
"""Remove a watch folder."""

66
deluge/plugins/autoadd/autoadd/gtkui.py
View File

@ -115,22 +115,22 @@ class OptionsDialog():
self.glade.get_widget(field+"_entry").show()
self.glade.get_widget(field+"_chooser").hide()
self.set_sensitive()
def on_get_enabled_plugins(result):
if 'Label' in result:
if 'Label' in result:
self.glade.get_widget('label_frame').show()
else:
self.glade.get_widget('label_frame').hide()
self.glade.get_widget('label_toggle').set_active(False)
client.core.get_enabled_plugins().addCallback(on_get_enabled_plugins)
def set_sensitive(self):
maintoggles = ['download_location', 'append_extension', 'move_completed', 'label', \
'max_download_speed', 'max_upload_speed', 'max_connections', \
'max_upload_slots', 'add_paused', 'auto_managed', 'stop_at_ratio', 'queue_to_top']
[self.on_toggle_toggled(self.glade.get_widget(x+'_toggle')) for x in maintoggles]
def on_toggle_toggled(self, tb):
toggle = str(tb.name).replace("_toggle", "")
isactive = tb.get_active()
@ -168,29 +168,29 @@ class OptionsDialog():
self.glade.get_widget('stop_at_ratio').set_active(isactive)
self.glade.get_widget('stop_ratio').set_sensitive(isactive)
self.glade.get_widget('remove_at_ratio').set_sensitive(isactive)
def on_apply(self, Event=None):
client.autoadd.set_options(str(self.watchdir_id), self.generate_opts()).addCallbacks(self.on_added, self.on_error_show)
def on_error_show(self, result):
self.glade.get_widget('error_label').set_text(result.value.exception_msg)
self.err_dialog = self.glade.get_widget('error_dialog')
self.err_dialog.set_transient_for(self.dialog)
result.cleanFailure()
self.err_dialog.show()
def on_added(self, result):
self.dialog.destroy()
def on_error_ok(self, Event=None):
self.err_dialog.hide()
def on_add(self, Event=None):
client.autoadd.add(self.generate_opts()).addCallbacks(self.on_added, self.on_error_show)
def on_cancel(self, Event=None):
self.dialog.destroy()
def generate_opts(self):
# generate options dict based on gtk objects
options = {}
@ -219,11 +219,11 @@ class OptionsDialog():
options[id] = self.glade.get_widget(id).get_active()
options[id+'_toggle'] = self.glade.get_widget(id+'_toggle').get_active()
return options
class GtkUI(GtkPluginBase):
def enable(self):
self.glade = gtk.glade.XML(get_resource("config.glade"))
self.glade.signal_autoconnect({
"on_add_button_clicked": self.on_add_button_clicked,
@ -231,18 +231,18 @@ class GtkUI(GtkPluginBase):
"on_remove_button_clicked": self.on_remove_button_clicked
})
self.opts_dialog = OptionsDialog()
component.get("PluginManager").register_hook("on_apply_prefs", self.on_apply_prefs)
component.get("PluginManager").register_hook("on_show_prefs", self.on_show_prefs)
client.register_event_handler("AutoaddOptionsChangedEvent", self.on_options_changed_event)
self.watchdirs = {}
vbox = self.glade.get_widget("watchdirs_vbox")
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox.pack_start(sw, True, True, 0)
self.store = self.create_model()
@ -258,28 +258,28 @@ class GtkUI(GtkPluginBase):
component.get("Preferences").add_page("AutoAdd", self.glade.get_widget("prefs_box"))
self.on_show_prefs()
def disable(self):
component.get("Preferences").remove_page("AutoAdd")
component.get("PluginManager").deregister_hook("on_apply_prefs", self.on_apply_prefs)
component.get("PluginManager").deregister_hook("on_show_prefs", self.on_show_prefs)
def create_model(self):
store = gtk.ListStore(str, bool, str)
for watchdir_id, watchdir in self.watchdirs.iteritems():
store.append([watchdir_id, watchdir['enabled'], watchdir['path']])
return store
def create_columns(self, treeView):
rendererToggle = gtk.CellRendererToggle()
column = gtk.TreeViewColumn("On", rendererToggle, activatable=True, active=1)
column.set_sort_column_id(1)
column.set_sort_column_id(1)
treeView.append_column(column)
tt = gtk.Tooltip()
tt.set_text('Double-click to toggle')
treeView.set_tooltip_cell(tt, None, None, rendererToggle)
rendererText = gtk.CellRendererText()
column = gtk.TreeViewColumn("Path", rendererText, text=2)
column.set_sort_column_id(2)
@ -291,20 +291,20 @@ class GtkUI(GtkPluginBase):
def load_watchdir_list(self):
pass
def add_watchdir_entry(self):
pass
def on_add_button_clicked(self, Event=None):
#display options_window
self.opts_dialog.show()
def on_remove_button_clicked(self, Event=None):
tree, tree_id = self.treeView.get_selection().get_selected()
watchdir_id = str(self.store.get_value(tree_id, 0))
if watchdir_id:
client.autoadd.remove(watchdir_id)
def on_edit_button_clicked(self, Event=None, a=None, col=None):
tree, tree_id = self.treeView.get_selection().get_selected()
watchdir_id = str(self.store.get_value(tree_id, 0))
@ -316,7 +316,7 @@ class GtkUI(GtkPluginBase):
client.autoadd.enable_watchdir(watchdir_id)
else:
self.opts_dialog.show(self.watchdirs[watchdir_id], watchdir_id)
def on_listitem_activated(self, treeview):
tree, tree_id = self.treeView.get_selection().get_selected()
if tree_id:
@ -325,7 +325,7 @@ class GtkUI(GtkPluginBase):
else:
self.glade.get_widget('edit_button').set_sensitive(False)
self.glade.get_widget('remove_button').set_sensitive(False)
def on_apply_prefs(self):
log.debug("applying prefs for AutoAdd")
for watchdir_id, watchdir in self.watchdirs.iteritems():
@ -333,8 +333,8 @@ class GtkUI(GtkPluginBase):
def on_show_prefs(self):
client.autoadd.get_config().addCallback(self.cb_get_config)
def on_options_changed_event(self, event):
def on_options_changed_event(self):
client.autoadd.get_config().addCallback(self.cb_get_config)
def cb_get_config(self, config):
@ -346,4 +346,4 @@ class GtkUI(GtkPluginBase):
# Disable the remove and edit buttons, because nothing in the store is selected
self.glade.get_widget('remove_button').set_sensitive(False)
self.glade.get_widget('edit_button').set_sensitive(False)

24
deluge/plugins/execute/execute/core.py
View File

@ -64,19 +64,15 @@ class ExecuteCommandAddedEvent(DelugeEvent):
"""
Emitted when a new command is added.
"""
__slots__ = ('command_id', 'event', 'command')
def __init__(self, command_id, event, command):
self.command_id = command_id
self.event = event
self.command = command
self._args = [command_id, event, command]
class ExecuteCommandRemovedEvent(DelugeEvent):
"""
Emitted when a command is removed.
"""
__slots__ = ('command_id',)
def __init__(self, command_id):
self.command_id = command_id
self._args = [command_id]
class Core(CorePluginBase):
def enable(self):
@ -86,17 +82,17 @@ class Core(CorePluginBase):
# Go through the commands list and register event handlers
for command in self.config["commands"]:
event_name = command[EXECUTE_EVENT]
if event_name in self.registered_events:
event = command[EXECUTE_EVENT]
if event in self.registered_events:
continue
def create_event_handler(event_name):
def event_handler(event):
self.execute_commands(event.torrent_id, event_name)
def create_event_handler(event):
def event_handler(torrent_id):
self.execute_commands(torrent_id, event)
return event_handler
event_handler = create_event_handler(event_name)
event_manager.register_event_handler(EVENT_MAP[event_name], event_handler)
self.registered_events[event_name] = event_handler
event_handler = create_event_handler(event)
event_manager.register_event_handler(EVENT_MAP[event], event_handler)
self.registered_events[event] = event_handler
log.debug("Execute core plugin enabled!")

12
deluge/plugins/execute/execute/gtkui.py
View File

@ -161,13 +161,13 @@ class ExecutePreferences(object):
command = widget.get_text()
client.execute.save_command(command_id, event, command)
def on_command_added_event(self, event):
log.debug("Adding command %s: %s", event.event, event.command)
self.add_command(event.command_id, event.event, event.command)
def on_command_added_event(self, command_id, event, command):
log.debug("Adding command %s: %s", event, command)
self.add_command(command_id, event, command)
def on_command_removed_event(self, event):
log.debug("Removing command %s", event.command_id)
self.remove_command(event.command_id)
def on_command_removed_event(self, command_id):
log.debug("Removing command %s", command_id)
self.remove_command(command_id)
class GtkUI(GtkPluginBase):

20
deluge/plugins/extractor/extractor/core.py
View File

@ -77,14 +77,14 @@ class Core(CorePluginBase):
def update(self):
pass
def _on_torrent_finished(self, event):
def _on_torrent_finished(self, torrent_id):
"""
This is called when a torrent finishes. We need to check to see if there
are any files to extract.
"""
# Get the save path
save_path = component.get("TorrentManager")[event.torrent_id].get_status(["save_path"])["save_path"]
files = component.get("TorrentManager")[event.torrent_id].get_files()
save_path = component.get("TorrentManager")[torrent_id].get_status(["save_path"])["save_path"]
files = component.get("TorrentManager")[torrent_id].get_files()
for f in files:
ext = os.path.splitext(f["path"])
if ext[1] in (".gz", ".bz2", ".lzma"):
@ -100,22 +100,22 @@ class Core(CorePluginBase):
# Now that we have the cmd, lets run it to extract the files
fp = os.path.join(save_path, f["path"])
# Get the destination path
dest = self.config["extract_path"]
if self.config["use_name_folder"]:
name = component.get("TorrentManager")[event.torrent_id].get_status(["name"])["name"]
name = component.get("TorrentManager")[torrent_id].get_status(["name"])["name"]
dest = os.path.join(dest, name)
# Create the destination folder if it doesn't exist
# Create the destination folder if it doesn't exist
if not os.path.exists(dest):
try:
os.makedirs(dest)
except Exception, e:
log.error("Error creating destination folder: %s", e)
return
log.debug("Extracting to %s", dest)
log.debug("Extracting to %s", dest)
def on_extract_success(result, torrent_id):
# XXX: Emit an event
log.debug("Extract was successful for %s", torrent_id)
@ -126,8 +126,8 @@ class Core(CorePluginBase):
# Run the command and add some callbacks
d = getProcessValue(cmd[0], cmd[1].split() + [str(fp)], {}, str(dest))
d.addCallback(on_extract_success, event.torrent_id)
d.addErrback(on_extract_failed, event.torrent_id)
d.addCallback(on_extract_success, torrent_id)
d.addErrback(on_extract_failed, torrent_id)
@export
def set_config(self, config):

16
deluge/plugins/freespace/freespace/core.py
View File

@ -55,14 +55,12 @@ class LowDiskSpaceEvent(DelugeEvent):
"""Triggered when the available space for a specific path is getting
too low.
"""
__slots__ = ('percents_dict',)
def __init__(self, percents_dict):
"""
:param percents: dictionary of path keys with their respecive
occupation percentages.
"""
self.percents_dict = percents_dict
self._args = [percents_dict]
DEFAULT_PREFS = {
"enabled": False,
@ -174,25 +172,25 @@ class Core(CorePluginBase):
free_percent = free_blocks * 100 / total_blocks
return free_percent
def __custom_email_notification(self, event):
def __custom_email_notification(self, ocupied_percents):
subject = _("Low Disk Space Warning")
message = _("You're running low on disk space:\n")
for path, ocupied_percent in event.percents_dict.iteritems():
for path, ocupied_percent in ocupied_percents.iteritems():
message += _(' %s%% ocupation in %s\n') % (ocupied_percent, path)
# "\"%s\"%% space occupation on %s") % (ocupied_percent, path)
return subject, message
def __on_plugin_enabled(self, event):
if event.plugin_name == 'Notifications':
def __on_plugin_enabled(self, plugin_name):
if plugin_name == 'Notifications':
component.get("CorePlugin.Notifications"). \
register_custom_email_notification(
"LowDiskSpaceEvent", self.__custom_email_notification
)
def __on_plugin_disabled(self, event):
if event.plugin_name == 'Notifications':
def __on_plugin_disabled(self, plugin_name):
if plugin_name == 'Notifications':
component.get("CorePlugin.Notifications"). \
deregister_custom_email_notification("LowDiskSpaceEvent")

14
deluge/plugins/freespace/freespace/gtkui.py
View File

@ -134,22 +134,22 @@ class GtkUI(GtkPluginBase):
self.glade.get_widget('enabled').set_active(config['enabled'])
self.glade.get_widget('percent').set_value(config['percent'])
def __custom_popup_notification(self, event):
def __custom_popup_notification(self, ocupied_percents):
title = _("Low Free Space")
message = ''
for path, percent in event.percents_dict.iteritems():
for path, percent in ocupied_percents.iteritems():
message += '%s%% %s\n' % (percent, path)
message += '\n'
return title, message
def __custom_blink_notification(self, event):
def __custom_blink_notification(self, ocupied_percents):
return True # Yes, do blink
def __custom_sound_notification(self, event):
def __custom_sound_notification(self, ocupied_percents):
return '' # Use default sound
def __on_plugin_enabled(self, event):
if event.plugin_name == 'Notifications':
def __on_plugin_enabled(self, plugin_name):
if plugin_name == 'Notifications':
notifications = component.get("GtkPlugin.Notifications")
notifications.register_custom_popup_notification(
"LowDiskSpaceEvent", self.__custom_popup_notification
@ -161,7 +161,7 @@ class GtkUI(GtkPluginBase):
"LowDiskSpaceEvent", self.__custom_sound_notification
)
def __on_plugin_disabled(self, event):
def __on_plugin_disabled(self, plugin_name):
pass
# if plugin_name == 'Notifications':
# notifications = component.get("GtkPlugin.Notifications")

12
deluge/plugins/label/label/core.py
View File

@ -133,20 +133,20 @@ class Core(CorePluginBase):
return dict( [(label, 0) for label in self.labels.keys()])
## Plugin hooks ##
def post_torrent_add(self, event):
def post_torrent_add(self, torrent_id, from_state):
log.debug("post_torrent_add")
torrent = self.torrents[event.torrent_id]
torrent = self.torrents[torrent_id]
for label_id, options in self.labels.iteritems():
if options["auto_add"]:
if self._has_auto_match(torrent, options):
self.set_torrent(event.torrent_id, label_id)
self.set_torrent(torrent_id, label_id)
return
def post_torrent_remove(self, event):
def post_torrent_remove(self, torrent_id):
log.debug("post_torrent_remove")
if event.torrent_id in self.torrent_labels:
del self.torrent_labels[event.torrent_id]
if torrent_id in self.torrent_labels:
del self.torrent_labels[torrent_id]
## Utils ##
def clean_config(self):

4
deluge/plugins/notifications/notifications/core.py
View File

@ -188,9 +188,9 @@ Subject: %(subject)s
return _("Notification email sent.")
def _on_torrent_finished_event(self, event):
def _on_torrent_finished_event(self, torrent_id):
log.debug("Handler for TorrentFinishedEvent called for CORE")
torrent = component.get("TorrentManager")[event.torrent_id]
torrent = component.get("TorrentManager")[torrent_id]
torrent_status = torrent.get_status({})
# Email
subject = _("Finished Torrent \"%(name)s\"") % torrent_status

7
deluge/plugins/scheduler/scheduler/core.py
View File

@ -76,12 +76,11 @@ class SchedulerEvent(DelugeEvent):
"""
Emitted when a schedule state changes.
"""
__slots__ = ('colour',)
def __init__(self, colour):
"""
:param colour: str, the current scheduler state
"""
self.colour = colour
self._args = [colour]
class Core(CorePluginBase):
def enable(self):
@ -120,8 +119,8 @@ class Core(CorePluginBase):
pass
def on_config_value_changed(self, event):
if event.key in CONTROLLED_SETTINGS:
def on_config_value_changed(self, key, value):
if key in CONTROLLED_SETTINGS:
self.do_schedule(False)
def __apply_set_functions(self):

4
deluge/plugins/scheduler/scheduler/gtkui.py
View File

@ -203,9 +203,9 @@ class GtkUI(GtkPluginBase):
client.scheduler.get_config().addCallback(on_get_config)
def on_scheduler_event(self, event):
def on_scheduler_event(self, state):
def on_state_deferred(s):
self.status_item.set_image_from_file(get_resource(event.colour.lower() + ".png"))
self.status_item.set_image_from_file(get_resource(state.lower() + ".png"))
self.state_deferred.addCallback(on_state_deferred)

2
deluge/ui/web/pluginmanager.py
View File

@ -77,7 +77,7 @@ class PluginManager(PluginManagerBase, component.Component):
def _on_plugin_disabled_event(self, name):
self.disable_plugin(name)
def disable_plugin(self, name):
# Get the plugin instance
try: