summaryrefslogtreecommitdiffstats
path: root/python_client/fatcat_client
diff options
context:
space:
mode:
Diffstat (limited to 'python_client/fatcat_client')
-rw-r--r--python_client/fatcat_client/api/default_api.py420
1 files changed, 252 insertions, 168 deletions
diff --git a/python_client/fatcat_client/api/default_api.py b/python_client/fatcat_client/api/default_api.py
index 8b652571..1dc79032 100644
--- a/python_client/fatcat_client/api/default_api.py
+++ b/python_client/fatcat_client/api/default_api.py
@@ -328,39 +328,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def create_container(self, entity, **kwargs): # noqa: E501
+ def create_container(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_container # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_container(entity, async=True)
+ >>> thread = api.create_container(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param ContainerEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.create_container_with_http_info(entity, **kwargs) # noqa: E501
+ return self.create_container_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.create_container_with_http_info(entity, **kwargs) # noqa: E501
+ (data) = self.create_container_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
return data
- def create_container_with_http_info(self, entity, **kwargs): # noqa: E501
+ def create_container_with_http_info(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_container # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_container_with_http_info(entity, async=True)
+ >>> thread = api.create_container_with_http_info(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param ContainerEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -385,6 +385,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `create_container`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `create_container`") # noqa: E501
collection_formats = {}
@@ -534,39 +538,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def create_creator(self, entity, **kwargs): # noqa: E501
+ def create_creator(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_creator # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_creator(entity, async=True)
+ >>> thread = api.create_creator(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param CreatorEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.create_creator_with_http_info(entity, **kwargs) # noqa: E501
+ return self.create_creator_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.create_creator_with_http_info(entity, **kwargs) # noqa: E501
+ (data) = self.create_creator_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
return data
- def create_creator_with_http_info(self, entity, **kwargs): # noqa: E501
+ def create_creator_with_http_info(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_creator # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_creator_with_http_info(entity, async=True)
+ >>> thread = api.create_creator_with_http_info(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param CreatorEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -591,6 +595,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `create_creator`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `create_creator`") # noqa: E501
collection_formats = {}
@@ -837,39 +845,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def create_file(self, entity, **kwargs): # noqa: E501
+ def create_file(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_file(entity, async=True)
+ >>> thread = api.create_file(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param FileEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.create_file_with_http_info(entity, **kwargs) # noqa: E501
+ return self.create_file_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.create_file_with_http_info(entity, **kwargs) # noqa: E501
+ (data) = self.create_file_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
return data
- def create_file_with_http_info(self, entity, **kwargs): # noqa: E501
+ def create_file_with_http_info(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_file_with_http_info(entity, async=True)
+ >>> thread = api.create_file_with_http_info(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param FileEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -894,6 +902,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `create_file`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `create_file`") # noqa: E501
collection_formats = {}
@@ -1043,39 +1055,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def create_fileset(self, entity, **kwargs): # noqa: E501
+ def create_fileset(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_fileset # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_fileset(entity, async=True)
+ >>> thread = api.create_fileset(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param FilesetEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.create_fileset_with_http_info(entity, **kwargs) # noqa: E501
+ return self.create_fileset_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.create_fileset_with_http_info(entity, **kwargs) # noqa: E501
+ (data) = self.create_fileset_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
return data
- def create_fileset_with_http_info(self, entity, **kwargs): # noqa: E501
+ def create_fileset_with_http_info(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_fileset # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_fileset_with_http_info(entity, async=True)
+ >>> thread = api.create_fileset_with_http_info(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param FilesetEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -1100,6 +1112,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `create_fileset`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `create_fileset`") # noqa: E501
collection_formats = {}
@@ -1249,39 +1265,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def create_release(self, entity, **kwargs): # noqa: E501
+ def create_release(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_release # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_release(entity, async=True)
+ >>> thread = api.create_release(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param ReleaseEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.create_release_with_http_info(entity, **kwargs) # noqa: E501
+ return self.create_release_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.create_release_with_http_info(entity, **kwargs) # noqa: E501
+ (data) = self.create_release_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
return data
- def create_release_with_http_info(self, entity, **kwargs): # noqa: E501
+ def create_release_with_http_info(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_release # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_release_with_http_info(entity, async=True)
+ >>> thread = api.create_release_with_http_info(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param ReleaseEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -1306,6 +1322,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `create_release`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `create_release`") # noqa: E501
collection_formats = {}
@@ -1455,39 +1475,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def create_webcapture(self, entity, **kwargs): # noqa: E501
+ def create_webcapture(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_webcapture # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_webcapture(entity, async=True)
+ >>> thread = api.create_webcapture(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param WebcaptureEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.create_webcapture_with_http_info(entity, **kwargs) # noqa: E501
+ return self.create_webcapture_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.create_webcapture_with_http_info(entity, **kwargs) # noqa: E501
+ (data) = self.create_webcapture_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
return data
- def create_webcapture_with_http_info(self, entity, **kwargs): # noqa: E501
+ def create_webcapture_with_http_info(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_webcapture # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_webcapture_with_http_info(entity, async=True)
+ >>> thread = api.create_webcapture_with_http_info(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param WebcaptureEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -1512,6 +1532,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `create_webcapture`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `create_webcapture`") # noqa: E501
collection_formats = {}
@@ -1661,39 +1685,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def create_work(self, entity, **kwargs): # noqa: E501
+ def create_work(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_work # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_work(entity, async=True)
+ >>> thread = api.create_work(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param WorkEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.create_work_with_http_info(entity, **kwargs) # noqa: E501
+ return self.create_work_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.create_work_with_http_info(entity, **kwargs) # noqa: E501
+ (data) = self.create_work_with_http_info(entity, editgroup_id, **kwargs) # noqa: E501
return data
- def create_work_with_http_info(self, entity, **kwargs): # noqa: E501
+ def create_work_with_http_info(self, entity, editgroup_id, **kwargs): # noqa: E501
"""create_work # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.create_work_with_http_info(entity, async=True)
+ >>> thread = api.create_work_with_http_info(entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param WorkEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -1718,6 +1742,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `create_work`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `create_work`") # noqa: E501
collection_formats = {}
@@ -1867,39 +1895,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def delete_container(self, ident, **kwargs): # noqa: E501
+ def delete_container(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_container # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_container(ident, async=True)
+ >>> thread = api.delete_container(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.delete_container_with_http_info(ident, **kwargs) # noqa: E501
+ return self.delete_container_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.delete_container_with_http_info(ident, **kwargs) # noqa: E501
+ (data) = self.delete_container_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
return data
- def delete_container_with_http_info(self, ident, **kwargs): # noqa: E501
+ def delete_container_with_http_info(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_container # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_container_with_http_info(ident, async=True)
+ >>> thread = api.delete_container_with_http_info(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -1924,6 +1952,10 @@ class DefaultApi(object):
if ('ident' not in params or
params['ident'] is None):
raise ValueError("Missing the required parameter `ident` when calling `delete_container`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `delete_container`") # noqa: E501
collection_formats = {}
@@ -2073,39 +2105,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def delete_creator(self, ident, **kwargs): # noqa: E501
+ def delete_creator(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_creator # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_creator(ident, async=True)
+ >>> thread = api.delete_creator(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.delete_creator_with_http_info(ident, **kwargs) # noqa: E501
+ return self.delete_creator_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.delete_creator_with_http_info(ident, **kwargs) # noqa: E501
+ (data) = self.delete_creator_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
return data
- def delete_creator_with_http_info(self, ident, **kwargs): # noqa: E501
+ def delete_creator_with_http_info(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_creator # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_creator_with_http_info(ident, async=True)
+ >>> thread = api.delete_creator_with_http_info(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -2130,6 +2162,10 @@ class DefaultApi(object):
if ('ident' not in params or
params['ident'] is None):
raise ValueError("Missing the required parameter `ident` when calling `delete_creator`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `delete_creator`") # noqa: E501
collection_formats = {}
@@ -2279,39 +2315,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def delete_file(self, ident, **kwargs): # noqa: E501
+ def delete_file(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_file(ident, async=True)
+ >>> thread = api.delete_file(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.delete_file_with_http_info(ident, **kwargs) # noqa: E501
+ return self.delete_file_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.delete_file_with_http_info(ident, **kwargs) # noqa: E501
+ (data) = self.delete_file_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
return data
- def delete_file_with_http_info(self, ident, **kwargs): # noqa: E501
+ def delete_file_with_http_info(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_file_with_http_info(ident, async=True)
+ >>> thread = api.delete_file_with_http_info(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -2336,6 +2372,10 @@ class DefaultApi(object):
if ('ident' not in params or
params['ident'] is None):
raise ValueError("Missing the required parameter `ident` when calling `delete_file`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `delete_file`") # noqa: E501
collection_formats = {}
@@ -2485,39 +2525,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def delete_fileset(self, ident, **kwargs): # noqa: E501
+ def delete_fileset(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_fileset # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_fileset(ident, async=True)
+ >>> thread = api.delete_fileset(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.delete_fileset_with_http_info(ident, **kwargs) # noqa: E501
+ return self.delete_fileset_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.delete_fileset_with_http_info(ident, **kwargs) # noqa: E501
+ (data) = self.delete_fileset_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
return data
- def delete_fileset_with_http_info(self, ident, **kwargs): # noqa: E501
+ def delete_fileset_with_http_info(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_fileset # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_fileset_with_http_info(ident, async=True)
+ >>> thread = api.delete_fileset_with_http_info(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -2542,6 +2582,10 @@ class DefaultApi(object):
if ('ident' not in params or
params['ident'] is None):
raise ValueError("Missing the required parameter `ident` when calling `delete_fileset`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `delete_fileset`") # noqa: E501
collection_formats = {}
@@ -2691,39 +2735,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def delete_release(self, ident, **kwargs): # noqa: E501
+ def delete_release(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_release # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_release(ident, async=True)
+ >>> thread = api.delete_release(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.delete_release_with_http_info(ident, **kwargs) # noqa: E501
+ return self.delete_release_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.delete_release_with_http_info(ident, **kwargs) # noqa: E501
+ (data) = self.delete_release_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
return data
- def delete_release_with_http_info(self, ident, **kwargs): # noqa: E501
+ def delete_release_with_http_info(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_release # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_release_with_http_info(ident, async=True)
+ >>> thread = api.delete_release_with_http_info(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -2748,6 +2792,10 @@ class DefaultApi(object):
if ('ident' not in params or
params['ident'] is None):
raise ValueError("Missing the required parameter `ident` when calling `delete_release`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `delete_release`") # noqa: E501
collection_formats = {}
@@ -2897,39 +2945,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def delete_webcapture(self, ident, **kwargs): # noqa: E501
+ def delete_webcapture(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_webcapture # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_webcapture(ident, async=True)
+ >>> thread = api.delete_webcapture(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.delete_webcapture_with_http_info(ident, **kwargs) # noqa: E501
+ return self.delete_webcapture_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.delete_webcapture_with_http_info(ident, **kwargs) # noqa: E501
+ (data) = self.delete_webcapture_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
return data
- def delete_webcapture_with_http_info(self, ident, **kwargs): # noqa: E501
+ def delete_webcapture_with_http_info(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_webcapture # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_webcapture_with_http_info(ident, async=True)
+ >>> thread = api.delete_webcapture_with_http_info(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -2954,6 +3002,10 @@ class DefaultApi(object):
if ('ident' not in params or
params['ident'] is None):
raise ValueError("Missing the required parameter `ident` when calling `delete_webcapture`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `delete_webcapture`") # noqa: E501
collection_formats = {}
@@ -3103,39 +3155,39 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def delete_work(self, ident, **kwargs): # noqa: E501
+ def delete_work(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_work # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_work(ident, async=True)
+ >>> thread = api.delete_work(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.delete_work_with_http_info(ident, **kwargs) # noqa: E501
+ return self.delete_work_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.delete_work_with_http_info(ident, **kwargs) # noqa: E501
+ (data) = self.delete_work_with_http_info(ident, editgroup_id, **kwargs) # noqa: E501
return data
- def delete_work_with_http_info(self, ident, **kwargs): # noqa: E501
+ def delete_work_with_http_info(self, ident, editgroup_id, **kwargs): # noqa: E501
"""delete_work # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.delete_work_with_http_info(ident, async=True)
+ >>> thread = api.delete_work_with_http_info(ident, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -3160,6 +3212,10 @@ class DefaultApi(object):
if ('ident' not in params or
params['ident'] is None):
raise ValueError("Missing the required parameter `ident` when calling `delete_work`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `delete_work`") # noqa: E501
collection_formats = {}
@@ -8430,41 +8486,41 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def update_container(self, ident, entity, **kwargs): # noqa: E501
+ def update_container(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_container # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_container(ident, entity, async=True)
+ >>> thread = api.update_container(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param ContainerEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.update_container_with_http_info(ident, entity, **kwargs) # noqa: E501
+ return self.update_container_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.update_container_with_http_info(ident, entity, **kwargs) # noqa: E501
+ (data) = self.update_container_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
return data
- def update_container_with_http_info(self, ident, entity, **kwargs): # noqa: E501
+ def update_container_with_http_info(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_container # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_container_with_http_info(ident, entity, async=True)
+ >>> thread = api.update_container_with_http_info(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param ContainerEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -8493,6 +8549,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `update_container`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `update_container`") # noqa: E501
collection_formats = {}
@@ -8539,41 +8599,41 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def update_creator(self, ident, entity, **kwargs): # noqa: E501
+ def update_creator(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_creator # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_creator(ident, entity, async=True)
+ >>> thread = api.update_creator(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param CreatorEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.update_creator_with_http_info(ident, entity, **kwargs) # noqa: E501
+ return self.update_creator_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.update_creator_with_http_info(ident, entity, **kwargs) # noqa: E501
+ (data) = self.update_creator_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
return data
- def update_creator_with_http_info(self, ident, entity, **kwargs): # noqa: E501
+ def update_creator_with_http_info(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_creator # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_creator_with_http_info(ident, entity, async=True)
+ >>> thread = api.update_creator_with_http_info(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param CreatorEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -8602,6 +8662,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `update_creator`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `update_creator`") # noqa: E501
collection_formats = {}
@@ -8753,41 +8817,41 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def update_file(self, ident, entity, **kwargs): # noqa: E501
+ def update_file(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_file(ident, entity, async=True)
+ >>> thread = api.update_file(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param FileEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.update_file_with_http_info(ident, entity, **kwargs) # noqa: E501
+ return self.update_file_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.update_file_with_http_info(ident, entity, **kwargs) # noqa: E501
+ (data) = self.update_file_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
return data
- def update_file_with_http_info(self, ident, entity, **kwargs): # noqa: E501
+ def update_file_with_http_info(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_file_with_http_info(ident, entity, async=True)
+ >>> thread = api.update_file_with_http_info(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param FileEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -8816,6 +8880,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `update_file`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `update_file`") # noqa: E501
collection_formats = {}
@@ -8862,41 +8930,41 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def update_fileset(self, ident, entity, **kwargs): # noqa: E501
+ def update_fileset(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_fileset # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_fileset(ident, entity, async=True)
+ >>> thread = api.update_fileset(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param FilesetEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.update_fileset_with_http_info(ident, entity, **kwargs) # noqa: E501
+ return self.update_fileset_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.update_fileset_with_http_info(ident, entity, **kwargs) # noqa: E501
+ (data) = self.update_fileset_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
return data
- def update_fileset_with_http_info(self, ident, entity, **kwargs): # noqa: E501
+ def update_fileset_with_http_info(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_fileset # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_fileset_with_http_info(ident, entity, async=True)
+ >>> thread = api.update_fileset_with_http_info(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param FilesetEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -8925,6 +8993,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `update_fileset`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `update_fileset`") # noqa: E501
collection_formats = {}
@@ -8971,41 +9043,41 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def update_release(self, ident, entity, **kwargs): # noqa: E501
+ def update_release(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_release # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_release(ident, entity, async=True)
+ >>> thread = api.update_release(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param ReleaseEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.update_release_with_http_info(ident, entity, **kwargs) # noqa: E501
+ return self.update_release_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.update_release_with_http_info(ident, entity, **kwargs) # noqa: E501
+ (data) = self.update_release_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
return data
- def update_release_with_http_info(self, ident, entity, **kwargs): # noqa: E501
+ def update_release_with_http_info(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_release # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_release_with_http_info(ident, entity, async=True)
+ >>> thread = api.update_release_with_http_info(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param ReleaseEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -9034,6 +9106,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `update_release`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `update_release`") # noqa: E501
collection_formats = {}
@@ -9080,41 +9156,41 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def update_webcapture(self, ident, entity, **kwargs): # noqa: E501
+ def update_webcapture(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_webcapture # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_webcapture(ident, entity, async=True)
+ >>> thread = api.update_webcapture(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param WebcaptureEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.update_webcapture_with_http_info(ident, entity, **kwargs) # noqa: E501
+ return self.update_webcapture_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.update_webcapture_with_http_info(ident, entity, **kwargs) # noqa: E501
+ (data) = self.update_webcapture_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
return data
- def update_webcapture_with_http_info(self, ident, entity, **kwargs): # noqa: E501
+ def update_webcapture_with_http_info(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_webcapture # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_webcapture_with_http_info(ident, entity, async=True)
+ >>> thread = api.update_webcapture_with_http_info(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param WebcaptureEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -9143,6 +9219,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `update_webcapture`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `update_webcapture`") # noqa: E501
collection_formats = {}
@@ -9189,41 +9269,41 @@ class DefaultApi(object):
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
- def update_work(self, ident, entity, **kwargs): # noqa: E501
+ def update_work(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_work # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_work(ident, entity, async=True)
+ >>> thread = api.update_work(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param WorkEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
- return self.update_work_with_http_info(ident, entity, **kwargs) # noqa: E501
+ return self.update_work_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
else:
- (data) = self.update_work_with_http_info(ident, entity, **kwargs) # noqa: E501
+ (data) = self.update_work_with_http_info(ident, entity, editgroup_id, **kwargs) # noqa: E501
return data
- def update_work_with_http_info(self, ident, entity, **kwargs): # noqa: E501
+ def update_work_with_http_info(self, ident, entity, editgroup_id, **kwargs): # noqa: E501
"""update_work # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
- >>> thread = api.update_work_with_http_info(ident, entity, async=True)
+ >>> thread = api.update_work_with_http_info(ident, entity, editgroup_id, async=True)
>>> result = thread.get()
:param async bool
:param str ident: (required)
:param WorkEntity entity: (required)
- :param str editgroup_id:
+ :param str editgroup_id: (required)
:return: EntityEdit
If the method is called asynchronously,
returns the request thread.
@@ -9252,6 +9332,10 @@ class DefaultApi(object):
if ('entity' not in params or
params['entity'] is None):
raise ValueError("Missing the required parameter `entity` when calling `update_work`") # noqa: E501
+ # verify the required parameter 'editgroup_id' is set
+ if ('editgroup_id' not in params or
+ params['editgroup_id'] is None):
+ raise ValueError("Missing the required parameter `editgroup_id` when calling `update_work`") # noqa: E501
collection_formats = {}