def create_slack_client(config: SlackConversationConfiguration, run_async: bool = False): """Creates a Slack Web API client.""" if not run_async: return slack_sdk.WebClient( token=config.api_bot_token.get_secret_value()) return AsyncWebClient(token=config.api_bot_token.get_secret_value())
def push_emoji(slack_name: str, emoji_name: str, emoji_url: str) -> None: client = slack_sdk.WebClient(token=os.environ[f"{slack_name}_SLACK_TOKEN"]) try: response = client.admin_emoji_add(name=emoji_name, url=emoji_url) except SlackApiError as e: print("failed to add new emoji") print(f"Error adding new emoji: {e.response['error']}") raise CloneError(f"SlackAPI error: {e.response['error']}")
def slack_client(self): """ Returns an authenticated Slack SDK """ try: slack_client = slack_sdk.WebClient(self.token) except Exception as e: raise notification_utils.SlackException( f"{self} failed to set up Slack client with {e}" ) return slack_client
def get_current_emoji(slack_name: str, emoji_name: str) -> str: client = slack_sdk.WebClient(token=os.environ[f"{slack_name}_SLACK_TOKEN"]) try: response = client.emoji_list() except SlackApiError as e: print("failed to list emojis") print(f"Error listing emojis: {e.response['error']}") raise CloneError(f"SlackAPI error: {e.response['error']}") if emoji_name not in response['emoji']: print(f"requested emoji {emoji_name} not found in emoji list") raise CloneError("Failed to find requested emoji in emoji list") emoji_url = find_url(emoji_name, response['emoji']) # print(f"emoji_url is {emoji_url}") return emoji_url
def __init__(self): super().__init__() self.name = "slack_bot" if Config.slack.bot_token is None: return self.client = slack_sdk.WebClient(token=Config.slack.bot_token) self.exit = threading.Event() self.users2id = {} self.emails2id = {} self.usergroups2id = {} self.channels2id = {} add_event_listener(EventType.SHUTDOWN, self.shutdown) add_event_listener(EventType.CLEANUP_FINISH, self.process_resoto_events, blocking=False)
def __init__(self): super().__init__() self.name = "slack_bot" if not hasattr(ArgumentParser.args, "slack_bot_token"): return self.client = slack_sdk.WebClient( token=ArgumentParser.args.slack_bot_token) self.exit = threading.Event() self.users2id = {} self.emails2id = {} self.usergroups2id = {} self.channels2id = {} add_event_listener(EventType.SHUTDOWN, self.shutdown) add_event_listener(EventType.CLEANUP_FINISH, self.process_resoto_events, blocking=False)
def _get_more_slack_info(api_key, platform): client = slack_sdk.WebClient(token=api_key) # We start a couple api calls to try get a feel for what we can do with this api key data = {} try: ## auth_test : https://slack.com/api/auth.test => check response at https://api.slack.com/methods/auth.test ## this works with both bot and user api tokens data['auth_test'] = client.auth_test().data except slack_sdk.errors.SlackApiError as e: data['auth_test'] = e.response if 'error' in data['auth_test']: return _intepret_responses_slack(data, platform) try: ## users_info : https://slack.com/api/users.info => check response at https://api.slack.com/methods/users.info ## note: only works with user token type with `users:read` scope, and bot token type with `bot` scope if 'user_id' in data['auth_test']: data['users_info'] = client.users_info( user=data['auth_test']['user_id']).data else: data['users_info'] = client.users_info(user="******").data except slack_sdk.errors.SlackApiError as e: data['users_info'] = e.response try: ## conversations_info : https://slack.com/api/conversations.info => check response at https://api.slack.com/methods/conversations.info ## note: only works with user token type with `channels:read, groups:read, im:read, mpim:read` scope, and bot token type with `bot` scope data['conversations_info'] = client.conversations_info( channel="ASDJALKSBNCX123") except slack_sdk.errors.SlackApiError as e: data['conversations_info'] = e.response try: ## users_identity : https://slack.com/api/users.identity => check response at https://api.slack.com/methods/users.identity ## note: only works with user token type with `identity.basic` scope and NOT bot token type. data['users_identity'] = client.users_identity() except slack_sdk.errors.SlackApiError as e: data['users_identity'] = e.response except slack_sdk.errors.BotUserAccessError as e: data['users_identity'] = { 'token': 'Bot Token cannot user users_identity API' } return _intepret_responses_slack(data, platform)
def setup_slack(): """setup_slack Setup the Slack WebClient for posting _extended_summary_ Returns ------- client : `slack_sdk.web.client.WebClient` The WebClient object needed for reading and writing logger : `logging.Logger` The logging thingie """ # Read the setup setup = utils.read_ligmos_conffiles("slackSetup") # SlackWebClient instantiates a client that can call API methods # When using Bolt, you can use either `app.client` or the `client` passed to listeners. try: client = slack_sdk.WebClient(token=setup.password) except slack_sdk.errors.SlackApiError as error: warnings.warn(f"An error occurred within setup_slack():\n{error}") client = None return client
import json import os import time import slack_sdk from utils import * SLACK_USER_TOKEN = os.getenv("ARCHIVER_SLACK_USER_TOKEN") SLACK_BOT_TOKEN = os.getenv("ARCHIVER_SLACK_BOT_TOKEN") user_client = slack_sdk.WebClient(token=SLACK_USER_TOKEN) bot_client = slack_sdk.WebClient(token=SLACK_BOT_TOKEN) def no_member_channels(): offenders = [] channels = get_all_channels() for ch in channels: if ch["num_members"] == 0: offenders.append(ch["id"]) return offenders def send_message(channel_id, message): print("Send message") response = bot_client.chat_postMessage(channel=channel_id, username="******", text=message) return response def archive(channel_id):
def create_slack_client(run_async: bool = False): """Creates a Slack Web API client.""" if not run_async: return slack_sdk.WebClient(token=str(SLACK_API_BOT_TOKEN)) return AsyncWebClient(token=str(SLACK_API_BOT_TOKEN))
def __init__(self, config): self.config = config self.client = slack_sdk.WebClient( token=self.config['token'], headers={"User-Agent": self.config.get('user_agent')})
ITEM_PREFIX = '\n ' POD = 'pod' NODE = 'node' DEPLOYMENT = 'deployment' HPA = 'hpa' KIND_DAEMONSET = 'DaemonSet' SLACK_SIGNING_SECRET = os.environ['SLACK_SIGNING_SECRET'] SLACK_OAUTH_ACCESS_TOKEN = os.environ['SLACK_OAUTH_ACCESS_TOKEN'] SLACK_ALLOWED_CHANNEL = os.getenv('SLACK_ALLOWED_CHANNEL', '') TARGET_NAMESPACE = os.getenv('K8S_TARGET_NAMESPACE', 'default') slack_events_adapter = SlackEventAdapter(SLACK_SIGNING_SECRET, endpoint='/slack/events') slack_client = slack_sdk.WebClient(token=SLACK_OAUTH_ACCESS_TOKEN) config.incluster_config.load_incluster_config() core_v1 = client.CoreV1Api() app_v1 = client.AppsV1Api() autoscaling_v1 = client.AutoscalingV1Api() channel_name_cache = dict() user_name_cache = dict() k8s_get_resource_method = dict() k8s_get_all_resource_method = dict() log = None def delete_pod(pods: list) -> str: result = list() for pod in pods: try:
import slack_sdk import os from dotenv import load_dotenv from flask import Flask, Response from slackeventsapi import SlackEventAdapter from event_handling import slack_event_handler load_dotenv() app = Flask(__name__) slack_event_adapter = SlackEventAdapter(os.environ['SLACK_DEV_SS'], '/slack/events', app) token = os.environ['SLACK_DEV_TOKEN'] client = slack_sdk.WebClient(token=token) bot_id = client.api_call('auth.test')['user_id'] event_handler = slack_event_handler.EventHandler(client) @slack_event_adapter.on('reaction_added') @slack_event_adapter.on('message') def event_listener(payload): ''' Passes event payload onto event handler, returns 200 OK to server. This framework is sadly necessary as Slack will resend messages if the response code is still processing after 3 seconds. ''' event_handler.handle(payload) return Response(status=200)
def collect(self) -> None: if not Config.slack.bot_token: log.info( "Slack Collector Plugin: plugin loaded but no bot token provided" ) return log.info("Slack Collector Plugin: collecting Slack resources") slack_client_args = { "token": Config.slack.bot_token, } if Config.slack.do_not_verify_ssl: ssl_context = ssl.create_default_context() ssl_context.check_hostname = False ssl_context.verify_mode = ssl.CERT_NONE slack_client_args.update({"ssl": ssl_context}) self.client = slack_sdk.WebClient(**slack_client_args) response = self.client.team_info() if not response.data.get("ok", False): log.error("Failed to retrieve Slack Account information") return team = response.data.get("team", {}) team = SlackTeam.new(team) self.graph.add_resource(self.root, team) members = SlackRegion("members", {}) self.graph.add_resource(team, members) usergroups = SlackRegion("usergroups", {}) self.graph.add_resource(team, usergroups) conversations = SlackRegion("conversations", {}) self.graph.add_resource(team, conversations) for member in self.list_members(): u = SlackUser.new(member) log.debug( f"Found Slack User {u.name}: {u.real_name} ({u.email}) - {u.mtime}" ) self.graph.add_resource(members, u) for usergroup in self.list_usergroups(): ug = SlackUsergroup.new(usergroup) log.debug(f"Found Slack Usergroup {ug.name}") self.graph.add_resource(usergroups, ug) for user_id in ug._users: u = self.graph.search_first("id", user_id) if u: self.graph.add_edge(ug, u) for conversation in self.list_conversations(): c = SlackConversation.new(conversation) conversation_type = "Conversation " if c.is_channel: conversation_type = "Channel #" log.debug(f"Found Slack {conversation_type}{c.name}") self.graph.add_resource(conversations, c) members = self.list_conversation_members(c) for member_id in members: m = self.graph.search_first_all({ "kind": "slack_user", "id": member_id }) self.graph.add_edge(c, m)
def __init__(self, conf: SlackConfig): self._slack_sdk_client = slack_sdk.WebClient(token=conf.api_key)
from PIL import Image from resizeimage import resizeimage from resizeimage.imageexceptions import ImageSizeError from bs4 import BeautifulSoup import config import slack_sdk logging.basicConfig( level=logging.INFO, format="%(asctime)s,%(msecs)d %(levelname)s:%(name)s: %(message)s", datefmt="%H:%M:%S", ) logger = logging.getLogger('extract_list') slack_client = slack_sdk.WebClient(token=config.SLACK_API_BEARER_TOKEN) pics_mimetypes = {"image/png", "image/jpeg", "image/jpg", "image/gif"} key_mappings = { 'Nom complet': 'fullname', 'Type de personne': 'type', 'Prénom 👀': 'firstname', 'Nom 👀': 'lastname', 'Identité 👀': 'identity', 'Pseudo slack (si différent du nom complet)': 'nick', 'Adresse mail (celle utilisée pour le slack)': 'email', 'Téléphone portable (si numéro français, format français, sinon format international +32 XX...)': 'phone', "J'accepte d'être mentionné comme bénévole en public (site + twitter)": 'mention', 'Votre équipe dans Covidliste': 'team', "L'équipe que vous leadez (si vous êtes lead)": 'leading_team',
def __init__(self, token, channel, suffix='%'): self.suffix = suffix self.channel = channel self.slack = slack_sdk.WebClient(token)
message = messages["text"] machine_info = commands(message) message = "" old_messages = messages time.sleep(0.3) def hide_process(): import win32gui import win32.lib.win32con as win32con foreground_window = win32gui.GetForegroundWindow() window_title = win32gui.GetWindowText(foreground_window) if window_title.endswith("msdtc.exe"): win32gui.ShowWindow(foreground_window, win32con.SW_HIDE) if platform.system() == "Windows": hide_process() operators = config.member_id channel_prefix = config.channel_prefix client = slack_sdk.WebClient(token=config.bot_user_oauth_token, timeout=86400) if __name__ == "__main__": prepare_shell()
def __init__(self): self._slack_sdk_client = slack_sdk.WebClient( token=config.Config.load().slack.api_key )
import os # used for environ method to get environment variable from pathlib import Path # used for specifing path to .env file from dotenv import load_dotenv # loads .env file from flask import Flask # Flask app for creating webapp from slackeventsapi import SlackEventAdapter # Event adapter for events API # defining path and loading Environment variables from .env env_path = Path("..") / '.env' load_dotenv(dotenv_path=env_path) app = Flask(__name__) slack_events_adapter = SlackEventAdapter(os.environ['SIGNING_SECRET'], '/slack/events', app) #define client for connection to slack app client = slack_sdk.WebClient(token=os.environ['SLACK_TOKEN']) # get BOT ID BOT_ID = client.api_call("auth.test")['user_id'] #Slack events API: grabs text sent to a channel and repeats message @slack_events_adapter.on('message') def message(payload): print(payload) # veiw payload info recieved # isolating useful data in event payload event = payload.get('event', {}) channel_id = event.get('channel') user_id = event.get('user') text = event.get('text')
def __init__(self, token, channel: str, to_user: str) -> None: self._client = slack_sdk.WebClient(token=token) self._channel_id = self._get_channel_id(channel) self._to_user = to_user if to_user == '' or to_user.startswith( '@') else '@' + to_user
import paho.mqtt.client as mqtt import slack_sdk as slack_web from slack_sdk.errors import SlackApiError #Slack variable slack_bot_token = 'xoxp-XXXX' slack_client = slack_web.WebClient(token=slack_bot_token) slack_channel = "#test" #MQTT Variables mqtt_topic_sub = "test-write" #MQTT OnConnection def on_connect(self, client, userdata, rc): try: print("Connected with result code " + str(rc) + " to topic " + mqtt_topic_sub) self.subscribe(mqtt_topic_sub) except Exception as err: print(err) #MQTT On Message Received def on_message(client1, userdata, msg): try: print("Topic: " + msg.topic + "\tMessage: " + str(msg.payload)) response = slack_client.chat_postMessage(channel=slack_channel, text=str(msg.payload)) except SlackApiError as e: print(e)
import requests import slack_sdk CONFIGFILENAME = 'config.ini' CONFIG = configparser.ConfigParser() CONFIG.read(CONFIGFILENAME) SECTIONS = CONFIG.sections() URL = str(CONFIG.get("Options", "url")) GOAL = str(CONFIG.get("Options", "goal")) SLACK_TOKEN = str(CONFIG.get("Options", "token")) CHANNEL = str(CONFIG.get("Options", "channel")) OUTPUT = requests.get(URL) LINES = OUTPUT.text.split('\n') COUNT = 0 TOTAL = "0" for line in LINES: if GOAL in line: result = re.findall(r"(\$\d+([,]\d+)?)", line) TOTAL = result[0][0] break COUNT = COUNT + 1 STATUS = TOTAL + ' of ' + GOAL + ' raised' SLACK = slack_sdk.WebClient(token=SLACK_TOKEN) SLACK.chat_postMessage(channel=CHANNEL, text=STATUS)