deluge-webapi 0.5.0__py3-none-any.whl

deluge_webapi/__init__.py

@@ -0,0 +1,28 @@
+VERSION = (0, 5, 0)
+
+
+try:
+    from deluge.plugins.init import PluginInitBase
+
+    class CorePlugin(PluginInitBase):
+        def __init__(self, plugin_name):
+            from .core import Core as _plugin_cls
+            self._plugin_cls = _plugin_cls
+            super(CorePlugin, self).__init__(plugin_name)
+
+    class Gtk3UIPlugin(PluginInitBase):
+        def __init__(self, plugin_name):
+            from .gtk3ui import Gtk3UI as _plugin_cls
+            self._plugin_cls = _plugin_cls
+            super(Gtk3UIPlugin, self).__init__(plugin_name)
+
+    class WebUIPlugin(PluginInitBase):
+        def __init__(self, plugin_name):
+            from .webui import WebUI as _plugin_cls
+            self._plugin_cls = _plugin_cls
+            super(WebUIPlugin, self).__init__(plugin_name)
+
+
+except ImportError:
+    # That's what we do when this import prevents docs from being built.
+    pass

deluge_webapi/common.py

@@ -0,0 +1,17 @@
+from importlib.resources import files
+
+from packaging import version
+
+from deluge.common import get_version
+
+DEFAULT_PREFS = {
+    "enable_cors": False,
+    "allowed_origin": [],
+}
+
+# twisted uses byte strings in deluge version 2.1.0 onward
+use_bytes = version.parse(get_version()) >= version.parse("2.1.0")
+
+
+def get_resource(filename):
+    return str(files("deluge_webapi").joinpath("data", filename))

deluge_webapi/core.py

@@ -0,0 +1,35 @@
+import logging
+
+import deluge.configmanager
+from deluge.core.rpcserver import export
+from deluge.plugins.pluginbase import CorePluginBase
+
+from .common import DEFAULT_PREFS
+
+LOGGER = logging.getLogger(__name__)
+
+
+class Core(CorePluginBase):
+
+    def enable(self):
+        LOGGER.info('Enabling WebAPI plugin CORE ...')
+
+        self.config = deluge.configmanager.ConfigManager('webapi.conf', DEFAULT_PREFS)
+
+    def disable(self):
+        LOGGER.info('Disabling WebAPI plugin CORE ...')
+
+        self.config.save()
+
+    @export
+    def set_config(self, config):
+        """sets the config dictionary"""
+
+        for key in config.keys():
+            self.config[key] = config[key]
+
+        self.config.save()
+
+    @export
+    def get_config(self):
+        return self.config.config

deluge_webapi/data/config.ui

