class SlackBot(ChatBot):
"""
params:
- slack_token(str):
"""
def __init__(self, slack_token, redis_host, redis_port):
print('Starting Slackbot')
self.slacksocket = SlackSocket(slack_token, event_filters=['message'])
self.me = self.slacksocket.user
print('Connected to Slack as %s' % self.me)
super().__init__(redis_host, redis_port)
@property
def messages(self):
for event in self.slacksocket.events():
log.debug('saw event %s' % event.json)
if self.me in event.mentions:
yield self._parse(event)
def reply(self, msg, channel):
# skip any empty messages
if not msg or msg == 'EOF':
return
# make codeblock if message is multiline
if isinstance(msg, list):
msg = '```' + '\n'.join(msg) + '```'
else:
msg = '`' + msg + '`'
self.slacksocket.send_msg(msg, channel_name=channel, confirm=False)
log.debug('sent "%s" to "%s"' % (msg, channel))
@staticmethod
def _parse(event):
"""
Parse slack event, removing @ mention
"""
words = event.event['text'].split(' ')
words.pop(0)
return (' '.join(words), event.event['user'], event.event['channel'])
def main():
# Get the default Slack channel from config
config = ConfigParser()
config.read('config.ini')
default_channel = config.get('slack', 'default_channel')
# Create a SlackSocket instance with select filters
event_filters = ['message']
s = SlackSocket(os.environ['SLACK_TOKEN'], translate=True, event_filters=event_filters)
# Try to create an instance of the bot
try:
botmod = eli5bot.BotMod(s)
except Exception as e:
msg = s.send_msg('Failed to start bot.\n Exception: %s' % e, channel_name=default_channel, confirm=False)
def notify():
teams = {}
with open('teams.pickle', 'rb') as f:
teams = pickle.load(f)
print(teams.keys())
for team_key in teams:
team = teams[team_key]
SLACK_TOKEN = ''
with open('tokens.pickle', 'rb') as f:
tokens = pickle.load(f)
print(tokens)
SLACK_TOKEN = tokens[team_key][0]
slack_socket = SlackSocket(SLACK_TOKEN, translate=True)
slack = Slacker(SLACK_TOKEN)
people = team['people']
channels = team['channels']
for key in people:
person = people[key]
print(person.name)
compute_person_channel_morale(slack, people, channels, person.name)
morale = person.morale
print(morale)
if type(morale) is float and morale < 0.15:
try:
res = slack.im.open(person._id)
c_id = res.body['channel']['id']
msg = slack_socket.send_msg(
'hey, you seem to be a bit down today. is everything alright?',
channel_id=c_id)
if msg.sent:
print('message sent to: ' + person.name)
except:
pass
def notify():
teams = {}
with open('teams.pickle', 'rb') as f:
teams = pickle.load(f)
print(teams.keys())
for team_key in teams:
team = teams[team_key]
SLACK_TOKEN = ''
with open('tokens.pickle', 'rb') as f:
tokens = pickle.load(f)
print(tokens)
SLACK_TOKEN = tokens[team_key][0]
slack_socket = SlackSocket(SLACK_TOKEN, translate=True)
slack = Slacker(SLACK_TOKEN)
people = team['people']
channels = team['channels']
for key in people:
person = people[key]
print(person.name)
compute_person_channel_morale(slack, people, channels, person.name)
morale = person.morale
print(morale)
if type(morale) is float and morale < 0.15:
try:
res = slack.im.open(person._id)
c_id = res.body['channel']['id']
msg = slack_socket.send_msg('hey, you seem to be a bit down today. is everything alright?', channel_id=c_id)
if msg.sent:
print('message sent to: ' + person.name)
except:
pass
import json
import env
from slacksocket import SlackSocket
from NWSData import AreaDiscussion
# translate will lookup and replace user and channel IDs with their
# human-readable names. default true.
s = SlackSocket(env.apikey, translate=True)
while True:
event = json.loads(s.get_event().json)
print(event['type'])
if event['type'] == 'message' and event['text'].split(' ', 1)[0].lower() == 'discussion':
print('dis')
try:
version = int(event['text'].split(' ', 1)[1])
print("args present")
except:
print("arts not present")
pass
d = AreaDiscussion(version=version)
message = "```" + d.returnDiscussion() + "```"
s.send_msg(message, "weather-test")
else:
pass
try:
s = SlackSocket(slackToken)
except:
import sys
import tools.shenanigans
if shenanigansState:
tools.shenanigans.enable()
tools.shenanigans.reboot()
else:
print "That token was invalid!"
sys.exit(2)
setPresence('auto')
s.send_msg("I'm combat ready!", debugChannel)
for event in s.events():
eventString = str(event.json)
if (eventString == '{}'):
reboot()
if (debugMode):
s.send_msg(eventString, debugChannel)
print(eventString)
if shenanigansState and('_left' in eventString):
import json
import tools.shenanigans
class GameMaster(object):
"""
Manages user sessions.
"""
def __init__(self, config):
# Slack config
slack_api_token = config.get('slack', 'api_token')
self._slack_username = config.get('slack', 'bot_username')
self._slack = SlackSocket(slack_api_token, translate=True)
self._slack_events = self._slack.events()
self._slack_sessions = {}
self._slack_event_handler = Thread(target=self._handle_slack_events,
name='event_handler')
# Frotz config
self._frotz_binary = config.get('frotz', 'path')
self._frotz_story_file = config.get('frotz', 'story')
# Logging config
self._logs_dir = config.get('frotzlack', 'logs_dir')
error_log_path = os.path.join(self._logs_dir, 'frotzlack.log')
self._global_handler = RotatingFileHandler(error_log_path)
self._global_handler.setLevel(logging.WARNING)
# Other config
self._admins = config.get('frotzlack', 'admins').split(',')
self._stop_requested = False
self._slack_event_handler.start()
def _event_is_game_input(self, event):
event_attrs = event.event
is_game_input = 'type' in event_attrs.keys() and \
event_attrs['type'] == 'message' and \
event_attrs['user'] in self._slack_sessions and \
event_attrs['user'] != self._slack_username and \
self._slack_username not in event.mentions and \
event_attrs['channel'] == event_attrs['user']
return is_game_input
def _event_is_command(self, event):
event_attrs = event.event
return 'type' in event_attrs.keys() and \
event_attrs['type'] == 'message' and \
self._slack_username in event.mentions
def _handle_game_input(self, user, game_input):
session = self._slack_sessions[user]
if game_input.strip() == 'save' or game_input.strip() == 'load':
session.send("Sorry, I can't save or load games yet.")
elif game_input.strip() == 'quit':
session.send("Sorry, I can't quit the game yet.")
else:
session.put(game_input)
def _start_session(self, username):
def send_msg(msg):
self._slack.send_msg(msg, channel_id=channel_id, confirm=False)
channel_id = self._slack.get_im_channel(username)['id']
session_logger = logging.getLogger(username)
session_logger.setLevel(logging.INFO)
session_log_path = os.path.join(self._logs_dir, username + '.log')
session_handler = RotatingFileHandler(session_log_path)
session_handler.setLevel(logging.INFO)
session_logger.addHandler(session_handler)
session_logger.addHandler(self._global_handler)
slack_session = SlackSession(send_msg, channel_id)
frotz_session = FrotzSession(self._frotz_binary,
self._frotz_story_file, session_logger)
self._slack_sessions[username] = slack_session
Session(slack_session, frotz_session)
def _reject_command(self, username, command):
channel = self._slack.get_im_channel(username)
message = "Sorry, I don't recognize the command `{0}`"
self._slack.send_msg(message.format(command), channel_id=channel['id'])
def _stop_server(self):
pool = ThreadPool()
for session in self._slack_sessions.values():
def polite_stop():
session.send("Sorry, the server is shutting down now.")
session.kill()
pool.apply_async(polite_stop)
pool.close()
pool.join()
self._stop_requested = True
def _handle_slack_events(self):
while not self._stop_requested:
event = self._slack_events.next()
event_attrs = event.event
if self._event_is_game_input(event):
msg = event_attrs['text']
self._handle_game_input(event_attrs['user'], msg)
elif self._event_is_command(event):
command = event_attrs['text']
user = event_attrs['user']
if 'stop' in command and user in self._admins:
self._stop_server()
elif 'play' in command:
self._start_session(user)
else:
self._reject_command(event_attrs['user'], command)
class GameMaster(object):
"""
Manages user sessions.
"""
def __init__(self, config):
# Slack config
slack_api_token = config.get('slack', 'api_token')
self._slack_username = config.get('slack', 'bot_username')
self._slack = SlackSocket(slack_api_token, translate=True)
self._slack_events = self._slack.events()
self._slack_sessions = {}
self._slack_event_handler = Thread(target=self._handle_slack_events,
name='event_handler')
# Frotz config
self._frotz_binary = config.get('frotz', 'path')
self._frotz_story_file = config.get('frotz', 'story')
# Logging config
self._logs_dir = config.get('frotzlack', 'logs_dir')
error_log_path = os.path.join(self._logs_dir, 'frotzlack.log')
self._global_handler = RotatingFileHandler(error_log_path)
self._global_handler.setLevel(logging.WARNING)
# Other config
self._admins = config.get('frotzlack', 'admins').split(',')
self._stop_requested = False
self._slack_event_handler.start()
def _event_is_game_input(self, event):
event_attrs = event.event
is_game_input = 'type' in event_attrs.keys() and \
event_attrs['type'] == 'message' and \
event_attrs['user'] in self._slack_sessions and \
event_attrs['user'] != self._slack_username and \
self._slack_username not in event.mentions and \
event_attrs['channel'] == event_attrs['user']
return is_game_input
def _event_is_command(self, event):
event_attrs = event.event
return 'type' in event_attrs.keys() and \
event_attrs['type'] == 'message' and \
self._slack_username in event.mentions
def _handle_game_input(self, user, game_input):
session = self._slack_sessions[user]
if game_input.strip() == 'save' or game_input.strip() == 'load':
session.send("Sorry, I can't save or load games yet.")
elif game_input.strip() == 'quit':
session.send("Sorry, I can't quit the game yet.")
else:
session.put(game_input)
def _start_session(self, username):
def send_msg(msg):
self._slack.send_msg(msg, channel_id=channel_id, confirm=False)
channel_id = self._slack.get_im_channel(username)['id']
session_logger = logging.getLogger(username)
session_logger.setLevel(logging.INFO)
session_log_path = os.path.join(self._logs_dir, username + '.log')
session_handler = RotatingFileHandler(session_log_path)
session_handler.setLevel(logging.INFO)
session_logger.addHandler(session_handler)
session_logger.addHandler(self._global_handler)
slack_session = SlackSession(send_msg, channel_id)
frotz_session = FrotzSession(self._frotz_binary,
self._frotz_story_file,
session_logger)
self._slack_sessions[username] = slack_session
Session(slack_session, frotz_session)
def _reject_command(self, username, command):
channel = self._slack.get_im_channel(username)
message = "Sorry, I don't recognize the command `{0}`"
self._slack.send_msg(message.format(command), channel_id=channel['id'])
def _stop_server(self):
pool = ThreadPool()
for session in self._slack_sessions.values():
def polite_stop():
session.send("Sorry, the server is shutting down now.")
session.kill()
pool.apply_async(polite_stop)
pool.close()
pool.join()
self._stop_requested = True
def _handle_slack_events(self):
while not self._stop_requested:
event = self._slack_events.next()
event_attrs = event.event
if self._event_is_game_input(event):
msg = event_attrs['text']
self._handle_game_input(event_attrs['user'], msg)
elif self._event_is_command(event):
command = event_attrs['text']
user = event_attrs['user']
if 'stop' in command and user in self._admins:
self._stop_server()
elif 'play' in command:
self._start_session(user)
else:
self._reject_command(event_attrs['user'], command)
def start_joy(team_id, bot_id):
SLACK_TOKEN = ''
with open('tokens.pickle', 'rb') as f:
tokens = pickle.load(f)
SLACK_TOKEN = tokens[team_id][0]
slack_socket = SlackSocket(SLACK_TOKEN, translate=True)
slack = Slacker(SLACK_TOKEN)
response = slack.channels.list()
channels = {}
for c in [u for u in response.body['channels']]:
name = c['name']
user_id = c['id']
channels[name] = Channel(name, user_id)
response = slack.users.list()
people = {}
for p in [u for u in response.body['members']]:
name = p['name']
user_id = p['id']
person = User(name, user_id)
if 'is_admin' in p:
person.manager = p['is_admin']
else:
person.manager = False
people[name] = person
print('starting joy on ' + team_id)
for event in slack_socket.events():
res = json.loads(event.json)
if 'team' in res and res['team'] == team_id and res['type'] == 'message' and 'user' in res and res['user'] != 'joy':
print(res)
team_id = res['team']
message = res['text']
user = res['user']
channel = res['channel']
timestamp = res['ts']
if bot_id in message:
if 'get morale' in message.lower():
t = message.lower().split('get morale ')
person = ''
if len(t) > 1:
person = t[1]
# print(person)
slack_socket.send_msg(str(compute_person_channel_morale(slack, people, channels, person)), channel_name=channel)
else:
slack_socket.send_msg(str(compute_team_morale(people)), channel_name=channel)
continue
res = tone_analyzer.tone(text=message)
emotional_tone = res['children'][0]
writing_tone = res['children'][1]
social_tone = res['children'][2]
cheerfulness = float(emotional_tone['children'][0]['normalized_score'])
negative = float(emotional_tone['children'][1]['normalized_score'])
anger = float(emotional_tone['children'][2]['normalized_score'])
analytical = float(writing_tone['children'][0]['normalized_score'])
confident = float(writing_tone['children'][1]['normalized_score'])
tentative = float(writing_tone['children'][2]['normalized_score'])
openness = float(social_tone['children'][0]['normalized_score'])
agreeableness = float(social_tone['children'][1]['normalized_score'])
conscientiousness = float(social_tone['children'][2]['normalized_score'])
sentiment = {
'cheerfulness' : [cheerfulness],
'negative' : [negative],
'anger' : [anger],
'analytical' : [analytical],
'confident' : [confident],
'tentative' : [tentative],
'openness' : [openness],
'agreeableness' : [agreeableness],
'conscientiousness' : [conscientiousness]
}
teams = {}
try:
with open('teams.pickle', 'rb') as f:
teams = pickle.load(f)
# print('load current teams: ' + str(teams.keys()))
except:
pass
if team_id in teams:
if channel in channels:
teams[team_id]['channels'][channel].add_sentiment(sentiment)
channels = teams[team_id]['channels']
if user in people:
teams[team_id]['people'][user].add_sentiment(sentiment)
people = teams[team_id]['people']
else:
d = {'channels' : channels, 'people' : people}
teams[team_id] = d
# print('saving ' + team_id)
# print('current teams: ' + str(teams.keys()))
with open('teams.pickle', 'wb') as f:
pickle.dump(teams, f)
