def get_auth(settings_file="settings.yaml", webauth=False):
gauth = GoogleAuth(settings_file=settings_file)
if webauth:
gauth.LocalWebserverAuth()
else:
gauth.CommandLineAuth()
return gauth
def authenticate_and_authorize(options, settings_file=None, method="local"):
gauth = GoogleAuth(settings_file=settings_file)
gauth.LoadCredentials()
if gauth.credentials is not None:
raise RuntimeError(
"Error: credentials found at %s and it's already authenticated; skipping..."
% gauth.settings.get("save_credentials_file"))
if method == "local":
gauth.LocalWebserverAuth(host_name=options.hostname,
port_numbers=options.ports)
elif method == "command_line":
gauth.CommandLineAuth()
else:
raise ValueError(
"Error: received --method=%s, but --method can only be either 'local' or 'command_line'."
% method)
if gauth:
print()
print("Finished authentication and authorizion.")
print(
"Please configure google drive client with gdrive-config if you have not done so yet."
)
print("Then, use gdrive -h for more information.")
return gauth
def main(argv):
root_directory = os.getcwd()
parent_id = ''
try:
opts, args = getopt.getopt(argv, 'i:d:h', ["directory="])
except getopt.GetoptError as err:
print(err)
usage()
sys.exit(2)
for o, a in opts:
if o == "-i":
parent_id = a
elif o == "-d":
root_directory = a
elif o == "-h":
usage()
else:
assert False, "unhandled option"
if parent_id is not '':
gauth = GoogleAuth()
gauth.LocalWebserverAuth()
drive = GoogleDrive(gauth)
if not os.path.exists(root_directory):
os.makedirs(root_directory)
tree = listFolder(parent_id, drive)
downloadAndStore(tree, root_directory)
def __init__(self, local_repo_path, model_id):
self.repo_path = local_repo_path
self.model_id = model_id
GoogleAuth = set_secrets_file()
gauth = GoogleAuth()
gauth.LocalWebserverAuth()
self.drive = GoogleDrive(gauth)
def drive_login() -> GoogleAuth:
cwd = change_dir(
) # temp solution until we know what will be the working directory
gauth = GoogleAuth()
gauth.LocalWebserverAuth()
os.chdir(cwd)
return gauth
def test_01_LocalWebserverAuthWithClientConfigFromFile(self):
# Delete old credentials file
delete_file("credentials/1.dat")
# Test if authentication works with config read from file
ga = GoogleAuth(settings_file_path("test_oauth_test_01.yaml"))
ga.LocalWebserverAuth()
self.assertEqual(ga.access_token_expired, False)
# Test if correct credentials file is created
self.CheckCredentialsFile("credentials/1.dat")
time.sleep(1)
def test_02_LocalWebserverAuthWithClientConfigFromSettings(self):
# Delete old credentials file
delete_file('credentials/2.dat')
# Test if authentication works with config read from settings
ga = GoogleAuth('pydrive2/test/settings/test_oauth_test_02.yaml')
ga.LocalWebserverAuth()
self.assertEqual(ga.access_token_expired, False)
# Test if correct credentials file is created
self.CheckCredentialsFile('credentials/2.dat')
time.sleep(1)
def test_03_LocalWebServerAuthWithNoCredentialsSaving(self):
# Delete old credentials file
delete_file('credentials/4.dat')
# Provide wrong credentials file
ga = GoogleAuth('pydrive2/test/settings/test_oauth_test_03.yaml')
ga.LocalWebserverAuth()
self.assertEqual(ga.access_token_expired, False)
# Test if correct credentials file is created
self.CheckCredentialsFile('credentials/4.dat', no_file=True)
time.sleep(1)
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 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):
##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 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 __init__(self, destination_root_directory=DEFAULT_DESTINATION_ROOT):
"""
Initialize logging and Google Drive authentication.
"""
# Enable logging
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
self.logger = logging.getLogger(__name__)
# self.destination_root_directory = destination_root_directory
self.destination_root_directory = self.DEFAULT_DESTINATION_ROOT
# TODO make directory name configurable
# this will require a parsing of the directory path
# all concerned subfolders will have to be looked up recursively in the file_exists function
gauth = GoogleAuth()
gauth.LocalWebserverAuth()
self.drive = GoogleDrive(gauth)
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 test_05_ConfigFromSettingsWithoutOauthScope(self):
# Test if authentication works without oauth_scope
ga = GoogleAuth('pydrive2/test/settings/test_oauth_test_05.yaml')
ga.LocalWebserverAuth()
self.assertEqual(ga.access_token_expired, False)
time.sleep(1)
# /////////////////////////
# MAIN ////////////////////
# /////////////////////////
print("*******************************************************************************************")
print("running microprojectgallery.py with CWD: " + os.getcwd())
if downloadCSV:
# grab CSV from gdrive
# --------------------
# authenticate
gauth = GoogleAuth()
gauth.LocalWebserverAuth() # Creates local webserver and auto handles authentication.
drive = GoogleDrive(gauth)
# Create GoogleDriveFile instance with file id of file1.
sheet = drive.CreateFile({'id': spreadsheetID})
print('title: %s, exportLink: %s' % (sheet['title'], sheet['exportLinks']['text/csv']))
# print(sheet.GetContentString())
downloadCSVURL = sheet['exportLinks']['text/csv']
r = requests.get(downloadCSVURL, allow_redirects=True)
open(savedSheetName, 'wb').write(r.content)
imageTest = drive.CreateFile({'id': "1hAcgM_VgLbkZgloqu0iC5V2-nVTyWe2J"})
# load dataframe
df = pd.read_csv(savedSheetName)
from pydrive2.auth import GoogleAuth from pydrive2.drive import GoogleDrive gauth = GoogleAuth() gauth.LocalWebserverAuth( ) # client_secrets.json need to be in the same directory as the script drive = GoogleDrive(gauth)
def Press_Authenticate(self, instance):
gauth = GoogleAuth()
gauth.LocalWebserverAuth()
GDrive = GoogleDrive(gauth) # Google Drive Class Object
return
def authenticate():
gauth = GoogleAuth(settings_file="maintenance/settings.yaml")
gauth.LocalWebserverAuth()
return GoogleDrive(gauth)
class GDriveServerNode(object):
folder_mime_type = 'application/vnd.google-apps.folder'
folder_url_format = 'https://drive.google.com/drive/folders/{}'
file_url_format = 'https://drive.google.com/uc?id={}'
def __init__(self):
settings_yaml = rospy.get_param('~settings_yaml', None)
self.share_type = rospy.get_param('~share_type', 'anyone')
self.share_value = rospy.get_param('~share_value', 'anyone')
self.share_role = rospy.get_param('~share_role', 'reader')
self.share_with_link = rospy.get_param('~share_with_link', True)
auth_max_trial = rospy.get_param('~auth_max_trial', -1)
auth_wait_seconds = rospy.get_param('~auth_wait_seconds', 10.0)
if settings_yaml is not None:
self.gauth = GoogleAuth(settings_yaml)
else:
rospy.logerr('param: ~settings_yaml is not correctly set.')
sys.exit(1)
rospy.loginfo('Google drive authentication starts.')
auth_success = False
auth_count = 0
while (not auth_success
and (auth_max_trial < 0 or auth_count < auth_max_trial)):
try:
self.gauth.LocalWebserverAuth()
auth_success = True
except ServerNotFoundError as e:
rospy.logerr('Authentication failed: {}'.format(e))
auth_count = auth_count + 1
time.sleep(auth_wait_seconds)
if not auth_success:
rospy.logerr(
'Authentication failed {} times.'.format(auth_max_trial))
sys.exit(1)
self.gdrive = GoogleDrive(self.gauth)
rospy.loginfo('Google drive authentication finished.')
self.upload_server = rospy.Service('~upload', Upload, self._upload_cb)
self.upload_multi_server = rospy.Service('~upload_multi',
MultipleUpload,
self._upload_multi_cb)
rospy.loginfo('Finish initialization, Server started.')
def _upload_cb(self, req):
timestamp = '{0:%Y%m%d%H%M%S}'.format(datetime.datetime.now())
parents_path = req.parents_path
parents_id = req.parents_id
# response initialization
res = UploadResponse()
res.success = False
res.file_id = ''
res.file_url = ''
if parents_id and parents_path:
rospy.logerr('parents_path and parents_id is both set.')
rospy.logerr(
'parents_id: {} is selected to upload.'.format(parents_id))
parents_path = ''
if parents_path:
try:
parents_id = self._get_parents_id(parents_path, mkdir=True)
except (ValueError, ApiRequestError, ServerNotFoundError) as e:
rospy.logerr(e)
rospy.logerr(
'Failed to get parents_id: {}'.format(parents_path))
return res
# root
elif parents_id == '' and parents_path == '':
parents_id = ''
if req.use_timestamp_folder:
try:
parents_id = self._get_parents_id([timestamp],
parents_id=parents_id,
mkdir=True)
except (ValueError, ApiRequestError, ServerNotFoundError) as e:
rospy.logerr(e)
rospy.logerr('Failed to get parents_id: {} in {}'.format(
timestamp, self.folder_url_format.format(parents_id)))
return res
success, file_id, file_url = self._upload_step(
req.file_path, req.file_title, parents_id,
req.use_timestamp_file_title, timestamp)
res.success = success
res.file_id = file_id
res.file_url = file_url
res.parents_id = parents_id
res.parents_url = self.folder_url_format.format(parents_id)
return res
def _upload_multi_cb(self, req):
timestamp = '{0:%Y%m%d%H%M%S}'.format(datetime.datetime.now())
parents_path = req.parents_path
parents_id = req.parents_id
# response initialization
res = MultipleUploadResponse()
res.successes = [False] * len(req.file_titles)
res.file_ids = [''] * len(req.file_titles)
res.file_urls = [''] * len(req.file_titles)
if parents_id and parents_path:
rospy.logerr('parents_path and parents_id is both set.')
rospy.logerr(
'parents_id: {} is selected to upload.'.format(parents_id))
parents_path = ''
if parents_path:
try:
parents_id = self._get_parents_id(parents_path, mkdir=True)
except (ValueError, ApiRequestError, ServerNotFoundError) as e:
rospy.logerr(e)
rospy.logerr(
'Failed to get parents_id: {}'.format(parents_path))
return res
# root
elif parents_id == '' and parents_path == '':
parents_id = ''
if req.use_timestamp_folder:
try:
parents_id = self._get_parents_id([timestamp],
parents_id=parents_id,
mkdir=True)
except (ValueError, ApiRequestError, ServerNotFoundError) as e:
rospy.logerr(e)
rospy.logerr('Failed to get parents_id: {} in {}'.format(
timestamp, self.folder_url_format.format(parents_id)))
return res
for i, (file_path,
file_title) in enumerate(zip(req.file_paths, req.file_titles)):
success, file_id, file_url = self._upload_step(
file_path, file_title, parents_id,
req.use_timestamp_file_title, timestamp)
res.successes[i] = success
res.file_ids[i] = file_id
res.file_urls[i] = file_url
res.parents_id = parents_id
res.parents_url = self.folder_url_format.format(parents_id)
return res
def _upload_step(self,
file_path,
file_title,
parents_id,
use_timestamp_file_title=False,
timestamp=None):
file_title = file_title if file_title else file_path.split('/')[-1]
file_path = os.path.expanduser(file_path)
if use_timestamp_file_title:
file_title = '{}_{}'.format(timestamp, file_title)
success = False
file_id = ''
file_url = ''
folder_url = self.folder_url_format.format(parents_id)
try:
file_id = self._upload_file(file_path,
file_title,
parents_id=parents_id)
file_url = self.file_url_format.format(file_id)
success = True
rospy.loginfo('Success to upload: {} -> {}'.format(
file_path, file_url))
except (OSError, ApiRequestError, ServerNotFoundError) as e:
rospy.logerr(e)
rospy.logerr('Failed to upload: {} -> {}'.format(
file_path, folder_url))
return success, file_id, file_url
def _upload_file(self, file_path, file_title, parents_id=None):
if not os.path.exists(file_path):
raise OSError('File not found: {}'.format(file_path))
rospy.loginfo('Start uploading a file: {}'.format(file_title))
if parents_id:
gfile = self.gdrive.CreateFile({'parents': [{'id': parents_id}]})
else:
gfile = self.gdrive.CreateFile()
gfile.SetContentFile(file_path)
gfile['title'] = file_title
gfile.Upload()
gfile.InsertPermission({
'type': self.share_type,
'value': self.share_value,
'role': self.share_role,
'withLink': self.share_with_link,
})
rospy.loginfo('Finish uploading a file: {}'.format(file_title))
return gfile['id']
def _upload_folder(self, folder_title, parents_id=None):
rospy.loginfo('Start making a folder: {}'.format(folder_title))
if parents_id:
gfolder = self.gdrive.CreateFile({
'title':
folder_title,
'parents': [{
'id': parents_id
}],
'mimeType':
'application/vnd.google-apps.folder'
})
else:
gfolder = self.gdrive.CreateFile({
'title':
folder_title,
'mimeType':
'application/vnd.google-apps.folder'
})
gfolder.Upload()
rospy.loginfo('Finish making a folder: {}'.format(folder_title))
return gfolder['id']
def _get_parents_id(self, parents_path, parents_id=None, mkdir=False):
if parents_path == '':
return None
if not isinstance(parents_path, list):
parents_path = [p for p in parents_path.split('/') if p != '']
folder_title = parents_path[0]
parent = parents_id if parents_id else 'root'
gfiles = self.gdrive.ListFile(
{'q': "'{}' in parents and trashed=false".format(parent)})
gfiles = gfiles.GetList()
gfolders = []
for gf in gfiles:
if (gf['mimeType'] == self.folder_mime_type
and gf['title'] == folder_title):
gfolders.append(gf)
if len(parents_path) == 1:
if len(gfolders) > 0:
return gfolders[0]['id']
if mkdir:
folder_id = self._upload_folder(folder_title,
parents_id=parents_id)
return folder_id
else:
raise ValueError(
'Folder is not found: {}'.format(folder_title))
else:
if len(gfolders) > 0 or mkdir:
if len(gfolders) > 0:
next_parents_id = gfolders[0]['id']
elif mkdir:
next_parents_id = self._upload_folder(
folder_title, parents_id=parents_id)
folder_id = self._get_parents_id(parents_path[1:],
parents_id=next_parents_id,
mkdir=mkdir)
return folder_id
else:
raise ValueError('folder is not found: {}', folder_title)
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()
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
'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.
# *DO NOT* leave this option enabled in production.
os.environ["OAUTHLIB_INSECURE_TRANSPORT"] = "1"