@@ -0,0 +1,146 @@
+<?xml version="1.0"?>
+<interface>
+  <!-- interface-requires gtk+ 2.24 -->
+  <!-- interface-naming-policy toplevel-contextual -->
+  <object class="GtkWindow" id="window1">
+    <property name="can_focus">False</property>
+    <child>
+      <object class="GtkHBox" id="prefs_box">
+        <property name="visible">True</property>
+        <property name="can_focus">False</property>
+        <child>
+          <object class="GtkLayout" id="layout1">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <child>
+              <object class="GtkCheckButton" id="enable_cors">
+                <property name="label" translatable="yes">enable CORS (cross-origin request)</property>
+                <property name="width_request">247</property>
+                <property name="height_request">80</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">False</property>
+                <property name="use_action_appearance">False</property>
+                <property name="draw_indicator">True</property>
+              </object>
+              <packing>
+                <property name="x">18</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel" id="label1">
+                <property name="width_request">152</property>
+                <property name="height_request">21</property>
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="xalign">0</property>
+                <property name="yalign">0</property>
+                <property name="label" translatable="yes">Allowed domain name :</property>
+              </object>
+              <packing>
+                <property name="x">19</property>
+                <property name="y">60</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkEntry" id="new_domain">
+                <property name="width_request">153</property>
+                <property name="height_request">27</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="invisible_char">&#x25CF;</property>
+                <property name="primary_icon_activatable">False</property>
+                <property name="secondary_icon_activatable">False</property>
+                <property name="primary_icon_sensitive">True</property>
+                <property name="secondary_icon_sensitive">True</property>
+              </object>
+              <packing>
+                <property name="x">67</property>
+                <property name="y">286</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="add_button">
+                <property name="label" translatable="yes">Add</property>
+                <property name="width_request">49</property>
+                <property name="height_request">27</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_action_appearance">False</property>
+              </object>
+              <packing>
+                <property name="x">16</property>
+                <property name="y">286</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkTreeView" id="listview_allowed_domains">
+                <property name="width_request">263</property>
+                <property name="height_request">194</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+              </object>
+              <packing>
+                <property name="x">16</property>
+                <property name="y">84</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkScrolledWindow" id="scrolledwindow_allowed_domains">
+                <property name="width_request">356</property>
+                <property name="height_request">197</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="hscrollbar_policy">automatic</property>
+                <property name="vscrollbar_policy">automatic</property>
+                <child>
+                  <placeholder/>
+                </child>
+              </object>
+              <packing>
+                <property name="x">16</property>
+                <property name="y">81</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="remove_button">
+                <property name="label" translatable="yes">Remove</property>
+                <property name="width_request">69</property>
+                <property name="height_request">27</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_action_appearance">False</property>
+              </object>
+              <packing>
+                <property name="x">221</property>
+                <property name="y">286</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="remove_all_button">
+                <property name="label" translatable="yes">Remove all</property>
+                <property name="width_request">82</property>
+                <property name="height_request">27</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_action_appearance">False</property>
+              </object>
+              <packing>
+                <property name="x">290</property>
+                <property name="y">286</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>

deluge_webapi/data/webapi.js

