def download(self, filename, bucket_name, object_name):
with open(filename, 'wb') as f:
req = self.cloud.objects().get_media(
bucket=bucket_name, object=object_name)
downloader = MediaIoBaseDownload(f, req)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download {}%.".format(int(status.progress() * 100)))
def download_file(self, source_id, fname, verbose=True):
fpath = pathlib.Path(fname)
request = self.service.files().get_media(fileId=source_id)
with fpath.open('wb') as f:
downloader = MediaIoBaseDownload(f, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print(f'{int(status.progress())*100} downloaded')
def downloadTo(file_id, fileName):
request = service.files().get_media(fileId=file_id)
fh = io.FileIO(fileName, 'wb')
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download %d%%." % int(status.progress() * 100))
return done
def download_file(service, file_id):
request = service.files().get_media(fileId=file_id)
fh = io.BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print "Download %d%%." % int(status.progress() * 100)
open(FILE_NAME, 'wb').write(fh.getvalue())
def download_file(self, file_id, download_destination):
request = self.service.files().get_media(fileId=file_id)
with open(download_destination, "wb") as fh:
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print
"Download %d%%." % int(status.progress() * 100)
def download_photo(file_id):
request = drive_service.files().get_media(fileId=file_id)
fh = io.BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print ("Download %d%%." % int(status.progress() * 100))
return fh.getvalue()
def get_file_stream(service, file_id):
request = service.files().get_media(fileId=file_id)
fp = io.BytesIO()
downloader = MediaIoBaseDownload(fp, request, chunksize=CHUNKSIZE)
done = False
while done is False:
status, done = downloader.next_chunk()
fp.seek(0)
return fp
def download(drive_service, file_id):
#file_id = '0BwwA4oUTeiV1UVNwOHItT0xfa2M'
request = drive_service.files().get_media(fileId=file_id)
fh = io.BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download %d%%." % int(status.progress() * 100))
def initialize_upload(youtube,
file,
mimetype,
title,
description,
keywords=None,
category=22,
privacyStatus='private'):
tags = None
if keywords:
tags = keywords.split(",")
body = dict(snippet=dict(title=title,
description=description,
tags=tags,
categoryId=category),
status=dict(privacyStatus=privacyStatus))
fh = io.BytesIO()
writer = io.BufferedWriter(fh)
# try:
# os.mkfifo('my_fifo')
# except FileExistsError:
# pass
# fh = open('my_fifo', 'w', os.O_WRONLY|os.O_NONBLOCK)
downloader = MediaIoBaseDownload(writer, file, chunksize=1024 * 1024)
#o = os.open('my_fifo', os.O_RDONLY | os.O_NONBLOCK)
reader = io.BufferedReader(fh)
# Call the API's videos.insert method to create and upload the video.
insert_request = youtube.videos().insert(
part=",".join(body.keys()),
body=body,
# The chunksize parameter specifies the size of each chunk of data, in
# bytes, that will be uploaded at a time. Set a higher value for
# reliable connections as fewer chunks lead to faster uploads. Set a lower
# value for better recovery on less reliable connections.
#
# Setting "chunksize" equal to -1 in the code below means that the entire
# file will be uploaded in a single HTTP request. (If the upload fails,
# it will still be retried where it left off.) This is usually a best
# practice, but if you're using Python older than 2.6 or if you're
# running on App Engine, you should set the chunksize to something like
# 1024 * 1024 (1 megabyte).
media_body=MediaIoBaseUpload(reader,
chunksize=1024 * 1024,
resumable=True,
mimetype=mimetype))
if "id" in insert_request:
print("Video id", insert_request["id"])
else:
print("id not in insert_request")
resumable_upload(insert_request, downloader, writer)
def startdownload(_request):
downloader = MediaIoBaseDownload(fh, _request)
done = False
while not done:
status, done = downloader.next_chunk()
try:
msg.edit(user.getstr('drive_downloading_progress')
.format(p=int(status.progress() * 100)))
except botogram.api.APIError:
pass
def download_drive_file(service, file_id):
request = service.files().get_media(fileId=file_id)
file_path = file_id + '.tsv'
fh = io.FileIO(file_path, mode='w')
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download %d%%." % int(status.progress() * 100))
return file_path
def _read_json_id(service, file_id):
request = service.files().get_media(fileId=file_id)
with io.BytesIO() as fh:
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
fh.seek(0)
data = fh.read()
return json.loads(data, encoding=METADATA_ENCODING)
def download(self, service, dir, res, index):
downloader = MediaIoBaseDownload(
io.FileIO('output/{}/{}.txt'.format(dir, index + 1), 'wb'),
service.files().export_media(fileId=res['id'],
mimeType="text/plain"))
done = False
while done is False:
status, done = downloader.next_chunk()
service.files().delete(fileId=res['id']).execute()
def download_file(f):
fid = f.get('id')
name = f.get('name')
create_folder('invoices')
request = service.files().get_media(fileId=fid)
with io.FileIO(os.path.join('invoices', name), 'wb') as fh:
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
def export(drive_service, file_id, outtype):
#file_id = '1ZdR3L3qP4Bkq8noWLJHSr_iBau0DNT4Kli4SxNc2YEo'
request = drive_service.files().export_media(fileId=file_id,
mimeType=outtype)
fh = io.BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download %d%%." % int(status.progress() * 100))
def download(service, file_id):
request1 = service.files().get_media(fileId=file_id)
tmp_file = 'temp/temp_plano.pdf'
fh = io.FileIO(tmp_file, 'wb')
downloader = MediaIoBaseDownload(fh, request1)
done = False
while done is False:
status, done = downloader.next_chunk()
fh.close()
return tmp_file
def file(self, file_id):
request = self._service.files().get_media(fileId=file_id)
fh = BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
# print "Download %d%%." % int(status.progress() * 100)
return fh
def download(file_id):
config = Config()
drive_service = load_credentials(config)
request = drive_service.files().get_media(fileId=file_id)
fh = io.BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download %d%%." % int(status.progress() * 100))
def downloadFile(self, file_id, filePath):
request = self.drive_service.files().get_media(fileId=file_id)
fh = io.BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
with io.open(filePath, 'wb') as f:
fh.seek(0)
f.write(fh.read())
def download_file(self, file_id):
request = self.gdrive_service.files().get_media(fileId=file_id,
supportsAllDrives=True)
fh = io.FileIO("file", "wb")
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print(f"Download {int(status.progress()*100)}")
print("File downloaded")
def download_file(output_dir, file_name, file_id):
if not os.path.exists(output_dir):
os.mkdir(output_dir)
request = drive_service.files().get_media(fileId=file_id)
fh = io.FileIO(output_dir + '/' + file_name, 'wb')
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download {0}%.".format(int(status.progress() * 100)))
def main():
store = file.Storage('token.json')
creds = store.get()
if not creds or creds.invalid:
flow = client.flow_from_clientsecrets('credentials.json', SCOPES)
creds = tools.run_flow(flow, store)
service = build('drive', 'v3', http=creds.authorize(Http()))
file_id = '***'
request = service.files().get_media(fileId=file_id)
fh = io.FileIO('timesheet.pdf', 'wb')
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print('Timesheet updated. Opening...')
print('------------------------------------------------')
os.system("open "+"***")
#Sends email to Operations
done = input('Edit the document. Enter c when finsihed: ')
if done == 'c':
fromaddr = "[my email]"
toaddr = "[Operations email]"
msg = MIMEMultipart("alternative")
msg['From'] = fromaddr
msg['To'] = toaddr
msg['Subject'] = "Timesheet"
body = """\
<html>
<head></head>
<body>
<p>Hello!<br>
<br>
Here is my timesheet! Have a good one!<br>
<br>
<[HTML for email signature}>
</p>
</body>
</html>
"""
msg.attach(MIMEText(body, 'html'))
filename = "timesheet.pdf"
attachment = open("***", "rb")
part = MIMEBase('application', 'octet-stream')
part.set_payload((attachment).read())
encoders.encode_base64(part)
part.add_header('Content-Disposition', "attachment; filename= %s" % filename)
msg.attach(part)
server = smtplib.SMTP('smtp-mail.outlook.com', 587)
server.starttls()
server.login(fromaddr, "[PASSWORD]")
text = msg.as_string()
server.sendmail(fromaddr, toaddr, text)
server.quit()
print('Submitted.')
print('------------------------------------------------')
def download_file(self, client, fileName):
#Create the folders if needed
app_folder_id, key_folder_id = self.create_folders(client)
file_id = 0
response = client.files().list(
q="'{0}' in parents and mimeType!='application/vnd.google-apps.folder'"
.format(app_folder_id),
spaces='drive',
pageSize=1000,
fields="nextPageToken, files(id, name)").execute()
items = response.get('files', [])
for item in items:
if item['name'] == fileName:
file_id = item['id']
request = client.files().get_media(fileId=file_id)
fh = io.FileIO(fileName, mode='wb')
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download %d%%." % int(status.progress() * 100))
#Download the key file
file_id = 0
response = client.files().list(
q="'{0}' in parents and mimeType!='application/vnd.google-apps.folder'"
.format(key_folder_id),
spaces='drive',
pageSize=1000,
fields="nextPageToken, files(id, name)").execute()
items = response.get('files', [])
for item in items:
if item['name'] == "{}.key".format(fileName):
file_id = item['id']
request = client.files().get_media(fileId=file_id)
fh = io.FileIO("{}.key".format(fileName), mode='wb')
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download %d%%." % int(status.progress() * 100))
def _download_file(self, folder_id, drive_file, file_index, file_count):
logging.debug('Downloading %s from Google Drive: ' %
str(drive_file['name']))
max_retries = 3
for retry in range(0, max_retries):
try:
request = self.drive.files().get_media(fileId=drive_file['id'])
downloaded_file = open(self.dir + '/' + drive_file['name'],
'w')
downloader = MediaIoBaseDownload(downloaded_file, request)
modified_time = self._touch(folder_id)
done = False
while self.running and not done:
if self._seconds_since(
modified_time
) > 5 * 60: # Heartbeat after 5 minutes download
modified_time = self._touch(folder_id)
status, done = downloader.next_chunk()
if not self.canceled:
self.listener.update_status({
'state':
'ACTIVE',
'step':
'DOWNLOADING',
'description':
"Downloaded %d%% of file %d of %d." %
(int(status.progress() * 100), file_index + 1,
file_count)
})
if self.canceled:
self.listener.update_status({
'state': 'CANCELED',
'description': "Canceled"
})
return False # Canceled
self._delete(drive_file['id'])
return True # Succeeded
except Exception:
logger.exception('Download from Google Drive failed. file: ' +
drive_file['name'] + ', retry: ' + str(retry))
logger.exception('Giving up download from Google Drive after ' +
str(max_retries) + ' retries. file: ' +
drive_file['name'])
self.listener.update_status({
'state':
'FAILED',
'description':
'Download from Google Drive failed'
})
self.stop()
return False # Failed
def downloadFile(file_id, filepath):
request = drive_service.files().get_media(fileId=file_id)
fh = io.BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download %d%%." % int(status.progress() * 100))
with io.open(filepath, 'wb') as f:
fh.seek(0)
f.write(fh.read())
def download_file(file_id, mimeType, filename):
if "google-apps" in mimeType:
# skip google files
return
request = drive_service.files().get_media(fileId=file_id)
fh = io.FileIO(filename, 'wb')
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print ("Download %d%%." % int(status.progress() * 100))
def download_file(drive_service, file_id, filename):
request = drive_service.files().get_media(fileId=file_id)
fh = io.BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
# print('Downloading into {}'.format(filename))
while done is False:
status, done = downloader.next_chunk()
# print("Download {}%.".format(int(status.progress() * 100)))
with open(filename, 'wb') as f:
f.write(fh.getvalue())
def download_file(service, file_id):
req = service.files().get_media(fileId=file_id)
f = io.BytesIO()
downloader = MediaIoBaseDownload(f, req)
done = False
while not done:
status, done = downloader.next_chunk()
print('downloading: ', status.progress())
# seek to the begining of the file and reuse
f.seek(0)
return f
def download_file(file_id, destination):
request = drive_service.files().get_media(fileId=file_id)
fh = BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
while not done:
status, done = downloader.next_chunk()
print("Download {}.".format(int(status.progress() * 100)))
with ioOpen(destination, 'wb') as f:
fh.seek(0)
f.write(fh.read())
def file_down(s, i):
file_id = i["id"]
file_name = i["name"]
request = s.files().get_media(fileId=file_id)
f = open(file_name, "w")
downloader = MediaIoBaseDownload(f, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download %d%%." % int(status.progress() * 100))
f.close()
