def test_convert_from_storage(self):
""" Convert from storage example test """
config = self.imaging_api.api_client.configuration
imaging_api = ImagingApi(config.api_key['client_secret'],
config.api_key['client_id'], config.host,
config.api_version)
try:
# upload local image to storage
result = imaging_api.upload_file(
requests.UploadFileRequest(
'ExampleFolderPython/inputImage.png',
os.path.join(self._local_test_folder, 'test.png'),
storage_name=self.test_storage))
# inspect result.Errors list if there were any
# inspect result.Uploaded list for uploaded file names
# convert image from storage to JPEG
converted_image = imaging_api.convert_image(
requests.ConvertImageRequest('inputImage.png',
'jpg',
'ExampleFolderPython',
storage=self.test_storage))
# process resulting image
# for example, save it to storage
result = imaging_api.upload_file(
requests.UploadFileRequest(
'ExampleFolderPython/resultImage.jpg',
converted_image,
storage_name=self.test_storage))
# inspect result.Errors list if there were any
# inspect result.Uploaded list for uploaded file names
finally:
# remove files from storage
imaging_api.delete_file(
requests.DeleteFileRequest(
'ExampleFolderPython/inputImage.png',
storage_name=self.test_storage))
imaging_api.delete_file(
requests.DeleteFileRequest(
'ExampleFolderPython/resultImage.jpg',
storage_name=self.test_storage))
def test_convert_from_stream_example(self):
""" Convert from stream example """
config = self.imaging_api.api_client.configuration
imaging_api = ImagingApi(config.api_key['client_secret'],
config.api_key['client_id'], config.host,
config.api_version)
remote_result_image = 'ExampleFolderPython' + '/' + 'resultImage.jpg'
try:
# get local image stream
local_input_image = os.path.join(self._local_test_folder,
'test.png')
# convert image from request stream to JPEG and save it to storage
# please, use outPath parameter for saving the result to storage
imaging_api.create_converted_image(
requests.CreateConvertedImageRequest(
local_input_image,
'jpg',
remote_result_image,
storage=self.test_storage))
# download saved image from storage
saved_file = imaging_api.download_file(
requests.DownloadFileRequest(remote_result_image,
storage_name=self.test_storage))
# TODO: process resulting image from storage
# convert image from request stream to JPEG and read it from
# resulting stream
image_stream = imaging_api.create_converted_image(
requests.CreateConvertedImageRequest(
local_input_image, "jpg", storage=self.test_storage))
# TODO: process resulting image from response stream
finally:
imaging_api.delete_file(
requests.DeleteFileRequest(remote_result_image,
storage_name=self.test_storage))
def __object_detection_request_tester(self,
test_method_name,
save_result_to_storage,
parameters_line,
input_file_name,
result_file_name,
invoke_request_action,
response_tester,
folder,
storage=None):
if not storage:
storage = self.default_storage
print(test_method_name)
if not self._check_input_file_exists(input_file_name):
raise ValueError(
"Input file {0} doesn't exist in the specified storage folder: {1}. Please, upload it first."
.format(input_file_name, folder))
if not self.imaging_api.object_exists(
requests.ObjectExistsRequest(
os.path.join(folder, input_file_name), storage)).exists:
self.imaging_api.copy_file(
requests.CopyFileRequest(
os.path.join(self.original_data_folder, input_file_name),
os.path.join(folder, input_file_name), storage, storage))
passed = False
out_path = str(None)
try:
print(parameters_line)
if save_result_to_storage:
out_path = os.path.join(folder, result_file_name)
if self.imaging_api.object_exists(
requests.ObjectExistsRequest(out_path,
storage)).exists:
self.imaging_api.delete_file(
requests.DeleteFileRequest(out_path, storage))
response = invoke_request_action()
if save_result_to_storage:
result_info = self._get_storage_file_info(
folder, result_file_name, storage)
if not result_info:
raise ValueError(
"Result file {0} doesn't exist in the specified storage folder: {1}. "
"Result isn't present in the storage by an unknown reason."
.format(result_file_name, folder))
response_tester(response)
passed = True
except Exception as e:
self.failed_any_test = True
print(str(e))
raise
finally:
if passed and save_result_to_storage and self.remove_result \
and self.imaging_api.object_exists(
requests.ObjectExistsRequest(out_path, storage)).exists:
self.imaging_api.delete_file(
requests.DeleteFileRequest(out_path, storage))
print("Test passed: " + str(passed) + os.linesep)
def __request_tester(self,
test_method_name,
save_result_to_storage,
parameters_line,
input_file_name,
result_file_name,
invoke_request_action,
properties_tester,
folder,
storage=None):
if not storage:
storage = self.default_storage
print(test_method_name)
self._copy_input_file_to_test_folder(input_file_name, folder, storage)
passed = False
out_path = str(None)
try:
print(parameters_line)
if save_result_to_storage:
out_path = os.path.join(folder, result_file_name)
if self.imaging_api.object_exists(
requests.ObjectExistsRequest(out_path,
storage)).exists:
self.imaging_api.delete_file(
requests.DeleteFileRequest(out_path, storage))
result_properties = None
response = invoke_request_action()
if save_result_to_storage:
result_info = self._get_storage_file_info(
folder, result_file_name, storage)
if not result_info:
raise ValueError(
"Result file {0} doesn't exist in the specified storage folder: {1}. "
"Result isn't present in the storage by an unknown reason."
.format(result_file_name, folder))
if not (str.endswith(result_file_name, '.pdf')
or str.endswith(result_file_name, '.pdf;')):
result_properties = self.imaging_api.get_image_properties(
requests.GetImagePropertiesRequest(
result_file_name, folder, storage))
self.assertIsNotNone(result_properties)
elif not (str.endswith(str(response), '.pdf')
or str.endswith(str(response), '.pdf;')):
result_properties = self.imaging_api.extract_image_properties(
requests.ExtractImagePropertiesRequest(response))
self.assertIsNotNone(result_properties)
original_properties = self.imaging_api.get_image_properties(
requests.GetImagePropertiesRequest(input_file_name, folder,
storage))
self.assertIsNotNone(original_properties)
if result_properties:
properties_tester(original_properties, result_properties,
response)
passed = True
except Exception as e:
self.failed_any_test = True
print(str(e))
raise
finally:
if passed and save_result_to_storage and self.remove_result \
and self.imaging_api.object_exists(
requests.ObjectExistsRequest(out_path, storage)).exists:
self.imaging_api.delete_file(
requests.DeleteFileRequest(out_path, storage))
print("Test passed: " + str(passed) + os.linesep)
def test_upload_file(self):
folder = self.temp_folder + '/Storage'
file = 'Storage.txt'
try:
if self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder, self.test_storage)).exists:
self.imaging_api.delete_folder(
requests.DeleteFolderRequest(
folder, self.test_storage, True))
self.assertFalse(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder, self.test_storage)).exists)
original_file = self.imaging_api.download_file(
requests.DownloadFileRequest(
self.original_data_folder + '/' + file,
self.test_storage))
result = self.imaging_api.upload_file(
requests.UploadFileRequest(
folder + '/' + file,
original_file,
self.test_storage))
self.assertIsNotNone(result)
self.assertTrue(not result.errors or len(result) == 0)
self.assertIsNotNone(result.uploaded)
self.assertEqual(1, len(result.uploaded))
self.assertEqual(file, result.uploaded[0])
exist_response = self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder + '/' + file, self.test_storage))
self.assertIsNotNone(exist_response)
self.assertFalse(exist_response.is_folder)
self.assertTrue(exist_response.exists)
original_file_info = next(
x for x in self.imaging_api.get_files_list(
requests.GetFilesListRequest(
self.original_data_folder,
self.test_storage)).value if x.name == file)
uploaded_file_info = next(
x for x in self.imaging_api.get_files_list(
requests.GetFilesListRequest(
folder, self.test_storage)).value if x.name == file)
self.assertEqual(original_file_info.size, uploaded_file_info.size)
original_file = self.imaging_api.download_file(
requests.DownloadFileRequest(
self.original_data_folder + '/' + file,
self.test_storage))
uploaded_file = self.imaging_api.download_file(
requests.DownloadFileRequest(
folder + '/' + file, self.test_storage))
with open(original_file, 'r') as original_reader, open(uploaded_file, 'r') as uploaded_reader:
original_string = original_reader.read()
copied_string = uploaded_reader.read()
self.assertEqual(len(original_string), len(copied_string))
self.assertEqual(len(original_string), original_file_info.size)
self.assertEqual(original_string, copied_string)
self.assertEqual(
original_string,
original_file_info.path.strip('/'))
self.assertEqual(
original_string.replace(
self.original_data_folder,
folder),
uploaded_file_info.path.strip('/'))
finally:
self.imaging_api.delete_file(
requests.DeleteFileRequest(
folder + '/' + file,
self.test_storage))
self.assertFalse(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder + '/' + file,
self.test_storage)).exists)
if self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder, self.test_storage)).exists:
self.imaging_api.delete_folder(
requests.DeleteFolderRequest(
folder, self.test_storage, True))
self.assertFalse(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder, self.test_storage)).exists)
def test_move_file(self):
folder = self.temp_folder + '/Storage'
file = 'Storage.txt'
try:
if self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder, self.test_storage)).exists:
self.imaging_api.delete_folder(
requests.DeleteFolderRequest(
folder, self.test_storage, True))
self.assertFalse(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder, self.test_storage)).exists)
self.imaging_api.copy_file(
requests.CopyFileRequest(
self.original_data_folder + '/' + file,
folder + '/' + file + '.copied',
self.test_storage,
self.test_storage))
exist_response = self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder + '/' + file + '.copied',
self.test_storage))
self.assertIsNotNone(exist_response)
self.assertFalse(exist_response.is_folder)
self.assertTrue(exist_response.exists)
self.imaging_api.move_file(
requests.MoveFileRequest(
folder + '/' + file + '.copied',
folder + '/' + file,
self.test_storage,
self.test_storage))
self.assertFalse(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder + '/' + file + '.copied',
self.test_storage)).exists)
exist_response = self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder + '/' + file, self.test_storage))
self.assertIsNotNone(exist_response)
self.assertFalse(exist_response.is_folder)
self.assertTrue(exist_response.exists)
original_file_info = next(
x for x in self.imaging_api.get_files_list(
requests.GetFilesListRequest(
self.original_data_folder,
self.test_storage)).value if x.name == file)
moved_file_info = next(
x for x in self.imaging_api.get_files_list(
requests.GetFilesListRequest(
folder, self.test_storage)).value if x.name == file)
self.assertEqual(original_file_info.size, moved_file_info.size)
with open(self.imaging_api.download_file(
requests.DownloadFileRequest(self.original_data_folder + '/' + file,
self.test_storage)), 'r') as original_file, \
open(self.imaging_api.download_file(requests.DownloadFileRequest(folder + '/' + file,
self.test_storage)),
'r') as moved_file:
original_string = original_file.read()
moved_string = moved_file.read()
self.assertEqual(len(original_string), len(moved_string))
self.assertEqual(len(original_string), original_file_info.size)
self.assertEqual(original_string, moved_string)
self.assertEqual(
original_string,
original_file_info.path.strip('/'))
self.assertEqual(
original_string.replace(
self.original_data_folder,
folder),
moved_file_info.path.strip('/'))
finally:
self.imaging_api.delete_file(
requests.DeleteFileRequest(
folder + '/' + file,
self.test_storage))
self.assertFalse(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder + '/' + file,
self.test_storage)).exists)
if self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder, self.test_storage)).exists:
self.imaging_api.delete_folder(
requests.DeleteFolderRequest(
folder, self.test_storage, True))
self.assertFalse(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder, self.test_storage)).exists)
def test_file_versions_delete(self):
if self.imaging_api.api_client.configuration.on_premise:
return
folder = self.temp_folder + '/Storage'
file1 = 'Storage.txt'
file2 = 'Folder1/Folder1.txt'
try:
if self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder, self.test_storage)).exists:
self.imaging_api.delete_folder(
requests.DeleteFolderRequest(
folder, self.test_storage, True))
self.assertFalse(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder, self.test_storage)).exists)
self.imaging_api.copy_file(
requests.CopyFileRequest(
self.original_data_folder + '/' + file1,
folder + '/' + file1,
self.test_storage,
self.test_storage))
self.imaging_api.copy_file(
requests.CopyFileRequest(
self.original_data_folder + '/' + file2,
folder + '/' + file1,
self.test_storage,
self.test_storage))
versions = self.imaging_api.get_file_versions(
requests.GetFileVersionsRequest(
folder + '/' + file1, self.test_storage)).value
recent_version = next(x for x in versions if x.is_latest is True)
old_version = next(x for x in versions if x.is_latest is not True)
self.assertTrue(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder + '/' + file1,
self.test_storage,
recent_version.version_id)).exists)
self.assertTrue(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder + '/' + file1,
self.test_storage,
old_version.version_id)).exists)
self.imaging_api.delete_file(
requests.DeleteFileRequest(
folder + '/' + file1,
self.test_storage,
recent_version.version_id))
versions = self.imaging_api.get_file_versions(
requests.GetFileVersionsRequest(
folder + '/' + file1, self.test_storage)).value
self.assertFalse(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder + '/' + file1,
self.test_storage,
recent_version.version_id)).exists)
self.assertTrue(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder + '/' + file1,
self.test_storage,
old_version.version_id)).exists)
self.assertEqual(1, len(versions))
self.assertEqual(old_version.size, versions[0].size)
self.imaging_api.delete_file(
requests.DeleteFileRequest(
folder + '/' + file1,
self.test_storage,
old_version.version_id))
self.assertFalse(
self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder + '/' + file1,
self.test_storage)).exists)
finally:
if self.imaging_api.object_exists(
requests.ObjectExistsRequest(
folder, self.test_storage)).exists:
self.imaging_api.delete_folder(
requests.DeleteFolderRequest(
folder, self.test_storage, True))