@@ -0,0 +1,198 @@
+
+WebApiPanel = Ext.extend(Ext.form.FormPanel, {
+
+
+    constructor: function(config) {
+
+        config = Ext.apply({
+            title: _('WebAPI'),
+            border: false,
+            labelWidth: 10,
+            autoHeight: true
+        }, config);
+
+        WebApiPanel.superclass.constructor.call(this, config);
+    },
+    initComponent: function() {
+        WebApiPanel.superclass.initComponent.call(this);
+        this.opts = new Deluge.OptionsManager();
+
+        var fieldset = this.add({
+            xtype: 'fieldset',
+            title: _('WebAPI Settings'),
+            defaultType: 'checkbox',
+            autoHeight: true
+        });
+
+        this.opts.bind('enable_cors', fieldset.add({
+            name: 'enable_cors',
+            id: 'enable_cors',
+            height: 22,
+            fieldLabel: '',
+            labelSeparator: '',
+            boxLabel: _('Enable CORS (cross-origin request)')
+        }));
+
+        this.list = this.add({
+            xtype: 'listview',
+            height: 150,
+            store: new Ext.data.ArrayStore({
+                fields: [
+                    { name: 'domain', mapping: 0 }
+                ]
+            }),
+            columns: [{
+                id: 'domain',
+                header: _('Allowed domain'),
+                width: 1,
+                sortable: true,
+                dataIndex: 'domain'
+            }],
+            singleSelect: true,
+            autoExpandColumn: 'domain',
+            listeners: {
+                selectionchange: { fn: this.onDomainSelect, scope: this }
+            }
+        });
+
+        this.panel = this.add({
+            region: 'center',
+            autoScroll: true,
+            items: [this.list]
+        });
+
+        this.domain_name = this.opts.bind('domain_name', fieldset.add({
+            fieldLabel: '',
+            xtype: 'textfield',
+            anchor: '50%',
+            name: 'domain_name',
+            id: 'domain_name',
+            autoWidth: true,
+            value: ''
+        }));
+
+        this.toolbar = this.add({
+            fieldLabel: _(''),
+            name: 'list_toolbar',
+            xtype: 'container',
+            layout: 'hbox',
+            items: [
+                {
+                    xtype: 'button',
+                    text: 'Add'
+                },
+                this.domain_name,
+                {
+                    xtype: 'button',
+                    text: 'Remove'
+                },
+                {
+                    xtype: 'button',
+                    text: 'Remove all'
+                }
+            ]
+        });
+
+        this.toolbar.getComponent(0).setHandler(this.addDomain, this);
+        this.toolbar.getComponent(2).setHandler(this.removeDomain, this);
+        this.toolbar.getComponent(3).setHandler(this.removeAllDomain, this);
+
+        deluge.preferences.on('show', this.onPreferencesShow, this);
+    },
+
+    removeDomain: function() {
+        if (!this.selectedDomain) return;
+        var index = this.list.getStore().find('domain', this.selectedDomain);
+        if (index == -1) return;
+        this.list.getStore().removeAt(index);
+        index = this.allowedDomains.indexOf(this.selectedDomain);
+        if (index !== -1) this.allowedDomains.splice(index, 1);
+        this.selectedDomain = false;
+    },
+
+    removeAllDomain: function() {
+        this.list.getStore().removeAll();
+        this.allowedDomains = [];
+        this.selectedDomain = false;
+    },
+
+    onDomainSelect: function (dv, selections) {
+        if (selections.length === 0) return;
+        var r = dv.getRecords(selections)[0];
+        this.selectedDomain = r.get('domain');
+    },
+
+    addDomain: function() {
+        var changed = this.opts.getDirty();
+        if (!Ext.isObjectEmpty(changed)) {
+            if (!Ext.isEmpty(changed['domain_name'])) {
+                changed['domain_name'] = changed['domain_name'];
+                this.allowedDomains.push(changed['domain_name']);
+                this.updateDomainsGrid();
+            }
+        }
+    },
+
+    updateDomainsGrid: function () {
+        var Domains = [];
+        Ext.each(this.allowedDomains, function (domain) {
+                Domains.push([domain]);
+        }, this);
+        this.list.getStore().loadData(Domains);
+    },
+
+    onPreferencesShow: function () {
+        deluge.client.webapi.get_config({
+            success: function (config) {
+                if (!Ext.isEmpty(config['enable_cors'])) {
+                    config['enable_cors'] = config['enable_cors'];
+                }
+                if (!Ext.isEmpty(config['allowed_origin'])) {
+                    config['allowed_origin'] = config['allowed_origin'];
+                }
+                this.allowedDomains = config['allowed_origin'];
+                this.updateDomainsGrid();
+                this.opts.set(config);
+            },
+            scope: this
+        });
+    },
+
+    onApply: function(e) {
+        var changed = this.opts.getDirty();
+        if (!Ext.isObjectEmpty(changed)) {
+            if (!Ext.isEmpty(changed['enable_cors'])) {
+                changed['enable_cors'] = changed['enable_cors'];
+            }
+            deluge.client.webapi.set_config(changed, {
+                success: this.onSetConfig,
+                scope: this
+            });
+        }
+        var config = {};
+        config['allowed_origin'] = this.allowedDomains;
+        console.log(config);
+        deluge.client.webapi.set_config(config);
+    },
+
+    onSetConfig: function() {
+        this.opts.commit();
+    }
+
+});
+
+
+WebApiPlugin = Ext.extend(Deluge.Plugin, {
+
+    name: 'WebAPI',
+
+    onDisable: function() {
+        deluge.preferences.removePage(this.prefsPage);
+    },
+
+    onEnable: function() {
+        this.prefsPage = deluge.preferences.addPage(new WebApiPanel());
+    }
+});
+
+Deluge.registerPlugin('WebAPI', WebApiPlugin);

deluge_webapi/gtk3ui.py

