moved everything from module to pyload

11 files changed, 0 insertions, 947 deletions

diff --git a/module/api/AccountApi.py b/module/api/AccountApi.py
deleted file mode 100644
index 981842b5c..000000000
--- a/module/api/AccountApi.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from module.Api import Api, RequirePerm, Permission
-
-from ApiComponent import ApiComponent
-
-
-class AccountApi(ApiComponent):
-    """ All methods to control accounts """
-
-    @RequirePerm(Permission.Accounts)
-    def getAccounts(self, refresh):
-        """Get information about all entered accounts.
-
-        :param refresh: reload account info
-        :return: list of `AccountInfo`
-        """
-        accs = self.core.accountManager.getAllAccounts(refresh)
-        accounts = []
-        for plugin in accs.itervalues():
-            accounts.extend([acc.toInfoData() for acc in plugin.values()])
-
-        return accounts
-
-    @RequirePerm(Permission.All)
-    def getAccountTypes(self):
-        """All available account types.
-
-        :return: string list
-        """
-        return self.core.pluginManager.getPlugins("accounts").keys()
-
-    @RequirePerm(Permission.Accounts)
-    def updateAccount(self, plugin, login, password):
-        """Changes pw/options for specific account."""
-        # TODO: options
-        self.core.accountManager.updateAccount(plugin, login, password, {})
-
-    def updateAccountInfo(self, account):
-        """ Update account from :class:`AccountInfo` """
-        #TODO
-
-    @RequirePerm(Permission.Accounts)
-    def removeAccount(self, account):
-        """Remove account from pyload.
-
-        :param account: :class:`ÀccountInfo` instance
-        """
-        self.core.accountManager.removeAccount(account.plugin, account.loginname)
-
-
-if Api.extend(AccountApi):
-    del AccountApi
\ No newline at end of file
diff --git a/module/api/AddonApi.py b/module/api/AddonApi.py
deleted file mode 100644
index 917c7dc4c..000000000
--- a/module/api/AddonApi.py
+++ /dev/null
@@ -1,27 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from module.Api import Api, RequirePerm, Permission
-
-from ApiComponent import ApiComponent
-
-class AddonApi(ApiComponent):
-    """ Methods to interact with addons """
-
-    def getAllInfo(self):
-        """Returns all information stored by addon plugins. Values are always strings
-
-        :return: {"plugin": {"name": value } }
-        """
-        return self.core.addonManager.getAllInfo()
-
-    def getInfoByPlugin(self, plugin):
-        """Returns information stored by a specific plugin.
-
-        :param plugin: pluginname
-        :return: dict of attr names mapped to value {"name": value}
-        """
-        return self.core.addonManager.getInfo(plugin)
-
-if Api.extend(AddonApi):
-    del AddonApi
\ No newline at end of file
diff --git a/module/api/ApiComponent.py b/module/api/ApiComponent.py
deleted file mode 100644
index 3948086c2..000000000
--- a/module/api/ApiComponent.py
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from module.remote.apitypes import Iface
-
-# Workaround to let code-completion think, this is subclass of Iface
-Iface = object
-class ApiComponent(Iface):
-
-    __slots__ = []
-
-    def __init__(self, core, user):
-        # Only for auto completion, this class can not be instantiated
-        from pyload import Core
-        from module.datatypes.User import User
-        assert isinstance(core, Core)
-        assert issubclass(ApiComponent, Iface)
-        self.core = core
-        assert isinstance(user, User)
-        self.user = user
-        self.primaryUID = 0
-        # No instantiating!
-        raise Exception()
\ No newline at end of file
diff --git a/module/api/CollectorApi.py b/module/api/CollectorApi.py
deleted file mode 100644
index eb36f7a21..000000000
--- a/module/api/CollectorApi.py
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from module.Api import Api, RequirePerm, Permission
-
-from ApiComponent import ApiComponent
-
-class CollectorApi(ApiComponent):
-    """ Link collector """
-
-    @RequirePerm(Permission.All)
-    def getCollector(self):
-        pass
-
-    @RequirePerm(Permission.Add)
-    def addToCollector(self, links):
-        pass
-
-    @RequirePerm(Permission.Add)
-    def addFromCollector(self, name, new_name):
-        pass
-
-    @RequirePerm(Permission.Delete)
-    def deleteCollPack(self, name):
-        pass
-
-    @RequirePerm(Permission.Add)
-    def renameCollPack(self, name, new_name):
-        pass
-
-    @RequirePerm(Permission.Delete)
-    def deleteCollLink(self, url):
-        pass
-
-
-if Api.extend(CollectorApi):
-    del CollectorApi
\ No newline at end of file
diff --git a/module/api/ConfigApi.py b/module/api/ConfigApi.py
deleted file mode 100644
index 527f494ce..000000000
--- a/module/api/ConfigApi.py
+++ /dev/null
@@ -1,134 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from module.Api import Api, RequirePerm, Permission, ConfigHolder, ConfigItem, ConfigInfo
-from module.utils import to_string
-
-from ApiComponent import ApiComponent
-
-# helper function to create a ConfigHolder
-def toConfigHolder(section, config, values):
-    holder = ConfigHolder(section, config.name, config.description, config.long_desc)
-    holder.items = [ConfigItem(option, x.name, x.description, x.type, to_string(x.default),
-                               to_string(values.get(option, x.default))) for option, x in
-                    config.config.iteritems()]
-    return holder
-
-
-class ConfigApi(ApiComponent):
-    """ Everything related to configuration """
-
-    def getConfigValue(self, section, option):
-        """Retrieve config value.
-
-        :param section: name of category, or plugin
-        :param option: config option
-        :rtype: str
-        :return: config value as string
-        """
-        value = self.core.config.get(section, option, self.primaryUID)
-        return to_string(value)
-
-    def setConfigValue(self, section, option, value):
-        """Set new config value.
-
-        :param section:
-        :param option:
-        :param value: new config value
-        """
-        if option in ("limit_speed", "max_speed"): #not so nice to update the limit
-            self.core.requestFactory.updateBucket()
-
-        self.core.config.set(section, option, value, self.primaryUID)
-
-    def getConfig(self):
-        """Retrieves complete config of core.
-
-        :rtype: dict of section -> ConfigHolder
-        """
-        data = {}
-        for section, config, values in self.core.config.iterCoreSections():
-            data[section] = toConfigHolder(section, config, values)
-        return data
-
-    def getCoreConfig(self):
-        """ Retrieves core config sections
-
-        :rtype: list of PluginInfo
-        """
-        return [ConfigInfo(section, config.name, config.description, False, False)
-                for section, config, values in self.core.config.iterCoreSections()]
-
-    @RequirePerm(Permission.Plugins)
-    def getPluginConfig(self):
-        """All plugins and addons the current user has configured
-
-        :rtype: list of PluginInfo
-        """
-        # TODO: include addons that are activated by default
-        # TODO: multi user
-        # TODO: better plugin / addon activated config
-        data = []
-        active = [x.getName() for x in self.core.addonManager.activePlugins()]
-        for name, config, values in self.core.config.iterSections(self.primaryUID):
-            # skip unmodified and inactive addons
-            if not values and name not in active: continue
-
-            item = ConfigInfo(name, config.name, config.description,
-                              self.core.pluginManager.getCategory(name),
-                              self.core.pluginManager.isUserPlugin(name),
-                              values.get("activated", None if "activated" not in config.config else config.config[
-                                  "activated"].default))
-            data.append(item)
-
-        return data
-
-    @RequirePerm(Permission.Plugins)
-    def getAvailablePlugins(self):
-        """List of all available plugins, that are configurable
-
-        :rtype: list of PluginInfo
-        """
-        # TODO: filter user_context / addons when not allowed
-        plugins = [ConfigInfo(name, config.name, config.description,
-                              self.core.pluginManager.getCategory(name),
-                              self.core.pluginManager.isUserPlugin(name))
-                   for name, config, values in self.core.config.iterSections(self.primaryUID)]
-
-        return plugins
-
-    @RequirePerm(Permission.Plugins)
-    def loadConfig(self, name):
-        """Get complete config options for desired section
-
-        :param name: Name of plugin or config section
-        :rtype: ConfigHolder
-        """
-        # requires at least plugin permissions, but only admin can load core config
-        config, values = self.core.config.getSection(name, self.primaryUID)
-        return toConfigHolder(name, config, values)
-
-
-    @RequirePerm(Permission.Plugins)
-    def saveConfig(self, config):
-        """Used to save a configuration, core config can only be saved by admins
-
-        :param config: :class:`ConfigHolder`
-        """
-        for item in config.items:
-            self.core.config.set(config.name, item.name, item.value, sync=False, user=self.primaryUID)
-            # save the changes
-        self.core.config.saveValues(self.primaryUID, config.name)
-
-    @RequirePerm(Permission.Plugins)
-    def deleteConfig(self, plugin):
-        """Deletes modified config
-
-        :param plugin: plugin name
-        """
-        #TODO: delete should deactivate addons?
-        self.core.config.delete(plugin, self.primaryUID)
-
-
-if Api.extend(ConfigApi):
-    del ConfigApi
\ No newline at end of file
diff --git a/module/api/CoreApi.py b/module/api/CoreApi.py
deleted file mode 100644
index e5c5e8b41..000000000
--- a/module/api/CoreApi.py
+++ /dev/null
@@ -1,131 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from module.Api import Api, RequirePerm, Permission, ServerStatus, Interaction
-from module.utils.fs import join, free_space
-from module.utils import compare_time
-
-from ApiComponent import ApiComponent
-
-class CoreApi(ApiComponent):
-    """ This module provides methods for general interaction with the core, like status or progress retrieval  """
-
-    @RequirePerm(Permission.All)
-    def getServerVersion(self):
-        """pyLoad Core version """
-        return self.core.version
-
-    @RequirePerm(Permission.All)
-    def getWSAddress(self):
-        """Gets and address for the websocket based on configuration"""
-        # TODO SSL (wss)
-        return "ws://%%s:%d" % self.core.config['remote']['port']
-
-    @RequirePerm(Permission.All)
-    def getServerStatus(self):
-        """Some general information about the current status of pyLoad.
-
-        :return: `ServerStatus`
-        """
-        queue = self.core.files.getQueueStats(self.primaryUID)
-        total = self.core.files.getDownloadStats(self.primaryUID)
-
-        serverStatus = ServerStatus(0,
-                                    total[0], queue[0],
-                                    total[1], queue[1],
-                                    self.isInteractionWaiting(Interaction.All),
-                                    not self.core.threadManager.pause and self.isTimeDownload(),
-                                    self.core.threadManager.pause,
-                                    self.core.config['reconnect']['activated'] and self.isTimeReconnect())
-
-
-        for pyfile in self.core.threadManager.getActiveDownloads(self.primaryUID):
-            serverStatus.speed += pyfile.getSpeed() #bytes/s
-
-        return serverStatus
-
-    @RequirePerm(Permission.All)
-    def getProgressInfo(self):
-        """ Status of all currently running tasks
-
-        :rtype: list of :class:`ProgressInfo`
-        """
-        return self.core.threadManager.getProgressList(self.primaryUID)
-
-    def pauseServer(self):
-        """Pause server: It won't start any new downloads, but nothing gets aborted."""
-        self.core.threadManager.pause = True
-
-    def unpauseServer(self):
-        """Unpause server: New Downloads will be started."""
-        self.core.threadManager.pause = False
-
-    def togglePause(self):
-        """Toggle pause state.
-
-        :return: new pause state
-        """
-        self.core.threadManager.pause ^= True
-        return self.core.threadManager.pause
-
-    def toggleReconnect(self):
-        """Toggle reconnect activation.
-
-        :return: new reconnect state
-        """
-        self.core.config["reconnect"]["activated"] ^= True
-        return self.core.config["reconnect"]["activated"]
-
-    def freeSpace(self):
-        """Available free space at download directory in bytes"""
-        return free_space(self.core.config["general"]["download_folder"])
-
-
-    def quit(self):
-        """Clean way to quit pyLoad"""
-        self.core.do_kill = True
-
-    def restart(self):
-        """Restart pyload core"""
-        self.core.do_restart = True
-
-    def getLog(self, offset=0):
-        """Returns most recent log entries.
-
-        :param offset: line offset
-        :return: List of log entries
-        """
-        filename = join(self.core.config['log']['log_folder'], 'log.txt')
-        try:
-            fh = open(filename, "r")
-            lines = fh.readlines()
-            fh.close()
-            if offset >= len(lines):
-                return []
-            return lines[offset:]
-        except:
-            return ['No log available']
-
-    @RequirePerm(Permission.All)
-    def isTimeDownload(self):
-        """Checks if pyload will start new downloads according to time in config.
-
-        :return: bool
-        """
-        start = self.core.config['downloadTime']['start'].split(":")
-        end = self.core.config['downloadTime']['end'].split(":")
-        return compare_time(start, end)
-
-    @RequirePerm(Permission.All)
-    def isTimeReconnect(self):
-        """Checks if pyload will try to make a reconnect
-
-        :return: bool
-        """
-        start = self.core.config['reconnect']['startTime'].split(":")
-        end = self.core.config['reconnect']['endTime'].split(":")
-        return compare_time(start, end) and self.core.config["reconnect"]["activated"]
-
-
-if Api.extend(CoreApi):
-    del CoreApi
\ No newline at end of file
diff --git a/module/api/DownloadApi.py b/module/api/DownloadApi.py
deleted file mode 100644
index ba49435b3..000000000
--- a/module/api/DownloadApi.py
+++ /dev/null
@@ -1,182 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from os.path import isabs
-
-from module.Api import Api, RequirePerm, Permission
-from module.utils.fs import join
-
-from ApiComponent import ApiComponent
-
-class DownloadApi(ApiComponent):
-    """ Component to create, add, delete or modify downloads."""
-
-    @RequirePerm(Permission.Add)
-    def generateAndAddPackages(self, links, paused=False):
-        """Generates and add packages
-
-        :param links: list of urls
-        :param paused: paused package
-        :return: list of package ids
-        """
-        return [self.addPackageP(name, urls, "", paused) for name, urls
-                in self.generatePackages(links).iteritems()]
-
-    @RequirePerm(Permission.Add)
-    def createPackage(self, name, folder, root, password="", site="", comment="", paused=False):
-        """Create a new package.
-
-        :param name: display name of the package
-        :param folder: folder name or relative path, abs path are not allowed
-        :param root: package id of root package, -1 for top level package
-        :param password: single pw or list of passwords separated with new line
-        :param site: arbitrary url to site for more information
-        :param comment: arbitrary comment
-        :param paused: No downloads will be started when True
-        :return: pid of newly created package
-        """
-
-        if isabs(folder):
-            folder = folder.replace("/", "_")
-
-        folder = folder.replace("http://", "").replace(":", "").replace("\\", "_").replace("..", "")
-
-        self.core.log.info(_("Added package %(name)s as folder %(folder)s") % {"name": name, "folder": folder})
-        pid = self.core.files.addPackage(name, folder, root, password, site, comment, paused)
-
-        return pid
-
-
-    @RequirePerm(Permission.Add)
-    def addPackage(self, name, links, password=""):
-        """Convenient method to add a package to the top-level and for adding links.
-
-        :return: package id
-        """
-        return self.addPackageChild(name, links, password, -1, False)
-
-    @RequirePerm(Permission.Add)
-    def addPackageP(self, name, links, password, paused):
-        """ Same as above with additional paused attribute. """
-        return self.addPackageChild(name, links, password, -1, paused)
-
-    @RequirePerm(Permission.Add)
-    def addPackageChild(self, name, links, password, root, paused):
-        """Adds a package, with links to desired package.
-
-        :param root: parents package id
-        :return: package id of the new package
-        """
-        if self.core.config['general']['folder_per_package']:
-            folder = name
-        else:
-            folder = ""
-
-        pid = self.createPackage(name, folder, root, password)
-        self.addLinks(pid, links)
-
-        return pid
-
-    @RequirePerm(Permission.Add)
-    def addLinks(self, pid, links):
-        """Adds links to specific package. Initiates online status fetching.
-
-        :param pid: package id
-        :param links: list of urls
-        """
-        hoster, crypter = self.core.pluginManager.parseUrls(links)
-
-        if hoster:
-            self.core.files.addLinks(hoster, pid)
-            self.core.threadManager.createInfoThread(hoster, pid)
-
-        self.core.threadManager.createDecryptThread(crypter, pid)
-
-        self.core.log.info((_("Added %d links to package") + " #%d" % pid) % len(hoster))
-        self.core.files.save()
-
-    @RequirePerm(Permission.Add)
-    def uploadContainer(self, filename, data):
-        """Uploads and adds a container file to pyLoad.
-
-        :param filename: filename, extension is important so it can correctly decrypted
-        :param data: file content
-        """
-        th = open(join(self.core.config["general"]["download_folder"], "tmp_" + filename), "wb")
-        th.write(str(data))
-        th.close()
-
-        return self.addPackage(th.name, [th.name])
-
-    @RequirePerm(Permission.Delete)
-    def deleteFiles(self, fids):
-        """Deletes several file entries from pyload.
-
-        :param fids: list of file ids
-        """
-        for fid in fids:
-            self.core.files.deleteFile(fid)
-
-        self.core.files.save()
-
-    @RequirePerm(Permission.Delete)
-    def deletePackages(self, pids):
-        """Deletes packages and containing links.
-
-        :param pids: list of package ids
-        """
-        for pid in pids:
-            self.core.files.deletePackage(pid)
-
-        self.core.files.save()
-
-
-    @RequirePerm(Permission.Modify)
-    def restartPackage(self, pid):
-        """Restarts a package, resets every containing files.
-
-        :param pid: package id
-        """
-        self.core.files.restartPackage(pid)
-
-    @RequirePerm(Permission.Modify)
-    def restartFile(self, fid):
-        """Resets file status, so it will be downloaded again.
-
-        :param fid: file id
-        """
-        self.core.files.restartFile(fid)
-
-    @RequirePerm(Permission.Modify)
-    def recheckPackage(self, pid):
-        """Check online status of all files in a package, also a default action when package is added. """
-        self.core.files.reCheckPackage(pid)
-
-    @RequirePerm(Permission.Modify)
-    def restartFailed(self):
-        """Restarts all failed failes."""
-        self.core.files.restartFailed()
-
-    @RequirePerm(Permission.Modify)
-    def stopAllDownloads(self):
-        """Aborts all running downloads."""
-
-        pyfiles = self.core.files.cachedFiles()
-        for pyfile in pyfiles:
-            pyfile.abortDownload()
-
-    @RequirePerm(Permission.Modify)
-    def stopDownloads(self, fids):
-        """Aborts specific downloads.
-
-        :param fids: list of file ids
-        :return:
-        """
-        pyfiles = self.core.files.cachedFiles()
-        for pyfile in pyfiles:
-            if pyfile.id in fids:
-                pyfile.abortDownload()
-
-
-if Api.extend(DownloadApi):
-    del DownloadApi
\ No newline at end of file
diff --git a/module/api/DownloadPreparingApi.py b/module/api/DownloadPreparingApi.py
deleted file mode 100644
index edd5d362c..000000000
--- a/module/api/DownloadPreparingApi.py
+++ /dev/null
@@ -1,121 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from itertools import chain
-
-from module.Api import Api, RequirePerm, Permission, OnlineCheck, LinkStatus, urlmatcher
-from module.utils.fs import join
-from module.utils.packagetools import parseNames
-from module.network.RequestFactory import getURL
-
-from ApiComponent import ApiComponent
-
-class DownloadPreparingApi(ApiComponent):
-    """ All kind of methods to parse links or retrieve online status """
-
-    @RequirePerm(Permission.Add)
-    def parseURLs(self, html=None, url=None):
-        """Parses html content or any arbitrary text for links and returns result of `checkURLs`
-
-        :param html: html source
-        :return:
-        """
-        urls = []
-
-        if html:
-            urls += [x[0] for x in urlmatcher.findall(html)]
-
-        if url:
-            page = getURL(url)
-            urls += [x[0] for x in urlmatcher.findall(page)]
-
-        # remove duplicates
-        return self.checkURLs(set(urls))
-
-
-    @RequirePerm(Permission.Add)
-    def checkURLs(self, urls):
-        """ Gets urls and returns pluginname mapped to list of matching urls.
-
-        :param urls:
-        :return: {plugin: urls}
-        """
-        data, crypter = self.core.pluginManager.parseUrls(urls)
-        plugins = {}
-
-        for url, plugin in chain(data, crypter):
-            if plugin in plugins:
-                plugins[plugin].append(url)
-            else:
-                plugins[plugin] = [url]
-
-        return plugins
-
-    @RequirePerm(Permission.Add)
-    def checkOnlineStatus(self, urls):
-        """ initiates online status check, will also decrypt files.
-
-        :param urls:
-        :return: initial set of data as :class:`OnlineCheck` instance containing the result id
-        """
-        data, crypter = self.core.pluginManager.parseUrls(urls)
-
-        # initial result does not contain the crypter links
-        tmp = [(url, (url, LinkStatus(url, pluginname, "unknown", 3, 0))) for url, pluginname in data]
-        data = parseNames(tmp)
-        result = {}
-
-        for k, v in data.iteritems():
-            for url, status in v:
-                status.packagename = k
-                result[url] = status
-
-        data.update(crypter) # hoster and crypter will be processed
-        rid = self.core.threadManager.createResultThread(data, False)
-
-        return OnlineCheck(rid, result)
-
-    @RequirePerm(Permission.Add)
-    def checkOnlineStatusContainer(self, urls, container, data):
-        """ checks online status of urls and a submitted container file
-
-        :param urls: list of urls
-        :param container: container file name
-        :param data: file content
-        :return: :class:`OnlineCheck`
-        """
-        th = open(join(self.core.config["general"]["download_folder"], "tmp_" + container), "wb")
-        th.write(str(data))
-        th.close()
-        urls.append(th.name)
-        return self.checkOnlineStatus(urls)
-
-    @RequirePerm(Permission.Add)
-    def pollResults(self, rid):
-        """ Polls the result available for ResultID
-
-        :param rid: `ResultID`
-        :return: `OnlineCheck`, if rid is -1 then there is no more data available
-        """
-        result = self.core.threadManager.getInfoResult(rid)
-
-        if "ALL_INFO_FETCHED" in result:
-            del result["ALL_INFO_FETCHED"]
-            return OnlineCheck(-1, result)
-        else:
-            return OnlineCheck(rid, result)
-
-
-    @RequirePerm(Permission.Add)
-    def generatePackages(self, links):
-        """ Parses links, generates packages names from urls
-
-        :param links: list of urls
-        :return: package names mapped to urls
-        """
-        result = parseNames((x, x) for x in links)
-        return result
-
-
-if Api.extend(DownloadPreparingApi):
-    del DownloadPreparingApi
\ No newline at end of file
diff --git a/module/api/FileApi.py b/module/api/FileApi.py
deleted file mode 100644
index 8a55d9dfd..000000000
--- a/module/api/FileApi.py
+++ /dev/null
@@ -1,169 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from module.Api import Api, RequirePerm, Permission, DownloadState, PackageDoesNotExists, FileDoesNotExists
-from module.utils import uniqify
-
-from ApiComponent import ApiComponent
-
-# TODO: user context
-class FileApi(ApiComponent):
-    """Everything related to available packages or files. Deleting, Modifying and so on."""
-
-    @RequirePerm(Permission.All)
-    def getAllFiles(self):
-        """ same as `getFileTree` for toplevel root and full tree"""
-        return self.getFileTree(-1, True)
-
-    @RequirePerm(Permission.All)
-    def getFilteredFiles(self, state):
-        """ same as `getFilteredFileTree` for toplevel root and full tree"""
-        return self.getFilteredFileTree(-1, state, True)
-
-    @RequirePerm(Permission.All)
-    def getFileTree(self, pid, full):
-        """ Retrieve data for specific package. full=True will retrieve all data available
-            and can result in greater delays.
-
-        :param pid: package id
-        :param full: go down the complete tree or only the first layer
-        :return: :class:`TreeCollection`
-        """
-        return self.core.files.getTree(pid, full, DownloadState.All)
-
-    @RequirePerm(Permission.All)
-    def getFilteredFileTree(self, pid, full, state):
-        """ Same as `getFileTree` but only contains files with specific download state.
-
-        :param pid: package id
-        :param full: go down the complete tree or only the first layer
-        :param state: :class:`DownloadState`, the attributes used for filtering
-        :return: :class:`TreeCollection`
-        """
-        return self.core.files.getTree(pid, full, state)
-
-    @RequirePerm(Permission.All)
-    def getPackageContent(self, pid):
-        """  Only retrieve content of a specific package. see `getFileTree`"""
-        return self.getFileTree(pid, False)
-
-    @RequirePerm(Permission.All)
-    def getPackageInfo(self, pid):
-        """Returns information about package, without detailed information about containing files
-
-        :param pid: package id
-        :raises PackageDoesNotExists:
-        :return: :class:`PackageInfo`
-        """
-        info = self.core.files.getPackageInfo(pid)
-        if not info:
-            raise PackageDoesNotExists(pid)
-        return info
-
-    @RequirePerm(Permission.All)
-    def getFileInfo(self, fid):
-        """ Info for specific file
-
-        :param fid: file id
-        :raises FileDoesNotExists:
-        :return: :class:`FileInfo`
-
-        """
-        info = self.core.files.getFileInfo(fid)
-        if not info:
-            raise FileDoesNotExists(fid)
-        return info
-
-    @RequirePerm(Permission.Download)
-    def getFilePath(self, fid):
-        """ Internal method to get the filepath"""
-        info = self.getFileInfo(fid)
-        pack = self.core.files.getPackage(info.package)
-        return pack.getPath(), info.name
-
-
-    @RequirePerm(Permission.All)
-    def findFiles(self, pattern):
-        return self.core.files.getTree(-1, True, DownloadState.All, pattern)
-
-    @RequirePerm(Permission.All)
-    def searchSuggestions(self, pattern):
-        names = self.core.db.getMatchingFilenames(pattern, self.primaryUID)
-        # TODO: stemming and reducing the names to provide better suggestions
-        return uniqify(names)
-
-    @RequirePerm(Permission.All)
-    def findPackages(self, tags):
-        pass
-
-    @RequirePerm(Permission.Modify)
-    def updatePackage(self, pack):
-        """Allows to modify several package attributes.
-
-        :param pid: package id
-        :param data: :class:`PackageInfo`
-        """
-        pid = pack.pid
-        p = self.core.files.getPackage(pid)
-        if not p: raise PackageDoesNotExists(pid)
-
-        #TODO: fix
-        for key, value in data.iteritems():
-            if key == "id": continue
-            setattr(p, key, value)
-
-        p.sync()
-        self.core.files.save()
-
-    @RequirePerm(Permission.Modify)
-    def setPackageFolder(self, pid, path):
-        pass
-
-    @RequirePerm(Permission.Modify)
-    def movePackage(self, pid, root):
-        """ Set a new root for specific package. This will also moves the files on disk\
-           and will only work when no file is currently downloading.
-
-        :param pid: package id
-        :param root: package id of new root
-        :raises PackageDoesNotExists: When pid or root is missing
-        :return: False if package can't be moved
-        """
-        return self.core.files.movePackage(pid, root)
-
-    @RequirePerm(Permission.Modify)
-    def moveFiles(self, fids, pid):
-        """Move multiple files to another package. This will move the files on disk and\
-        only work when files are not downloading. All files needs to be continuous ordered
-        in the current package.
-
-        :param fids: list of file ids
-        :param pid: destination package
-        :return: False if files can't be moved
-        """
-        return self.core.files.moveFiles(fids, pid)
-
-    @RequirePerm(Permission.Modify)
-    def orderPackage(self, pid, position):
-        """Set new position for a package.
-
-        :param pid: package id
-        :param position: new position, 0 for very beginning
-        """
-        self.core.files.orderPackage(pid, position)
-
-    @RequirePerm(Permission.Modify)
-    def orderFiles(self, fids, pid, position):
-        """ Set a new position for a bunch of files within a package.
-        All files have to be in the same package and must be **continuous**\
-        in the package. That means no gaps between them.
-
-        :param fids: list of file ids
-        :param pid: package id of parent package
-        :param position:  new position: 0 for very beginning
-        """
-        self.core.files.orderFiles(fids, pid, position)
-
-
-if Api.extend(FileApi):
-    del FileApi
\ No newline at end of file
diff --git a/module/api/UserInteractionApi.py b/module/api/UserInteractionApi.py
deleted file mode 100644
index b95b7c468..000000000
--- a/module/api/UserInteractionApi.py
+++ /dev/null
@@ -1,61 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from module.Api import Api, RequirePerm, Permission, Interaction
-
-from ApiComponent import ApiComponent
-
-class UserInteractionApi(ApiComponent):
-    """ Everything needed for user interaction """
-
-    @RequirePerm(Permission.Interaction)
-    def isInteractionWaiting(self, mode):
-        """ Check if task is waiting.
-
-        :param mode: binary or'ed output type
-        :return: boolean
-        """
-        return self.core.interactionManager.isTaskWaiting(self.primaryUID, mode)
-
-    @RequirePerm(Permission.Interaction)
-    def getInteractionTasks(self, mode):
-        """Retrieve task for specific mode.
-
-        :param mode: binary or'ed interaction types which should be retrieved
-        :rtype list of :class:`InteractionTask`
-        """
-        tasks = self.core.interactionManager.getTasks(self.primaryUID, mode)
-        # retrieved tasks count as seen
-        for t in tasks:
-            t.seen = True
-            if t.type == Interaction.Notification:
-                t.setWaiting(self.core.interactionManager.CLIENT_THRESHOLD)
-
-        return tasks
-
-    @RequirePerm(Permission.Interaction)
-    def setInteractionResult(self, iid, result):
-        """Set Result for a interaction task. It will be immediately removed from task queue afterwards
-
-        :param iid: interaction id
-        :param result: result as json string
-        """
-        task = self.core.interactionManager.getTaskByID(iid)
-        if task and self.primaryUID == task.owner:
-            task.setResult(result)
-
-    @RequirePerm(Permission.Interaction)
-    def getAddonHandler(self):
-        pass
-
-    @RequirePerm(Permission.Interaction)
-    def callAddonHandler(self, plugin, func, pid_or_fid):
-        pass
-
-    @RequirePerm(Permission.Download)
-    def generateDownloadLink(self, fid, timeout):
-        pass
-
-
-if Api.extend(UserInteractionApi):
-    del UserInteractionApi
\ No newline at end of file
diff --git a/module/api/__init__.py b/module/api/__init__.py
deleted file mode 100644
index 1348fd26f..000000000
--- a/module/api/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-__all__ = ["CoreApi", "ConfigApi", "DownloadApi", "DownloadPreparingApi", "FileApi",
-           "CollectorApi", "UserInteractionApi", "AccountApi", "AddonApi"]
-
-# Import all components
-# from .import *
-# Above does not work in py 2.5
-for name in __all__:
-    __import__(__name__ + "." + name)
\ No newline at end of file