def upload():
os.system('python --version > file.txt')
CLIENT_SECRET_FILE = 'client_secret.json'
API_NAME = 'drive'
API_VERSION = 'v3'
SCOPES = ['https://www.googleapis.com/auth/drive']
folder_id = '1Bz75IcdiIB-bdmc68ux-v42hlyolup2G'
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
file_names = ['file.txt']
mime_types = ['text/plain']
for file_name, mime_type in zip(file_names, mime_types):
file_metadata = {'name': file_name, 'parents': [folder_id]}
media = MediaFileUpload('./{0}'.format(file_name), mimetype=mime_type)
service.files().create(body=file_metadata,
media_body=media,
fields='id').execute()
#try:
# main()
#except:
# print("error")
def uploadToYoutube(path, title, description, thumbpath):
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
request_body = {
'snippet': {
'categoryI': 19,
'title': title,
'description': description,
'tags': ['development']
},
'status': {
'privacyStatus': 'unlisted',
# 'publishAt': upload_date_time,
'selfDeclaredMadeForKids': False,
},
'notifySubscribers': False
}
# mediaFile = MediaFileUpload('test23.mp4')
mediaFile = MediaFileUpload(path)
response_upload = service.videos().insert(part='snippet,status',
body=request_body,
media_body=mediaFile).execute()
service.thumbnails().set(videoId=response_upload.get('id'),
media_body=MediaFileUpload(thumbpath)).execute()
return response_upload
def upload_file(outfile):
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
# upload_date_time = datetime.datetime(2020, 12, 25, 12, 30, 0).isoformat() + '.000Z'
request_body = {
'snippet': {
'categoryI': 19,
'title': 'My Python Uploaded Music Video',
'description':
'This video was created automatically by an AI agent by Eng. Dr. MD. Wsaam',
'tags': ['Travel', 'video test', 'Travel Tips']
},
'status': {
'privacyStatus': 'public',
'selfDeclaredMadeForKids': False,
},
'notifySubscribers': False
}
mediaFile = MediaFileUpload(outfile)
response_upload = service.videos().insert(part='snippet,status',
body=request_body,
media_body=mediaFile).execute()
#service.thumbnails().set(
# videoId=response_upload.get('id'),
# media_body=MediaFileUpload('thumbnail.png')
#).execute()
print("Uploaded successfully")
def __init__(self):
CLIENT_SECRET_FILE = 'client_secret_GoogleCloudDemo.json'
API_NAME = 'drive'
API_VERSION = 'v3'
SCOPES = ["https://www.googleapis.com/auth/drive"]
self.service = Create_Service(CLIENT_SECRET_FILE, API_NAME,
API_VERSION, SCOPES)
def hi():
CLIENT_SECRET_FILE = '' #download and insert your own secret file of google calender
API_NAME = 'calendar'
API_VERSION = 'v3'
SCOPES = ['https://www.googleapis.com/auth/calendar']
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
syear = sy.get()
smon = sm.get()
sdate = sd.get()
eyear = ey.get()
emon = em.get()
edate = ed.get()
stime = sh.get()
smin = smi.get()
etime = eh.get()
emin = emi.get()
event_name = en.get()
edes = ed1.get()
stime, smin = time(stime, smin)
etime, emin = time(etime, emin)
#Create
calendar_id_party = '' ##insert your own id
event_request_body = {
'start': {
'dateTime':
convert_to_RFC_datetime(int(syear), int(smon), int(sdate),
int(stime), int(smin)),
'timeZone':
'Asia/Kolkata',
},
'end': {
'dateTime':
convert_to_RFC_datetime(int(eyear), int(emon), int(edate),
int(etime), int(emin)),
'timeZone':
'Asia/Kolkata',
},
'summary': event_name,
'description': edes,
'colorId': 5,
'status': 'confirmed',
'transparency': 'opaque',
'visibility': 'public'
}
response = service.events().insert(calendarId=calendar_id_party,
body=event_request_body).execute()
eventId = response['id']
pymsgbox.alert(text='Your event is created successfully',
title='Confirmation',
button='OK')
def __init__(self):
self.config = dotenv_values("resources/.env")
self.CLIENT_SECRET_FILE = 'resources/client_secret.json'
self.API_NAME = 'drive'
self.API_VERSION = 'v3'
self.SCOPES = ['https://www.googleapis.com/auth/drive']
self.service = Create_Service(self.CLIENT_SECRET_FILE, self.API_NAME, self.API_VERSION, self.SCOPES)
def __init__(self, CLIENT_SECRET_FILE):
self.CLIENT_SECRET_FILE = CLIENT_SECRET_FILE
self.API_NAME = "youtube"
self.API_VERSION = "v3"
self.SCOPES = ["https://www.googleapis.com/auth/youtube.upload"]
self.service = Create_Service(self.CLIENT_SECRET_FILE, self.API_NAME,
self.API_VERSION, self.SCOPES)
self.upload_time = datetime.datetime(2020, 1, 1, 12, 30,
0).isoformat() + ".000Z"
def getData(sheet):
CLIENT_SECRET_FILE = 'credentials.json'
API_SERVICE_NAME = 'sheets'
API_VERSION = 'v4'
SCOPES = ['https://www.googleapis.com/auth/spreadsheets.readonly']
s = Create_Service(CLIENT_SECRET_FILE, API_SERVICE_NAME, API_VERSION,
SCOPES)
gs = s.spreadsheets()
rows = gs.values().get(spreadsheetId=sheet, range='Alumnos').execute()
return rows.get('values')
def launch(self):
self.service = Create_Service(self.CLIENT_SECRET_FILE, self.API_NAME,
self.API_VERSION, self.SCPOES)
self.request = self.service.files().get_media(fileId=self.fileId)
self.fh = io.BytesIO()
self.downloader = MediaIoBaseDownload(fd=self.fh, request=self.request)
self.status = self.downloader.next_chunk()[0].progress()
self.fh.seek(0)
with open(f"D:\\EOSs\\{self.savedFileName}", 'wb+') as self.f:
self.f.write(self.fh.read())
self.status = self.status == 1
def calendar():
CLIENT_SECRET_FILE = 'client_secret_key.json.json'
API_NAME = 'calendar'
API_VERSION = 'v3'
SCOPES = ['https://www.googleapis.com/auth/calendar']
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
#inserting a calendar
request_body = {'summary': 'BMSIT ISE EVENTS'}
response = service.calendars().insert(body=request_body).execute()
print(response)
def gsheet_to_df(gsheetId, scope):
CLIENT_SECRET_FILE = 'client_secret.json'
API_SERVICE_NAME = 'sheets'
API_VERSION = 'v4'
SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
s = Create_Service(CLIENT_SECRET_FILE, API_SERVICE_NAME, API_VERSION,
SCOPES)
gs = s.spreadsheets()
rows = gs.values().get(spreadsheetId=gsheetId, range=scope).execute()
header = rows.get('values', [])[0] # Assumes first line is header!
values = rows.get('values', [])[1:] # Everything else is data.
df = pd.DataFrame(values, columns=header)
return df
def df_to_gsheet(df, gsheetId, scope='Arkusz1'):
CLIENT_SECRET_FILE = 'client_secret.json'
API_SERVICE_NAME = 'sheets'
API_VERSION = 'v4'
SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
service = Create_Service(CLIENT_SECRET_FILE, API_SERVICE_NAME, API_VERSION,
SCOPES)
df.replace(np.nan, '', inplace=True)
response_date = service.spreadsheets().values().append(
spreadsheetId=gsheetId,
valueInputOption='RAW',
range=scope + '!A1',
body=dict(majorDimension='ROWS',
values=df.T.reset_index().T.values.tolist())).execute()
def getName():
CLIENT_SECRET_FILE = 'client_secret.json'
API_SERVICE_NAME = 'sheets'
API_VERSION = 'v4'
SCOPES = ['https://www.googleapis.com/auth/spreadsheets.readonly']
gsheetId = '1H3KBMR6J5UBxQStSi1GGUbnHiG5MMSsVBO1if2MsKQk'
s = Create_Service(CLIENT_SECRET_FILE, API_SERVICE_NAME, API_VERSION,
SCOPES)
gs = s.spreadsheets()
rows = gs.values().get(spreadsheetId=gsheetId,
range='Government Agencies').execute()
data = rows.get('values')
df = pd.DataFrame(data)
return (df[0] + ' ' + df[1])
def construct_service(api_service):
CLIENT_SERVICE_FILE = "client_secret.json"
try:
if api_service == "drive":
API_NAME = "drive"
API_VERSION = "v3"
SCOPE = ['https://www.googleapis.com/auth/drive']
return Create_Service(CLIENT_SERVICE_FILE, API_NAME, API_VERSION, SCOPE)
elif api_service == 'gmail':
API_NAME = "gmail"
API_VERSION = "v1"
SCOPE = ['https://mail.google.com/']
return Create_Service(CLIENT_SERVICE_FILE, API_NAME, API_VERSION, SCOPE)
except Exception as e:
print(e)
return None
class google_drive_scrape(object):
def __init__(self):
CLIENT_SECRET_FILE = 'client_secret_GoogleCloudDemo.json'
API_NAME = 'drive'
API_VERSION = 'v3'
SCOPES = ["https://www.googleapis.com/auth/drive"]
self.service = Create_Service(CLIENT_SECRET_FILE, API_NAME,
API_VERSION, SCOPES)
def search(self, search_term):
results = self.service.files().list(
q="fullText contains \'" + search_term + "\' or name contains \'" +
search_term + "\'",
spaces='drive',
fields="nextPageToken, files(id, name, webViewLink)").execute()
items = results.get('files', [])
f = open("search results.html", "w")
if not items:
print('No files found in Google drive.')
else:
f.write("Files found in Google Drive:" + '\n')
for item in items:
# print('{0} ({1})'.format(item['name'], item['webViewLink']))
f.write('<li>' + '<a href=\"' + item['webViewLink'] +
'\"</a>' + '</li>')
f.write(item['name'])
f.close()
def create_service():
CLIENT_SECRET_FILE = 'client_secret.json'
API_NAME = 'youtube'
API_VERSION = 'v3'
SCOPES = ['https://www.googleapis.com/auth/youtube.upload']
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
return service
def sendEmail(messageHeader, receipientEmail, body):
CLIENT_SECRET_FILE = 'credentials.json'
API_NAME = 'gmail'
API_VERSION = 'v1'
SCOPES = ['https://mail.google.com/']
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
emailMsg = body
mimeMessage = MIMEMultipart()
mimeMessage['to'] = receipientEmail
mimeMessage['subject'] = messageHeader
mimeMessage.attach(MIMEText(emailMsg, 'plain'))
raw_string = base64.urlsafe_b64encode(mimeMessage.as_bytes()).decode()
message = service.users().messages().send(userId='me', body={'raw': raw_string}).execute()
print(message)
def bindmailelementsusingAPI(to1):
from Google import Create_Service
import base64
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
global i
global folder_id
CLIENT_SECRET_FILE = "C:\\Users\\darsh\\PycharmProjects\\test111\\test11\\New folder\\client_secrets.json"
API_NAME = 'gmail'
API_VERSION = 'v1'
SCOPES = ['https://mail.google.com/']
global authorizeerror, successsent, sendingerror
try:
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION,
SCOPES)
except:
messagebox.showerror('Error', 'Authorization file moved')
totenant = to1
emailMsg = ''' Hi,
Your monthly rent invoice has been uploaded on the drive.
https://drive.google.com/drive/folders/''' + str(folder_id) + '''
Thanks. '''
global inv_get
mimeMessage = MIMEMultipart()
mimeMessage['to'] = totenant
mimeMessage[
'subject'] = 'Rent Invoice ' + inv_get + ' Uploaded on Drive'
mimeMessage.attach(MIMEText(emailMsg, 'plain'))
raw_string = base64.urlsafe_b64encode(mimeMessage.as_bytes()).decode()
message = service.users().messages().send(userId='me',
body={
'raw': raw_string
}).execute()
messagebox.showinfo('Success', 'Mail successfully sent')
except:
messagebox.showinfo('Error', 'Error in sending email')
def sendemail():
CLIENT_SECRET_FILE = 'src/client_secret.json'
API_NAME = 'gmail'
API_VERSION = 'v1'
SCOPES = ['https://mail.google.com/']
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
emailMsg = event.upper() + " já está disponível!\n\n Disponibilidade: \n" + disp + '\n Dias disponíveis: \n \n' + listday + '\n\n Locais disponíveis: \n' + selplace + "\n Para comprar acesse: " + url_current
mimeMessage = MIMEMultipart()
mimeMessage['to'] = user_mail
mimeMessage['subject'] = 'Auto-Ingresso: Seu Evento Foi Encontrado!'
mimeMessage.attach(MIMEText(emailMsg, 'plain'))
raw_string = base64.urlsafe_b64encode(mimeMessage.as_bytes()).decode()
message = service.users().messages().send(userId='me', body={'raw': raw_string}).execute()
print(message)
def sendMail(filename, ownername, ownermail):
CLIENT_SECRET_FILE = 'gmail.json'
API_NAME = 'gmail'
API_VERSION = 'v1'
SCOPES = ['https://mail.google.com/']
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
emailMsg = 'Estimado ' + ownername + ', el archivo ' + filename + ' se encontraba público y fue modificado a privado.'
mimeMessage = MIMEMultipart()
mimeMessage['to'] = ownermail
mimeMessage['subject'] = 'Un archivo de su Google Drive ha sido modificado'
mimeMessage.attach(MIMEText(emailMsg, 'plain'))
raw_string = base64.urlsafe_b64encode(mimeMessage.as_bytes()).decode()
message = service.users().messages().send(userId='me', body={'raw': raw_string}).execute()
#print(message)
#sendMail('archivo.doc', 'Maria Lujan Tissera', '*****@*****.**')
def send_email(address, subject, message):
print('Starting mail client')
CLIENT_SECRET_FILE = 'client_secret_1041291564289-k0r0de67l1dd1aq3h7fbhopf9re8u0i7.apps.googleusercontent.com.json'
API_NAME = 'gmail'
API_VERSION = 'v1'
SCOPES = ['https://mail.google.com/']
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
emailMsg = message
mimeMessage = MIMEMultipart()
mimeMessage['to'] = address
mimeMessage['subject'] = subject
mimeMessage.attach(MIMEText(emailMsg, 'plain'))
raw_string = base64.urlsafe_b64encode(mimeMessage.as_bytes()).decode()
message = service.users().messages().send(userId='me',
body={
'raw': raw_string
}).execute()
print(message)
def get_youtube_data(data_frame):
"""
A function to get data from YouTube (here, views for each music).
:param data_frame: A dataframe with the YouTube video IDs associated to each music.
:return: The same dataframe but with the total number of views for each music.
"""
client_secret_file = '../files/code_secret_client.json'
api_name = 'YouTube'
api_version = 'v3'
scopes = ['https://www.googleapis.com/auth/youtube']
service = Create_Service(client_secret_file, api_name, api_version, scopes)
df = data_frame.fillna("NONE")
youtube_dict = {}
for an_idx, a_row in df.iterrows():
youtube_dict[a_row["YouTube_ID1"]] = [an_idx]
youtube_dict[a_row["YouTube_ID2"]] = [an_idx]
youtube_dict[a_row["YouTube_ID3"]] = [an_idx]
youtube_dict[a_row["YouTube_ID4"]] = [an_idx]
df1 = pd.DataFrame(youtube_dict).transpose().rename({0: "idx"}, axis=1). \
drop(index="NONE")
videos = list(df1.index)
# print(videos)
video_views = api_get_videos_views(videos, service)
df2 = pd.DataFrame(video_views).transpose().rename({
0: "idx",
1: "views"
},
axis=1)
concat = pd.merge(df1, df2, left_index=True, right_index=True)
view_sum = concat.groupby("idx").sum()
# print(data_frame)
# print(view_sum)
final = data_frame.join(view_sum,
how='outer').rename({'views': "YouTube_Views"},
axis=1)
final.YouTube_Views = final.YouTube_Views.fillna(0)
return final
def exportFile():
CLIENT_SECRET_FILE = "client_secret_290484746034-g2jo5esvo50gs2ckfenl4c172m8rflps.apps.googleusercontent.com.json"
API_Name = 'drive'
API_Version = "v3"
SCOPES = [
'https://www.googleapis.com/auth/drive.readonly',
'https://www.googleapis.com/auth/drive.file',
'https://www.googleapis.com/auth/drive.readonly',
'https://www.googleapis.com/auth/drive.metadata'
]
service = Create_Service(CLIENT_SECRET_FILE, API_Name, API_Version, SCOPES)
file_id = ["1p_RVPF0YjMOX1z2XZeStz_wEbt4OqOACy2mjLz4-hls"]
file_name = [sys.argv[1]]
for file_id, file_name in zip(file_id, file_name):
request = service.files().export_media(fileId=file_id,
mimeType='text/plain')
fh = io.BytesIO()
downloader = MediaIoBaseDownload(fd=fh, request=request)
done = False
while not done:
status, done = downloader.next_chunk()
print("Download Progress {0}".format(status.progress() * 100))
fh.seek(0)
most_recent_zoom_folder_path = ZOOM_FOLDER_PATH + "/" + find_most_recent_zoom_folder(
)
with open(os.path.join(most_recent_zoom_folder_path, file_name),
'wb') as f:
f.write(fh.read())
f.close()
def otp_email(email: str, q: Optional[str] = None):
API_NAME = 'gmail'
API_VERSION = 'v1'
CLIENT_SECRET_FILE = 'credentials.json'
SCOPES = ['https://www.googleapis.com/auth/gmail.readonly']
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
OTP = random.randint(1, 999999)
emailMsg = f"your otp for safemeet varification: {OTP} do not with anyone"
mimeMessage = MIMEMultipart()
mimeMessage['to'] = email
mimeMessage['subject'] = 'SAFEMEET VERIFICATION PROCESS'
mimeMessage.attach(MIMEText(emailMsg, 'plain'))
raw_string = base64.urlsafe_b64encode(mimeMessage.as_bytes()).decode()
message = service.users().messages().send(userId='me',
body={
'raw': raw_string
}).execute()
global otp
otp = OTP
return {"item_id": "sent mail..!", "q": q}
def driveUpload(self):
# CREATE SERVICE
CLIENT_SECRET_FILE = 'client_secret.json'
API_NAME = 'drive'
API_VERSION = 'v3'
SCOPES = ['https://www.googleapis.com/auth/drive']
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
# UPLOAD CSV FILE TO GOOGLE DRIVE
def export_csv(file_path: str, parents: list=None):
if not os.path.exists(file_path):
print(f"{file_path} not found")
return
try:
file_metadata = {
'name': os.path.basename(file_path).replace('.csv', " "),
'mimeType': "application/vnd.google-apps.spreadsheet",
'parents': parents
}
media = MediaFileUpload(filename=file_path, mimetype='text/csv')
response = service.files().create(
media_body =media,
body =file_metadata,
).execute()
print(response)
return response
except Exception as e:
print(e)
return
# UPLOAD THE CSV FILES IN DIRECTORY
csv_files = os.listdir("upload")
for csv_file in csv_files:
print(f"uploading {csv_file} now...")
export_csv(os.path.join('upload', csv_file))
print("drive upload completed")
def create_service(self):
spreadsheetID = self.entry.get()
if len(spreadsheetID) == 0:
msg.showerror(title="ERROR!",
message="The SpreadsheetID field is empty!")
return
self.finished.pack_forget()
self.in_progress.pack()
self.master.update()
"""
Can get credentials.json file from https://developers.google.com/sheets/api/quickstart/python
"""
CLIENT_SECRET_FILE = 'credentials.json'
API_NAME = 'sheets'
API_VERSION = 'v4'
SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION,
SCOPES)
self.cycle_sheets(service, spreadsheetID)
class EOS_DOWNLOADER():
def __init__(self, fileId, savedFileName):
self.CLIENT_SECRET_FILE = 'D:\\Coding\\Py\\DriveAPI\\credentials.json'
self.API_NAME = 'drive'
self.API_VERSION = 'v3'
self.SCPOES = ['https://www.googleapis.com/auth/drive']
self.fileId = fileId
self.savedFileName = savedFileName
def launch(self):
self.service = Create_Service(self.CLIENT_SECRET_FILE, self.API_NAME,
self.API_VERSION, self.SCPOES)
self.request = self.service.files().get_media(fileId=self.fileId)
self.fh = io.BytesIO()
self.downloader = MediaIoBaseDownload(fd=self.fh, request=self.request)
self.status = self.downloader.next_chunk()[0].progress()
self.fh.seek(0)
with open(f"D:\\EOSs\\{self.savedFileName}", 'wb+') as self.f:
self.f.write(self.fh.read())
self.status = self.status == 1
import os
import requests
import textract
import re
import io
from Google import Create_Service
from googleapiclient.http import MediaIoBaseDownload
import spacy
CLIENT_SECRET = 'client_secret.json'
API_NAME = 'drive'
API_VERSION = 'v3'
SCOPES = ['https://www.googleapis.com/auth/drive']
service = Create_Service(CLIENT_SECRET, API_NAME, API_VERSION, SCOPES)
# take google drive ids from shareable links taking into account different links templates
def get_id(url):
if len(url.split('/')) > 6:
doc_id = url.split('/')[-2]
else:
doc_id = url.split('=')[1]
return doc_id
# extract texts from documents given doc_id
def get_text2(doc_id):
# get metadata on doc given id
file_name = service.files().get(fileId=doc_id).execute()
exit(0)
else:
click.secho("Invalid choice", fg="red", bold=True)
return confkey
if __name__ == "__main__":
import sys
# Initialize Google API tasks service
FOLDER_PATH = sys.argv[1]
CLIENT_SECRET_FILE = os.path.join(FOLDER_PATH, 'credentials-trankilou.json')
API_SERVICE_NAME = 'tasks'
API_VERSION = 'v1'
SCOPES = ['https://www.googleapis.com/auth/tasks']
service = Create_Service(CLIENT_SECRET_FILE, API_SERVICE_NAME, API_VERSION,
SCOPES)
# Initialize the list of recipes from the JSON file
data_path = sys.argv[1] + "shopping_lists.json"
db = JManager(data_path)
shopping_lists = db.read_list(ShoppingList.from_json)
recipe_path_data = sys.argv[1] + "recipes.json"
db_recipes = JManager(recipe_path_data)
all_recipes = db_recipes.read_list(Recipe.from_json)
ingredient_path_data = sys.argv[1] + "ingredients.json"
db_ingredients = JManager(ingredient_path_data)
all_ingredients = db_ingredients.read_list(Ingredient.from_json)
units_path_data = sys.argv[1] + "units.json"
db_units = JManager(units_path_data)
all_units = db_units.read_list(Unit.from_json)
domains_path_data = sys.argv[1] + "domains.json"
import plotly.express as px
import plotly.graph_objects as go
from streamlit_echarts import st_echarts
import os
from Google import Create_Service
import re
import datetime
from datetime import timedelta
from secret import sheets_id
CLIENT_SECRET_FILE = 'credentials.json'
API_NAME = 'sheets'
API_VERSION = 'v4'
SCOPES = ['https://www.googleapis.com/auth/spreadsheets.readonly']
service = Create_Service(CLIENT_SECRET_FILE, API_NAME, API_VERSION, SCOPES)
spreadsheet_id = sheets_id
result = service.spreadsheets().values().get(spreadsheetId=spreadsheet_id,
majorDimension='ROWS',
range='A1:R').execute()
# DataFrame
columns = result['values'][0]
data = result['values'][1:]
df = pd.DataFrame(data, columns=columns)
pd.set_option('display.max_columns', None)
# Change Date Format
df['Submitted At'] = pd.to_datetime(df['Submitted At']).dt.normalize()
