def lastPost(groupname):
group = findGroup(groupname)
memberdict = {}
allmemdict = {}
nopostlist = []
messagelist = list(group.messages.list().autopage())
for member in group.members:
allmemdict[member.user_id] = member.name
for message in messagelist:
if message.user_id not in memberdict.keys():
memberdict[message.user_id] = {
"name": message.name,
"date": message.created_at
}
print("Most recent message per member:")
sorted_memberdict = sorted(memberdict.items(),
key=lambda x: x[1]["name"],
reverse=True)
for index in sorted_memberdict:
print(f"{index[1]['name']} - {index[1]['date'].strftime('%m-%d-%Y')}")
for key, val in allmemdict.items():
if key not in memberdict.keys():
nopostlist.append(val)
print(
f"\n{len(nopostlist)} members that haven't posted in {group.name}:\n{nopostlist}"
)
def messInMonth(groupname):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
memberdict = {}
monthlist = [6, 7, 8]
for member in group.members:
memberdict[member.user_id] = {"name": member.name, "mess": 0}
for message in messagelist:
# print(message.created_at.month)
if message.created_at.month in monthlist and message.created_at.year == datetime.today(
).year:
try:
memberdict[message.user_id]["mess"] += 1
except:
pass
sorted_memberdict = sorted(memberdict.items(),
key=lambda x: x[1]["mess"],
reverse=True)
for index in sorted_memberdict:
if index[10]["mess"] > 0:
print(f'{index[1]["name"]} - {index[1]["mess"]}')
def consecPosts(groupname):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
memberdict = {}
for member in group.members:
memberdict[member.user_id] = {
"name": member.name,
"curr": 0,
"high": 0,
"currlist": [],
"highlist": []
}
for message in messagelist:
for key, val in memberdict.items():
if message.user_id == key:
val["curr"] += 1
try:
val["currlist"].append(message.text)
except:
val["currlist"].append("A message")
if val["curr"] > val["high"]:
val["high"] = val["curr"]
val["highlist"] = val["currlist"]
else:
val["curr"] = 0
val["currlist"] = []
for val in memberdict.values():
if val['high'] > 1:
print(f"{val['name']} : {val['high']}")
print(f"{val['highlist']}\n\n")
def pullGroup(groupname):
group = findGroup(groupname)
folderpath = f".\\Offline\\{group.name}"
messagelist = list(group.messages.list().autopage())
memberdata = []
messagedata = []
# Create offline folder if needed
if not os.path.exists(folderpath):
os.makedirs(folderpath)
# Write members.csv
for member in group.members:
memberdata.append([member.user_id, member.name])
memberframe = pd.DataFrame(memberdata, columns=["user_id", "name"])
memberframe.to_csv(f"{folderpath}\\members.csv")
# Write messages.csv
for message in messagelist:
messagedata.append([
message.created_at, message.name, message.text,
message.favorited_by
])
messageframe = pd.DataFrame(
messagedata, columns=["created_at", "name", "text", "favorited_by"])
messageframe.to_csv(f"{folderpath}\\messages.csv")
def likeStats(groupname):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
memberdict = {}
memberlist = list(group.members)
path = f"./Groups/{group.name}"
if not os.path.exists(path):
os.makedirs(path)
for outer in memberlist:
memberdict[outer.user_id] = {}
for inner in memberlist:
memberdict[outer.user_id][inner.user_id] = 0
for message in messagelist:
if len(message.favorited_by) > 0:
for index in message.favorited_by:
try:
memberdict[message.user_id][index] += 1
except:
# print(message.data)
pass
with open(path + "/ExtendedLikeStats.txt", "w") as writer:
for key, val in memberdict.items():
writer.write(f"{findMember(group, key).name}\n")
for ikey, ival in val.items():
if ival > 0:
writer.write(f"\tLiked {findMember(group, ikey).name} - {ival}\n")
writer.write("\n\n")
def likeStreak(groupname):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
memberdict = {}
for member in group.members:
memberdict[member.user_id] = {"name" : member.name, "totallikes" : 0, "currstreak" : 0, "beststreak" : 0}
for message in messagelist:
for key, val in memberdict.items():
if key in message.favorited_by:
val["currstreak"] += 1
val["totallikes"] += 1
# While this is technically innacurate, it may be more "applicable"
# because users usually don't like their own messages
elif message.user_id == key:
pass
else:
if val["currstreak"] > val["beststreak"]:
val["beststreak"] = val["currstreak"]
val["currstreak"] = 0
print("Like Stats:")
for val in memberdict.values():
if val["beststreak"] > 0:
print(f"{val['name']}\n\tBest Streak - {val['beststreak']}\n\tTotal Likes - {val['totallikes']}\n")
def printPandas(groupname):
group = findGroup(groupname)
folderpath = f".\\Offline\\{group.name}"
memberframe = pd.read_csv(f"{folderpath}\\members.csv", index_col=0)
messageframe = pd.read_csv(f"{folderpath}\\messages.csv", index_col=0)
print(memberframe)
print(messageframe)
def mutedChat(groupname):
group = findGroup(groupname)
muted = 0
for member in group.members:
if member.muted:
muted += 1
print(f"{muted} members have {group.name} muted")
def eventsAttended(groupname, sincedate):
import pytz
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
if sincedate:
sincedate = datetime.strptime(sincedate, '%m/%d/%Y')
sincedate = pytz.UTC.localize(sincedate)
else:
sincedate = datetime.strptime("01/01/1999")
memberdict = {}
eventlist = []
for member in group.members:
memberdict[member.nickname] = {
"name": member.name,
"attended": 0,
"idlist": []
}
for message in messagelist:
if message.created_at > sincedate:
try:
# Don't count duplicate "going" responses
if message.data["event"][
"type"] == "calendar.event.user.going" and message.data[
"event"]["data"]["event"]["id"] not in memberdict[
message.data["event"]["data"]["user"]
["nickname"]]["idlist"]:
memberdict[message.data["event"]["data"]["user"]
["nickname"]]["attended"] += 1
memberdict[message.data["event"]["data"]["user"][
"nickname"]]["idlist"].append(
message.data["event"]["data"]["event"]["id"])
except:
pass
try:
if message.data["event"][
"type"] == "calendar.event.user.going" and message.data[
"event"]["data"]["event"]["name"] not in eventlist:
eventlist.append(
message.data["event"]["data"]["event"]["name"])
except:
pass
# {k: v for k, v in sorted(memberdict.items(), key=lambda item: item[1]["attended"])}
sortedmemberdict = dict(
sorted(memberdict.items(),
key=lambda item: item[1]["attended"],
reverse=True))
print(f"Events attended since {sincedate}")
for key, val in sortedmemberdict.items():
if val['attended'] > 0:
print(f"{val['name']} attended {val['attended']}")
print(eventlist)
def liker(groupname, reqlikes):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
if reqlikes == "all":
reqlikes = len(messagelist)
else:
reqlikes = int(reqlikes)
for num in range(reqlikes):
messagelist[num].like()
def memberStats(groupname, membername):
group = findGroup(groupname)
member = findMember(group, membername)
messagelist = list(group.messages.list().autopage())
messagesposted = 0
likes = 0
counter = 0
receivedlikes = 0
totallikes = 0
found = False
for message in messagelist:
counter += 1
totallikes += len(message.favorited_by)
# Figure out when member joined/was added
if message.system and not found:
# Check to see if the users were added
if message.event["type"] == "membership.announce.added":
# Iterate the added_users list
for index in range(len(message.event['data']['added_users'])):
if str(message.event['data']['added_users'][index]
['id']) == str(member.user_id):
print(
f"Added by {message.event['data']['adder_user']['nickname']} on {convertCreatedAt(message)}"
)
found = True
# Check to see if the user joined
elif message.event["type"] == "membership.announce.joined":
if str(message.event['data']['user']['id']) == str(
member.user_id):
print(
f"Joined {group.name} on {convertCreatedAt(message)}")
found = True
# Count messages posted
if message.user_id == member.user_id:
messagesposted += 1
# Count likes
if member.user_id in message.favorited_by:
likes += 1
# Count number of likes received
if message.user_id == member.user_id:
receivedlikes += len(message.favorited_by)
# Print results
print(
f"Posted {messagesposted} out of {counter} ({round(messagesposted/counter*100,2)}%) messages"
)
print(
f"Liked {likes} out of {counter} ({round(likes/counter*100,2)}%) messages"
)
print(
f"Received {receivedlikes} out of {totallikes} ({round(receivedlikes/totallikes*100,2)}%) likes"
)
def averMessPerMonth(groupname):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
memberdict = {}
details = ""
counter = 0
path = f"./Groups/{group.name}"
# Instantiate the memberdict member objects with counters at 0
for member in group.members:
memberdict[member.user_id] = {
"messcount": 0,
"firstmessdate": "",
"aver": 1,
"diffmonths": 1
}
# For each message, increase message.user_id value by 1 and total counter by 1.
for message in messagelist:
try:
memberdict[message.user_id]["messcount"] += 1
memberdict[message.user_id]["firstmessdate"] = message.created_at
counter += 1
except:
pass
for x, y in memberdict.items():
if not y["messcount"] == 0:
diffmonths = (datetime.today().year - y["firstmessdate"].year
) * 12 + (datetime.today().month -
y["firstmessdate"].month)
if diffmonths == 0:
diffmonths = 1
y["aver"] = round(y["messcount"] / diffmonths)
y["diffmonths"] = diffmonths
sorted_memberdict = sorted(memberdict.items(),
key=lambda x: x[1]["aver"],
reverse=True)
for i in sorted_memberdict:
membername = findMember(group, i[0]).name
# print(f"{membername} - Average Messages/Month: {i[1]['aver']}")
details = details + membername + "\n\tMessages Sent - " + str(
i[1]['messcount']) + "\n\tMembership in Months - " + str(
i[1]['diffmonths']
) + "\n\tAverage Messages per Month - " + str(i[1]['aver']) + "\n"
with open(f"{path}/AverPostsPerMonth.txt", "w") as writer:
writer.write(
f"--- Average Posts per Month for {group.name} out of {len(group.members)} members and {counter} posts as of {datetime.now().strftime('%m/%d/%Y')} ---\n"
)
writer.write(details)
def backupMems(groupname):
group = findGroup(groupname)
memberlist = []
for member in group.members:
memberlist.append(member.name)
memberlist.sort()
path = f"./Groups/{group.name}/"
with open(f"{path}members.txt", "w") as writer:
for index in memberlist:
writer.write(f"{index}\n")
def numLikesGiven(groupname):
group = findGroup(groupname)
totalposts = 0
path = f"./Groups/{group.name}"
if not os.path.exists(path):
os.makedirs(path)
print("Filling memberdict...")
memberdict = {}
for member in group.members:
memberdict[member.user_id] = {"name" : member.name, "likesgiven" : 0, "posts" : 0}
print("Filling messagelist...")
messagelist = list(group.messages.list().autopage())
print("Filling likes...")
for message in messagelist:
# Add one to the total posts
totalposts += 1
try:
# Add one to the relevant member's total posts
memberdict[message.user_id]["posts"] += 1
except KeyError:
pass
except Exception as e:
print(f"Error occurred {e}")
for messagelike in message.favorited_by:
try:
# Add a like to each member in the favorited_by list
memberdict[messagelike]["likesgiven"] += 1
except KeyError:
pass
except Exception as e:
print(f"Error occurred {e}")
# Sort by number of likes given
print("Sorting memberdict...")
sorted_memberdict = sorted(memberdict.items(), key=lambda x: x[1]["likesgiven"], reverse=True)
print(f"Writing results to {path}/percentagelikes.txt...")
with open(path + "/percentagelikes.txt", "w") as writer:
writer.write(f"Percentage of likes given of messages not posted by member in {group.name}...\n")
for entry in sorted_memberdict:
name = entry[1]["name"]
likedmessages = entry[1]["likesgiven"]
posts = entry[1]["posts"]
otherposts = totalposts - posts
writer.write(f"{name} liked {round(likedmessages/otherposts*100,2)}% of {otherposts} messages\n")
def fullDownPics(groupname):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
urlmemdict = {}
if not os.path.exists(f"./Groups/{group.name}/Pictures"):
os.makedirs(f"./Groups/{group.name}/Pictures")
for member in group.members:
urlmemdict[member.user_id] = {"name": member.name, "urllist": []}
for message in messagelist:
try:
if len(message.attachments) > 0:
if (message.attachments[0].type) == "image":
urlmemdict[message.user_id]["urllist"].append(
message.attachments[0].url)
except Exception as e:
print(f"Exception {e}\n{message.data}")
for val in urlmemdict.values():
num = 1
for index in val["urllist"]:
if "png" in index:
ext = ".png"
elif "gif" in index:
ext = ".gif"
elif "jpeg" in index:
ext = ".jpeg"
else:
ext = ".txt"
with open(
f"./Groups/{group.name}/Pictures/{val['name']}_{num}{ext}",
"wb") as handle:
try:
response = requests.get(index, stream=True)
if not response.ok:
print(response)
for block in response.iter_content(1024):
if not block:
break
handle.write(block)
except Exception as e:
print(f"Error on {val['name']}_{num}{ext}: {e}")
pass
num += 1
def numLikes(groupname):
group = findGroup(groupname)
likefloor = 3
print("Filling messagelist...")
messagelist = list(group.messages.list().autopage())
path = f"./Groups/{group.name}"
if not os.path.exists(path):
os.makedirs(path)
print("Creating memberdict...")
memberdict = {}
for member in group.members:
memberdict[member.user_id] = {"name" : member.name, "likedmessages" : 0, "messages" : 0}
print("Counting likes...")
for message in messagelist:
try:
memberdict[message.user_id]["messages"] += 1
if len(message.favorited_by) >= likefloor:
memberdict[message.user_id]["likedmessages"] += 1
except:
pass
print("Sorting memberdict...")
sorted_memberdict = sorted(memberdict.items(), key=lambda x: x[1]["likedmessages"], reverse=True)
likedict = {}
for entry in sorted_memberdict:
try:
likedict[entry[1]["name"]] = round(entry[1]["likedmessages"]/entry[1]["messages"]*100,2)
except:
print(f"{entry[1]['name']} had a division issue")
pass
print("Sorting likedict...")
sorted_likedict = sorted(likedict.items(), key=lambda x: x[1], reverse=True)
print("Writing results...")
num = 1
with open(f"{path}/MoreLikes.txt", "w") as writer:
writer.write(f"\nPosts that got {likefloor}+ likes\n")
for entry in sorted_likedict:
writer.write(f"{num}. {entry[0]}: {entry[1]}% of {memberdict[findMember(group, entry[0]).user_id]['messages']} posts\n")
num += 1
def stealthLikeOthers(groupname, choice):
group = findGroup(groupname)
likeddict = {}
# Defines whether we are going to only like or only unlike in the beginning. Those changes will be reversed in the second half
if choice.lower() == "like":
like = True
else:
like = False
print("Filling messagelist...")
messagelist = list(group.messages.list().autopage())
print("Liking/Unliking messages...")
for message in messagelist:
# Store message in likeddict only if we liked it already...
if myuser.id in message.favorited_by:
likeddict[message.created_at] = message
# Try to unlike the message if like is False since we know that we originally liked it
if like == False:
try:
message.unlike()
except Exception as e:
print(f"Encountered error in the unlike: {e}")
# If we didn't like it already but like is True, try to like it
elif like:
try:
message.like()
except Exception as e:
print(f"Encountered error in the like: {e}")
print("Undoing changes now...")
for message in messagelist:
if myuser.id in message.favorited_by:
# If we had originally liked the message and and like is False, it means we unliked it. Try to like it again
if message.created_at in likeddict.keys() and like == False:
try:
message.like()
except Exception as e:
print(f"Encountered error in the reverse like: {e}")
# If we didn't originally like the message, but like is true, it means we liked it. Now we need to unlike it
elif like:
try:
message.unlike()
except Exception as e:
print(f"Encountered error in the reverse unlike: {e}")
def usersLeft(groupname, date):
import pytz
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
sincedate = datetime.strptime(date, '%m/%d/%Y')
sincedate = pytz.UTC.localize(sincedate)
usersleft = 0
for message in messagelist:
if message.created_at > sincedate:
try:
if message.data["event"][
"type"] == "membership.notifications.exited":
usersleft += 1
except:
pass
print(f"{usersleft} users left since {sincedate.strftime('%m/%d/%Y')}")
def commonWords(groupname, num):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
num = int(num)
memberdict = {}
wordlist = []
print("Filling memberdict...")
for member in group.members:
memberdict[member.user_id] = {}
print("Searching messages...")
# This can be optimized...
for message in messagelist:
for member in memberdict.items():
if message.user_id == member[0]:
try:
wordlist = message.text.split(" ")
for word in wordlist:
word = word.lower()
if word in member[1].keys():
member[1][word] += 1
elif len(word) > num or word in exceptionlist:
member[1][word] = 1
except:
pass
print(f"Writing results to {path}/commonwords.txt...")
with open(path + "/commonwords.txt", "w") as writer:
writer.write(f"--- Words greater than {num} letters ---")
for member in memberdict.items():
writer.write(
f"\n{findMember(group, member[0]).name}'s most common words - \n"
)
sorted_list = sorted(member[1].items(),
key=lambda x: x[1],
reverse=True)
for x in range(10):
try:
writer.write(sorted_list[x][0] + " - " +
str(sorted_list[x][1]) + "\n")
except:
pass
writer.write("\n")
def scopedSharedGroups(sourcegroupname):
sourcegroup = findGroup(sourcegroupname)
memberdict = {}
for member in sourcegroup.members:
memberdict[member.user_id] = {"name": member.name, "shared": 0}
for group in grouplist:
for member in group.members:
if member.user_id in memberdict.keys():
memberdict[member.user_id]["shared"] += 1
sorted_memberdict = sorted(memberdict.items(),
key=lambda x: x[1]["shared"],
reverse=True)
print(f"Shared groups with source group: {sourcegroup.name}")
for index in sorted_memberdict:
if index[1]['shared'] > 1 and index[1]['name'] != myuser['name']:
print(f"{index[1]['name']} - {index[1]['shared']}")
def percentImagePost(groupname):
group = findGroup(groupname)
userdict = {}
total = 0
print("Reading file...")
with open(f".\\Images\\Images_{group.name}.csv", "r") as reader:
lines = reader.readlines()
print("Creating user dictionary and counting images...")
for line in lines:
splitline = line.strip().split(",")
if splitline[1] not in userdict.keys():
userdict[splitline[1]] = 1
else:
userdict[splitline[1]] += 1
for value in userdict.values():
total += value
print("Sorting list...")
sorted_userdict = sorted(userdict.items(),
key=lambda x: x[1],
reverse=True)
print("Writing file...")
with open(f".\\Images\\PercentImages_{group.name}.txt", "w") as writer:
try:
writer.write("Total images: " + str(total) + "\n\n")
except:
print("Error")
for item in sorted_userdict:
try:
writer.write(""
f"{findMember(group, item[0]).name} posted\n\t"
f"{item[1]} images"
f"\n\t{round(item[1]/total*100, 2)}%\n"
"")
except Exception as e:
print(str(e))
pass
def messLikes(groupname, text):
group = findGroup(groupname)
print("Filling messagelist...")
messagelist = list(group.messages.list().autopage())
print("Searching for text...")
while text != "0":
textlist = []
for message in messagelist:
try:
if text.lower() in message.text.lower():
textlist.append(message)
except:
pass
if len(textlist) > 0:
for message in textlist:
print(f"{convertCreatedAt(message)} - {message.name} - {message.text} - {len(message.favorited_by)} likes")
else:
print("No message found with that text")
text = input("Enter new text or 0 to exit: ")
def downProfilePics(groupname):
group = findGroup(groupname)
memberdict = {}
if not os.path.exists(f"./Groups/{group.name}/ProfilePics"):
os.mkdir(f"./Groups/{group.name}/ProfilePics")
for member in group.members:
try:
if "png" in member.image_url:
ext = ".png"
elif "jpeg" in member.image_url:
ext = ".jpeg"
else:
ext = ".old"
except:
print(f"Unable to capture URL: {member.data}")
ext = ".old"
memberdict[member.user_id] = {
"name": member.name,
"url": member.image_url,
"ext": ext
}
# Code inside with statement used from Stack Overflow answer on downloading images using requests
for val in memberdict.values():
with open(
f"./Groups/{group.name}/ProfilePics/{val['name']}{val['ext']}",
"wb") as handle:
try:
response = requests.get(val['url'], stream=True)
if not response.ok:
print(response)
for block in response.iter_content(1024):
if not block:
break
handle.write(block)
except Exception as e:
print("Error: " + str(e))
pass
def dateJoined(groupname):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
joineddict = {}
for message in messagelist:
try:
if message.data["event"]["type"] == "membership.announce.added":
for member in message.data["event"]["data"]["added_users"]:
joineddict[member["nickname"]] = convertCreatedAt(message)
elif message.data["event"]["type"] == "membership.announce.joined":
joineddict[message.data['event']['data']['user']
['nickname']] = convertCreatedAt(message)
except:
pass
sortedjoineddict = dict(
sorted(joineddict.items(), key=lambda item: item[1]))
for key, val in sortedjoineddict.items():
print(f"{val} - {key}")
def mostLikedMessages(groupname, nummessages):
group = findGroup(groupname)
nummessages = int(nummessages)
mostlikeddict = {}
path = f"./Groups/{group.name}"
if not os.path.exists(path):
os.makedirs(path)
print("Filling messagelist...")
messagelist = group.messages.list().autopage()
for message in messagelist:
mostlikeddict[message.text] = {"numfavorites" : len(message.favorited_by), "sendername" : message.name, "timestamp" : convertCreatedAt(message)}
print("Sorting by number of likes...")
sorted_mostlikeddict = sorted(mostlikeddict.items(), key=lambda x: x[1]["numfavorites"], reverse=True)
# path = f".\\MostLikes\\MostLikes_{group.name}.txt"
print(f"Writing top {nummessages} messages to {path}/mostlikes.txt...")
with open(path + "/mostlikes.txt", "w") as writer:
for num in range(nummessages):
likes = sorted_mostlikeddict[num][1]["numfavorites"]
time = sorted_mostlikeddict[num][1]["timestamp"]
name = sorted_mostlikeddict[num][1]["sendername"]
text = sorted_mostlikeddict[num][0]
try:
writer.write(f"{likes} likes: {time} - {name} - {text}\n\n" )
except:
writer.write(f"{likes} likes: {time} - {name} - ")
if text != None:
for character in text:
try:
writer.write(character)
except:
pass
writer.write("\n\n")
def longestMess(groupname):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
longestmesslen = 0
longestmesslist = []
for message in messagelist:
try:
# Create a new list if the message is longer than the length of the previous list messages
if len(str(message.text)) > longestmesslen:
longestmesslist = [message]
longestmesslen = len(str(message.text))
# Otherwise, append the same length message to the current list
elif len(str(message.text)) == longestmesslen:
longestmesslist.append(message)
except Exception as e:
print(f"Exception occurred: {e}")
pass
for longestmess in longestmesslist:
print(
f"{convertCreatedAt(longestmess)} - {longestmess.name} - {longestmess.text}\n"
)
print(f"Length: {longestmesslen}")
def noLikes(groupname):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
path = f"./Groups/{group.name}"
if not os.path.exists(path):
os.makedirs(path)
memberdict = {}
for member in group.members:
memberdict[member.user_id] = {"name" : member.name, "liked" : False}
for message in messagelist:
for id in message.favorited_by:
try:
memberdict[id]["liked"] = True
except:
pass
with open(path + "/nolikes.txt", "w") as writer:
print(f"Writing to {path}/nolikes.txt...")
for key, val in memberdict.items():
if not val["liked"]:
writer.write(f"{val['name']}\n")
def dateUserAdded(groupname):
# Attributes of a message reading "x added y to the group"
# {'attachments': [], 'avatar_url': None, 'created_at': datenum, 'favorited_by': ['numid', 'numid'], 'group_id': 'numid', 'id': 'numid', 'name': 'GroupMe', 'sender_id': 'system', 'sender_type': 'system', 'source_guid': 'redacted', 'system': True, 'text': 'x added y to the group.', 'user_id': 'system', 'event': {'type': 'membership.announce.added', 'data': {'added_users': [{'id': numid, 'nickname': 'y'}], 'adder_user': {'id': numid, 'nickname': 'x'}}}, 'platform': 'gm'}
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
currmemlist = []
# Add current member ids to list
for member in group.members:
currmemlist.append(str(member.user_id))
print(f"Total Members - {len(currmemlist)}")
# Print list chronologically
num = len(messagelist) - 1
while num >= 0:
message = messagelist[num]
# Check to see if it's a system message
if message.system:
# Check to see if the users were added
if message.event["type"] == "membership.announce.added":
# Iterate the added_users list
for index in range(len(message.event['data']['added_users'])):
# Only print if the user is still in the group
if str(message.event['data']['added_users'][index]
['id']) in currmemlist:
print(
f"{convertCreatedAt(message)} - {message.event['data']['added_users'][index]['nickname']}"
)
# Check to see if the user joined
elif message.event["type"] == "membership.announce.joined":
# Only print if user is still in the group
if str(message.event['data']['user']['id']) in currmemlist:
print(
f"{convertCreatedAt(message)} - {message.event['data']['user']['nickname']}"
)
num -= 1
def allMemberPercentPosts(groupname):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
memberdict = {}
details = ""
counter = 0
# Instantiate the memberdict member objects with counters at 0
for member in group.members:
memberdict[member.user_id] = 0
# For each message, increase message.user_id value by 1 and total counter by 1.
try:
for message in messagelist:
memberdict[message.user_id] += 1
counter += 1
except:
pass
sorted_memberdict = sorted(memberdict.items(),
key=lambda x: x[1],
reverse=True)
for i in sorted_memberdict:
try:
membername = findMember(group, i[0]).name
details = details + membername + " - " + str(
round(i[1] / counter * 100, 2)) + "%\n"
except:
pass
details = details + "\nTotal posts - " + str(counter)
with open("PercentagePosts.txt", "a+") as writer:
writer.write(
f"\n\n--- Percentage of Total Posts for {groupname} out of {len(group.members)} members and {counter} posts ---\n"
)
writer.write(details)
def aveLikesReceived(groupname):
group = findGroup(groupname)
messagelist = list(group.messages.list().autopage())
path = f"./Groups/{group.name}"
if not os.path.exists(path):
os.makedirs(path)
memberdict = {}
for member in group.members:
memberdict[member.user_id] = {"name" : member.name, "messages" : 0, "likes" : 0}
for message in messagelist:
try:
memberdict[message.user_id]["messages"] += 1
memberdict[message.user_id]["likes"] += len(message.favorited_by)
except KeyError:
pass
avelikedict = {}
for key, val in memberdict.items():
try:
average = round(val["likes"]/val["messages"])
except:
average = 0
avelikedict[val["name"]] = {"average" : average, "messages" : memberdict[key]["messages"], "likes" : memberdict[key]["likes"]}
sorted_avelikedict = sorted(avelikedict.items(), key=lambda x: x[1]["average"], reverse=True)
with open(f"{path}/averageLikes.txt", "w") as writer:
num = 1
writer.write(f"Average number of likes received in relation to messages sent\n")
for index in sorted_avelikedict:
if index[1]['average'] > 0:
writer.write(f"{num}. {index[0]} -\n\tLikes Received: {index[1]['likes']}\n\tMessages Sent: {index[1]['messages']}\n\tAverage Likes Received per Message: {index[1]['average']}\n\n")
num += 1