@@ -0,0 +1,99 @@
+import logging
+
+from gi.repository import Gtk
+from deluge import component
+from deluge.plugins.pluginbase import Gtk3PluginBase
+from deluge.ui.client import client
+
+from .common import get_resource
+
+LOGGER = logging.getLogger(__name__)
+
+
+class Gtk3UI(Gtk3PluginBase):
+
+    plugin_id = 'WebAPI'
+
+    def enable(self):
+        """Triggers when plugin is enabled."""
+        LOGGER.info('Enabling WebAPI plugin GTK ...')
+
+        self.builder = Gtk.Builder.new_from_file(get_resource("config.ui"))
+
+        component.get('Preferences').add_page('WebAPI', self.builder.get_object('prefs_box'))
+        component.get('PluginManager').register_hook('on_apply_prefs', self.on_apply_prefs)
+        component.get('PluginManager').register_hook('on_show_prefs', self.on_show_prefs)
+
+        self.builder.get_object('add_button').connect('clicked', self.add_domain)
+        self.builder.get_object('remove_button').connect('clicked', self.remove_domain)
+        self.builder.get_object('remove_all_button').connect('clicked', self.remove_all_domain)
+        self.create_listview()
+
+    def disable(self):
+        """Triggers when plugin is disabled."""
+        LOGGER.info('Disabling WebAPI plugin GTK ...')
+
+        component.get('Preferences').remove_page('WebAPI')
+        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 on_apply_prefs(self):
+        """Triggers when plugin prefs are apply."""
+        config = {}
+        if self.builder.get_object('enable_cors').get_active():
+            config['enable_cors'] = True
+        else:
+            config['enable_cors'] = False
+
+        config['allowed_origin'] = []
+        for i, value in enumerate(self.model):
+            item = self.model.get_iter(i)
+            config['allowed_origin'].append(self.model[item][0])
+
+        client.webapi.set_config(config)
+
+    def on_show_prefs(self):
+        """Triggers when plugin prefs are show."""
+        client.webapi.get_config().addCallback(self.cb_get_config)
+
+    def cb_get_config(self, config):
+        """callback for on show_prefs"""
+        self.builder.get_object('enable_cors').set_active(config['enable_cors'])
+        self.remove_all_domain()
+        for domain in config['allowed_origin']:
+            self.model.append([domain])
+
+    def create_listview(self):
+        self.model = Gtk.ListStore(str)
+        self.list = self.builder.get_object('listview_allowed_domains')
+        self.list.set_model(self.model)
+
+        parent = self.list.get_parent()
+        parent.remove(self.list)
+        self.scrollTree = self.builder.get_object('scrolledwindow_allowed_domains')
+        self.scrollTree.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+        self.scrollTree.add(self.list)
+
+        column = Gtk.TreeViewColumn('domain', Gtk.CellRendererText(), text=0)
+        column.set_clickable(True)
+        column.set_resizable(True)
+        self.list.append_column(column)
+
+        self.selection = self.list.get_selection()
+
+    def add_domain(self, button):
+        domain = self.builder.get_object('new_domain').get_text()
+        self.model.append([domain])
+
+    def remove_domain(self, button):
+        # if there is still an entry in the model
+        if len(self.model) != 0:
+            # get the selection
+            (model, item) = self.selection.get_selected()
+            if item is not None:
+                self.model.remove(item)
+
+    def remove_all_domain(self, button=None):
+        for i, value in enumerate(self.model):
+            item = self.model.get_iter(0)
+            self.model.remove(item)

deluge_webapi/test.py

