def main(): input_token = input("token: ") client = Client.from_token(input_token) x = [] i = 1 print("Targets") print("0 - Quit") for chat in client.chats.list(): print(str(i) + ' - ', end="") print(chat.other_user['name']) x.append(chat) i += 1 message = "fck" i = 1 while (True): ''' input_target = input("target: ") if input_target == '0': break input_message = input("message: ") ''' #x[int(input_target)-1].post(text = input_message) x[int(2) - 1].post(text="Yo where you at?") print("message sent to: ", end="") print(x[1]) print("#: ") print(i) i += 1 '''
def init(): global token, client, session, bots, headers, botID, botIDs, groupIDs, messageManager, index, indexDict, members, memList token = "*" client = Client.from_token(token) session = client.session bots = Bots(session) headers = { 'x-rapidapi-host': "apidojo-yahoo-finance-v1.p.rapidapi.com", 'x-rapidapi-key': "*" } # bot 0 = test # bot 1 = real bot = 0 run = True botIDs = ['*', '*'] groupIDs = ['*', '*'] index = 0 indexDict = {} botID = botIDs[bot] messageManager = Messages(session, groupIDs[bot]) members = client.groups.get(groupIDs[bot]).members memList = list() for member in members: memList.append(Portfolio(member.id)) memList[index].name = member.nickname indexDict[member.nickname] = index index = index + 1
def lambda_handler(event,context): # test=1 if test == 1: access_token=access_token_gordon group_name='PJW Calling Email Method' else: group_name='2017-2018 UT Captains' access_token=access_token_rishabh curr_date=datetime.datetime.now() weekday=curr_date.weekday() next_week=curr_date+datetime.timedelta(days=7) dt_str=str(next_week.month)+'/'+str(next_week.day) # Hardcoded inputs, these need to be changed to suit your needs if weekday==7 or weekday == 2 or weekday == 3: if weekday==7: msg="PJW Calling for next Sunday 8-10pm "+dt_str+"\n1. Greg South\n2. Greg North\n3. Trophy Room" elif weekday==2: msg="PJW Calling for next Tuesday 10-12pm "+dt_str+"\n1. Greg South\n2. Greg North\n3. Trophy Room" elif weekday==3: msg="PJW Calling for next Wednesday 10-12pm "+dt_str+"\n1. Greg South\n2. Greg North\n3. Trophy Room" client=Client.from_token(access_token) for group in client.groups.list_all(): if group.name==group_name: group.post(text=msg)
def __init__(self, config): self._client = Client.from_token(config.get('token')) self._groups = [] for group in client.groups.list(omit="memberships") if group.id == '49117054' self._groups.append( group )
def makeGroup(n, usrList): client = Client.from_token('jI9arGAkDrtNWAhKdKLnjaj182R2L7RLV7q9odFj') now = datetime.datetime.now() nDate = n + now.strftime() new_group = client.groups.create(name=nDate) for i in usrList: new_group.memberships.add(i[0], None, i[1], None)
def fetch_data(): if 'client_key' not in session: #do some sort of error pass else: client = Client.from_token(session['client_key']) return client
def groupMeGenerateGroup(studyGroup): # Generate client that does the work client = Client.from_token(GROUPME_TOKEN) # Create the group itself new_group = client.groups.create(name=studyGroup.name) studyGroup.group_id = new_group.group_id studyGroup.save()
def grab_song_links(GroupMe_Token, GroupMe_Group_Name): # Authorization Step, Returns Client client = Client.from_token(GroupMe_Token) # Grabs Group Chat group_chat = get_group_chat(client, GroupMe_Group_Name) # Grabs last message ID from previous runs last_message = get_last_id() # Grabs list of messages after last message try: list_of_messages = list(group_chat.messages.list_after(last_message)) #if there is no ID/not recognized, grabs every single message in the list except: list_of_messages = list(group_chat.messages.list().autopage()) # Note: Groupy list() function always returns a page of messages even if you # include a since_id so spotify song adder will always have to check if the song # isn't added already. Spotify song adder will need that function anyways to # make sure that the song hasn't been added by someone before. # Initializes list of songs to add to spotify list_of_songs = [] for message in list_of_messages: if message.text != None: x = message.text[message.text.find("https://open.spotify.com/track" ):message.text.find(" ")] if x: list_of_songs.append(x) # Creates new log ID last_message = list_of_messages[0].id filename = "log.txt" # opening the file with w+ mode truncates the file f = open(filename, "w+") f.close() logging.basicConfig(filename=("log.txt"), level=logging.DEBUG, format='%(message)s') logging.info(last_message) # Returns a reversed list as the list of messages is returned in reversed order. # Reversing the final list ensures that the songs are added in the same order they were sent. list_of_songs.reverse() return list_of_songs
def create_groupme_api(): keys = readKeys() groupme_key = keys['groupme']['access_token'] client = Client.from_token(groupme_key) groups = list(client.groups.list_all()) for group in groups: print(group.name) if group.name == 'Large Fry Larrys': lfl = group return lfl
def group_created(token): client = Client.from_token(token) groups = client.groups.list_all() group_created_times = {} for group in groups: group_created_times[group.name] = created_at(group) with open('Groups Created At.txt', 'w', encoding='utf8') as output: for name, timestamp in group_created_times.items(): output.write(name + ': ' + timestamp + '\n')
def groupMeJoinGroup(studyGroup, student: Student): # Generate client that does the work client = Client.from_token(GROUPME_TOKEN) # Get group object try: group = client.groups.get(studyGroup.group_id) except: print("Failed to find group") return # group = None # for g in client.groups.list_all(): # if str(g.name) == studyGroup.name: # group = g # Fancy out-of-library technique to do what I want - add via phone number mship = group.get_membership() memberships = Memberships(mship.manager.session, group_id=group.group_id) member = { 'nickname': str(student.name), 'phone_number': str(student.phone) } memberships.add_multiple(member) #result.poll(timeout=5, interval=0.1) time.sleep(1) try: group = client.groups.get(studyGroup.group_id) except: print("Failed to find group") return # Save their user id for later mem = None print(group.members) for m in group.members: print(str(m.nickname), str(student.name)) if str(m.nickname) == str(student.name): mem = m studyGroup.save() try: print(type(mem)) print(mem) print(mem.user_id) print(str(mem.user_id)) if str(mem.user_id) != "None": print("Entered if statement") student.groupme_id = str(mem.user_id) student.save() print("Finished if statement") else: print("Skipped if statement") except: print("Failed to save") pass
def message_birdbrains(message, token_fn=TOKEN_FN): with open(token_fn, 'r') as token_file: token = token_file.read() token = token.replace("\n", "") client = Client.from_token(token) bird_brains = [ group.name == 'Bird Brains' for group in client.groups.list() ] bird_brains = client.groups.list()[np.where(bird_brains)[0][0]] return bird_brains.post(text=message)
def load_logged_in_user(): user_id = session.get('user_id') username = session.get('user_id') token = session.get('token') if user_id is None: g.user = None else: g.user = { "user_id": int(user_id), "username": username, "client": Client.from_token(token) }
def __init__(self, cfg): self.token = cfg["ZeBanker"]["token"] self.groupme_group_id = cfg["ZeBanker"]["groupme_group_id"] self.donk_group_id = cfg["ZeBanker"]["donk_group_id"] self.output_dir = os.path.join(script_path, cfg["ZeBanker"]["output_dir_relative_to_script"]) self.message = cfg["ZeBanker"]["message"] == "True" self.bot_id = cfg["ZeBanker"]["bot_id"] self.client = Client.from_token(self.token) self.groupme_group = self.get_group() self.banker = None self.new_messages = None self.command = "" self.commander = None
def __init__(self): self.commands = { "!commands": self.list_commands, } self.commandDescriptions = { "!commands": "Lists all commands", } self.database = Database('GroupMe') self.Lastfm = LastfmCommands() self.commands.update(self.Lastfm.commands) self.commandDescriptions.update(self.Lastfm.commandDescriptions) self.client = Client.from_token(groupyToken) self.ran_tasks = False
def main(input_args): client = Client.from_token(input_args.token) if client is not None: stats_group = client.groups.get(input_args.groupid) print("Generating Stats for: " + stats_group.name) # Create a dict of members for name lookups print("Getting group members...") members = get_members(stats_group) print_members(members) # One last server update before grabbing everything print("Refreshing groups...") stats_group.refresh_from_server() #dump_chat_history_to_file(stats_group, "out.csv") dump_chat_history_to_file(stats_group, members)
def main(): # Create groupy client from access token client = Client.from_token(Config.token) myGroup = findGroup(client, Config.groupName) # make sure group is newly refreshed myGroup.refresh_from_server() allMessages = list(myGroup.messages.list().autopage()) memberList = [] for member in myGroup.members: memberList.append((member.user_id, member.nickname)) memberDict = memberDictBuilder(memberList, Config.keywords) countedMemberDict = getWordCounts(memberDict, allMessages, Config.keywords) displayData(countedMemberDict, memberList, Config.keywords)
def __init__(self, input_dict): ''' input dict : dictionary built with DataFromUser class with inputs ['gm_token', 'group_name', 'log_file', 'sp_client_id', 'sp_client_secret', 'sp_redirect', 'sp_username', 'sp_user_id', 'sp_playlist_id', 'playlist_name'] to act as dictionary keys ''' # Assign paramaters to class attributes self.__dict__.update(input_dict) self.sp_scope = "playlist-modify-public" # Groupme Client gp_client = Client.from_token(self.gm_token) # Groupme Groupchat groupchat = self.find_groupchat(gp_client) # Song URLs From Messages song_urls = self.get_tracks_from_groupchat( groupchat, self.find_last_checked_message(self.log_file)) # If there are new songs in the groupchat: if song_urls: # Login to Spotify sp_cred = SpotifyOAuth(client_id=self.sp_client_id, client_secret=self.sp_client_secret, redirect_uri=self.sp_redirect, username=self.sp_username, scope=self.sp_scope) self.sp = spotipy.Spotify(client_credentials_manager=sp_cred) # Add songs to Spotify playlist self.add_songs_to_playlist(song_urls)
def groupMeLeaveGroup(studyGroup: StudyGroup, student: Student): # Generate client that does the work client = Client.from_token(GROUPME_TOKEN) # Get group object try: group = client.groups.get(studyGroup.group_id) except: print("Failed to find group") return # Assumes their user_id is known mem = None for m in group.members: if str(m.user_id) == str(student.groupme_id): mem = m try: mem.remove() mem.save() except: pass
def login(): token = request.args.get('access_token') if not token is None: # Get client client = Client.from_token(token) error = None # Error check try: me = client.user.get_me() except: error = "Bad GroupMe login." if error is not None: flash(error) else: # Setup the session user_id = me["id"] username = me["name"] session.clear() session['user_id'] = user_id session['username'] = username session['token'] = token # Check for bot instances # Only useful in event of catastrophic DB failure bot_client = Bots(client.session) bots = bot_client.list() for bot in bots: if bot["name"] == config["name"]: db = get_db() if db.execute('SELECT * FROM bot WHERE group_id = ?', (bot["group_id"], )).fetchone() is None: # This bot instance is unrecorded bot_client.destroy(bot["bot_id"]) return redirect(url_for('index')) return render_template('auth/login.html')
def post(groups=True, message='#mathMemeMonday', limit=10 ,targetFile='targets.txt',credFile='credientials.txt'): token=getStringFromFile('token',credFile) client = Client.from_token(token) targets=setTargetsFromFile(targetFile) postTo=[] i=0 if(not groups): for chat in client.chats.list_all(): if (chat.other_user['name'] in targets): print('Adding: '+chat.other_user['name']+' to reciving list') postTo.append(chat) else: for group in client.groups.list(): if (group.id in targets): print('Adding: '+group.name+' to reciving list') postTo.append(group) for squad in postTo: while (i<limit): atts=[] if(not groups): print('Posting Meme '+str(i)+' to '+squad.other_user['name']) else: print('Posting Meme '+str(i)+' to '+squad.name) with open('meme'+str(i)+'.jpg','rb') as f: image=client.images.from_file(f) atts.append(image) mess=squad.post(text=message,attachments=atts) f.close() i+=1 i=0 while (i<10): os.remove('meme'+str(i)+'.jpg') i+=1 print('All Memes Posted')
def delete(self, *args, **kwargs): # Note this is a simple example. it only handles delete(), # and not replacing images in .save() print("deleting") group_id = None if (self.group_id != None): group_id = self.group_id super(StudyGroup, self).delete(*args, **kwargs) if (group_id != None): # Generate client that does the work client = Client.from_token(GROUPME_TOKEN) # Get group try: group = client.groups.get(group_id) except: print("Failed to find group") return print("destroying group") group.destroy()
from datetime import datetime from Bot.LastfmCommands import LastfmCommands from Database.Database import Database from Token import bot_id, groupyToken, groupy_id from groupy.client import Client from groupy.api.attachments import Mentions, Image client = Client.from_token(groupyToken) group = client.groups.get(groupy_id) class GroupmeCommandHandler: """The Groupme Command Handler Class. The command handler class is responsible for connecting the bot to API's and executing the commands. It contains the list of commands and their given descriptions; it also contains some default commands for controlling the bot. """ def __init__(self): self.commands = { "!commands": self.list_commands, } self.commandDescriptions = { "!commands": "Lists all commands", } self.database = Database('GroupMe')
"Sunday Brunch", "Sunday Dinner", "Monday Dinner", "Tuesday Dinner", "Wednesday Dinner", "Thursday Dinner" ] DAY_OFFSETS = { "Sunday Brunch": 0, "Sunday Dinner": 0, "Monday Dinner": 1, "Tuesday Dinner": 2, "Wednesday Dinner": 3, "Thursday Dinner": 4 } r = sr.Recognizer() from groupy.client import Client token = "d0d1772007dc0137492936e4528fcc3b" client = Client.from_token(token) #groups = client.groups.list(omit="memberships") #To see what groupmes available #for group in groups.autopage(): # print(group.name) group_chat_list = ["DH", "2018"] #list of stings that are in the groupchat name def post_to_DH(message): groups = client.groups.list(omit="memberships") for group in groups.autopage(): if all([a in group.name for a in group_chat_list]): message = group.post(text=message)
# import json file if present try: with open('secret.json', 'r') as f: DATA = json.load(f) if not DATA: DATA = {} except (NameError, FileNotFoundError): print( 'WARNING: no secret.json file present in project root, ignoring update' ) # config vars # os.environ == (heroku) environment global vars # replace with local values if desired # ex for each above definition try: # 1234567890abcdef1234567890abcdef GROUPME_TOKEN = os.getenv('GROUPME_TOKEN') or DATA['GROUPME_TOKEN'] CLIENT = Client.from_token(GROUPME_TOKEN) except NameError: raise Exception('***all necessary global config not defined***') def getIDs(): for group in CLIENT.groups.list(omit="memberships").autopage(): print(group.name + ' (' + group.id + ')') if __name__ == '__getIDs__': getIDs()
from groupy.client import Client from time import sleep from dotenv import load_dotenv from os import getenv load_dotenv() shakes = open('corpora/shakespeare.txt', 'r') groupme = Client.from_token(getenv('GROUPME_TOKEN')) dingus_parade = [ group for group in groupme.groups.list() if group.id == '19442193' ][0] for line in shakes: if line != "\n": dingus_parade.post(line) sleep(3)
def main(): """ :return: sets up the groups the bot will listen and then initialize the threads """ args = parser.parse_args() config_parser = configparser.ConfigParser() config_path = os.path.abspath(args.config) config_parser.read(config_path) try: chat_key = config_parser['keys']['groupme'] except KeyError: Utilities.log(f"Need groupme api key to continue") sys.exit(1) try: yt_key = config_parser['keys']['youtube'] except KeyError: yt_key = None delim = config_parser['bot']['delim'] refresh_group_interval = int( config_parser['bot']['refresh_group_interval']) consume_time = float(config_parser['bot']['consume_time']) client = Client.from_token(chat_key) groups = {} try: with open(os.path.abspath(args.groups), 'r') as all_groups: groups = json.load(all_groups) except FileNotFoundError: potential_groups = [] group_file_path = os.path.abspath(args.groups) for group in client.groups.list(): potential_groups.append((group.id, group.name)) print("Which groups to use the bot for?") for index, pair in enumerate(potential_groups): print(f"{index + 1}: {pair[1]}") choices = input("Which ones (comma separated): ").split(",") chosen_groups = {} for choice in choices: try: chosen_groups[potential_groups[int(choice) - 1][1]] = { "id": potential_groups[int(choice) - 1][0], "enabled": True } except ValueError: pass except IndexError: pass with open(os.path.abspath(group_file_path), 'w') as finalized_groups: json.dump(chosen_groups, finalized_groups, sort_keys=True, indent=2) print(f"created groups.json at {group_file_path}") groups = chosen_groups for group in groups: name = group group = groups[group] try: if group['enabled']: group = client.groups.get(group['id']) bot = Bot(group, yt_key=yt_key, delim=delim, refresh_group_interval=refresh_group_interval) Utilities.log(f"creating thread for {group.name}") threading.Thread(target=consume, name=group.name, daemon=True, args=(bot, consume_time)).start() except (IndexError, groupy.exceptions.BadResponse, requests.exceptions.HTTPError): Utilities.log(f"'{name}' group doesn't exist") signal.signal(signal.SIGINT, shutdown_bot) Utilities.log(f"Bot started up successfully")
import os from groupy.client import Client GROUP_ID = 46649296 TOKEN = os.environ['GROUPME_ACCESS_TOKEN'] client = Client.from_token(TOKEN) group = client.groups.get(id=GROUP_ID) targets = [ 'Chike Iwuagwu', 'hiba hamid', 'AIDAN YOO(NOT SIMON)', 'Walli Chen (penn daddy)', 'Simon', 'Nick Bausenwein (Penn)', 'Eashan Sahai', 'AJ Manning', 'Margaret LaMarche', 'Rachel Wilson', 'Nitin S', 'Mia McDonald', 'David Yang', 'David Lu', 'serin b', 'Halsey Ziglar', 'Langston Luck', 'Sophie Hirt', 'Nick Bausenwein (Penn)', 'Jacob K', 'Nicole Overton' ] for member in group.members: if member.nickname in targets: print(member.remove())
import model, sample, encoder from groupy.client import Client import asyncio import re import time import random #Your GroupMe client token from the top right corner of https://dev.groupme.com/ CLI_TOKEN = "CLIENT TOKEN HERE" GROUP_NAME = "GROUP NAME HERE" BOT_NAME = "BOT NAME HERE" #Init connection to groupMe client using your token client = Client.from_token(CLI_TOKEN) #Find the bot with name @BOT_NAME and store it as bot for bot in client.bots.list(): if bot.name == BOT_NAME: break #Find the group with name @GROUP_NAME and store it as @group for group in client.groups.list_all(omit="memberships"): if group.name == GROUP_NAME: break memberList = group.members #Precompile regular expressions for recognizing commands. #Precompilation improves the speed of recognition
# RESOURCE: http://www.apnorton.com/blog/2017/02/28/How-I-wrote-a-Groupme-Chatbot-in-24-hours/ # IMPORTS import os import json from urllib.parse import urlencode from urllib.request import Request, urlopen from flask import Flask, request from apscheduler.schedulers.blocking import BlockingScheduler import groupy from groupy.client import Client as groupmeClient gmclient = groupmeClient.from_token('vW461v8rqQ8tya2YGf4J6cSWV5MUoVI2tuNHI60R') for gmgroups in gmclient.groups.list(): if gmgroups.name == 'AW log (updates only)': gmlog = gmgroups #----------------from production log from selenium import webdriver #from selenium.webdriver.common.keys import Keys import selenium.webdriver.chrome.options import gspread from oauth2client.service_account import ServiceAccountCredentials import time from datetime import timedelta, datetime from pytz import timezone tztime = datetime.now(timezone('America/Los_Angeles')) scope = [ 'https://spreadsheets.google.com/feeds', 'https://www.googleapis.com/auth/drive' ]