model_api = ModelAPI(port=str(args.port)) if not self.personality: self.personality = random.choice(self.model_api.personalities) logger.info(f"Using personality={self.personality}") # TODO channel whitelist, only roast people who invite it or speak in a thread @slack.RTMClient.run_on(event="message") def say_hello(**payload): print("message", payload) data = payload["data"] web_client = payload["web_client"] rtm_client = payload["rtm_client"] channel_id = data["channel"] thread_ts = data["ts"] if "text" in data and "user" in data and not "subtype" in data: body = data["text"] name = data["user"] msg = model_api.roast(body, name, personality=args.personality) web_client.chat_postMessage(channel=channel_id, text=msg, thread_ts=thread_ts) logger.info( "Out msg %s", dict(channel=channel_id, text=msg, thread_ts=thread_ts) ) logger.info("Starting RTMClient") rtm_client = slack.RTMClient(token=args.token) rtm_client.start()
async def slack_client(): # real-time-messaging Slack client client = slack.RTMClient(token=token, run_async=True) await asyncio.gather(client.start())
move = data.get('text', []).split(" ")[1] who_moves = "white" if board.turn == chess.WHITE else "black" try: board.parse_san(move) # This throws if not legal board.push_san(move) web_client.chat_postMessage( channel=channel_id, text=f"{who_moves} plays {move}!", ) except ValueError as e: print(e) web_client.chat_postMessage( channel=channel_id, text=f"Illegal Move for {who_moves}!", ) elif data.get('text', []) == "help": board.clear() web_client.chat_postMessage( channel=channel_id, text="""Say `status` for current game status Say `move SAN` to make a move. Eg: move e4 """, ) slack_token = os.environ["SLACK_API_TOKEN"] rtm_client = slack.RTMClient(token=slack_token) rtm_client.start()
def main() -> None: """Entrypoint.""" database.load() door.start() rtm_client = slack.RTMClient(token=os.environ['SLACK_API_TOKEN']) rtm_client.start()
# Create a new onboarding tutorial. onboarding_tutorial = OnboardingTutorial(channel) # Get the onboarding message payload message = onboarding_tutorial.get_message_payload() # Post the onboarding message in Slack response = web_client.chat_postMessage(**message) # Capture the timestamp of the message we've just posted so # we can use it to update the message after a user # has completed an onboarding task. onboarding_tutorial.timestamp = response["ts"] # Store the message sent in onboarding_tutorials_sent if channel not in onboarding_tutorials_sent: onboarding_tutorials_sent[channel] = {} onboarding_tutorials_sent[channel][user_id] = onboarding_tutorial logger = logging.getLogger() logger.setLevel(logging.DEBUG) logger.addHandler(logging.StreamHandler()) ssl_context = ssl_lib.create_default_context(cafile=certifi.where()) s3 = S3Connection(os.environ['S3_KEY'], os.environ['S3_SECRET']) os.environ["DEBUSSY"] = "LOL" slack_token = os.environ["SLACK_BOT_TOKEN"] rtm_client = slack.RTMClient(token=slack_token, ssl=ssl_context) rtm_client.start()
def __init__(self, token, fp, su): self.client = slack.RTMClient(token=token, auto_reconnect=True) client = slack.WebClient(token=token) self.table = functions.get_users_table(client) self.fp = fp self.su = su
def main(): rtm_client = slack.RTMClient(token=SLACK_TOKEN) rtm_client.start()
def start(): slack_token = os.environ["SLACK_BOT_TOKEN"] rtm_client = slack.RTMClient(token=slack_token) rtm_client.start()
def checking(loop): ssl_context = ssl_lib.create_default_context(cafile=certifi.where()) slack_token = "xoxb-795840878529-856613875153-zMXfzOYTYXrfQTVuevr1LEF5" asyncio.set_event_loop(loop) rtm_client = slack.RTMClient(token=slack_token, ssl=ssl_context, run_async=True, loop=loop) loop.run_until_complete(rtm_client.start())
def run(self): if self.init(): self.log.info("Slack bot connecting to server") self.slack_client = slack.RTMClient(token=self.slackBotToken) self.slack_client.on(event='message', callback=handle_message) self.slack_client.start()
game.shield = message[len(message_words[0]) + 1:] utils.send_channel_message(game.channel_id, "<!channel>\nThe shield has been updated to %s!" \ % game.shield) elif message_words[0] == "!set_end_words": game.end_string = message[len(message_words[0]) + 1:] save_game(game) else: print("throw") utils.send_users_message([user], "Unrecognized command! Or maybe unformatted. I'm disappointed. " + \ "Message !help for a list of available commands!") except: print("input error") if __name__ == "__main__": global game # with open('stdout.log', 'w') as stdout, redirect_stdout(stdout): # with open('errors.log', 'w') as stderr, redirect_stderr(stderr): game = Game(channel = "test-codeassassin", weapon = "chicken egg", shield = "banana") #game = load_game() while(1): rtm_client = slack.RTMClient(token=utils.get_oauth_token()) rtm_client.start() print("Done at %s" % date.today().strftime("%B %d, %Y"))
def setUp(self): self.client = slack.RTMClient(token="xoxp-1234", auto_reconnect=False)
webclient = payload['web_client'] await webclient.chat_postMessage(channel=channel, text=message) def parse_direct_mention(message_text): """ Finds a direct mention (a mention that is at the beginning) in message text and returns the user ID which was mentioned. If there is no direct mention, returns None """ matches = re.search(MENTION_REGEX, message_text) # the first group contains the username, the second group contains the remaining message return (matches.group(1), matches.group(2).strip()) if matches else (None, None) if __name__ == "__main__": # TODO (Future Work): Verify if it is possible to use @mentions in a more elegant way slack_web_client = slack.WebClient(SLACK_BOT_TOKEN) # extract the bot_id in order to check if it is mentioned in a channel conversation if bot_id is None: bot_id = slack_web_client.api_call("auth.test")["user_id"] loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) slack_client = slack.RTMClient(token=SLACK_BOT_TOKEN, run_async=True, loop=loop) loop.run_until_complete(slack_client.start())
import slack import apis.keys my_token = apis.keys.SLACK_TOKEN rtmclient = slack.RTMClient(token=my_token) webclient = slack.WebClient(my_token) def get_rtm_client(): return rtmclient def get_web_client(): return webclient
def setUp(self): setup_mock_web_api_server(self) self.client = slack.RTMClient(token="xoxp-1234", base_url="http://localhost:8888", auto_reconnect=False)
async def slack_main(): loop = asyncio.get_event_loop() rtm_client = slack.RTMClient(token=slack_token, run_async=True, loop=loop) executor = concurrent.futures.ThreadPoolExecutor(max_workers=1) await asyncio.gather(loop.run_in_executor(executor, sync_loop), rtm_client.start())
web_client.chat_postMessage( channel=channel_id, text=("The score is now updated.") ) if ('report' in data['text']) and not ('text' in data['text']): web_client.chat_postMessage( channel=channel_id, text=("Sending out a graphic report...") ) EmailReports.Slackbot_Screenshot() if ('text' in data['text']) and ('report' in data['text']): web_client.chat_postMessage( channel=channel_id, text=("Sending out a text report...") ) EmailReports.Slackbot_Text() def post_img(filename, channel_id): response = client.files_upload( channels=channel_id, file=filename) assert response["ok"] if __name__ == "__main__": slack_token = os.environ["SLACK_API_TOKEN"] # Get API token from virtual environment (set in Autorun.py) client = slack.WebClient(token=slack_token, proxy='ENTER PROXY') rtm_client = slack.RTMClient(token=slack_token, proxy='ENTER PROXY') rtm_client.start()
summary_parser = subparsers.add_parser('summary', help='Summarize a cluster by ID.') summary_parser.add_argument('cluster', metavar='ID', help='The cluster ID.') summary_parser.set_defaults(func=handle_summary) set_summary_parser = subparsers.add_parser( 'set-summary', help= 'Set (or edit) the cluster summary. The line following the set-summary command will be used in the summary subject, and subsequent lines will be used in the summary body.' ) set_summary_parser.add_argument('cluster', metavar='ID', help='The cluster ID.') set_summary_parser.set_defaults(func=handle_set_summary) detail_parser = subparsers.add_parser( 'detail', help='Upload a file to Slack with the cluster summary and all comments.') detail_parser.add_argument('cluster', metavar='ID', help='The cluster ID.') detail_parser.set_defaults(func=handle_detail) comment_parser = subparsers.add_parser( 'comment', help= 'Add a comment on a cluster by ID. The line following the comment command will be used in the summary subject, and subsequent lines will be used in the summary body.' ) comment_parser.add_argument('cluster', metavar='ID', help='The cluster ID.') comment_parser.set_defaults(func=handle_comment) # start the RTM socket rtm_client = slack.RTMClient(token=os.environ['SLACK_BOT_TOKEN']) logger.info("bot starting...") rtm_client.start()
def main(): rtm_client = slack.RTMClient(token=os.environ["BOT_ACCESS_TOKEN"]) print("bot START!") print(register) res = rtm_client.start() print(res)
def live(self): info("Starting Real-Time Message monitoring") rtm_client = slack.RTMClient(token=self.args.get('token')) rtm_client.start()
slack_client = slack.WebClient(token=bot_token) @slack.RTMClient.run_on(event='message') def express_pure_rage(**payload): #RETURN ALL NEEDED INFORMATION TO DECIDE WHETHER OR NOT THE USER #SHOULD DIE data = payload['data'] web_client = payload['web_client'] rtm_client = payload['rtm_client'] MESSAGE = data['text'] if not MESSAGE.isupper(): RESPONSE = "ICI, ON ÉCRIT EN MAJUSCULE! TU DEVRAIS ÉCRIRE: " + MESSAGE.upper( ) channel_id = data['channel'] thread_ts = data['ts'] user = data['user'] web_client.chat_postMessage(channel=channel_id, text=RESPONSE, as_user=True) if __name__ == "__main__": if slack_client.rtm_connect(): print("RAGEBOT IS CONNECTED! REEEEEEEEEE") rtm_client = slack.RTMClient(token=bot_token) rtm_client.start() else: print("CONNECTION FAILED! CHECK YOUR BOT TOKEN YOU DAMNED NORMIE!")
def open(self, token): self.rtm_client = slack.RTMClient(token=token) self.rtm_client.start()
from BasicBot import respond @slack.RTMClient.run_on(event='message') def respond_to_message(**payload): data = payload['data'] if 'subtype' in data and data['subtype'] == 'bot_message': return web_client = payload['web_client'] content = data['text'] print('Got a message: {}'.format(content)) if content.startswith('<@'): content = content.split(' ', 1)[1] channel_id = data['channel'] user = data['user'] web_client.chat_postMessage(channel=channel_id, text='<@{}> {}'.format(user, respond(content))) print('Bot running ------------\n') client = slack.RTMClient(token=bot_token, connect_method='rtm.start') client.start()
@slack.RTMClient.run_on(event='message') def say_hello(**payload): # print(payload.keys()) data = payload['data'] # print(data) web_client = payload['web_client'] # rtm_client = payload['rtm_client'] if 'text' in data.keys(): print(data['text']) if 'Hello' in data['text']: channel_id = data['channel'] thread_ts = data['ts'] user = data['user'] web_client.chat_postMessage(channel=channel_id, text=f'Hi <@{user}>!', thread_ts=thread_ts, username=USER) # print('Done!') if __name__ == '__main__': rtm_client = slack.RTMClient(token=_TOKEN) try: rtm_client.start() except KeyboardInterrupt: rtm_client.stop()
def __init__(self): _LOGGER.debug('new SlackBridge instance') _LOGGER.debug('connecting to redis') self.redis = redis.Redis(host=REDIS_HOSTNAME, port=REDIS_PORT, password=REDIS_PASSWORD, charset="utf-8", decode_responses=True) _LOGGER.debug('connecting to zulip') self.zulip_client = zulip.Client(email=ZULIP_BOT_EMAIL, api_key=ZULIP_API_KEY, site=ZULIP_URL) self.zulip_thread = threading.Thread(target=self.run_zulip_listener) self.zulip_thread.setDaemon(True) self.zulip_thread.start() # self.zulip_ev_thread = threading.Thread(target=self.run_zulip_ev) # self.zulip_ev_thread.setDaemon(True) # self.zulip_ev_thread.start() self.user_formatter = slack_reformat.SlackUserFormatter( lambda user_id: self.get_slack_user( user_id, web_client=self.slack_web_client)) if GROUPME_ENABLE: _LOGGER.debug('connecting to groupmes') self.groupme_threads = {} for channel, conf in GROUPME_TWO_WAY.items(): self.groupme_threads[channel] = threading.Thread( target=self.run_groupme_listener, args=(channel, conf)) self.groupme_threads[channel].setDaemon(True) self.groupme_threads[channel].start() @slack.RTMClient.run_on(event='message') async def receive_slack_msg(**payload): _LOGGER.debug('caught slack message') _LOGGER.debug('JSON: %s' % json.dumps(payload['data'])) try: data = payload['data'] web_client = payload['web_client'] rtm_client = payload['rtm_client'] bot = False edit = False delete = False me = False attachments = [] files = [] if ('subtype' in data and data['subtype'] == 'message_changed'): data.update(data['message']) edit = True elif ('subtype' in data and data['subtype'] == 'message_deleted'): data.update(data['previous_message']) delete = True if ('subtype' in data and data['subtype'] == 'message_replied'): return # This needs to be below the handling of message_changed and # message_deleted as the message might be replaced with a # bot_message. if (('subtype' in data and data['subtype'] == 'bot_message') or ('bot_id' in data and 'user' not in data)): bot_id = data['bot_id'] user_id = await self.get_slack_bot(bot_id, web_client=web_client) if not user_id: _LOGGER.debug("no bot found") return if user_id == SLACK_BOT_ID: _LOGGER.debug("oops that's my message!") return bot = True if not bot: user_id = data['user'] channel_id = data['channel'] thread_ts = data['ts'] user = await self.get_slack_user(user_id, web_client=web_client) if not user: return channel = await self.get_slack_channel(channel_id, web_client=web_client) if not channel: return # Clean up formatting of message before we forward it. # This does not deal with attachments, # which are dealt with in a per-service way. data['text'] = \ await slack_reformat.reformat_slack_text(self.user_formatter, data['text']) if (channel['type'] == 'channel' or channel['type'] == 'private-channel'): msg = data['text'] channel_name = channel['name'] private = (channel['type'] == 'private-channel') if ('subtype' in data and data['subtype'] in GROUP_UPDATES): msg_id = None user = None elif ('subtype' in data and data['subtype'] == 'me_message'): msg_id = None me = True if 'edited' in data: edit = True elif 'client_msg_id' in data: msg_id = data['client_msg_id'] elif 'bot_id' in data: msg_id = None else: msg_id = None _LOGGER.warning("no msg id for user %s: %s", user, data) if 'attachments' in data: attachments = data['attachments'] if 'files' in data: files = data['files'] # TODO: When real support for 'files' is implemented, # it should probably be in the format_attachments_for_zulip # call. # if 'files' in data: # for file in data['files']: # web_client.files_sharedPublicURL(id=file['id']) # if msg == '': # msg = file['permalink_public'] # else: # msg += '\n' + file['permalink_public'] formatted_attachments = \ await slack_reformat.format_attachments_from_slack( msg, attachments, edit or delete, self.user_formatter) # Assumes that both markdown and plaintext need a newline together. needs_leading_newline = \ (len(msg) > 0 or len(formatted_attachments['markdown']) > 0) formatted_files = slack_reformat.format_files_from_slack( files, needs_leading_newline, SLACK_TOKEN, self.zulip_client) zulip_message_text = \ msg + formatted_attachments['markdown'] + formatted_files['markdown'] if channel_name in PUBLIC_TWO_WAY: self.send_to_zulip(channel_name, zulip_message_text, user=user, send_public=True, slack_id=msg_id, edit=edit, delete=delete, me=me) # If we are not sending publicly, then we are sending for # logging purposes, which might be disabled. if ZULIP_LOG_ENABLE: self.send_to_zulip(channel_name, zulip_message_text, user=user, slack_id=msg_id, edit=edit, delete=delete, me=me, private=private) # If groupme is enabled, then send there. Note that this # will also filter to only the GROUPME_TWO_WAY channels # within the send_to_groupme call. if GROUPME_ENABLE: groupme_message_text = \ msg + formatted_attachments['plaintext'] + formatted_files['plaintext'] self.send_to_groupme(channel_name, groupme_message_text, user=user, edit=edit, delete=delete, me=me) elif channel['type'] == 'im': _LOGGER.debug('updating user display name') user = await self.get_slack_user(user_id, web_client=web_client, force_update=True) await self.slack_web_client.chat_postMessage( channel=channel_id, text="OK, I have updated your display name for Slack \ messgaes on Zulip. Your name is now seen as: *" + user + "*.", mrkdwn=True) elif channel['type'] == 'group': await self.slack_web_client.chat_postMessage( channel=channel_id, text="I'm not sure what I'm doing here, so I'll just \ be annoying.", mrkdwn=True) except: e = sys.exc_info() exc_type, exc_value, exc_traceback = e _LOGGER.error( 'Error receive slack message: %s, %s', repr( traceback.format_exception(exc_type, exc_value, exc_traceback)), data) _LOGGER.debug('connecting to slack') self.slack_loop = asyncio.new_event_loop() self.slack_rtm_client = slack.RTMClient(token=SLACK_TOKEN, run_async=True, loop=self.slack_loop) self.slack_web_client = slack.WebClient(token=SLACK_TOKEN, run_async=True, loop=self.slack_loop) self.slack_log_format = '%(asctime)s %(name)-12s %(levelname)-8s %(message)s' self.slack_log_formatter = logging.Formatter(self.slack_log_format) self.slack_logger = SlackHandler(self.slack_web_client, self.slack_loop, SLACK_ERR_CHANNEL) self.slack_logger.setLevel(logging.INFO) self.slack_logger.setFormatter(self.slack_log_formatter) logging.getLogger('').addHandler(self.slack_logger) self.slack_loop.run_until_complete(self.slack_rtm_client.start())
ombi_api = 'apikey=INSERT YOUR KEY' root_folder = '/Users/azuser/media/movies' headers = { 'Content-Type': 'application/json', } params = ( ('apikey', 'xxxxxx'), ) # instantiate Slack client rtmclient = slack.RTMClient(token='INSERT YOUR TOKEN') # starterbot's user ID in Slack: value is assigned after the bot starts up starterbot_id = None @slack.RTMClient.run_on(event='message') def get_movie(**payload): data = payload['data'] if 'add' in data['text']: channel_id = data['channel'] thread_ts = data['ts'] user = data['user'] full_url = ombi_url + ombi_api + "&" + "t=" + data['text'] params = { 'apikey': 'INSERT API KEY', 't': data['text'].strip('add ') } #print (data['text'].strip('add'))
# ============== Message Events ============= # # When a user sends a DM, the event type will be 'message'. # Here we'll link the message callback to the 'message' event. @slack.RTMClient.run_on(event="message") async def message(**payload): """Display the onboarding welcome message after receiving a message that contains "start". """ data = payload["data"] web_client = payload["web_client"] channel_id = data.get("channel") user_id = data.get("user") text = data.get("text") if text and text.lower() == "start": return await start_onboarding(web_client, user_id, channel_id) if __name__ == "__main__": logger = logging.getLogger() logger.setLevel(logging.DEBUG) logger.addHandler(logging.StreamHandler()) ssl_context = ssl_lib.create_default_context(cafile=certifi.where()) slack_token = os.environ["SLACK_BOT_TOKEN"] loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) rtm_client = slack.RTMClient( token=slack_token, ssl=ssl_context, run_async=True, loop=loop ) loop.run_until_complete(rtm_client.start())
import slack from rpg_helper import RPGHelper @slack.RTMClient.run_on(event="message") def respond_to_messages(**payload): '''Responds to messages on every channel if needed.''' if any(key not in payload for key in ("data", "web_client")): return data = payload["data"] web_client = payload["web_client"] if any(key not in data for key in ("text", "channel", "user")): return resp = RPGHELPER.handle_command(data["user"], data["text"]) if resp: web_client.chat_postMessage(channel=data["channel"], text=resp) if __name__ == "__main__": PARSER = argparse.ArgumentParser() PARSER.add_argument("-l", "--load", default="minatoris", help="Load a game by default on start") ARGS = PARSER.parse_args() RPGHELPER = RPGHelper(ARGS.load) slack.RTMClient(token=os.environ["slack_token"]).start()
# this is not supposed to happen! print("Oops something bad happened.") # checksum is right after send if send_index is not None: video_name_checksum = word_list[send_index + 1] print(f"Sending {video_name_checksum}.") # web_client = payload['web_client'] # rtm_client = payload['rtm_client'] # message = data["text"] @slack.RTMClient.run_on(event="message") def handleCommands(**payload): data = payload["data"] if data.get("user") == "UQMNRUT88": parseMotionCommands(data) parseListCommands(data) parseSendCommands(data) def get_slack_token(file_path): with open(file_path) as token_file: return token_file.readline() return None if __name__ == "__main__": client = slack.RTMClient(token=get_slack_token("slack_token.dat")) client.start()
message = new_channel_message.get_message_payload() web_client.chat_postMessage(**message) def send_new_user_message(web_client: slack.WebClient, report_channel: str, new_user: str) -> None: """Send a message to a channel about a new user event. Automatically pins the message. :param web_client: The client to respond on :param report_channel: The channel to send the message to :param new_user: The new slack user object """ new_user_message = NewUserMessage(report_channel, new_user) message = new_user_message.get_message_payload() response = web_client.chat_postMessage(**message) # Pin this message to the channel web_client.pins_add(channel=response['channel'], timestamp=response['ts']) if __name__ == '__main__': logging.basicConfig( level=logging.INFO, format= '[%(asctime)s] {%(filename)s:%(lineno)d} %(levelname)s - %(message)s') SLACK_TOKEN = os.environ['SLACK_BOT_TOKEN'] rtm_client = slack.RTMClient(token=SLACK_TOKEN) rtm_client.start()