@@ -0,0 +1,48 @@
+import requests
+from os import environ
+
+PASSWORD = environ.get('WEBAPI_PASSWORD', '*****')
+COOKIES = None
+REQUEST_ID = 0
+
+
+def send_request(method, params=None):
+    global REQUEST_ID
+    global COOKIES
+    REQUEST_ID += 1
+
+    try:
+
+        response = requests.post(
+            'http://localhost:8112/json',
+            json={'id': REQUEST_ID, 'method': method, 'params': params or []},
+            cookies=COOKIES)
+
+    except requests.exceptions.ConnectionError:
+        raise Exception('WebUI seems to be unavailable. Run deluge-web or enable WebUI plugin using other thin client.')
+
+    data = response.json()
+
+    error = data.get('error')
+
+    if error:
+        msg = error['message']
+
+        if msg == 'Unknown method':
+            msg += '. Check WebAPI is enabled.'
+
+        raise Exception('API response: %s' % msg)
+
+    COOKIES = response.cookies
+
+    return data['result']
+
+
+assert send_request('auth.login', [PASSWORD]), 'Unable to log in. Check password.'
+
+version_number = send_request('webapi.get_api_version')
+assert version_number
+
+print('WebAPI version: %s' % version_number)
+
+print('Success')

deluge_webapi/webui.py

@@ -0,0 +1,176 @@
+import logging
+
+import deluge.configmanager
+from deluge import component, common
+from deluge.plugins.pluginbase import WebPluginBase
+from deluge.ui.client import client
+from deluge.ui.web.json_api import export as export_api
+from twisted.internet.defer import Deferred
+from twisted.web import http, server
+
+from .common import DEFAULT_PREFS, get_resource, use_bytes
+
+LOGGER = logging.getLogger(__name__)
+
+
+class WebUI(WebPluginBase):
+
+    scripts = [get_resource('webapi.js')]
+
+    def enable(self):
+        """Triggers when plugin is enabled."""
+        LOGGER.info('Enabling WebAPI plugin WEB ...')
+
+        self.patched = False
+        self.config = deluge.configmanager.ConfigManager('webapi.conf', DEFAULT_PREFS)
+
+        if self.config['enable_cors']:
+            self.patch_web_ui()
+
+    def disable(self):
+        """Triggers when plugin is disabled."""
+        LOGGER.info('Disabling WebAPI plugin WEB ...')
+
+        self.unpatch_web_ui()
+
+    def patch_web_ui(self):
+        """Applies CORS headers patching to the WebUI JSON component."""
+
+        if self.patched:
+            return
+
+        LOGGER.info('Patching webui for CORS ...')
+
+        try:
+            cmp_json = component.get('JSON')
+
+        except KeyError:
+            LOGGER.warning('The JSON component is not available in this process. CORS patching is skipped.')
+            return
+
+        self.old_render = cmp_json.render
+        self.old_send_request = cmp_json._send_response
+        cmp_json.render = self.render_patch
+        cmp_json._send_response = self._send_response_patch
+
+        self.patched = True
+
+    def unpatch_web_ui(self):
+        """Reverts CORS headers patching of the WebUI JSON component."""
+
+        if not self.patched:
+            return
+
+        LOGGER.info('Unpatching webui for CORS ...')
+
+        cmp_json = component.get('JSON')
+        cmp_json.render = self.old_render
+        cmp_json._send_response = self.old_send_request
+
+        self.patched = False
+
+    def render_patch(self, request):
+
+        if request.method != (b'OPTIONS' if use_bytes else 'OPTIONS'):
+            return self.old_render(request)
+
+        request.setResponseCode(http.OK)
+        origin = request.getHeader('Origin')
+
+        if origin in self.config['allowed_origin']:
+            request.setHeader('Access-Control-Allow-Origin', origin)
+            request.setHeader('Access-Control-Allow-Headers', 'content-type')
+            request.setHeader('Access-Control-Allow-Methods', 'POST')
+            request.setHeader('Access-Control-Allow-Credentials', 'true')
+
+        request.write(b'' if use_bytes else '')
+        request.finish()
+        return server.NOT_DONE_YET
+
+    def _send_response_patch(self, request, response):
+
+        if request._disconnected:
+            return ''
+
+        origin = request.getHeader('Origin')
+
+        if origin in self.config['allowed_origin']:
+            request.setHeader('Access-Control-Allow-Origin', origin)
+            request.setHeader('Access-Control-Allow-Credentials', 'true')
+
+        return self.old_send_request(request, response)
+
+    @export_api
+    def get_torrents(self, ids=None, params=None):
+        """Returns information about all or a definite torrent.
+        Returned information can be filtered by supplying wanted parameter names.
+
+        """
+
+        if params is None:
+            filter_fields = ['name', 'comment', 'hash', 'save_path']
+        else:
+            if isinstance(params, list):
+                filter_fields = params
+            else:
+                filter_fields = params.replace(" ","").split(",")
+
+        proxy = component.get('SessionProxy')
+
+        filter_dict = {}
+        if ids is not None:
+            filter_dict['id'] = set(ids).intersection(set(proxy.torrents.keys()))
+
+        document = {
+            'torrents': []
+        }
+        response = Deferred()
+
+        deffered_torrents = proxy.get_torrents_status(filter_dict, filter_fields)
+
+        def on_complete(torrents_dict):
+            document['torrents'] = list(torrents_dict.values())
+            response.callback(document)
+        deffered_torrents.addCallback(on_complete)
+
+        return response
+
+    @export_api
+    def add_torrent(self, metainfo, options=None):
+        """Adds a torrent with the given options.
+        metainfo could either be base64 torrent data or a magnet link.
+
+        Returns `torrent_id` string or None.
+
+        Available options are listed in deluge.core.torrent.TorrentOptions.
+
+        :rtype: None|str
+        """
+        if options is None:
+            options = {}
+
+        coreconfig = component.get('CoreConfig')
+
+        if 'download_location' not in options.keys():
+            options.update({'download_location': coreconfig.get("download_location")})
+
+        if common.is_magnet(metainfo):
+            LOGGER.info('Adding torrent from magnet URI `%s` using options `%s` ...', metainfo, options)
+            result = client.core.add_torrent_magnet(metainfo, options)
+
+        else:
+            LOGGER.info('Adding torrent from base64 string using options `%s` ...', options)
+            result = client.core.add_torrent_file(None, metainfo, options)
+
+        return result
+
+    @export_api
+    def remove_torrent(self, torrent_id, remove_data=False):
+        """Removes a given torrent. Optionally can remove data."""
+        return client.core.remove_torrent(torrent_id, remove_data)
+
+    @export_api
+    def get_api_version(self):
+        """Returns WebAPI plugin version."""
+        from . import VERSION
+        return '.'.join(map(str, VERSION))

