def main():
credentials = quickstart.get_credentials()
service = build('gmail', 'v1', http=credentials.authorize(Http()))
message = GetMimeMessage(service, 'me', '1572cb5cbb852f6d')
print(message)
def main():
print("Today : ", today)
print("yesterday : ", yesterday, '\n')
# Week counter
week_counter = 0
credentials = get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('gmail', 'v1', http=http)
results = service.users().labels().list(userId=my_email).execute()
GetMessageIds(today, yesterday, service, my_email)
GetSender(service, my_email, today, week_counter)
def main():
credentials = quickstart.get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('calendar', 'v3', http=http)
calendarIds = [
'*****@*****.**', 'primary'
]
allEvents = getEventsOfTheDay(calendarIds, service)
for event in allEvents:
print(event['summary'], event['start']['dateTime'])
def events_in_interval(interval_start, interval_end, cal_ID):
credentials = get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('calendar', 'v3', http=http)
eventsResult = service.events().list(
calendarId=cal_ID,
timeMin=interval_start.isoformat() + 'Z',
timeMax=interval_end.isoformat() + 'Z',
maxResults=1000,
singleEvents=True,
orderBy='startTime').execute()
events = eventsResult.get('items', [])
return events
def send_mail(recipients, subject, body):
credentials = get_credentials(client_secret_file=CLIENT_SECRET_FILE,
credentials_file=CREDENTIALS_FILE_NAME)
http = credentials.authorize(httplib2.Http())
service = discovery.build('gmail', 'v1', http=http)
body = 'Gist URLs : {}'.format(body)
for recipient in recipients:
raw_message = create_message('me', recipient, subject, body)
try:
message = (service.users().messages().send(
userId='me', body=raw_message).execute())
except errors.HttpError, error:
print 'An error occurred: %s' % error
def handle_event(self, rtm_event):
'''
Handles all real time messaging events.
'''
if len(rtm_event) == 0:
return
event = rtm_event[0]
# Right now, just handles the case where it replies to any message that
# says "hello" with "hello there"
if "type" in event and event["type"] == "message":
channel = event["channel"]
message = event["text"]
if message == "hello":
print("message sent was hello")
self.send_message("hello there", channel)
elif message == "see event":
self.send_message("getting the calendars", channel)
credentials = get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('calendar', 'v3', http=http)
now = datetime.datetime.utcnow().isoformat() + 'Z' # 'Z' indicates UTC time
print('Getting the upcoming 5 events')
eventsResult = service.events().list(
calendarId=self.calendar_id, timeMin=now, maxResults=5, singleEvents=True,
orderBy='startTime').execute()
events = eventsResult.get('items', [])
if not events:
print('No upcoming events found.')
for event in events:
start = event['start'].get('dateTime', event['start'].get('date'))
print(start, event['summary'])
print("looking at calendars")
elif message == "make event":
self.send_message("making the calendars", channel)
create_event(self.calendar_id,"Disney", "Disney", "day")
elif message == "remove event":
self.send_message("removing event")
remove_event("Disney")
def set_talk():
nom = "<Your name>"
location = json.loads(maps.geolocate())
lat = int(location['location']['lat'])
lng = int(location['location']['lng'])
API_key = '<Your API key>' # create an API key on https://openweathermap.org/api
owm = OWM(API_key)
obs = owm.weather_at_coords(lat, lng)
w = obs.get_weather()
l = obs.get_location()
talk = "Hello " + nom + ", the weather is currently " + w.get_detailed_status(
) + " and the temperature is " + str(
int(round(w.get_temperature(unit='celsius')['temp']))) + " degrees. "
slots = b'{"input":"what is my next meeting today","intent":{"intentName":"user_Hk9PxP07b__CalendarIntent","probability":0.34624666},"slots":[{"value":{"kind":"Custom","value":"first"},"rawValue":"next","range":{"start":11,"end":15},"entity":"order2","slotName":"PrecisionDate2"},{"value":{"kind":"Builtin","value":{"kind":"Time","value":{"kind":"InstantTime","value":{"value":"2017-07-10 00:00:00 +00:00","grain":"Day","precision":"Exact"}}}},"rawValue":"today","range":{"start":24,"end":29},"entity":"snips/datetime","slotName":"DateEvent"}]}'
event_talk = calendar.set_talk(slots)
talk = talk + event_talk
credentials = calendar.get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('calendar', 'v3', http=http)
beg = calendar.date(slots)['beggin']
end = calendar.date(slots)['end']
eventsResult = service.events().list(
calendarId=CALENDAR_ID,
timeMin=beg.isoformat() + 'Z',
timeMax=end.isoformat() + 'Z',
singleEvents=True, # 'Z' indicates UTC time
orderBy='startTime').execute()
events = eventsResult.get('items', [])
try:
address = events[0]['location']
new_slot = '{"input":"","intent":{"intentName":"user_Hk9PxP07b__DistanceIntent","probability":0.8132438},"slots":[{"rawValue":' + str(
address
) + ',"value":{"kind":"Custom","value":"lille"},"range":{"start":21,"end":26},"entity":"snips/default--CityDestination","slotName":"CityDestination"}]}'
talk = talk + maps.set_talk(slots)
except:
talk = talk
return talk
def main():
"""
Shows basic usage of the Gmail API.
Creates a Gmail API service object and outputs a list of label names
of the user's Gmail account.
"""
credentials = M.get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('gmail', 'v1', http=http)
results = service.users().labels().list(userId='me').execute()
messageIds = M.ListMessagesMatchingQuery(service, 'me', query='subject:Flight Confirmation')
datalist = []
#f = open('out.txt', 'wb')
for message in messageIds:
datalist.append(M.GetMimeMessage(service, 'me', message[u'id']))
processDateAndTime(datalist[-1])
def main():
credentials = get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('calendar', 'v3', http=http)
timeNow = datetime.datetime.utcnow()
nowStr = timeNow.isoformat() + 'Z' # 'Z' indicates UTC time
eventsResult = service.events().list(
calendarId='primary', timeMin=nowStr, maxResults=100, singleEvents=True,
orderBy='startTime').execute()
events = eventsResult.get('items', [])
if not events:
print('No upcoming events found.')
for event in events:
start = event['start'].get('dateTime', event['start'].get('date'))
end = event['end'].get('dateTime', event['end'].get('date'))
if ((strToDate(start) >= hourToUSEDT(MIN_START_TIME,0, timeNow)) and
(strToDate(start) <= hourToUSEDT(MAX_START_TIME, 0, timeNow))):
print(parse_date(start).hour, ":", parse_date(start).minute, "-",
min(parse_date(end).hour,23),":", parse_date(end).minute, "-", event['summary'])
def send_mail(mail_content):
with io.open('tmpfile.txt', 'w', encoding="utf-8") as f:
f.write(mail_content)
f.close()
#print("Now we would normally send a mail!")
#return 0
SCOPES = 'https://www.googleapis.com/auth/gmail.send'
credentials = qs.get_credentials(SCOPES)
#mail_content = "This is a test"
msg = qs.create_message("*****@*****.**", "*****@*****.**",
"New flats found!", mail_content)
# Send the message via our own SMTP server, but don't include the
# envelope header.
service_id = qs.create_service(credentials)
qs.send_message(service_id, "me", msg)
def SendMessage(message):
credentials = get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('gmail', 'v1', http=http)
user_id = 'me'
"""Send an email message.
Args:
service: Authorized Gmail API service instance.
user_id: User's email address. The special value "me"
can be used to indicate the authenticated user.
message: Message to be sent.
Returns:
Sent Message.
"""
try:
message = (service.users().messages().send(userId=user_id,
body=message).execute())
print('Message Id: ' + str(message['id']))
return message
except errors.HttpError, error:
print('An error occurred: ' + str(error))
def main():
"""Shows basic usage of the Google Calendar API.
Creates a Google Calendar API service object and outputs a list of the next
10 events on the user's calendar.
"""
credentials = quickstart.get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('calendar', 'v3', http=http)
now = datetime.datetime.utcnow().isoformat(
) + 'Z' # 'Z' indicates UTC time
print('Getting the upcoming 10 events')
eventsResult = service.events().list(calendarId='primary',
timeMin=now,
maxResults=10,
singleEvents=True,
orderBy='startTime').execute()
events = eventsResult.get('items', [])
# if not events:
# print('No upcoming events found.')
# for event in events:
# start = event['start'].get('dateTime', event['start'].get('date'))
# print(start, event['summary'])
pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'
string = pytesseract.image_to_string(Image.open('test.jpg'))
events = grabContent(string)
for event in events:
event = service.events().insert(calendarId='primary',
body=event).execute()
print('Event created:', event.get('htmlLink'))
print("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
import quickstart
import httplib2
import os
import urllib2
from apiclient import discovery
from apiclient.http import MediaFileUpload
#Initialize GoogleDrive
credentials = quickstart.get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('drive', 'v3', http=http)
def containsPrints(folder):
for filename in os.listdir(folder):
if filename.endswith(".jpg"):
return True
else:
return False
def internet_on():
try:
response=urllib2.urlopen('http://www.google.com',timeout=1)
return True
except urllib2.URLError as err: pass
return False
def save2drive(filePath, fileName, folderID):
file_metadata = {
'name' : fileName,
'parents': [ folderID ]
def __init__(self):
credentials = quickstart.get_credentials()
http = credentials.authorize(httplib2.Http())
self.client = discovery.build('gmail', 'v1', http=http)
'verizon': 'vtext.com',
'virgin': 'vmobl.com'
}
message = """Subject: %s
%s
""" % (config.subject, config.body)
currentList = []
SMTPserver = smtplib.SMTP("smtp.gmail.com",587)
SMTPserver.starttls()
SMTPserver.login(config.email, config.password)
credentials = quickstart.get_credentials()
http = credentials.authorize(httplib2.Http())
discoveryUrl = ('https://sheets.googleapis.com/$discovery/rest?'
'version=v4')
service = discovery.build('sheets', 'v4', http=http,
discoveryServiceUrl=discoveryUrl)
def createList():
result = service.spreadsheets().values().get(
spreadsheetId=config.spreadsheet_id, range=config.range_name).execute()
for entry in result['values']:
carrier = entry[0].lower()
number = re.sub(r'\D', '', entry[1])
currentList.append({carrier:number})
def __init__(self):
credentials = get_credentials()
http = credentials.authorize(httplib2.Http())
self.service = apiclient.discovery.build("drive", "v3", http=http)
def test_credentials_valid():
"""Test that get_credentials from quickstart still works."""
from quickstart import get_credentials
credentials = get_credentials()
assert not credentials.invalid
def main():
credentials = get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('gmail', 'v1', http=http)
message_body = CreateMessage('*****@*****.**','*****@*****.**','Test again','I am testing again')
CreateDraft(service,'me',message_body)
def set_talk(slots):
try:
origin = slots['CityOrigin']
except:
location = json.loads(geolocate())
lat = location['location']['lat']
lng = location['location']['lng']
origin = str(lat) + ',' + str(lng)
try:
destination = slots['CityDestination']
except:
try:
credentials = quickstart.get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('calendar', 'v3', http=http)
try:
beg = str_To_Date(slots['date']['value']['value']['from'])
end = str_To_Date(slots['date']['value']['value']['to'])
except:
try:
beg = quickstart.str_To_Date(slots['dateEvent']['value'])
end = quickstart.end_Of_Day(beg)
except:
beg = datetime.datetime.utcnow()
end = quickstart.end_Of_Day(beg)
eventsResult = service.events().list(
calendarId=CALENDAR_ID, timeMin=beg.isoformat()+'Z', timeMax=end.isoformat()+'Z', singleEvents=True, # 'Z' indicates UTC time
orderBy='startTime').execute()
events = eventsResult.get('items', [])
try:
order = slots['order'].lower()
except:
order = 'initial'
if (order == "initial" or order == "next"):
index = 0
else:
index = len(events)-1
if (len(events)==0) :
destination = ""
else:
destination = events[index]['location']
except:
destination = ""
try:
mode = slots['TravelMode']
distance = get_distance(origin, destination, mode)
except:
distance = get_distance(origin, destination)
if distance_to_tab(distance)['hours']==-1 or distance_to_tab(distance)['mins']==-1 :
talk = "Sorry, I can't find any way to go there."
else :
hours = distance_to_tab(distance)['hours']
mins = distance_to_tab(distance)['mins']
talk = "It will take you "
if hours != 0 :
talk += str(hours) + " hours and "
talk += str(mins) + " minutes to go to " + destination
return talk
