def save_as(self, options_xml, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param options_xml:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = self.base_uri + '/saveAs'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.post(signed_uri, options_xml, headers={
'content-type': 'application/xml', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
return Utils.download_file(response['SaveResult']['DestDocument']['Href'],
response['SaveResult']['DestDocument']['Href'],
remote_folder, storage_type, storage_name)
else:
return validate_output
def convert_drawing_object(self, object_index, render_format,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param object_index:
:param render_format:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
str_uri = self.base_uri + '/drawingObjects/' + str(object_index) + '?format=' + render_format
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
})
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
return Utils.save_file(response,
AsposeApp.output_path + Utils.get_filename(self.filename)
+ '_' + str(object_index) + '.' + render_format)
else:
return validate_output
def append_document(self, doc_list, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param doc_list:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
str_uri = self.base_uri + '/appendDocument'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
json_data = json.dumps(doc_list)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.post(signed_uri, json_data, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
return Utils.download_file(self.filename, self.filename, remote_folder, storage_type, storage_name)
else:
return validate_output
def replace_all_text(self, old_text, new_text,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param slide_number:
:param old_text:
:param new_text:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
str_uri = self.base_uri + '/replaceText'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
json_data = json.dumps({'OldValue': old_text, 'NewValue': new_text})
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.post(signed_uri, json_data, headers={
'content-type': 'application/json', 'accept': 'application/json'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
return True
else:
return validate_output
def insert_watermark_image(self, image_file, angle, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param image_file:
:param angle:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
str_uri = self.base_uri + '/insertWatermarkText'
qry = {'imageFile': image_file, 'rotationAngle': angle}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.post(signed_uri, None, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
return Utils.download_file(self.filename, self.filename, remote_folder, storage_type, storage_name)
else:
return validate_output
def replace_text(self, slide_number, old_text, new_text,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param slide_number:
:param old_text:
:param new_text:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
str_uri = self.base_uri + '/slides/' + str(slide_number) + '/replaceText'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
json_data = json.dumps({'OldValue': old_text, 'NewValue': new_text})
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.post(signed_uri, json_data, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
return True
else:
return validate_output
def update_gif_properties_local(self,
input_file_path,
bg_color_index,
px_aspect_ratio,
interlaced,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param input_file_path:
:param bg_color_index:
:param px_aspect_ratio:
:param interlaced:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/gif'
qry = {
'backgroundColorIndex': bg_color_index,
'pixelAspectRatio': px_aspect_ratio,
'interlaced': interlaced
}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
with open(input_file_path, 'rb') as payload:
response = requests.post(signed_uri,
data=payload,
headers={
'content-type':
'application/json',
'accept': 'application/json',
'x-aspose-client':
'PYTHONSDK/v1.0'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(
self.filename) + '_updated.gif'
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def extract_frame(self, frame_id, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param frame_id:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
str_uri = self.base_uri + '/frames/' + str(frame_id) + '?saveOtherFrames=false'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '_frame_' + str(frame_id) + '.tiff'
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
return response
def get_attachment(self, attachment_name, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param attachment_name:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
if not attachment_name:
raise ValueError("attachment_name not specified")
str_uri = self.base_uri + '/attachments/' + attachment_name
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + attachment_name
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def execute_template(self, str_xml, with_regions=False, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param str_xml:
:param with_regions:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
if not str_xml:
raise ValueError("str_xml not specified")
str_uri = self.base_uri + '/executeTemplate'
str_uri = str_uri + '?withRegions=true' if with_regions else str_uri
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.post(signed_uri, str_xml, headers={
'content-type': 'application/xml', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
return Utils.download_file(self.filename, self.filename, remote_folder, storage_type, storage_name)
else:
return validate_output
def update_bmp_properties_local(self,
input_file_path,
bits_per_px,
h_resolution,
v_resolution,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param bits_per_px:
:param h_resolution:
:param v_resolution:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/bmp'
qry = {
'bitsPerPixel': bits_per_px,
'horizontalResolution': h_resolution,
'verticalResolution': v_resolution
}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
with open(input_file_path, 'rb') as payload:
response = requests.post(signed_uri,
data=payload,
headers={
'content-type':
'application/json',
'accept': 'application/json',
'x-aspose-client':
'PYTHONSDK/v1.0'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(
self.filename) + '_updated.bmp'
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def get_drawing_object(object_uri, output_path, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param object_uri:
:param output_path:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
object_index = object_uri[-1:]
str_uri = Product.product_uri + 'words/' + object_uri
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
object_info = response['DrawingObject']
if not object_info['ImageDataLink'] is None:
str_uri = Product.product_uri + 'words/' + object_uri + '/imageData'
output_path = output_path + 'DrawingObject_' + str(object_index) + '.jpg'
elif not object_info['OleDataLink'] is None:
str_uri = Product.product_uri + 'words/' + object_uri + '/oleData'
output_path = output_path + 'DrawingObject_' + str(object_index) + '.xlsx'
else:
str_uri = Product.product_uri + 'words/' + object_uri + '?format=jpg'
output_path = output_path + 'DrawingObject_' + str(object_index) + '.jpg'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
})
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
return Utils.save_file(response, output_path)
else:
return validate_output
def resize_tiff_frame(self,
frame_id,
new_width,
new_height,
output_path,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param frame_id:
:param new_width:
:param new_height:
:param output_path:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/' + self.filename + '/frames/' + str(
frame_id)
qry = {
'saveOtherFrames': True,
'newWidth': new_width,
'newHeight': new_height,
'outputPath': output_path
}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
save_format = 'tiff'
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '_resized_frame_' + \
str(frame_id) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def convert_local_file(self,
input_file_path,
save_format,
stream_out=False,
output_filename=None,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param input_file_path:
:param save_format:
:param stream_out:
:param output_filename:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/' + self.filename + '/saveAs?format=' + save_format
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
with open(input_file_path, 'rb') as payload:
response = requests.get(signed_uri,
data=payload,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
if not stream_out:
if output_filename is None:
output_filename = input_file_path
save_format = 'zip' if save_format == 'html' else save_format
output_path = AsposeApp.output_path + Utils.get_filename(
output_filename) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return response.content
else:
return validate_output
def update_psd_properties_local(self,
input_file_path,
channels_count,
compression_method,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param input_file_path:
:param channels_count:
:param compression_method:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/psd'
qry = {
'channelsCount': channels_count,
'compressionMethod': compression_method
}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
with open(input_file_path, 'rb') as payload:
response = requests.post(signed_uri,
data=payload,
headers={
'content-type':
'application/json',
'accept': 'application/json',
'x-aspose-client':
'PYTHONSDK/v1.0'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(
self.filename) + '_updated.psd'
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def update_tiff_properties(self, bit_depth, compression, resolution_unit, new_width, new_height,
horizontal_resolution, vertical_resolution, output_path,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param bit_depth:
:param compression:
:param resolution_unit:
:param new_width:
:param new_height:
:param horizontal_resolution:
:param vertical_resolution:
:param output_path:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'storage/file/' + self.filename
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
file_content = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json'
}, stream=True)
str_uri = Product.product_uri + 'imaging/tiff'
qry = {'compression': compression, 'resolutionUnit': resolution_unit, 'newWidth' : new_width,
'newHeight' : new_height, 'horizontalResolution' : horizontal_resolution,
'verticalResolution' : vertical_resolution, 'bitDepth' : bit_depth, 'outputPath': output_path}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.post(signed_uri, file_content, headers={
'content-type': 'application/json', 'accept': 'application/json'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '_updated.tiff'
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def rotate_image(self,
method,
output_path,
save_format,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param method:
:param output_path:
:param save_format:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/' + self.filename + '/rotateflip'
qry = {
'method': method,
'outputPath': output_path,
'format': save_format
}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
save_format = 'zip' if save_format == 'html' else save_format
output_path = AsposeApp.output_path + Utils.get_filename(
self.filename) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def convert(self, save_format, additional_params=None, slide_number=None, stream_out=False, output_filename=None,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param save_format:
:param additional_params:
:param slide_number:
:param stream_out:
:param output_filename:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
if not save_format:
raise ValueError("save_format not specified")
str_uri = self.base_uri + '/slides'
if(slide_number):
str_uri += '/' + str(slide_number)
qry_str = {'format': save_format}
if(additional_params):
qry_str.update(additional_params)
str_uri = Utils.build_uri(str_uri, qry_str)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
if not stream_out:
if output_filename is None:
output_filename = self.filename
save_format = 'zip' if save_format == 'html' else save_format
if(slide_number):
output_path = AsposeApp.output_path + Utils.get_filename(output_filename) + '_' + str(slide_number) + '.' + \
save_format
else:
output_path = AsposeApp.output_path + Utils.get_filename(output_filename) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return response.content
else:
return validate_output
def convert_to_image(self, slide_number, save_format, width=None, height=None, stream_out=False,
output_filename=None, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param slide_number:
:param save_format:
:param width:
:param height:
:param stream_out:
:param output_filename:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
if not save_format:
raise ValueError("save_format not specified")
if not slide_number:
raise ValueError("slide_number not specified")
str_uri = self.base_uri + '/slides/' + str(slide_number)
qry = {'format': save_format}
if width and height:
qry['width'] = width
qry['height'] = height
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
if not stream_out:
if output_filename is None:
output_filename = self.filename
output_path = AsposeApp.output_path + Utils.get_filename(output_filename) + '_' + str(slide_number) + '.' + \
save_format
Utils.save_file(response, output_path)
return output_path
else:
return response.content
else:
return validate_output
def update_jpg_properties(self,
quality,
compression_type,
output_path,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param quality:
:param compression_type:
:param output_path:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = self.base_uri + '/jpg'
qry = {
'quality': quality,
'compressionType': compression_type,
'outputPath': output_path
}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(
self.filename) + '_updated.jpg'
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def convert(self,
save_format,
stream_out=False,
output_filename=None,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
convert an email message document to a different format
:param save_format:
:param output_filename:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
if not save_format:
raise ValueError("save_format not specified")
str_uri = self.base_uri + '?format=' + save_format
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
if not stream_out:
if output_filename is None:
output_filename = self.filename
output_path = AsposeApp.output_path + Utils.get_filename(
output_filename) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return response.content
else:
return validate_output
def append_documents(self,
append_file,
start_page=None,
end_page=None,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
Append a pdf file to base pdf
:param append_file:
:param start_page:
:param end_page:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
str_uri = self.base_uri + '/appendDocument'
qry = {'appendFile': append_file}
if start_page:
qry['startPage'] = start_page
if end_page:
qry['endPage'] = end_page
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.post(signed_uri,
None,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if validate_output:
return validate_output
else:
return True
def get_image(self, page_number, image_index, save_format, width=None, height=None,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
Get image from given page
:param page_number:
:param image_index:
:param save_format:
:param width:
:param height:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
if not save_format:
raise ValueError("save_format not specified")
if not page_number:
raise ValueError("page_number not specified")
str_uri = self.base_uri + '/pages/' + str(page_number) + '/images/' + str(image_index)
qry = {'format': save_format}
if width and height:
qry['width'] = width
qry['height'] = height
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '_' + str(page_number) \
+ '_' + str(image_index) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def convert_tiff_to_fax(self,
stream_out=False,
output_filename=None,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param stream_out:
:param output_filename:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/tiff/' + self.filename + '/toFax'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
if not stream_out:
if output_filename is None:
output_filename = self.filename
output_path = AsposeApp.output_path + output_filename
Utils.save_file(response, output_path)
return output_path
else:
return response.content
else:
return validate_output
def update_image(self,
params,
save_format,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param params:
:param save_format:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = self.base_uri + '/updateImage'
params['format'] = save_format
str_uri = Utils.build_uri(str_uri, params)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
save_format = 'zip' if save_format == 'html' else save_format
output_path = AsposeApp.output_path + Utils.get_filename(
self.filename) + '_updated.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def crop_tiff_frame(self, frame_id, x, y, new_width, new_height, output_path,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param frame_id:
:param x:
:param y:
:param new_width:
:param new_height:
:param output_path:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/' + self.filename + '/frames/' + str(frame_id)
qry = {'saveOtherFrames': True, 'x':x, 'y':y, 'newWidth': new_width, 'newHeight': new_height,
'outputPath': output_path}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
save_format = 'tiff'
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '_croped_frame_' + \
str(frame_id) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def resize_image(self, input_file_path, new_width, new_height, output_filename, save_format,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param input_file_path:
:param new_width:
:param new_height:
:param output_filename:
:param save_format:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/resize'
qry = {'newWidth': new_width, 'newHeight': new_height, 'format': save_format}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
with open(input_file_path, 'rb') as payload:
response = requests.post(signed_uri, data=payload, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
save_format = 'zip' if save_format == 'html' else save_format
output_path = AsposeApp.output_path + Utils.get_filename(input_file_path) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def convert_local_file(self, input_file_path, save_format, stream_out=False, output_filename=None,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param input_file_path:
:param save_format:
:param stream_out:
:param output_filename:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/' + self.filename + '/saveAs?format=' + save_format
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
with open(input_file_path, 'rb') as payload:
response = requests.get(signed_uri, data=payload, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
if not stream_out:
if output_filename is None:
output_filename = input_file_path
save_format = 'zip' if save_format == 'html' else save_format
output_path = AsposeApp.output_path + Utils.get_filename(output_filename) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return response.content
else:
return validate_output
def crop_image(self, x, y, width, height, output_path, save_format,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param x:
:param y:
:param width:
:param height:
:param output_path:
:param save_format:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/' + self.filename + '/crop'
qry = {'x': x, 'y': y, 'width': width, 'height': height, 'outputPath': output_path, 'format': save_format}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
save_format = 'zip' if save_format == 'html' else save_format
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '_croped.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def update_gif_properties_local(self, input_file_path, bg_color_index, px_aspect_ratio, interlaced,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param input_file_path:
:param bg_color_index:
:param px_aspect_ratio:
:param interlaced:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/gif'
qry = {'backgroundColorIndex': bg_color_index, 'pixelAspectRatio': px_aspect_ratio,
'interlaced': interlaced}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
with open(input_file_path, 'rb') as payload:
response = requests.post(signed_uri, data=payload, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '_updated.gif'
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def extract_frame(self,
frame_id,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param frame_id:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
str_uri = self.base_uri + '/frames/' + str(
frame_id) + '?saveOtherFrames=false'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(
self.filename) + '_frame_' + str(frame_id) + '.tiff'
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
return response
def get_attachment(self,
attachment_name,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param attachment_name:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
if not attachment_name:
raise ValueError("attachment_name not specified")
str_uri = self.base_uri + '/attachments/' + attachment_name
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + attachment_name
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def update_jpg_properties_local(self, input_file_path, quality, compression_type,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param input_file_path:
:param quality:
:param compression_type:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/jpg'
qry = {'quality': quality, 'compressionType': compression_type}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
with open(input_file_path, 'rb') as payload:
response = requests.post(signed_uri, data=payload, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '_updated.jpg'
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def update_psd_properties(self, channels_count, compression_method, output_path,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param channels_count:
:param compression_method:
:param output_path:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = self.base_uri + '/psd'
qry = {'channelsCount': channels_count, 'compressionMethod': compression_method,
'outputPath': output_path}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '_updated.psd'
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def update_bmp_properties(self, bits_per_px, h_resolution, v_resolution, output_path,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param bits_per_px:
:param h_resolution:
:param v_resolution:
:param output_path:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = self.base_uri + '/bmp'
qry = {'bitsPerPixel': bits_per_px, 'horizontalResolution': h_resolution,
'verticalResolution': v_resolution,'outputPath': output_path}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '_updated.bmp'
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def convert(self, save_format, stream_out=False, output_filename=None,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
convert an email message document to a different format
:param save_format:
:param output_filename:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
if not save_format:
raise ValueError("save_format not specified")
str_uri = self.base_uri + '?format=' + save_format
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
if not stream_out:
if output_filename is None:
output_filename = self.filename
output_path = AsposeApp.output_path + Utils.get_filename(output_filename) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return response.content
else:
return validate_output
def rotate_image(self, method, output_path, save_format,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param method:
:param output_path:
:param save_format:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/' + self.filename + '/rotateflip'
qry = {'method': method, 'outputPath': output_path, 'format': save_format}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
save_format = 'zip' if save_format == 'html' else save_format
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def convert_local_file(input_file, save_format, stream_out=False, output_filename=None):
"""
:param input_file:
:param save_format:
:param stream_out:
:param output_filename:
:return:
"""
if not input_file:
raise ValueError("input_file not specified")
if not save_format:
raise ValueError("save_format not specified")
str_uri = Product.product_uri + 'words/convert?format=' + save_format
signed_uri = Utils.sign(str_uri)
response = None
try:
response = Utils.upload_file_binary(input_file, signed_uri)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
if not stream_out:
if output_filename is None:
output_filename = input_file
save_format = 'zip' if save_format == 'html' else save_format
output_path = AsposeApp.output_path + Utils.get_filename(output_filename) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return response.content
else:
return validate_output
def append_documents(self, append_file, start_page=None, end_page=None,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
Append a pdf file to base pdf
:param append_file:
:param start_page:
:param end_page:
:param remote_folder: storage path to operate
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return:
"""
str_uri = self.base_uri + '/appendDocument'
qry = {'appendFile': append_file}
if start_page:
qry['startPage'] = start_page
if end_page:
qry['endPage'] = end_page
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.post(signed_uri, None, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if validate_output:
return validate_output
else:
return True
def update_tiff_frame(self, frame_id, params,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param frame_id:
:param params:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/' + self.filename + '/frames/' + str(frame_id)
str_uri = Utils.build_uri(str_uri, params)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
save_format = 'tiff'
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '_updated_frame_' + \
str(frame_id) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def convert_tiff_to_fax(self, stream_out=False, output_filename=None, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param stream_out:
:param output_filename:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/tiff/' + self.filename + '/toFax'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
if not stream_out:
if output_filename is None:
output_filename = self.filename
output_path = AsposeApp.output_path + output_filename
Utils.save_file(response, output_path)
return output_path
else:
return response.content
else:
return validate_output
def update_image(self, params, save_format, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param params:
:param save_format:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = self.base_uri + '/updateImage'
params['format'] = save_format
str_uri = Utils.build_uri(str_uri, params)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json'
}, stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
save_format = 'zip' if save_format == 'html' else save_format
output_path = AsposeApp.output_path + Utils.get_filename(self.filename) + '_updated.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def crop_image(self,
x,
y,
width,
height,
output_path,
save_format,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param x:
:param y:
:param width:
:param height:
:param output_path:
:param save_format:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/' + self.filename + '/crop'
qry = {
'x': x,
'y': y,
'width': width,
'height': height,
'outputPath': output_path,
'format': save_format
}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
save_format = 'zip' if save_format == 'html' else save_format
output_path = AsposeApp.output_path + Utils.get_filename(
self.filename) + '_croped.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def resize_image(self,
input_file_path,
new_width,
new_height,
output_filename,
save_format,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param input_file_path:
:param new_width:
:param new_height:
:param output_filename:
:param save_format:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'imaging/resize'
qry = {
'newWidth': new_width,
'newHeight': new_height,
'format': save_format
}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
with open(input_file_path, 'rb') as payload:
response = requests.post(signed_uri,
data=payload,
headers={
'content-type':
'application/json',
'accept': 'application/json',
'x-aspose-client':
'PYTHONSDK/v1.0'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
save_format = 'zip' if save_format == 'html' else save_format
output_path = AsposeApp.output_path + Utils.get_filename(
input_file_path) + '.' + save_format
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
def update_tiff_properties(self,
bit_depth,
compression,
resolution_unit,
new_width,
new_height,
horizontal_resolution,
vertical_resolution,
output_path,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param bit_depth:
:param compression:
:param resolution_unit:
:param new_width:
:param new_height:
:param horizontal_resolution:
:param vertical_resolution:
:param output_path:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = Product.product_uri + 'storage/file/' + self.filename
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
file_content = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json'
},
stream=True)
str_uri = Product.product_uri + 'imaging/tiff'
qry = {
'compression': compression,
'resolutionUnit': resolution_unit,
'newWidth': new_width,
'newHeight': new_height,
'horizontalResolution': horizontal_resolution,
'verticalResolution': vertical_resolution,
'bitDepth': bit_depth,
'outputPath': output_path
}
str_uri = Utils.build_uri(str_uri, qry)
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.post(signed_uri,
file_content,
headers={
'content-type': 'application/json',
'accept': 'application/json'
},
stream=True)
response.raise_for_status()
except requests.HTTPError as e:
print e
print response.content
exit(1)
validate_output = Utils.validate_result(response)
if not validate_output:
output_path = AsposeApp.output_path + Utils.get_filename(
self.filename) + '_updated.tiff'
Utils.save_file(response, output_path)
return output_path
else:
return validate_output