deluge_webapi-0.5.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: deluge-webapi
+Version: 0.5.0
+Summary: Plugin for Deluge WebUI providing sane JSON API.
+Author-email: Igor `idle sign` Starikov <idlesign@yandex.ru>
+License: BSD 3-Clause License
+Project-URL: Homepage, https://github.com/idlesign/deluge-webapi
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Environment :: Plugins
+Classifier: Intended Audience :: End Users/Desktop
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: AUTHORS
+Dynamic: license-file
+
+deluge-webapi
+=============
+https://github.com/idlesign/deluge-webapi
+
+
+.. image:: https://img.shields.io/pypi/v/deluge-webapi.svg
+    :target: https://pypi.python.org/pypi/deluge-webapi
+
+
+Description
+-----------
+
+*Plugin for Deluge WebUI providing sane JSON API.*
+
+Exposes some sane JSON API through Deluge WebUI (missing out of the box or restyled) so that you can manipulate
+Deluge from your programs using HTTP requests.
+
+Supported methods:
+
+* ``get_torrents``
+* ``add_torrent`` (magnet or file)
+* ``remove_torrent``
+* ``get_api_version``
+
+Deluge is a lightweight, Free Software, cross-platform BitTorrent client. Download it at http://deluge-torrent.org/
+
+.. note:: Use egg version 0.4.0 or higher for Deluge 2
+.. note:: Use egg version 0.3.2 or lower for Deluge 1.x
+
+
+Installation
+------------
+
+1. Get plugin egg file, from ``dist/`` (https://github.com/idlesign/deluge-webapi/tree/master/dist) directory.
+
+2. Open Deluge Web UI, go to "Preferences -> Plugins -> Install plugin" and choose egg file.
+
+3. Activate ``WebAPI`` plugin.
+
+4. In case you use Client-Server setup, you'll need to install the plugin both on client and server, see - https://dev.deluge-torrent.org/wiki/Plugins#Client-ServerSetups
+
+
+.. note::
+
+    To build .egg file from source code yourself use ``python setup.py bdist_egg`` command in source code directory.
+
+
+Documentation
+-------------
+
+http://deluge-webapi.readthedocs.org/

deluge_webapi-0.5.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+deluge_webapi/__init__.py,sha256=6Cvdwf2wHE8jmKeamI2MV25JtD6uaQebpAqxpGZIND4,887
+deluge_webapi/common.py,sha256=oCh7t6hw6mHDOxnOiVreRhAkxCF4JPV-OvTDf7O0Idk,404
+deluge_webapi/core.py,sha256=b2M_2usudeYbVB5mCJEvklvKCT9HpNyjHw3gskcZ-bk,782
+deluge_webapi/gtk3ui.py,sha256=8rw9X0VyN0VDLyIlpwX-t9-BSrqDEE0huNvEJfwA2a0,3669
+deluge_webapi/test.py,sha256=wRGstZUF9xZMlVUzrAFwVZSHFaU7-1N5ChJY0RdpKHQ,1116
+deluge_webapi/webui.py,sha256=UKafC3J5D0jNSEUYG9IaU8BiR8boX-qpj7NAiwMLujE,5548
+deluge_webapi/data/config.ui,sha256=E9iEGGm5ro6hAu5Mux_7_jKaNe3Xel7gMbc65CDUNqo,6660
+deluge_webapi/data/webapi.js,sha256=dC6N9pYLo95CWsnXrSg7D9OvKzTmB7P6PA_FWzfPvog,5803
+deluge_webapi-0.5.0.dist-info/licenses/AUTHORS,sha256=No-8N3pBL_yFSDBESx1LD4PK31d1pgNmF0vScpQaU2c,340
+deluge_webapi-0.5.0.dist-info/licenses/LICENSE,sha256=LevsUhQhcqhuI9hWa6WD6IUknGIGVpyaXb_HdpHCNEE,1504
+deluge_webapi-0.5.0.dist-info/METADATA,sha256=2hNOPIq2dUtpxaVsQ3VM_zm4ro4qkaJRYzTR_fyGICw,2126
+deluge_webapi-0.5.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+deluge_webapi-0.5.0.dist-info/entry_points.txt,sha256=BMX6LLx1C2hQm9Sb10Url1p5zJuOBdoBkcTIhwIFSf0,171
+deluge_webapi-0.5.0.dist-info/top_level.txt,sha256=ci4wChOllyVj1-BYYxvrdExM0wQjWtM9s8u16neoekg,14
+deluge_webapi-0.5.0.dist-info/RECORD,,

deluge_webapi-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

deluge_webapi-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,8 @@
+[deluge.plugin.core]
+WebAPI = deluge_webapi:CorePlugin
+
+[deluge.plugin.gtk3ui]
+WebAPI = deluge_webapi:Gtk3UIPlugin
+
+[deluge.plugin.web]
+WebAPI = deluge_webapi:WebUIPlugin

deluge_webapi-0.5.0.dist-info/licenses/AUTHORS

@@ -0,0 +1,14 @@
+deluge-webapi authors
+=====================
+
+Created by Igor `idle sign` Starikov.
+
+
+Contributors
+------------
+
+theonedemon <https://github.com/theonedemon>
+Daniel Marcos <https://github.com/dmarcosl>
+Brandon Gillis <https://github.com/BrandonGillis>
+Ivan Filippov <https://github.com/ivanfilippov>
+griest024 <https://github.com/griest024>

deluge_webapi-0.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2014-2019 Igor `idle sign` Starikov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the deluge-webapi nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

deluge_webapi-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+deluge_webapi