def __init__(self, configuration):
api_client = ApiClient(configuration)
self.auth = Auth(configuration, api_client)
self.api_client = api_client
self.configuration = configuration
class FileApi(object):
"""
GroupDocs.Conversion Cloud API
:param configuration: API configuration
"""
def __init__(self, configuration):
api_client = ApiClient(configuration)
self.auth = Auth(configuration, api_client)
self.api_client = api_client
self.configuration = configuration
def close(self): # noqa: E501
"""
Closes thread pool. This method should be called when
methods are executed asynchronously (is_async=True is passed as parameter)
and this instance of FileApi is not going to be used any more.
"""
if self.api_client is not None:
if(self.api_client.pool is not None):
self.api_client.pool.close()
self.api_client.pool.join()
self.api_client.pool = None
@classmethod
def from_keys(cls, app_sid, app_key):
"""
Initializes new instance of FileApi with API keys
:param app_sid Application identifier (App SID)
:param app_key Application private key (App Key)
"""
configuration = Configuration(app_sid, app_key)
return FileApi(configuration)
@classmethod
def from_config(cls, configuration):
"""
Initializes new instance of FileApi with configuration options
:param configuration API configuration
"""
return FileApi(configuration)
def copy_file(self, request,**kwargs): # noqa: E501
"""Copy file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param str src_path: Source file path e.g. '/folder/file.ext' (required)
:param str dest_path: Destination file path (required)
:param str src_storage_name: Source storage name
:param str dest_storage_name: Destination storage name
:param str version_id: File version ID to copy
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._copy_file_with_http_info(request, **kwargs) # noqa: E501
self._copy_file_with_http_info(request, **kwargs) # noqa: E501
def _copy_file_with_http_info(self, request, **kwargs): # noqa: E501
"""Copy file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param CopyFileRequest request object with parameters
:return: None
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method copy_file" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'src_path' is set
if request.src_path is None:
raise ValueError("Missing the required parameter `src_path` when calling `copy_file`") # noqa: E501
# verify the required parameter 'dest_path' is set
if request.dest_path is None:
raise ValueError("Missing the required parameter `dest_path` when calling `copy_file`") # noqa: E501
collection_formats = {}
path = '/conversion/storage/file/copy/{srcPath}'
path_params = {}
if request.src_path is not None:
path_params[self.__downcase_first_letter('srcPath')] = request.src_path # noqa: E501
query_params = []
if self.__downcase_first_letter('destPath') in path:
path = path.replace('{' + self.__downcase_first_letter('destPath' + '}'), request.dest_path if request.dest_path is not None else '')
else:
if request.dest_path is not None:
query_params.append((self.__downcase_first_letter('destPath'), request.dest_path)) # noqa: E501
if self.__downcase_first_letter('srcStorageName') in path:
path = path.replace('{' + self.__downcase_first_letter('srcStorageName' + '}'), request.src_storage_name if request.src_storage_name is not None else '')
else:
if request.src_storage_name is not None:
query_params.append((self.__downcase_first_letter('srcStorageName'), request.src_storage_name)) # noqa: E501
if self.__downcase_first_letter('destStorageName') in path:
path = path.replace('{' + self.__downcase_first_letter('destStorageName' + '}'), request.dest_storage_name if request.dest_storage_name is not None else '')
else:
if request.dest_storage_name is not None:
query_params.append((self.__downcase_first_letter('destStorageName'), request.dest_storage_name)) # noqa: E501
if self.__downcase_first_letter('versionId') in path:
path = path.replace('{' + self.__downcase_first_letter('versionId' + '}'), request.version_id if request.version_id is not None else '')
else:
if request.version_id is not None:
query_params.append((self.__downcase_first_letter('versionId'), request.version_id)) # noqa: E501
header_params = {}
form_params = []
local_var_files = []
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path':path,
'method':'PUT',
'path_params':path_params,
'query_params':query_params,
'header_params':header_params,
'body':body_params,
'post_params':form_params,
'files':local_var_files,
'response_type':None, # noqa: E501
'auth_settings':self.auth.get_auth_settings(),
'is_async':params.get('is_async'),
'_return_http_data_only':params.get('_return_http_data_only'),
'_preload_content':params.get('_preload_content', True),
'_request_timeout':params.get('_request_timeout'),
'collection_formats':collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def delete_file(self, request,**kwargs): # noqa: E501
"""Delete file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param str path: File path e.g. '/folder/file.ext' (required)
:param str storage_name: Storage name
:param str version_id: File version ID to delete
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._delete_file_with_http_info(request, **kwargs) # noqa: E501
self._delete_file_with_http_info(request, **kwargs) # noqa: E501
def _delete_file_with_http_info(self, request, **kwargs): # noqa: E501
"""Delete file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param DeleteFileRequest request object with parameters
:return: None
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method delete_file" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'path' is set
if request.path is None:
raise ValueError("Missing the required parameter `path` when calling `delete_file`") # noqa: E501
collection_formats = {}
path = '/conversion/storage/file/{path}'
path_params = {}
if request.path is not None:
path_params[self.__downcase_first_letter('path')] = request.path # noqa: E501
query_params = []
if self.__downcase_first_letter('storageName') in path:
path = path.replace('{' + self.__downcase_first_letter('storageName' + '}'), request.storage_name if request.storage_name is not None else '')
else:
if request.storage_name is not None:
query_params.append((self.__downcase_first_letter('storageName'), request.storage_name)) # noqa: E501
if self.__downcase_first_letter('versionId') in path:
path = path.replace('{' + self.__downcase_first_letter('versionId' + '}'), request.version_id if request.version_id is not None else '')
else:
if request.version_id is not None:
query_params.append((self.__downcase_first_letter('versionId'), request.version_id)) # noqa: E501
header_params = {}
form_params = []
local_var_files = []
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path':path,
'method':'DELETE',
'path_params':path_params,
'query_params':query_params,
'header_params':header_params,
'body':body_params,
'post_params':form_params,
'files':local_var_files,
'response_type':None, # noqa: E501
'auth_settings':self.auth.get_auth_settings(),
'is_async':params.get('is_async'),
'_return_http_data_only':params.get('_return_http_data_only'),
'_preload_content':params.get('_preload_content', True),
'_request_timeout':params.get('_request_timeout'),
'collection_formats':collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def download_file(self, request,**kwargs): # noqa: E501
"""Download file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param str path: File path e.g. '/folder/file.ext' (required)
:param str storage_name: Storage name
:param str version_id: File version ID to download
:return: file
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._download_file_with_http_info(request, **kwargs) # noqa: E501
(data) = self._download_file_with_http_info(request, **kwargs) # noqa: E501
return data
def _download_file_with_http_info(self, request, **kwargs): # noqa: E501
"""Download file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param DownloadFileRequest request object with parameters
:return: file
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method download_file" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'path' is set
if request.path is None:
raise ValueError("Missing the required parameter `path` when calling `download_file`") # noqa: E501
collection_formats = {}
path = '/conversion/storage/file/{path}'
path_params = {}
if request.path is not None:
path_params[self.__downcase_first_letter('path')] = request.path # noqa: E501
query_params = []
if self.__downcase_first_letter('storageName') in path:
path = path.replace('{' + self.__downcase_first_letter('storageName' + '}'), request.storage_name if request.storage_name is not None else '')
else:
if request.storage_name is not None:
query_params.append((self.__downcase_first_letter('storageName'), request.storage_name)) # noqa: E501
if self.__downcase_first_letter('versionId') in path:
path = path.replace('{' + self.__downcase_first_letter('versionId' + '}'), request.version_id if request.version_id is not None else '')
else:
if request.version_id is not None:
query_params.append((self.__downcase_first_letter('versionId'), request.version_id)) # noqa: E501
header_params = {}
form_params = []
local_var_files = []
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['multipart/form-data']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path':path,
'method':'GET',
'path_params':path_params,
'query_params':query_params,
'header_params':header_params,
'body':body_params,
'post_params':form_params,
'files':local_var_files,
'response_type':'file', # noqa: E501
'auth_settings':self.auth.get_auth_settings(),
'is_async':params.get('is_async'),
'_return_http_data_only':params.get('_return_http_data_only'),
'_preload_content':params.get('_preload_content', True),
'_request_timeout':params.get('_request_timeout'),
'collection_formats':collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def move_file(self, request,**kwargs): # noqa: E501
"""Move file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param str src_path: Source file path e.g. '/src.ext' (required)
:param str dest_path: Destination file path e.g. '/dest.ext' (required)
:param str src_storage_name: Source storage name
:param str dest_storage_name: Destination storage name
:param str version_id: File version ID to move
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._move_file_with_http_info(request, **kwargs) # noqa: E501
self._move_file_with_http_info(request, **kwargs) # noqa: E501
def _move_file_with_http_info(self, request, **kwargs): # noqa: E501
"""Move file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param MoveFileRequest request object with parameters
:return: None
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method move_file" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'src_path' is set
if request.src_path is None:
raise ValueError("Missing the required parameter `src_path` when calling `move_file`") # noqa: E501
# verify the required parameter 'dest_path' is set
if request.dest_path is None:
raise ValueError("Missing the required parameter `dest_path` when calling `move_file`") # noqa: E501
collection_formats = {}
path = '/conversion/storage/file/move/{srcPath}'
path_params = {}
if request.src_path is not None:
path_params[self.__downcase_first_letter('srcPath')] = request.src_path # noqa: E501
query_params = []
if self.__downcase_first_letter('destPath') in path:
path = path.replace('{' + self.__downcase_first_letter('destPath' + '}'), request.dest_path if request.dest_path is not None else '')
else:
if request.dest_path is not None:
query_params.append((self.__downcase_first_letter('destPath'), request.dest_path)) # noqa: E501
if self.__downcase_first_letter('srcStorageName') in path:
path = path.replace('{' + self.__downcase_first_letter('srcStorageName' + '}'), request.src_storage_name if request.src_storage_name is not None else '')
else:
if request.src_storage_name is not None:
query_params.append((self.__downcase_first_letter('srcStorageName'), request.src_storage_name)) # noqa: E501
if self.__downcase_first_letter('destStorageName') in path:
path = path.replace('{' + self.__downcase_first_letter('destStorageName' + '}'), request.dest_storage_name if request.dest_storage_name is not None else '')
else:
if request.dest_storage_name is not None:
query_params.append((self.__downcase_first_letter('destStorageName'), request.dest_storage_name)) # noqa: E501
if self.__downcase_first_letter('versionId') in path:
path = path.replace('{' + self.__downcase_first_letter('versionId' + '}'), request.version_id if request.version_id is not None else '')
else:
if request.version_id is not None:
query_params.append((self.__downcase_first_letter('versionId'), request.version_id)) # noqa: E501
header_params = {}
form_params = []
local_var_files = []
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path':path,
'method':'PUT',
'path_params':path_params,
'query_params':query_params,
'header_params':header_params,
'body':body_params,
'post_params':form_params,
'files':local_var_files,
'response_type':None, # noqa: E501
'auth_settings':self.auth.get_auth_settings(),
'is_async':params.get('is_async'),
'_return_http_data_only':params.get('_return_http_data_only'),
'_preload_content':params.get('_preload_content', True),
'_request_timeout':params.get('_request_timeout'),
'collection_formats':collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def upload_file(self, request,**kwargs): # noqa: E501
"""Upload file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param str path: Path where to upload including filename and extension e.g. /file.ext or /Folder 1/file.ext If the content is multipart and path does not contains the file name it tries to get them from filename parameter from Content-Disposition header. (required)
:param file file: File to upload (required)
:param str storage_name: Storage name
:return: FilesUploadResult
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._upload_file_with_http_info(request, **kwargs) # noqa: E501
(data) = self._upload_file_with_http_info(request, **kwargs) # noqa: E501
return data
def _upload_file_with_http_info(self, request, **kwargs): # noqa: E501
"""Upload file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param UploadFileRequest request object with parameters
:return: FilesUploadResult
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method upload_file" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'path' is set
if request.path is None:
raise ValueError("Missing the required parameter `path` when calling `upload_file`") # noqa: E501
# verify the required parameter 'file' is set
if request.file is None:
raise ValueError("Missing the required parameter `file` when calling `upload_file`") # noqa: E501
collection_formats = {}
path = '/conversion/storage/file/{path}'
path_params = {}
if request.path is not None:
path_params[self.__downcase_first_letter('path')] = request.path # noqa: E501
query_params = []
if self.__downcase_first_letter('storageName') in path:
path = path.replace('{' + self.__downcase_first_letter('storageName' + '}'), request.storage_name if request.storage_name is not None else '')
else:
if request.storage_name is not None:
query_params.append((self.__downcase_first_letter('storageName'), request.storage_name)) # noqa: E501
header_params = {}
form_params = []
local_var_files = []
if request.file is not None:
local_var_files.append((self.__downcase_first_letter('File'), request.file)) # noqa: E501
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['multipart/form-data']) # noqa: E501
call_kwargs = {
'resource_path':path,
'method':'PUT',
'path_params':path_params,
'query_params':query_params,
'header_params':header_params,
'body':body_params,
'post_params':form_params,
'files':local_var_files,
'response_type':'FilesUploadResult', # noqa: E501
'auth_settings':self.auth.get_auth_settings(),
'is_async':params.get('is_async'),
'_return_http_data_only':params.get('_return_http_data_only'),
'_preload_content':params.get('_preload_content', True),
'_request_timeout':params.get('_request_timeout'),
'collection_formats':collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def __downcase_first_letter(self, s):
if len(s) == 0:
return str
else:
return s[0].lower() + s[1:]
class LicenseApi(object):
"""
GroupDocs.Conversion Cloud API
:param configuration: API configuration
"""
def __init__(self, configuration):
api_client = ApiClient(configuration)
self.auth = Auth(configuration, api_client)
self.api_client = api_client
self.configuration = configuration
def close(self): # noqa: E501
"""
Closes thread pool. This method should be called when
methods are executed asynchronously (is_async=True is passed as parameter)
and this instance of LicenseApi is not going to be used any more.
"""
if self.api_client is not None:
if (self.api_client.pool is not None):
self.api_client.pool.close()
self.api_client.pool.join()
self.api_client.pool = None
@classmethod
def from_keys(cls, app_sid, app_key):
"""
Initializes new instance of LicenseApi with API keys
:param app_sid Application identifier (App SID)
:param app_key Application private key (App Key)
"""
configuration = Configuration(app_sid, app_key)
return LicenseApi(configuration)
@classmethod
def from_config(cls, configuration):
"""
Initializes new instance of LicenseApi with configuration options
:param configuration API configuration
"""
return LicenseApi(configuration)
def get_consumption_credit(self, **kwargs): # noqa: E501
"""Get license consumption # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:return: ConsumptionResult
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._get_consumption_credit_with_http_info(
**kwargs) # noqa: E501
(data) = self._get_consumption_credit_with_http_info(
**kwargs) # noqa: E501
return data
def _get_consumption_credit_with_http_info(self, **kwargs): # noqa: E501
"""Get license consumption # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:return: ConsumptionResult
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError("Got an unexpected keyword argument '%s'"
" to method get_consumption_credit" % key)
params[key] = val
del params['kwargs']
collection_formats = {}
path = '/conversion/consumption'
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = []
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path': path,
'method': 'GET',
'path_params': path_params,
'query_params': query_params,
'header_params': header_params,
'body': body_params,
'post_params': form_params,
'files': local_var_files,
'response_type': 'ConsumptionResult', # noqa: E501
'auth_settings': self.auth.get_auth_settings(),
'is_async': params.get('is_async'),
'_return_http_data_only': params.get('_return_http_data_only'),
'_preload_content': params.get('_preload_content', True),
'_request_timeout': params.get('_request_timeout'),
'collection_formats': collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def __downcase_first_letter(self, s):
if len(s) == 0:
return str
else:
return s[0].lower() + s[1:]
class InfoApi(object):
"""
GroupDocs.Conversion Cloud API
:param configuration: API configuration
"""
def __init__(self, configuration):
api_client = ApiClient(configuration)
self.auth = Auth(configuration, api_client)
self.api_client = api_client
self.configuration = configuration
def close(self): # noqa: E501
"""
Closes thread pool. This method should be called when
methods are executed asynchronously (is_async=True is passed as parameter)
and this instance of InfoApi is not going to be used any more.
"""
if self.api_client is not None:
if (self.api_client.pool is not None):
self.api_client.pool.close()
self.api_client.pool.join()
self.api_client.pool = None
@classmethod
def from_keys(cls, app_sid, app_key):
"""
Initializes new instance of InfoApi with API keys
:param app_sid Application identifier (App SID)
:param app_key Application private key (App Key)
"""
configuration = Configuration(app_sid, app_key)
return InfoApi(configuration)
@classmethod
def from_config(cls, configuration):
"""
Initializes new instance of InfoApi with configuration options
:param configuration API configuration
"""
return InfoApi(configuration)
def get_document_metadata(self, request, **kwargs): # noqa: E501
"""Returns metadata for provided document # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param str file_path: Absolute path to a document in the storage
:param str storage_name: StorageName which contains the document
:return: DocumentMetadata
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._get_document_metadata_with_http_info(
request, **kwargs) # noqa: E501
(data) = self._get_document_metadata_with_http_info(
request, **kwargs) # noqa: E501
return data
def _get_document_metadata_with_http_info(self, request,
**kwargs): # noqa: E501
"""Returns metadata for provided document # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param GetDocumentMetadataRequest request object with parameters
:return: DocumentMetadata
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError("Got an unexpected keyword argument '%s'"
" to method get_document_metadata" % key)
params[key] = val
del params['kwargs']
collection_formats = {}
path = '/conversion/info'
path_params = {}
query_params = []
if self.__downcase_first_letter('FilePath') in path:
path = path.replace(
'{' + self.__downcase_first_letter('FilePath' + '}'),
request.file_path if request.file_path is not None else '')
else:
if request.file_path is not None:
query_params.append((self.__downcase_first_letter('FilePath'),
request.file_path)) # noqa: E501
if self.__downcase_first_letter('StorageName') in path:
path = path.replace(
'{' + self.__downcase_first_letter('StorageName' + '}'),
request.storage_name
if request.storage_name is not None else '')
else:
if request.storage_name is not None:
query_params.append(
(self.__downcase_first_letter('StorageName'),
request.storage_name)) # noqa: E501
header_params = {}
form_params = []
local_var_files = []
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path': path,
'method': 'GET',
'path_params': path_params,
'query_params': query_params,
'header_params': header_params,
'body': body_params,
'post_params': form_params,
'files': local_var_files,
'response_type': 'DocumentMetadata', # noqa: E501
'auth_settings': self.auth.get_auth_settings(),
'is_async': params.get('is_async'),
'_return_http_data_only': params.get('_return_http_data_only'),
'_preload_content': params.get('_preload_content', True),
'_request_timeout': params.get('_request_timeout'),
'collection_formats': collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def get_supported_conversion_types(self, request, **kwargs): # noqa: E501
"""Returns all supported conversion types # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param str file_path: Absolute path to a document in the storage
:param str storage_name: StorageName which contains the document
:param str format: If provided only supported conversions for specified format will be returned
:return: list[SupportedFormat]
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._get_supported_conversion_types_with_http_info(
request, **kwargs) # noqa: E501
(data) = self._get_supported_conversion_types_with_http_info(
request, **kwargs) # noqa: E501
return data
def _get_supported_conversion_types_with_http_info(self, request,
**kwargs): # noqa: E501
"""Returns all supported conversion types # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param GetSupportedConversionTypesRequest request object with parameters
:return: list[SupportedFormat]
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError("Got an unexpected keyword argument '%s'"
" to method get_supported_conversion_types" %
key)
params[key] = val
del params['kwargs']
collection_formats = {}
path = '/conversion/formats'
path_params = {}
query_params = []
if self.__downcase_first_letter('FilePath') in path:
path = path.replace(
'{' + self.__downcase_first_letter('FilePath' + '}'),
request.file_path if request.file_path is not None else '')
else:
if request.file_path is not None:
query_params.append((self.__downcase_first_letter('FilePath'),
request.file_path)) # noqa: E501
if self.__downcase_first_letter('StorageName') in path:
path = path.replace(
'{' + self.__downcase_first_letter('StorageName' + '}'),
request.storage_name
if request.storage_name is not None else '')
else:
if request.storage_name is not None:
query_params.append(
(self.__downcase_first_letter('StorageName'),
request.storage_name)) # noqa: E501
if self.__downcase_first_letter('format') in path:
path = path.replace(
'{' + self.__downcase_first_letter('format' + '}'),
request.format if request.format is not None else '')
else:
if request.format is not None:
query_params.append((self.__downcase_first_letter('format'),
request.format)) # noqa: E501
header_params = {}
form_params = []
local_var_files = []
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path': path,
'method': 'GET',
'path_params': path_params,
'query_params': query_params,
'header_params': header_params,
'body': body_params,
'post_params': form_params,
'files': local_var_files,
'response_type': 'list[SupportedFormat]', # noqa: E501
'auth_settings': self.auth.get_auth_settings(),
'is_async': params.get('is_async'),
'_return_http_data_only': params.get('_return_http_data_only'),
'_preload_content': params.get('_preload_content', True),
'_request_timeout': params.get('_request_timeout'),
'collection_formats': collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def __downcase_first_letter(self, s):
if len(s) == 0:
return str
else:
return s[0].lower() + s[1:]
class StorageApi(object):
"""
GroupDocs.Conversion Cloud API
:param configuration: API configuration
"""
def __init__(self, configuration):
api_client = ApiClient(configuration)
self.auth = Auth(configuration, api_client)
self.api_client = api_client
self.configuration = configuration
def close(self): # noqa: E501
"""
Closes thread pool. This method should be called when
methods are executed asynchronously (is_async=True is passed as parameter)
and this instance of StorageApi is not going to be used any more.
"""
if self.api_client is not None:
if(self.api_client.pool is not None):
self.api_client.pool.close()
self.api_client.pool.join()
self.api_client.pool = None
@classmethod
def from_keys(cls, app_sid, app_key):
"""
Initializes new instance of StorageApi with API keys
:param app_sid Application identifier (App SID)
:param app_key Application private key (App Key)
"""
configuration = Configuration(app_sid, app_key)
return StorageApi(configuration)
@classmethod
def from_config(cls, configuration):
"""
Initializes new instance of StorageApi with configuration options
:param configuration API configuration
"""
return StorageApi(configuration)
def get_disc_usage(self, request,**kwargs): # noqa: E501
"""Get disc usage # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param str storage_name: Storage name
:return: DiscUsage
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._get_disc_usage_with_http_info(request, **kwargs) # noqa: E501
(data) = self._get_disc_usage_with_http_info(request, **kwargs) # noqa: E501
return data
def _get_disc_usage_with_http_info(self, request, **kwargs): # noqa: E501
"""Get disc usage # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param GetDiscUsageRequest request object with parameters
:return: DiscUsage
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method get_disc_usage" % key
)
params[key] = val
del params['kwargs']
collection_formats = {}
path = '/conversion/storage/disc'
path_params = {}
query_params = []
if self.__downcase_first_letter('storageName') in path:
path = path.replace('{' + self.__downcase_first_letter('storageName' + '}'), request.storage_name if request.storage_name is not None else '')
else:
if request.storage_name is not None:
query_params.append((self.__downcase_first_letter('storageName'), request.storage_name)) # noqa: E501
header_params = {}
form_params = []
local_var_files = []
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path':path,
'method':'GET',
'path_params':path_params,
'query_params':query_params,
'header_params':header_params,
'body':body_params,
'post_params':form_params,
'files':local_var_files,
'response_type':'DiscUsage', # noqa: E501
'auth_settings':self.auth.get_auth_settings(),
'is_async':params.get('is_async'),
'_return_http_data_only':params.get('_return_http_data_only'),
'_preload_content':params.get('_preload_content', True),
'_request_timeout':params.get('_request_timeout'),
'collection_formats':collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def get_file_versions(self, request,**kwargs): # noqa: E501
"""Get file versions # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param str path: File path e.g. '/file.ext' (required)
:param str storage_name: Storage name
:return: FileVersions
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._get_file_versions_with_http_info(request, **kwargs) # noqa: E501
(data) = self._get_file_versions_with_http_info(request, **kwargs) # noqa: E501
return data
def _get_file_versions_with_http_info(self, request, **kwargs): # noqa: E501
"""Get file versions # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param GetFileVersionsRequest request object with parameters
:return: FileVersions
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method get_file_versions" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'path' is set
if request.path is None:
raise ValueError("Missing the required parameter `path` when calling `get_file_versions`") # noqa: E501
collection_formats = {}
path = '/conversion/storage/version/{path}'
path_params = {}
if request.path is not None:
path_params[self.__downcase_first_letter('path')] = request.path # noqa: E501
query_params = []
if self.__downcase_first_letter('storageName') in path:
path = path.replace('{' + self.__downcase_first_letter('storageName' + '}'), request.storage_name if request.storage_name is not None else '')
else:
if request.storage_name is not None:
query_params.append((self.__downcase_first_letter('storageName'), request.storage_name)) # noqa: E501
header_params = {}
form_params = []
local_var_files = []
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path':path,
'method':'GET',
'path_params':path_params,
'query_params':query_params,
'header_params':header_params,
'body':body_params,
'post_params':form_params,
'files':local_var_files,
'response_type':'FileVersions', # noqa: E501
'auth_settings':self.auth.get_auth_settings(),
'is_async':params.get('is_async'),
'_return_http_data_only':params.get('_return_http_data_only'),
'_preload_content':params.get('_preload_content', True),
'_request_timeout':params.get('_request_timeout'),
'collection_formats':collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def object_exists(self, request,**kwargs): # noqa: E501
"""Check if file or folder exists # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param str path: File or folder path e.g. '/file.ext' or '/folder' (required)
:param str storage_name: Storage name
:param str version_id: File version ID
:return: ObjectExist
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._object_exists_with_http_info(request, **kwargs) # noqa: E501
(data) = self._object_exists_with_http_info(request, **kwargs) # noqa: E501
return data
def _object_exists_with_http_info(self, request, **kwargs): # noqa: E501
"""Check if file or folder exists # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param ObjectExistsRequest request object with parameters
:return: ObjectExist
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method object_exists" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'path' is set
if request.path is None:
raise ValueError("Missing the required parameter `path` when calling `object_exists`") # noqa: E501
collection_formats = {}
path = '/conversion/storage/exist/{path}'
path_params = {}
if request.path is not None:
path_params[self.__downcase_first_letter('path')] = request.path # noqa: E501
query_params = []
if self.__downcase_first_letter('storageName') in path:
path = path.replace('{' + self.__downcase_first_letter('storageName' + '}'), request.storage_name if request.storage_name is not None else '')
else:
if request.storage_name is not None:
query_params.append((self.__downcase_first_letter('storageName'), request.storage_name)) # noqa: E501
if self.__downcase_first_letter('versionId') in path:
path = path.replace('{' + self.__downcase_first_letter('versionId' + '}'), request.version_id if request.version_id is not None else '')
else:
if request.version_id is not None:
query_params.append((self.__downcase_first_letter('versionId'), request.version_id)) # noqa: E501
header_params = {}
form_params = []
local_var_files = []
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path':path,
'method':'GET',
'path_params':path_params,
'query_params':query_params,
'header_params':header_params,
'body':body_params,
'post_params':form_params,
'files':local_var_files,
'response_type':'ObjectExist', # noqa: E501
'auth_settings':self.auth.get_auth_settings(),
'is_async':params.get('is_async'),
'_return_http_data_only':params.get('_return_http_data_only'),
'_preload_content':params.get('_preload_content', True),
'_request_timeout':params.get('_request_timeout'),
'collection_formats':collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def storage_exists(self, request,**kwargs): # noqa: E501
"""Check if storage exists # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param str storage_name: Storage name (required)
:return: StorageExist
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._storage_exists_with_http_info(request, **kwargs) # noqa: E501
(data) = self._storage_exists_with_http_info(request, **kwargs) # noqa: E501
return data
def _storage_exists_with_http_info(self, request, **kwargs): # noqa: E501
"""Check if storage exists # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param StorageExistsRequest request object with parameters
:return: StorageExist
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method storage_exists" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'storage_name' is set
if request.storage_name is None:
raise ValueError("Missing the required parameter `storage_name` when calling `storage_exists`") # noqa: E501
collection_formats = {}
path = '/conversion/storage/{storageName}/exist'
path_params = {}
if request.storage_name is not None:
path_params[self.__downcase_first_letter('storageName')] = request.storage_name # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = []
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path':path,
'method':'GET',
'path_params':path_params,
'query_params':query_params,
'header_params':header_params,
'body':body_params,
'post_params':form_params,
'files':local_var_files,
'response_type':'StorageExist', # noqa: E501
'auth_settings':self.auth.get_auth_settings(),
'is_async':params.get('is_async'),
'_return_http_data_only':params.get('_return_http_data_only'),
'_preload_content':params.get('_preload_content', True),
'_request_timeout':params.get('_request_timeout'),
'collection_formats':collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def __downcase_first_letter(self, s):
if len(s) == 0:
return str
else:
return s[0].lower() + s[1:]
class ConvertApi(object):
"""
GroupDocs.Conversion Cloud API
:param configuration: API configuration
"""
def __init__(self, configuration):
api_client = ApiClient(configuration)
self.auth = Auth(configuration, api_client)
self.api_client = api_client
self.configuration = configuration
def close(self): # noqa: E501
"""
Closes thread pool. This method should be called when
methods are executed asynchronously (is_async=True is passed as parameter)
and this instance of ConvertApi is not going to be used any more.
"""
if self.api_client is not None:
if(self.api_client.pool is not None):
self.api_client.pool.close()
self.api_client.pool.join()
self.api_client.pool = None
@classmethod
def from_keys(cls, app_sid, app_key):
"""
Initializes new instance of ConvertApi with API keys
:param app_sid Application identifier (App SID)
:param app_key Application private key (App Key)
"""
configuration = Configuration(app_sid, app_key)
return ConvertApi(configuration)
@classmethod
def from_config(cls, configuration):
"""
Initializes new instance of ConvertApi with configuration options
:param configuration API configuration
"""
return ConvertApi(configuration)
def convert_document(self, request,**kwargs): # noqa: E501
"""Converts specified input document to format specified in the convertSettings with specified options # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param ConvertSettings convert_settings: (required)
:return: list[StoredConvertedResult]
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._convert_document_with_http_info(request, **kwargs) # noqa: E501
(data) = self._convert_document_with_http_info(request, **kwargs) # noqa: E501
return data
def _convert_document_with_http_info(self, request, **kwargs): # noqa: E501
"""Converts specified input document to format specified in the convertSettings with specified options # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param ConvertDocumentRequest request object with parameters
:return: list[StoredConvertedResult]
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method convert_document" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'convert_settings' is set
if request.convert_settings is None:
raise ValueError("Missing the required parameter `convert_settings` when calling `convert_document`") # noqa: E501
collection_formats = {}
path = '/conversion'
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = []
body_params = None
if request.convert_settings is not None:
body_params = request.convert_settings
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path':path,
'method':'POST',
'path_params':path_params,
'query_params':query_params,
'header_params':header_params,
'body':body_params,
'post_params':form_params,
'files':local_var_files,
'response_type':'list[StoredConvertedResult]', # noqa: E501
'auth_settings':self.auth.get_auth_settings(),
'is_async':params.get('is_async'),
'_return_http_data_only':params.get('_return_http_data_only'),
'_preload_content':params.get('_preload_content', True),
'_request_timeout':params.get('_request_timeout'),
'collection_formats':collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def convert_document_download(self, request,**kwargs): # noqa: E501
"""Converts specified input document to format specified in the convertSettings with specified options # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param ConvertSettings convert_settings: (required)
:return: file
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._convert_document_download_with_http_info(request, **kwargs) # noqa: E501
(data) = self._convert_document_download_with_http_info(request, **kwargs) # noqa: E501
return data
def _convert_document_download_with_http_info(self, request, **kwargs): # noqa: E501
"""Converts specified input document to format specified in the convertSettings with specified options # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param ConvertDocumentRequest request object with parameters
:return: list[StoredConvertedResult]
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method convert_document" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'convert_settings' is set
if request.convert_settings is None:
raise ValueError("Missing the required parameter `convert_settings` when calling `convert_document`") # noqa: E501
collection_formats = {}
path = '/conversion'
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = []
body_params = None
if request.convert_settings is not None:
body_params = request.convert_settings
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
call_kwargs = {
'resource_path':path,
'method':'POST',
'path_params':path_params,
'query_params':query_params,
'header_params':header_params,
'body':body_params,
'post_params':form_params,
'files':local_var_files,
'response_type':'file', # noqa: E501
'auth_settings':self.auth.get_auth_settings(),
'is_async':params.get('is_async'),
'_return_http_data_only':params.get('_return_http_data_only'),
'_preload_content':params.get('_preload_content', True),
'_request_timeout':params.get('_request_timeout'),
'collection_formats':collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def convert_document_direct(self, request,**kwargs): # noqa: E501
"""Converts input document file to format specified # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param str format: Requested conversion format (required)
:param file file: Input file to convert (required)
:param int from_page: Page start conversion from
:param int pages_count: Number of pages to convert
:return: file
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('is_async'):
return self._convert_document_direct_with_http_info(request, **kwargs) # noqa: E501
(data) = self._convert_document_direct_with_http_info(request, **kwargs) # noqa: E501
return data
def _convert_document_direct_with_http_info(self, request, **kwargs): # noqa: E501
"""Converts input document file to format specified # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass is_async=True
:param is_async bool
:param ConvertDocumentDirectRequest request object with parameters
:return: file
If the method is called asynchronously,
returns the request thread.
"""
params = locals()
params['is_async'] = ''
params['_return_http_data_only'] = False
params['_preload_content'] = True
params['_request_timeout'] = ''
for key, val in six.iteritems(params['kwargs']):
if key not in params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method convert_document_direct" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'format' is set
if request.format is None:
raise ValueError("Missing the required parameter `format` when calling `convert_document_direct`") # noqa: E501
# verify the required parameter 'file' is set
if request.file is None:
raise ValueError("Missing the required parameter `file` when calling `convert_document_direct`") # noqa: E501
collection_formats = {}
path = '/conversion'
path_params = {}
query_params = []
if self.__downcase_first_letter('format') in path:
path = path.replace('{' + self.__downcase_first_letter('format' + '}'), request.format if request.format is not None else '')
else:
if request.format is not None:
query_params.append((self.__downcase_first_letter('format'), request.format)) # noqa: E501
if self.__downcase_first_letter('fromPage') in path:
path = path.replace('{' + self.__downcase_first_letter('fromPage' + '}'), request.from_page if request.from_page is not None else '')
else:
if request.from_page is not None:
query_params.append((self.__downcase_first_letter('fromPage'), request.from_page)) # noqa: E501
if self.__downcase_first_letter('pagesCount') in path:
path = path.replace('{' + self.__downcase_first_letter('pagesCount' + '}'), request.pages_count if request.pages_count is not None else '')
else:
if request.pages_count is not None:
query_params.append((self.__downcase_first_letter('pagesCount'), request.pages_count)) # noqa: E501
header_params = {}
form_params = []
local_var_files = []
if request.file is not None:
local_var_files.append((self.__downcase_first_letter('File'), request.file)) # noqa: E501
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['multipart/form-data']) # noqa: E501
call_kwargs = {
'resource_path':path,
'method':'PUT',
'path_params':path_params,
'query_params':query_params,
'header_params':header_params,
'body':body_params,
'post_params':form_params,
'files':local_var_files,
'response_type':'file', # noqa: E501
'auth_settings':self.auth.get_auth_settings(),
'is_async':params.get('is_async'),
'_return_http_data_only':params.get('_return_http_data_only'),
'_preload_content':params.get('_preload_content', True),
'_request_timeout':params.get('_request_timeout'),
'collection_formats':collection_formats
}
return self.api_client.call_api(**call_kwargs) # noqa: E501
def __downcase_first_letter(self, s):
if len(s) == 0:
return str
else:
return s[0].lower() + s[1:]