deathbybandaid/SpiceBot-migrated
1
0
Fork 0
mirror of https://github.com/SpiceBot/SpiceBot.git synced 2026-11-13 15:09:54 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

not defined

Browse Source
This commit is contained in:
deathbybandaid 2019-05-29 13:19:47 -04:00
parent 0f7f0d043e
commit 05a1758aab
3 changed files with 339 additions and 577 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

678
sopel_modules/SpiceBot/Database.py
View File

@ -21,6 +21,345 @@ import json
BASE = declarative_base() BASE = declarative_base()
class PluginValues(BASE):
"""
PluginValues SQLAlchemy Class
"""
__tablename__ = 'plugin_values'
plugin = Column(String(255), primary_key=True)
sortingkey = Column(String(255), primary_key=True)
key = Column(String(255), primary_key=True)
value = Column(String(255))
class NickValues(BASE):
"""
NickValues SQLAlchemy Class
"""
__tablename__ = 'nick_values'
nick_id = Column(Integer, ForeignKey('nick_ids.nick_id'), primary_key=True)
sortingkey = Column(String(255), primary_key=True)
key = Column(String(255), primary_key=True)
value = Column(String(255))
class ChannelValues(BASE):
"""
ChannelValues SQLAlchemy Class
"""
__tablename__ = 'channel_values'
channel = Column(String(255), primary_key=True)
sortingkey = Column(String(255), primary_key=True)
key = Column(String(255), primary_key=True)
value = Column(String(255))
class SpiceDB(object):
# NICK FUNCTIONS
def set_nick_value(self, nick, key, value, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the nick."""
nick = Identifier(nick)
value = json.dumps(value, ensure_ascii=False)
nick_id = self.get_nick_id(nick)
session = self.ssession()
try:
result = session.query(NickValues) \
.filter(NickValues.nick_id == nick_id) \
.filter(NickValues.sortingkey == sortingkey) \
.filter(NickValues.key == key) \
.one_or_none()
# NickValue exists, update
if result:
result.value = value
session.commit()
# DNE - Insert
else:
new_nickvalue = NickValues(nick_id=nick_id, sortingkey=sortingkey, key=key, value=value)
session.add(new_nickvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def get_nick_value(self, nick, key, sortingkey='unsorted'):
"""Retrieves the value for a given key associated with a nick."""
nick = Identifier(nick)
session = self.ssession()
try:
result = session.query(NickValues) \
.filter(Nicknames.nick_id == NickValues.nick_id) \
.filter(Nicknames.slug == nick.lower()) \
.filter(NickValues.sortingkey == sortingkey) \
.filter(NickValues.key == key) \
.one_or_none()
if result is not None:
result = result.value
return _deserialize(result)
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def delete_nick_value(self, nick, key, sortingkey='unsorted'):
"""Deletes the value for a given key to be associated with the nick."""
nick = Identifier(nick)
nick_id = self.get_nick_id(nick)
session = self.ssession()
try:
result = session.query(NickValues) \
.filter(NickValues.nick_id == nick_id) \
.filter(NickValues.sortingkey == sortingkey) \
.filter(NickValues.key == key) \
.one_or_none()
# NickValue exists, delete
if result:
session.delete(result)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def adjust_nick_value(self, nick, key, value, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the nick."""
nick = Identifier(nick)
value = json.dumps(value, ensure_ascii=False)
nick_id = self.get_nick_id(nick)
session = self.ssession()
try:
result = session.query(NickValues) \
.filter(NickValues.nick_id == nick_id) \
.filter(NickValues.sortingkey == sortingkey) \
.filter(NickValues.key == key) \
.one_or_none()
# NickValue exists, update
if result:
result.value = result.value + value
session.commit()
# DNE - Insert
else:
new_nickvalue = NickValues(nick_id=nick_id, sortingkey=sortingkey, key=key, value=value)
session.add(new_nickvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
# CHANNEL FUNCTIONS
def set_channel_value(self, channel, key, value, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the channel."""
channel = Identifier(channel).lower()
value = json.dumps(value, ensure_ascii=False)
session = self.ssession()
try:
result = session.query(ChannelValues) \
.filter(ChannelValues.channel == channel)\
.filter(ChannelValues.sortingkey == sortingkey) \
.filter(ChannelValues.key == key) \
.one_or_none()
# ChannelValue exists, update
if result:
result.value = value
session.commit()
# DNE - Insert
else:
new_channelvalue = ChannelValues(channel=channel, sortingkey=sortingkey, key=key, value=value)
session.add(new_channelvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def get_channel_value(self, channel, key, sortingkey='unsorted'):
"""Retrieves the value for a given key associated with a channel."""
channel = Identifier(channel).lower()
session = self.ssession()
try:
result = session.query(ChannelValues) \
.filter(ChannelValues.channel == channel)\
.filter(ChannelValues.sortingkey == sortingkey) \
.filter(ChannelValues.key == key) \
.one_or_none()
if result is not None:
result = result.value
return _deserialize(result)
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def delete_channel_value(self, channel, key, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the channel."""
channel = Identifier(channel).lower()
session = self.ssession()
try:
result = session.query(ChannelValues) \
.filter(ChannelValues.channel == channel)\
.filter(ChannelValues.sortingkey == sortingkey) \
.filter(ChannelValues.key == key) \
.one_or_none()
# ChannelValue exists, delete
if result:
session.delete(result)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def adjust_channel_value(self, channel, key, value, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the channel."""
channel = Identifier(channel).lower()
value = json.dumps(value, ensure_ascii=False)
session = self.ssession()
try:
result = session.query(ChannelValues) \
.filter(ChannelValues.channel == channel)\
.filter(ChannelValues.sortingkey == sortingkey) \
.filter(ChannelValues.key == key) \
.one_or_none()
# ChannelValue exists, update
if result:
result.value = result.value + value
session.commit()
# DNE - Insert
else:
new_channelvalue = ChannelValues(channel=channel, sortingkey=sortingkey, key=key, value=value)
session.add(new_channelvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
# NICK AND CHANNEL FUNCTIONS
def get_nick_or_channel_value(self, name, key, sortingkey='unsorted'):
"""Gets the value `key` associated to the nick or channel `name`."""
name = Identifier(name)
if name.is_nick():
return self.get_nick_value(name, key, sortingkey)
else:
return self.get_channel_value(name, key, sortingkey)
def get_preferred_value(self, names, key, sortingkey='unsorted'):
"""Gets the value for the first name which has it set.
`names` is a list of channel and/or user names. Returns None if none of
the names have the key set."""
for name in names:
value = self.get_nick_or_channel_value(name, key, sortingkey)
if value is not None:
return value
# PLUGIN FUNCTIONS
def set_plugin_value(self, plugin, key, value, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the plugin."""
plugin = Identifier(plugin).lower()
value = json.dumps(value, ensure_ascii=False)
session = self.ssession()
try:
result = session.query(PluginValues) \
.filter(PluginValues.plugin == plugin)\
.filter(PluginValues.sortingkey == sortingkey) \
.filter(PluginValues.key == key) \
.one_or_none()
# PluginValues exists, update
if result:
result.value = value
session.commit()
# DNE - Insert
else:
new_pluginvalue = PluginValues(plugin=plugin, sortingkey=sortingkey, key=key, value=value)
session.add(new_pluginvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def get_plugin_value(self, plugin, key, sortingkey='unsorted'):
"""Retrieves the value for a given key associated with a plugin."""
plugin = Identifier(plugin).lower()
session = self.ssession()
try:
result = session.query(PluginValues) \
.filter(PluginValues.plugin == plugin)\
.filter(PluginValues.sortingkey == sortingkey) \
.filter(PluginValues.key == key) \
.one_or_none()
if result is not None:
result = result.value
return _deserialize(result)
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def adjust_plugin_value(self, plugin, key, value, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the plugin."""
plugin = Identifier(plugin).lower()
value = json.dumps(value, ensure_ascii=False)
session = self.ssession()
try:
result = session.query(PluginValues) \
.filter(PluginValues.plugin == plugin)\
.filter(PluginValues.sortingkey == sortingkey) \
.filter(PluginValues.key == key) \
.one_or_none()
# ChannelValue exists, update
if result:
result.value = result.value + value
session.commit()
# DNE - Insert
else:
new_pluginvalue = PluginValues(plugin=plugin, sortingkey=sortingkey, key=key, value=value)
session.add(new_pluginvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def delete_plugin_value(self, plugin, key, sortingkey='unsorted'):
"""Deletes the value for a given key to be associated with the plugin."""
plugin = Identifier(plugin).lower()
session = self.ssession()
try:
result = session.query(PluginValues) \
.filter(PluginValues.plugin == plugin)\
.filter(PluginValues.sortingkey == sortingkey) \
.filter(PluginValues.key == key) \
.one_or_none()
# PluginValues exists, delete
if result:
session.delete(result)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
class BotDatabase(): class BotDatabase():
"""A thread safe database cache""" """A thread safe database cache"""
@ -402,342 +741,3 @@ class BotDatabase():
db = BotDatabase() db = BotDatabase()
class PluginValues(BASE):
"""
PluginValues SQLAlchemy Class
"""
__tablename__ = 'plugin_values'
plugin = Column(String(255), primary_key=True)
sortingkey = Column(String(255), primary_key=True)
key = Column(String(255), primary_key=True)
value = Column(String(255))
class NickValues(BASE):
"""
NickValues SQLAlchemy Class
"""
__tablename__ = 'nick_values'
nick_id = Column(Integer, ForeignKey('nick_ids.nick_id'), primary_key=True)
sortingkey = Column(String(255), primary_key=True)
key = Column(String(255), primary_key=True)
value = Column(String(255))
class ChannelValues(BASE):
"""
ChannelValues SQLAlchemy Class
"""
__tablename__ = 'channel_values'
channel = Column(String(255), primary_key=True)
sortingkey = Column(String(255), primary_key=True)
key = Column(String(255), primary_key=True)
value = Column(String(255))
class SpiceDB(object):
# NICK FUNCTIONS
def set_nick_value(self, nick, key, value, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the nick."""
nick = Identifier(nick)
value = json.dumps(value, ensure_ascii=False)
nick_id = self.get_nick_id(nick)
session = self.ssession()
try:
result = session.query(NickValues) \
.filter(NickValues.nick_id == nick_id) \
.filter(NickValues.sortingkey == sortingkey) \
.filter(NickValues.key == key) \
.one_or_none()
# NickValue exists, update
if result:
result.value = value
session.commit()
# DNE - Insert
else:
new_nickvalue = NickValues(nick_id=nick_id, sortingkey=sortingkey, key=key, value=value)
session.add(new_nickvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def get_nick_value(self, nick, key, sortingkey='unsorted'):
"""Retrieves the value for a given key associated with a nick."""
nick = Identifier(nick)
session = self.ssession()
try:
result = session.query(NickValues) \
.filter(Nicknames.nick_id == NickValues.nick_id) \
.filter(Nicknames.slug == nick.lower()) \
.filter(NickValues.sortingkey == sortingkey) \
.filter(NickValues.key == key) \
.one_or_none()
if result is not None:
result = result.value
return _deserialize(result)
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def delete_nick_value(self, nick, key, sortingkey='unsorted'):
"""Deletes the value for a given key to be associated with the nick."""
nick = Identifier(nick)
nick_id = self.get_nick_id(nick)
session = self.ssession()
try:
result = session.query(NickValues) \
.filter(NickValues.nick_id == nick_id) \
.filter(NickValues.sortingkey == sortingkey) \
.filter(NickValues.key == key) \
.one_or_none()
# NickValue exists, delete
if result:
session.delete(result)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def adjust_nick_value(self, nick, key, value, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the nick."""
nick = Identifier(nick)
value = json.dumps(value, ensure_ascii=False)
nick_id = self.get_nick_id(nick)
session = self.ssession()
try:
result = session.query(NickValues) \
.filter(NickValues.nick_id == nick_id) \
.filter(NickValues.sortingkey == sortingkey) \
.filter(NickValues.key == key) \
.one_or_none()
# NickValue exists, update
if result:
result.value = result.value + value
session.commit()
# DNE - Insert
else:
new_nickvalue = NickValues(nick_id=nick_id, sortingkey=sortingkey, key=key, value=value)
session.add(new_nickvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
# CHANNEL FUNCTIONS
def set_channel_value(self, channel, key, value, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the channel."""
channel = Identifier(channel).lower()
value = json.dumps(value, ensure_ascii=False)
session = self.ssession()
try:
result = session.query(ChannelValues) \
.filter(ChannelValues.channel == channel)\
.filter(ChannelValues.sortingkey == sortingkey) \
.filter(ChannelValues.key == key) \
.one_or_none()
# ChannelValue exists, update
if result:
result.value = value
session.commit()
# DNE - Insert
else:
new_channelvalue = ChannelValues(channel=channel, sortingkey=sortingkey, key=key, value=value)
session.add(new_channelvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def get_channel_value(self, channel, key, sortingkey='unsorted'):
"""Retrieves the value for a given key associated with a channel."""
channel = Identifier(channel).lower()
session = self.ssession()
try:
result = session.query(ChannelValues) \
.filter(ChannelValues.channel == channel)\
.filter(ChannelValues.sortingkey == sortingkey) \
.filter(ChannelValues.key == key) \
.one_or_none()
if result is not None:
result = result.value
return _deserialize(result)
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def delete_channel_value(self, channel, key, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the channel."""
channel = Identifier(channel).lower()
session = self.ssession()
try:
result = session.query(ChannelValues) \
.filter(ChannelValues.channel == channel)\
.filter(ChannelValues.sortingkey == sortingkey) \
.filter(ChannelValues.key == key) \
.one_or_none()
# ChannelValue exists, delete
if result:
session.delete(result)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def adjust_channel_value(self, channel, key, value, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the channel."""
channel = Identifier(channel).lower()
value = json.dumps(value, ensure_ascii=False)
session = self.ssession()
try:
result = session.query(ChannelValues) \
.filter(ChannelValues.channel == channel)\
.filter(ChannelValues.sortingkey == sortingkey) \
.filter(ChannelValues.key == key) \
.one_or_none()
# ChannelValue exists, update
if result:
result.value = result.value + value
session.commit()
# DNE - Insert
else:
new_channelvalue = ChannelValues(channel=channel, sortingkey=sortingkey, key=key, value=value)
session.add(new_channelvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
# NICK AND CHANNEL FUNCTIONS
def get_nick_or_channel_value(self, name, key, sortingkey='unsorted'):
"""Gets the value `key` associated to the nick or channel `name`."""
name = Identifier(name)
if name.is_nick():
return self.get_nick_value(name, key, sortingkey)
else:
return self.get_channel_value(name, key, sortingkey)
def get_preferred_value(self, names, key, sortingkey='unsorted'):
"""Gets the value for the first name which has it set.
`names` is a list of channel and/or user names. Returns None if none of
the names have the key set."""
for name in names:
value = self.get_nick_or_channel_value(name, key, sortingkey)
if value is not None:
return value
# PLUGIN FUNCTIONS
def set_plugin_value(self, plugin, key, value, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the plugin."""
plugin = Identifier(plugin).lower()
value = json.dumps(value, ensure_ascii=False)
session = self.ssession()
try:
result = session.query(PluginValues) \
.filter(PluginValues.plugin == plugin)\
.filter(PluginValues.sortingkey == sortingkey) \
.filter(PluginValues.key == key) \
.one_or_none()
# PluginValues exists, update
if result:
result.value = value
session.commit()
# DNE - Insert
else:
new_pluginvalue = PluginValues(plugin=plugin, sortingkey=sortingkey, key=key, value=value)
session.add(new_pluginvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def get_plugin_value(self, plugin, key, sortingkey='unsorted'):
"""Retrieves the value for a given key associated with a plugin."""
plugin = Identifier(plugin).lower()
session = self.ssession()
try:
result = session.query(PluginValues) \
.filter(PluginValues.plugin == plugin)\
.filter(PluginValues.sortingkey == sortingkey) \
.filter(PluginValues.key == key) \
.one_or_none()
if result is not None:
result = result.value
return _deserialize(result)
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def adjust_plugin_value(self, plugin, key, value, sortingkey='unsorted'):
"""Sets the value for a given key to be associated with the plugin."""
plugin = Identifier(plugin).lower()
value = json.dumps(value, ensure_ascii=False)
session = self.ssession()
try:
result = session.query(PluginValues) \
.filter(PluginValues.plugin == plugin)\
.filter(PluginValues.sortingkey == sortingkey) \
.filter(PluginValues.key == key) \
.one_or_none()
# ChannelValue exists, update
if result:
result.value = result.value + value
session.commit()
# DNE - Insert
else:
new_pluginvalue = PluginValues(plugin=plugin, sortingkey=sortingkey, key=key, value=value)
session.add(new_pluginvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def delete_plugin_value(self, plugin, key, sortingkey='unsorted'):
"""Deletes the value for a given key to be associated with the plugin."""
plugin = Identifier(plugin).lower()
session = self.ssession()
try:
result = session.query(PluginValues) \
.filter(PluginValues.plugin == plugin)\
.filter(PluginValues.sortingkey == sortingkey) \
.filter(PluginValues.key == key) \
.one_or_none()
# PluginValues exists, delete
if result:
session.delete(result)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()

232
sopel_modules/SpiceBot_Database_Addons/Databaseaddons.py
View File

@ -1,232 +0,0 @@
#!/usr/bin/env python
# coding=utf-8
from __future__ import unicode_literals, absolute_import, print_function, division
# sopel imports
import sopel.module
from sopel.tools import Identifier
import sopel.db
from sopel.db import SopelDB, NickValues, ChannelValues, _deserialize
from sqlalchemy import Column, String
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.ext.declarative import declarative_base
import json
import sopel_modules.SpiceBot as SpiceBot
BASE = declarative_base()
def setup(bot):
# Inject Database Functions
SpiceBot.logs.log('SpiceBot_Databaseaddons', "Implanting Database functions into bot")
sopel.db.PluginValues = PluginValues
SopelDB.delete_nick_value = SopelDBAddon.delete_nick_value
SopelDB.adjust_nick_value = SopelDBAddon.adjust_nick_value
SopelDB.delete_channel_value = SopelDBAddon.delete_channel_value
SopelDB.adjust_channel_value = SopelDBAddon.adjust_channel_value
SopelDB.get_plugin_value = SopelDBAddon.get_plugin_value
SopelDB.set_plugin_value = SopelDBAddon.set_plugin_value
SopelDB.delete_plugin_value = SopelDBAddon.delete_plugin_value
SopelDB.adjust_plugin_value = SopelDBAddon.adjust_plugin_value
class PluginValues(BASE):
"""
PluginValues SQLAlchemy Class
"""
__tablename__ = 'plugin_values'
plugin = Column(String(255), primary_key=True)
key = Column(String(255), primary_key=True)
value = Column(String(255))
class SopelDBAddon:
"""Nicks"""
def delete_nick_value(self, nick, key):
"""Deletes the value for a given key to be associated with the nick."""
nick = Identifier(nick)
nick_id = self.get_nick_id(nick)
session = self.ssession()
try:
result = session.query(NickValues) \
.filter(NickValues.nick_id == nick_id) \
.filter(NickValues.key == key) \
.one_or_none()
# NickValue exists, delete
if result:
session.delete(result)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def adjust_nick_value(self, nick, key, value):
"""Sets the value for a given key to be associated with the nick."""
nick = Identifier(nick)
value = json.dumps(value, ensure_ascii=False)
nick_id = self.get_nick_id(nick)
session = self.ssession()
try:
result = session.query(NickValues) \
.filter(NickValues.nick_id == nick_id) \
.filter(NickValues.key == key) \
.one_or_none()
# NickValue exists, update
if result:
result.value = result.value + value
session.commit()
# DNE - Insert
else:
new_nickvalue = NickValues(nick_id=nick_id, key=key, value=value)
session.add(new_nickvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
"""Channels"""
def delete_channel_value(self, channel, key):
"""Sets the value for a given key to be associated with the channel."""
channel = Identifier(channel).lower()
session = self.ssession()
try:
result = session.query(ChannelValues) \
.filter(ChannelValues.channel == channel)\
.filter(ChannelValues.key == key) \
.one_or_none()
# ChannelValue exists, delete
if result:
session.delete(result)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def adjust_channel_value(self, channel, key, value):
"""Sets the value for a given key to be associated with the channel."""
channel = Identifier(channel).lower()
value = json.dumps(value, ensure_ascii=False)
session = self.ssession()
try:
result = session.query(ChannelValues) \
.filter(ChannelValues.channel == channel)\
.filter(ChannelValues.key == key) \
.one_or_none()
# ChannelValue exists, update
if result:
result.value = result.value + value
session.commit()
# DNE - Insert
else:
new_channelvalue = ChannelValues(channel=channel, key=key, value=value)
session.add(new_channelvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
# PLUGIN FUNCTIONS
def set_plugin_value(self, plugin, key, value):
"""Sets the value for a given key to be associated with the plugin."""
plugin = Identifier(plugin).lower()
value = json.dumps(value, ensure_ascii=False)
session = self.ssession()
try:
result = session.query(PluginValues) \
.filter(PluginValues.plugin == plugin)\
.filter(PluginValues.key == key) \
.one_or_none()
# PluginValues exists, update
if result:
result.value = value
session.commit()
# DNE - Insert
else:
new_pluginvalue = PluginValues(plugin=plugin, key=key, value=value)
session.add(new_pluginvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def get_plugin_value(self, plugin, key):
"""Retrieves the value for a given key associated with a plugin."""
plugin = Identifier(plugin).lower()
session = self.ssession()
try:
result = session.query(PluginValues) \
.filter(PluginValues.plugin == plugin)\
.filter(PluginValues.key == key) \
.one_or_none()
if result is not None:
result = result.value
return _deserialize(result)
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def adjust_plugin_value(self, plugin, key, value):
"""Sets the value for a given key to be associated with the plugin."""
plugin = Identifier(plugin).lower()
value = json.dumps(value, ensure_ascii=False)
session = self.ssession()
try:
result = session.query(PluginValues) \
.filter(PluginValues.plugin == plugin)\
.filter(PluginValues.key == key) \
.one_or_none()
# ChannelValue exists, update
if result:
result.value = result.value + value
session.commit()
# DNE - Insert
else:
new_pluginvalue = PluginValues(plugin=plugin, key=key, value=value)
session.add(new_pluginvalue)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def delete_plugin_value(self, plugin, key):
"""Deletes the value for a given key to be associated with the plugin."""
plugin = Identifier(plugin).lower()
session = self.ssession()
try:
result = session.query(PluginValues) \
.filter(PluginValues.plugin == plugin)\
.filter(PluginValues.key == key) \
.one_or_none()
# PluginValues exists, delete
if result:
session.delete(result)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()

6
sopel_modules/SpiceBot_Database_Addons/__init__.py
View File

@ -1,6 +0,0 @@
# coding=utf-8
"""Useful miscellaneous tools and shortcuts for SpiceBot Sopel modules
"""
from __future__ import unicode_literals, absolute_import, print_function, division
from .Databaseaddons import *