def conf_basic(self):
print ""
print _("## Basic Setup ##")
print ""
print _("The following logindata is valid for CLI, GUI and webinterface.")
from module.database import DatabaseBackend
db = DatabaseBackend(None)
db.setup()
username = self.ask(_("Username"), "User")
password = self.ask("", "", password=True)
db.addUser(username, password)
db.shutdown()
print ""
print _("External clients (GUI, CLI or other) need remote access to work over the network.")
print _("However, if you only want to use the webinterface you may disable it to save ram.")
self.config["remote"]["activated"] = self.ask(_("Enable remote access"), self.yes, bool=True)
print ""
langs = self.config.getMetaData("general", "language")
self.config["general"]["language"] = self.ask(_("Language"), "en", langs.type.split(";"))
self.config["general"]["download_folder"] = self.ask(_("Downloadfolder"), "Downloads")
self.config["download"]["max_downloads"] = self.ask(_("Max parallel downloads"), "3")
#print _("You should disable checksum proofing, if you have low hardware requirements.")
#self.config["general"]["checksum"] = self.ask(_("Proof checksum?"), "y", bool=True)
reconnect = self.ask(_("Use Reconnect?"), self.no, bool=True)
self.config["reconnect"]["activated"] = reconnect
if reconnect:
self.config["reconnect"]["method"] = self.ask(_("Reconnect script location"), "./reconnect.sh")
def set_user(self):
gettext.setpaths([join(os.sep, "usr", "share", "pyload", "locale"), None])
translation = gettext.translation("setup", join(self.path, "locale"),
languages=[self.config["general"]["language"], "en"], fallback=True)
translation.install(True)
from module.database import DatabaseBackend
db = DatabaseBackend(None)
db.setup()
noaction = True
try:
while True:
print _("Select action")
print _("1 - Create/Edit user")
print _("2 - List users")
print _("3 - Remove user")
print _("4 - Quit")
action = raw_input("[1]/2/3/4: ")
if not action in ("1", "2", "3", "4"):
continue
elif action == "1":
print
username = self.ask(_("Username"), "User")
password = self.ask("", "", password=True)
db.addUser(username, password)
noaction = False
elif action == "2":
print
print _("Users")
print "-----"
users = db.listUsers()
noaction = False
for user in users:
print user
print "-----"
print
elif action == "3":
print
username = self.ask(_("Username"), "")
if username:
db.removeUser(username)
noaction = False
elif action == "4":
break
finally:
if not noaction:
db.shutdown()
def setUpClass(cls):
cls.db = DatabaseBackend(Core())
cls.db.manager = cls.db.core
cls.db.manager.statusMsg = defaultdict(lambda: "statusmsg")
cls.config = ConfigParser()
cls.db.setup()
cls.db.clearAllConfigs()
def setUpClass(cls):
c = Core()
# db needs seperate initialisation
cls.db = c.db = DatabaseBackend(c)
cls.db.setup()
cls.db.purgeAll()
cls.m = cls.db.manager = FileManager(c)
def conf_basic(self):
print _("## Basic Setup ##")
print
print _("The following logindata is valid for CLI and webinterface.")
from module.database import DatabaseBackend
db = DatabaseBackend(None)
db.setup()
print _("NOTE: Consider a password of 10 or more symbols if you expect to access from outside your local network (ex. internet).")
print
username = self.ask(_("Username"), "User")
password = self.ask("", "", password=True)
db.addUser(username, password)
db.shutdown()
print
print _("External clients (GUI, CLI or other) need remote access to work over the network.")
print _("However, if you only want to use the webinterface you may disable it to save ram.")
self.config["remote"]["activated"] = self.ask(_("Enable remote access"), self.no, bool=True)
print
langs = self.config.getMetaData("general", "language")
self.config["general"]["language"] = self.ask(_("Choose pyLoad language"), "en", langs["type"].split(";"))
print
self.config["general"]["download_folder"] = self.ask(_("Download folder"), "Downloads")
print
self.config["download"]["max_downloads"] = self.ask(_("Max parallel downloads"), "3")
print
reconnect = self.ask(_("Use Reconnect?"), self.no, bool=True)
self.config["reconnect"]["activated"] = reconnect
if reconnect:
self.config["reconnect"]["method"] = self.ask(_("Reconnect script location"), "./reconnect.sh")
def setUpClass(cls):
cls.core = Core()
cls.db = DatabaseBackend(cls.core)
cls.core.db = cls.db
cls.db.manager = cls.core
cls.db.manager.statusMsg = defaultdict(lambda: "statusmsg")
cls.parser = ConfigParser()
cls.config = ConfigManager(cls.core, cls.parser)
cls.db.setup()
def setUpClass(cls):
cls.pids = [-1]
cls.fids = []
cls.db = DatabaseBackend(Core())
cls.db.manager = cls.db.core
cls.db.setup()
cls.db.purgeAll()
def conf_basic(self):
print _("## Basic Setup ##")
print
print _("The following logindata is valid for CLI and webinterface.")
from module.database import DatabaseBackend
db = DatabaseBackend(None)
db.setup()
print _(
"NOTE: Consider a password of 10 or more symbols if you expect to access from outside your local network (ex. internet)."
)
print
username = self.ask(_("Username"), "User")
password = self.ask("", "", password=True)
db.addUser(username, password)
db.shutdown()
print
print _(
"External clients (GUI, CLI or other) need remote access to work over the network."
)
print _(
"However, if you only want to use the webinterface you may disable it to save ram."
)
self.config["remote"]["activated"] = self.ask(
_("Enable remote access"), self.no, bool=True)
print
langs = self.config.getMetaData("general", "language")
self.config["general"]["language"] = self.ask(
_("Choose pyLoad language"), "en", langs["type"].split(";"))
print
self.config["general"]["download_folder"] = self.ask(
_("Download folder"), "Downloads")
print
self.config["download"]["max_downloads"] = self.ask(
_("Max parallel downloads"), "3")
print
reconnect = self.ask(_("Use Reconnect?"), self.no, bool=True)
self.config["reconnect"]["activated"] = reconnect
if reconnect:
self.config["reconnect"]["method"] = self.ask(
_("Reconnect script location"), "./reconnect.sh")
# -*- coding: utf-8 -*-
from module.database import queue, async
from module.database import DatabaseBackend
class AccountMethods:
@queue
def loadAccounts(db):
db.c.execute(
'SELECT plugin, loginname, activated, password, options FROM accounts;'
)
return db.c.fetchall()
@async
def saveAccounts(db, data):
db.c.executemany(
'INSERT INTO accounts(plugin, loginname, activated, password, options) VALUES(?,?,?,?,?)',
data)
@async
def removeAccount(db, plugin, loginname):
db.c.execute('DELETE FROM accounts WHERE plugin=? AND loginname=?',
(plugin, loginname))
DatabaseBackend.registerSub(AccountMethods)
(str(pid), ))
return [r[0] for r in self.c]
@style.queue
def deleteFinished(self):
self.c.execute("DELETE FROM links WHERE status IN (0, 4)")
self.c.execute(
"DELETE FROM packages WHERE NOT EXISTS(SELECT 1 FROM links WHERE packages.id=links.package)"
)
@style.queue
def restartFailed(self):
self.c.execute(
"UPDATE links SET status=3, error='' WHERE status IN (6, 8, 9)")
@style.queue
def findDuplicates(self, id, folder, filename):
""" checks if filename exists with different id and same package """
self.c.execute(
"SELECT l.plugin FROM links as l INNER JOIN packages as p ON l.package=p.id AND p.folder=? WHERE l.id!=? AND l.status=0 AND l.name=?",
(folder, id, filename))
return self.c.fetchone()
@style.queue
def purgeLinks(self):
self.c.execute("DELETE FROM links;")
self.c.execute("DELETE FROM packages;")
DatabaseBackend.registerSub(FileMethods)
(value, identifier, key))
else:
db.c.execute(
"INSERT INTO storage (identifier, key, value) VALUES (?, ?, ?)",
(identifier, key, value))
@style.queue
def getStorage(db, identifier, key=None):
if key is not None:
db.c.execute(
"SELECT value FROM storage WHERE identifier=? AND key=?",
(identifier, key))
row = db.c.fetchone()
if row is not None:
return row[0]
else:
db.c.execute("SELECT key, value FROM storage WHERE identifier=?",
(identifier, ))
d = {}
for row in db.c:
d[row[0]] = row[1]
return d
@style.queue
def delStorage(db, identifier, key):
db.c.execute("DELETE FROM storage WHERE identifier=? AND key=?",
(identifier, key))
DatabaseBackend.registerSub(StorageMethods)
def setupDB(self):
self.db = DatabaseBackend(self) # the backend
self.db.setup()
self.files = FileHandler(self)
self.db.manager = self.files #ugly?
class Core(object):
"""pyLoad Core, one tool to rule them all... (the filehosters) :D"""
def __init__(self, **kwargs):
if kwargs.get('display_version'):
print("pyLoad", CURRENT_VERSION)
exit()
elif kwargs.get('do_clean'):
self.cleanTree()
exit()
elif kwargs.get('user'):
from module.setup import Setup
self.config = ConfigParser()
s = Setup(pypath, self.config)
s.set_user()
exit()
elif kwargs.get('setup'):
from module.setup import Setup
self.config = ConfigParser()
s = Setup(pypath, self.config)
s.start()
exit()
elif kwargs.get('change_dir'):
from module.setup import Setup
self.config = ConfigParser()
s = Setup(pypath, self.config)
s.conf_path(True)
exit()
elif kwargs.get('do_quit'):
self.quitInstance()
exit()
elif kwargs.get('display_status'):
pid = self.isAlreadyRunning()
if self.isAlreadyRunning():
print(pid)
exit(0)
else:
print("false")
exit(1)
self.running = False
self.pidfile = kwargs.get('pidfile') or 'pyload.pid'
self.doDebug = bool(kwargs.get('do_debug'))
self.remote = not bool(kwargs.get('no_remote'))
self.daemon = bool(kwargs.get('is_daemon'))
self.deleteLinks = bool(kwargs.get('do_clear')) # will delete links on startup
def toggle_pause(self):
thread_manager = get_thread_manager()
thread_manager.pause = not thread_manager.pause
return thread_manager.pause
def quit(self, a, b):
self.shutdown()
self.log.info(_("Received Quit signal"))
_exit(1)
def writePidFile(self):
self.deletePidFile()
pid = os.getpid()
f = open(self.pidfile, "wb")
f.write(smart_bytes(pid))
f.close()
def deletePidFile(self):
if self.checkPidFile():
self.log.debug("Deleting old pidfile %s" % self.pidfile)
os.remove(self.pidfile)
def checkPidFile(self):
""" return pid as int or 0"""
if os.path.isfile(self.pidfile):
f = open(self.pidfile, "rb")
pid = f.read().strip()
f.close()
if pid:
pid = int(pid)
return pid
return 0
def isAlreadyRunning(self):
pid = self.checkPidFile()
if not pid or IS_WINDOWS:
return False
try:
os.kill(pid, 0) # 0 - default signal (does nothing)
except Exception:
return 0
return pid
def quitInstance(self):
if IS_WINDOWS:
print("Not supported on windows.")
return
pid = self.isAlreadyRunning()
if not pid:
print("No pyLoad running.")
return
try:
os.kill(pid, 3) #SIGUIT
t = time()
print("waiting for pyLoad to quit")
while exists(self.pidfile) and t + 10 > time():
sleep(0.25)
if not exists(self.pidfile):
print("pyLoad successfully stopped")
else:
os.kill(pid, 9) #SIGKILL
print("pyLoad did not respond")
print("Kill signal was send to process with id %s" % pid)
except:
print("Error quitting pyLoad")
def cleanTree(self):
for path, dirs, files in walk(self.path("")):
for f in files:
if not f.endswith(".pyo") and not f.endswith(".pyc"):
continue
if "_25" in f or "_26" in f or "_27" in f:
continue
print(join(path, f))
remove(join(path, f))
def start(self, rpc=True, web=True):
""" starts the fun :D """
self.version = CURRENT_VERSION
if not exists("pyload.conf"):
from module.setup import Setup
print("This is your first start, running configuration assistent now.")
self.config = ConfigParser()
s = Setup(pypath, self.config)
res = False
try:
res = s.start()
except SystemExit:
pass
except KeyboardInterrupt:
print("\nSetup interrupted")
except:
res = False
print_exc()
print("Setup failed")
if not res:
remove("pyload.conf")
exit()
try: signal.signal(signal.SIGQUIT, self.quit)
except: pass
self.config = ConfigParser()
gettext.setpaths([join(os.sep, "usr", "share", "pyload", "locale"), None])
translation = gettext.translation("pyLoad", self.path("locale"),
languages=[self.config['general']['language'],"en"],fallback=True)
install_translation(translation)
self.debug = self.doDebug or self.config['general']['debug_mode']
self.remote &= self.config['remote']['activated']
pid = self.isAlreadyRunning()
if pid:
print(_("pyLoad already running with pid %s") % pid)
exit()
if not IS_WINDOWS and self.config["general"]["renice"]:
os.system("renice %d %d" % (self.config["general"]["renice"], os.getpid()))
if self.config["permission"]["change_group"]:
if not IS_WINDOWS:
try:
from grp import getgrnam
group = getgrnam(self.config["permission"]["group"])
os.setgid(group[2])
except Exception as e:
print(_("Failed changing group: %s") % e)
if self.config["permission"]["change_user"]:
if not IS_WINDOWS:
try:
from pwd import getpwnam
user = getpwnam(self.config["permission"]["user"])
os.setuid(user[2])
except Exception as e:
print(_("Failed changing user: %s") % e)
self.check_file(
self.config['log']['log_folder'],
_("folder for logs"),
is_folder=True,
)
if self.debug:
self.init_logger(logging.DEBUG) # logging level
else:
self.init_logger(logging.INFO) # logging level
sys.excepthook = exceptHook
self.do_kill = False
self.do_restart = False
self.shuttedDown = False
self.log.info(_("Starting") + " pyLoad %s" % CURRENT_VERSION)
self.log.info(_("Using home directory: %s") % getcwd())
self.writePidFile()
#@TODO refractor
remote.activated = self.remote
self.log.debug("Remote activated: %s" % self.remote)
self.check_install("Crypto", _("pycrypto to decode container files"))
#img = self.check_install("Image", _("Python Image Libary (PIL) for captcha reading"))
#self.check_install("pycurl", _("pycurl to download any files"), True, True)
self.check_file("tmp", _("folder for temporary files"), is_folder=True)
#tesser = self.check_install("tesseract", _("tesseract for captcha reading"), False) if not IS_WINDOWS else True
self.captcha = True # checks seems to fail, althoug tesseract is available
self.check_file(
self.config['general']['download_folder'],
_("folder for downloads"),
is_folder=True,
)
if self.config['ssl']['activated']:
self.check_install("OpenSSL", _("OpenSSL for secure connection"))
self.setupDB()
if self.deleteLinks:
self.log.info(_("All links removed"))
self.db.purgeLinks()
set_request_factory(RequestFactory(self))
self.lastClientConnected = 0
# later imported because they would trigger api import, and remote value not set correctly
from module import Api
from module.HookManager import HookManager
from module.ThreadManager import ThreadManager
if Api.activated != self.remote:
self.log.warning("Import error: API remote status not correct.")
self.api = Api.Api(self)
self.scheduler = Scheduler(self)
#hell yeah, so many important managers :D
set_plugin_manager(PluginManager(self))
set_pull_manager(PullManager(self))
set_thread_manager(ThreadManager(self))
set_account_manager(AccountManager(self))
set_captcha_manager(CaptchaManager(self))
# HookManager sets itself as a singleton
HookManager(self)
set_remote_manager(RemoteManager(self))
thread_manager = get_thread_manager()
self.js = JsEngine()
self.log.info(_("Downloadtime: %s") % self.api.isTimeDownload())
if rpc:
get_remote_manager().startBackends()
if web:
self.init_webserver()
spaceLeft = freeSpace(self.config["general"]["download_folder"])
self.log.info(_("Free space: %s") % formatSize(spaceLeft))
self.config.save() #save so config files gets filled
link_file = join(pypath, "links.txt")
if exists(link_file):
f = open(link_file, "rb")
if f.read().strip():
self.api.addPackage("links.txt", [link_file], 1)
f.close()
link_file = "links.txt"
if exists(link_file):
f = open(link_file, "rb")
if f.read().strip():
self.api.addPackage("links.txt", [link_file], 1)
f.close()
#self.scheduler.addJob(0, get_account_manager().getAccountInfos)
self.log.info(_("Activating Accounts..."))
get_account_manager().getAccountInfos()
thread_manager.pause = False
self.running = True
self.log.info(_("Activating Plugins..."))
get_hook_manager().coreReady()
self.log.info(_("pyLoad is up and running"))
#test api
# from module.common.APIExerciser import startApiExerciser
# startApiExerciser(self, 3)
#some memory stats
# from guppy import hpy
# hp=hpy()
# import objgraph
# objgraph.show_most_common_types(limit=20)
# import memdebug
# memdebug.start(8002)
locals().clear()
while True:
try:
sleep(2)
except IOError as e:
if e.errno != 4: # errno.EINTR
raise
if self.do_restart:
self.log.info(_("restarting pyLoad"))
self.restart()
if self.do_kill:
self.shutdown()
self.log.info(_("pyLoad quits"))
self.removeLogger()
_exit(0) #@TODO thrift blocks shutdown
thread_manager.work()
self.scheduler.work()
def setupDB(self):
self.db = DatabaseBackend(self) # the backend
self.db.setup()
self.files = FileHandler(self)
self.db.manager = self.files #ugly?
def init_webserver(self):
if self.config['webinterface']['activated']:
self.webserver = WebServer(self)
self.webserver.start()
def init_logger(self, level):
console = logging.StreamHandler(sys.stdout)
frm = logging.Formatter("%(asctime)s %(levelname)-8s %(message)s", "%d.%m.%Y %H:%M:%S")
console.setFormatter(frm)
self.log = logging.getLogger("log") # settable in config
if self.config['log']['file_log']:
if self.config['log']['log_rotate']:
file_handler = logging.handlers.RotatingFileHandler(
join(smart_text(self.config['log']['log_folder']), u'log.txt'),
maxBytes=self.config['log']['log_size'] * 1024,
backupCount=int(self.config['log']['log_count']),
encoding="utf8",
)
else:
file_handler = logging.FileHandler(
join(smart_text(self.config['log']['log_folder']), u'log.txt'),
encoding="utf8",
)
file_handler.setFormatter(frm)
self.log.addHandler(file_handler)
self.log.addHandler(console) #if console logging
self.log.setLevel(level)
def removeLogger(self):
for h in list(self.log.handlers):
self.log.removeHandler(h)
h.close()
def check_install(self, check_name, legend, python=True, essential=False):
"""check wether needed tools are installed"""
try:
if python:
find_module(check_name)
else:
pipe = subprocess.PIPE
subprocess.Popen(check_name, stdout=pipe, stderr=pipe)
return True
except:
if essential:
self.log.info(_("Install %s") % legend)
exit()
return False
def check_file(self, check_name, description, is_folder=False):
"""Check whether needed files exist."""
file_created = True
file_exists = True
check_name = smart_text(check_name)
if not exists(check_name):
file_exists = False
try:
if is_folder:
check_name = check_name.replace(u'/', smart_text(sep))
os.makedirs(check_name)
else:
open(check_name, "w")
except Exception:
file_created = False
if not file_exists and not file_created:
print(_("could not create %(desc)s: %(name)s") % {"desc": description, "name": check_name})
def isClientConnected(self):
return (self.lastClientConnected + 30) > time()
def restart(self):
self.shutdown()
chdir(owd)
# close some open fds
for i in range(3,50):
try:
close(i)
except:
pass
execl(executable, executable, *sys.argv)
_exit(0)
def shutdown(self):
self.log.info(_("shutting down..."))
try:
if self.config['webinterface']['activated'] and hasattr(self, "webserver"):
self.webserver.quit()
for thread in get_thread_manager().threads:
thread.put("quit")
pyfiles = self.files.cache.values()
for pyfile in pyfiles:
pyfile.abortDownload()
get_hook_manager().coreExiting()
except:
if self.debug:
print_exc()
self.log.info(_("error while shutting down"))
finally:
self.files.syncSave()
self.shuttedDown = True
self.deletePidFile()
def path(self, *args):
return join(pypath, *args)
@style.queue
def restartFailed(self):
self.c.execute("UPDATE links SET status=3,error='' WHERE status IN (6, 8, 9)")
@style.queue
def findDuplicates(self, id, folder, filename):
""" checks if filename exists with different id and same package """
self.c.execute("SELECT l.plugin FROM links as l INNER JOIN packages as p ON l.package=p.id AND p.folder=? WHERE l.id!=? AND l.status=0 AND l.name=?", (folder, id, filename))
return self.c.fetchone()
@style.queue
def purgeLinks(self):
self.c.execute("DELETE FROM links;")
self.c.execute("DELETE FROM packages;")
DatabaseBackend.registerSub(FileMethods)
if __name__ == "__main__":
pypath = "."
_ = lambda x: x
db = FileHandler(None)
#p = PyFile(db, 5)
#sleep(0.1)
a = time()
#print db.addPackage("package", "folder" , 1)
def set_user(self):
gettext.setpaths([os.path.join(os.sep, "usr", "share", "pyload", "locale"), None])
translation = gettext.translation(
"setup",
os.path.join(self.path, "locale"),
languages=[self.config["general"]["language"], "en"],
fallback=True,
)
install_translation(translation)
from module.database import DatabaseBackend
db = DatabaseBackend(None)
db.setup()
noaction = True
try:
while True:
print(_("Select action"))
print(_("1 - Create/Edit user"))
print(_("2 - List users"))
print(_("3 - Remove user"))
print(_("4 - Quit"))
action = input("[1]/2/3/4: ")
if not action in ("1", "2", "3", "4"):
continue
elif action == "1":
print("")
username = self.ask(_("Username"), "User")
password = self.ask("", "", password=True)
db.addUser(username, password)
noaction = False
elif action == "2":
print("")
print(_("Users"))
print("-----")
users = db.listUsers()
noaction = False
for user in users:
print(user)
print("-----")
print("")
elif action == "3":
print("")
username = self.ask(_("Username"), "")
if username:
db.removeUser(username)
noaction = False
elif action == "4":
break
finally:
if not noaction:
db.shutdown()
def set_user(self):
gettext.setpaths([join(os.sep, "usr", "share", "pyload", "locale"), None])
translation = gettext.translation("setup", join(self.path, "locale"),
languages=[self.config["general"]["language"], "en"], fallback=True)
translation.install(True)
from module.database import DatabaseBackend
db = DatabaseBackend(None)
db.setup()
noaction = True
try:
while True:
print _("Select action")
print _("1 - Create/Edit user")
print _("2 - List users")
print _("3 - Remove user")
print _("4 - Quit")
action = raw_input("[1]/2/3/4: ")
if not action in ("1", "2", "3", "4"):
continue
elif action == "1":
print ""
username = self.ask(_("Username"), "User")
password = self.ask("", "", password=True)
db.addUser(username, password)
noaction = False
elif action == "2":
print ""
print _("Users")
print "-----"
users = db.getAllUserData()
noaction = False
for user in users.itervalues():
print user.name
print "-----"
print ""
elif action == "3":
print ""
username = self.ask(_("Username"), "")
if username:
db.removeUser(username)
noaction = False
elif action == "4":
db.syncSave()
break
finally:
if not noaction:
db.shutdown()
from module.database import style
from module.database import DatabaseBackend
class StorageMethods(object):
@style.queue
def setStorage(db, identifier, key, value):
db.c.execute("SELECT id FROM storage WHERE identifier=? AND key=?", (identifier, key))
if db.c.fetchone() is not None:
db.c.execute("UPDATE storage SET value=? WHERE identifier=? AND key=?", (value, identifier, key))
else:
db.c.execute("INSERT INTO storage (identifier, key, value) VALUES (?, ?, ?)", (identifier, key, value))
@style.queue
def getStorage(db, identifier, key=None):
if key is not None:
db.c.execute("SELECT value FROM storage WHERE identifier=? AND key=?", (identifier, key))
row = db.c.fetchone()
if row is not None:
return row[0]
else:
db.c.execute("SELECT key, value FROM storage WHERE identifier=?", (identifier,))
return {row[0]: row[1] for row in db.c}
@style.queue
def delStorage(db, identifier, key):
db.c.execute("DELETE FROM storage WHERE identifier=? AND key=?", (identifier, key))
DatabaseBackend.registerSub(StorageMethods)
# -*- coding: utf-8 -*-
from module.database import queue, async
from module.database import DatabaseBackend
class AccountMethods:
@queue
def loadAccounts(db):
db.c.execute('SELECT plugin, loginname, activated, password, options FROM accounts;')
return db.c.fetchall()
@async
def saveAccounts(db, data):
db.c.executemany('INSERT INTO accounts(plugin, loginname, activated, password, options) VALUES(?,?,?,?,?)', data)
@async
def removeAccount(db, plugin, loginname):
db.c.execute('DELETE FROM accounts WHERE plugin=? AND loginname=?', (plugin, loginname))
DatabaseBackend.registerSub(AccountMethods)
