def create_slack_client(token):
slack_client = SlackClient(token)
if not slack_client.rtm_connect():
raise Exception('Cannot connect to Slack')
clients.slack = slack_client
tokens.slack = token
return slack_client
def handle_event(event: dict, channel: str, channel_id: str, message: str,
sc: SlackClient, logger: logging.Logger) -> None:
pretty_event = pformat(event)
logger.debug(f"Event received:\n{pretty_event}")
subtype = event.get('subtype')
user = event.get('user')
if subtype in ('group_join', 'channel_join') and user:
# We will use the event's channel ID to send a response and refer to
# users by their display_name in accordance with new guidelines.
# https://api.slack.com/changelog/2017-09-the-one-about-usernames
event_channel_id = event.get('channel')
user_profile = event.get('user_profile')
username = user_profile.get('display_name')
user_mention = f"<@{user}>"
message = message.replace('{user}', user_mention)
if event_channel_id == channel_id:
try:
sc.rtm_send_message(event_channel_id, message)
logger.info(f"Welcomed {username} to #{channel}")
except AttributeError:
logger.error(f"Couldn't send message to #{channel}")
def slack():
logs.write("In slack function in new thread", 'working')
sc = SlackClient(token)
if sc.rtm_connect():
logs.write("Connected to rtm socket", 'success')
while True:
time.sleep(0.1)
message=sc.rtm_read()
if message!=[]:
if message[0].keys()[0]=='text':
command=message[0].values()[0]
logs.write(command,'working')
try:
command=json.loads(command)
except ValueError:
command=[{'type':'command'},{'devices':'all'},{'action':"{0}".format(command)}]
commandtype=command[0]
devices=command[1]
action=command[2]
if devices.values()[0]=='all' or devices.values()[0]=="XPS":
logs.write("Checking local W.I.L.L server", 'trying')
answer=requests.get('http://127.0.0.1:5000/?context=command&command={0}'.format(action.values()[0])).text
print sc.api_call( "chat.postMessage", channel="#w_i_l_l", text="{0}".format(answer), username='******')
else:
logs.write("Connection Failed, invalid token?", 'error')
def get_slack_users():
'''Gets all users from slack and returns a list of users, each as a dictionary'''
sc = SlackClient(TOKEN)
members = sc.api_call("users.list")['members']
slack_users = []
for member in members:
slack_id = member['id']
slack_deleted = member['deleted']
slack_name = member['name']
slack_status = member['status']
slack_first_name = member['profile']['first_name']
slack_last_name = member['profile']['last_name']
slack_real_name = member['profile']['real_name']
slack_real_name_normalized = member['profile']['real_name_normalized']
slack_email = member['profile']['email']
slack_user = {'slack_id': slack_id,
'slack_deleted': slack_deleted,
'slack_name': slack_name,
'slack_status': slack_status,
'slack_first_name': slack_first_name,
'slack_last_name': slack_last_name,
'slack_real_name': slack_real_name,
'slack_real_name_normalized': slack_real_name_normalized,
'slack_email': slack_email}
slack_users.append(slack_user)
return slack_users
def _register_deployment():
branch = local('git rev-parse --abbrev-ref HEAD', capture=True)
author = local('git log -1 --pretty=format:"%an"', capture=True)
commit = local('git log -1 --pretty=format:"%B"', capture=True)
git_url = f'https://github.com/CDE-UNIBE/qcat/tree/{branch}'
sc = SlackClient(settings.SLACK_TOKEN)
sc.api_call(
'chat.postMessage',
channel='server-info',
username='******',
text=f'Branch "{branch}" deployed: {git_url}',
attachments=[
{
'pretext': f'Great success!',
'title': commit,
'title_link': git_url,
'fields': [
{
'title': 'Branch',
'value': 'develop',
'short': False
},
{
'title': 'Author',
'value': author,
'short': False
}
],
'image_url': 'https://qcat.wocat.net/static/assets/favicons/favicon-32x32.png'
}
]
)
class SlackMediator(object):
def __init__(self, token):
self.token = token
self.slack_client = SlackClient(self.token)
self.time_keeper = _TimeKeeper()
def time_keeping(self):
self.time_keeper.reset()
return iter(self.time_keeper)
def wait(self):
self.time_keeper.wait()
def read(self):
return self.slack_client.rtm_read()
def send(self, output, wait_itr):
channel_id, message = output
channel = self.find_channel(channel_id)
if channel is not None and message is not None:
next(wait_itr)
channel.send_message(message)
def ping(self):
return self.slack_client.server.ping()
def find_channel(self, name):
return self.slack_client.server.channels.find(name)
def connect(self):
"""Convenience method that creates Server instance"""
logger.info("connect to slack ..")
self.slack_client.rtm_connect()
class Slack:
def __init__(self, config, token_file):
self.disabled = True
try:
from slackclient import SlackClient
except:
return
try:
self.channel = config['channel']
self.method = config['method']
self.username = config['username']
self.emoji = config['emoji']
except (TypeError, KeyError) as e:
return
try:
with open(token_file) as stoken:
r = stoken.readlines()
slack_token = ''.join(r).strip()
self.client = SlackClient(slack_token)
except IOError:
return
self.disabled = False
def api_call(self, text):
if not self.disabled:
self.client.api_call(self.method, channel=self.channel,
username=self.username, icon_emoji=self.emoji, text=text)
print ("Your current configuration for slack notifications is deprecated! Please switch to latest configuration.")
def sendSlackAlert(token, channel, username, *args): sc = SlackClient(token) sc.api_call( "chat.postMessage", channel=str(channel), text=args[0] + "\n", username=str(username))
def send_message(channel, message, username):
slack_token = os.environ.get('SLACK_API_TOKEN')
client = SlackClient(slack_token)
client.api_call(
'chat.postMessage',
channel=channel, text=message, username=username
)
class Output(cowrie.core.output.Output):
def __init__(self):
self.slack_channel = CONFIG.get('output_slack', 'channel')
self.slack_token = CONFIG.get('output_slack', 'token')
cowrie.core.output.Output.__init__(self)
def start(self):
pass
def stop(self):
pass
def write(self, logentry):
for i in list(logentry.keys()):
# Remove twisted 15 legacy keys
if i.startswith('log_'):
del logentry[i]
self.sc = SlackClient(self.slack_token)
self.sc.api_call(
"chat.postMessage",
channel=self.slack_channel,
text="%s %s" % (time.strftime('%Y-%m-%d %H:%M:%S'), json.dumps(logentry, indent=4, sort_keys=True))
)
class Utils:
def __init__(self):
self.sc = SlackClient(token)
def send(self, chan, message):
"""Print to chat function using the slackclient api"""
self.sc.api_call("chat.postMessage", channel = chan, text = "`" + message + "`", icon_emoji=':robot_face:')
def whisper(self, message):
return message
def is_empty_input(param, self):
"""Check parameters to see if it is empty"""
param = request.args.get("text")
if param is None:
self.help()
return True
return False
def is_user_online(self, username):
"""Grats the user_ID (U123456789) via username"""
data = self.sc.api_call("users.list", presence='1')
try:
for key in data['members']:
if key['name'] == username:
return key['presence']
except:
pass
return None
def slack_upload(fname, title=None, channel=CONF['alerts_channel'],
token=SLACK_BOT_TOKEN):
"""Upload a file to a channel
Args:
fname (str): Filepath
title (str, optional): Title of the file. Defaults to fname
channel (str): Channel id. Defaults to alerts_channel specified in
private.yml
token (str): Token to use with SlackClient. Defaults to bot_token
specified in private.yml
Returns:
dict: Slack response object
"""
if title is None:
title = os.path.basename(fname)
slack_client = SlackClient(token)
response = slack_client.api_call(
"files.upload",
channels=channel,
filename=fname,
file=open(fname, 'rb'),
title=title
)
return response
class RtmBot(object):
def __init__(self, token):
self.last_ping = 0
self.token = token
self.bot_plugins = []
self.slack_client = None
self.exit = False
def connect(self):
"""Convenience method that creates Server instance"""
self.slack_client = SlackClient(self.token)
self.slack_client.rtm_connect()
def start(self):
self.connect()
self.load_plugins()
while True and not self.exit:
for reply in self.slack_client.rtm_read():
self.input(reply)
self.crons()
self.output()
self.autoping()
time.sleep(.1)
def autoping(self):
#hardcode the interval to 3 seconds
now = int(time.time())
if now > self.last_ping + 3:
self.slack_client.server.ping()
self.last_ping = now
def input(self, data):
if "type" in data:
function_name = "process_" + data["type"]
dbg("got {}".format(function_name))
for plugin in self.bot_plugins:
plugin.register_jobs()
plugin.do(function_name, data)
def output(self):
for plugin in self.bot_plugins:
if plugin.name == 'robbie':
self.exit = plugin.exit
limiter = False
for output in plugin.do_output():
channel = self.slack_client.server.channels.find(output[0])
if channel != None and output[1] != None:
if limiter == True:
time.sleep(.1)
limiter = False
message = output[1].encode('utf-8','ignore')
channel.send_message("{}".format(message))
limiter = True
def crons(self):
for plugin in self.bot_plugins:
plugin.do_jobs()
def load_plugins(self):
for plugin in glob.glob(directory+'/plugins/*'):
sys.path.insert(0, plugin)
sys.path.insert(0, directory+'/plugins/')
for plugin in glob.glob(directory+'/plugins/*.py') + glob.glob(directory+'/plugins/*/*.py'):
logging.info(plugin)
name = plugin.split('/')[-1][:-3]
# try:
self.bot_plugins.append(Plugin(name))
def slack_notifier(slack_token, secret_conf_path, server, user, password, build_url):
branches = run_command("git branch")
branch_name_reg = re.search("\* (.*)", branches)
branch_name = branch_name_reg.group(1)
if branch_name == 'master':
print_color("Starting Slack notifications about instances", LOG_COLORS.GREEN)
attachments, integrations_counter = get_attachments(secret_conf_path, server, user, password, build_url)
sc = SlackClient(slack_token)
sc.api_call(
"chat.postMessage",
channel="devops-events",
username="******",
as_user="******",
attachments=attachments,
text="You have {0} instances configurations".format(integrations_counter)
)
sc.api_call(
"chat.postMessage",
channel="content-lab-tests",
username="******",
as_user="******",
attachments=attachments,
text="You have {0} instances configurations".format(integrations_counter)
)
def slack_post(message, channel=CONF['alerts_channel'],
token=SLACK_BOT_TOKEN):
"""Post a message to a channel
Args:
message (str): Message to post
channel (str): Channel id. Defaults to alerts_channel specified in
private.yml
token (str): Token to use with SlackClient. Defaults to bot_token
specified in private.yml
"""
LOGGER.debug("Posting to slack")
slack_client = SlackClient(token)
response = slack_client.api_call(
"chat.postMessage",
as_user=True,
channel=channel,
text=message
)
if response['ok']:
LOGGER.info('Posted succesfully')
else:
LOGGER.error('Unable to post, response: %s', response)
return
def marcopolo_bot():
# Insert API token from Slack
# My token was disabled as soon as I uploaded it to Git, another token must be generated
token = 'xoxb-55268990450-WzfkM0A5ufihTTElZ8k6sC33'
# Creating the slackclient object/instance
sc = SlackClient(token)
# Connect to Slack
if sc.rtm_connect():
while True:
# Read latest messages as long as connected to Slack
rtm_responses = sc.rtm_read()
# Check every instance of potential response and check for text response
for rtm_response in rtm_responses:
if 'text' in rtm_response:
# If response is found as 'marco', call API function to respond with 'polo'
if rtm_response['text'] == 'marco':
sc.api_call(
"chat.postMessage", channel="marco-polo", text="polo",
username='******', icon_emoji=':robot_face:'
)
time.sleep(1)
else:
quit()
class TachikomaFrontend(pykka.ThreadingActor, CoreListener):
def new_slack_client(self):
self.sc = SlackClient(self.slackToken)
if not self.sc.rtm_connect():
raise Exception("Bad Slack token?")
logger.info("New Slack client started")
def __init__(self, config, core):
super(TachikomaFrontend, self).__init__()
self.daemon = True
self.slackToken = config['tachikoma']['slack_token'],
self.core = core
self.new_slack_client()
thread.start_new_thread(self.doSlack, ())
def doSlackRead(self, last_track_told):
try:
items = self.sc.rtm_read()
except Exception, e:
logger.info("Exception from Slack: %r", e)
time.sleep(1)
self.new_slack_client()
return last_track_told
logger.debug("info %r", items)
if items != []:
try:
current_track = self.core.playback.get_current_track().get(3)
except pykka.Timeout, e:
logger.warning("Failure to get current track: %r", e)
current_track = None
return self.doSlackLoop(last_track_told, current_track, items)
class SlackAPI(object):
def __init__(self, token, username="******"):
self.client = SlackClient(token)
self._all_channels = self._get_channels()
self.username = username
def _get_channels(self):
res = self.client.api_call("channels.list")
_channels = json.loads(res.decode())
_parsed_channels = _channels.get("channels", None)
if _parsed_channels is None:
raise Exception("Could not get Slack channels. Are you sure your token is correct?")
return _parsed_channels
def get_channels(self, reload_channels=False):
if not self._all_channels or reload_channels:
self._all_channels = self._get_channels()
return self._all_channels
def channel_name_to_id(self, channel_name):
for channel in self._all_channels:
if channel["name"] == channel_name:
return channel["id"]
raise ChannelNotFoundError("Channel {} not in the list of available channels".format(channel_name))
def bulk_message(self, message, post_to=[]):
for channel in post_to:
if not channel.startswith("@"):
channel = self.channel_name_to_id(channel)
logging.debug("Posting message to {}".format(channel))
self.client.api_call("chat.postMessage", text=message, channel=channel, username=self.username)
return True
def connect(self, inLegalSlack):
"""
Connects to the Slack Real Time Messaging (RTM) API.
"""
if inLegalSlack:
self.client = SlackClient(self.human_token)
else:
self.client = SlackClient(self.bot_token)
self.client.rtm_connect()
self.username = self.client.server.username
response = self.client.api_call(method="im.list").decode("utf-8")
response = json.loads(response)
# debug
directIDList = []
for imObj in response["ims"]:
directIDList.append(imObj["id"])
self.directChannelList = directIDList
userObjects = self.client.api_call(method="users.list").decode("utf-8") # list all users in slack w/API call
userObjects = json.loads(userObjects)
if userObjects["ok"]:
for user in userObjects["members"]:
self.conversationList.append(Conversation(user["name"], user["id"]))
class BasicSlackClient:
"""
Basic slack client.git
"""
def __init__(self, token: str, default_channel: str, default_username: str):
"""
Constructor.
:param token: authentication tocken from BasicSlackClient
"""
self._default_channel = default_channel
self._default_username = default_username
self._slack_client = SlackClient(token)
def post(self, message: str, channel: str=None, username: str=None):
"""
Post the given message to the given channel as the given username.
:param message: the message to post
:param channel: the channel to post to
:param username: the username to post as
"""
if channel is None:
channel = self._default_channel
if username is None:
username = self._default_username
self._slack_client.api_call(_SLACK_CLIENT_POST_MESSAGE, channel=channel, text=message, username=username)
def postNotification(token, channelID, service, calendar, timePeriod):
events = []
message = ""
sc = SlackClient(token)
if timePeriod == "today":
events = get_todays_events(token, channelID, service, calendar)
elif timePeriod == "this week":
events = get_weeks_events(token, channelID, service, calendar)
elif timePeriod == "this month":
events = get_months_events(token, channelID,service, calendar)
if not events:
period = "*_No events scheduled for " + timePeriod + " :sleepy: _*\n"
for event in events:
period = "*_Here are the events happening " + timePeriod + " :smile: _*\n"
period = period.encode('utf-8')
start_date = dateutil.parser.parse(event['start'].get('dateTime'))
start_date = start_date.strftime("%A, %B %d %Y @ %I:%M %p")
end_date = dateutil.parser.parse(event['end'].get('dateTime'))
end_date = end_date.strftime("%A, %B %d %Y @ %I:%M %p")
message += "\n - " + "*" + event['summary'] + "*" + "\n"+ start_date + " to " + end_date + "\n" + "*Where:* " + event['location'] + "\n" + "*Description:* " + event['description'] + "\n" + event['htmlLink'] + "\n"
message = message.encode('utf-8')
sc.api_call("chat.postMessage",username="******",channel=channelID,text=period + message)
def router():
_logger = get_logger(__name__)
if request.form.get("token") == os.environ.get("SLACK_WEBHOOK_SECRET"):
# Get info from incoming request
channel_id = request.form.get("channel_id")
user = request.form.get("user_name")
message = request.form.get("text")
_logger.info("Incoming message from {0} on {1}: {2}".format(channel_id, user, message))
# Parse and route
try:
response = parse_message(message, user)
except Exception as e:
response = fail(e, user)
slack_client = SlackClient(os.environ.get("SLACK_TOKEN"))
slack_client.api_call(
"chat.postMessage",
channel=channel_id,
username='******',
icon_emoji=':sausage:',
**response
)
return Response(), 200
class SlackThread(threading.Thread):
def __init__(self, queue, config):
super(SlackThread, self).__init__()
self.daemon = True
self.queue = queue
self._config = config
self.conn = None
def run(self):
try:
print 'Connecting to slack'
self.conn = SlackClient(self._config['token'])
if not self.conn.rtm_connect():
return
self.parseLoginData(self.conn.server.login_data)
print 'Connected to slack'
self.conn.server.websocket.sock.setblocking(True)
while True:
for event in self.conn.rtm_read():
self.queue.put({'type': 'slack.event', 'data': event})
except Exception as e:
print 'SLACK RUNLOOP ERROR: %s' % e
self.conn = None
def parseLoginData(self, loginData):
for user in loginData.get('users', []):
if user.get('deleted', False):
continue
if user.get('is_bot', False):
continue
self.queue.put({'type': 'slack.join', 'data': {'id': user['id'], 'name': user['name']}})
def check(self):
sc = SlackClient(self.config["bot"]["token"])
history = sc.api_call("channels.history", channel=self.config["bot"]["channel"], oldest=self.lastcheck )
botname = "%s" % self.config["bot"]["name"]
#sometimes there are no messages!
if "messages" in history:
for message in history["messages"]:
if botname in message["text"]:
timestamp = message["ts"]
command = message["text"].split(" ")
if command[1] == self.config["hostname"]:
if command[2] == "df":
self._action_df()
self._set_lastcheck(timestamp)
elif command[2] == "mem":
self._action_mem()
self._set_lastcheck(timestamp)
elif command[2] == "top":
self._action_top()
self._set_lastcheck(timestamp)
else:
self._send_message("I don't know what this action is '%s'. Supported actions: df, mem, top" % command[2])
sc.api_call("chat.postMessage", as_user="******", channel=self.config["bot"]["channel"], text="I don't know what this action is '%s'. Supported actions: df, mem, top" % command[2])
self._set_lastcheck(timestamp)
elif command[1] == "rollcall":
self._send_message("%s on %s reporting in" % (self.config["bot"]["name"], self.config["hostname"]))
def main(args):
global sc
for i in range(NUM_WORKERS):
t = threading.Thread(target=worker)
t.daemon = True
t.start()
for n in range(NUM_TRY):
sc = SlackClient(TOKEN)
if sc.rtm_connect():
while True:
try:
records = sc.rtm_read()
except:
print "接続が切断されました。再接続します。試行回数: %d" % (n + 1)
break
for record in records:
if "file" in record:
fileinfo = record["file"]["id"]
filedata = sc.api_call("files.info", file=fileinfo)
if fileinfo not in memo:
q.put(filedata["file"])
memo.append(fileinfo)
time.sleep(WAIT_TIME)
else:
print "接続に失敗しました。TOKENが間違っていませんか?"
time.sleep(60)
def bot():
try:
slack_client = SlackClient(token=config["slack"]["token"])
slack_client.rtm_connect()
bot_info = json.loads(slack_client.api_call("auth.test").decode("utf-8"))
last_ping = 0
cache_emoji_list(slack_client)
while True:
last_ping = autoping(slack_client, last_ping)
process_queued_responses(slack_client)
for event in slack_client.rtm_read():
print(event)
event_type = event.get("type")
if event_type == "message":
process_message_event(slack_client, bot_info, event)
time.sleep(0.1)
except KeyboardInterrupt:
sys.exit(0)
def post_message(self):
sc = SlackClient(self.token)
print sc.api_call("api.test")
sc.api_call(
"chat.postMessage", channel="#general", text="Hello from Python! :tada:",
username=self.username, as_user="******", icon_emoji=':robot_face:'
)
class SlackROS():
# Must have __init__(self) function for a class, similar to a C++ class constructor.
def __init__(self):
# Get the ~private namespace parameters from command line or launch file.
self.token = rospy.get_param('~token', 'xoxp-123456789')
self.channel = rospy.get_param('~channel', 'G1234567Q')
self.username = rospy.get_param('~username', 'ros-bot')
# Create a publisher for our custom message.
pub = rospy.Publisher('from_slack_to_ros', String, queue_size=10)
rospy.Subscriber("from_ros_to_slack", String, self.callback)
# Create the slack client
self.sc = SlackClient(self.token)
if self.sc.rtm_connect():
# Main while loop.
while not rospy.is_shutdown():
for reply in self.sc.rtm_read():
if "type" in reply and "user" in reply:
#print reply
if reply["type"] == "message" and reply["channel"] == self.channel:
pub.publish(reply["text"])
# Sleep for a while before publishing new messages. Division is so rate != period.
rospy.sleep(2.0)
def callback(self, data):
self.sc.api_call(
"chat.postMessage", channel=self.channel, text=data.data,
username=self.username, icon_emoji=':robot_face:'
)
def main(self):
token = os.environ.get("SLACK_TOKEN")
slack_client = SlackClient(token)
if slack_client.rtm_connect():
while True:
new_evts = slack_client.rtm_read()
for evt in new_evts:
#print evt
if 'type' in evt:
if str(evt["type"]) == "message" and "text" in evt:
# this is where the logic for the human input text is placed.
# we also get more information from the JSON
keyword = True
channel = evt['channel']
response = evt['text']
print response
elif 'reply_to' in evt:
#this is where the logic for the chat bot is placed.
slack_client.rtm_send_message('This is where the messages will go', 'Hello World')
else:
print "Failed."
def call(self, method, api_params):
sc = SlackClient(self.token)
rc = sc.api_call(method, **api_params)
if not rc['ok']:
msg = "Slack API call failed ({})".format(rc['error'])
raise AirflowException(msg)
import os
import time
import re
from slackclient import SlackClient
# instantiate Slack client
slack_client = SlackClient("xoxb-293862340119-kmqFvNoEefpiPJ9AWsqZUnRh")
# starterbot's user ID in Slack: value is assigned after the bot starts up
starterbot_id = None
# constants
RTM_READ_DELAY = 1 # 1 second delay between reading from RTM
EXAMPLE_COMMAND = "do"
MENTION_REGEX = "^<@(|[WU].+)>(.*)"
def parse_bot_commands(slack_events):
"""
Parses a list of events coming from the Slack RTM API to find bot commands.
If a bot command is found, this function returns a tuple of command and channel.
If its not found, then this function returns None, None.
"""
for event in slack_events:
if event["type"] == "message" and not "subtype" in event:
user_id, message = parse_direct_mention(event["text"])
if user_id == starterbot_id:
return message, event["channel"]
return None, None
def parse_direct_mention(message_text):
class SlackBot():
"""master slack client that remains alive for the duration of the script. subsidiary connections to SlackClient are made on each connection drop or error"""
def __init__(self, config):
self.config = config
self.token = self.config['api_key']
self.slack_client = None
self.name = self.config['bot_name']
self.slack_user_id = None
self.direct_message_channels = None
self.channel_id = None
self.channel_name = None
self.master = self.config['master']
self.plugins = self.config.get('plugins', 'plugins').split('\n')
logger.info("Plugins installed: " + str(self.plugins))
self.last_ping = 0
self.reconnects = 0
self.error_count = 0
self.run_time = 0
self.run_time_total = 0
self.first_time = True
self.auth_check = True
self.errors = []
self.ping_frequency = 15
def test_connection(self, verbose=True):
"""tests whether the device is connected to the internet"""
connected = False
retries = 0
while connected == False:
if verbose:
logger.info("Testing internet connection...")
try:
socket.create_connection(("www.google.com", 80))
if verbose:
logger.info("internet working")
connected = True
return True
except (socket.gaierror, socket.error):
logger.error("Internet connection down - retrying " +
str(retries))
error = utils.ConnectionDrop(self, "internet down")
retries += 1
time.sleep((1 + retries))
def generate_client(self):
"""creates an instance of SlackClient for each connection"""
if self.test_connection():
self.reconnects += 1
logger.info("Generating slack_client")
# check token is valid
self.slack_client = SlackClient(self.token)
if self.auth_check:
self.auth_check = False
if self.slack_client.api_call(
"auth.test", token=self.token).get('ok') == False:
logger.error("key not recognised")
sys.exit("Invalid key.. exiting")
logger.info("Token valid - SlackClient generated " +
str(self.slack_client))
logger.info("Connecting to RTM...")
#test RTM connection
try:
self.slack_client.rtm_connect()
logger.info("Connected to RTM")
self.run_time = 0
except Exception as e:
logger.error("Error in RTM connection: " + str(e))
logger.warning("Exiting script...")
sys.exit(1)
logger.info("Getting user & channel IDs")
#get list of users, channels and direct message channels
channel_list = self.slack_client.api_call("channels.list")
self.direct_message_channels = self.slack_client.api_call(
"im.list")
user_list = self.slack_client.api_call("users.list")
for channel in channel_list.get('channels'):
if channel.get('is_member'):
self.channel_id = str(channel.get('id'))
self.channel_name = str(channel.get('name'))
for user in user_list.get('members'):
if user.get('name') == self.name:
self.slack_user_id = user.get('id')
logger.info("Bot ID: " + str(self.slack_user_id) +
" Channel ID: " + str(self.channel_id) + "/ " +
str(self.channel_name))
def say(self, text_message):
"""simple function to post a message to the bot's channel"""
try:
self.slack_client.api_call("chat.postMessage",
channel=self.channel_id,
text=str(text_message),
as_user=True)
except (websocket.WebSocketConnectionClosedException,
socket.error) as e:
error = utils.ConnectionDrop(self, "chat connection error")
def autoping(self):
"""pings the slack server as set by the Bot"""
now = int(time.time())
if now > self.last_ping + self.ping_frequency:
self.slack_client.server.ping()
self.last_ping = now
def load_plugin(self, name):
"""loads the plugin for the process method"""
plugin = __import__("plugin_%s" % name)
return plugin
def call_plugin(self, name, message):
plugin = self.load_plugin(name)
plugin.plugin_main(message, self)
def process(self):
"""checks for connection errors, reads the RTM firehose and parses messages"""
self.run_time += 1
self.run_time_total += 1
try:
messages = self.slack_client.rtm_read()
self.error_count = 0
if self.first_time:
self.say("Bot ID:" + str(self.slack_user_id) + " is awake")
self.first_time = False
if self.errors:
drop_period = int(time.time()) - self.errors[0].timestamp
self.say("I was offline for " + str(drop_period) + " secs. " +
str(len(self.errors)) + "errors.")
logger.debug("Offline for " + str(drop_period) + " secs")
self.errors = []
except websocket.WebSocketConnectionClosedException:
error = utils.ConnectionDrop(self, "websocket drop")
self.generate_client()
return
except socket.error:
error = utils.ConnectionDrop(self, "Socket error")
time.sleep(5)
self.error_count += 1
if self.error_count > 5:
self.generate_client()
return
#checks the message stream
for message in messages:
#print (message)
if message['type'] == 'presence_change':
if message['presence'] == 'active':
time.sleep(.5)
self.say(
lex.response('greetings') + " " + str(self.master))
if 'text' in message:
if message['text'].startswith(
"<@%s>" % self.slack_user_id
) or 'text' in message and message['text'].startswith(
"<!%s>" % 'everyone'):
#if user issues a command, run through through all plugins
message_text = message['text']
for plugin in self.plugins:
self.call_plugin(plugin, message_text)
self.autoping()
from slackclient import SlackClient
from settings import SLACK_TOKEN, SLACK_CHANNEL, CLUSTER_NAME
sc = SlackClient(SLACK_TOKEN)
NORMAL_COLOR = '#36a64f'
WARNING_COLOR = '#FFFF00'
ERROR_COLOR = '#FF0000'
ALERTS_COLORS = {
'Normal': NORMAL_COLOR,
'Warning': WARNING_COLOR,
}
def get_slack_msg_color(event_type):
return ALERTS_COLORS.get(event_type, ERROR_COLOR)
def send_alert(event_type, url, description, status, response_time):
attachment = {
"fallback":
description,
"color":
get_slack_msg_color(event_type),
"title":
description,
"title_link":
url,
"fields": [{
"title": "URL",
class Bot(object):
""" Instanciates a Bot object to handle Slack onboarding interactions."""
def __init__(self):
super(Bot, self).__init__()
self.name = "come_back_here"
self.emoji = ":robot_face:"
# When we instantiate a new bot object, we can access the app
# credentials we set earlier in our local development environment.
self.oauth = {
"client_id": os.environ.get("CLIENT_ID"),
"client_secret": os.environ.get("CLIENT_SECRET"),
# Scopes provide and limit permissions to what our app
# can access. It's important to use the most restricted
# scope that your app will need.
"scope": "users.profile:read"
}
self.oauth
self.verification = os.environ.get("VERIFICATION_TOKEN")
# NOTE: Python-slack requires a client connection to generate
# an oauth token. We can connect to the client without authenticating
# by passing an empty string as a token and then reinstantiating the
# client with a valid OAuth token once we have one.
self.client = SlackClient("")
# We'll use this dictionary to store the state of each message object.
# In a production envrionment you'll likely want to store this more
# persistantly in a database.
self.messages = {}
def auth(self, code):
"""
Authenticate with OAuth and assign correct scopes.
Save a dictionary of authed team information in memory on the bot
object.
Parameters
----------
code : str
temporary authorization code sent by Slack to be exchanged for an
OAuth token
"""
# After the user has authorized this app for use in their Slack team,
# Slack returns a temporary authorization code that we'll exchange for
# an OAuth token using the oauth.access endpoint
auth_response = self.client.api_call(
"oauth.access",
client_id=self.oauth["client_id"],
client_secret=self.oauth["client_secret"],
code=code)
# To keep track of authorized teams and their associated OAuth tokens,
# we will save the team ID and bot tokens to the global
# authed_teams object
team_id = auth_response["team_id"]
authed_teams[team_id] = {"bot_token": auth_response["access_token"]}
# Then we'll reconnect to the Slack Client with the correct team's
# bot token
self.client = SlackClient(authed_teams[team_id]["bot_token"])
def bring_back_user(self, user_id, channel, token):
"""
Create and send an onboarding welcome message to new users. Save the
time stamp of this message on the message object for updating in the
future.
Parameters
----------
team_id : str
id of the Slack team associated with the incoming event
user_id : str
id of the Slack user associated with the incoming event
"""
# We'll use the message object's method to create the attachments that
# we'll want to add to our Slack message. This method will also save
# the attachments on the message object which we're accessing in the
# API call below through the message object's `attachments` attribute.
text = "Hey... get back here <@" + str(user_id) + ">"
self.client.api_call("chat.postMessage",
channel=channel,
token=token,
username=self.name,
icon_emoji=self.emoji,
text=text)
self.client.api_call("channels.invite",
token=token,
channel=channel,
user=user_id)
def create_slack_client(self, token):
self.SLACK_CLIENT = SlackClient(token)
class Bot(object):
admin_env_string = os.environ['PB_ADMIN']
ADMIN = admin_env_string.split(',')
# Set the name for the logger
# Add custom log handler to logger
EMOJI_LIST = ["party-parrot", "venezuela-parrot", "star2", "fiesta-parrot", "wasfi_dust", "dab"]
GENERAL_CHANNEL = ""
TTPB = "talk-to-pantherbot"
VERSION = "2.1.0"
def __init__(self, token, bot_name=""):
self.SLACK_CLIENT = None
self.BOT_NAME = bot_name
self.BOT_ICON_URL = "http://i.imgur.com/QKaLCX7.png"
self.USER_LIST = None
self.POLLING_LIST = dict()
self.WEBSOCKET = None
self.THREADS = []
self.COMMANDS_LIST = commands
self.pb_cooldown = True
# self.check_in_thread_ts
self.create_slack_client(token)
def create_slack_client(self, token):
self.SLACK_CLIENT = SlackClient(token)
# Returns a list of channel IDs searched for by name
def channels_to_ids(self, channel_names):
pub_channels = self.SLACK_CLIENT.api_call(
"channels.list",
exclude_archived=1
)
pri_channels = self.SLACK_CLIENT.api_call(
"groups.list",
exclude_archived=1
)
list_of_channels = []
for channel in pub_channels["channels"]:
for num in range(0, len(channel_names)):
if channel["name"].lower() == channel_names[num].lower():
list_of_channels.append(channel["id"])
# Same as above
for channel in pri_channels["groups"]:
for num in range(0, len(channel_names)):
if channel["name"].lower() == channel_names[num].lower():
list_of_channels.append(channel["id"])
return list_of_channels
# Send Message
# Sends a message to the specified channel (looks up by channel name, unless is_id is True)
def send_msg(self, channel, text, is_id=False, thread_ts=None):
if is_id:
channel_id = channel
else:
channel_id = self.channels_to_ids([channel])[0]
if thread_ts is not None:
response_json = self.SLACK_CLIENT.api_call(
"chat.postMessage",
channel=channel_id,
text=text,
username=self.BOT_NAME,
icon_url=self.BOT_ICON_URL,
thread_ts=thread_ts
)
else:
response_json = self.SLACK_CLIENT.api_call(
"chat.postMessage",
channel=channel_id,
text=text,
username=self.BOT_NAME,
icon_url=self.BOT_ICON_URL
)
logger.info("Message sent: ")
return response_json
def emoji_reaction(self, channel, ts, emoji):
self.SLACK_CLIENT.api_call(
"reactions.add",
name=emoji,
channel=channel,
timestamp=ts
)
logger.info("Reaction posted: " + emoji)
def close(self):
self.WEBSOCKET.keep_running = False
logger.info("Closing Websocket...")
class Bot(object):
""" Instanciates a Bot object to handle Slack onboarding interactions."""
def __init__(self):
super(Bot, self).__init__()
self.name = "SouthwestCheckin"
# self.emoji = ":robot_face:"
# # When we instantiate a new bot object, we can access the app
# # credentials we set earlier in our local development environment.
# self.oauth = {"client_id": key.client_id,
# "client_secret": key.client_secret,
# # Scopes provide and limit permissions to what our app
# # can access. It's important to use the most restricted
# # scope that your app will need.
# "scope": "bot"}
self.verification = key.verification_token
# NOTE: Python-slack requires a client connection to generate
# an oauth token. We can connect to the client without authenticating
# by passing an empty string as a token and then reinstantiating the
# client with a valid OAuth token once we have one.
self.client = SlackClient(key.bot_token)
# We'll use this dictionary to store the state of each message object.
# In a production envrionment you'll likely want to store this more
# persistantly in a database.
self.messages = {}
def open_dm(self, user_id):
"""
Open a DM to send a welcome message when a 'team_join' event is
recieved from Slack.
Parameters
----------
user_id : str
id of the Slack user associated with the 'team_join' event
Returns
----------
dm_id : str
id of the DM channel opened by this method
"""
new_dm = self.client.api_call("im.open",
user=user_id)
dm_id = new_dm["channel"]["id"]
return dm_id
def onboarding_message(self, team_id, user_id):
"""
Create and send an onboarding welcome message to new users. Save the
time stamp of this message on the message object for updating in the
future.
Parameters
----------
team_id : str
id of the Slack team associated with the incoming event
user_id : str
id of the Slack user associated with the incoming event
"""
# We've imported a Message class from `message.py` that we can use
# to create message objects for each onboarding message we send to a
# user. We can use these objects to keep track of the progress each
# user on each team has made getting through our onboarding tutorial.
# First, we'll check to see if there's already messages our bot knows
# of for the team id we've got.
if self.messages.get(team_id):
# Then we'll update the message dictionary with a key for the
# user id we've recieved and a value of a new message object
self.messages[team_id].update({user_id: message.Message()})
else:
# If there aren't any message for that team, we'll add a dictionary
# of messages for that team id on our Bot's messages attribute
# and we'll add the first message object to the dictionary with
# the user's id as a key for easy access later.
self.messages[team_id] = {user_id: message.Message()}
message_obj = self.messages[team_id][user_id]
# Then we'll set that message object's channel attribute to the DM
# of the user we'll communicate with
message_obj.channel = self.open_dm(user_id)
# We'll use the message object's method to create the attachments that
# we'll want to add to our Slack message. This method will also save
# the attachments on the message object which we're accessing in the
# API call below through the message object's `attachments` attribute.
message_obj.create_attachments()
post_message = self.client.api_call("chat.postMessage",
channel=message_obj.channel,
username=self.name,
icon_emoji=self.emoji,
text=message_obj.text,
attachments=message_obj.attachments
)
timestamp = post_message["ts"]
# We'll save the timestamp of the message we've just posted on the
# message object which we'll use to update the message after a user
# has completed an onboarding task.
message_obj.timestamp = timestamp
def checkin_instructions(self, team_id, user_id):
"""
Create and send an onboarding welcome message to new users. Save the
time stamp of this message on the message object for updating in the
future.
Parameters
----------
team_id : str
id of the Slack team associated with the incoming event
user_id : str
id of the Slack user associated with the incoming event
"""
# We've imported a Message class from `message.py` that we can use
# to create message objects for each onboarding message we send to a
# user. We can use these objects to keep track of the progress each
# user on each team has made getting through our onboarding tutorial.
# First, we'll check to see if there's already messages our bot knows
# of for the team id we've got.
if self.messages.get(team_id):
# Then we'll update the message dictionary with a key for the
# user id we've recieved and a value of a new message object
self.messages[team_id].update({user_id: message.Message()})
else:
# If there aren't any message for that team, we'll add a dictionary
# of messages for that team id on our Bot's messages attribute
# and we'll add the first message object to the dictionary with
# the user's id as a key for easy access later.
self.messages[team_id] = {user_id: message.Message()}
message_obj = self.messages[team_id][user_id]
# Then we'll set that message object's channel attribute to the DM
# of the user we'll communicate with
message_obj.channel = self.open_dm(user_id)
# We'll use the message object's method to create the attachments that
# we'll want to add to our Slack message. This method will also save
# the attachments on the message object which we're accessing in the
# API call below through the message object's `attachments` attribute.
post_message = self.client.api_call("chat.postMessage",
channel=message_obj.channel,
username=self.name,
#icon_emoji=self.emoji,
text=message_obj.text,
#attachments=message_obj.attachments
)
timestamp = post_message["ts"]
# We'll save the timestamp of the message we've just posted on the
# message object which we'll use to update the message after a user
# has completed an onboarding task.
message_obj.timestamp = timestamp
def pass_checkin(self, conf_number, firstname, lastname, user_id, team_id):
# TODO: Pass variables to checkin.py
# TODO: Store checkins and associate to user id so user can ask what are scheduled
print('Running pass_checkin')
print("Checkin {} {} {} for {} on team {}".format(conf_number, firstname, lastname, user_id, team_id))
#TODO Use subprocess instead of os.system
#subprocess.call(['python', 'checkin.py', '%s %s %s %s %s']) % (conf_number, firstname, lastname, user_id, team_id)
os.system("python3 checkin.py {} {} {} {} {}".format(conf_number, firstname, lastname, user_id, team_id))
def checkin_initial(self, team_id, user_id, conf_number, firstname, lastname):
"""
Create and send an onboarding welcome message to new users. Save the
time stamp of this message on the message object for updating in the
future.
Parameters
----------
team_id : str
id of the Slack team associated with the incoming event
user_id : str
id of the Slack user associated with the incoming event
"""
# We've imported a Message class from `message.py` that we can use
# to create message objects for each onboarding message we send to a
# user. We can use these objects to keep track of the progress each
# user on each team has made getting through our onboarding tutorial.
# First, we'll check to see if there's already messages our bot knows
# of for the team id we've got.
if self.messages.get(team_id):
# Then we'll update the message dictionary with a key for the
# user id we've recieved and a value of a new message object
self.messages[team_id].update({user_id: message.Message()})
else:
# If there aren't any message for that team, we'll add a dictionary
# of messages for that team id on our Bot's messages attribute
# and we'll add the first message object to the dictionary with
# the user's id as a key for easy access later.
self.messages[team_id] = {user_id: message.Message()}
message_obj = self.messages[team_id][user_id]
# Then we'll set that message object's channel attribute to the DM
# of the user we'll communicate with
message_obj.channel = self.open_dm(user_id)
# We'll use the message object's method to create the attachments that
# we'll want to add to our Slack message. This method will also save
# the attachments on the message object which we're accessing in the
# API call below through the message object's `attachments` attribute.
post_message = self.client.api_call("chat.postMessage",
channel=message_obj.channel,
username=self.name,
#icon_emoji=self.emoji,
text="Got it, processing check in for: *" + firstname + " " + lastname +
"* on confirmation number *" + conf_number + "*",
#attachments=message_obj.attachments
)
print('Sending ' + conf_number, firstname, lastname, user_id, team_id)
self.pass_checkin(conf_number, firstname, lastname, user_id, team_id)
timestamp = post_message["ts"]
# We'll save the timestamp of the message we've just posted on the
# message object which we'll use to update the message after a user
# has completed an onboarding task.
message_obj.timestamp = timestamp
def checkin_response(self, team_id, user_id, message_text):
#TODO clean up all this
"""
Creating response ability for checkin.py
Parameters
----------
team_id : str
id of the Slack team associated with the incoming event
user_id : str
id of the Slack user associated with the incoming event
message_text : str
text for bot to respond with
"""
# We've imported a Message class from `message.py` that we can use
# to create message objects for each onboarding message we send to a
# user. We can use these objects to keep track of the progress each
# user on each team has made getting through our onboarding tutorial.
# First, we'll check to see if there's already messages our bot knows
# of for the team id we've got.
if self.messages.get(team_id):
# Then we'll update the message dictionary with a key for the
# user id we've recieved and a value of a new message object
self.messages[team_id].update({user_id: message.Message()})
else:
# If there aren't any message for that team, we'll add a dictionary
# of messages for that team id on our Bot's messages attribute
# and we'll add the first message object to the dictionary with
# the user's id as a key for easy access later.
self.messages[team_id] = {user_id: message.Message()}
message_obj = self.messages[team_id][user_id]
# Then we'll set that message object's channel attribute to the DM
# of the user we'll communicate with
message_obj.channel = self.open_dm(user_id)
# We'll use the message object's method to create the attachments that
# we'll want to add to our Slack message. This method will also save
# the attachments on the message object which we're accessing in the
# API call below through the message object's `attachments` attribute.
post_message = self.client.api_call("chat.postMessage",
channel=message_obj.channel,
username=self.name,
#icon_emoji=self.emoji,
text=message_text,
#attachments=message_obj.attachments
)
timestamp = post_message["ts"]
# We'll save the timestamp of the message we've just posted on the
# message object which we'll use to update the message after a user
# has completed an onboarding task.
message_obj.timestamp = timestamp
def update_emoji(self, team_id, user_id):
"""
Update onboarding welcome message after recieving a "reaction_added"
event from Slack. Update timestamp for welcome message.
Parameters
----------
team_id : str
id of the Slack team associated with the incoming event
user_id : str
id of the Slack user associated with the incoming event
"""
# These updated attachments use markdown and emoji to mark the
# onboarding task as complete
completed_attachments = {"text": ":white_check_mark: "
"~*Add an emoji reaction to this "
"message*~ :thinking_face:",
"color": "#439FE0"}
# Grab the message object we want to update by team id and user id
message_obj = self.messages[team_id].get(user_id)
# Update the message's attachments by switching in incomplete
# attachment with the completed one above.
message_obj.emoji_attachment.update(completed_attachments)
# Update the message in Slack
post_message = self.client.api_call("chat.update",
channel=message_obj.channel,
ts=message_obj.timestamp,
text=message_obj.text,
attachments=message_obj.attachments
)
# Update the timestamp saved on the message object
message_obj.timestamp = post_message["ts"]
def update_pin(self, team_id, user_id):
"""
Update onboarding welcome message after recieving a "pin_added"
event from Slack. Update timestamp for welcome message.
Parameters
----------
team_id : str
id of the Slack team associated with the incoming event
user_id : str
id of the Slack user associated with the incoming event
"""
# These updated attachments use markdown and emoji to mark the
# onboarding task as complete
completed_attachments = {"text": ":white_check_mark: "
"~*Pin this message*~ "
":round_pushpin:",
"color": "#439FE0"}
# Grab the message object we want to update by team id and user id
message_obj = self.messages[team_id].get(user_id)
# Update the message's attachments by switching in incomplete
# attachment with the completed one above.
message_obj.pin_attachment.update(completed_attachments)
# Update the message in Slack
post_message = self.client.api_call("chat.update",
channel=message_obj.channel,
ts=message_obj.timestamp,
text=message_obj.text,
attachments=message_obj.attachments
)
# Update the timestamp saved on the message object
message_obj.timestamp = post_message["ts"]
def update_share(self, team_id, user_id):
"""
Update onboarding welcome message after recieving a "message" event
with an "is_share" attachment from Slack. Update timestamp for
welcome message.
Parameters
----------
team_id : str
id of the Slack team associated with the incoming event
user_id : str
id of the Slack user associated with the incoming event
"""
# These updated attachments use markdown and emoji to mark the
# onboarding task as complete
completed_attachments = {"text": ":white_check_mark: "
"~*Share this Message*~ "
":mailbox_with_mail:",
"color": "#439FE0"}
# Grab the message object we want to update by team id and user id
message_obj = self.messages[team_id].get(user_id)
# Update the message's attachments by switching in incomplete
# attachment with the completed one above.
message_obj.share_attachment.update(completed_attachments)
# Update the message in Slack
post_message = self.client.api_call("chat.update",
channel=message_obj.channel,
ts=message_obj.timestamp,
text=message_obj.text,
attachments=message_obj.attachments
)
# Update the timestamp saved on the message object
message_obj.timestamp = post_message["ts"]
import logging
import os
import pickle
import re
import sys
from slackclient import SlackClient
botuser = os.environ.get('SLACK_KARMA_BOTUSER')
token = os.environ.get('SLACK_KARMA_TOKEN')
if not botuser or not token:
print('Make sure you set SLACK_KARMA_BOTUSER and SLACK_KARMA_TOKEN in env')
sys.exit(1)
KARMA_BOT = botuser
SLACK_CLIENT = SlackClient(token)
MAX_POINTS = 5
# the first +/- is merely signaling, start counting (regex capture)
# from second +/- onwards, so bob++ adds 1 point, bob+++ = +2, etc
KARMA_ACTION = re.compile(r'(?:^| )(\S{2,}?)\s?[\+\-]([\+\-]+)')
IS_USER = re.compile(r'^<@[^>]+>$')
USERNAME_CACHE = {}
KARMA_CACHE = 'data'
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s', # noqa E501
datefmt='%m-%d %H:%M',
import os
import time
from slackclient import SlackClient
from commands import *
# Gather all exported tokens
access_token = os.getenv("SERVER_TOKEN")
BOT_ID = os.environ.get("BOT_ID")
AT_BOT = "<@" + BOT_ID + ">"
# instantiate Slack Clients
SLACK_TOKEN = os.environ.get('SLACK_BOT_TOKEN')
slack_client = SlackClient(SLACK_TOKEN)
def handle_command(command, channel):
"""
Receives commands directed at the bot and determines if they
are valid commands. If so, then acts on the commands. If not,
returns back what it needs for clarification.
"""
response = "Sorry didn't catch that :("
if command.startswith(DEFAULT_COMMAND):
response = greeting()
elif command.startswith(HELP_COMMAND):
response = help()
import os
from slackclient import SlackClient
SLACK_TOKEN='insert-here-slack-token'
slack_client = SlackClient(SLACK_TOKEN)
def send_message(channel_id, message):
slack_client.api_call(
"chat.postMessage",
channel=channel_id,
text=message,
username='******',
icon_emoji=':space_invader:'
)
if __name__ == '__main__':
send_message('test_python', "Hello World!")
return profile.pop("first_name")
def processIncomingEvent(client, event):
if commande == "SOF":
text = text.replace("SOF", "")
print text
print requests.get(
'https://api.stackexchange.com/2.2/search?order=desc&sort=activity&intitle='
+ text + '&site=stackoverflow').text
sendMessage(
event.pop("channel"), "Hello " + getfirstNameByID(userID) +
", que puis-je faire pour vous ? :tada:")
sc1 = SlackClient(token1)
slack1 = Slack(sc1)
sc2 = SlackClient(token2)
slack2 = Slack(sc2)
listeQuestions = []
waitingForAnswer = []
currentTS = time.time()
if slack1.connect() and slack2.connect():
listClients = [slack1, slack2]
while True:
for client in listClients:
data = client.fetch()
for event in data:
print event
from lxml import html
import requests
page = requests.get('http://smittenicecream.com/menu/')
tree = html.fromstring(page.content)
flavors = tree.xpath("//span[@class='name']/span/text()")
message = '\n'.join(flavors)
print 'Flavors:', flavors
from slackclient import SlackClient
token = 'xoxb-23465111906-LUJJs8YHOSmpKgf6JU4dMLEC'
sc = SlackClient(token)
print sc.api_call("api.test")
print sc.api_call("channels.info", channel="1234567890")
print sc.api_call("chat.postMessage",
channel="#general",
text=message,
username='******',
icon_emoji=':robot_face:')
if __name__ == "__main__":
parser = argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
description='''
This script posts a message into a slack channel.
Sample commands:
post.py mychannel "This is a message."
''',
epilog='''''' )
parser.add_argument('channel', type=str, nargs=1,
help='Channel to post to')
parser.add_argument('message', type=str, nargs=1,
help='Message to post')
args = parser.parse_args()
config = ConfigParser.RawConfigParser()
config.read('creds.cfg')
token = config.get("Slack","token")
client = SlackClient(token)
client.rtm_connect()
try:
post(client, args.channel[0], args.message[0])
except Exception as e:
sys.exit("Error: %s" % e.message)
import os
import time
from slackclient import SlackClient
# randoBot's ID as an env. variable
BOT_ID = os.environ.get("BOT_ID")
# constants
AT_BOT = "<@" + BOT_ID + ">"
EXAMPLE_COMMAND = "do"
# instantiate Slack & Twilio clients
slack_client = SlackClient(os.environ.get('SLACK_BOT_TOKEN'))
def handle_command(command, channel):
"""
Receives commands directed at the bot and determines if they are valid commands. If so, then acts on the commands. If not, returns back what it needs for clarification.
"""
response = "oooohhhh yeeaaahhh brother get ready for some PICKEMS!!! I'M GONNA TAKE YOU DOWN, NICK!!"
if command.startswith(EXAMPLE_COMMAND):
response = "Sure... write some more nerd code, then I can do that, dummy!"
slack_client.api_call("chat.postMessage",
channel=channel,
text=response,
as_user=True)
def parse_slack_output(slack_rtm_output):
"""
The Slack Real Time Messaging API is an events firehose. this parsing function returns None unless a message is directed at the bot, based on its ID.
def connect(self):
"""Convenience method that creates Server instance"""
self.slack_client = SlackClient(self.token)
self.slack_client.rtm_connect()
async def on_ready():
if bot._intro_displayed:
return
bot._intro_displayed = True
owner_cog = bot.get_cog('Owner')
total_cogs = len(owner_cog._list_cogs())
users = len(set(bot.get_all_members()))
servers = len(bot.servers)
channels = len([c for c in bot.get_all_channels()])
login_time = datetime.datetime.utcnow() - bot.uptime
login_time = login_time.seconds + login_time.microseconds / 1E6
print("Login successful. ({}ms)\n".format(login_time))
owner = await set_bot_owner()
settings.bot_user = str(bot.user)
settings.save_settings()
print("--------------------------")
print("Red Magician - Discord Bot")
print("--------------------------")
print(str(bot.user))
print("\nConnected to:")
print("{} servers".format(servers))
print("{} channels".format(channels))
print("{} users\n".format(users))
prefix_label = 'Prefix'
if len(bot.settings.prefixes) > 1:
prefix_label += 'es'
print("{}: {}".format(prefix_label, " ".join(bot.settings.prefixes)))
print("Owner: {}".format(owner))
print("{}/{} active cogs with {} commands".format(
len(bot.cogs), total_cogs, len(bot.commands)))
print("--------------------------")
if bot.settings.token and not bot.settings.self_bot:
print("\nUse this url to bring your bot to a server:")
url = await get_oauth_url()
bot.oauth_url = url
print(url)
print("\ndealien's Server: https://discord.gg/SN4TvHJ")
if str(os.environ.get("IS_HEROKU")) == "True":
herokustatus = True
else:
herokustatus = False
fields = [{
"title": "Heroku Deployed",
"value": str(herokustatus),
"short": True
}]
fields.append({
"title": prefix_label,
"value": "{}".format(" ".join(bot.settings.prefixes)),
"short": True
})
fields.append({
"title":
"Cogs",
"value":
"{}/{} active cogs with {} commands".format(
len(bot.cogs), total_cogs, len(bot.commands)),
"short":
True
})
fields.append({
"title": "Active Cogs",
"value": "{}".format(", ".join(bot.cogs)),
"short": False
})
slackattachments = [{
"fallback":
"Red DiscordBot Initialized",
"color":
"good",
"title":
"Bot Initialized",
"title_link":
"https://github.com/dealien/Red-Magician",
"text":
"*Servers:* {}, *Channels:* {}, *Users:* {}".format(
servers, channels, users),
"fields":
fields,
"footer":
str(bot.user),
"footer_icon":
"https://cdn.discordapp.com/app-icons/349363592627486740/eacdbc4e9c80e0db0e1160db529d45a4.png",
"ts":
datetime.datetime.now().timestamp()
}]
# print(slackattachments)
SlackClient(settings.slack_token).api_call(
"chat.postMessage",
channel=settings.slack_channel,
attachments=slackattachments,
mrkdwn=True,
as_user=False,
username=str(settings.bot_user).split("#", 1)[0],
icon_url=
"https://cdn.discordapp.com/app-icons/349363592627486740/eacdbc4e9c80e0db0e1160db529d45a4.png"
)
print("Slack message sent")
await bot.get_cog('Owner').disable_commands()
def __init__(self, token):
history_length = 20
summary_frequency = 5
summary_countdown = summary_frequency
self.s = requests.Session()
self.tea = TextEmotionAnalyzer(outputMode="json")
self.token = token
sc = SlackClient(token)
self.history = bot_history(history_length)
channel = "#dancewithdeanna"
if sc.rtm_connect():
while True:
new_evts = sc.rtm_read()
for evt in new_evts:
if len(evt) != 0:
if evt.has_key('text') and not evt.has_key('subtype'):
print evt['text']
top_emotion = self.analyse(evt['text'],
evt['user'],
evt['channel'])
if top_emotion is None:
print "top emotion is None"
continue
print top_emotion["docEmotions"]
if top_emotion["docEmotions"].has_key('anger'):
print sc.api_call(
'chat.postMessage',
channel=channel,
text='Calm down!',
username='******',
icon_emoji=':woman::skin-tone-2:',
as_user='******')
elif top_emotion["docEmotions"].has_key('fear'):
print sc.api_call(
'chat.postMessage',
channel=channel,
text='Dont worry!',
username='******',
icon_emoji=':woman::skin-tone-2:',
as_user='******')
elif top_emotion["docEmotions"].has_key('joy'):
print sc.api_call(
'chat.postMessage',
channel=channel,
text='Yay!',
username='******',
icon_emoji=':woman::skin-tone-2:',
as_user='******')
elif top_emotion["docEmotions"].has_key('sadness'):
print sc.api_call(
'chat.postMessage',
channel=channel,
text='*hugs*!',
username='******',
icon_emoji=':woman::skin-tone-2:',
as_user='******')
elif top_emotion["docEmotions"].has_key('disgust'):
print sc.api_call(
'chat.postMessage',
channel=channel,
text='Gross!',
username='******',
icon_emoji=':woman::skin-tone-2:',
as_user='******')
if (summary_countdown >= 0):
summary_countdown -= 1
else:
print_summary(self.history)
time.sleep(1)
else:
print "Connection Failed, invalid token?"
import time
import re
from operator import itemgetter
from slackclient import SlackClient
import conf
from tweepy import API
from tweepy import OAuthHandler
import json
import schedule
# instantiate Slack client
slack_client = SlackClient(conf.SLACK_BOT_TOKEN)
# starterbot's user ID in Slack: value is assigned after the bot starts up
starterbot_id = None
# constants
RTM_READ_DELAY = 1 # 1 second delay between reading from RTM
EXAMPLE_COMMAND = "topsy"
MENTION_REGEX = "^<@(|[WU].+?)>(.*)"
auth = OAuthHandler(conf.CONSUMER_KEY, conf.CONSUMER_SECRET)
auth.set_access_token(conf.ACCESS_TOKEN, conf.ACCESS_SECRET)
api = API(auth)
def call_top(sched='True'):
top_tweets = api.trends_place(1)
new_tweets = json.dumps(top_tweets, indent=4, sort_keys=True)
new_tweets = json.loads(new_tweets)
tweet_dict = new_tweets[0]
# log quote
import syslog
import sqlite3
import re
import os
import time
import datetime
import sys
import traceback
from daemonize import Daemonize
from slackclient import SlackClient
# Setting up the RTM API
from prodtoken import token
sc = SlackClient(token)
avatar = ":metro-robo:"
# Setting up the Web API
#import json
#import requests
#url = "https://hooks.slack.com/services/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"
#headers={'Content-Type': 'application/json'}
###################################################################### Vars
testmode = False
pid = "/tmp/sassist.pid"
app = "assistant"
nickname = "Métro"
dump = "#dump"
import os
import time
from slackclient import SlackClient
from app.services.corpus_callosum import CorpusCallosum
token = os.environ['SLACK_TOKEN']
sc = SlackClient(token)
if sc.rtm_connect():
while True:
events = sc.rtm_read()
for event in events:
# Narowing down event types
# Make sure there's a channel to respond back, there is text, the event type is of message
# And most importantly to avoid loop, verify if wasn't a bot who sent the message, in which case
# Matilda would just be forever talking to herself
if ('channel' in event and 'bot_id' not in event and 'text' in event and event.get('type') == 'message'):
cc = CorpusCallosum(event);
else:
print ("Connection Failed, invalid token?")
class Checkbot:
def __init__(self):
self.redis = StrictRedis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD)
self.slack = SlackClient(SLACK_API_TOKEN)
def hmart(self):
form = {
'custno': HMART_NUMBER,
'lastname': HMART_NAME,
'zipcode': HMART_ZIP,
}
logger.info(f'checking points for {form}')
response = requests.post(HMART_POINTS_URL, data=form)
data = response.json()
points = data['tpldata'][0]['point']
date = data['tpldata'][0]['trdate']
logger.info(f'{points} points as of {date}')
cached = self.redis.get(HMART_POINTS_KEY)
is_point_change = int(points) != int(cached) if cached else False
if not cached or is_point_change:
logger.info('current points differ from cached points')
self.redis.set(HMART_POINTS_KEY, points)
# TODO: include difference between old and new totals in message?
self.message(f'{points} Hmart points as of {date}')
def ez(self):
base_url = 'https://www.ezdrivema.com'
session = requests.Session()
session.headers.update({
'User-Agent': (
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) '
'Chrome/69.0.3497.100 Safari/537.36'
)
})
login_url = f'{base_url}/ezpassmalogin'
response = session.get(login_url)
logger.info(f'{login_url} get {response.status_code}')
soup = BeautifulSoup(response.text, 'html.parser')
with open('forms/login.json') as f:
form = json.load(f)
form['__RequestVerificationToken'] = soup.find('input', {'name': '__RequestVerificationToken'}).get('value')
form['__VIEWSTATE'] = soup.find(id='__VIEWSTATE').get('value')
form['__EVENTVALIDATION'] = soup.find(id='__EVENTVALIDATION').get('value')
form['dnn$ctr689$View$txtUserName'] = EZ_USERNAME
form['dnn$ctr689$View$txtPassword'] = EZ_PASSWORD
response = session.post(login_url, data=form)
logger.info(f'{login_url} post {response.status_code}')
soup = BeautifulSoup(response.text, 'html.parser')
balance = soup.find(id='dnn_ctr670_ucAccountSummaryMassDot_lblBalance').text
logger.info(f'balance {balance}')
cached = self.redis.get(EZ_BALANCE_KEY)
cached = cached.decode('utf-8') if cached else None
is_balance_change = balance != cached if cached else False
if not cached or is_balance_change:
logger.info('current balance differs from cached balance')
self.redis.set(EZ_BALANCE_KEY, balance)
self.message(f'E-ZPass balance is {balance}')
else:
logger.info('balance unchanged, exiting')
return
tx_url = f'{base_url}/ezpassviewtransactions'
response = session.get(tx_url)
logger.info(f'{tx_url} get {response.status_code}')
soup = BeautifulSoup(response.text, 'html.parser')
with open('forms/tx.json') as f:
form = json.load(f)
form['__RequestVerificationToken'] = soup.find('input', {'name': '__RequestVerificationToken'}).get('value')
form['__VIEWSTATE'] = soup.find(id='__VIEWSTATE').get('value')
form['__EVENTVALIDATION'] = soup.find(id='__EVENTVALIDATION').get('value')
yesterday = datetime.now() - timedelta(days=1)
yesterday = yesterday.strftime('%m/%d/%Y')
form['dnn$ctr1180$ucMassDotTcoreTransaction$ucBaseTcoreTransaction$txtStartDate'] = yesterday
form['dnn$ctr1180$ucMassDotTcoreTransaction$ucBaseTcoreTransaction$txtEndDate'] = yesterday
response = session.post(tx_url, data=form, timeout=10)
logger.info(f'{tx_url} post {response.status_code}')
soup = BeautifulSoup(response.text, 'html.parser')
table = soup.find(id='dnn_ctr1180_ucMassDotTcoreTransaction_ucBaseTcoreTransaction_AccountGridView')
rows = table.find_all('tr')
if len(rows) == 1:
logger.info('no transactions found')
return
header = rows.pop(0) # noqa: F841
total = rows.pop()
dollars = total.find_all('td')[-1].text
if dollars.startswith('('):
stripped = dollars.strip('()')
dollars = f'-{stripped}'
msg = f'found {len(rows)} transactions totaling {dollars}'
logger.info(msg)
self.message(msg)
for row in rows:
cells = row.find_all('td')
tx_type = cells[2].text.lower().strip()
if 'toll' in tx_type:
toll_ts = cells[1].get_text(' ')
toll_loc = cells[6].text
toll_dollars = cells[8].text.strip('()')
msg = f'{tx_type} {toll_dollars} at {toll_loc} {toll_ts}'
logger.info(msg)
self.message(msg)
elif 'replenish' in tx_type:
replenish_ts = cells[0].text
replenish_dollars = cells[8].text
msg = f'{tx_type} {replenish_dollars} on {replenish_ts}'
logger.info(msg)
self.message(msg)
def message(self, message):
self.slack.api_call(
'chat.postMessage',
channel=SLACK_CHANNEL,
text=message,
)
import unirest
import numpy as np
import pandas as pd
from pandas.io.json import json_normalize
# starterbot's ID as an environment variable
#export BOT_ID='U4AK5FZTP'
#export SLACK_BOT_TOKEN='xoxb-146651543941-V78nlhngwrirtcf8mSbMPkZM'
#channel_id='C3S7PP03A'
BOT_ID = os.environ.get("BOT_ID")
# constants
AT_BOT = "<@" + BOT_ID + ">"
EXAMPLE_COMMAND = "do"
# instantiate Slack client
slack_client = SlackClient(os.environ.get('SLACK_BOT_TOKEN'))
def image_predictions():
app = ClarifaiApp("vRFXZQ1VC4WEBnurtH1XiehfUL7DgZoV4oMHcX7n", "DFzeuPqmt0T3UoMODZiCX904IV84SYOHXz0gkdTO")
model = app.models.get('food-items-v1.0')
image=app.inputs.create_image_from_filename("/home/aashay/a.jpg")
predictions=model.predict([image])
return predictions
def list_channels():
channels_call = slack_client.api_call("channels.list")
if channels_call['ok']:
print channels_call['channels']
return channels_call['channels']
return None
def execute(self, **kwargs):
sc = SlackClient(self.token)
sc.api_call(self.method, **self.params)
def __init__(self):
self.redis = StrictRedis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD)
self.slack = SlackClient(SLACK_API_TOKEN)
import os
import time
from datetime import datetime
from slackclient import SlackClient
slack_token = os.environ["SLACK_API_TOKEN"]
SLACK_WEBHOOK_SECRET = os.environ.get('SLACK_WEBHOOK_SECRET')
sc = SlackClient(slack_token)
# [{'type': 'message',
# 'channel': 'C4H2ZJVUK',
# 'user': '******', 'text': 'hello test bot',
# 'ts': '1489331005.529033', 'source_team': 'T4H2ZJVA7', 'team': 'T4H2ZJVA7'}]
# [{'text': 'Testing :tada:', 'username': '******',
# 'bot_id': 'B4H33G00K', 'type': 'message', 'subtype': 'bot_message',
# 'team': 'T4H2ZJVA7', 'channel': 'C4H2ZJVUK', 'event_ts': '1489330956.526758', 'ts': '1489330956.526758'}]
def rtm_loop(start_time):
while True:
events = sc.rtm_read()
for e in events:
print(e)
e_type = e.get('type')
is_bot = bool(e.get('bot_id'))
new_message = e.get('ts') and float(e['ts']) > start_time
e_text = e.get('text')
parrot_rmt_messages(e_text, e_type, is_bot, new_message)
time.sleep(1)
import os
import sys
from slackclient import SlackClient
BOT_NAME = 'portfolio'
TOKEN = os.environ.get('SLACK_BOT_TOKEN')
BOT_ID = os.environ.get('BOT_ID')
if __name__ == "__main__":
if TOKEN is None:
TOKEN = sys.argv[1]
if BOT_ID is None:
BOT_ID = sys.argv[2]
slack_client = SlackClient(sys.argv[1])
api_call = slack_client.api_call("users.list")
if api_call.get('ok'):
# retrieve all users so we can find our bot
users = api_call.get('members')
for user in users:
if 'name' in user and user.get('name') == BOT_NAME:
print("Bot ID for '" + user['name'] + "' is " + user.get('id'))
else:
print("could not find bot user with the name " + BOT_NAME)
class Bot(object):
def __init__(self, key, codeword='iamgod'):
self.slack_client = SlackClient(key)
self.bot_name = "chocbot"
self.bot_id = self.get_bot_id()
print('My ID is:', self.bot_id)
self.codeword = codeword
self.scoreboard = Scoreboard()
self.nominators = Scoreboard('Nominators')
if self.bot_id is None:
exit("Error, could not find " + self.bot_name)
self.restore_state()
self.event = Event(self)
self.listen()
def get_bot_id(self):
api_call = self.slack_client.api_call("users.list")
if api_call.get('ok'):
# retrieve all users so we can find our bot
users = api_call.get('members')
for user in users:
if 'name' in user and user.get('name') == self.bot_name:
return "<@" + user.get('id') + ">"
return None
def get_user_name(self, userid):
api_call = self.slack_client.api_call("users.list")
if api_call.get('ok'):
# retrieve all users so we can find our bot
users = api_call.get('members')
for user in users:
if 'name' in user and user.get('id') == userid:
return user.get('name')
return None
def listen(self):
if self.slack_client.rtm_connect(with_team_state=False):
print("Successfully connected, listening for commands")
while True:
self.event.wait_for_event()
time.sleep(1)
else:
exit("Error, Connection Failed")
def send_message(self, channel, message):
#sends a message to the noted channel
self.slack_client.api_call("chat.postMessage",
channel=channel,
text=message,
as_user=True)
def save_state(self, filename='bot_state.pkl'):
#dumps the state out to an appropriate file
try:
state = {
'scoreboard': self.scoreboard,
'nominators': self.nominators
}
pickle.dump(state, open(filename, 'wb'))
except:
print('Count not save state. Is the location writeable?')
def restore_state(self, filename='bot_state.pkl'):
try:
state = pickle.load(open(filename, 'rb'))
self.scoreboard = state['scoreboard']
self.nominators = state['nominators']
print('Restored state from save file.')
except:
print('Save file not found')
except ImportError as e:
print(e)
plt = None
import requests
from slackclient import SlackClient
VELOCITY = 13
SHOOTOUT = 0.6
OVERTIME = 0.8
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.DEBUG)
SLACK_CLIENT_ID = os.environ.get('SLACK_CLIENT_ID')
SLACK_CLIENT = SlackClient(SLACK_CLIENT_ID)
IMGUR_CLIENT_ID = os.environ.get('IMGUR_CLIENT_ID')
CSV_ID = "11HKFGPgWCA3g8auTNNSqVtyKk6WBuV7UeRYarVTBHvk"
class Team:
"""
Model to hold ELO histories of each team
"""
def __init__(self, name, color, emoji):
self.name = name
self.history = [1500]
self.color = color
self.emoji = emoji
@property
from slackbot.bot import Bot
from slackbot.bot import respond_to
from slackclient import SlackClient
from slackbot_settings import API_TOKEN
import re
from scholar_script import ScholarQuerier, ScholarSettings, SearchScholarQuery
sc = SlackClient(API_TOKEN)
def scholar_wrapper():
querier = ScholarQuerier()
settings = ScholarSettings()
querier.apply_settings(settings)
query = SearchScholarQuery()
return (querier, query)
@respond_to('doi (.*)')
def doi(message, something):
message.reply('Try this link: {}'.format("http://dx.doi.org/" + something))
@respond_to('who cited (.*)')
def cited_by(message, something):
querier, query = scholar_wrapper()
query.set_words(something)
querier.send_query(query)
from slackclient import SlackClient
from firebase import firebase
firebase = firebase.FirebaseApplication(
'https://slackbotadventures.firebaseio.com/', None)
# starterbot's ID as an environment variable
BOT_ID = os.environ.get("BOT_ID")
BOT_ID = 'U4AA1UYN7'
# constants
AT_BOT = "<@" + BOT_ID + ">"
EXAMPLE_COMMAND = "do"
# instantiate Slack & Twilio clients
slack_client = SlackClient(os.environ.get('SLACK_BOT_TOKEN'))
slack_client = SlackClient('xoxb-146341984755-1fYi3Oau3Cx262xcxP3Tzzp0')
def handle_command(command, channel, user):
"""
Receives commands directed at the bot and determines if they
are valid commands. If so, then acts on the commands. If not,
returns back what it needs for clarification.
"""
response = "Not sure what you mean. Use the *" + EXAMPLE_COMMAND + \
"* command with numbers, delimited by spaces."
if command.startswith("get"):
name = command.split(" ")
parsed = '/'
for part in name:
