def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __create_drawing_translation(self, did, wv, wvid, eid,
bt_translate_format_params, **kwargs):
"""Create Drawing translation # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_drawing_translation(did, wv, wvid, eid, bt_translate_format_params, async_req=True)
>>> result = thread.get()
Args:
did (str):
wv (str):
wvid (str):
eid (str):
bt_translate_format_params (bt_translate_format_params.BTTranslateFormatParams):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_translation_request_info.BTTranslationRequestInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['did'] = \
did
kwargs['wv'] = \
wv
kwargs['wvid'] = \
wvid
kwargs['eid'] = \
eid
kwargs['bt_translate_format_params'] = \
bt_translate_format_params
return self.call_with_http_info(**kwargs)
self.create_drawing_translation = Endpoint(
settings={
'response_type':
(bt_translation_request_info.BTTranslationRequestInfo, ),
'auth': ['OAuth2'],
'endpoint_path':
'/api/drawings/d/{did}/{wv}/{wvid}/e/{eid}/translations',
'operation_id':
'create_drawing_translation',
'http_method':
'POST',
'servers': [],
},
params_map={
'all': [
'did',
'wv',
'wvid',
'eid',
'bt_translate_format_params',
],
'required': [
'did',
'wv',
'wvid',
'eid',
'bt_translate_format_params',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'did': (str, ),
'wv': (str, ),
'wvid': (str, ),
'eid': (str, ),
'bt_translate_format_params':
(bt_translate_format_params.BTTranslateFormatParams, ),
},
'attribute_map': {
'did': 'did',
'wv': 'wv',
'wvid': 'wvid',
'eid': 'eid',
},
'location_map': {
'did': 'path',
'wv': 'path',
'wvid': 'path',
'eid': 'path',
'bt_translate_format_params': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': ['application/json;charset=UTF-8; qs=0.09']
},
api_client=api_client,
callable=__create_drawing_translation)
def __get_drawing_translator_formats(self, did, wid, eid, **kwargs):
"""get_drawing_translator_formats # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_drawing_translator_formats(did, wid, eid, async_req=True)
>>> result = thread.get()
Args:
did (str):
wid (str):
eid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
[bt_model_format_info.BTModelFormatInfo]
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['did'] = \
did
kwargs['wid'] = \
wid
kwargs['eid'] = \
eid
return self.call_with_http_info(**kwargs)
self.get_drawing_translator_formats = Endpoint(
settings={
'response_type': ([bt_model_format_info.BTModelFormatInfo], ),
'auth': [],
'endpoint_path':
'/api/drawings/d/{did}/w/{wid}/e/{eid}/translationformats',
'operation_id': 'get_drawing_translator_formats',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'did',
'wid',
'eid',
],
'required': [
'did',
'wid',
'eid',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'did': (str, ),
'wid': (str, ),
'eid': (str, ),
},
'attribute_map': {
'did': 'did',
'wid': 'wid',
'eid': 'eid',
},
'location_map': {
'did': 'path',
'wid': 'path',
'eid': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__get_drawing_translator_formats)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __create_obsoletion_package(
self,
wfid,
**kwargs
):
"""create_obsoletion_package # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_obsoletion_package(wfid, async_req=True)
>>> result = thread.get()
Args:
wfid (str):
Keyword Args:
revision_id (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['wfid'] = \
wfid
return self.call_with_http_info(**kwargs)
self.create_obsoletion_package = Endpoint(
settings={
'response_type': None,
'auth': [
'OAuth2'
],
'endpoint_path': '/api/releasepackages/obsoletion/{wfid}',
'operation_id': 'create_obsoletion_package',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'wfid',
'revision_id',
],
'required': [
'wfid',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'wfid':
(str,),
'revision_id':
(str,),
},
'attribute_map': {
'wfid': 'wfid',
'revision_id': 'revisionId',
},
'location_map': {
'wfid': 'path',
'revision_id': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
],
'content_type': [],
},
api_client=api_client,
callable=__create_obsoletion_package
)
def __create_release_package(
self,
wfid,
bt_release_package_params,
**kwargs
):
"""create_release_package # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_release_package(wfid, bt_release_package_params, async_req=True)
>>> result = thread.get()
Args:
wfid (str):
bt_release_package_params (bt_release_package_params.BTReleasePackageParams):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['wfid'] = \
wfid
kwargs['bt_release_package_params'] = \
bt_release_package_params
return self.call_with_http_info(**kwargs)
self.create_release_package = Endpoint(
settings={
'response_type': None,
'auth': [
'OAuth2'
],
'endpoint_path': '/api/releasepackages/release/{wfid}',
'operation_id': 'create_release_package',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'wfid',
'bt_release_package_params',
],
'required': [
'wfid',
'bt_release_package_params',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'wfid':
(str,),
'bt_release_package_params':
(bt_release_package_params.BTReleasePackageParams,),
},
'attribute_map': {
'wfid': 'wfid',
},
'location_map': {
'wfid': 'path',
'bt_release_package_params': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
],
'content_type': [
'application/json;charset=UTF-8; qs=0.09'
]
},
api_client=api_client,
callable=__create_release_package
)
def __get_company_release_workflow(
self,
**kwargs
):
"""get_company_release_workflow # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_company_release_workflow(async_req=True)
>>> result = thread.get()
Keyword Args:
document_id (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_active_workflow_info.BTActiveWorkflowInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
return self.call_with_http_info(**kwargs)
self.get_company_release_workflow = Endpoint(
settings={
'response_type': (bt_active_workflow_info.BTActiveWorkflowInfo,),
'auth': [
'OAuth2'
],
'endpoint_path': '/api/releasepackages/companyreleaseworkflow',
'operation_id': 'get_company_release_workflow',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'document_id',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'document_id':
(str,),
},
'attribute_map': {
'document_id': 'documentId',
},
'location_map': {
'document_id': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
],
'content_type': [],
},
api_client=api_client,
callable=__get_company_release_workflow
)
def __get_release_package(
self,
rpid,
**kwargs
):
"""get_release_package # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_release_package(rpid, async_req=True)
>>> result = thread.get()
Args:
rpid (str):
Keyword Args:
detailed (bool): [optional] if omitted the server will use the default value of False
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_release_package_info.BTReleasePackageInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['rpid'] = \
rpid
return self.call_with_http_info(**kwargs)
self.get_release_package = Endpoint(
settings={
'response_type': (bt_release_package_info.BTReleasePackageInfo,),
'auth': [
'OAuth2'
],
'endpoint_path': '/api/releasepackages/{rpid}',
'operation_id': 'get_release_package',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'rpid',
'detailed',
],
'required': [
'rpid',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'rpid':
(str,),
'detailed':
(bool,),
},
'attribute_map': {
'rpid': 'rpid',
'detailed': 'detailed',
},
'location_map': {
'rpid': 'path',
'detailed': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
],
'content_type': [],
},
api_client=api_client,
callable=__get_release_package
)
def __update_release_package(
self,
rpid,
bt_update_release_package_params,
**kwargs
):
"""update_release_package # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_release_package(rpid, bt_update_release_package_params, async_req=True)
>>> result = thread.get()
Args:
rpid (str):
bt_update_release_package_params (bt_update_release_package_params.BTUpdateReleasePackageParams):
Keyword Args:
action (str): [optional] if omitted the server will use the default value of 'UPDATE'
wfaction (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_release_package_info.BTReleasePackageInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['rpid'] = \
rpid
kwargs['bt_update_release_package_params'] = \
bt_update_release_package_params
return self.call_with_http_info(**kwargs)
self.update_release_package = Endpoint(
settings={
'response_type': (bt_release_package_info.BTReleasePackageInfo,),
'auth': [
'OAuth2'
],
'endpoint_path': '/api/releasepackages/{rpid}',
'operation_id': 'update_release_package',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'rpid',
'bt_update_release_package_params',
'action',
'wfaction',
],
'required': [
'rpid',
'bt_update_release_package_params',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'rpid':
(str,),
'bt_update_release_package_params':
(bt_update_release_package_params.BTUpdateReleasePackageParams,),
'action':
(str,),
'wfaction':
(str,),
},
'attribute_map': {
'rpid': 'rpid',
'action': 'action',
'wfaction': 'wfaction',
},
'location_map': {
'rpid': 'path',
'bt_update_release_package_params': 'body',
'action': 'query',
'wfaction': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
],
'content_type': [
'application/json;charset=UTF-8; qs=0.09'
]
},
api_client=api_client,
callable=__update_release_package
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __copy_element_from_source_document(
self, did, wid, bt_copy_element_params, **kwargs
):
"""Copy Element # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.copy_element_from_source_document(did, wid, bt_copy_element_params, async_req=True)
>>> result = thread.get()
Args:
did (str):
wid (str):
bt_copy_element_params (bt_copy_element_params.BTCopyElementParams):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_document_element_info.BTDocumentElementInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["wid"] = wid
kwargs["bt_copy_element_params"] = bt_copy_element_params
return self.call_with_http_info(**kwargs)
self.copy_element_from_source_document = Endpoint(
settings={
"response_type": (bt_document_element_info.BTDocumentElementInfo,),
"auth": ["OAuth2"],
"endpoint_path": "/api/elements/copyelement/{did}/workspace/{wid}",
"operation_id": "copy_element_from_source_document",
"http_method": "POST",
"servers": [],
},
params_map={
"all": ["did", "wid", "bt_copy_element_params",],
"required": ["did", "wid", "bt_copy_element_params",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"did": (str,),
"wid": (str,),
"bt_copy_element_params": (
bt_copy_element_params.BTCopyElementParams,
),
},
"attribute_map": {"did": "did", "wid": "wid",},
"location_map": {
"did": "path",
"wid": "path",
"bt_copy_element_params": "body",
},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__copy_element_from_source_document,
)
def __decode_configuration(self, did, wvm, wvmid, eid, cid, **kwargs):
"""Decode Configuration String # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.decode_configuration(did, wvm, wvmid, eid, cid, async_req=True)
>>> result = thread.get()
Args:
did (str):
wvm (str):
wvmid (str):
eid (str):
cid (str):
Keyword Args:
link_document_id (str): [optional]
include_display (bool): [optional] if omitted the server will use the default value of False
configuration_is_id (bool): [optional] if omitted the server will use the default value of False
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_configuration_info.BTConfigurationInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["wvm"] = wvm
kwargs["wvmid"] = wvmid
kwargs["eid"] = eid
kwargs["cid"] = cid
return self.call_with_http_info(**kwargs)
self.decode_configuration = Endpoint(
settings={
"response_type": (bt_configuration_info.BTConfigurationInfo,),
"auth": ["OAuth2"],
"endpoint_path": "/api/elements/d/{did}/{wvm}/{wvmid}/e/{eid}/configurationencodings/{cid}",
"operation_id": "decode_configuration",
"http_method": "GET",
"servers": [],
},
params_map={
"all": [
"did",
"wvm",
"wvmid",
"eid",
"cid",
"link_document_id",
"include_display",
"configuration_is_id",
],
"required": ["did", "wvm", "wvmid", "eid", "cid",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"did": (str,),
"wvm": (str,),
"wvmid": (str,),
"eid": (str,),
"cid": (str,),
"link_document_id": (str,),
"include_display": (bool,),
"configuration_is_id": (bool,),
},
"attribute_map": {
"did": "did",
"wvm": "wvm",
"wvmid": "wvmid",
"eid": "eid",
"cid": "cid",
"link_document_id": "linkDocumentId",
"include_display": "includeDisplay",
"configuration_is_id": "configurationIsId",
},
"location_map": {
"did": "path",
"wvm": "path",
"wvmid": "path",
"eid": "path",
"cid": "path",
"link_document_id": "query",
"include_display": "query",
"configuration_is_id": "query",
},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__decode_configuration,
)
def __delete_element(self, did, wid, eid, **kwargs):
"""Delete Element # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_element(did, wid, eid, async_req=True)
>>> result = thread.get()
Args:
did (str):
wid (str):
eid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["wid"] = wid
kwargs["eid"] = eid
return self.call_with_http_info(**kwargs)
self.delete_element = Endpoint(
settings={
"response_type": None,
"auth": ["OAuth2"],
"endpoint_path": "/api/elements/d/{did}/w/{wid}/e/{eid}",
"operation_id": "delete_element",
"http_method": "DELETE",
"servers": [],
},
params_map={
"all": ["did", "wid", "eid",],
"required": ["did", "wid", "eid",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {"did": (str,), "wid": (str,), "eid": (str,),},
"attribute_map": {"did": "did", "wid": "wid", "eid": "eid",},
"location_map": {"did": "path", "wid": "path", "eid": "path",},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__delete_element,
)
def __encode_configuration_map(
self, did, eid, bt_configuration_params, **kwargs
):
"""Encode Configuration # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.encode_configuration_map(did, eid, bt_configuration_params, async_req=True)
>>> result = thread.get()
Args:
did (str):
eid (str):
bt_configuration_params (bt_configuration_params.BTConfigurationParams):
Keyword Args:
version_id (str): [optional]
link_document_id (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_encoded_configuration_info.BTEncodedConfigurationInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["eid"] = eid
kwargs["bt_configuration_params"] = bt_configuration_params
return self.call_with_http_info(**kwargs)
self.encode_configuration_map = Endpoint(
settings={
"response_type": (
bt_encoded_configuration_info.BTEncodedConfigurationInfo,
),
"auth": ["OAuth2"],
"endpoint_path": "/api/elements/d/{did}/e/{eid}/configurationencodings",
"operation_id": "encode_configuration_map",
"http_method": "POST",
"servers": [],
},
params_map={
"all": [
"did",
"eid",
"bt_configuration_params",
"version_id",
"link_document_id",
],
"required": ["did", "eid", "bt_configuration_params",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"did": (str,),
"eid": (str,),
"bt_configuration_params": (
bt_configuration_params.BTConfigurationParams,
),
"version_id": (str,),
"link_document_id": (str,),
},
"attribute_map": {
"did": "did",
"eid": "eid",
"version_id": "versionId",
"link_document_id": "linkDocumentId",
},
"location_map": {
"did": "path",
"eid": "path",
"bt_configuration_params": "body",
"version_id": "query",
"link_document_id": "query",
},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__encode_configuration_map,
)
def __get_configuration(self, did, wvm, wvmid, eid, **kwargs):
"""Get Configuration # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_configuration(did, wvm, wvmid, eid, async_req=True)
>>> result = thread.get()
Args:
did (str):
wvm (str):
wvmid (str):
eid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_configuration_info.BTConfigurationInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["wvm"] = wvm
kwargs["wvmid"] = wvmid
kwargs["eid"] = eid
return self.call_with_http_info(**kwargs)
self.get_configuration = Endpoint(
settings={
"response_type": (bt_configuration_info.BTConfigurationInfo,),
"auth": ["OAuth2"],
"endpoint_path": "/api/elements/d/{did}/{wvm}/{wvmid}/e/{eid}/configuration",
"operation_id": "get_configuration",
"http_method": "GET",
"servers": [],
},
params_map={
"all": ["did", "wvm", "wvmid", "eid",],
"required": ["did", "wvm", "wvmid", "eid",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"did": (str,),
"wvm": (str,),
"wvmid": (str,),
"eid": (str,),
},
"attribute_map": {
"did": "did",
"wvm": "wvm",
"wvmid": "wvmid",
"eid": "eid",
},
"location_map": {
"did": "path",
"wvm": "path",
"wvmid": "path",
"eid": "path",
},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_configuration,
)
def __get_element_translator_formats_by_version_or_workspace(
self, did, wv, wvid, eid, **kwargs
):
"""Get Element Translator Formats # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_element_translator_formats_by_version_or_workspace(did, wv, wvid, eid, async_req=True)
>>> result = thread.get()
Args:
did (str):
wv (str):
wvid (str):
eid (str):
Keyword Args:
check_content (bool): [optional] if omitted the server will use the default value of True
configuration (str): [optional] if omitted the server will use the default value of ''
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
[bt_model_format_info.BTModelFormatInfo]
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["wv"] = wv
kwargs["wvid"] = wvid
kwargs["eid"] = eid
return self.call_with_http_info(**kwargs)
self.get_element_translator_formats_by_version_or_workspace = Endpoint(
settings={
"response_type": ([bt_model_format_info.BTModelFormatInfo],),
"auth": [],
"endpoint_path": "/api/elements/translatorFormats/{did}/{wv}/{wvid}/{eid}",
"operation_id": "get_element_translator_formats_by_version_or_workspace",
"http_method": "GET",
"servers": [],
},
params_map={
"all": ["did", "wv", "wvid", "eid", "check_content", "configuration",],
"required": ["did", "wv", "wvid", "eid",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"did": (str,),
"wv": (str,),
"wvid": (str,),
"eid": (str,),
"check_content": (bool,),
"configuration": (str,),
},
"attribute_map": {
"did": "did",
"wv": "wv",
"wvid": "wvid",
"eid": "eid",
"check_content": "checkContent",
"configuration": "configuration",
},
"location_map": {
"did": "path",
"wv": "path",
"wvid": "path",
"eid": "path",
"check_content": "query",
"configuration": "query",
},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_element_translator_formats_by_version_or_workspace,
)
def __update_configuration(self, did, wvm, wvmid, eid, **kwargs):
"""Update Configuration # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_configuration(did, wvm, wvmid, eid, async_req=True)
>>> result = thread.get()
Args:
did (str):
wvm (str):
wvmid (str):
eid (str):
Keyword Args:
body (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_configuration_info.BTConfigurationInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["wvm"] = wvm
kwargs["wvmid"] = wvmid
kwargs["eid"] = eid
return self.call_with_http_info(**kwargs)
self.update_configuration = Endpoint(
settings={
"response_type": (bt_configuration_info.BTConfigurationInfo,),
"auth": ["OAuth2"],
"endpoint_path": "/api/elements/d/{did}/{wvm}/{wvmid}/e/{eid}/configuration",
"operation_id": "update_configuration",
"http_method": "POST",
"servers": [],
},
params_map={
"all": ["did", "wvm", "wvmid", "eid", "body",],
"required": ["did", "wvm", "wvmid", "eid",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"did": (str,),
"wvm": (str,),
"wvmid": (str,),
"eid": (str,),
"body": (str,),
},
"attribute_map": {
"did": "did",
"wvm": "wvm",
"wvmid": "wvmid",
"eid": "eid",
},
"location_map": {
"did": "path",
"wvm": "path",
"wvmid": "path",
"eid": "path",
"body": "body",
},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__update_configuration,
)
def __update_references(
self, did, wid, eid, bt_update_reference_params, **kwargs
):
"""Update or replace node references # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_references(did, wid, eid, bt_update_reference_params, async_req=True)
>>> result = thread.get()
Args:
did (str):
wid (str):
eid (str):
bt_update_reference_params (bt_update_reference_params.BTUpdateReferenceParams):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["wid"] = wid
kwargs["eid"] = eid
kwargs["bt_update_reference_params"] = bt_update_reference_params
return self.call_with_http_info(**kwargs)
self.update_references = Endpoint(
settings={
"response_type": None,
"auth": ["OAuth2"],
"endpoint_path": "/api/elements/d/{did}/w/{wid}/e/{eid}/updatereferences",
"operation_id": "update_references",
"http_method": "POST",
"servers": [],
},
params_map={
"all": ["did", "wid", "eid", "bt_update_reference_params",],
"required": ["did", "wid", "eid", "bt_update_reference_params",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"did": (str,),
"wid": (str,),
"eid": (str,),
"bt_update_reference_params": (
bt_update_reference_params.BTUpdateReferenceParams,
),
},
"attribute_map": {"did": "did", "wid": "wid", "eid": "eid",},
"location_map": {
"did": "path",
"wid": "path",
"eid": "path",
"bt_update_reference_params": "body",
},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__update_references,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_folder_acl(self, fid, **kwargs):
"""Get Access Control List # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_folder_acl(fid, async_req=True)
>>> result = thread.get()
Args:
fid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_acl_info.BTAclInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['fid'] = \
fid
return self.call_with_http_info(**kwargs)
self.get_folder_acl = Endpoint(
settings={
'response_type': (bt_acl_info.BTAclInfo, ),
'auth': ['OAuth2'],
'endpoint_path': '/api/folders/{fid}/acl',
'operation_id': 'get_folder_acl',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'fid',
],
'required': [
'fid',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'fid': (str, ),
},
'attribute_map': {
'fid': 'fid',
},
'location_map': {
'fid': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__get_folder_acl)
def __share(self, fid, bt_share_params, **kwargs):
"""Share Folder # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.share(fid, bt_share_params, async_req=True)
>>> result = thread.get()
Args:
fid (str):
bt_share_params (bt_share_params.BTShareParams):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_acl_info.BTAclInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['fid'] = \
fid
kwargs['bt_share_params'] = \
bt_share_params
return self.call_with_http_info(**kwargs)
self.share = Endpoint(
settings={
'response_type': (bt_acl_info.BTAclInfo, ),
'auth': ['OAuth2'],
'endpoint_path': '/api/folders/{fid}/share',
'operation_id': 'share',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'fid',
'bt_share_params',
],
'required': [
'fid',
'bt_share_params',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'fid': (str, ),
'bt_share_params': (bt_share_params.BTShareParams, ),
},
'attribute_map': {
'fid': 'fid',
},
'location_map': {
'fid': 'path',
'bt_share_params': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': ['application/json;charset=UTF-8; qs=0.09']
},
api_client=api_client,
callable=__share)
def __un_share(self, fid, eid, **kwargs):
"""Unshare Folder # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.un_share(fid, eid, async_req=True)
>>> result = thread.get()
Args:
fid (str):
eid (str):
Keyword Args:
entry_type (int): [optional] if omitted the server will use the default value of 0
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['fid'] = \
fid
kwargs['eid'] = \
eid
return self.call_with_http_info(**kwargs)
self.un_share = Endpoint(
settings={
'response_type': None,
'auth': ['OAuth2'],
'endpoint_path': '/api/folders/{fid}/share/{eid}',
'operation_id': 'un_share',
'http_method': 'DELETE',
'servers': [],
},
params_map={
'all': [
'fid',
'eid',
'entry_type',
],
'required': [
'fid',
'eid',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'fid': (str, ),
'eid': (str, ),
'entry_type': (int, ),
},
'attribute_map': {
'fid': 'fid',
'eid': 'eid',
'entry_type': 'entryType',
},
'location_map': {
'fid': 'path',
'eid': 'path',
'entry_type': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__un_share)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __delete_app_settings(self, uid, cid, **kwargs):
"""Delete Application Settings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_app_settings(uid, cid, async_req=True)
>>> result = thread.get()
Args:
uid (str):
cid (str):
Keyword Args:
key ([str]): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["uid"] = uid
kwargs["cid"] = cid
return self.call_with_http_info(**kwargs)
self.delete_app_settings = Endpoint(
settings={
"response_type": None,
"auth": [],
"endpoint_path":
"/api/applications/clients/{cid}/settings/users/{uid}",
"operation_id": "delete_app_settings",
"http_method": "DELETE",
"servers": [],
},
params_map={
"all": [
"uid",
"cid",
"key",
],
"required": [
"uid",
"cid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"uid": (str, ),
"cid": (str, ),
"key": ([str], ),
},
"attribute_map": {
"uid": "uid",
"cid": "cid",
"key": "key",
},
"location_map": {
"uid": "path",
"cid": "path",
"key": "query",
},
"collection_format_map": {
"key": "multi",
},
},
headers_map={
"accept": [],
"content_type": [],
},
api_client=api_client,
callable=__delete_app_settings,
)
def __get_user_app_settings(self, uid, cid, **kwargs):
"""Get User Application Settings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_user_app_settings(uid, cid, async_req=True)
>>> result = thread.get()
Args:
uid (str):
cid (str):
Keyword Args:
key ([str]): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_user_app_settings_info.BTUserAppSettingsInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["uid"] = uid
kwargs["cid"] = cid
return self.call_with_http_info(**kwargs)
self.get_user_app_settings = Endpoint(
settings={
"response_type":
(bt_user_app_settings_info.BTUserAppSettingsInfo, ),
"auth": [],
"endpoint_path":
"/api/applications/clients/{cid}/settings/users/{uid}",
"operation_id": "get_user_app_settings",
"http_method": "GET",
"servers": [],
},
params_map={
"all": [
"uid",
"cid",
"key",
],
"required": [
"uid",
"cid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"uid": (str, ),
"cid": (str, ),
"key": ([str], ),
},
"attribute_map": {
"uid": "uid",
"cid": "cid",
"key": "key",
},
"location_map": {
"uid": "path",
"cid": "path",
"key": "query",
},
"collection_format_map": {
"key": "multi",
},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_user_app_settings,
)
def __update_app_settings(self, uid, cid, bt_user_app_settings_params,
**kwargs):
"""Update Application Settings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_app_settings(uid, cid, bt_user_app_settings_params, async_req=True)
>>> result = thread.get()
Args:
uid (str):
cid (str):
bt_user_app_settings_params (bt_user_app_settings_params.BTUserAppSettingsParams):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["uid"] = uid
kwargs["cid"] = cid
kwargs["bt_user_app_settings_params"] = bt_user_app_settings_params
return self.call_with_http_info(**kwargs)
self.update_app_settings = Endpoint(
settings={
"response_type": None,
"auth": [],
"endpoint_path":
"/api/applications/clients/{cid}/settings/users/{uid}",
"operation_id": "update_app_settings",
"http_method": "POST",
"servers": [],
},
params_map={
"all": [
"uid",
"cid",
"bt_user_app_settings_params",
],
"required": [
"uid",
"cid",
"bt_user_app_settings_params",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"uid": (str, ),
"cid": (str, ),
"bt_user_app_settings_params":
(bt_user_app_settings_params.BTUserAppSettingsParams, ),
},
"attribute_map": {
"uid": "uid",
"cid": "cid",
},
"location_map": {
"uid": "path",
"cid": "path",
"bt_user_app_settings_params": "body",
},
"collection_format_map": {},
},
headers_map={
"accept": [],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__update_app_settings,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_user_settings(self, uid, **kwargs):
"""get_user_settings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_user_settings(uid, async_req=True)
>>> result = thread.get()
Args:
uid (str):
Keyword Args:
includematerials (bool): [optional] if omitted the server will use the default value of True
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_user_settings_info.BTUserSettingsInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["uid"] = uid
return self.call_with_http_info(**kwargs)
self.get_user_settings = Endpoint(
settings={
"response_type": (bt_user_settings_info.BTUserSettingsInfo, ),
"auth": [],
"endpoint_path": "/api/users/{uid}/settings",
"operation_id": "get_user_settings",
"http_method": "GET",
"servers": [],
},
params_map={
"all": [
"uid",
"includematerials",
],
"required": [
"uid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"uid": (str, ),
"includematerials": (bool, ),
},
"attribute_map": {
"uid": "uid",
"includematerials": "includematerials",
},
"location_map": {
"uid": "path",
"includematerials": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_user_settings,
)
def __get_user_settings_current_logged_in_user(self, **kwargs):
"""get_user_settings_current_logged_in_user # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_user_settings_current_logged_in_user(async_req=True)
>>> result = thread.get()
Keyword Args:
includematerials (bool): [optional] if omitted the server will use the default value of True
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_user_settings_info.BTUserSettingsInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
return self.call_with_http_info(**kwargs)
self.get_user_settings_current_logged_in_user = Endpoint(
settings={
"response_type": (bt_user_settings_info.BTUserSettingsInfo, ),
"auth": [],
"endpoint_path": "/api/users/settings",
"operation_id": "get_user_settings_current_logged_in_user",
"http_method": "GET",
"servers": [],
},
params_map={
"all": [
"includematerials",
],
"required": [],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"includematerials": (bool, ),
},
"attribute_map": {
"includematerials": "includematerials",
},
"location_map": {
"includematerials": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_user_settings_current_logged_in_user,
)
def __session_info(self, **kwargs):
"""session_info # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.session_info(async_req=True)
>>> result = thread.get()
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_user_o_auth2_summary_info.BTUserOAuth2SummaryInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
return self.call_with_http_info(**kwargs)
self.session_info = Endpoint(
settings={
"response_type":
(bt_user_o_auth2_summary_info.BTUserOAuth2SummaryInfo, ),
"auth": [],
"endpoint_path":
"/api/users/sessioninfo",
"operation_id":
"session_info",
"http_method":
"GET",
"servers": [],
},
params_map={
"all": [],
"required": [],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {},
"attribute_map": {},
"location_map": {},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__session_info,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __create_obsoletion_package(self, wfid, **kwargs):
"""create_obsoletion_package # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_obsoletion_package(wfid, async_req=True)
>>> result = thread.get()
Args:
wfid (str):
Keyword Args:
revision_id (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["wfid"] = wfid
return self.call_with_http_info(**kwargs)
self.create_obsoletion_package = Endpoint(
settings={
"response_type": None,
"auth": ["OAuth2"],
"endpoint_path": "/api/releasepackages/obsoletion/{wfid}",
"operation_id": "create_obsoletion_package",
"http_method": "POST",
"servers": [],
},
params_map={
"all": [
"wfid",
"revision_id",
],
"required": [
"wfid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"wfid": (str, ),
"revision_id": (str, ),
},
"attribute_map": {
"wfid": "wfid",
"revision_id": "revisionId",
},
"location_map": {
"wfid": "path",
"revision_id": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__create_obsoletion_package,
)
def __create_release_package(self, wfid, bt_release_package_params,
**kwargs):
"""create_release_package # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_release_package(wfid, bt_release_package_params, async_req=True)
>>> result = thread.get()
Args:
wfid (str):
bt_release_package_params (bt_release_package_params.BTReleasePackageParams):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["wfid"] = wfid
kwargs["bt_release_package_params"] = bt_release_package_params
return self.call_with_http_info(**kwargs)
self.create_release_package = Endpoint(
settings={
"response_type": None,
"auth": ["OAuth2"],
"endpoint_path": "/api/releasepackages/release/{wfid}",
"operation_id": "create_release_package",
"http_method": "POST",
"servers": [],
},
params_map={
"all": [
"wfid",
"bt_release_package_params",
],
"required": [
"wfid",
"bt_release_package_params",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"wfid": (str, ),
"bt_release_package_params":
(bt_release_package_params.BTReleasePackageParams, ),
},
"attribute_map": {
"wfid": "wfid",
},
"location_map": {
"wfid": "path",
"bt_release_package_params": "body",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__create_release_package,
)
def __get_company_release_workflow(self, **kwargs):
"""get_company_release_workflow # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_company_release_workflow(async_req=True)
>>> result = thread.get()
Keyword Args:
document_id (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_active_workflow_info.BTActiveWorkflowInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
return self.call_with_http_info(**kwargs)
self.get_company_release_workflow = Endpoint(
settings={
"response_type":
(bt_active_workflow_info.BTActiveWorkflowInfo, ),
"auth": ["OAuth2"],
"endpoint_path": "/api/releasepackages/companyreleaseworkflow",
"operation_id": "get_company_release_workflow",
"http_method": "GET",
"servers": [],
},
params_map={
"all": [
"document_id",
],
"required": [],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"document_id": (str, ),
},
"attribute_map": {
"document_id": "documentId",
},
"location_map": {
"document_id": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_company_release_workflow,
)
def __get_release_package(self, rpid, **kwargs):
"""get_release_package # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_release_package(rpid, async_req=True)
>>> result = thread.get()
Args:
rpid (str):
Keyword Args:
detailed (bool): [optional] if omitted the server will use the default value of False
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_release_package_info.BTReleasePackageInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["rpid"] = rpid
return self.call_with_http_info(**kwargs)
self.get_release_package = Endpoint(
settings={
"response_type":
(bt_release_package_info.BTReleasePackageInfo, ),
"auth": ["OAuth2"],
"endpoint_path": "/api/releasepackages/{rpid}",
"operation_id": "get_release_package",
"http_method": "GET",
"servers": [],
},
params_map={
"all": [
"rpid",
"detailed",
],
"required": [
"rpid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"rpid": (str, ),
"detailed": (bool, ),
},
"attribute_map": {
"rpid": "rpid",
"detailed": "detailed",
},
"location_map": {
"rpid": "path",
"detailed": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_release_package,
)
def __update_release_package(self, rpid,
bt_update_release_package_params,
**kwargs):
"""update_release_package # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_release_package(rpid, bt_update_release_package_params, async_req=True)
>>> result = thread.get()
Args:
rpid (str):
bt_update_release_package_params (bt_update_release_package_params.BTUpdateReleasePackageParams):
Keyword Args:
action (str): [optional] if omitted the server will use the default value of 'UPDATE'
wfaction (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_release_package_info.BTReleasePackageInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["rpid"] = rpid
kwargs[
"bt_update_release_package_params"] = bt_update_release_package_params
return self.call_with_http_info(**kwargs)
self.update_release_package = Endpoint(
settings={
"response_type":
(bt_release_package_info.BTReleasePackageInfo, ),
"auth": ["OAuth2"],
"endpoint_path": "/api/releasepackages/{rpid}",
"operation_id": "update_release_package",
"http_method": "POST",
"servers": [],
},
params_map={
"all": [
"rpid",
"bt_update_release_package_params",
"action",
"wfaction",
],
"required": [
"rpid",
"bt_update_release_package_params",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"rpid": (str, ),
"bt_update_release_package_params":
(bt_update_release_package_params.
BTUpdateReleasePackageParams, ),
"action": (str, ),
"wfaction": (str, ),
},
"attribute_map": {
"rpid": "rpid",
"action": "action",
"wfaction": "wfaction",
},
"location_map": {
"rpid": "path",
"bt_update_release_package_params": "body",
"action": "query",
"wfaction": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__update_release_package,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __delete_app_settings(self, uid, cid, **kwargs):
"""Delete Application Settings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_app_settings(uid, cid, async_req=True)
>>> result = thread.get()
Args:
uid (str):
cid (str):
Keyword Args:
key ([str]): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['uid'] = \
uid
kwargs['cid'] = \
cid
return self.call_with_http_info(**kwargs)
self.delete_app_settings = Endpoint(settings={
'response_type': None,
'auth': [],
'endpoint_path':
'/api/applications/clients/{cid}/settings/users/{uid}',
'operation_id': 'delete_app_settings',
'http_method': 'DELETE',
'servers': [],
},
params_map={
'all': [
'uid',
'cid',
'key',
],
'required': [
'uid',
'cid',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'uid': (str, ),
'cid': (str, ),
'key': ([str], ),
},
'attribute_map': {
'uid': 'uid',
'cid': 'cid',
'key': 'key',
},
'location_map': {
'uid': 'path',
'cid': 'path',
'key': 'query',
},
'collection_format_map': {
'key': 'multi',
}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__delete_app_settings)
def __get_user_app_settings(self, uid, cid, **kwargs):
"""Get User Application Settings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_user_app_settings(uid, cid, async_req=True)
>>> result = thread.get()
Args:
uid (str):
cid (str):
Keyword Args:
key ([str]): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_user_app_settings_info.BTUserAppSettingsInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['uid'] = \
uid
kwargs['cid'] = \
cid
return self.call_with_http_info(**kwargs)
self.get_user_app_settings = Endpoint(
settings={
'response_type':
(bt_user_app_settings_info.BTUserAppSettingsInfo, ),
'auth': [],
'endpoint_path':
'/api/applications/clients/{cid}/settings/users/{uid}',
'operation_id': 'get_user_app_settings',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'uid',
'cid',
'key',
],
'required': [
'uid',
'cid',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'uid': (str, ),
'cid': (str, ),
'key': ([str], ),
},
'attribute_map': {
'uid': 'uid',
'cid': 'cid',
'key': 'key',
},
'location_map': {
'uid': 'path',
'cid': 'path',
'key': 'query',
},
'collection_format_map': {
'key': 'multi',
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__get_user_app_settings)
def __update_app_settings(self, uid, cid, bt_user_app_settings_params,
**kwargs):
"""Update Application Settings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_app_settings(uid, cid, bt_user_app_settings_params, async_req=True)
>>> result = thread.get()
Args:
uid (str):
cid (str):
bt_user_app_settings_params (bt_user_app_settings_params.BTUserAppSettingsParams):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['uid'] = \
uid
kwargs['cid'] = \
cid
kwargs['bt_user_app_settings_params'] = \
bt_user_app_settings_params
return self.call_with_http_info(**kwargs)
self.update_app_settings = Endpoint(
settings={
'response_type': None,
'auth': [],
'endpoint_path':
'/api/applications/clients/{cid}/settings/users/{uid}',
'operation_id': 'update_app_settings',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'uid',
'cid',
'bt_user_app_settings_params',
],
'required': [
'uid',
'cid',
'bt_user_app_settings_params',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'uid': (str, ),
'cid': (str, ),
'bt_user_app_settings_params':
(bt_user_app_settings_params.BTUserAppSettingsParams, ),
},
'attribute_map': {
'uid': 'uid',
'cid': 'cid',
},
'location_map': {
'uid': 'path',
'cid': 'path',
'bt_user_app_settings_params': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': ['application/json;charset=UTF-8; qs=0.09']
},
api_client=api_client,
callable=__update_app_settings)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_client_plans(self, cid, **kwargs):
"""Get billing plans for client. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_client_plans(cid, async_req=True)
>>> result = thread.get()
Args:
cid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['cid'] = \
cid
return self.call_with_http_info(**kwargs)
self.get_client_plans = Endpoint(settings={
'response_type': None,
'auth': [],
'endpoint_path': '/api/billing/plans/client/{cid}',
'operation_id': 'get_client_plans',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'cid',
],
'required': [
'cid',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'cid': (str, ),
},
'attribute_map': {
'cid': 'cid',
},
'location_map': {
'cid': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__get_client_plans)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_folder_acl(self, fid, **kwargs):
"""Get Access Control List # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_folder_acl(fid, async_req=True)
>>> result = thread.get()
Args:
fid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_acl_info.BTAclInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["fid"] = fid
return self.call_with_http_info(**kwargs)
self.get_folder_acl = Endpoint(
settings={
"response_type": (bt_acl_info.BTAclInfo, ),
"auth": ["OAuth2"],
"endpoint_path": "/api/folders/{fid}/acl",
"operation_id": "get_folder_acl",
"http_method": "GET",
"servers": [],
},
params_map={
"all": [
"fid",
],
"required": [
"fid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"fid": (str, ),
},
"attribute_map": {
"fid": "fid",
},
"location_map": {
"fid": "path",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_folder_acl,
)
def __share(self, fid, bt_share_params, **kwargs):
"""Share Folder # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.share(fid, bt_share_params, async_req=True)
>>> result = thread.get()
Args:
fid (str):
bt_share_params (bt_share_params.BTShareParams):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_acl_info.BTAclInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["fid"] = fid
kwargs["bt_share_params"] = bt_share_params
return self.call_with_http_info(**kwargs)
self.share = Endpoint(
settings={
"response_type": (bt_acl_info.BTAclInfo, ),
"auth": ["OAuth2"],
"endpoint_path": "/api/folders/{fid}/share",
"operation_id": "share",
"http_method": "POST",
"servers": [],
},
params_map={
"all": [
"fid",
"bt_share_params",
],
"required": [
"fid",
"bt_share_params",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"fid": (str, ),
"bt_share_params": (bt_share_params.BTShareParams, ),
},
"attribute_map": {
"fid": "fid",
},
"location_map": {
"fid": "path",
"bt_share_params": "body",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__share,
)
def __un_share(self, fid, eid, **kwargs):
"""Unshare Folder # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.un_share(fid, eid, async_req=True)
>>> result = thread.get()
Args:
fid (str):
eid (str):
Keyword Args:
entry_type (int): [optional] if omitted the server will use the default value of 0
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["fid"] = fid
kwargs["eid"] = eid
return self.call_with_http_info(**kwargs)
self.un_share = Endpoint(
settings={
"response_type": None,
"auth": ["OAuth2"],
"endpoint_path": "/api/folders/{fid}/share/{eid}",
"operation_id": "un_share",
"http_method": "DELETE",
"servers": [],
},
params_map={
"all": [
"fid",
"eid",
"entry_type",
],
"required": [
"fid",
"eid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"fid": (str, ),
"eid": (str, ),
"entry_type": (int, ),
},
"attribute_map": {
"fid": "fid",
"eid": "eid",
"entry_type": "entryType",
},
"location_map": {
"fid": "path",
"eid": "path",
"entry_type": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__un_share,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __enumerate_revisions(
self,
cid,
**kwargs
):
"""enumerate_revisions # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.enumerate_revisions(cid, async_req=True)
>>> result = thread.get()
Args:
cid (str):
Keyword Args:
element_type (int): [optional]
limit (int): [optional] if omitted the server will use the default value of 20
offset (int): [optional] if omitted the server will use the default value of 0
latest_only (bool): [optional] if omitted the server will use the default value of False
after (int): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_list_response_bt_revision_info.BTListResponseBTRevisionInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['cid'] = \
cid
return self.call_with_http_info(**kwargs)
self.enumerate_revisions = Endpoint(
settings={
'response_type': (bt_list_response_bt_revision_info.BTListResponseBTRevisionInfo,),
'auth': [
'OAuth2'
],
'endpoint_path': '/api/revisions/companies/{cid}',
'operation_id': 'enumerate_revisions',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'cid',
'element_type',
'limit',
'offset',
'latest_only',
'after',
],
'required': [
'cid',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'cid':
(str,),
'element_type':
(int,),
'limit':
(int,),
'offset':
(int,),
'latest_only':
(bool,),
'after':
(int,),
},
'attribute_map': {
'cid': 'cid',
'element_type': 'elementType',
'limit': 'limit',
'offset': 'offset',
'latest_only': 'latestOnly',
'after': 'after',
},
'location_map': {
'cid': 'path',
'element_type': 'query',
'limit': 'query',
'offset': 'query',
'latest_only': 'query',
'after': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__enumerate_revisions
)
def __get_latest_in_document_or_company(
self,
cd,
cdid,
pnum,
**kwargs
):
"""get_latest_in_document_or_company # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_latest_in_document_or_company(cd, cdid, pnum, async_req=True)
>>> result = thread.get()
Args:
cd (str):
cdid (str):
pnum (str):
Keyword Args:
et (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_revision_info.BTRevisionInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['cd'] = \
cd
kwargs['cdid'] = \
cdid
kwargs['pnum'] = \
pnum
return self.call_with_http_info(**kwargs)
self.get_latest_in_document_or_company = Endpoint(
settings={
'response_type': (bt_revision_info.BTRevisionInfo,),
'auth': [
'OAuth2'
],
'endpoint_path': '/api/revisions/{cd}/{cdid}/p/{pnum}/latest',
'operation_id': 'get_latest_in_document_or_company',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'cd',
'cdid',
'pnum',
'et',
],
'required': [
'cd',
'cdid',
'pnum',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'cd':
(str,),
'cdid':
(str,),
'pnum':
(str,),
'et':
(str,),
},
'attribute_map': {
'cd': 'cd',
'cdid': 'cdid',
'pnum': 'pnum',
'et': 'et',
},
'location_map': {
'cd': 'path',
'cdid': 'path',
'pnum': 'path',
'et': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__get_latest_in_document_or_company
)
def __get_revision_history_in_company(
self,
cid,
pnum,
**kwargs
):
"""get_revision_history_in_company # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_revision_history_in_company(cid, pnum, async_req=True)
>>> result = thread.get()
Args:
cid (str):
pnum (str):
Keyword Args:
element_type (str): [optional]
fill_approvers (bool): [optional] if omitted the server will use the default value of False
fill_export_permission (bool): [optional] if omitted the server will use the default value of False
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_list_response_bt_revision_info.BTListResponseBTRevisionInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['cid'] = \
cid
kwargs['pnum'] = \
pnum
return self.call_with_http_info(**kwargs)
self.get_revision_history_in_company = Endpoint(
settings={
'response_type': (bt_list_response_bt_revision_info.BTListResponseBTRevisionInfo,),
'auth': [
'OAuth2'
],
'endpoint_path': '/api/revisions/companies/{cid}/partnumber/{pnum}',
'operation_id': 'get_revision_history_in_company',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'cid',
'pnum',
'element_type',
'fill_approvers',
'fill_export_permission',
],
'required': [
'cid',
'pnum',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'cid':
(str,),
'pnum':
(str,),
'element_type':
(str,),
'fill_approvers':
(bool,),
'fill_export_permission':
(bool,),
},
'attribute_map': {
'cid': 'cid',
'pnum': 'pnum',
'element_type': 'elementType',
'fill_approvers': 'fillApprovers',
'fill_export_permission': 'fillExportPermission',
},
'location_map': {
'cid': 'path',
'pnum': 'path',
'element_type': 'query',
'fill_approvers': 'query',
'fill_export_permission': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__get_revision_history_in_company
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __find(self, **kwargs):
"""find # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find(async_req=True)
>>> result = thread.get()
Keyword Args:
prefix (str): [optional] if omitted the server will use the default value of ''
uid (str): [optional]
company_id (str): [optional]
include_company_owned_teams (bool): [optional] if omitted the server will use the default value of True
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_global_tree_node_list_response_bt_team_info.BTGlobalTreeNodeListResponseBTTeamInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
return self.call_with_http_info(**kwargs)
self.find = Endpoint(
settings={
"response_type": (
bt_global_tree_node_list_response_bt_team_info.BTGlobalTreeNodeListResponseBTTeamInfo,
),
"auth": ["OAuth2"],
"endpoint_path": "/api/teams",
"operation_id": "find",
"http_method": "GET",
"servers": [],
},
params_map={
"all": ["prefix", "uid", "company_id", "include_company_owned_teams",],
"required": [],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"prefix": (str,),
"uid": (str,),
"company_id": (str,),
"include_company_owned_teams": (bool,),
},
"attribute_map": {
"prefix": "prefix",
"uid": "uid",
"company_id": "companyId",
"include_company_owned_teams": "includeCompanyOwnedTeams",
},
"location_map": {
"prefix": "query",
"uid": "query",
"company_id": "query",
"include_company_owned_teams": "query",
},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__find,
)
def __get_team(self, tid, **kwargs):
"""get_team # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_team(tid, async_req=True)
>>> result = thread.get()
Args:
tid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_team_info.BTTeamInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["tid"] = tid
return self.call_with_http_info(**kwargs)
self.get_team = Endpoint(
settings={
"response_type": (bt_team_info.BTTeamInfo,),
"auth": ["OAuth2"],
"endpoint_path": "/api/teams/{tid}",
"operation_id": "get_team",
"http_method": "GET",
"servers": [],
},
params_map={
"all": ["tid",],
"required": ["tid",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {"tid": (str,),},
"attribute_map": {"tid": "tid",},
"location_map": {"tid": "path",},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_team,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_client_plans(self, cid, **kwargs):
"""Get billing plans for client. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_client_plans(cid, async_req=True)
>>> result = thread.get()
Args:
cid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["cid"] = cid
return self.call_with_http_info(**kwargs)
self.get_client_plans = Endpoint(
settings={
"response_type": None,
"auth": [],
"endpoint_path": "/api/billing/plans/client/{cid}",
"operation_id": "get_client_plans",
"http_method": "GET",
"servers": [],
},
params_map={
"all": ["cid",],
"required": ["cid",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {"cid": (str,),},
"attribute_map": {"cid": "cid",},
"location_map": {"cid": "path",},
"collection_format_map": {},
},
headers_map={"accept": [], "content_type": [],},
api_client=api_client,
callable=__get_client_plans,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __create_translation(self, did, wid, **kwargs):
"""Create translation from upload. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_translation(did, wid, async_req=True)
>>> result = thread.get()
Args:
did (str):
wid (str):
Keyword Args:
allow_faulty_parts (bool): [optional]
create_composite (bool): [optional]
create_drawing_if_possible (bool): [optional]
encoded_filename (str): [optional]
extract_assembly_hierarchy (bool): [optional]
file (file_type): [optional]
file_body_with_details (form_data_body_part.FormDataBodyPart): [optional]
file_content_length (int): [optional]
file_detail (form_data_content_disposition.FormDataContentDisposition): [optional]
flatten_assemblies (bool): [optional]
format_name (str): [optional]
isy_axis_is_up (bool): [optional]
join_adjacent_surfaces (bool): [optional]
location_element_id (str): [optional]
location_group_id (str): [optional]
location_position (int): [optional]
notify_user (bool): [optional]
owner_id (str): [optional]
owner_type (str): [optional]
parent_id (str): [optional]
project_id (str): [optional]
public (bool): [optional]
split_assemblies_into_multiple_documents (bool): [optional]
store_in_document (bool): [optional]
translate (bool): [optional]
unit (str): [optional]
upload_id (str): [optional]
version_string (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_translation_request_info.BTTranslationRequestInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["wid"] = wid
return self.call_with_http_info(**kwargs)
self.create_translation = Endpoint(
settings={
"response_type": (
bt_translation_request_info.BTTranslationRequestInfo,
),
"auth": ["OAuth2"],
"endpoint_path": "/api/translations/d/{did}/w/{wid}",
"operation_id": "create_translation",
"http_method": "POST",
"servers": [],
},
params_map={
"all": [
"did",
"wid",
"allow_faulty_parts",
"create_composite",
"create_drawing_if_possible",
"encoded_filename",
"extract_assembly_hierarchy",
"file",
"file_body_with_details",
"file_content_length",
"file_detail",
"flatten_assemblies",
"format_name",
"isy_axis_is_up",
"join_adjacent_surfaces",
"location_element_id",
"location_group_id",
"location_position",
"notify_user",
"owner_id",
"owner_type",
"parent_id",
"project_id",
"public",
"split_assemblies_into_multiple_documents",
"store_in_document",
"translate",
"unit",
"upload_id",
"version_string",
],
"required": ["did", "wid",],
"nullable": [],
"enum": ["owner_type",],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {
("owner_type",): {
"USER": "******",
"COMPANY": "COMPANY",
"ONSHAPE": "ONSHAPE",
},
},
"openapi_types": {
"did": (str,),
"wid": (str,),
"allow_faulty_parts": (bool,),
"create_composite": (bool,),
"create_drawing_if_possible": (bool,),
"encoded_filename": (str,),
"extract_assembly_hierarchy": (bool,),
"file": (file_type,),
"file_body_with_details": (form_data_body_part.FormDataBodyPart,),
"file_content_length": (int,),
"file_detail": (
form_data_content_disposition.FormDataContentDisposition,
),
"flatten_assemblies": (bool,),
"format_name": (str,),
"isy_axis_is_up": (bool,),
"join_adjacent_surfaces": (bool,),
"location_element_id": (str,),
"location_group_id": (str,),
"location_position": (int,),
"notify_user": (bool,),
"owner_id": (str,),
"owner_type": (str,),
"parent_id": (str,),
"project_id": (str,),
"public": (bool,),
"split_assemblies_into_multiple_documents": (bool,),
"store_in_document": (bool,),
"translate": (bool,),
"unit": (str,),
"upload_id": (str,),
"version_string": (str,),
},
"attribute_map": {
"did": "did",
"wid": "wid",
"allow_faulty_parts": "allowFaultyParts",
"create_composite": "createComposite",
"create_drawing_if_possible": "createDrawingIfPossible",
"encoded_filename": "encodedFilename",
"extract_assembly_hierarchy": "extractAssemblyHierarchy",
"file": "file",
"file_body_with_details": "fileBodyWithDetails",
"file_content_length": "fileContentLength",
"file_detail": "fileDetail",
"flatten_assemblies": "flattenAssemblies",
"format_name": "formatName",
"isy_axis_is_up": "isyAxisIsUp",
"join_adjacent_surfaces": "joinAdjacentSurfaces",
"location_element_id": "locationElementId",
"location_group_id": "locationGroupId",
"location_position": "locationPosition",
"notify_user": "******",
"owner_id": "ownerId",
"owner_type": "ownerType",
"parent_id": "parentId",
"project_id": "projectId",
"public": "public",
"split_assemblies_into_multiple_documents": "splitAssembliesIntoMultipleDocuments",
"store_in_document": "storeInDocument",
"translate": "translate",
"unit": "unit",
"upload_id": "uploadId",
"version_string": "versionString",
},
"location_map": {
"did": "path",
"wid": "path",
"allow_faulty_parts": "form",
"create_composite": "form",
"create_drawing_if_possible": "form",
"encoded_filename": "form",
"extract_assembly_hierarchy": "form",
"file": "form",
"file_body_with_details": "form",
"file_content_length": "form",
"file_detail": "form",
"flatten_assemblies": "form",
"format_name": "form",
"isy_axis_is_up": "form",
"join_adjacent_surfaces": "form",
"location_element_id": "form",
"location_group_id": "form",
"location_position": "form",
"notify_user": "******",
"owner_id": "form",
"owner_type": "form",
"parent_id": "form",
"project_id": "form",
"public": "form",
"split_assemblies_into_multiple_documents": "form",
"store_in_document": "form",
"translate": "form",
"unit": "form",
"upload_id": "form",
"version_string": "form",
},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["multipart/form-data"],
},
api_client=api_client,
callable=__create_translation,
)
def __delete_translation(self, tid, **kwargs):
"""delete_translation # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_translation(tid, async_req=True)
>>> result = thread.get()
Args:
tid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["tid"] = tid
return self.call_with_http_info(**kwargs)
self.delete_translation = Endpoint(
settings={
"response_type": None,
"auth": ["OAuth2"],
"endpoint_path": "/api/translations/{tid}",
"operation_id": "delete_translation",
"http_method": "DELETE",
"servers": [],
},
params_map={
"all": ["tid",],
"required": ["tid",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {"tid": (str,),},
"attribute_map": {"tid": "tid",},
"location_map": {"tid": "path",},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__delete_translation,
)
def __get_all_translator_formats(self, **kwargs):
"""get_all_translator_formats # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_all_translator_formats(async_req=True)
>>> result = thread.get()
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
[bt_model_format_full_info.BTModelFormatFullInfo]
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
return self.call_with_http_info(**kwargs)
self.get_all_translator_formats = Endpoint(
settings={
"response_type": ([bt_model_format_full_info.BTModelFormatFullInfo],),
"auth": [],
"endpoint_path": "/api/translations/translationformats",
"operation_id": "get_all_translator_formats",
"http_method": "GET",
"servers": [],
},
params_map={
"all": [],
"required": [],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {},
"attribute_map": {},
"location_map": {},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_all_translator_formats,
)
def __get_document_translations(self, did, **kwargs):
"""get_document_translations # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_document_translations(did, async_req=True)
>>> result = thread.get()
Args:
did (str):
Keyword Args:
offset (int): [optional] if omitted the server will use the default value of 0
limit (int): [optional] if omitted the server will use the default value of 20
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_list_response_bt_translation_request_info.BTListResponseBTTranslationRequestInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
return self.call_with_http_info(**kwargs)
self.get_document_translations = Endpoint(
settings={
"response_type": (
bt_list_response_bt_translation_request_info.BTListResponseBTTranslationRequestInfo,
),
"auth": ["OAuth2"],
"endpoint_path": "/api/translations/d/{did}",
"operation_id": "get_document_translations",
"http_method": "GET",
"servers": [],
},
params_map={
"all": ["did", "offset", "limit",],
"required": ["did",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {"did": (str,), "offset": (int,), "limit": (int,),},
"attribute_map": {"did": "did", "offset": "offset", "limit": "limit",},
"location_map": {"did": "path", "offset": "query", "limit": "query",},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_document_translations,
)
def __get_translation(self, tid, **kwargs):
"""get_translation # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_translation(tid, async_req=True)
>>> result = thread.get()
Args:
tid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_translation_request_info.BTTranslationRequestInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["tid"] = tid
return self.call_with_http_info(**kwargs)
self.get_translation = Endpoint(
settings={
"response_type": (
bt_translation_request_info.BTTranslationRequestInfo,
),
"auth": ["OAuth2"],
"endpoint_path": "/api/translations/{tid}",
"operation_id": "get_translation",
"http_method": "GET",
"servers": [],
},
params_map={
"all": ["tid",],
"required": ["tid",],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {"tid": (str,),},
"attribute_map": {"tid": "tid",},
"location_map": {"tid": "path",},
"collection_format_map": {},
},
headers_map={
"accept": ["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_translation,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __enumerate_revisions(self, cid, **kwargs):
"""enumerate_revisions # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.enumerate_revisions(cid, async_req=True)
>>> result = thread.get()
Args:
cid (str):
Keyword Args:
element_type (int): [optional]
limit (int): [optional] if omitted the server will use the default value of 20
offset (int): [optional] if omitted the server will use the default value of 0
latest_only (bool): [optional] if omitted the server will use the default value of False
after (int): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_list_response_bt_revision_info.BTListResponseBTRevisionInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["cid"] = cid
return self.call_with_http_info(**kwargs)
self.enumerate_revisions = Endpoint(
settings={
"response_type": (bt_list_response_bt_revision_info.
BTListResponseBTRevisionInfo, ),
"auth": ["OAuth2"],
"endpoint_path":
"/api/revisions/companies/{cid}",
"operation_id":
"enumerate_revisions",
"http_method":
"GET",
"servers": [],
},
params_map={
"all": [
"cid",
"element_type",
"limit",
"offset",
"latest_only",
"after",
],
"required": [
"cid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"cid": (str, ),
"element_type": (int, ),
"limit": (int, ),
"offset": (int, ),
"latest_only": (bool, ),
"after": (int, ),
},
"attribute_map": {
"cid": "cid",
"element_type": "elementType",
"limit": "limit",
"offset": "offset",
"latest_only": "latestOnly",
"after": "after",
},
"location_map": {
"cid": "path",
"element_type": "query",
"limit": "query",
"offset": "query",
"latest_only": "query",
"after": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__enumerate_revisions,
)
def __get_latest_in_document_or_company(self, cd, cdid, pnum,
**kwargs):
"""get_latest_in_document_or_company # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_latest_in_document_or_company(cd, cdid, pnum, async_req=True)
>>> result = thread.get()
Args:
cd (str):
cdid (str):
pnum (str):
Keyword Args:
et (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_revision_info.BTRevisionInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["cd"] = cd
kwargs["cdid"] = cdid
kwargs["pnum"] = pnum
return self.call_with_http_info(**kwargs)
self.get_latest_in_document_or_company = Endpoint(
settings={
"response_type": (bt_revision_info.BTRevisionInfo, ),
"auth": ["OAuth2"],
"endpoint_path": "/api/revisions/{cd}/{cdid}/p/{pnum}/latest",
"operation_id": "get_latest_in_document_or_company",
"http_method": "GET",
"servers": [],
},
params_map={
"all": [
"cd",
"cdid",
"pnum",
"et",
],
"required": [
"cd",
"cdid",
"pnum",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"cd": (str, ),
"cdid": (str, ),
"pnum": (str, ),
"et": (str, ),
},
"attribute_map": {
"cd": "cd",
"cdid": "cdid",
"pnum": "pnum",
"et": "et",
},
"location_map": {
"cd": "path",
"cdid": "path",
"pnum": "path",
"et": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_latest_in_document_or_company,
)
def __get_revision_history_in_company(self, cid, pnum, **kwargs):
"""get_revision_history_in_company # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_revision_history_in_company(cid, pnum, async_req=True)
>>> result = thread.get()
Args:
cid (str):
pnum (str):
Keyword Args:
element_type (str): [optional]
fill_approvers (bool): [optional] if omitted the server will use the default value of False
fill_export_permission (bool): [optional] if omitted the server will use the default value of False
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_list_response_bt_revision_info.BTListResponseBTRevisionInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["cid"] = cid
kwargs["pnum"] = pnum
return self.call_with_http_info(**kwargs)
self.get_revision_history_in_company = Endpoint(
settings={
"response_type": (bt_list_response_bt_revision_info.
BTListResponseBTRevisionInfo, ),
"auth": ["OAuth2"],
"endpoint_path":
"/api/revisions/companies/{cid}/partnumber/{pnum}",
"operation_id":
"get_revision_history_in_company",
"http_method":
"GET",
"servers": [],
},
params_map={
"all": [
"cid",
"pnum",
"element_type",
"fill_approvers",
"fill_export_permission",
],
"required": [
"cid",
"pnum",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"cid": (str, ),
"pnum": (str, ),
"element_type": (str, ),
"fill_approvers": (bool, ),
"fill_export_permission": (bool, ),
},
"attribute_map": {
"cid": "cid",
"pnum": "pnum",
"element_type": "elementType",
"fill_approvers": "fillApprovers",
"fill_export_permission": "fillExportPermission",
},
"location_map": {
"cid": "path",
"pnum": "path",
"element_type": "query",
"fill_approvers": "query",
"fill_export_permission": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_revision_history_in_company,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __create_blob_translation(self, did, wv, wvid, eid,
bt_translate_format_params, **kwargs):
"""Create Translation. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_blob_translation(did, wv, wvid, eid, bt_translate_format_params, async_req=True)
>>> result = thread.get()
Args:
did (str):
wv (str):
wvid (str):
eid (str):
bt_translate_format_params (bt_translate_format_params.BTTranslateFormatParams):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_translation_request_info.BTTranslationRequestInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['did'] = \
did
kwargs['wv'] = \
wv
kwargs['wvid'] = \
wvid
kwargs['eid'] = \
eid
kwargs['bt_translate_format_params'] = \
bt_translate_format_params
return self.call_with_http_info(**kwargs)
self.create_blob_translation = Endpoint(
settings={
'response_type':
(bt_translation_request_info.BTTranslationRequestInfo, ),
'auth': ['OAuth2'],
'endpoint_path':
'/api/blobelements/d/{did}/{wv}/{wvid}/e/{eid}/translations',
'operation_id':
'create_blob_translation',
'http_method':
'POST',
'servers': [],
},
params_map={
'all': [
'did',
'wv',
'wvid',
'eid',
'bt_translate_format_params',
],
'required': [
'did',
'wv',
'wvid',
'eid',
'bt_translate_format_params',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'did': (str, ),
'wv': (str, ),
'wvid': (str, ),
'eid': (str, ),
'bt_translate_format_params':
(bt_translate_format_params.BTTranslateFormatParams, ),
},
'attribute_map': {
'did': 'did',
'wv': 'wv',
'wvid': 'wvid',
'eid': 'eid',
},
'location_map': {
'did': 'path',
'wv': 'path',
'wvid': 'path',
'eid': 'path',
'bt_translate_format_params': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept':
['application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'],
'content_type': ['application/json;charset=UTF-8; qs=0.09']
},
api_client=api_client,
callable=__create_blob_translation)
def __download_file_workspace(self, did, wid, eid, **kwargs):
"""Download File From Blob Element. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.download_file_workspace(did, wid, eid, async_req=True)
>>> result = thread.get()
Args:
did (str):
wid (str):
eid (str):
Keyword Args:
content_disposition (str): [optional]
if_none_match (str): [optional]
link_document_id (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
file_type
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['did'] = \
did
kwargs['wid'] = \
wid
kwargs['eid'] = \
eid
return self.call_with_http_info(**kwargs)
self.download_file_workspace = Endpoint(
settings={
'response_type': (file_type, ),
'auth': ['OAuth2'],
'endpoint_path': '/api/blobelements/d/{did}/w/{wid}/e/{eid}',
'operation_id': 'download_file_workspace',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'did',
'wid',
'eid',
'content_disposition',
'if_none_match',
'link_document_id',
],
'required': [
'did',
'wid',
'eid',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'did': (str, ),
'wid': (str, ),
'eid': (str, ),
'content_disposition': (str, ),
'if_none_match': (str, ),
'link_document_id': (str, ),
},
'attribute_map': {
'did': 'did',
'wid': 'wid',
'eid': 'eid',
'content_disposition': 'contentDisposition',
'if_none_match': 'If-None-Match',
'link_document_id': 'linkDocumentId',
},
'location_map': {
'did': 'path',
'wid': 'path',
'eid': 'path',
'content_disposition': 'query',
'if_none_match': 'header',
'link_document_id': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/octet-stream'],
'content_type': [],
},
api_client=api_client,
callable=__download_file_workspace)
def __update_units(self, did, eid, wid, bt_update_mesh_units_params,
**kwargs):
"""Update Mesh Units. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_units(did, eid, wid, bt_update_mesh_units_params, async_req=True)
>>> result = thread.get()
Args:
did (str):
eid (str):
wid (str):
bt_update_mesh_units_params (bt_update_mesh_units_params.BTUpdateMeshUnitsParams):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_document_element_processing_info.BTDocumentElementProcessingInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['did'] = \
did
kwargs['eid'] = \
eid
kwargs['wid'] = \
wid
kwargs['bt_update_mesh_units_params'] = \
bt_update_mesh_units_params
return self.call_with_http_info(**kwargs)
self.update_units = Endpoint(
settings={
'response_type': (bt_document_element_processing_info.
BTDocumentElementProcessingInfo, ),
'auth': ['OAuth2'],
'endpoint_path':
'/api/blobelements/d/{did}/w/{wid}/e/{eid}/units',
'operation_id':
'update_units',
'http_method':
'POST',
'servers': [],
},
params_map={
'all': [
'did',
'eid',
'wid',
'bt_update_mesh_units_params',
],
'required': [
'did',
'eid',
'wid',
'bt_update_mesh_units_params',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'did': (str, ),
'eid': (str, ),
'wid': (str, ),
'bt_update_mesh_units_params':
(bt_update_mesh_units_params.BTUpdateMeshUnitsParams, ),
},
'attribute_map': {
'did': 'did',
'eid': 'eid',
'wid': 'wid',
},
'location_map': {
'did': 'path',
'eid': 'path',
'wid': 'path',
'bt_update_mesh_units_params': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept':
['application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'],
'content_type': ['application/json;charset=UTF-8; qs=0.09']
},
api_client=api_client,
callable=__update_units)
def __upload_file_create_element(self, did, wid, **kwargs):
"""Upload file to new element. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.upload_file_create_element(did, wid, async_req=True)
>>> result = thread.get()
Args:
did (str):
wid (str):
Keyword Args:
allow_faulty_parts (bool): [optional]
create_composite (bool): [optional]
create_drawing_if_possible (bool): [optional]
encoded_filename (str): [optional]
extract_assembly_hierarchy (bool): [optional]
file (file_type): [optional]
file_body_with_details (form_data_body_part.FormDataBodyPart): [optional]
file_content_length (int): [optional]
file_detail (form_data_content_disposition.FormDataContentDisposition): [optional]
flatten_assemblies (bool): [optional]
format_name (str): [optional]
isy_axis_is_up (bool): [optional]
join_adjacent_surfaces (bool): [optional]
location_element_id (str): [optional]
location_group_id (str): [optional]
location_position (int): [optional]
notify_user (bool): [optional]
owner_id (str): [optional]
owner_type (str): [optional]
parent_id (str): [optional]
project_id (str): [optional]
public (bool): [optional]
split_assemblies_into_multiple_documents (bool): [optional]
store_in_document (bool): [optional]
translate (bool): [optional]
unit (str): [optional]
upload_id (str): [optional]
version_string (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_document_element_processing_info.BTDocumentElementProcessingInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['did'] = \
did
kwargs['wid'] = \
wid
return self.call_with_http_info(**kwargs)
self.upload_file_create_element = Endpoint(
settings={
'response_type': (bt_document_element_processing_info.
BTDocumentElementProcessingInfo, ),
'auth': ['OAuth2'],
'endpoint_path':
'/api/blobelements/d/{did}/w/{wid}',
'operation_id':
'upload_file_create_element',
'http_method':
'POST',
'servers': [],
},
params_map={
'all': [
'did',
'wid',
'allow_faulty_parts',
'create_composite',
'create_drawing_if_possible',
'encoded_filename',
'extract_assembly_hierarchy',
'file',
'file_body_with_details',
'file_content_length',
'file_detail',
'flatten_assemblies',
'format_name',
'isy_axis_is_up',
'join_adjacent_surfaces',
'location_element_id',
'location_group_id',
'location_position',
'notify_user',
'owner_id',
'owner_type',
'parent_id',
'project_id',
'public',
'split_assemblies_into_multiple_documents',
'store_in_document',
'translate',
'unit',
'upload_id',
'version_string',
],
'required': [
'did',
'wid',
],
'nullable': [],
'enum': [
'owner_type',
],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {
('owner_type', ): {
"USER": "******",
"COMPANY": "COMPANY",
"ONSHAPE": "ONSHAPE"
},
},
'openapi_types': {
'did': (str, ),
'wid': (str, ),
'allow_faulty_parts': (bool, ),
'create_composite': (bool, ),
'create_drawing_if_possible': (bool, ),
'encoded_filename': (str, ),
'extract_assembly_hierarchy': (bool, ),
'file': (file_type, ),
'file_body_with_details':
(form_data_body_part.FormDataBodyPart, ),
'file_content_length': (int, ),
'file_detail':
(form_data_content_disposition.FormDataContentDisposition,
),
'flatten_assemblies': (bool, ),
'format_name': (str, ),
'isy_axis_is_up': (bool, ),
'join_adjacent_surfaces': (bool, ),
'location_element_id': (str, ),
'location_group_id': (str, ),
'location_position': (int, ),
'notify_user': (bool, ),
'owner_id': (str, ),
'owner_type': (str, ),
'parent_id': (str, ),
'project_id': (str, ),
'public': (bool, ),
'split_assemblies_into_multiple_documents': (bool, ),
'store_in_document': (bool, ),
'translate': (bool, ),
'unit': (str, ),
'upload_id': (str, ),
'version_string': (str, ),
},
'attribute_map': {
'did': 'did',
'wid': 'wid',
'allow_faulty_parts': 'allowFaultyParts',
'create_composite': 'createComposite',
'create_drawing_if_possible': 'createDrawingIfPossible',
'encoded_filename': 'encodedFilename',
'extract_assembly_hierarchy': 'extractAssemblyHierarchy',
'file': 'file',
'file_body_with_details': 'fileBodyWithDetails',
'file_content_length': 'fileContentLength',
'file_detail': 'fileDetail',
'flatten_assemblies': 'flattenAssemblies',
'format_name': 'formatName',
'isy_axis_is_up': 'isyAxisIsUp',
'join_adjacent_surfaces': 'joinAdjacentSurfaces',
'location_element_id': 'locationElementId',
'location_group_id': 'locationGroupId',
'location_position': 'locationPosition',
'notify_user': '******',
'owner_id': 'ownerId',
'owner_type': 'ownerType',
'parent_id': 'parentId',
'project_id': 'projectId',
'public': 'public',
'split_assemblies_into_multiple_documents':
'splitAssembliesIntoMultipleDocuments',
'store_in_document': 'storeInDocument',
'translate': 'translate',
'unit': 'unit',
'upload_id': 'uploadId',
'version_string': 'versionString',
},
'location_map': {
'did': 'path',
'wid': 'path',
'allow_faulty_parts': 'form',
'create_composite': 'form',
'create_drawing_if_possible': 'form',
'encoded_filename': 'form',
'extract_assembly_hierarchy': 'form',
'file': 'form',
'file_body_with_details': 'form',
'file_content_length': 'form',
'file_detail': 'form',
'flatten_assemblies': 'form',
'format_name': 'form',
'isy_axis_is_up': 'form',
'join_adjacent_surfaces': 'form',
'location_element_id': 'form',
'location_group_id': 'form',
'location_position': 'form',
'notify_user': '******',
'owner_id': 'form',
'owner_type': 'form',
'parent_id': 'form',
'project_id': 'form',
'public': 'form',
'split_assemblies_into_multiple_documents': 'form',
'store_in_document': 'form',
'translate': 'form',
'unit': 'form',
'upload_id': 'form',
'version_string': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept':
['application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'],
'content_type': ['multipart/form-data']
},
api_client=api_client,
callable=__upload_file_create_element)
def __upload_file_update_element(self, did, eid, wid, **kwargs):
"""Update Blob Element. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.upload_file_update_element(did, eid, wid, async_req=True)
>>> result = thread.get()
Args:
did (str):
eid (str):
wid (str):
Keyword Args:
parent_change_id (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_document_element_processing_info.BTDocumentElementProcessingInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['did'] = \
did
kwargs['eid'] = \
eid
kwargs['wid'] = \
wid
return self.call_with_http_info(**kwargs)
self.upload_file_update_element = Endpoint(
settings={
'response_type': (bt_document_element_processing_info.
BTDocumentElementProcessingInfo, ),
'auth': ['OAuth2'],
'endpoint_path':
'/api/blobelements/d/{did}/w/{wid}/e/{eid}',
'operation_id':
'upload_file_update_element',
'http_method':
'POST',
'servers': [],
},
params_map={
'all': [
'did',
'eid',
'wid',
'parent_change_id',
],
'required': [
'did',
'eid',
'wid',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'did': (str, ),
'eid': (str, ),
'wid': (str, ),
'parent_change_id': (str, ),
},
'attribute_map': {
'did': 'did',
'eid': 'eid',
'wid': 'wid',
'parent_change_id': 'parentChangeId',
},
'location_map': {
'did': 'path',
'eid': 'path',
'wid': 'path',
'parent_change_id': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept':
['application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'],
'content_type': [],
},
api_client=api_client,
callable=__upload_file_update_element)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __cancel_purchase_new(
self,
aid,
pid,
**kwargs
):
"""Cancel Recurring Subscription # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.cancel_purchase_new(aid, pid, async_req=True)
>>> result = thread.get()
Args:
aid (str):
pid (str):
Keyword Args:
cancel_immediately (bool): [optional] if omitted the server will use the default value of False
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['aid'] = \
aid
kwargs['pid'] = \
pid
return self.call_with_http_info(**kwargs)
self.cancel_purchase_new = Endpoint(
settings={
'response_type': None,
'auth': [
'OAuth2'
],
'endpoint_path': '/api/accounts/{aid}/purchases/{pid}',
'operation_id': 'cancel_purchase_new',
'http_method': 'DELETE',
'servers': [],
},
params_map={
'all': [
'aid',
'pid',
'cancel_immediately',
],
'required': [
'aid',
'pid',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'aid':
(str,),
'pid':
(str,),
'cancel_immediately':
(bool,),
},
'attribute_map': {
'aid': 'aid',
'pid': 'pid',
'cancel_immediately': 'cancelImmediately',
},
'location_map': {
'aid': 'path',
'pid': 'path',
'cancel_immediately': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__cancel_purchase_new
)
def __consume_purchase(
self,
pid,
**kwargs
):
"""Mark Purchase Consumed For User # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.consume_purchase(pid, async_req=True)
>>> result = thread.get()
Args:
pid (str):
Keyword Args:
bt_purchase_user_params (bt_purchase_user_params.BTPurchaseUserParams): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_purchase_info.BTPurchaseInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['pid'] = \
pid
return self.call_with_http_info(**kwargs)
self.consume_purchase = Endpoint(
settings={
'response_type': (bt_purchase_info.BTPurchaseInfo,),
'auth': [
'OAuth2'
],
'endpoint_path': '/api/accounts/purchases/{pid}/consume',
'operation_id': 'consume_purchase',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'pid',
'bt_purchase_user_params',
],
'required': [
'pid',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'pid':
(str,),
'bt_purchase_user_params':
(bt_purchase_user_params.BTPurchaseUserParams,),
},
'attribute_map': {
'pid': 'pid',
},
'location_map': {
'pid': 'path',
'bt_purchase_user_params': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [
'application/json;charset=UTF-8; qs=0.09'
]
},
api_client=api_client,
callable=__consume_purchase
)
def __get_plan_purchases(
self,
plan_id,
**kwargs
):
"""Get Plan Purchases # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_plan_purchases(plan_id, async_req=True)
>>> result = thread.get()
Args:
plan_id (str):
Keyword Args:
offset (int): [optional] if omitted the server will use the default value of 0
limit (int): [optional] if omitted the server will use the default value of 20
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_list_response_bt_purchase_info.BTListResponseBTPurchaseInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['plan_id'] = \
plan_id
return self.call_with_http_info(**kwargs)
self.get_plan_purchases = Endpoint(
settings={
'response_type': (bt_list_response_bt_purchase_info.BTListResponseBTPurchaseInfo,),
'auth': [],
'endpoint_path': '/api/accounts/plans/{planId}/purchases',
'operation_id': 'get_plan_purchases',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'plan_id',
'offset',
'limit',
],
'required': [
'plan_id',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'plan_id':
(str,),
'offset':
(int,),
'limit':
(int,),
},
'attribute_map': {
'plan_id': 'planId',
'offset': 'offset',
'limit': 'limit',
},
'location_map': {
'plan_id': 'path',
'offset': 'query',
'limit': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__get_plan_purchases
)
def __get_purchases(
self,
**kwargs
):
"""Get User's Appstore Purchases. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_purchases(async_req=True)
>>> result = thread.get()
Keyword Args:
all (bool): [optional] if omitted the server will use the default value of False
own_purchase_only (bool): [optional] if omitted the server will use the default value of False
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
[bt_purchase_info.BTPurchaseInfo]
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
return self.call_with_http_info(**kwargs)
self.get_purchases = Endpoint(
settings={
'response_type': ([bt_purchase_info.BTPurchaseInfo],),
'auth': [],
'endpoint_path': '/api/accounts/purchases',
'operation_id': 'get_purchases',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'all',
'own_purchase_only',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'all':
(bool,),
'own_purchase_only':
(bool,),
},
'attribute_map': {
'all': 'all',
'own_purchase_only': 'ownPurchaseOnly',
},
'location_map': {
'all': 'query',
'own_purchase_only': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__get_purchases
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_open_api(self, **kwargs):
"""OpenAPI spec documentation for the Onshape REST API. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_open_api(async_req=True)
>>> result = thread.get()
Keyword Args:
excluded_tags (str): If an operation contains an excluded tag, it is not returned from this endpoint.. [optional]
included_tags (str): Return only operations with tags included in includedTags.. [optional]
include_deprecated (bool): Include deprecated endpoints.. [optional]
documentation_status ([str]): Only return endpoints that have the specified document status. Default is to return all the endpoints the user should have access to.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True
)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type", True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
return self.call_with_http_info(**kwargs)
self.get_open_api = Endpoint(
settings={
"response_type": None,
"auth": [],
"endpoint_path": "/api/openapi",
"operation_id": "get_open_api",
"http_method": "GET",
"servers": [],
},
params_map={
"all": [
"excluded_tags",
"included_tags",
"include_deprecated",
"documentation_status",
],
"required": [],
"nullable": [],
"enum": ["documentation_status",],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {
("documentation_status",): {
"DEVELOPMENT": "DEVELOPMENT",
"PRODUCTION": "PRODUCTION",
"STAGING": "STAGING",
"EVP": "EVP",
"UNSET": "UNSET",
"INTERNAL": "INTERNAL",
},
},
"openapi_types": {
"excluded_tags": (str,),
"included_tags": (str,),
"include_deprecated": (bool,),
"documentation_status": ([str],),
},
"attribute_map": {
"excluded_tags": "excludedTags",
"included_tags": "includedTags",
"include_deprecated": "includeDeprecated",
"documentation_status": "documentationStatus",
},
"location_map": {
"excluded_tags": "query",
"included_tags": "query",
"include_deprecated": "query",
"documentation_status": "query",
},
"collection_format_map": {"documentation_status": "multi",},
},
headers_map={"accept": [], "content_type": [],},
api_client=api_client,
callable=__get_open_api,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __create_webhook(self, **kwargs):
"""create_webhook # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_webhook(async_req=True)
>>> result = thread.get()
Keyword Args:
bt_webhook_params (bt_webhook_params.BTWebhookParams): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_webhook_info.BTWebhookInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
return self.call_with_http_info(**kwargs)
self.create_webhook = Endpoint(
settings={
"response_type": (bt_webhook_info.BTWebhookInfo, ),
"auth": ["OAuth2"],
"endpoint_path": "/api/webhooks",
"operation_id": "create_webhook",
"http_method": "POST",
"servers": [],
},
params_map={
"all": [
"bt_webhook_params",
],
"required": [],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"bt_webhook_params": (bt_webhook_params.BTWebhookParams, ),
},
"attribute_map": {},
"location_map": {
"bt_webhook_params": "body",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__create_webhook,
)
def __get_webhook(self, webhookid, **kwargs):
"""get_webhook # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_webhook(webhookid, async_req=True)
>>> result = thread.get()
Args:
webhookid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_webhook_info.BTWebhookInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["webhookid"] = webhookid
return self.call_with_http_info(**kwargs)
self.get_webhook = Endpoint(
settings={
"response_type": (bt_webhook_info.BTWebhookInfo, ),
"auth": ["OAuth2"],
"endpoint_path": "/api/webhooks/{webhookid}",
"operation_id": "get_webhook",
"http_method": "GET",
"servers": [],
},
params_map={
"all": [
"webhookid",
],
"required": [
"webhookid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"webhookid": (str, ),
},
"attribute_map": {
"webhookid": "webhookid",
},
"location_map": {
"webhookid": "path",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_webhook,
)
def __get_webhooks(self, **kwargs):
"""get_webhooks # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_webhooks(async_req=True)
>>> result = thread.get()
Keyword Args:
company (str): [optional] if omitted the server will use the default value of ''
user (str): [optional]
offset (int): [optional] if omitted the server will use the default value of 0
limit (int): [optional] if omitted the server will use the default value of 20
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_list_response_bt_webhook_info.BTListResponseBTWebhookInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
return self.call_with_http_info(**kwargs)
self.get_webhooks = Endpoint(
settings={
"response_type":
(bt_list_response_bt_webhook_info.BTListResponseBTWebhookInfo,
),
"auth": ["OAuth2"],
"endpoint_path":
"/api/webhooks",
"operation_id":
"get_webhooks",
"http_method":
"GET",
"servers": [],
},
params_map={
"all": [
"company",
"user",
"offset",
"limit",
],
"required": [],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"company": (str, ),
"user": (str, ),
"offset": (int, ),
"limit": (int, ),
},
"attribute_map": {
"company": "company",
"user": "******",
"offset": "offset",
"limit": "limit",
},
"location_map": {
"company": "query",
"user": "******",
"offset": "query",
"limit": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_webhooks,
)
def __ping_webhook(self, webhookid, **kwargs):
"""ping_webhook # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.ping_webhook(webhookid, async_req=True)
>>> result = thread.get()
Args:
webhookid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["webhookid"] = webhookid
return self.call_with_http_info(**kwargs)
self.ping_webhook = Endpoint(
settings={
"response_type": None,
"auth": ["OAuth2"],
"endpoint_path": "/api/webhooks/{webhookid}/ping",
"operation_id": "ping_webhook",
"http_method": "POST",
"servers": [],
},
params_map={
"all": [
"webhookid",
],
"required": [
"webhookid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"webhookid": (str, ),
},
"attribute_map": {
"webhookid": "webhookid",
},
"location_map": {
"webhookid": "path",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__ping_webhook,
)
def __unregister_webhook(self, webhookid, **kwargs):
"""unregister_webhook # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.unregister_webhook(webhookid, async_req=True)
>>> result = thread.get()
Args:
webhookid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["webhookid"] = webhookid
return self.call_with_http_info(**kwargs)
self.unregister_webhook = Endpoint(
settings={
"response_type": None,
"auth": ["OAuth2"],
"endpoint_path": "/api/webhooks/{webhookid}",
"operation_id": "unregister_webhook",
"http_method": "DELETE",
"servers": [],
},
params_map={
"all": [
"webhookid",
],
"required": [
"webhookid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"webhookid": (str, ),
},
"attribute_map": {
"webhookid": "webhookid",
},
"location_map": {
"webhookid": "path",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__unregister_webhook,
)
def __update_webhook(self, webhookid, **kwargs):
"""update_webhook # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_webhook(webhookid, async_req=True)
>>> result = thread.get()
Args:
webhookid (str):
Keyword Args:
bt_webhook_params (bt_webhook_params.BTWebhookParams): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_webhook_info.BTWebhookInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["webhookid"] = webhookid
return self.call_with_http_info(**kwargs)
self.update_webhook = Endpoint(
settings={
"response_type": (bt_webhook_info.BTWebhookInfo, ),
"auth": ["OAuth2"],
"endpoint_path": "/api/webhooks/{webhookid}",
"operation_id": "update_webhook",
"http_method": "POST",
"servers": [],
},
params_map={
"all": [
"webhookid",
"bt_webhook_params",
],
"required": [
"webhookid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"webhookid": (str, ),
"bt_webhook_params": (bt_webhook_params.BTWebhookParams, ),
},
"attribute_map": {
"webhookid": "webhookid",
},
"location_map": {
"webhookid": "path",
"bt_webhook_params": "body",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__update_webhook,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __create_feature_studio(self, did, wid, bt_model_element_params,
**kwargs):
"""Create Feature Studio # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_feature_studio(did, wid, bt_model_element_params, async_req=True)
>>> result = thread.get()
Args:
did (str):
wid (str):
bt_model_element_params (bt_model_element_params.BTModelElementParams):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_document_element_info.BTDocumentElementInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["wid"] = wid
kwargs["bt_model_element_params"] = bt_model_element_params
return self.call_with_http_info(**kwargs)
self.create_feature_studio = Endpoint(
settings={
"response_type":
(bt_document_element_info.BTDocumentElementInfo, ),
"auth": ["OAuth2"],
"endpoint_path": "/api/featurestudios/d/{did}/w/{wid}",
"operation_id": "create_feature_studio",
"http_method": "POST",
"servers": [],
},
params_map={
"all": [
"did",
"wid",
"bt_model_element_params",
],
"required": [
"did",
"wid",
"bt_model_element_params",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"did": (str, ),
"wid": (str, ),
"bt_model_element_params":
(bt_model_element_params.BTModelElementParams, ),
},
"attribute_map": {
"did": "did",
"wid": "wid",
},
"location_map": {
"did": "path",
"wid": "path",
"bt_model_element_params": "body",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__create_feature_studio,
)
def __get_feature_studio_contents(self, did, wvm, wvmid, eid,
**kwargs):
"""Get Feature Studio Contents. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_feature_studio_contents(did, wvm, wvmid, eid, async_req=True)
>>> result = thread.get()
Args:
did (str):
wvm (str):
wvmid (str):
eid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_feature_studio_contents2239.BTFeatureStudioContents2239
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["wvm"] = wvm
kwargs["wvmid"] = wvmid
kwargs["eid"] = eid
return self.call_with_http_info(**kwargs)
self.get_feature_studio_contents = Endpoint(
settings={
"response_type":
(bt_feature_studio_contents2239.BTFeatureStudioContents2239, ),
"auth": ["OAuth2"],
"endpoint_path":
"/api/featurestudios/d/{did}/{wvm}/{wvmid}/e/{eid}",
"operation_id":
"get_feature_studio_contents",
"http_method":
"GET",
"servers": [],
},
params_map={
"all": [
"did",
"wvm",
"wvmid",
"eid",
],
"required": [
"did",
"wvm",
"wvmid",
"eid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"did": (str, ),
"wvm": (str, ),
"wvmid": (str, ),
"eid": (str, ),
},
"attribute_map": {
"did": "did",
"wvm": "wvm",
"wvmid": "wvmid",
"eid": "eid",
},
"location_map": {
"did": "path",
"wvm": "path",
"wvmid": "path",
"eid": "path",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_feature_studio_contents,
)
def __get_feature_studio_specs(self, did, wvm, wvmid, eid, **kwargs):
"""Get Feature Studio Specs # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_feature_studio_specs(did, wvm, wvmid, eid, async_req=True)
>>> result = thread.get()
Args:
did (str):
wvm (str):
wvmid (str):
eid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_feature_specs_response664.BTFeatureSpecsResponse664
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["wvm"] = wvm
kwargs["wvmid"] = wvmid
kwargs["eid"] = eid
return self.call_with_http_info(**kwargs)
self.get_feature_studio_specs = Endpoint(
settings={
"response_type":
(bt_feature_specs_response664.BTFeatureSpecsResponse664, ),
"auth": ["OAuth2"],
"endpoint_path":
"/api/featurestudios/d/{did}/{wvm}/{wvmid}/e/{eid}/featurespecs",
"operation_id":
"get_feature_studio_specs",
"http_method":
"GET",
"servers": [],
},
params_map={
"all": [
"did",
"wvm",
"wvmid",
"eid",
],
"required": [
"did",
"wvm",
"wvmid",
"eid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"did": (str, ),
"wvm": (str, ),
"wvmid": (str, ),
"eid": (str, ),
},
"attribute_map": {
"did": "did",
"wvm": "wvm",
"wvmid": "wvmid",
"eid": "eid",
},
"location_map": {
"did": "path",
"wvm": "path",
"wvmid": "path",
"eid": "path",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_feature_studio_specs,
)
def __update_feature_studio_contents(self, did, wvm, wvmid, eid,
**kwargs):
"""Update Feature Studio contents # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_feature_studio_contents(did, wvm, wvmid, eid, async_req=True)
>>> result = thread.get()
Args:
did (str):
wvm (str):
wvmid (str):
eid (str):
Keyword Args:
body (str): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_feature_studio_contents2239.BTFeatureStudioContents2239
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["did"] = did
kwargs["wvm"] = wvm
kwargs["wvmid"] = wvmid
kwargs["eid"] = eid
return self.call_with_http_info(**kwargs)
self.update_feature_studio_contents = Endpoint(
settings={
"response_type":
(bt_feature_studio_contents2239.BTFeatureStudioContents2239, ),
"auth": ["OAuth2"],
"endpoint_path":
"/api/featurestudios/d/{did}/{wvm}/{wvmid}/e/{eid}",
"operation_id":
"update_feature_studio_contents",
"http_method":
"POST",
"servers": [],
},
params_map={
"all": [
"did",
"wvm",
"wvmid",
"eid",
"body",
],
"required": [
"did",
"wvm",
"wvmid",
"eid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"did": (str, ),
"wvm": (str, ),
"wvmid": (str, ),
"eid": (str, ),
"body": (str, ),
},
"attribute_map": {
"did": "did",
"wvm": "wvm",
"wvmid": "wvmid",
"eid": "eid",
},
"location_map": {
"did": "path",
"wvm": "path",
"wvmid": "path",
"eid": "path",
"body": "body",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__update_feature_studio_contents,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __cancel_purchase_new(self, aid, pid, **kwargs):
"""Cancel Recurring Subscription # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.cancel_purchase_new(aid, pid, async_req=True)
>>> result = thread.get()
Args:
aid (str):
pid (str):
Keyword Args:
cancel_immediately (bool): [optional] if omitted the server will use the default value of False
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["aid"] = aid
kwargs["pid"] = pid
return self.call_with_http_info(**kwargs)
self.cancel_purchase_new = Endpoint(
settings={
"response_type": None,
"auth": ["OAuth2"],
"endpoint_path": "/api/accounts/{aid}/purchases/{pid}",
"operation_id": "cancel_purchase_new",
"http_method": "DELETE",
"servers": [],
},
params_map={
"all": [
"aid",
"pid",
"cancel_immediately",
],
"required": [
"aid",
"pid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"aid": (str, ),
"pid": (str, ),
"cancel_immediately": (bool, ),
},
"attribute_map": {
"aid": "aid",
"pid": "pid",
"cancel_immediately": "cancelImmediately",
},
"location_map": {
"aid": "path",
"pid": "path",
"cancel_immediately": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__cancel_purchase_new,
)
def __consume_purchase(self, pid, **kwargs):
"""Mark Purchase Consumed For User # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.consume_purchase(pid, async_req=True)
>>> result = thread.get()
Args:
pid (str):
Keyword Args:
bt_purchase_user_params (bt_purchase_user_params.BTPurchaseUserParams): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_purchase_info.BTPurchaseInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["pid"] = pid
return self.call_with_http_info(**kwargs)
self.consume_purchase = Endpoint(
settings={
"response_type": (bt_purchase_info.BTPurchaseInfo, ),
"auth": ["OAuth2"],
"endpoint_path": "/api/accounts/purchases/{pid}/consume",
"operation_id": "consume_purchase",
"http_method": "POST",
"servers": [],
},
params_map={
"all": [
"pid",
"bt_purchase_user_params",
],
"required": [
"pid",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"pid": (str, ),
"bt_purchase_user_params":
(bt_purchase_user_params.BTPurchaseUserParams, ),
},
"attribute_map": {
"pid": "pid",
},
"location_map": {
"pid": "path",
"bt_purchase_user_params": "body",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": ["application/json;charset=UTF-8; qs=0.09"],
},
api_client=api_client,
callable=__consume_purchase,
)
def __get_plan_purchases(self, plan_id, **kwargs):
"""Get Plan Purchases # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_plan_purchases(plan_id, async_req=True)
>>> result = thread.get()
Args:
plan_id (str):
Keyword Args:
offset (int): [optional] if omitted the server will use the default value of 0
limit (int): [optional] if omitted the server will use the default value of 20
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_list_response_bt_purchase_info.BTListResponseBTPurchaseInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
kwargs["plan_id"] = plan_id
return self.call_with_http_info(**kwargs)
self.get_plan_purchases = Endpoint(
settings={
"response_type": (bt_list_response_bt_purchase_info.
BTListResponseBTPurchaseInfo, ),
"auth": [],
"endpoint_path":
"/api/accounts/plans/{planId}/purchases",
"operation_id":
"get_plan_purchases",
"http_method":
"GET",
"servers": [],
},
params_map={
"all": [
"plan_id",
"offset",
"limit",
],
"required": [
"plan_id",
],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"plan_id": (str, ),
"offset": (int, ),
"limit": (int, ),
},
"attribute_map": {
"plan_id": "planId",
"offset": "offset",
"limit": "limit",
},
"location_map": {
"plan_id": "path",
"offset": "query",
"limit": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_plan_purchases,
)
def __get_purchases(self, **kwargs):
"""Get User's Appstore Purchases. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_purchases(async_req=True)
>>> result = thread.get()
Keyword Args:
all (bool): [optional] if omitted the server will use the default value of False
own_purchase_only (bool): [optional] if omitted the server will use the default value of False
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
[bt_purchase_info.BTPurchaseInfo]
If the method is called asynchronously, returns the request
thread.
"""
kwargs["async_req"] = kwargs.get("async_req", False)
kwargs["_return_http_data_only"] = kwargs.get(
"_return_http_data_only", True)
kwargs["_preload_content"] = kwargs.get("_preload_content", True)
kwargs["_request_timeout"] = kwargs.get("_request_timeout", None)
kwargs["_check_input_type"] = kwargs.get("_check_input_type", True)
kwargs["_check_return_type"] = kwargs.get("_check_return_type",
True)
kwargs["_host_index"] = kwargs.get("_host_index", 0)
return self.call_with_http_info(**kwargs)
self.get_purchases = Endpoint(
settings={
"response_type": ([bt_purchase_info.BTPurchaseInfo], ),
"auth": [],
"endpoint_path": "/api/accounts/purchases",
"operation_id": "get_purchases",
"http_method": "GET",
"servers": [],
},
params_map={
"all": [
"all",
"own_purchase_only",
],
"required": [],
"nullable": [],
"enum": [],
"validation": [],
},
root_map={
"validations": {},
"allowed_values": {},
"openapi_types": {
"all": (bool, ),
"own_purchase_only": (bool, ),
},
"attribute_map": {
"all": "all",
"own_purchase_only": "ownPurchaseOnly",
},
"location_map": {
"all": "query",
"own_purchase_only": "query",
},
"collection_format_map": {},
},
headers_map={
"accept":
["application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1"],
"content_type": [],
},
api_client=api_client,
callable=__get_purchases,
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __find_company(self, **kwargs):
"""Get User companies. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_company(async_req=True)
>>> result = thread.get()
Keyword Args:
uid (str): [optional]
active_only (bool): [optional] if omitted the server will use the default value of True
include_all (bool): [optional] if omitted the server will use the default value of False
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_list_response_bt_company_info.BTListResponseBTCompanyInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
return self.call_with_http_info(**kwargs)
self.find_company = Endpoint(
settings={
'response_type':
(bt_list_response_bt_company_info.BTListResponseBTCompanyInfo,
),
'auth': [],
'endpoint_path':
'/api/companies',
'operation_id':
'find_company',
'http_method':
'GET',
'servers': [],
},
params_map={
'all': [
'uid',
'active_only',
'include_all',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'uid': (str, ),
'active_only': (bool, ),
'include_all': (bool, ),
},
'attribute_map': {
'uid': 'uid',
'active_only': 'activeOnly',
'include_all': 'includeAll',
},
'location_map': {
'uid': 'query',
'active_only': 'query',
'include_all': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept':
['application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'],
'content_type': [],
},
api_client=api_client,
callable=__find_company)
def __get_company(self, cid, **kwargs):
"""Get company. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_company(cid, async_req=True)
>>> result = thread.get()
Args:
cid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_company_info.BTCompanyInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['cid'] = \
cid
return self.call_with_http_info(**kwargs)
self.get_company = Endpoint(
settings={
'response_type': (bt_company_info.BTCompanyInfo, ),
'auth': [],
'endpoint_path': '/api/companies/{cid}',
'operation_id': 'get_company',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'cid',
],
'required': [
'cid',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'cid': (str, ),
},
'attribute_map': {
'cid': 'cid',
},
'location_map': {
'cid': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept':
['application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'],
'content_type': [],
},
api_client=api_client,
callable=__get_company)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __create_webhook(
self,
**kwargs
):
"""create_webhook # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_webhook(async_req=True)
>>> result = thread.get()
Keyword Args:
bt_webhook_params (bt_webhook_params.BTWebhookParams): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_webhook_info.BTWebhookInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
return self.call_with_http_info(**kwargs)
self.create_webhook = Endpoint(
settings={
'response_type': (bt_webhook_info.BTWebhookInfo,),
'auth': [
'OAuth2'
],
'endpoint_path': '/api/webhooks',
'operation_id': 'create_webhook',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'bt_webhook_params',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'bt_webhook_params':
(bt_webhook_params.BTWebhookParams,),
},
'attribute_map': {
},
'location_map': {
'bt_webhook_params': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [
'application/json;charset=UTF-8; qs=0.09'
]
},
api_client=api_client,
callable=__create_webhook
)
def __get_webhook(
self,
webhookid,
**kwargs
):
"""get_webhook # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_webhook(webhookid, async_req=True)
>>> result = thread.get()
Args:
webhookid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_webhook_info.BTWebhookInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['webhookid'] = \
webhookid
return self.call_with_http_info(**kwargs)
self.get_webhook = Endpoint(
settings={
'response_type': (bt_webhook_info.BTWebhookInfo,),
'auth': [
'OAuth2'
],
'endpoint_path': '/api/webhooks/{webhookid}',
'operation_id': 'get_webhook',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'webhookid',
],
'required': [
'webhookid',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'webhookid':
(str,),
},
'attribute_map': {
'webhookid': 'webhookid',
},
'location_map': {
'webhookid': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__get_webhook
)
def __get_webhooks(
self,
**kwargs
):
"""get_webhooks # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_webhooks(async_req=True)
>>> result = thread.get()
Keyword Args:
company (str): [optional] if omitted the server will use the default value of ''
user (str): [optional]
offset (int): [optional] if omitted the server will use the default value of 0
limit (int): [optional] if omitted the server will use the default value of 20
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_list_response_bt_webhook_info.BTListResponseBTWebhookInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
return self.call_with_http_info(**kwargs)
self.get_webhooks = Endpoint(
settings={
'response_type': (bt_list_response_bt_webhook_info.BTListResponseBTWebhookInfo,),
'auth': [
'OAuth2'
],
'endpoint_path': '/api/webhooks',
'operation_id': 'get_webhooks',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'company',
'user',
'offset',
'limit',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'company':
(str,),
'user':
(str,),
'offset':
(int,),
'limit':
(int,),
},
'attribute_map': {
'company': 'company',
'user': '******',
'offset': 'offset',
'limit': 'limit',
},
'location_map': {
'company': 'query',
'user': '******',
'offset': 'query',
'limit': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__get_webhooks
)
def __ping_webhook(
self,
webhookid,
**kwargs
):
"""ping_webhook # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.ping_webhook(webhookid, async_req=True)
>>> result = thread.get()
Args:
webhookid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['webhookid'] = \
webhookid
return self.call_with_http_info(**kwargs)
self.ping_webhook = Endpoint(
settings={
'response_type': None,
'auth': [
'OAuth2'
],
'endpoint_path': '/api/webhooks/{webhookid}/ping',
'operation_id': 'ping_webhook',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'webhookid',
],
'required': [
'webhookid',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'webhookid':
(str,),
},
'attribute_map': {
'webhookid': 'webhookid',
},
'location_map': {
'webhookid': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__ping_webhook
)
def __unregister_webhook(
self,
webhookid,
**kwargs
):
"""unregister_webhook # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.unregister_webhook(webhookid, async_req=True)
>>> result = thread.get()
Args:
webhookid (str):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['webhookid'] = \
webhookid
return self.call_with_http_info(**kwargs)
self.unregister_webhook = Endpoint(
settings={
'response_type': None,
'auth': [
'OAuth2'
],
'endpoint_path': '/api/webhooks/{webhookid}',
'operation_id': 'unregister_webhook',
'http_method': 'DELETE',
'servers': [],
},
params_map={
'all': [
'webhookid',
],
'required': [
'webhookid',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'webhookid':
(str,),
},
'attribute_map': {
'webhookid': 'webhookid',
},
'location_map': {
'webhookid': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [],
},
api_client=api_client,
callable=__unregister_webhook
)
def __update_webhook(
self,
webhookid,
**kwargs
):
"""update_webhook # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_webhook(webhookid, async_req=True)
>>> result = thread.get()
Args:
webhookid (str):
Keyword Args:
bt_webhook_params (bt_webhook_params.BTWebhookParams): [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
bt_webhook_info.BTWebhookInfo
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['webhookid'] = \
webhookid
return self.call_with_http_info(**kwargs)
self.update_webhook = Endpoint(
settings={
'response_type': (bt_webhook_info.BTWebhookInfo,),
'auth': [
'OAuth2'
],
'endpoint_path': '/api/webhooks/{webhookid}',
'operation_id': 'update_webhook',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'webhookid',
'bt_webhook_params',
],
'required': [
'webhookid',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'webhookid':
(str,),
'bt_webhook_params':
(bt_webhook_params.BTWebhookParams,),
},
'attribute_map': {
'webhookid': 'webhookid',
},
'location_map': {
'webhookid': 'path',
'bt_webhook_params': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1',
'application/json;charset=UTF-8; qs=0.09'
],
'content_type': [
'application/json;charset=UTF-8; qs=0.09'
]
},
api_client=api_client,
callable=__update_webhook
)
