def read_from_url(self, url, symbology=None, remote_folder='', storage_type='Aspose', storage_name=None):
"""
Read a Barcode
:param url:
:param symbology:
: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 url:
raise ValueError("url not specified")
str_uri = self.base_uri + '/' + self.filename + '/recognize?url=' + url
if symbology:
str_uri += '&type=' + symbology
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}).json()
return response['Barcodes'] if response['Code'] == 200 else False
def read_from_local_image(local_image, symbology):
"""
Read barcode from local image
:param local_image:
:param symbology:
:return: Text of barcode
"""
if not local_image:
raise ValueError("local_image not specified")
filename = os.path.basename(local_image)
str_uri = Product.product_uri + 'storage/file/' + filename
signed_uri = Utils.sign(str_uri)
Utils.upload_file_binary(local_image, signed_uri)
str_uri = Product.product_uri + 'barcode/' + filename + '/recognize'
if symbology:
str_uri += '?type=' + symbology
signed_uri = Utils.sign(str_uri)
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}).json()
return response['Barcodes'] if response['Code'] == 200 else False
def get_tiff_frame_properties(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) + '/properties'
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'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
return response
def get_placeholder_count(self, slide_number, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param slide_number:
: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 slide_number:
raise ValueError("slide_number not specified")
str_uri = self.base_uri + '/slides/' + str(slide_number) + '/placeholders'
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)
return len(response['Placeholders']['PlaceholderLinks']) if response['Placeholders']['PlaceholderLinks'] else 0
def change_slide_position(self, old_position, new_position, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param old_position:
:param new_position:
: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?OldPosition=' + str(old_position) + '&NewPosition=' + str(new_position)
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'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
return response
def delete_property(self, property_name, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param property_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:
"""
str_uri = self.base_uri + '/documentProperties/' + property_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.delete(signed_uri, 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)
return True if response['Code'] == 200 else False
def read_region(self, x, y, w, h, symbology=None, remote_folder='', storage_type='Aspose', storage_name=None):
"""
Read a Barcode
:param x:
:param y:
:param w:
:param h:
:param symbology:
: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 + '/' + self.filename + '/recognize?rectX=' + str(x) + '&rectY=' + str(y)
str_uri += '&rectWidth=' + str(w) + '&rectHeight=' + str(h)
if symbology:
str_uri += '&type=' + symbology
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}).json()
return response['Barcodes'] if response['Code'] == 200 else False
def add_link(self, link_data, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param link_data:
: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 + '/taskLinks'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
json_data = json.dumps(link_data)
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)
return response
def get_aspect_ratio(self, slide_no, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param slide_no:
: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_no)
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'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
return response['Slide']['Width'] / response['Slide']['Height'] if response['Code'] == 200 else False
def get_shape(self, slide_number, shape_index, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param slide_number:
:param shape_index:
: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 slide_number:
raise ValueError("slide_number not specified")
if not shape_index:
raise ValueError("shape_index not specified")
str_uri = self.base_uri + '/slides/' + str(slide_number) + '/shapes/' + str(shape_index)
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'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
return response['Shape']
def upload_file(self, local_file, remote_folder='', storage_type='Aspose', storage_name=None):
"""
Upload a local file to cloud storage.
:param local_file:
: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: returns True or False
"""
if not local_file:
raise ValueError("local_file not specified.")
filename = os.path.basename(local_file)
str_uri = self.str_uri_file
if remote_folder:
str_uri = str_uri + remote_folder + '/'
str_uri += filename
str_uri = Utils.append_storage(str_uri, '', storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = Utils.upload_file_binary(local_file, signed_uri).json()
if response['Status'] == 'OK':
return True
else:
return False
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 get_text_items(self, page_number, remote_folder='', storage_type='Aspose', storage_name=None):
"""
Get text items from given page number
:param page_number:
: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 + '/pages/' + str(page_number) + '/textitems'
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)
return response['TextItems']['List'] if response['TextItems']['List'] else False
def add_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:
"""
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.post(signed_uri, None, 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)
return response
def merge_documents(merged_filename, source_files, remote_folder='', storage_type='Aspose', storage_name=None):
"""
Merge multiple pdf files
:param merged_filename:
:param source_files:
: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:
"""
json_data = json.dumps({'List': source_files})
str_uri = Product.product_uri + 'pdf/' + merged_filename + '/merge'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.put(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)
return True if response['Status'] == 'OK' else False
def set_property(self, property_name, property_value, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param property_name:
:param property_value:
: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 + '/properties/' + property_name
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
json_data = json.dumps({'Value': property_value})
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.put(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)
return response['EmailProperty']['Value']
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 add_custom_property(self, properties_list, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param properties_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:
"""
json_data = json.dumps(properties_list)
str_uri = self.base_uri + '/documentProperties'
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, 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)
return response
def get_outline_codes(self, remote_folder='', storage_type='Aspose', storage_name=None):
"""
: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 + '/outlineCodes'
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)
return response['OutlineCodes']
def merge_presentations(self, presentation_list, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param presentation_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 + '/merge'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
json_data = json.dumps(presentation_list)
response = None
try:
response = requests.put(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)
return response['Document'] if response['Code'] == 200 else False
def add_task(self, task_name, before_task_id, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param task_name:
:param before_task_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 + '/tasks'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
qry = {'taskName': task_name, 'beforeTaskId': before_task_id}
str_uri = Utils.build_uri(str_uri, qry)
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)
return response['TaskItem']
def get_all_text_items(self, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param slide_number:
: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 + '/textItems'
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'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
return response['TextItems']['Items'] if response['TextItems']['Items'] else False
def append_tiff(self, append_file, remote_folder='', storage_type='Aspose', storage_name=None):
"""
: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 = Product.product_uri + 'imaging/tiff/' + self.filename + '/appendTiff'
qry = {'appendFile': append_file}
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'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
return response
def split_presentation(self, from_slide, to_slide, destination=None, save_format=None, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param from_slide:
:param to_slide:
:param destination:
:param save_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 + '/split'
qry_str = {'from': from_slide, 'to': to_slide}
if(destination):
qry_str['destFolder'] = destination
if(save_format):
qry_str['format'] = save_format
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.post(signed_uri, None, 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)
return response
def delete_extended_attribute(self, attribute_id, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param attribute_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 + '/extendedAttributes/' + attribute_id
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.delete(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)
return response
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 generate(self, code_text, symbology='QR', image_format='png', x_res=None, y_res=None, x_dim=None,
y_dim=None, extra_params=None, remote_folder='', storage_type='Aspose', storage_name=None):
"""
Generate Barcode
:param code_text:
:param symbology:
:param image_format:
:param x_res:
:param y_res:
:param x_dim:
:param y_dim:
:param extra_params:
: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 code_text:
raise ValueError("code_text not specified.")
if symbology == '':
raise ValueError("symbology can not be empty.")
if image_format == '':
raise ValueError("image_format can not be empty.")
str_uri = self.base_uri + '/generate'
qry_str = {'text': code_text, 'type': symbology, 'format': image_format}
if x_res:
qry_str['resolutionX'] = x_res
if y_res:
qry_str['resolutionY'] = y_res
if x_dim:
qry_str['dimensionX'] = x_dim
if y_dim:
qry_str['dimensionsY'] = y_dim
if extra_params:
qry_str.update(extra_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 = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json'
}, stream=True)
return response
def get_disc_usage(self, storage_type='Aspose', storage_name=None):
"""
Get the disc usage details of specified storage
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return: list with disc usage details
"""
str_uri = Utils.append_storage(self.str_uri_disc, '', storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = requests.get(signed_uri, headers={
'content-type': 'application/json', 'accept': 'application/json', 'x-aspose-client' : 'PYTHONSDK/v1.0'
}).json()
return response['DiscUsage']
def create_pdf(self, template_file, source_format, stream_out=False, output_filename=None,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
Create a pdf file from any supported format file e.g. html,xml,jpeg,svg,tiff
:param template_file:
:param source_format:
: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 template_file:
raise ValueError("template_file not specified")
if not source_format:
raise ValueError("source_format not specified")
save_format = 'pdf'
str_uri = self.base_uri + '?templateFile=' + template_file + '&templateType=' + source_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.put(signed_uri, None, 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)
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
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 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_disc_usage(self, storage_type='Aspose', storage_name=None):
"""
Get the disc usage details of specified storage
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return: list with disc usage details
"""
str_uri = Utils.append_storage(self.str_uri_disc, '', storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
}).json()
return response['DiscUsage']
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 add_resource(self,
resource_name,
after_resource_id,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param resource_name:
:param after_resource_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 + '/resources'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
qry = {
'resourceName': resource_name,
'afterResourceId': after_resource_id
}
str_uri = Utils.build_uri(str_uri, qry)
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)
return response['ResourceItem']
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_gif_properties(self,
bg_color_index,
px_aspect_ratio,
interlaced,
output_path,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param bg_color_index:
:param px_aspect_ratio:
:param interlaced:
:param output_path:
:param remote_folder:
:param storage_type:
:param storage_name:
:return:
"""
str_uri = self.base_uri + '/gif'
qry = {
'backgroundColorIndex': bg_color_index,
'pixelAspectRatio': px_aspect_ratio,
'interlaced': interlaced,
'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.gif'
Utils.save_file(response, output_path)
return output_path
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 convert_local_file(input_file,
save_format,
stream_out=False,
output_filename=None):
"""
Convert a local pdf file to any supported format
: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 + 'pdf/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)
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
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 merge_documents(merged_filename,
source_files,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
Merge multiple pdf files
:param merged_filename:
:param source_files:
: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:
"""
json_data = json.dumps({'List': source_files})
str_uri = Product.product_uri + 'pdf/' + merged_filename + '/merge'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.put(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)
return True if response['Status'] == 'OK' else False
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 read_region(self,
x,
y,
w,
h,
symbology=None,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
Read a Barcode
:param x:
:param y:
:param w:
:param h:
:param symbology:
: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 + '/' + self.filename + '/recognize?rectX=' + str(
x) + '&rectY=' + str(y)
str_uri += '&rectWidth=' + str(w) + '&rectHeight=' + str(h)
if symbology:
str_uri += '&type=' + symbology
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
signed_uri = Utils.sign(str_uri)
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
}).json()
return response['Barcodes'] if response['Code'] == 200 else False
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 set_property(self,
property_name,
property_value,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param property_name:
:param property_value:
: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 + '/properties/' + property_name
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
json_data = json.dumps({'Value': property_value})
signed_uri = Utils.sign(str_uri)
response = None
try:
response = requests.put(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)
return response['EmailProperty']['Value']
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_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 get_image_count(self,
page_number,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
Count images on a given page
:param page_number:
: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 page_number:
raise ValueError("page_number not specified")
str_uri = self.base_uri + '/pages/' + str(page_number) + '/images'
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)
return len(
response['Images']['List']) if response['Images']['List'] else 0
def get_text(self,
page_number,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
Get text from give page number
:param page_number:
: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 + '/pages/' + str(page_number) + '/textitems'
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)
output_text = ''
for item in response['TextItems']['List']:
output_text += item['Text']
return output_text
def file_exists(self, filename, storage_type='Aspose', storage_name=None):
"""
Check if a file already exist on specified storage.
:param filename:
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return: True or False
"""
if not filename:
raise ValueError("filename not specified.")
str_uri = self.str_uri_exist + filename
str_uri = Utils.append_storage(str_uri, '', storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
}).json()
return response['FileExist']['IsExist']
def delete_file(self, filename, storage_type='Aspose', storage_name=None):
"""
Delete a file from specified storage.
:param filename:
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return: True or False
"""
if not filename:
raise ValueError("filename not specified.")
str_uri = self.str_uri_file + filename
str_uri = Utils.append_storage(str_uri, '', storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = requests.delete(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
}).json()
return True if response['Code'] == 200 else False
def replace_text(self, old_text, new_text, match_case=False, match_whole_word=False,
remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param old_text:
:param new_text:
:param match_case:
:param match_whole_word:
: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,
'IsMatchCase': match_case, 'IsMatchWholeWord': match_whole_word})
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 add_link(self,
link_data,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
:param link_data:
: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 + '/taskLinks'
str_uri = Utils.append_storage(str_uri, remote_folder, storage_type,
storage_name)
json_data = json.dumps(link_data)
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)
return response
def get_document_info(self, remote_folder='', storage_type='Aspose', storage_name=None):
"""
: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 = Utils.append_storage(self.base_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)
return response['Document']
def update_bookmark(self, bookmark_name, bookmark_text, remote_folder='', storage_type='Aspose', storage_name=None):
"""
:param bookmark_name:
:param bookmark_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:
"""
if not bookmark_name:
raise ValueError("bookmark_name not specified")
if not bookmark_text:
raise ValueError("bookmark_text not specified")
post_data = {'Text': bookmark_text}
str_uri = self.base_uri + '/bookmarks/' + bookmark_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.post(signed_uri, post_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)
return True if response['Code'] == 200 else False
def append_tiff(self,
append_file,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
: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 = Product.product_uri + 'imaging/tiff/' + self.filename + '/appendTiff'
qry = {'appendFile': append_file}
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'
})
response.raise_for_status()
response = response.json()
except requests.HTTPError as e:
print e
print response.content
exit(1)
return response
def get_files(self,
remote_folder='',
storage_type='Aspose',
storage_name=None):
"""
Download the file list of specified folder
: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: list of files
"""
str_uri = self.str_uri_folder + remote_folder
str_uri = str_uri[:-1] if str_uri[-1] == '/' else str_uri
str_uri = Utils.append_storage(str_uri, '', storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
}).json()
return response['Files']
def get_file(self, filename, storage_type='Aspose', storage_name=None):
"""
Download the file to your local storage from remote storage
:param filename:
:param storage_type: type of storage e.g Aspose, S3
:param storage_name: name of storage e.g. MyAmazonS3
:return: returns file stream
"""
if not filename:
raise ValueError("filename not specified.")
str_uri = self.str_uri_file + filename
str_uri = Utils.append_storage(str_uri, '', storage_type, storage_name)
signed_uri = Utils.sign(str_uri)
response = requests.get(signed_uri,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
},
stream=True)
return response
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 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 extract_from_url(url):
"""
Extract text from image using url
:param url:
:return: Text
"""
str_uri = Product.product_uri + 'ocr/recognize?url=' + url
signed_uri = Utils.sign(str_uri)
response = requests.post(signed_uri,
None,
headers={
'content-type': 'application/json',
'accept': 'application/json',
'x-aspose-client': 'PYTHONSDK/v1.0'
}).json()
return response['Text'] if response['Code'] == 200 else False
