def get_google_auth():
"""Create a connection to Google Drive
On first use, a client_secrets.json file must be placed in the current directory.
If you need guidance on where to get the client_secrets.json file, run `auth-help`.
Or consult project readme. Source: https://github.com/wrecodde/pusher#readme
If authentication has been previously set up, authentication credentials would be loaded
from saved file.
"""
# TODO: need to allow for expiry and refresh of tokens
global drive
google_auth = GoogleAuth()
if CREDS_FILE.exists():
try:
google_auth.LoadCredentialsFile(CREDS_FILE)
except:
error_message = \
"Error occured when attempting to use saved auth credentials. \n\
Check your internet connection. If the error persists, clear saved credentials with `clear-auth`."
logger.error(error_message)
else:
logger.info('Unavailable auth credentials. Allow access with the `add-auth` command.')
sys.exit()
drive = GoogleDrive(google_auth)
def upload_via_celery(self, name, file_name, cred_file):
gauth = GoogleAuth()
print(os.listdir(settings.MEDIA_ROOT + "/uploaded"))
gauth.LoadCredentialsFile(settings.MEDIA_ROOT + "/" + cred_file)
self.update_state(state='PROGRESS')
# all_objects_dict = {"web_address":[],"original_text":[],"translated_text":[],"name":[],"hyperlink":[],"img":[],"link_to_image":[],"drive_link":[]}
all_objects_dict = scrap_the_file(name, self)
print(all_objects_dict)
dataframe = pd.DataFrame(all_objects_dict)
dataframe.drop(columns=["image_data"])
dataframe.columns = [
"Page", "description", "Translated Text", "Name", "hyperlink", "img",
"link_to_image", "drive_link"
]
dict = dataframe.to_dict()
json_str = json.dumps(dict)
if os.path.exists(settings.MEDIA_ROOT + "/" + cred_file):
os.remove(settings.MEDIA_ROOT + "/" + cred_file)
if os.path.exists(settings.MEDIA_ROOT + "/" + cred_file):
os.remove(settings.MEDIA_ROOT + "/" + cred_file)
return json_str, all_objects_dict["image_data"]
def on_event(self, event, payload):
if event == "plugin_backup_backup_created" and self._settings.get_boolean(
["cert_authorized"]):
self._logger.info(
"{} created, will now attempt to upload to Google Drive".
format(payload["path"]))
from pydrive2.drive import GoogleDrive
from pydrive2.auth import GoogleAuth
credentials_file = "{}/credentials.json".format(
self.get_plugin_data_folder())
gauth = GoogleAuth()
gauth.LoadCredentialsFile(credentials_file)
if gauth.credentials is None:
self._logger.error("not authorized")
self._settings.set(["cert_authorized"], False)
self._settings.save()
return
elif gauth.access_token_expired:
gauth.Refresh()
else:
gauth.Authorize()
gauth.SaveCredentialsFile(credentials_file)
drive = GoogleDrive(gauth)
f = drive.CreateFile({'title': payload["name"]})
f.SetContentFile(payload["path"])
f.Upload()
f = None
def getDrive(drive=None, gauth=None):
if not drive:
if not gauth:
gauth = GoogleAuth(settings_file=SETTINGS_YAML)
# Try to load saved client credentials
gauth.LoadCredentialsFile(CREDENTIALS)
if gauth.access_token_expired:
# Refresh them if expired
try:
gauth.Refresh()
except RefreshError as e:
log.error("Google Drive error: {}".format(e))
except Exception as ex:
log.error_or_exception(ex)
else:
# Initialize the saved creds
gauth.Authorize()
# Save the current credentials to a file
return GoogleDrive(gauth)
if drive.auth.access_token_expired:
try:
drive.auth.Refresh()
except RefreshError as e:
log.error("Google Drive error: {}".format(e))
return drive
async def gdrive_upload(filename: str, filebuf: BytesIO = None) -> str:
"""
Upload files to Google Drive using PyDrive2
"""
# a workaround for disabling cache errors
# https://github.com/googleapis/google-api-python-client/issues/299
logging.getLogger('googleapiclient.discovery_cache').setLevel(
logging.CRITICAL)
# Authenticate Google Drive automatically
# https://stackoverflow.com/a/24542604
gauth = GoogleAuth()
# Try to load saved client credentials
gauth.LoadCredentialsFile("secret.json")
if gauth.credentials is None:
return "nosecret"
if gauth.access_token_expired:
gauth.Refresh()
else:
# Initialize the saved credentials
gauth.Authorize()
# Save the current credentials to a file
gauth.SaveCredentialsFile("secret.json")
drive = GoogleDrive(gauth)
if filename.count('/') > 1:
filename = filename.split('/')[-1]
filedata = {
'title': filename,
"parents": [{
"kind": "drive#fileLink",
"id": GDRIVE_FOLDER
}]
}
if filebuf:
mime_type = mimetypes.guess_type(filename)
if mime_type[0] and mime_type[1]:
filedata['mimeType'] = f"{mime_type[0]}/{mime_type[1]}"
else:
filedata['mimeType'] = 'text/plain'
file = drive.CreateFile(filedata)
file.content = filebuf
else:
file = drive.CreateFile(filedata)
file.SetContentFile(filename)
name = filename.split('/')[-1]
file.Upload()
# insert new permission
file.InsertPermission({
'type': 'anyone',
'value': 'anyone',
'role': 'reader'
})
if not filebuf:
os.remove(filename)
reply = f"[{name}]({file['alternateLink']})\n" \
f"__Direct link:__ [Here]({file['downloadUrl']})"
return reply
def access():
gauth = GoogleAuth()
gauth.LoadCredentialsFile("credentials.json") # load credentials
if gauth.credentials is None: # if failed, get them
gauth.LocalWebserverAuth()
elif gauth.access_token_expired: # or if expired, refresh
gauth.Refresh()
else:
gauth.Authorize() # good
gauth.SaveCredentialsFile("credentials.json") # save
return GoogleDrive(gauth)
def __init__(self):
gauth = GoogleAuth()
gauth.LoadCredentialsFile("google_credentials.txt")
if gauth.credentials is None:
gauth.LocalWebserverAuth()
elif gauth.access_token_expired:
gauth.Refresh()
else:
gauth.Authorize()
gauth.SaveCredentialsFile("google_credentials.txt")
self.drive = GoogleDrive(gauth)
def __init__(self):
##vars to use later
self.lastScheduleUpdateTime = datetime.datetime.min
self.scheduleData = []
##load important stuff
self.root = LOAD_ENV_VARS.ENV_VARS['root']
self.access_token = LOAD_ENV_VARS.ENV_VARS['gd_access_token']
self.client_secret = LOAD_ENV_VARS.ENV_VARS['gd_client_secret']
self.client_id = LOAD_ENV_VARS.ENV_VARS['gd_client_id']
self.refresh_token = LOAD_ENV_VARS.ENV_VARS['gd_refresh_token']
self.token_expiry = LOAD_ENV_VARS.ENV_VARS['gd_token_expiry']
if True:
##make client creds
Text = """{"access_token": %s, "client_id": %s, "client_secret": %s, "refresh_token": %s, "token_expiry": %s, "token_uri": "https://oauth2.googleapis.com/token", "user_agent": null, "revoke_uri": "https://oauth2.googleapis.com/revoke", "id_token": null, "id_token_jwt": null, "token_response": {"access_token": %s, "expires_in": 3600, "refresh_token": %s, "scope": "https://www.googleapis.com/auth/drive", "token_type": "Bearer"}, "scopes": ["https://www.googleapis.com/auth/drive"], "token_info_uri": "https://oauth2.googleapis.com/tokeninfo", "invalid": false, "_class": "OAuth2Credentials", "_module": "oauth2client.client"}""" % (
self.access_token, self.client_id, self.client_secret,
self.refresh_token, self.token_expiry, self.access_token,
self.refresh_token)
f = open("mycreds.txt", "w+")
f.write(Text)
f.close()
##make client secrets from enviromental variables
Text = '''{"installed":{"client_id":%s,"project_id":"quickstart-1564436220867","auth_uri":"https://accounts.google.com/o/oauth2/auth","token_uri":"https://oauth2.googleapis.com/token","auth_provider_x509_cert_url":"https://www.googleapis.com/oauth2/v1/certs","client_secret":%s,"redirect_uris":["urn:ietf:wg:oauth:2.0:oob","http://localhost"]}}''' % (
self.client_id, self.client_secret)
f = open("client_secrets.json", "w+")
f.write(Text)
f.close()
else:
self.root = 'Python Bot Test'
# Try to load saved client credentials
gauth = GoogleAuth()
gauth.LoadCredentialsFile("mycreds.txt")
if gauth.credentials is None:
# Authenticate if they're not there
gauth.LocalWebserverAuth()
elif gauth.access_token_expired:
# Refresh them if expired
gauth.Refresh()
else:
# Initialize the saved creds
gauth.Authorize()
# Save the current credentials to a file
gauth.SaveCredentialsFile("mycreds.txt")
self.UpdateEnvVars()
#initialize drive object
self.drive = GoogleDrive(gauth)
##Setup sechdule
self.loadSchedule()
def login():
GoogleAuth.DEFAULT_SETTINGS['client_config_file'] = credencials_directory
gauth = GoogleAuth()
gauth.LoadCredentialsFile(credencials_directory)
if gauth.credentials is None:
gauth.LocalWebserverAuth(port_numbers=[8092])
elif gauth.access_token_expired:
gauth.Refresh()
else:
gauth.Authorize()
gauth.SaveCredentialsFile(credencials_directory)
credentials = GoogleDrive(gauth)
return credentials
def main():
gauth = GoogleAuth()
# Try to load saved client credentials
gauth.LoadCredentialsFile("secret.json")
if gauth.credentials is None:
# Authenticate if they're not there
gauth.LocalWebserverAuth()
elif gauth.access_token_expired:
# Refresh them if expired
gauth.Refresh()
else:
# Initialize the saved credentials
gauth.Authorize()
# Save the current credentials to a file
gauth.SaveCredentialsFile("secret.json")
def Upload_To_GDrive():
global File_Name
gauth = GoogleAuth()
gauth.LoadCredentialsFile("mycreds.txt")
if gauth.credentials is None:
gauth.GetFlow()
gauth.flow.params.update({'access_type': 'offline'})
gauth.flow.params.update({'approval_prompt': 'force'})
gauth.LocalWebserverAuth()
elif gauth.access_token_expired:
try:
gauth.Refresh()
except Exception as e:
print(e)
else:
gauth.Authorize()
gauth.SaveCredentialsFile("mycreds.txt")
drive = GoogleDrive(gauth)
folder_id = [
'Folder_String_A', 'Folder_String_B', 'Folder_String_C',
'Folder_String_D'
]
for k in range(len(File_Name)):
try:
f = drive.CreateFile({
'title':
f'{File_Name[k]}.csv',
"parents": [{
"kind": "drive#fileLink",
"id": folder_id[k]
}]
})
f.SetContentFile(f'./Data/{File_Name[k]}.csv')
f.Upload()
print("Uploading succeeded!")
except:
print("Uploading failed.")
print(time.ctime())
def __authenticate(self):
credentials_full_path = os.path.join(self._credentials_path,
'credentials.json')
token = os.path.join(self._credentials_path, 'credentials')
gauth = GoogleAuth()
gauth.LoadClientConfigFile(credentials_full_path)
if os.path.exists(token):
gauth.LoadCredentialsFile(token)
cred = gauth.credentials
if not cred or cred.invalid:
if cred and cred.access_token_expired and cred.refresh_token:
gauth.Refresh()
else:
gauth.LocalWebserverAuth()
gauth.SaveCredentialsFile(token)
return gauth
def google_drive_connect(id, path, auto_auth=True):
'''
Method for connecting to the subject's Google Drive
'''
# Initialize Google Auth object
try:
gauth = GoogleAuth(settings_file=path + '/Subjects/' + id +
'/pydrive.yaml')
local_set = True
except:
gauth = GoogleAuth()
local_set = False
# String to the credentials file
credPath = path + '/Subjects/' + id + "/mycreds.txt"
# Try to load saved client credentials
gauth.LoadCredentialsFile(credPath)
# If this credential does not exist
if gauth.credentials is None:
# Authenticate if they're not there
raise Exception(
"Error: the credentials for this subject do not exist.")
elif gauth.access_token_expired:
# Refresh them if expired
print("Note: This subject's credentials are being renewed.")
# try to refresh the access token
try:
gauth.Refresh()
# may fail if the refresh token does not exist
except:
#gauth.LocalWebserverAuth()
#gauth.Authenticate()
print("ERROR: Authorization refresh failed!")
return None
#print("Gauth:")
#print(gauth)
# Save the current credentials to the file
#gauth.SaveCredentialsFile(credPath)
# Initialize the Google Drive Connection
drive = GoogleDrive(gauth)
#print("Drive Object:")
#print(drive)
# Return the Google Drive object
return drive
def initial_gdrive():
'''
Authorize and refresh Google Drive token.
Reference: https://stackoverflow.com/a/24542604/10114014
'''
gauth = GoogleAuth()
# Try to load saved client credentials
gauth.LoadCredentialsFile("mycreds.txt")
if gauth.credentials is None:
# Authenticate if they're not there
gauth.LocalWebserverAuth()
elif gauth.access_token_expired:
# Refresh them if expired
gauth.Refresh()
else:
# Initialize the saved creds
gauth.Authorize()
# Save the current credentials to a file
gauth.SaveCredentialsFile("mycreds.txt")
return GoogleDriveWithBytes(gauth)
def upload_via_celery_home(self, name, file_name, cred_file):
self.update_state(state='PROGRESS')
cred_name = str(timezone.now())
cred_name = re.sub('[\W_]+', '', "file_{}".format(cred_name)) + ".txt"
with open(settings.MEDIA_ROOT + "/uploaded/" + cred_name + ".txt",
"w") as file:
file.write(cred_file)
file.close()
gauth = GoogleAuth()
gauth.LoadCredentialsFile(settings.MEDIA_ROOT + "/uploaded/" + cred_name +
".txt")
# all_objects_dict = {"web_address":[],"original_text":[],"translated_text":[],"name":[],"hyperlink":[],"img":[],"link_to_image":[],"drive_link":[]}
all_objects_dict = scrap_the_file(name, gauth, self)
dataframe = pd.DataFrame(all_objects_dict)
dataframe.columns = [
"Page", "description", "Translated Text", "Name", "hyperlink", "img",
"link_to_image", "drive_link", "image_data"
]
# dict = dataframe.to_csv(settings.MEDIA_ROOT+"/"+file_name+".csv")
dict = dataframe.to_dict()
json_str = json.dumps(dict)
df = dataframe.drop(columns=["image_data", "link_to_image"], axis=1)
csv_name = re.sub(r'[\W_]+', "", str(timezone.now()))
df.to_csv("csv_{}.csv".format(csv_name))
drive = GoogleDrive(gauth)
file = drive.CreateFile()
file.SetContentFile("csv_{}.csv".format(csv_name))
file["title"] = file_name
file.Upload()
if os.path.exists("csv_{}.csv".format(csv_name)):
try:
os.remove("csv_{}.csv".format(csv_name))
except:
pass
return json_str, file.metadata["embedLink"]
from pydrive2.auth import GoogleAuth
if __name__ == "__main__":
try:
gauth = GoogleAuth()
gauth.LoadCredentialsFile("credentials.json")
if self.gauth.credentials is None:
gauth.LocalWebserverAuth()
gauth.SaveCredentialsFile("credentials.json")
print("Credentials.json has been created")
else:
print("A valid credentials.json already exists")
except:
print("\nPlease make sure to run this file close to settings.yaml")
import os
import requests
import shutil
from pydrive2.auth import GoogleAuth
from pydrive2.drive import GoogleDrive
import discord
from discord.ext import commands
import tension
from helpy import hell
gauth = GoogleAuth()
gauth.LoadCredentialsFile("auth.json")
if gauth.access_token_expired:
gauth.Refresh()
else:
gauth.Authorize()
drive = GoogleDrive(gauth)
class Cloudshit(commands.Cog, name='Cloud Transfers'):
def __init__(self, bot):
self.bot = bot
@commands.command(aliases=['u', 'up'], help=hell['upload'])
async def upload(self, ctx, title=None):
try:
attachment = ctx.message.attachments[0]
fileurl = attachment.url
if fileurl.find('/'):
name = fileurl.rsplit('/', 1)[1]
class Pinguin(QMainWindow):
login_signal = pyqtSignal()
def __init__(self):
super().__init__()
self.db = PinguinDB()
self.trello = Trello()
self.auth = None
self.google_client = GoogleClient()
self.login_signal.connect(self.login_success)
self.login_menu = Login_Window(self.login_signal, self.db, self.trello)
self.main_window = Main_Menu(self.db, self.trello, self.google_client)
#self.mutex = QMutex()
@pyqtSlot()
def login_success(self):
self.main_window.show()
self.login_menu.close()
if self.trello.client == None:
print("setting up trello client")
print(self.db.user.user_id)
self.trello.action_setup2(self.db.user.user_id)
print("trello client all set")
print("setting up google auth")
#print(self.main_window.ui.google_client)
self.auth = GoogleAuth()
#print(auth)
# Try to load saved client credentials
self.auth.LoadCredentialsFile("Credentials.json")
if self.auth.credentials is None:
print("no creds")
# Authenticate if they're not there
self.auth.LocalWebserverAuth()
elif self.auth.access_token_expired:
print("creds expired")
# Refresh them if expired
self.auth.LocalWebserverAuth()
#self.auth.Refresh()
print("creds renewed")
else:
print("new creds")
# Initialize the saved creds
self.auth.Authorize()
# Save the current credentials to a file
#self.auth.SaveCredentialsFile("Credentials.json")
print("authorization complete")
self.google_client.set_client(self.auth)
self.main_window.ui.google_client = self.google_client
#print(self.main_window.ui.google_client)
#self.main_window.ui.set_google_client(GoogleClient(self.auth))
#self.main_window.show()
print("heresdasd")
self.main_window.ui.widgets_refresh()
self.main_window.ui.widgets_timer.start(30000)
def run(self):
self.login_menu.show()
class Drive(object):
def __init__(self):
self.logger = logging.getLogger(__name__)
self.login()
def login(self):
self.gauth = GoogleAuth()
self.gauth.LoadCredentialsFile("mycreds.txt")
self.logger.debug("Loading credentials")
if self.gauth.credentials is None:
self.logger.debug("First authentication")
# Authenticate if they're not there
self.gauth.LocalWebserverAuth()
elif self.gauth.access_token_expired:
self.logger.debug("Token has expired, refreshing")
# Refresh them if expired
self.gauth.Refresh()
else:
self.logger.debug("Connected")
# Initialize the saved creds
self.gauth.Authorize()
# Save the current credentials to a file
self.gauth.SaveCredentialsFile("mycreds.txt")
# Create GoogleDrive instance with authenticated GoogleAuth instance
self.drive = GoogleDrive(self.gauth)
def find_folders(self, folder_name):
file_list = self.drive.ListFile({
"q":
"title='{}' and mimeType contains 'application/vnd.google-apps.folder' and trashed=false"
.format(folder_name)
}).GetList()
return file_list
def create_subfolder(self, folder, sub_folder_name):
new_folder = self.drive.CreateFile({
"title":
"{}".format(sub_folder_name),
"mimeType":
"application/vnd.google-apps.folder",
})
if folder is not None:
new_folder["parents"] = [{u"id": folder["id"]}]
new_folder.Upload()
self.logger.debug("Folder created {}/{}".format(
folder, sub_folder_name))
return new_folder
def upload_files_to_folder(self, fnames, folder):
for fname in fnames:
nfile = self.drive.CreateFile({
"title": os.path.basename(fname),
"parents": [{
u"id": folder["id"]
}]
})
nfile.SetContentFile(fname)
nfile.Upload()
def CheckCredentialsFile(self, credentials, no_file=False):
ga = GoogleAuth(settings_file_path("test_oauth_default.yaml"))
ga.LoadCredentialsFile(credentials)
self.assertEqual(ga.access_token_expired, no_file)
def __init__(self, parsed_url):
duplicity.backend.Backend.__init__(self, parsed_url)
try:
import httplib2
from apiclient.discovery import build
except ImportError as e:
raise BackendException(u"""\
PyDrive backend requires PyDrive and Google API client installation.
Please read the manpage for setup details.
Exception: %s""" % str(e))
# Shared Drive ID specified as a query parameter in the backend URL.
# Example: pydrive://developer.gserviceaccount.com/target-folder/?driveID=<SHARED DRIVE ID>
self.api_params = {}
self.shared_drive_id = None
if u'driveID' in parsed_url.query_args:
self.shared_drive_id = parsed_url.query_args[u'driveID'][0]
self.api_params = {
u'corpora': u'teamDrive',
u'teamDriveId': self.shared_drive_id,
u'includeTeamDriveItems': True,
u'supportsTeamDrives': True
}
try:
from pydrive2.auth import GoogleAuth
from pydrive2.drive import GoogleDrive
from pydrive2.files import ApiRequestError, FileNotUploadedError
except ImportError as e:
try:
from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
from pydrive.files import ApiRequestError, FileNotUploadedError
except ImportError as e:
raise BackendException(u"""\
PyDrive backend requires PyDrive installation. Please read the manpage for setup details.
Exception: %s""" % str(e))
# let user get by with old client while he can
try:
from oauth2client.client import SignedJwtAssertionCredentials
self.oldClient = True
except:
from oauth2client.service_account import ServiceAccountCredentials
from oauth2client import crypt
self.oldClient = False
if u'GOOGLE_DRIVE_ACCOUNT_KEY' in os.environ:
account_key = os.environ[u'GOOGLE_DRIVE_ACCOUNT_KEY']
if self.oldClient:
credentials = SignedJwtAssertionCredentials(
parsed_url.username + u'@' + parsed_url.hostname,
account_key,
scopes=u'https://www.googleapis.com/auth/drive')
else:
signer = crypt.Signer.from_string(account_key)
credentials = ServiceAccountCredentials(
parsed_url.username + u'@' + parsed_url.hostname,
signer,
scopes=u'https://www.googleapis.com/auth/drive')
credentials.authorize(httplib2.Http())
gauth = GoogleAuth(http_timeout=60)
gauth.credentials = credentials
elif u'GOOGLE_DRIVE_SETTINGS' in os.environ:
gauth = GoogleAuth(
settings_file=os.environ[u'GOOGLE_DRIVE_SETTINGS'],
http_timeout=60)
gauth.CommandLineAuth()
elif (u'GOOGLE_SECRETS_FILE' in os.environ
and u'GOOGLE_CREDENTIALS_FILE' in os.environ):
gauth = GoogleAuth(http_timeout=60)
gauth.LoadClientConfigFile(os.environ[u'GOOGLE_SECRETS_FILE'])
gauth.LoadCredentialsFile(os.environ[u'GOOGLE_CREDENTIALS_FILE'])
if gauth.credentials is None:
gauth.CommandLineAuth()
elif gauth.access_token_expired:
gauth.Refresh()
else:
gauth.Authorize()
gauth.SaveCredentialsFile(os.environ[u'GOOGLE_CREDENTIALS_FILE'])
else:
raise BackendException(
u'GOOGLE_DRIVE_ACCOUNT_KEY or GOOGLE_DRIVE_SETTINGS environment '
u'variable not set. Please read the manpage to fix.')
self.drive = GoogleDrive(gauth)
if self.shared_drive_id:
parent_folder_id = self.shared_drive_id
else:
# Dirty way to find root folder id
file_list = self.drive.ListFile({
u'q':
u"'Root' in parents and trashed=false"
}).GetList()
if file_list:
parent_folder_id = file_list[0][u'parents'][0][u'id']
else:
file_in_root = self.drive.CreateFile(
{u'title': u'i_am_in_root'})
file_in_root.Upload()
parent_folder_id = file_in_root[u'parents'][0][u'id']
file_in_root.Delete()
# Fetch destination folder entry and create hierarchy if required.
folder_names = parsed_url.path.split(u'/')
for folder_name in folder_names:
if not folder_name:
continue
list_file_args = {
u'q':
u"'" + parent_folder_id + u"' in parents and trashed=false"
}
list_file_args.update(self.api_params)
file_list = self.drive.ListFile(list_file_args).GetList()
folder = next(
(item
for item in file_list if item[u'title'] == folder_name and
item[u'mimeType'] == u'application/vnd.google-apps.folder'),
None)
if folder is None:
create_file_args = {
u'title': folder_name,
u'mimeType': u"application/vnd.google-apps.folder",
u'parents': [{
u'id': parent_folder_id
}]
}
create_file_args[u'parents'][0].update(self.api_params)
create_file_args.update(self.api_params)
folder = self.drive.CreateFile(create_file_args)
if self.shared_drive_id:
folder.Upload(param={u'supportsTeamDrives': True})
else:
folder.Upload()
parent_folder_id = folder[u'id']
self.folder = parent_folder_id
self.id_cache = {}
def CheckCredentialsFile(self, credentials, no_file=False):
ga = GoogleAuth('pydrive2/test/settings/test_oauth_default.yaml')
ga.LoadCredentialsFile(credentials)
self.assertEqual(ga.access_token_expired, no_file)
from pydrive2.auth import GoogleAuth #potrebna knjiđnica PyDrive2, ki se jo dobi z pip install pydrive2
from pydrive2.drive import GoogleDrive
gauth = GoogleAuth() #Potrebno je imeti na kompu ali client_secrets.json ali pa mycreds.txt, ki ne pridejo s knjižnco zraven
# Try to load saved client credentials
gauth.LoadCredentialsFile("mycreds.txt")
if gauth.credentials is None:
# Authenticate if they're not there
gauth.LocalWebserverAuth()
elif gauth.access_token_expired:
# Refresh them if expired
gauth.Refresh()
else:
# Initialize the saved creds
gauth.Authorize()
# Save the current credentials to a file
gauth.SaveCredentialsFile("mycreds.txt")
drive = GoogleDrive(gauth)
##FUNKCIJE
def delete_file(file_id):
file1 = drive.CreateFile({'parents': [{'id': '1eeA-y9DjF4zOuH4z5wkOB5nSehRtGneV'}],'id': file_id})
file1.Delete()
def create_file(name,content):
file1 = drive.CreateFile({'title': name,'parents': [{'id': '1eeA-y9DjF4zOuH4z5wkOB5nSehRtGneV'}]}) # Create GoogleDriveFile instance with title 'Hello.txt'.
file1.SetContentString(content,encoding="utf-8")
file1.Upload()
print("File was created under the id %s" %(file1['id']))
return file1
#======Global stuffs========
scopes = ['https://www.googleapis.com/auth/drive.metadata.readonly',
'https://www.googleapis.com/auth/drive.file',
'https://www.googleapis.com/auth/youtube.force-ssl']
url = ['https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable']
id ='*****@*****.**'
key = base64.b64decode(open("configs\private_key.json", "r").read())
live_3d = False
# creds = Credentials.from_json_keyfile_name('client_secrets.json', scopes)
# service = build('drive', 'v2', credentials=creds)
g_login = GoogleAuth()
#g_login.creds = creds
g_login.LoadCredentialsFile('configs\mycreds.txt')
if g_login.credentials is None:
g_login.LocalWebserverAuth()
elif g_login.access_token_expired:
g_login.Refresh()
else:
g_login.Authorize()
g_login.SaveCredentialsFile('configs\mycreds.txt')
drive = GoogleDrive(g_login)
folder_id = '1eAnQD9mV0xhqaMVoeSGA06NrU1R6ik7Y'
#====polling loop for youtube; update manually for now.====
def poll_loop(channel_id):
# Disable OAuthlib's HTTPS verification when running locally.
