def check_email(): """ Checks gmail for unread emails, extracts artist/song name, marks email as read, and returns artist and song name""" client = Gmail() USERNAME = '******' PASSWORD = '******' client.login(USERNAME, PASSWORD) if client.inbox().mail(unread=True): unread = client.inbox().mail(unread=True) unread[0].fetch() print "The input string is {}".format(unread[0].body) print "" # FORMAT MUST BE (ARTIST, SONG NAME) input_string = unread[0].body input_split = input_string.split(',') artist = input_split[0].lower() song_name = input_split[1].lower() test = song_name.rstrip() unread[0].read() else: #print "YOU HAVE READ EVERYTHING" artist = None test = None return artist, test
class GmailHandler(object): def __init__(self): """Initialise Gmail object""" self.obj = Gmail() self.obj.login(GMAIL_CONFIG['username'], GMAIL_CONFIG['password']) self.unread = self.obj.inbox().mail(unread=True) def get_unread(self, recent=False): if recent: self.unread = self.obj.inbox().mail(unread=True, on=date.today()) else: self.unread = self.obj.inbox().mail(unread=True) return self._format_msg_count(len(self.unread)) def search_unread(self, term): """Search sender or subject for a given term. Args: term (str): term to search. Returns: subject (str): subject of email with term/from sender """ self.unread = self.obj.inbox().mail(unread=True) term = term.lower() result = [] for mail in self.unread: mail.fetch() subject = mail.subject sender = mail.fr if term in subject.lower() or term in sender: result.append(mail.subject) return self._format_search_results(result) """Formatting methods.""" def _format_msg_count(self, msg_count): if msg_count: msg = 'You have {msg_count} new emails.' msg = msg.format(msg_count=msg_count) else: msg = 'You have no new emails.' return msg def _format_search_results(self, results): msg = self._format_msg_count(len(results)) results.insert(0, msg) msg = '\n'.join(results) return msg def __del__(self): """Destructor""" self.obj.logout()
class Mail(): def __init__(self): # user info self.username = None self.password = None # object using the gmail library self.g = Gmail() def login(self): # get user info username = raw_input('Username: '******'Password: '******'Unable to login' def logout(self): # logout self.g.logout() def getNumUnread(self): # get number of unread email try: return len(self.g.inbox().mail(unread=True)) except Exception as err: print str(err)
def fetch_codes(): client = Gmail() client.login(sys.argv[1], email_password) mails = client.inbox().mail(unread=True, sender="*****@*****.**") for entry in mails: entry.fetch() if 'need to complete the process:' not in entry.body: continue entry.read() # First, find the username this went too username = re.findall("Dear (.*),", entry.body)[0] # Label this as a proper steam-guard code entry.add_label("Codes") # Grab the actual steam-guard code _, data = entry.body.split("need to complete the process:") code = data.strip().split("\n", 1)[0].strip() store_code(entry.to, username, code) client.logout()
def get(self, request, limit=10): """ Log in to gmail using credentials from our config file and retrieve email to store into our db """ profile = request.user.get_profile() username = profile.gmail_username password = profile.gmail_password source = profile.gmail_source g = Gmail() g.login(username, password) msgs = g.inbox().mail(sender=source) imported = 0 for msg in msgs[:int(limit)]: try: email_summary = EmailSummary.objects.get( message_id=msg.message_id) continue except EmailSummary.DoesNotExist: pass msg.fetch() email_summary = EmailSummary.objects.create( user=request.user, message_id=msg.message_id, subject=msg.subject, date=msg.sent_at, source_addr=source, imported_to_wordpress=False ) email_summary.save() imported += 1 return Response({"response": "imported %s messages" % imported})
def run(): g = Gmail() # Store your Username/Pwd in secret.py, and don't include secret.py in your github success = login_to_gmail(g) if not success: return # TODO: Add error handling # Return list of gmail message objects to_me = g.inbox().mail() received = parse_emails(to_me, store={}) return received
class YoutubeCheck: def __init__(self, users, passes): print "Started youtube checker....", self.gmail = Gmail() self.user = users self.password = passes self.emails = [] self.lastNum = None self.arguments = None print "Done" self.set_args(sender="*****@*****.**", unread=True) @staticmethod def delete_email(emaillist): for email in emaillist: email.delete() def set_args(self, **kwargs): print "Attempting to start gmail (args)...", self.arguments = kwargs print "Done" def get_emails(self): return self.gmail.inbox().mail(self.arguments) def check_videos(self): self.login() sleep(1) print "Trying to check if new emails have been sent...", self.emails = [] emailss = (self.get_emails()) if len(emailss) == 0: return [0] print "Done" for email in emailss: subject = email.subject if '"' in subject: if '"' in subject[subject.index("\"") + 1:]: print "Found copyrighted video...", videoname = str(subject[subject.index("\"") + 1:][:subject.index("\"")]).replace( "\"", "") self.emails.append(videoname) print "Done" self.delete_email(emailss) return self.emails def login(self): self.gmail.login(self.user, self.password) def logout(self): self.gmail.logout()
class YoutubeCheck: def __init__(self, users, passes): print "Started youtube checker....", self.gmail = Gmail() self.user = users self.password = passes self.emails = [] self.lastNum = None self.arguments = None print "Done" self.set_args(sender="*****@*****.**", unread=True) @staticmethod def delete_email(emaillist): for email in emaillist: email.delete() def set_args(self, **kwargs): print "Attempting to start gmail (args)...", self.arguments = kwargs print "Done" def get_emails(self): return self.gmail.inbox().mail(self.arguments) def check_videos(self): self.login() sleep(1) print "Trying to check if new emails have been sent...", self.emails = [] emailss = (self.get_emails()) if len(emailss) == 0: return [0] print "Done" for email in emailss: subject = email.subject if '"' in subject: if '"' in subject[subject.index("\"")+1:]: print "Found copyrighted video...", videoname = str(subject[subject.index("\"")+1:][:subject.index("\"")]).replace("\"", "") self.emails.append(videoname) print "Done" self.delete_email(emailss) return self.emails def login(self): self.gmail.login(self.user, self.password) def logout(self): self.gmail.logout()
def acceptEmailTerms(listing): gmail = Gmail() gmail.login(gmailUser,gmailPass) today = date.today() year = today.year month = today.month day = today.day print("Receiving email confirmation...") time.sleep(60) print ("Checking email") emails = gmail.inbox().mail(sender="*****@*****.**",unread=True,after=datetime.date(year, month, day-1)) termsUrl = getCraigslistEmailUrl(listing,emails) acceptTermsAndConditions(listing,termsUrl) gmail.logout() print ("Confirmed")
def acceptEmailTerms(listing): gmail = Gmail() gmail.login(gmailUser,gmailPass) today = date.today() year = today.year month = today.month day = today.day time.sleep(120) print "Checking email" emails = gmail.inbox().mail(sender="*****@*****.**",unread=True,after=datetime.date(year, month, day-1)) termsUrl = getFirstCraigslistEmailUrl(listing,emails) acceptTermsAndConditions(listing,termsUrl) gmail.logout() print "Done Checking Email"
def _get_an_email(gmail_configs, index): """ Log in to gmail using credentials from our config file and retrieve an email from our sender with a given index-number. """ g = Gmail() g.login(gmail_configs['username'], gmail_configs['password']) msg = g.inbox().mail(sender=gmail_configs['source_address'])[index] msg.fetch() raw_message = msg.message html_body = '' if raw_message.get_content_maintype() == "multipart": for content in raw_message.walk(): print content.get_content_type() if content.get_content_type() == "text/html": html_body = content.get_payload(decode=True) return html_body
def monitorEmail(self): if not self.isSafetySwitchOff(): self.sendMonitorErrorEmail("Monitor Email still broken: safety switch turned on") return g = Gmail() g.login(SECRETS_DICT['EMAIL_USERNAME'], SECRETS_DICT['EMAIL_PASSWORD']) # play with your gmail... messages = g.inbox().mail(unread=True, sender="*****@*****.**") for x in messages: x.fetch() try: self.handleEmail(x) except Exception as e: x.add_label("Monitor Email Job Error") g.logout()
def monitorEmail(self): if not self.isSafetySwitchOff(): self.sendMonitorErrorEmail( "Monitor Email still broken: safety switch turned on") return g = Gmail() g.login(SECRETS_DICT['EMAIL_USERNAME'], SECRETS_DICT['EMAIL_PASSWORD']) # play with your gmail... messages = g.inbox().mail(unread=True, sender="*****@*****.**") for x in messages: x.fetch() try: self.handleEmail(x) except Exception as e: x.add_label("Monitor Email Job Error") g.logout()
class UtIntfGmail(object): def __init__(self, dictCreds): self.init(dictCreds) pass def init(self, dictCreds): self.__api_Gmail = Gmail() self.__api_Gmail.login(dictCreds['username'], dictCreds['password']) pass def getEmails(self, user): bRet = True bodyList = [] mailList = self.__api_Gmail.inbox().mail(unread=True, sender=user) for m in mailList: m.fetch() bodyList.append(m.body) return bRet, bodyList
def acceptEmailTerms(listing): gmail = Gmail() gmail.login(gmailUser, gmailPass) today = date.today() year = today.year month = today.month day = today.day time.sleep(120) print "Checking email" emails = gmail.inbox().mail(sender="*****@*****.**", unread=True, after=datetime.date(year, month, day - 1)) termsUrl = getFirstCraigslistEmailUrl(listing, emails) acceptTermsAndConditions(listing, termsUrl) gmail.logout() print "Done Checking Email"
class ProxyZipDownloader: def __init__(self, username, password, abs_path_zips): self.username = username self.password = password self.abs_path_zips = abs_path_zips self.g = Gmail() self.g.login(username, password) def __remove_all_zips__(self): for file_name in os.listdir(self.abs_path_zips): if file_name.endswith(".zip"): file_to_remove = self.abs_path_zips + file_name print "Removing %s" % file_to_remove os.remove(file_to_remove) def __is_zip_file_old__(self, file_name): # proxylist-10-26-13.zip date_zip_file = datetime.datetime.strptime(file_name, \ 'proxylist-%m-%d-%y.zip') date_today = datetime.datetime.now() return (date_today - date_zip_file).days >= 2 def fetch_files(self): self.__remove_all_zips__() for email in self.g.inbox().mail(sender="*****@*****.**", after=datetime.datetime.now() - datetime.timedelta(days=3)): message = email.fetch() m1 = message.get_payload()[0] m2 = message.get_payload()[1] zip_file_name = m2.get_filename() if self.__is_zip_file_old__(zip_file_name): continue zip_file_contents = m2.get_payload(decode=True) print "Saving %s" % zip_file_name f = open(self.abs_path_zips + zip_file_name, 'w') f.write(zip_file_contents) f.close()
def __init__(self, **kwargs): super(Gmail_checker, self).__init__(**kwargs) # check if parameters have been provided username = kwargs.get('username', None) password = kwargs.get('password', None) if username is None: raise MissingParameterException("Username parameter required") if password is None: raise MissingParameterException("Password parameter required") # prepare a returned dict returned_dict = dict() g = Gmail() g.login(username, password) # check if login succeed logging.debug("Gmail loggin ok: %s" % g.logged_in) # Should be True, AuthenticationError if login fails # get unread mail unread = g.inbox().mail(unread=True) returned_dict["unread"] = len(unread) if len(unread) > 0: # add a list of subject subject_list = list() for email in unread: email.fetch() encoded_subject = email.subject subject = self._parse_subject(encoded_subject) subject_list.append(subject) returned_dict["subjects"] = subject_list logger.debug("gmail neuron returned dict: %s" % str(returned_dict)) # logout of gmail g.logout() self.say(returned_dict)
def in_(destdir, instream): input = json.load(instream) username = input['source']['username'] password = input['source']['password'] version = input.get('version') uid = version.get('uid', "") if version is not None else "" common.msg("logging into gmail as '{0}'".format(username)) g = Gmail() # login, fail if unable to authenticate try: g.login(username, password) except: common.msg("unable to log in") exit(1) # fetch this particular email common.msg("fetching email with uid '{0}'".format(uid)) msg = g.fetch_multiple_messages({uid: Message(g.inbox(), uid)})[uid] # if we haven't found the required email message, then exit if msg is None or msg.message is None: common.msg("unable to find email with uid '{0}'".format(uid)) exit(1) # put it on a file system common.msg("writing email '{0}' to {1}".format(msg.subject, destdir)) with safe_open(os.path.join(destdir, "email"), 'w') as f: f.write(json.dumps(toJSON(msg))) # log out and swallow the error try: g.logout() except: pass metadata = [{'name': 'uid', "value": msg.uid}, {'name': 'subject', "value": msg.subject}] return {'version': {'uid': msg.uid}, 'metadata': metadata}
def main(): path = "C:\\Users\\L.SeonHo\\Desktop\\result\\" gmaps = list() # for location gmap_path = str() # for full path g = Gmail() g.login('bob5leesh', 'rlayuna#0905') if not os.path.isdir(path): os.mkdir(path) set_sqlite(path) for i in range(16, 30): mailday = date(2016, 7, i) daypath = "C:\\Users\\L.SeonHo\\Desktop\\result\\" + str(mailday) +"\\" # for create day folder daygmap = list() # create day gmap if not os.path.isdir(daypath): os.mkdir(daypath) # create folder emails = g.inbox().mail(on = mailday, sender = '*****@*****.**') for email in emails: flock = fl0ckfl0ck(email) # one mail routine flock.path = daypath flock.GetGmail() gmap_path = flock.path if flock.ShortToFull() != 0: # in : success get full url / out : fail get full url flock.GetImage() flock.GetHash() flock.GetGPS() # check exist gps info from file if str(flock.gps_lat) == 'None' or str(flock.gps_lon) == 'None': pass elif str(flock.gps_lat) == 'N/A' or str(flock.gps_lon) == 'N/A': pass else: gmaps.append(flock.MakeGmap()) # setting day gmap daygmap.append(flock.MakeGmap()) # setting full gmap flock.OutCSV() # create CSV file flock.OutSQLite(path) # create SQLite database if len(daygmap) != 0: get_googlemap(daygmap, gmap_path) # get day gmap get_googlemap(gmaps, path) # get full gmap
def findPayments(username, password): # Main Part, use Gmail to find venmo balances file = open('recent.txt', 'r') most_recent = file.read() file.close() IDs = [0,most_recent] charges = {} #can use this if we only want to check most recent emails #then = datetime.datetime.now().replace(hour=8, minute=0, second=0, microsecond=0) ''' Make benefits_on true to provide benefits to DKEggertor founders ''' benefits_on = False g = Gmail() g.login(username, password) newMail = g.inbox().mail(fr="*****@*****.**") print "got mail" #Filter venmo emails that are payments emails from venmo payments = filterPayments(newMail) print "filtered" #Can use this part to implement only most recent email checking, Note: use email.sent_at to get the emails timestamp. #for i in pay: #if i.sent_at >= then: #payments.append(i) #Iterate through payment emails to find balances i = 0 while i < len(payments): #Check if the ID number of the email has already been checked #as this prevents checking emails twice and incorrectly calculating balances if payments[i].uid not in IDs: print "Test 1" #Check if email is a payment to DKE Keg if isKegEmail(payments[i]) and int(payments[i].uid) >= int(most_recent)+1: print "Test 2" #Seperate out the subject of the email to find Name and Amount that was paid IDs.append(payments[i].uid) payments[i].fetch() print "Fetched" message = payments[i].subject print "subject" name = message.split(" p")[0] if len(message.split("$")[1]) >= 10: amount = float(message.split("$")[1].split(" ")[0]) else: amount = float(message.split("$")[1]) #Update amount if name is already in the database if name in charges: amount = charges[name] + amount #This check is only for when I (Mike DeLaus) pay from the my venmo account as it is the same email we use for DKE Keg if name != "You": charges[name] = amount #Provides benefits for the founding members of DKEggerator founders = ["Michael DeLaus", "Ryan Kelly", "Mitch Maisel"] for name in founders: if benefits_on == True: charges[name] = 999999999999 file = open('recent.txt', 'w') most_recent = payments[i].uid file.write(str(most_recent)) file.close() i+=1 return charges #Sleep the program so we don't constantly check, can probably find better way to do this #time.sleep(60) #Logout of email so next check uses a refreshed inbox g.logout()
self.to_dict = { 'attachments': gm.attachments, 'body': gm.body, 'to': gm.to, 'cc': gm.cc, 'flags': gm.flags, 'headers': gm.headers, 'message_id': gm.message_id, 'sent_at': str(gm.sent_at), 'subject': gm.subject, 'thread': gm.thread, 'thread_id': gm.thread_id } if __name__ == '__main__': g = Gmail() g.login("grfvanfvphermmn", "pbzchgrefrphevgl") emails = g.inbox().mail() mailist = [] for e in emails[:10]: e.fetch() m = Mailwrapper(e) mailist.append(json.dumps(m.to_dict)) # print e.body with open('data.json', 'w') as fp: json.dump(mailist, fp) g.logout()
def calculate_email_stats( USERNAME, ACCESS_TOKEN, DAYS, ALIASES=[], IGNORE_EMAILS=[], IGNORE_SUBJECT_KEYWORDS=[], IGNORE_BODY_KEYWORDS=[], MIN_THREAD_LENGTH=0, ): """ Calculate a bunch of stats and return a dict of values for rendering. """ ALIASES.append(USERNAME) # Log in to Gmail g = Gmail() g.authenticate(USERNAME, ACCESS_TOKEN) write( "Login success!") # Pull all emails now = datetime.datetime.now() after = now - datetime.timedelta(days=DAYS) emails = g.all_mail().mail( prefetch=True, after = after, ) total_email_count = len(emails) write("Retrieved %s emails." % total_email_count) # Clean emails could_not_fetch = [email for email in emails if not email.body] emails = [email for email in emails if email.body] no_thread_id = [email for email in emails if not email.thread_id] emails = [email for email in emails if email.thread_id] ignored_for_email = [email for email in emails if \ (email_in_aliases(email.fr, IGNORE_EMAILS) or \ email_in_aliases(email.to, IGNORE_EMAILS))] emails = [email for email in emails if \ not (email_in_aliases(email.fr, IGNORE_EMAILS) or \ email_in_aliases(email.to, IGNORE_EMAILS))] ignored_for_subject = [email for email in emails if \ email_in_aliases( email.subject, IGNORE_SUBJECT_KEYWORDS)] emails = [email for email in emails if \ not email_in_aliases( email.subject, IGNORE_SUBJECT_KEYWORDS)] ignored_for_body = [email for email in emails if \ email_in_aliases( email.body, IGNORE_BODY_KEYWORDS)] emails = [email for email in emails if \ not email_in_aliases( email.body, IGNORE_BODY_KEYWORDS)] write("Finished grabbing emails") # Group emails by thread threads = {} for email in emails: if not email.thread_id in threads.keys(): threads[email.thread_id] = [] threads[email.thread_id].append(email) write("Removed bad emails") # Sort and pull off the last responder last_responder_was_me = [] last_responder_was_counterparty = [] selfies = [] only_sender_was_me = [] for key in threads.keys(): thread = threads[key] #if len(thread) > 5: # import ipdb; # ipdb.set_trace() thread.sort(cmp=lambda x,y:cmp(x.sent_at, y.sent_at), reverse=True) conversation = Conversation(thread) last_email = conversation.last_email # import ipdb # if "rentapp" in last_email.fr and "rentapp" in last_email.to: # ipdb.set_trace() # I wrote it to someone other than me if (email_in_aliases(last_email.fr, ALIASES) and \ not email_in_aliases(last_email.to, ALIASES)): last_responder_was_me.append(conversation) # I wrote it to myself elif (email_in_aliases(last_email.fr, ALIASES) and \ email_in_aliases(last_email.to, ALIASES)): selfies.append(conversation) # Someone else wrote it else: last_responder_was_counterparty.append(conversation) if all([email_in_aliases(email.fr, ALIASES) for email in conversation.thread]): only_sender_was_me.append(conversation) inbound_emails = [email for email in emails \ if (email_in_aliases(email.to, ALIASES) and \ not email_in_aliases(email.fr, ALIASES))] outbound_emails = [email for email in emails \ if (email_in_aliases(email.fr, ALIASES) and \ not email_in_aliases(email.to, ALIASES))] selfie_emails = [email for email in emails \ if (email_in_aliases(email.fr, ALIASES) and \ email_in_aliases(email.to, ALIASES))] other_emails = [email for email in emails \ if (not email_in_aliases(email.fr, ALIASES) and \ not email_in_aliases(email.to, ALIASES))] email_days = set(email.sent_at.date() for email in emails) emails_received_by_day = [(email_day, len([email for email in inbound_emails if email.sent_at.date() == email_day])) for email_day in email_days] emails_sent_by_day = [(email_day, len([email for email in outbound_emails if email.sent_at.date() == email_day])) for email_day in email_days] emails_received_by_day.sort(cmp=lambda x,y: cmp(x,y)) emails_sent_by_day.sort(cmp=lambda x,y: cmp(x,y)) emails_received_by_day = [{"date": "{} {}".format(day_of_week(date.weekday()), date.day), "count": count} for (date, count) in emails_received_by_day] emails_sent_by_day = [{"date": "{} {}".format(day_of_week(date.weekday()), date.day), "count": count} for (date, count) in emails_sent_by_day] write("Sorted emails") write("* " * 25) inbox_total = g.inbox().count() inbox_unread = g.inbox().count(unread=True) total_email_count = total_email_count ignored_for_email = ignored_for_email ignored_for_subject = ignored_for_subject ignored_for_body = ignored_for_body num_remaining_emails = len(emails) num_threads = len(threads) num_inbound_emails = len(inbound_emails) num_outbound_emails = len(outbound_emails) num_selfie_emails = len(selfie_emails) num_other_emails = len(other_emails) num_last_responder_was_me = len(last_responder_was_me) num_last_responder_was_counterparty = len(last_responder_was_counterparty) response_times = [] for thread in (last_responder_was_counterparty + last_responder_was_me): response_times.extend(thread.get_response_times()) senders = {} for response_time in response_times: if not response_time.get("fr"): continue sender = response_time.get("fr").lower() name, email_address = parseaddr(sender) if not email_address in senders.keys(): senders[email_address] = {'response_times':[]} senders[email_address]['response_times'].append(response_time.get("response_time")) emails_sent_per_person = [(sender, len(senders[sender].get("response_times"))) for sender in senders.keys()] emails_sent_per_person.sort(cmp=lambda x,y: cmp(x[1], y[1]), reverse=True) for sender in senders.keys(): senders[sender]['num_no_response'] = len([response_time is None for response_time in senders[sender]['response_times']]) senders[sender]['response_times'] = [response_time for response_time in senders[sender]['response_times'] if not response_time is None] my_response_times = [] for sender in senders.keys(): if email_in_aliases(sender, ALIASES): my_response_times.extend(senders[sender].get("response_times")) my_response_times = [int(t/3600) for t in my_response_times] last_responder_was_me = [convert_conversation_object_to_dict(i) for i in last_responder_was_me] last_responder_was_counterparty = [convert_conversation_object_to_dict(i) for i in last_responder_was_counterparty] only_sender_was_me = [convert_conversation_object_to_dict(i) for i in only_sender_was_me] only_sender_was_me.sort(cmp=lambda x,y: cmp(x.get("length"), y.get("length")), reverse=True) emails_sent_per_person.sort(cmp=lambda x,y: cmp(x[1], y[1]), reverse=True) ignored_for_email = [convert_email_object_to_dict(i) for i in ignored_for_email] ignored_for_subject = [convert_email_object_to_dict(i) for i in ignored_for_subject] ignored_for_body = [convert_email_object_to_dict(i) for i in ignored_for_body] #_last_responder_was_me = [] #for conversation in last_responder_was_me: # _last_responder_was_me.append( # dict(thread_length=conversation.length, # to=conversation.last_email.to, # url=conversation.get_gmail_url(), # subject=conversation.last_email.subject)) #last_responder_was_me = _last_responder_was_me #_last_responder_was_counterparty = [] #for conversation in last_responder_was_counterparty: # if conversation.length > MIN_THREAD_LENGTH: # _last_responder_was_counterparty.append( # dict( # thread_length=conversation.length, # fr=conversation.last_email.fr, # url=conversation.get_gmail_url(), # subject=conversation.last_email.subject)) #last_responder_was_counterparty = _last_responder_was_counterparty keys = [ "inbox_total", "inbox_unread", "total_email_count", "ignored_for_email", "ignored_for_subject", "ignored_for_body", "num_remaining_emails", "num_threads", "num_inbound_emails", "num_outbound_emails", "num_selfie_emails", "num_other_emails", "num_last_responder_was_me", "num_last_responder_was_counterparty", "last_responder_was_me", "last_responder_was_counterparty", "only_sender_was_me", "senders", "response_times", "my_response_times", "emails_sent_per_person", "DAYS", "emails_sent_by_day", "emails_received_by_day", ] return dict([(key, locals()[key]) for key in keys])
def readMail(): # Read & Parse the mail index = 0 gpsflag = 0 seplat = 0.0 maxlat = 0.0 minlat = 999.999 datalat = [] seplon = 0.0 maxlon = 0.0 minlon = 999.999 datalon = [] gpsdata = "" try: flat = "N/A" flon = "N/A" g = Gmail() g = gmail.login('*****@*****.**', 'qaz123ws') print "[*] Authentication complete." emails = g.inbox().mail(sender='*****@*****.**') print "[*] Engaging email parsing." for email in emails: index = index + 1 email.read() email.fetch() time = email.sent_at print time time = time + datetime.timedelta(hours=9) print time body = email.body print "[*] RAW body : "+body if (len(body) >= 12) and (body.find("http") == -1) : body = b64(email.body) print "[*] Base64 decoded body : "+body surl = re.findall('(https?:\/\/\S+)', str(body)) surl = str(surl)[2:-2] path = (surl.split("/")[-1]) surl = surl.replace(path, '') path = re.sub('[=@#?$}.]', '', path.decode('utf-8')) surl = surl + path if len(str(surl).split("/")[-1]) > 4 and str(surl).find("grep.kr") != -1 : print str(surl.find("grep.kr")) path = (surl.split("/")[-1]) surl = surl.replace(path, '') path = path[:4] surl = surl + path print "[*] grep.kr processed: ", surl if str(surl).decode('utf-8').find(str("\\x")) > -1 : print surl print str(surl).decode('utf-8') surl = re.sub('(\\\\x..)', '', str(surl).decode('utf-8')) print "[*] Junk data removed: ", surl if str(surl).find('\\n') != -1: surl = str(surl)[:-2] print "[*] New line removed: ", surl furl, surl = unshortURL(surl.decode('utf-8')) print "[*] URL Unshortened" print "[*] Shortened URL : "+surl print "[*] Full URL : "+str(urllib.unquote(urllib.unquote(furl)).decode('utf-8').encode('cp949')) filename = furl.split('/')[-1] filepath = (dirpath+"\\"+filename) filepath = urllib2.unquote(urllib.unquote(filepath)).decode('utf-8').encode('cp949') req = urllib2.Request(furl, headers={ 'User-Agent': 'Mozilla/5.0' }) req.add_header('Accept', 'application/json') file = urllib2.urlopen(req) file.close() urllib.urlretrieve(furl, filepath) fMD5 = MD5(filepath) fSHA1 = SHA1(filepath) if filepath.split('.')[-1] == 'jpg' : flat, flon = jpgGPS(filepath) if flat!="N/A" and flon!="N/A" : print "[*] GPS data found, Lat: " + str(flat) +" Lon:"+str(flon) flat = float(flat) flon = float(flon) datalat.append(flat) datalon.append(flon) if(flat > maxlat) : maxlat = flat if(flat < minlat) : minlat = flat if(flon > maxlon) : maxlon = flon if(flon < minlon) : minlon = flon gpsflag=1 furl = urllib.unquote(urllib.unquote(furl)) filename = urllib.unquote(urllib.unquote(filename)) print "[*] Information added to CSV file" addCsv(filepath, str(index), str(time), str(surl), str(furl), str(filename), str(flat), str(flon), str(fMD5), str(fSHA1)) SQLDump(str(time), str(surl), str(furl), str(filename), str(flat), str(flon), str(fMD5), str(fSHA1)) finallat = datalat[:] finallon = datalon[:] except gmail.AuthenticationError: print "Auth fail" print "[*] Mail read complete." if gpsflag == 1: latsum = 0.0 lonsum = 0.0 for i in datalat: latsum = latsum + i latavg = latsum / len(datalat) for i in datalon: lonsum = lonsum + i lonavg = lonsum / len(datalon) if((abs(maxlat-minlat) > 1.5) or abs(maxlon-minlon) > 1.5) and ((abs(latavg-minlat) > 1.5) or (abs(lonavg-minlon) > 1.5)) : datalat.remove(maxlat) datalat.remove(minlat) datalon.remove(maxlon) datalon.remove(minlon) sum = 0.0 latsum = 0.0 lonsum = 0.0 print maxlat, minlat, latavg, datalat, finallat print maxlon, minlon, lonavg, datalon, finallon print lonavg if(abs(latavg-minlat) > 1.5): print "[*] latavg - minlat : ",latavg-minlat finallat.remove(minlat) seplat = minlat elif(abs(maxlat-latavg) > 1.5) : print "[*] maxlat - latavg : ", maxlat-latavg finallat.remove(maxlat) seplat = maxlat if(abs(maxlon-lonavg) > 1.5) : print "[*] maxlon - lonavg : ", maxlon-lonavg finallon.remove(maxlon) seplon = maxlon elif(abs(lonavg-minlon) > 1.5): print "[*] lonavg - minlon : ",lonavg-minlon finallon.remove(minlon) seplon = minlon seperateGPSMAP(filepath, seplat, seplon) print seplat, seplon for i in range(len(finallat)): gpsdata = gpsdata+str(finallat[i])+","+str(finallon[i])+"|" GPSMAP(filepath, gpsdata)
opener = urllib2.build_opener(urllib2.HTTPSHandler(context=ssl.SSLContext(ssl.PROTOCOL_SSLv23))) urllib2.install_opener(opener) today=str(datetime.datetime.now())[:10] # YYYY MM DD for name of directory year = today[:4] month = today[5:7] day = today[-2:] dirpath = os.path.expanduser('~') + '\Desktop\\result\\' + today # Path of directory ctx = ssl.create_default_context() ctx.check_hostname = False ctx.verify_mode = ssl.CERT_NONE flat = "N/A" flon = "N/A" g = Gmail() g = gmail.login('*****@*****.**', 'qaz123ws') print "[*] Authentication complete." emails = g.inbox().mail(sender='*****@*****.**') print "[*] Engaging email parsing." for email in emails: email.read() email.fetch() time = email.sent_at print email.subject print "original time: ",time time = time + datetime.timedelta(hours=9) print "processed time: ",time print "________________\r\n" todayDir() SQLInit() makeCsv() readMail()
import serial import time from datetime import datetime from gmail import Gmail # Don't forget to replace the email and password in config.py! g = Gmail() g.login(config.email, config.password) # Runs every 10 seconds while True: # Connect to the Bean via virtual serial port. Wait 250ms at most. # Set up the Bean you want to use as a virtual serial device in the # Bean Loader App for OS X. ser = serial.Serial('/tmp/tty.LightBlue-Bean', 9600, timeout=0.25) twitter_emails = g.inbox().mail(sender='*****@*****.**') facebook_emails = g.inbox().mail(sender='facebookmail.com') all_emails = g.inbox().mail(unread=True) # Display how many emails were found in the inbox print datetime.now() print 'Twitter notifications:', len(twitter_emails) print 'Facebook notifications:', len(facebook_emails) print 'All unread emails:', len(all_emails) print # Mark all emails as read so we don't trigger on the same email each time for email in twitter_emails: email.read() for email in facebook_emails: email.read()
def check(instream): input = json.load(instream) username = input['source']['username'] password = input['source']['password'] version = input.get('version') startUid = version.get('uid', "") if version is not None else "" common.msg("logging into gmail as '{0}'".format(username)) g = Gmail() # login, fail if unable to authenticate try: g.login(username, password) except: common.msg("unable to log in") exit(1) # see what emails have appeared messages = g.inbox().mail(unread=True, prefetch=True) messages = sorted(messages, key=lambda m: m.sent_at) messages_after_start = [] found = False for m in messages: # only consider emails after the given startUid if startUid == m.uid: found = True common.msg("[{0}] {1} [check = {2}]".format(m.uid, m.subject, found)) if found: messages_after_start.append(m) # if it's the very first call, let's return the very first email if len(startUid) <= 0: messages_after_start = [messages[0]] if len(messages) > 0 else [] else: # if nothing has been found, let's return the complete list if not found: messages_after_start = messages # return the resulting list result = [] for m in messages_after_start: try: # read the corresponding email message (so we don't receive it during the next check) # but keep it in the mailbox and don't move anywhere, so it doesn't change uid m.read() result.append({'uid': m.uid}) except: common.msg("[{0}] {1} [unable to mark message as read".format( m.uid, m.subject)) break # log out and swallow the error try: g.logout() except: pass return result
# import getemailcontent.py import sys sys.path.append('D:/python_stufff/algorithm') import gmail from gmail import Gmail import datetime import xlwt #excel python library import xlrd #write excel import re #regular expression import types import numpy as np g = Gmail() username='******' password='******' g.login(username, password) g.inbox().mail(unread=True, sender="*****@*****.**")#sender data=g.inbox().mail(on=datetime.date(2014, 3, 26)) #date #print len(data) #number of emails for i in range(len(data)-1): data[i].fetch() #get email # print data[i].body #testing and printing email #-----------------------------------------------------------------------------------------------------------------------# #each email including contents like attachement is not attached, find all attachments than erase everything before that maillist=(len(data)-1,2) indexlist=np.zeros(maillist) for i in range(5): indexlist[i,:]=np.asarray(re.search('Attached',data[i].body).span())
from account import Account from gmail import Gmail gmail = Gmail() while True: choice = input('1. Sign up\n2. Login\n') if choice == '1': new_account = Account() elif choice == '2': user_account = Account.login() if user_account != None: while True: choice2 = input('1. Inbox\n2.Send Email\n') if choice2 == '1': inbx = gmail.inbox(user_account) print(inbx) choice3 = input('Enter the index of message to view (max {}) / -1 to go back: '.format(len(inbx)-1)) if int(choice3) == -1: pass else: print(gmail.view_message(int(choice3),inbx)) elif choice2 == '2': #to_email, msg, subject, user t = input('To: ') s = input('Subject: ') m = input('Message: ') gmail.send_email(t, m, s, user_account)
browser_url = browser.get_url() for url in success_urls: if browser_url.startswith(url): return True return False if __name__ == '__main__': dir_here = os.path.dirname(os.path.realpath(__file__)) filename = os.path.join(dir_here, 'private/funshop_result.txt') g = Gmail() while not g.logged_in: time.sleep(1) g.login(private.GMAIL_ID, private.GMAIL_PASSWORD) print("logged in!") mails = g.inbox().mail(unread=True, sender='*****@*****.**') print("total %d unread mails from funshop" % len(mails)) for m in mails: m.fetch() content = m.message.get_payload(decode=True) url = get_delivery_point_urls(content) if url is None: print('No point button on this email') is_success = True else: is_success = get_delivery_point(url) with open(filename, 'a') as fp: fp.write('%s: %s\n' % (datetime.datetime.now().isoformat(), is_success)) if is_success: print('success!')
from account import Account from gmail import Gmail gmail = Gmail() while True: choice = input('1. Sign up\n2. Login\n') if choice == '1': new_account = Account() elif choice == '2': user_account = Account.login() if user_account != None: while True: choice2 = input('1. Inbox\n2.Send Email\n') if choice2 == '1': inbx = gmail.inbox(user_account) print(inbx) choice3 = input( 'Enter the index of message to view (max {}) / -1 to go back: ' .format(len(inbx) - 1)) if int(choice3) == -1: pass else: print(gmail.view_message(int(choice3), inbx)) elif choice2 == '2': #to_email, msg, subject, user t = input('To: ') s = input('Subject: ') m = input('Message: ') gmail.send_email(t, m, s, user_account)
# Settings login = '******' # Login for gmail account password = '******' # Password for gmail account template = ['Rejected', 'Undeliverable', 'Failure', 'Delay'] # Stop words to search bounces safeemail = [login, '*****@*****.**' ] # email that shouldn't be in the final list # The big number of message in inbox can stuck your OS. Python eat a lot of RAM. rd = True # Param to get unread only messages. If you want to get all mesagges put it False st = False # Star message. If you want to star message put it True dl = False # Delete message. If you want to delete message put it True g = Gmail() g.login(login, password) # there are a lot of parameters for filtering here https://github.com/charlierguo/gmail mails = g.inbox().mail(unread=rd) # Get emails with open('bounced.txt', 'a') as result: for mail in mails: res = '' mail.fetch() if any(tmp in mail.subject for tmp in template): try: res = mail.headers['X-Failed-Recipients'] print 'EMAIL:', res, '\033[32m', mail.fr, '\033[0m' result.write(res + '\n') if st: mail.star() if dl: mail.delete() continue
def doScrape(Con, q): try: g = Gmail() ################ LOGIN ##################################### q.put(('Logging In', 5),) logger.info("Logging In") try: g.login(Con.Username, Con.Password) except AuthenticationError: logger.exception(sys.exc_info()) q.put(('Login Failed', 100),) return "AUTH_ERROR" ############################################################ ################ GET LABEL MAILBOX ######################### mailbox = None q.put(('Getting Mailbox', 10),) logger.info("Getting Mailbox") try: if Con.Label.lower() == 'inbox': mailbox = g.inbox() else: mailbox = g.mailbox(Con.Label) except: logger.exception(sys.exc_info()) q.put(('Problem in fetching Gmail Label', 100),) return "LABEL_FETCH_ERROR" if not mailbox: q.put(('Gmail Label Not Found', 100),) return "LABEL_NOT_FOUND" ############################################################ ################ GET EMAILS ################################ mails = None q.put(('Searching For Emails', 15),) logger.info("Searching Emails") try: afterDate = Con.FromDate - timedelta(days=1) beforeDate = Con.ToDate + timedelta(days=1) mails = mailbox.mail(subject='Fiverr: Congrats! You have a new order', after=afterDate, before=beforeDate) mails.extend(mailbox.mail(subject='just ordered an Extra', after=afterDate, before=beforeDate)) # mails = mailbox.mail(after=Con.FromDate, before=Con.ToDate) except: logger.exception(sys.exc_info()) q.put(('Problem in searching for emails', 100),) return "EMAILS_FETCH_ERROR" if len(mails) == 0: q.put(('No Emails Found with search criteria', 100),) return "NO_EMAIL_FOUND" ############################################################ ################ FETCH EMAILS ############################## q.put(('Fetching Emails', 20),) logger.info("Scraping Order Data From Emails") Con.Orders = [] logger.info("Num of Emails found: " + str(len(mails))) try: for mail in mails: msg = "Fetching Email " + str(mails.index(mail)+1) + ' of ' + str(len(mails)) per = 20 + int((float(mails.index(mail)+1) * 100.0 * 0.6 / float(len(mails)))) q.put((msg, per),) #logger.info(msg) mail.fetch() gmailEvents.extract_orders_from_email(mail, Con) except: logger.exception(sys.exc_info()) q.put(('Problem in fetching emails', 100),) return "EMAIL_FETCH_ERROR" ############################################################ # return 'SUCCESS' ################ CALCULATE TOTAL AMOUNT #################### q.put(('Calculating Total and Revenue', 85),) logger.info("Calculating Total Amount") gmailEvents.calculate_total_amount(Con) ############################################################ ################ GENERATE XLS ############################## q.put(('Generating XLS', 90),) logger.info("Generating XLS") gmailEvents.generate_xls(Con) ############################################################ q.put(('Logging Out of Gmail', 95),) g.logout() q.put(('SUCCESS', 100),) return 'SUCCESS' except: if g: g.logout() logger.exception(sys.exc_info()) q.put(('Error Occurred', 100),) return "ERROR"
year = int(date_str.split("-")[0]) month = int(date_str.split("-")[1]) day = int(date_str.split("-")[2]) date_formated = datetime.date(year, month, day) return date_formated # End functions g = Gmail() # Find a way to 'hide' your credentials. That must be insecure :) g.login("your_email", "your_password") alerts = g.inbox().mail(prefetch=True, unread=True, sender='*****@*****.**') extractions = [] for alert in alerts: if alert.body.find("Photos") != -1: address = alert.body.split( "We found a new property for you:")[1].split("https")[0].strip() area = address.split(",")[-2].strip() acc = alert.body.split("Photos")[1].split("<strong")[0].strip() price = alert.body.split("€")[1].split("</strong")[0] price = int(price.replace(",", "")) per_mth_week = alert.body.split("</strong>")[1].split( "To opt out")[0].strip() beds = acc.split("|")[1].strip() baths = acc.split("|")[2].strip()
def doScrape(Con, q): try: g = Gmail() ################ LOGIN ##################################### q.put(('Logging In', 5), ) logger.info("Logging In") try: g.login(Con.Username, Con.Password) except AuthenticationError: logger.exception(sys.exc_info()) q.put(('Login Failed', 100), ) return "AUTH_ERROR" ############################################################ ################ GET LABEL MAILBOX ######################### mailbox = None q.put(('Getting Mailbox', 10), ) logger.info("Getting Mailbox") try: if Con.Label.lower() == 'inbox': mailbox = g.inbox() else: mailbox = g.mailbox(Con.Label) except: logger.exception(sys.exc_info()) q.put(('Problem in fetching Gmail Label', 100), ) return "LABEL_FETCH_ERROR" if not mailbox: q.put(('Gmail Label Not Found', 100), ) return "LABEL_NOT_FOUND" ############################################################ ################ GET EMAILS ################################ mails = None q.put(('Searching For Emails', 15), ) logger.info("Searching Emails") try: afterDate = Con.FromDate - timedelta(days=1) beforeDate = Con.ToDate + timedelta(days=1) mails = mailbox.mail( subject='Fiverr: Congrats! You have a new order', after=afterDate, before=beforeDate) mails.extend( mailbox.mail(subject='just ordered an Extra', after=afterDate, before=beforeDate)) # mails = mailbox.mail(after=Con.FromDate, before=Con.ToDate) except: logger.exception(sys.exc_info()) q.put(('Problem in searching for emails', 100), ) return "EMAILS_FETCH_ERROR" if len(mails) == 0: q.put(('No Emails Found with search criteria', 100), ) return "NO_EMAIL_FOUND" ############################################################ ################ FETCH EMAILS ############################## q.put(('Fetching Emails', 20), ) logger.info("Scraping Order Data From Emails") Con.Orders = [] logger.info("Num of Emails found: " + str(len(mails))) try: for mail in mails: msg = "Fetching Email " + str(mails.index(mail) + 1) + ' of ' + str(len(mails)) per = 20 + int((float(mails.index(mail) + 1) * 100.0 * 0.6 / float(len(mails)))) q.put((msg, per), ) #logger.info(msg) mail.fetch() gmailEvents.extract_orders_from_email(mail, Con) except: logger.exception(sys.exc_info()) q.put(('Problem in fetching emails', 100), ) return "EMAIL_FETCH_ERROR" ############################################################ # return 'SUCCESS' ################ CALCULATE TOTAL AMOUNT #################### q.put(('Calculating Total and Revenue', 85), ) logger.info("Calculating Total Amount") gmailEvents.calculate_total_amount(Con) ############################################################ ################ GENERATE XLS ############################## q.put(('Generating XLS', 90), ) logger.info("Generating XLS") gmailEvents.generate_xls(Con) ############################################################ q.put(('Logging Out of Gmail', 95), ) g.logout() q.put(('SUCCESS', 100), ) return 'SUCCESS' except: if g: g.logout() logger.exception(sys.exc_info()) q.put(('Error Occurred', 100), ) return "ERROR"
message='' for word in sys.argv[3:]: message+=" " message+=word message=message.strip() client = SinchSMS("app_public_key","app_secret_key") print("Sending '%s' to %s" % (message, number)) client.send_message(number, message) #------------------------------------------------------ if sys.argv[1]=='recive': g = Gmail() g.login('gmail_login', 'gmail_pass') # mark the letters without html markup as Normal messages = g.inbox().mail() for message in messages: message.fetch() message_body=message.body.split() message_body=("".join(message_body)).strip() if this_html(message_body)==False: message.add_label("Normal") # all letters marked as Normal if sys.argv[2]=='all': all_messages=g.label("Normal").mail() for mes in all_messages: mes.fetch() mes.read() # mark letter as read print mes.fr #from whom print mes.body # main text (body) of e-mail
def findPayments(username, password): # Main Part, use Gmail to find venmo balances file = open('recent.txt', 'r') most_recent = file.read() file.close() IDs = [0, most_recent] charges = {} #can use this if we only want to check most recent emails #then = datetime.datetime.now().replace(hour=8, minute=0, second=0, microsecond=0) ''' Make benefits_on true to provide benefits to DKEggertor founders ''' benefits_on = False g = Gmail() g.login(username, password) newMail = g.inbox().mail(fr="*****@*****.**") print "got mail" #Filter venmo emails that are payments emails from venmo payments = filterPayments(newMail) print "filtered" #Can use this part to implement only most recent email checking, Note: use email.sent_at to get the emails timestamp. #for i in pay: #if i.sent_at >= then: #payments.append(i) #Iterate through payment emails to find balances i = 0 while i < len(payments): #Check if the ID number of the email has already been checked #as this prevents checking emails twice and incorrectly calculating balances if payments[i].uid not in IDs: print "Test 1" #Check if email is a payment to DKE Keg if isKegEmail(payments[i]) and int( payments[i].uid) >= int(most_recent) + 1: print "Test 2" #Seperate out the subject of the email to find Name and Amount that was paid IDs.append(payments[i].uid) payments[i].fetch() print "Fetched" message = payments[i].subject print "subject" name = message.split(" p")[0] if len(message.split("$")[1]) >= 10: amount = float(message.split("$")[1].split(" ")[0]) else: amount = float(message.split("$")[1]) #Update amount if name is already in the database if name in charges: amount = charges[name] + amount #This check is only for when I (Mike DeLaus) pay from the my venmo account as it is the same email we use for DKE Keg if name != "You": charges[name] = amount #Provides benefits for the founding members of DKEggerator founders = ["Michael DeLaus", "Ryan Kelly", "Mitch Maisel"] for name in founders: if benefits_on == True: charges[name] = 999999999999 file = open('recent.txt', 'w') most_recent = payments[i].uid file.write(str(most_recent)) file.close() i += 1 return charges #Sleep the program so we don't constantly check, can probably find better way to do this #time.sleep(60) #Logout of email so next check uses a refreshed inbox g.logout()
class EmailBot(object): def __init__(self): self.email = None self.friends = [] self.gmail = None self.outbox = None @property def logged_in(self): return (self.gmail and self.gmail.logged_in and self.outbox and self.outbox.logged_in) def login(self): with open(CREDENTIALS, "r") as handle: lines = [line.rstrip("\n") for line in handle] self.email = lines[0] gmail_user = self.email.split("@")[0] password = lines[1] self.friends = lines[2:] logging.info("Logging in to Gmail.") self.gmail = Gmail() self.gmail.login(gmail_user, password) self.outbox = EmailSender(self.email) self.outbox.login(password) return self.gmail.logged_in and self.outbox.logged_in def logout(self): if self.gmail and self.gmail.logged_in: logging.info("Logging out of Gmail.") self.gmail.logout() self.gmail = None if self.outbox and self.outbox.logged_in: self.outbox.logout() self.outbox = None def fetch_messages(self): logging.info("Fetching messages from inbox.") n = 0 for friend in self.friends: logging.debug("Fetching messages for {}".format(friend)) msgs = self.gmail.inbox().mail(unread=True, sender=friend) for msg in msgs: msg.fetch() if not msg.subject: continue logging.debug("Found message: {}".format(msg.subject)) n += 1 if msg.subject.startswith("[cmd]"): self._execute_friend_command(friend, msg) elif msg.subject.startswith("[ping]"): self.outbox.send(friend, "[pong]", "") msg.read() elif msg.subject.startswith("[bot]"): self._save_message(msg) else: logging.debug("Ignored message.") logging.info("Fetched {} messages.".format(n)) return n def _execute_friend_command(self, friend, msg): cmd = msg.subject[6:].strip() logging.debug("Executing {}".format(cmd)) try: output = subprocess.check_output(cmd, shell=True) logging.info("Friend command executed successfully.") self.outbox.send(friend, "Re: " + msg.subject, output) except subprocess.CalledProcessError as e: logging.error("Friend command raised an error: " + repr(e)) logging.debug("Error code: " + str(e.returncode)) logging.debug("Output:\n" + e.output) msg.read() def _save_message(self, msg): for attachment in msg.attachments: if not attachment.name is None: attachment.name = "".join(attachment.name.split()) logging.debug("Found attachment: " + attachment.name) attachment.save(PRINT_DIR) filepath = os.path.join(PRINT_DIR, attachment.name) logging.debug("Saved attachment at: " + filepath) msg.read() def __enter__(self): self.login() return self def __exit__(self, exc_type, exc_value, traceback): self.logout()
import sys from gmail import Gmail username = '******' # password print('Please enter the password for ' + username) password = raw_input() g = Gmail() g.login(username, password) g.inbox().mail(sender="*****@*****.**") # cleanup, logout, and exit g.logout() sys.exit()