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 __init__(self, debug=False):
"""Initializes our Slack bot and slack bot token. Will exit if the required environment
variable is not set.
"""
self._SLACK_BOT_TOKEN = os.environ.get("SLACK_BOT_TOKEN")
if self._SLACK_BOT_TOKEN is None:
sys.exit("ERROR: environment variable SLACK_BOT_TOKEN is not set")
self._slacker = Slacker(self._SLACK_BOT_TOKEN)
self._slackSocket = SlackSocket(self._SLACK_BOT_TOKEN, translate=False)
self._BOT_ID = self._slacker.auth.test().body["user_id"]
self._registrations = {
} # our dictionary of event_types to a list of callbacks
if debug:
print("DEBUG!")
logger.removeHandler(null_handler)
logger.addHandler(StreamHandler())
logger.setLevel(logging.DEBUG)
logger.info(
f"set bot id to {self._BOT_ID} with name {self.helper_user_id_to_user_name(self._BOT_ID)}"
)
logger.info("initialized")
def __init__(self, debug=False):
"""Initializes our Slack bot and slack bot token. Will exit if the required environment
variable is not set.
:param debug: Whether or not to use default a Logging config
"""
self._SLACK_BOT_TOKEN = os.environ['HERREN_TOKEN']
# self._SLACK_BOT_TOKEN = os.environ['TEST_TOKEN']
if self._SLACK_BOT_TOKEN is None:
sys.exit("ERROR: environment variable SLACK_BOT_TOKEN is not set")
self._slacker = Slacker(self._SLACK_BOT_TOKEN)
self._slackSocket = SlackSocket(self._SLACK_BOT_TOKEN, translate=False)
self._BOT_ID = self._slacker.auth.test().body["user_id"]
self._registrations = {
} # our dictionary of event_types to a list of callbacks
if debug:
# Enable logging for our users
logger.addHandler(StreamHandler())
logger.setLevel(logging.DEBUG)
logger.info(
f"set bot id to {self._BOT_ID} with name {self.helper_user_id_to_user_name(self._BOT_ID)}"
)
logger.info("initialized")
def monitor_new_slack(self, team):
s = SlackSocket(team.bot_access_token,
translate=False,
event_filters=['message'])
t = Thread(name="Slackmonitor, team: " + team.team_name,
target=self.monitor_slack_events,
args=[s, team.access_token, team.team_name])
t.start()
def __init__(self, config):
self.s = SlackSocket(config['slack'].get('token'))
# Is this a good way to handle mongo connection? Seems weird.
# TODO check for connection timeout
self.mongo = mongoengine
self.mongo.connect(config['mongo'].get('db'),
host=config['mongo'].get('host'),
port=config['mongo'].getint('port'))
def monitor_all_slacks(self):
for team in self.config.teams:
s = SlackSocket(team.bot_access_token,
translate=False,
event_filters=['message'])
t = Thread(name="Slackmonitor, team: " + team.team_name,
target=self.monitor_slack_events,
args=[s, team.access_token, team.team_name])
t.start()
def connect(self):
logger.info("Connecting...")
self._slacker = Slacker(self._SLACK_BOT_TOKEN)
self._slackSocket = SlackSocket(self._SLACK_BOT_TOKEN, translate=False)
self._BOT_ID = self._slacker.auth.test().body["user_id"]
self._registrations = {
} # our dictionary of event_types to a list of callbacks
logger.info(
f"Connected. Set bot id to {self._BOT_ID} with name {self.helper_user_id_to_user_name(self._BOT_ID)}"
)
def connect(self):
"""Connect to underlying SlackSocket.
Additionally stores conections for future usage.
"""
# Disable all the attribute-defined-out-init in this function
# pylint: disable=attribute-defined-outside-init
logger.info("Connecting...")
self._python_slackclient = WebClient(self._slack_bot_token)
self._slack_socket = SlackSocket(self._slack_bot_token)
self._bot_id = self._python_slackclient.auth_test()["bot_id"]
logger.info(
"Connected. Set bot id to %s with name %s",
self._bot_id,
self.helper_user_id_to_user_name(self._bot_id),
)
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 time
import json
import re
import traceback
import requests
import threading
from slacksocket import SlackSocket
from slackclient import SlackClient
from block_io import BlockIo
version = 2 # API version
from key_pin import *
block_io_doge = BlockIo(blockio_api_doge_key, blockio_secret_pin, version)
block_io_btc = BlockIo(blockio_api_btc_key, blockio_secret_pin, version)
block_io_ltc = BlockIo(blockio_api_ltc_key, blockio_secret_pin, version)
ss = SlackSocket(slack_token,translate=False) # translate will lookup and replace user and channel IDs with their human-readable names. default true.
sc = SlackClient(slack_token)
url = 'https://shapeshift.io/shift'
coincap_doge = 'http://www.coincap.io/page/DOGE'
coincap_btc = 'http://www.coincap.io/page/BTC'
coincap_ltc = 'http://www.coincap.io/page/LTC'
cryptocomp_doge = 'https://www.cryptocompare.com/api/data/price?fsym=DOGE&tsyms=USD'
cryptocomp_btc = 'https://www.cryptocompare.com/api/data/price?fsym=BTC&tsyms=USD'
cryptocomp_ltc = 'https://www.cryptocompare.com/api/data/price?fsym=LTC&tsyms=USD'
shapeshift_pubkey = "06c04cfc9f18632d50ca546ba4f3dc49edcaf6217e3cefe73ed98d92cc2f37e764df8371fc3d23847aee4a4d65bdaa2defd30ca43311378827a94146feb017cb"
min_amount = {'doge': 2.0, 'ltc': 0.002, 'btc': 0.0002}
def main():
time.sleep(1)
for event in ss.events():
j = json.loads(event.json)
if j['type'] != 'message':
readSuccess = False
if readSuccess:
if "<@U1ES5EE1J|cleverbot>" in msg:
output = respondToMessage(msg, data)
output += "\nSUCCESS: Got message and responded!\n"
elif "<@U1ES5EE1J>" in msg:
output = respondToMessage(msg, data)
output += "\nSUCCESS: Got message and responded!\n"
else:
output = "\nERROR: Cleverbot not called in msg: " + msg + "\n"
print(output)
else:
output = "\nERROR:: Could not read message body. Cleverbot might " \
"have been mentioned by a status change\n"
# Logging
with open('./log.txt', 'a') as f:
f.write(output)
time.sleep(1)
# -------------------------------------------------------------------
# START IT!
token = slacktools.getSlackToken()
sc = SlackSocket(token, translate=True)
cleverbot = cb()
go()
import json
import os
import sys
from slacksocket import SlackSocket
SLACK_API_KEY = os.environ["SLACK_API_KEY"]
s = SlackSocket(SLACK_API_KEY)
def mainloop():
for event in s.events():
obj = json.loads(event.json)
if not obj["type"] == "message":
continue
user = obj["user"]
message = obj["text"]
channel = obj["channel"]
if 'VEP' not in message.upper():
continue
reply_text = "@{} Pythonはいいぞ！".format(user)
if __debug__:
print(reply_text)
else:
try:
def helpme():
return "+ = Snelheid verhogen\n- = Snelheid verlagen\n} = Pitch verhogen\n{ = Pitch verlagen\n] = Volume verhogen (Nee Tim)\n[ = Volume verlagen\n$ = Achterstevoren afspelen\n~ = Kill all\n& = Heen en weer"
async def handler(fplayer, bplayer, tplayer):
while True:
log.debug("in handler loop")
event = await s.get_event_aio()
log.debug("processing: " + event.json)
data = json.loads(event.json)
log.debug("data type: " + data['type'])
log.debug("text in data: " + str('text' in data))
if event.event.get(
'channel') == config.slack_channel and event.event.get(
'type') == 'message':
handle_cmd(event.event.get('text'), event.event.get('user'),
fplayer, bplayer, tplayer)
soundq_fore = AiterQueue()
soundq_back = AiterQueue()
soundq_third = AiterQueue()
s = SlackSocket(config.api_key, asyncio.get_event_loop(), translate=True)
fplayer = asyncio.get_event_loop().create_task(playsounds(soundq_fore))
bplayer = asyncio.get_event_loop().create_task(playsounds(soundq_back))
tplayer = asyncio.get_event_loop().create_task(playsounds(soundq_third))
asyncio.get_event_loop().run_until_complete(handler(fplayer, bplayer, tplayer))
