def test_delete_nick_value(db: SopelDB):
nick = 'TerryGilliam'
db.set_nick_value(nick, 'testkey', 'test-value')
# sanity check
assert db.get_nick_value(nick, 'testkey') == 'test-value', (
'Check set_nick_value: this key must contain the correct value.')
# delete key
db.delete_nick_value(nick, 'testkey')
assert db.get_nick_value(nick, 'testkey') is None
def fmtop(bot, trigger):
user = trigger.group(2)
api = bot.config.lastfm.api
if not user:
db = SopelDB(bot.config)
user = db.get_nick_value(trigger.nick, 'lastfm_user')
if not user:
bot.say('User not given or set. Use .fmset to set your user')
return
r = requests.get('http://ws.audioscrobbler.com/2.0/'
'?method=user.gettopartists&user={}&'
'api_key={}&format=json'
'&period=7day&limit=3'.format(user, api))
if 'topartists' not in r.json():
bot.say('User {} not found'.format(user))
return
if len(r.json()['topartists']['artist']) == 0:
bot.say('{} hasn\'t listened to any tracks yet'.format(user))
return
artists = ' * '.join(['{} ({})'.format(i['name'], i['playcount'])
for i in r.json()['topartists']['artist']])
out = '{}\'s top artists (7 days): {}'.format(user, artists)
bot.say(out)
def handle_quiz(bot, trigger):
if not bot.memory['quiz']:
return
quiz = bot.memory['quiz']
if quiz.question.attempt(trigger.args[1]) and not quiz.question.answered:
quiz.question.answered = True
bot.say(color('Correct! The answer was {}'.format(quiz.question.answer),
colors.GREEN))
quiz.award_user(trigger.nick, quiz.question.value
if bot.config.quiz.win_method == 'score' else 1)
score = bot.memory['quiz'].get_scores()[trigger.nick]
bot.say('{} has {} point{}!'.format(trigger.nick, score,
's' * (score > 1)))
if bot.config.quiz.win_method == 'points':
win_value = bot.config.quiz.points_to_win
else:
win_value = bot.config.quiz.score_to_win
if score >= win_value:
bot.say('{} is the winner!'.format(trigger.nick))
qscores(bot)
db = SopelDB(bot.config)
db_users = bot.config.quiz.db_users
if not db_users or quiz.starter in db_users:
wins = (db.get_nick_value(trigger.nick, 'quiz_wins') or 0) + 1
db.set_nick_value(trigger.nick, 'quiz_wins', wins)
bot.say('{} has won {} time{}'.format(trigger.nick, wins,
's' * (wins > 1)))
bot.memory['quiz'] = None
return
next_q(bot)
def traktstats(bot, trigger):
user = trigger.group(2)
if not user:
db = SopelDB(bot.config)
user = db.get_nick_value(trigger.nick, 'trakt_user')
if not user:
bot.say('User not given or set. Use .traktset to set your user')
return
stats_r = requests.get(bot.memory['trakt']['stats_url'].format(user),
headers=bot.memory['trakt']['headers'])
if stats_r.status_code == 404:
bot.say('User {} does not exist'.format(user))
return
ratings_r = requests.get(bot.memory['trakt']['r_url'].format(user),
headers=bot.memory['trakt']['headers'])
stats = stats_r.json()
ratings = ratings_r.json()
r_counter = Counter(i['rating'] for i in ratings)
ratings_dist = '/'.join(str(i) for i in r_counter.values())
meta = [user,
stats['movies']['watched'],
stats['shows']['watched'],
stats['episodes']['watched'],
sum(r_counter.values()),
ratings_dist]
out = ('{} has watched {} films and {} shows with {} episodes. They have '
'rated {} films with the following distribution: {}').format(*meta)
bot.say(out)
def fm(bot, trigger):
user = trigger.group(2)
api = bot.config.lastfm.api
if not user:
db = SopelDB(bot.config)
user = db.get_nick_value(trigger.nick, 'lastfm_user')
if not user:
bot.say('User not given or set. Use .fmset to set your user')
return
r = requests.get('http://ws.audioscrobbler.com/2.0/'
'?method=user.getrecenttracks&user={}&'
'api_key={}&format=json&limit=1'.format(user, api))
if 'recenttracks' not in r.json():
bot.say('User {} not found'.format(user))
return
if len(r.json()['recenttracks']['track']) == 0:
bot.say('{} hasn\'t listened to any tracks yet'.format(user))
return
last = r.json()['recenttracks']['track'][0]
if '@attr' in last and last['@attr']['nowplaying'] == 'true':
action = 'is listening to'
else:
action = 'last listened to'
meta = (user, action, last['artist']['#text'], last['name'],
last['album']['#text'])
out = '♫ {} {} {} - {} ({}) ♫'.format(*meta)
bot.say(out)
def twit(bot, trigger):
user = trigger.group(2)
if not user:
db = SopelDB(bot.config)
user = db.get_nick_value(trigger.nick, 'twit_user')
if not user:
bot.say('User not given or set. Use .twitset to set your user')
return
url = ('https://api.twitter.com/1.1/statuses/'
'user_timeline.json?screen_name={}').format(user)
response, content = bot.memory['twitter']['client'].request(url)
content_json = json.loads(content.decode('utf-8'))
if response['status'] == '401':
bot.say('User {}\'s tweets are private'.format(user))
return
if response['status'] == '404':
bot.say('User {} not found'.format(user))
return
last = content_json[0]
message = ('[Twitter] {last[text]} | {last[user][name]} '
'(@{last[user][screen_name]}) | {last[retweet_count]} RTs '
'| {last[favorite_count]} ♥s').format(last=last)
bot.say(message)
def test_get_nick_value(db: SopelDB, value):
nick = 'TerryGilliam'
nick_id = db.get_nick_id(nick, create=True)
with db.session() as session:
nick_value = NickValues(
nick_id=nick_id,
key='testkey',
value=json.dumps(value, ensure_ascii=False),
)
session.add(nick_value)
session.commit()
assert db.get_nick_value(nick, 'testkey') == value
assert db.get_nick_value(nick, 'otherkey') is None
assert db.get_nick_value('NotTestUser', 'testkey') is None, (
'This key must be defined for TerryGilliam only.')
def test_delete_nick_value_none(db: SopelDB):
"""Test method doesn't raise an error when there is nothing to delete."""
nick = 'TerryGilliam'
# this user doesn't even exist
db.delete_nick_value(nick, 'testkey')
assert db.get_nick_value(nick, 'testkey') is None, (
'Trying to delete a key must not create it.')
# create a key
db.set_nick_value(nick, 'otherkey', 'value')
# delete another key for that user
db.delete_nick_value(nick, 'testkey')
assert db.get_nick_value(nick, 'testkey') is None, (
'Trying to delete a key must not create it.')
# the nick still exists, and its key as well
assert db.get_nick_value(
nick,
'otherkey') == 'value', ('This key must not be deleted by error.')
def strava(bot, trigger):
db = SopelDB(bot.config)
strava_token = db.get_nick_value(trigger.nick, 'strava_token')
if not strava_token:
bot.say('Strava token not set. Use .stravaset (through PMs) to set')
return
client = stravalib.client.Client()
client.access_token = strava_token
action = trigger.group(2)
action_funs = {
'lastact': strava_lastact,
'bikes': strava_bikes,
'koms': strava_koms
}
action_fun = action_funs.get(action, strava_help)
action_fun(bot, trigger, client)
def godstats(bot, trigger):
god = trigger.group(2)
if not god:
db = SopelDB(bot.config)
god = db.get_nick_value(trigger.nick, 'god')
if not god:
bot.say('God not given or set. Use .godset to set your god')
return
r = requests.get('http://godvillegame.com/gods/api/{}.json'.format(god))
hero = r.json()
if 'clan' not in hero:
hero['clan'] = 'no clan'
hero['clan_position'] = 'member'
out = ('{h[godname]}\'s hero {h[name]}: '
'A level {h[level]} {h[alignment]} {h[gender]}, '
'{h[clan]} {h[clan_position]}, {h[arena_won]} arena wins, '
'{h[arena_lost]} arena losses. {h[motto]}.').format(h=hero)
bot.say(out)
def test_set_nick_value_update(db: SopelDB):
"""Test set_nick_value can update an existing value."""
db.set_nick_value('Pepperpots', 'testkey', 'first-value')
db.set_nick_value('Pepperpots', 'otherkey', 'other-value')
db.set_nick_value('Vikings', 'testkey', 'other-nick-value')
# sanity check: ensure every (nick, key, value) is correct
assert db.get_nick_value('Pepperpots', 'testkey') == 'first-value'
assert db.get_nick_value('Pepperpots', 'otherkey') == 'other-value'
assert db.get_nick_value('Vikings', 'testkey') == 'other-nick-value'
# update only one key
db.set_nick_value('Pepperpots', 'testkey', 'new-value')
# check new value while old values are still the same
assert db.get_nick_value('Pepperpots', 'testkey') == 'new-value'
assert db.get_nick_value('Pepperpots', 'otherkey') == 'other-value'
assert db.get_nick_value('Vikings', 'testkey') == 'other-nick-value'
def trakt(bot, trigger):
user = trigger.group(2)
if not user:
db = SopelDB(bot.config)
user = db.get_nick_value(trigger.nick, 'trakt_user')
if not user:
bot.say('User not given or set. Use .traktset to set your user')
return
r = requests.get(bot.memory['trakt']['hist_url'].format(user),
headers=bot.memory['trakt']['headers'])
if r.status_code == 404:
bot.say('User {} does not exist'.format(user))
return
if len(r.json()) == 0:
bot.say('User {} has no history'.format(user))
return
last = r.json()[0]
if last['type'] == 'episode':
meta = [user,
last['show']['title'],
last['episode']['season'],
last['episode']['number'],
last['episode']['title']]
out = '{} last watched: {} {}x{:02} - {}'.format(*meta)
elif last['type'] == 'movie':
meta = [user,
last['movie']['title'],
last['movie']['year']]
out = '{} last watched: {} ({})'.format(*meta)
bot.say(out)
def test_get_nick_value_default(db: SopelDB):
assert db.get_nick_value("TerryGilliam", "nokey") is None
assert db.get_nick_value("TerryGilliam", "nokey", "default") == "default"
def test_set_nick_value(db: SopelDB, value):
nick = 'Pepperpots'
db.set_nick_value(nick, 'testkey', value)
assert db.get_nick_value(nick, 'testkey') == value, (
'The value retrieved must be exactly what was stored.')
class BotDatabase():
def __init__(self):
SopelDB.nick_id_lock = threading.Lock()
sopel.db.NickIDs = NickIDs
sopel.db.Nicknames = Nicknames
sopel.db.NickValues = NickValues
SopelDB.get_nick_id = SpiceDB.get_nick_id
SopelDB.get_nick_value = SpiceDB.get_nick_value
SopelDB.set_nick_value = SpiceDB.set_nick_value
SopelDB.delete_nick_value = SpiceDB.delete_nick_value
SopelDB.adjust_nick_value = SpiceDB.adjust_nick_value
SopelDB.adjust_nick_list = SpiceDB.adjust_nick_list
sopel.db.ChannelValues = ChannelValues
SopelDB.get_channel_value = SpiceDB.get_channel_value
SopelDB.set_channel_value = SpiceDB.set_channel_value
SopelDB.delete_channel_value = SpiceDB.delete_channel_value
SopelDB.adjust_channel_value = SpiceDB.adjust_channel_value
SopelDB.adjust_channel_list = SpiceDB.adjust_channel_list
sopel.db.ServerValues = ServerValues
SopelDB.get_server_value = SpiceDB.get_server_value
SopelDB.set_server_value = SpiceDB.set_server_value
SopelDB.delete_server_value = SpiceDB.delete_server_value
SopelDB.adjust_server_value = SpiceDB.adjust_server_value
SopelDB.adjust_server_list = SpiceDB.adjust_server_list
sopel.db.PluginValues = PluginValues
SopelDB.get_plugin_value = SpiceDB.get_plugin_value
SopelDB.set_plugin_value = SpiceDB.set_plugin_value
SopelDB.delete_plugin_value = SpiceDB.delete_plugin_value
SopelDB.adjust_plugin_value = SpiceDB.adjust_plugin_value
SopelDB.adjust_plugin_list = SpiceDB.adjust_plugin_list
self.db = SopelDB(botconfig.config)
BASE.metadata.create_all(self.db.engine)
"""Nick"""
def get_nick_id(self, nick, create=True):
return self.db.get_nick_id(nick, create)
def alias_nick(self, nick, alias):
return self.db.alias_nick(nick, alias)
def unalias_nick(self, alias):
return self.db.unalias_nick(alias)
def check_nick_id(self, nick):
try:
self.db.get_nick_id(nick, create=False)
return True
except ValueError:
return False
def get_nick_value(self, nick, key, namespace='default'):
return self.db.get_nick_value(nick, key, namespace)
def set_nick_value(self, nick, key, value, namespace='default'):
return self.db.set_nick_value(nick, key, value, namespace)
def delete_nick_value(self, nick, key, namespace='default'):
return self.db.delete_nick_value(nick, key, namespace)
def adjust_nick_value(self, nick, key, value, namespace='default'):
return self.db.adjust_nick_value(nick, key, value, namespace)
def adjust_nick_list(self, nick, key, entries, adjustmentdirection, namespace='default'):
return self.db.adjust_nick_list(nick, key, entries, adjustmentdirection, namespace)
"""Bot"""
def get_bot_value(self, key, namespace='default'):
return self.db.get_nick_value(botconfig.nick, key, namespace)
def set_bot_value(self, key, value, namespace='default'):
return self.db.set_nick_value(botconfig.nick, key, value, namespace)
def delete_bot_value(self, key, namespace='default'):
return self.db.delete_nick_value(botconfig.nick, key, namespace)
def adjust_bot_value(self, key, value, namespace='default'):
return self.db.adjust_nick_value(botconfig.nick, key, value, namespace)
def adjust_bot_list(self, key, entries, adjustmentdirection, namespace='default'):
return self.db.adjust_nick_list(botconfig.nick, key, entries, adjustmentdirection, namespace)
"""Channels"""
def get_channel_value(self, channel, key, namespace='default'):
return self.db.get_channel_value(channel, key, namespace)
def set_channel_value(self, channel, key, value, namespace='default'):
return self.db.set_channel_value(channel, key, value, namespace)
def delete_channel_value(self, channel, key, namespace='default'):
return self.db.delete_channel_value(channel, key, namespace)
def adjust_channel_value(self, channel, key, value, namespace='default'):
return self.db.adjust_channel_value(channel, key, value, namespace)
def adjust_channel_list(self, nick, key, entries, adjustmentdirection, namespace='default'):
return self.db.adjust_channel_list(nick, key, entries, adjustmentdirection, namespace)
"""Servers"""
def get_server_value(self, _server, key, namespace='default'):
return self.db.get__server_value(_server, key, namespace)
def set__server_value(self, _server, key, value, namespace='default'):
return self.db.set__server_value(_server, key, value, namespace)
def delete__server_value(self, _server, key, namespace='default'):
return self.db.delete__server_value(_server, key, namespace)
def adjust__server_value(self, _server, key, value, namespace='default'):
return self.db.adjust__server_value(_server, key, value, namespace)
def adjust__server_list(self, nick, key, entries, adjustmentdirection, namespace='default'):
return self.db.adjust__server_list(nick, key, entries, adjustmentdirection, namespace)
"""Plugins"""
def get_plugin_value(self, plugin, key, namespace='default'):
return self.db.get_plugin_value(plugin, key, namespace)
def set_plugin_value(self, plugin, key, value, namespace='default'):
return self.db.set_plugin_value(plugin, key, value, namespace)
def delete_plugin_value(self, plugin, key, namespace='default'):
return self.db.delete_plugin_value(plugin, key, namespace)
def adjust_plugin_value(self, plugin, key, value, namespace='default'):
return self.db.adjust_plugin_value(plugin, key, value, namespace)
def adjust_plugin_list(self, plugin, key, entries, adjustmentdirection, namespace='default'):
return self.db.adjust_plugin_list(plugin, key, entries, adjustmentdirection, namespace)
class BotDatabase():
def __init__(self):
self.db = None
self.dict = {
"bot": {
"nick": None,
},
}
def initialize(self, config):
SopelDB.adjust_nick_value = SpiceDB.adjust_nick_value
SopelDB.adjust_nick_list = SpiceDB.adjust_nick_list
SopelDB.adjust_channel_value = SpiceDB.adjust_channel_value
SopelDB.adjust_channel_list = SpiceDB.adjust_channel_list
SopelDB.adjust_plugin_value = SpiceDB.adjust_plugin_value
SopelDB.adjust_plugin_list = SpiceDB.adjust_plugin_list
self.db = SopelDB(config)
BASE.metadata.create_all(self.db.engine)
self.dict["bot"]["nick"] = config.core.nick
def __getattr__(self, name):
''' will only get called for undefined attributes '''
if hasattr(self.db, name):
return eval("self.db." + name)
else:
return None
"""Nick"""
def adjust_nick_value(self, nick, key, value):
return self.db.adjust_nick_value(nick, key, value)
def adjust_nick_list(self, nick, key, entries, adjustmentdirection):
return self.db.adjust_nick_list(nick, key, entries,
adjustmentdirection)
"""Bot"""
def get_bot_value(self, key):
return self.db.get_nick_value(self.dict["bot"]["nick"], key)
def set_bot_value(self, key, value):
return self.db.set_nick_value(self.dict["bot"]["nick"], key, value)
def delete_bot_value(self, key):
return self.db.delete_nick_value(self.dict["bot"]["nick"], key)
def adjust_bot_value(self, key, value):
return self.db.adjust_nick_value(self.dict["bot"]["nick"], key, value)
def adjust_bot_list(self, key, entries, adjustmentdirection):
return self.db.adjust_nick_list(self.dict["bot"]["nick"], key, entries,
adjustmentdirection)
"""Channels"""
def adjust_channel_value(self, channel, key, value):
return self.db.adjust_channel_value(channel, key, value)
def adjust_channel_list(self, nick, key, entries, adjustmentdirection):
return self.db.adjust_channel_list(nick, key, entries,
adjustmentdirection)
"""Plugins"""
def adjust_plugin_value(self, plugin, key, value):
return self.db.adjust_plugin_value(plugin, key, value)
def adjust_plugin_list(self, plugin, key, entries, adjustmentdirection):
return self.db.adjust_plugin_list(plugin, key, entries,
adjustmentdirection)