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()