def uploadToGCS(filename, file, file_type, bucket_name, object_name):
log('Building upload request...', True)
media = MediaIoBaseUpload(io.BytesIO(file), file_type, chunksize=CHUNKSIZE, resumable=True)
if not media.mimetype():
media = MediaIoBaseUpload(io.BytesIO(file), DEFAULT_MIMETYPE, chunksize=CHUNKSIZE, resumable=True)
request = service.objects().insert(bucket=bucket_name, name=object_name, media_body=media)
log('Uploading file: %s to bucket: %s object: %s ' % (filename, bucket_name, object_name))
progressless_iters = 0
response = None
while response is None:
error = None
try:
progress, response = request.next_chunk()
if progress:
log('Upload %d%%' % (100 * progress.progress()))
except urllib.error.HTTPError as err:
error = err
if err.resp.status < 500:
raise
except RETRYABLE_ERRORS as err:
error = err
if error:
progressless_iters += 1
handle_progressless_iter(error, progressless_iters)
else:
progressless_iters = 0
#print('\n')
log('Upload complete!')
def test_media_io_base_upload_serializable(self):
f = open(datafile('small.png'), 'r')
upload = MediaIoBaseUpload(fd=f, mimetype='image/png')
try:
json = upload.to_json()
self.fail('MediaIoBaseUpload should not be serializable.')
except NotImplementedError:
pass
def test_media_io_base_upload_serializable(self):
f = open(datafile('small.png'), 'r')
upload = MediaIoBaseUpload(fd=f, mimetype='image/png')
try:
json = upload.to_json()
self.fail('MediaIoBaseUpload should not be serializable.')
except NotImplementedError:
pass
def test_media_io_base_upload_serializable(self):
f = open(datafile("small.png"), "r")
upload = MediaIoBaseUpload(fh=f, mimetype="image/png")
try:
json = upload.to_json()
self.fail("MediaIoBaseUpload should not be serializable.")
except NotImplementedError:
pass
def test_media_io_base_upload_streamable(self):
try:
import io
fd = io.BytesIO('stuff')
upload = MediaIoBaseUpload(
fd=fd, mimetype='image/png', chunksize=500, resumable=True)
self.assertEqual(True, upload.has_stream())
self.assertEqual(fd, upload.stream())
except ImportError:
pass
def test_media_io_base_upload_streamable(self):
try:
import io
fd = io.BytesIO('stuff')
upload = MediaIoBaseUpload(
fd=fd, mimetype='image/png', chunksize=500, resumable=True)
self.assertEqual(True, upload.has_stream())
self.assertEqual(fd, upload.stream())
except ImportError:
pass
def test_resumable_media_handle_resume_of_upload_of_unknown_size(self):
http = HttpMockSequence([
({'status': '200',
'location': 'http://upload.example.com'}, ''),
({'status': '400'}, ''),
])
self.http = HttpMock(datafile('zoo.json'), {'status': '200'})
zoo = build('zoo', 'v1', http=self.http)
# Create an upload that doesn't know the full size of the media.
fd = io.StringIO('data goes here')
upload = MediaIoBaseUpload(
fd=fd, mimetype='image/png', chunksize=500, resumable=True)
request = zoo.animals().insert(media_body=upload, body=None)
# Put it in an error state.
self.assertRaises(HttpError, request.next_chunk, http=http)
http = HttpMockSequence([
({'status': '400',
'range': '0-5'}, 'echo_request_headers_as_json'),
])
try:
# Should resume the upload by first querying the status of the upload.
request.next_chunk(http=http)
except HttpError as e:
expected = {
'Content-Range': 'bytes */14',
'content-length': '0'
}
self.assertEqual(expected, simplejson.loads(e.content),
'Should send an empty body when requesting the current upload status.')
def update_file(service, file_id, filecontent, mime_type):
"""Insert new file.
Args:
service: Drive API service instance.
title: Title of the file to insert, including the extension.
description: Description of the file to insert.
parent_id: Parent folder's ID.
mime_type: MIME type of the file to insert.
filename: Filename of the file to insert.
Returns:
Inserted file metadata if successful, None otherwise.
"""
media_body = MediaIoBaseUpload(filecontent,
mimetype=mime_type,
resumable=True)
try:
file = service.files().update(
fileId=file_id,
media_body=media_body,
newRevision=True,
).execute()
# Uncomment the following line to print the File ID
# print 'File ID: %s' % file['id']
return file
except errors.HttpError, error:
print 'An error occured: %s' % error
return None
def _handle_timeline_notification(self, data):
"""Handle timeline notification."""
for user_action in data.get('userActions', []):
if user_action.get('type') == 'SHARE':
# Fetch the timeline item.
item = self.mirror_service.timeline().get(id=data['itemId']).execute()
attachments = item.get('attachments', [])
media = None
if attachments:
# Get the first attachment on that timeline item and do stuff with it.
attachment = self.mirror_service.timeline().attachments().get(
itemId=data['itemId'],
attachmentId=attachments[0]['id']).execute()
resp, content = self.mirror_service._http.request(
attachment['contentUrl'])
if resp.status == 200:
media = MediaIoBaseUpload(
io.BytesIO(content), attachment['contentType'],
resumable=True)
else:
logging.info('Unable to retrieve attachment: %s', resp.status)
body = {
'text': 'Echoing your shared item: %s' % item.get('text', ''),
'notification': {'level': 'DEFAULT'}
}
self.mirror_service.timeline().insert(
body=body, media_body=media).execute()
# Only handle the first successful action.
break
elif user_action.get('type') == 'CUSTOM' and user_action.get('payload') == 'social-stream':
self._insert_social_stream()
else:
logging.info(
"I don't know what to do with this notification: %s", user_action)
def upload_to_bucket(file, bucket, mimetype, id):
"""
SUCCESS: return None
ERROR: return http error code
"""
credentials = GoogleCredentials.get_application_default()
service = apiclient.discovery.build('storage',
'v1',
credentials=credentials)
image = MediaIoBaseUpload(file, mimetype=mimetype, resumable=True)
req = service.objects().insert(bucket=bucket, media_body=image, name=id)
# PROCESS UPLOAD IN CHUNKS
resp = None
serverErrorCount = 0 # to prevent infinite loop
while resp is None:
try:
status, resp = req.next_chunk()
# IF SERVER ERROR, TRY CHUNK AGAIN
except apiclient.errors.HttpError as e:
# IF 5xx ERROR RETRY
if e.resp.status in [500, 502, 503, 504]:
# Check how many retries have happened
if serverErrorCount > 8:
return e.resp.status
else:
time.sleep(1 + (serverErrorCount * 0.3)) # sleep it off
serverErrorCount += 1
continue
# If OTHER ERROR, RETURN IT IMMEDIATELY
else:
return e.resp.status
# IF NO ERROR, RETURN NONE
return None
def _save(self, name, content):
folder_path = os.path.sep.join(self._split_path(name)[:-1])
folder_data = self._get_or_create_folder(folder_path)
parent_id = None if folder_data is None else folder_data['id']
# Now we had created (or obtained) folder on GDrive
# Upload the file
mime_type = mimetypes.guess_type(name)
if mime_type[0] is None:
mime_type = self._UNKNOWN_MIMETYPE_
media_body = MediaIoBaseUpload(content.file,
mime_type,
resumable=True,
chunksize=1024 * 512)
body = {'name': self._split_path(name)[-1], 'mimeType': mime_type}
# Set the parent folder.
if parent_id:
body['parents'] = [parent_id]
file_data = self._drive_service.files().create(
body=body, media_body=media_body).execute()
# Setting up permissions
for p in self._permissions:
self._drive_service.permissions().create(fileId=file_data["id"],
body={
**p.raw
}).execute()
return file_data.get(u'originalFilename', file_data.get(u'name'))
def _save(self, name, content):
folder_path = os.path.sep.join(self._split_path(name)[:-1])
folder_data = self._get_or_create_folder(folder_path)
parent_id = None if folder_data is None else folder_data['id']
# Now we had created (or obtained) folder on GDrive
# Upload the file
fd = BytesIO(content.file.read())
mime_type = mimetypes.guess_type(name)
if mime_type[0] is None:
mime_type = self._UNKNOWN_MIMETYPE_
media_body = MediaIoBaseUpload(fd, mime_type, resumable=True)
body = {
'title': name,
'mimeType': mime_type
}
# Set the parent folder.
if parent_id:
body['parents'] = [{'id': parent_id}]
file_data = self._drive_service.files().insert(
body=body,
media_body=media_body).execute()
# Setting up public permission
public_permission = {
'type': 'anyone',
'role': 'reader'
}
self._drive_service.permissions().insert(fileId=file_data["id"], body=public_permission).execute()
return file_data[u'originalFilename']
def upload(self, file_p, filename, mime_type="application/octet-stream", parent=None):
"""
Upload file
name = Name of the file
source_location = absolutale location of the file where it is saved
mime_type - Type of the file/folder
parent - Id of the parent folder. Default is None
"""
if parent is None:
_file_metadata = {
'name': filename,
}
else:
_file_metadata = {
'name': filename,
'parents': [parent]
}
# _media = MediaFileUpload(file_p, mimetype=mime_type, resumable=True)
_media = MediaIoBaseUpload(fd=file_p, mimetype=mime_type, resumable=False)
return self._service.files().create(body=_file_metadata, media_body=_media, fields='id').execute()
def upload_revision(self, document_name, document, folder_id, original_format, title='Untitled', target_format='*/*'):
"""Upload file to a Google Drive folder.
Args:
document_name: Name of the document
document: content of the document to upload.
folder_id: id of the Google Drive folder
original_format: file format of the document content
title: document title
target_format: file format that that the uploaded file will transform into.
Returns:
A string to represent the uploaded file's id.
"""
file_metadata = {
'name': document_name,
'title': title,
'parents': [folder_id],
'mimeType': target_format
}
fh = BytesIO(document)
media = MediaIoBaseUpload(fh, mimetype=original_format, resumable=True)
file = self._drive_service.files().insert(body=file_metadata,
media_body=media,
convert=True,
fields='id').execute()
print ('File ID: ' + file.get('id'))
return file.get('id')
def test_media_io_base_stream_unlimited_chunksize_resume(self):
self.http = HttpMock(datafile('zoo.json'), {'status': '200'})
zoo = build('zoo', 'v1', http=self.http)
try:
import io
# Set up a seekable stream and try to upload in single chunk.
fd = io.BytesIO(b'01234"56789"')
media_upload = MediaIoBaseUpload(
fd=fd, mimetype='text/plain', chunksize=-1, resumable=True)
request = zoo.animals().insert(media_body=media_upload, body=None)
# The single chunk fails, restart at the right point.
http = HttpMockSequence([
({'status': '200',
'location': 'http://upload.example.com'}, ''),
({'status': '308',
'location': 'http://upload.example.com/2',
'range': '0-4'}, ''),
({'status': '200'}, 'echo_request_body'),
])
body = request.execute(http=http)
self.assertEqual('56789', body)
except ImportError:
pass
def _save(self, name, content):
folder_path = os.path.sep.join(self._split_path(name)[:-1])
folder_data = self._get_or_create_folder(folder_path)
parent_id = None if folder_data is None else folder_data['id']
# Now we had created (or obtained) folder on GDrive
# Upload the file
fd = BytesIO(content.file.read())
mime_type = mimetypes.guess_type(name)
if mime_type[0] is None:
mime_type = self._UNKNOWN_MIMETYPE_
media_body = MediaIoBaseUpload(fd, mime_type, resumable=True)
body = {
'title': name,
'mimeType': mime_type
}
# Set the parent folder.
if parent_id:
body['parents'] = [{'id': parent_id}]
file_data = self._drive_service.files().insert(
body=body,
media_body=media_body).execute()
# Setting up permissions
for p in self._permissions:
time.sleep(0.25) # avoid HTTP 500 "An internal error has occurred which prevented the sharing of these item(s)"
self._drive_service.permissions().insert(fileId=file_data["id"], body=p.raw).execute()
return file_data.get(u'originalFilename', file_data.get(u'title'))
def create_drive_file_from_io(self, name, parent_ids, io_bytes, mime_type, description=None, propertyDict=None):
file_metadata = {'name': name,
'description': description,
'mimeType': mime_type,
'parents': parent_ids}
media_body = MediaIoBaseUpload(io_bytes,
chunksize=-1,
mimetype=mime_type,
resumable=True)
request = self.service.files().create(body=file_metadata,
media_body=media_body,
fields="id")
response = None
backoff = 1
while response is None:
try:
status, response = request.next_chunk()
# if status:
# print('{} percent {}'.format(name, int(status.progress() * 100)))
except errors.HttpError, e:
if e.resp.status in [404]:
# Start the upload all over again or error.
raise Exception('Upload Failed 404')
elif e.resp.status in [500, 502, 503, 504]:
if backoff > 8:
raise Exception('Upload Failed: {}'.format(e))
print 'Retrying upload in: {} seconds'.format(backoff)
sleep(backoff + uniform(.001, .999))
backoff += backoff
else:
msg = 'Upload Failed\n{}'.format(e)
raise Exception(msg)
def upload_string(self,
contents,
mime_type,
title,
description=None,
parent_ids=None):
"""Upload a string."""
if description is None:
description = title
body = {
'title': title,
'description': description,
'mimeType': mime_type
}
if parent_ids is not None:
if isinstance(parent_ids, list):
body['parents'] = [{
'id': parent_id
} for parent_id in parent_ids
if isinstance(parent_id, basestring)]
elif isinstance(parent_ids, basestring):
body['parents'] = [{'id': parent_ids}]
media_body = MediaIoBaseUpload(StringIO(contents), mimetype=mime_type)
return self.service.files().insert(body=body,
media_body=media_body,
convert=True).execute()
def _upload(self):
with gcs.open(self._file_name, read_buffer_size=self._BUFFER_SIZE) as f:
media = MediaIoBaseUpload(f, mimetype='application/octet-stream',
chunksize=self._BUFFER_SIZE, resumable=True)
request = self._ga_client.management().uploads().uploadData(
accountId=self._account_id,
webPropertyId=self._params['property_id'],
customDataSourceId=self._params['dataset_id'],
media_body=media)
response = None
tries = 0
milestone = 0
while response is None and tries < 5:
try:
status, response = request.next_chunk()
except HttpError, e:
if e.resp.status in [404, 500, 502, 503, 504]:
tries += 1
delay = 5 * 2 ** (tries + random())
self.log_warn('%s, Retrying in %.1f seconds...', e, delay)
time.sleep(delay)
else:
raise WorkerException(e)
else:
tries = 0
if status:
progress = int(status.progress() * 100)
if progress >= milestone:
self.log_info('Uploaded %d%%.', int(status.progress() * 100))
milestone += 20
self.log_info('Upload Complete.')
def put(self, local_path, remote_path, report_to=None):
LOG.debug('Uploading %s to cloud storage (remote path: %s)', local_path, remote_path)
filename = os.path.basename(local_path)
bucket, name = self._parse_url(remote_path)
if name.endswith("/"):
name = os.path.join(name, filename)
buckets = self._list_buckets()
if bucket not in buckets:
self._create_bucket(bucket)
fd = open(local_path, 'rb')
try:
media = MediaIoBaseUpload(fd,
'application/octet-stream',
resumable=True)
req = self.cloudstorage.objects().insert(
bucket=bucket, name=name, media_body=media
)
last_progress = 0
response = None
while response is None:
status, response = req.next_chunk()
if status:
percentage = int(status.progress() * 100)
if percentage - last_progress >= self.report_interval:
if report_to:
report_to(status.resumable_progress, status.total_size)
last_progress = percentage
finally:
fd.close()
LOG.debug("Finished uploading %s", os.path.basename(local_path))
return self._format_url(bucket, name)
def upload(self, data, mime_type=None, as_binary=False, **body): if not hasattr(self, "service"): return None if not as_binary: try: with open(data, 'rb') as d: data = d.read() except IOError as e: if DEBUG: print e return False import io, sys from apiclient.http import MediaIoBaseUpload if mime_type is None: mime_type = "application/octet-stream" chunk_size = 1024*1024 # unless data is tiny. check first data = io.BytesIO(data) if sys.getsizeof(data) < chunk_size: chunk_size = -1 media_body = MediaIoBaseUpload(data, mimetype=mime_type, chunksize=chunk_size, resumable=True) try: upload = self.service.files().insert( body=body, media_body=media_body).execute() return upload except errors.HttpError as e: if DEBUG: print e return None
def test_resumable_media_handle_uploads_of_unknown_size_eof(self):
http = HttpMockSequence([
({
'status': '200',
'location': 'http://upload.example.com'
}, ''),
({
'status': '200'
}, 'echo_request_headers_as_json'),
])
self.http = HttpMock(datafile('zoo.json'), {'status': '200'})
zoo = build('zoo', 'v1', http=self.http)
fd = io.StringIO('data goes here')
# Create an upload that doesn't know the full size of the media.
upload = MediaIoBaseUpload(fd=fd,
mimetype='image/png',
chunksize=15,
resumable=True)
request = zoo.animals().insert(media_body=upload, body=None)
status, body = request.next_chunk(http=http)
self.assertEqual(body, {
'Content-Range': 'bytes 0-13/14',
'Content-Length': '14',
})
def upload_csv_as_sheet(self, sheetName='GooGIS', body = {}, csv_file_obj = None, csv_path = None, update_sheetId = None):
'''
Method to upload to Google drive a csv file (or a path to a csv file) as a google-apps.spreadsheet
:param sheetName:
:param body:
:param csv_file_obj:
:param csv_path:
:param update_sheetId:
:return: response object
'''
body['mimeType'] = 'application/vnd.google-apps.spreadsheet'
if csv_path or csv_file_obj:
if csv_path:
media_body = MediaFileUpload(csv_path, mimetype='text/csv', resumable=None)
elif csv_file_obj:
media_body = MediaIoBaseUpload(csv_file_obj, mimetype='text/csv', resumable=None)
if update_sheetId:
return self.service.files().update(fileId=update_sheetId, media_body=media_body).execute()
else:
body['description'] = 'GooGIS sheet'
body['name'] = sheetName
return self.service.files().create(body=body, media_body=media_body).execute()
else:
return None
def credentails_put(cloud_path, credentials):
service = get_service()
bucket, filename = cloud_path.split(':',1)
data = auth_encode(credentials)
media = MediaIoBaseUpload(BytesIO(str(data)), mimetype="text/json")
service.objects().insert(bucket=bucket, name=filename, media_body=media).execute()
return filename
def object_put(auth, path, data, mimetype='application/octet-stream'):
bucket, filename = path.split(':', 1)
service = get_service('storage', 'v1', auth)
media = MediaIoBaseUpload(data,
mimetype=mimetype,
chunksize=CHUNKSIZE,
resumable=True)
request = service.objects().insert(bucket=bucket,
name=filename,
media_body=media)
response = None
errors = 0
while response is None:
error = None
try:
status, response = request.next_chunk()
if project.verbose and status:
print "Uploaded %d%%." % int(status.progress() * 100)
except HttpError, e:
if e.resp.status < 500: raise
error = e
except (httplib2.HttpLib2Error, IOError), e:
error = e
def upload(self, bucket, object, filename=None, file_handle=None,
mime_type='application/octet-stream'):
"""
Uploads a local file to Google Cloud Storage.
:param bucket: The bucket to upload to.
:type bucket: string
:param object: The object name to set when uploading the local file.
:type object: string
:param filename: The local file path to the file to be uploaded.
:type filename: string
:param file_handle: The source of the bytes to upload.
:type file_handle: io.Base or file object
:param mime_type: The MIME type to set when uploading the file.
:type mime_type: string
"""
service = self.get_conn()
if not (filename or file_handle):
raise ValueError('Supply either filename or file_handle!')
if filename:
media = MediaFileUpload(filename, mime_type)
else:
media = MediaIoBaseUpload(file_handle, mime_type)
try:
service \
.objects() \
.insert(bucket=bucket, name=object, media_body=media) \
.execute()
return True
except errors.HttpError as ex:
if ex.resp['status'] == '404':
return False
raise
def test_media_io_base_stream_chunksize_resume(self):
self.http = HttpMock(datafile('zoo.json'), {'status': '200'})
zoo = build('zoo', 'v1', http=self.http)
try:
import io
# Set up a seekable stream and try to upload in chunks.
fd = io.BytesIO(b'0123456789')
media_upload = MediaIoBaseUpload(fd=fd,
mimetype='text/plain',
chunksize=5,
resumable=True)
request = zoo.animals().insert(media_body=media_upload, body=None)
# The single chunk fails, pull the content sent out of the exception.
http = HttpMockSequence([
({
'status': '200',
'location': 'http://upload.example.com'
}, ''),
({
'status': '400'
}, 'echo_request_body'),
])
try:
body = request.execute(http=http)
except HttpError as e:
self.assertEqual('01234', e.content)
except ImportError:
pass
def test_media_io_base_next_chunk_retries(self):
try:
import io
except ImportError:
return
f = open(datafile('small.png'), 'r')
fd = io.BytesIO(f.read())
upload = MediaIoBaseUpload(fd=fd,
mimetype='image/png',
chunksize=500,
resumable=True)
# Simulate 5XXs for both the request that creates the resumable upload and
# the upload itself.
http = HttpMockSequence([
({
'status': '500'
}, ''),
({
'status': '500'
}, ''),
({
'status': '503'
}, ''),
({
'status': '200',
'location': 'location'
}, ''),
({
'status': '500'
}, ''),
({
'status': '500'
}, ''),
({
'status': '503'
}, ''),
({
'status': '200'
}, '{}'),
])
model = JsonModel()
uri = u'https://www.googleapis.com/someapi/v1/upload/?foo=bar'
method = u'POST'
request = HttpRequest(http,
model.response,
uri,
method=method,
headers={},
resumable=upload)
sleeptimes = []
request._sleep = lambda x: sleeptimes.append(x)
request._rand = lambda: 10
request.execute(num_retries=3)
self.assertEqual([20, 40, 80, 20, 40, 80], sleeptimes)
def InsertRowData(self, tableObject, rowDictionary):
sump = io.StringIO()
w = csv.writer(sump, quoting=csv.QUOTE_ALL)
w.writerows(rowDictionary)
mu = MediaIoBaseUpload(sump, mimetype="application/octet-stream")
return self.service.table().importRows(tableId=tableObject["tableId"],
media_body=mu).execute()
def execute(self):
media_body = MediaIoBaseUpload(self.reader,
mimetype=mimetypes.guess_type(
self.args["name"])[0])
self.service.files().create(
body=self.args,
media_body=media_body,
).execute()
def upload_csv_under_folder(self, csv_upload_name, file_in_memory,
folder_id):
file_metadata = dict(name=csv_upload_name, parents=[folder_id])
media_body = MediaIoBaseUpload(io.BytesIO(
file_in_memory.getvalue().encode('utf-8')),
mimetype='text/csv')
self.google_drive_api.files().create(body=file_metadata,
media_body=media_body).execute()
def _upload_image(self, url):
"""
@return: media_object
"""
resp = urlfetch.fetch(url, deadline=20)
media = MediaIoBaseUpload(io.BytesIO(resp.content),
mimetype='image/jpeg',
resumable=True)
return media
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 test_media_io_base_upload_from_file_object(self):
f = open(datafile("small.png"), "r")
upload = MediaIoBaseUpload(fh=f, mimetype="image/png", chunksize=500, resumable=True)
self.assertEqual("image/png", upload.mimetype())
self.assertEqual(190, upload.size())
self.assertEqual(True, upload.resumable())
self.assertEqual(500, upload.chunksize())
self.assertEqual("PNG", upload.getbytes(1, 3))
f.close()
def test_media_io_base_upload_from_file_object(self):
f = open(datafile('small.png'), 'r')
upload = MediaIoBaseUpload(
fd=f, mimetype='image/png', chunksize=500, resumable=True)
self.assertEqual('image/png', upload.mimetype())
self.assertEqual(190, upload.size())
self.assertEqual(True, upload.resumable())
self.assertEqual(500, upload.chunksize())
self.assertEqual('PNG', upload.getbytes(1, 3))
f.close()
def test_media_io_base_upload_from_string_io(self):
f = open(datafile("small.png"), "r")
fh = StringIO.StringIO(f.read())
f.close()
upload = MediaIoBaseUpload(fh=fh, mimetype="image/png", chunksize=500, resumable=True)
self.assertEqual("image/png", upload.mimetype())
self.assertEqual(None, upload.size())
self.assertEqual(True, upload.resumable())
self.assertEqual(500, upload.chunksize())
self.assertEqual("PNG", upload.getbytes(1, 3))
f.close()
def test_media_io_base_upload_from_file_io(self):
try:
import io
fh = io.FileIO(datafile("small.png"), "r")
upload = MediaIoBaseUpload(fh=fh, mimetype="image/png", chunksize=500, resumable=True)
self.assertEqual("image/png", upload.mimetype())
self.assertEqual(190, upload.size())
self.assertEqual(True, upload.resumable())
self.assertEqual(500, upload.chunksize())
self.assertEqual("PNG", upload.getbytes(1, 3))
except ImportError:
pass
def test_media_io_base_upload_from_string_io(self):
f = open(datafile('small.png'), 'r')
fd = StringIO.StringIO(f.read())
f.close()
upload = MediaIoBaseUpload(
fd=fd, mimetype='image/png', chunksize=500, resumable=True)
self.assertEqual('image/png', upload.mimetype())
self.assertEqual(None, upload.size())
self.assertEqual(True, upload.resumable())
self.assertEqual(500, upload.chunksize())
self.assertEqual('PNG', upload.getbytes(1, 3))
f.close()
def test_media_io_base_upload_from_file_io(self):
try:
import io
fd = io.FileIO(datafile('small.png'), 'r')
upload = MediaIoBaseUpload(
fd=fd, mimetype='image/png', chunksize=500, resumable=True)
self.assertEqual('image/png', upload.mimetype())
self.assertEqual(190, upload.size())
self.assertEqual(True, upload.resumable())
self.assertEqual(500, upload.chunksize())
self.assertEqual('PNG', upload.getbytes(1, 3))
except ImportError:
pass