generated from Luis/nextjs-python-web-template
1494 lines
60 KiB
Python
1494 lines
60 KiB
Python
# coding: utf-8
|
|
|
|
"""
|
|
FastAPI
|
|
|
|
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
|
|
|
|
The version of the OpenAPI document: 0.1.0
|
|
Generated by OpenAPI Generator (https://openapi-generator.tech)
|
|
|
|
Do not edit the class manually.
|
|
""" # noqa: E501
|
|
|
|
|
|
import re # noqa: F401
|
|
import io
|
|
import warnings
|
|
|
|
from pydantic import validate_arguments, ValidationError
|
|
|
|
from pydantic import StrictInt, StrictStr, conlist
|
|
|
|
from typing import Any, List, Optional, Dict
|
|
|
|
from openapi_client.models.entity import Entity
|
|
from openapi_client.models.entity_create import EntityCreate
|
|
from openapi_client.models.role import Role
|
|
|
|
from openapi_client.api_client import ApiClient
|
|
from openapi_client.api_response import ApiResponse
|
|
from openapi_client.exceptions import ( # noqa: F401
|
|
ApiTypeError,
|
|
ApiValueError
|
|
)
|
|
|
|
|
|
class EntitiesApi:
|
|
"""NOTE: This class is auto generated by OpenAPI Generator
|
|
Ref: https://openapi-generator.tech
|
|
|
|
Do not edit the class manually.
|
|
"""
|
|
|
|
def __init__(self, api_client=None) -> None:
|
|
if api_client is None:
|
|
api_client = ApiClient.get_default()
|
|
self.api_client = api_client
|
|
|
|
@validate_arguments
|
|
def attach_entity(self, entity_did : Optional[StrictStr] = None, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> Dict[str, str]: # noqa: E501
|
|
"""Attach Entity # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
|
|
>>> thread = api.attach_entity(entity_did, skip, limit, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_did:
|
|
:type entity_did: str
|
|
:param skip:
|
|
:type skip: int
|
|
:param limit:
|
|
:type limit: int
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _request_timeout: 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.
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: Dict[str, str]
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if '_preload_content' in kwargs:
|
|
message = "Error! Please call the attach_entity_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
|
|
raise ValueError(message)
|
|
return self.attach_entity_with_http_info(entity_did, skip, limit, **kwargs) # noqa: E501
|
|
|
|
@validate_arguments
|
|
def attach_entity_with_http_info(self, entity_did : Optional[StrictStr] = None, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
"""Attach Entity # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
|
|
>>> thread = api.attach_entity_with_http_info(entity_did, skip, limit, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_did:
|
|
:type entity_did: str
|
|
:param skip:
|
|
:type skip: int
|
|
:param limit:
|
|
:type limit: int
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _preload_content: if False, the ApiResponse.data will
|
|
be set to none and raw_data will store the
|
|
HTTP response body without reading/decoding.
|
|
Default is True.
|
|
:type _preload_content: bool, optional
|
|
:param _return_http_data_only: response data instead of ApiResponse
|
|
object with status code, headers, etc
|
|
:type _return_http_data_only: bool, optional
|
|
:param _request_timeout: 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.
|
|
:param _request_auth: set to override the auth_settings for an a single
|
|
request; this effectively ignores the authentication
|
|
in the spec for a single request.
|
|
:type _request_auth: dict, optional
|
|
:type _content_type: string, optional: force content-type for the request
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: tuple(Dict[str, str], status_code(int), headers(HTTPHeaderDict))
|
|
"""
|
|
|
|
_params = locals()
|
|
|
|
_all_params = [
|
|
'entity_did',
|
|
'skip',
|
|
'limit'
|
|
]
|
|
_all_params.extend(
|
|
[
|
|
'async_req',
|
|
'_return_http_data_only',
|
|
'_preload_content',
|
|
'_request_timeout',
|
|
'_request_auth',
|
|
'_content_type',
|
|
'_headers'
|
|
]
|
|
)
|
|
|
|
# validate the arguments
|
|
for _key, _val in _params['kwargs'].items():
|
|
if _key not in _all_params:
|
|
raise ApiTypeError(
|
|
"Got an unexpected keyword argument '%s'"
|
|
" to method attach_entity" % _key
|
|
)
|
|
_params[_key] = _val
|
|
del _params['kwargs']
|
|
|
|
_collection_formats = {}
|
|
|
|
# process the path parameters
|
|
_path_params = {}
|
|
|
|
# process the query parameters
|
|
_query_params = []
|
|
if _params.get('entity_did') is not None: # noqa: E501
|
|
_query_params.append(('entity_did', _params['entity_did']))
|
|
|
|
if _params.get('skip') is not None: # noqa: E501
|
|
_query_params.append(('skip', _params['skip']))
|
|
|
|
if _params.get('limit') is not None: # noqa: E501
|
|
_query_params.append(('limit', _params['limit']))
|
|
|
|
# process the header parameters
|
|
_header_params = dict(_params.get('_headers', {}))
|
|
# process the form parameters
|
|
_form_params = []
|
|
_files = {}
|
|
# process the body parameter
|
|
_body_params = None
|
|
# set the HTTP header `Accept`
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# authentication setting
|
|
_auth_settings = [] # noqa: E501
|
|
|
|
_response_types_map = {
|
|
'200': "Dict[str, str]",
|
|
'422': "HTTPValidationError",
|
|
}
|
|
|
|
return self.api_client.call_api(
|
|
'/api/v1/attach', 'PUT',
|
|
_path_params,
|
|
_query_params,
|
|
_header_params,
|
|
body=_body_params,
|
|
post_params=_form_params,
|
|
files=_files,
|
|
response_types_map=_response_types_map,
|
|
auth_settings=_auth_settings,
|
|
async_req=_params.get('async_req'),
|
|
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
|
|
_preload_content=_params.get('_preload_content', True),
|
|
_request_timeout=_params.get('_request_timeout'),
|
|
collection_formats=_collection_formats,
|
|
_request_auth=_params.get('_request_auth'))
|
|
|
|
@validate_arguments
|
|
def create_entity(self, entity_create : EntityCreate, **kwargs) -> Entity: # noqa: E501
|
|
"""Create Entity # 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_entity(entity_create, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_create: (required)
|
|
:type entity_create: EntityCreate
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _request_timeout: 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.
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: Entity
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if '_preload_content' in kwargs:
|
|
message = "Error! Please call the create_entity_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
|
|
raise ValueError(message)
|
|
return self.create_entity_with_http_info(entity_create, **kwargs) # noqa: E501
|
|
|
|
@validate_arguments
|
|
def create_entity_with_http_info(self, entity_create : EntityCreate, **kwargs) -> ApiResponse: # noqa: E501
|
|
"""Create Entity # 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_entity_with_http_info(entity_create, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_create: (required)
|
|
:type entity_create: EntityCreate
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _preload_content: if False, the ApiResponse.data will
|
|
be set to none and raw_data will store the
|
|
HTTP response body without reading/decoding.
|
|
Default is True.
|
|
:type _preload_content: bool, optional
|
|
:param _return_http_data_only: response data instead of ApiResponse
|
|
object with status code, headers, etc
|
|
:type _return_http_data_only: bool, optional
|
|
:param _request_timeout: 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.
|
|
:param _request_auth: set to override the auth_settings for an a single
|
|
request; this effectively ignores the authentication
|
|
in the spec for a single request.
|
|
:type _request_auth: dict, optional
|
|
:type _content_type: string, optional: force content-type for the request
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: tuple(Entity, status_code(int), headers(HTTPHeaderDict))
|
|
"""
|
|
|
|
_params = locals()
|
|
|
|
_all_params = [
|
|
'entity_create'
|
|
]
|
|
_all_params.extend(
|
|
[
|
|
'async_req',
|
|
'_return_http_data_only',
|
|
'_preload_content',
|
|
'_request_timeout',
|
|
'_request_auth',
|
|
'_content_type',
|
|
'_headers'
|
|
]
|
|
)
|
|
|
|
# validate the arguments
|
|
for _key, _val in _params['kwargs'].items():
|
|
if _key not in _all_params:
|
|
raise ApiTypeError(
|
|
"Got an unexpected keyword argument '%s'"
|
|
" to method create_entity" % _key
|
|
)
|
|
_params[_key] = _val
|
|
del _params['kwargs']
|
|
|
|
_collection_formats = {}
|
|
|
|
# process the path parameters
|
|
_path_params = {}
|
|
|
|
# process the query parameters
|
|
_query_params = []
|
|
# process the header parameters
|
|
_header_params = dict(_params.get('_headers', {}))
|
|
# process the form parameters
|
|
_form_params = []
|
|
_files = {}
|
|
# process the body parameter
|
|
_body_params = None
|
|
if _params['entity_create'] is not None:
|
|
_body_params = _params['entity_create']
|
|
|
|
# set the HTTP header `Accept`
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# set the HTTP header `Content-Type`
|
|
_content_types_list = _params.get('_content_type',
|
|
self.api_client.select_header_content_type(
|
|
['application/json']))
|
|
if _content_types_list:
|
|
_header_params['Content-Type'] = _content_types_list
|
|
|
|
# authentication setting
|
|
_auth_settings = [] # noqa: E501
|
|
|
|
_response_types_map = {
|
|
'200': "Entity",
|
|
'422': "HTTPValidationError",
|
|
}
|
|
|
|
return self.api_client.call_api(
|
|
'/api/v1/entity', 'POST',
|
|
_path_params,
|
|
_query_params,
|
|
_header_params,
|
|
body=_body_params,
|
|
post_params=_form_params,
|
|
files=_files,
|
|
response_types_map=_response_types_map,
|
|
auth_settings=_auth_settings,
|
|
async_req=_params.get('async_req'),
|
|
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
|
|
_preload_content=_params.get('_preload_content', True),
|
|
_request_timeout=_params.get('_request_timeout'),
|
|
collection_formats=_collection_formats,
|
|
_request_auth=_params.get('_request_auth'))
|
|
|
|
@validate_arguments
|
|
def delete_entity(self, entity_did : Optional[StrictStr] = None, **kwargs) -> Dict[str, str]: # noqa: E501
|
|
"""Delete Entity # 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_entity(entity_did, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_did:
|
|
:type entity_did: str
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _request_timeout: 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.
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: Dict[str, str]
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if '_preload_content' in kwargs:
|
|
message = "Error! Please call the delete_entity_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
|
|
raise ValueError(message)
|
|
return self.delete_entity_with_http_info(entity_did, **kwargs) # noqa: E501
|
|
|
|
@validate_arguments
|
|
def delete_entity_with_http_info(self, entity_did : Optional[StrictStr] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
"""Delete Entity # 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_entity_with_http_info(entity_did, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_did:
|
|
:type entity_did: str
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _preload_content: if False, the ApiResponse.data will
|
|
be set to none and raw_data will store the
|
|
HTTP response body without reading/decoding.
|
|
Default is True.
|
|
:type _preload_content: bool, optional
|
|
:param _return_http_data_only: response data instead of ApiResponse
|
|
object with status code, headers, etc
|
|
:type _return_http_data_only: bool, optional
|
|
:param _request_timeout: 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.
|
|
:param _request_auth: set to override the auth_settings for an a single
|
|
request; this effectively ignores the authentication
|
|
in the spec for a single request.
|
|
:type _request_auth: dict, optional
|
|
:type _content_type: string, optional: force content-type for the request
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: tuple(Dict[str, str], status_code(int), headers(HTTPHeaderDict))
|
|
"""
|
|
|
|
_params = locals()
|
|
|
|
_all_params = [
|
|
'entity_did'
|
|
]
|
|
_all_params.extend(
|
|
[
|
|
'async_req',
|
|
'_return_http_data_only',
|
|
'_preload_content',
|
|
'_request_timeout',
|
|
'_request_auth',
|
|
'_content_type',
|
|
'_headers'
|
|
]
|
|
)
|
|
|
|
# validate the arguments
|
|
for _key, _val in _params['kwargs'].items():
|
|
if _key not in _all_params:
|
|
raise ApiTypeError(
|
|
"Got an unexpected keyword argument '%s'"
|
|
" to method delete_entity" % _key
|
|
)
|
|
_params[_key] = _val
|
|
del _params['kwargs']
|
|
|
|
_collection_formats = {}
|
|
|
|
# process the path parameters
|
|
_path_params = {}
|
|
|
|
# process the query parameters
|
|
_query_params = []
|
|
if _params.get('entity_did') is not None: # noqa: E501
|
|
_query_params.append(('entity_did', _params['entity_did']))
|
|
|
|
# process the header parameters
|
|
_header_params = dict(_params.get('_headers', {}))
|
|
# process the form parameters
|
|
_form_params = []
|
|
_files = {}
|
|
# process the body parameter
|
|
_body_params = None
|
|
# set the HTTP header `Accept`
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# authentication setting
|
|
_auth_settings = [] # noqa: E501
|
|
|
|
_response_types_map = {
|
|
'200': "Dict[str, str]",
|
|
'422': "HTTPValidationError",
|
|
}
|
|
|
|
return self.api_client.call_api(
|
|
'/api/v1/entity', 'DELETE',
|
|
_path_params,
|
|
_query_params,
|
|
_header_params,
|
|
body=_body_params,
|
|
post_params=_form_params,
|
|
files=_files,
|
|
response_types_map=_response_types_map,
|
|
auth_settings=_auth_settings,
|
|
async_req=_params.get('async_req'),
|
|
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
|
|
_preload_content=_params.get('_preload_content', True),
|
|
_request_timeout=_params.get('_request_timeout'),
|
|
collection_formats=_collection_formats,
|
|
_request_auth=_params.get('_request_auth'))
|
|
|
|
@validate_arguments
|
|
def detach_entity(self, entity_did : Optional[StrictStr] = None, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> Dict[str, str]: # noqa: E501
|
|
"""Detach Entity # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
|
|
>>> thread = api.detach_entity(entity_did, skip, limit, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_did:
|
|
:type entity_did: str
|
|
:param skip:
|
|
:type skip: int
|
|
:param limit:
|
|
:type limit: int
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _request_timeout: 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.
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: Dict[str, str]
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if '_preload_content' in kwargs:
|
|
message = "Error! Please call the detach_entity_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
|
|
raise ValueError(message)
|
|
return self.detach_entity_with_http_info(entity_did, skip, limit, **kwargs) # noqa: E501
|
|
|
|
@validate_arguments
|
|
def detach_entity_with_http_info(self, entity_did : Optional[StrictStr] = None, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
"""Detach Entity # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
|
|
>>> thread = api.detach_entity_with_http_info(entity_did, skip, limit, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_did:
|
|
:type entity_did: str
|
|
:param skip:
|
|
:type skip: int
|
|
:param limit:
|
|
:type limit: int
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _preload_content: if False, the ApiResponse.data will
|
|
be set to none and raw_data will store the
|
|
HTTP response body without reading/decoding.
|
|
Default is True.
|
|
:type _preload_content: bool, optional
|
|
:param _return_http_data_only: response data instead of ApiResponse
|
|
object with status code, headers, etc
|
|
:type _return_http_data_only: bool, optional
|
|
:param _request_timeout: 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.
|
|
:param _request_auth: set to override the auth_settings for an a single
|
|
request; this effectively ignores the authentication
|
|
in the spec for a single request.
|
|
:type _request_auth: dict, optional
|
|
:type _content_type: string, optional: force content-type for the request
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: tuple(Dict[str, str], status_code(int), headers(HTTPHeaderDict))
|
|
"""
|
|
|
|
_params = locals()
|
|
|
|
_all_params = [
|
|
'entity_did',
|
|
'skip',
|
|
'limit'
|
|
]
|
|
_all_params.extend(
|
|
[
|
|
'async_req',
|
|
'_return_http_data_only',
|
|
'_preload_content',
|
|
'_request_timeout',
|
|
'_request_auth',
|
|
'_content_type',
|
|
'_headers'
|
|
]
|
|
)
|
|
|
|
# validate the arguments
|
|
for _key, _val in _params['kwargs'].items():
|
|
if _key not in _all_params:
|
|
raise ApiTypeError(
|
|
"Got an unexpected keyword argument '%s'"
|
|
" to method detach_entity" % _key
|
|
)
|
|
_params[_key] = _val
|
|
del _params['kwargs']
|
|
|
|
_collection_formats = {}
|
|
|
|
# process the path parameters
|
|
_path_params = {}
|
|
|
|
# process the query parameters
|
|
_query_params = []
|
|
if _params.get('entity_did') is not None: # noqa: E501
|
|
_query_params.append(('entity_did', _params['entity_did']))
|
|
|
|
if _params.get('skip') is not None: # noqa: E501
|
|
_query_params.append(('skip', _params['skip']))
|
|
|
|
if _params.get('limit') is not None: # noqa: E501
|
|
_query_params.append(('limit', _params['limit']))
|
|
|
|
# process the header parameters
|
|
_header_params = dict(_params.get('_headers', {}))
|
|
# process the form parameters
|
|
_form_params = []
|
|
_files = {}
|
|
# process the body parameter
|
|
_body_params = None
|
|
# set the HTTP header `Accept`
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# authentication setting
|
|
_auth_settings = [] # noqa: E501
|
|
|
|
_response_types_map = {
|
|
'200': "Dict[str, str]",
|
|
'422': "HTTPValidationError",
|
|
}
|
|
|
|
return self.api_client.call_api(
|
|
'/api/v1/detach', 'PUT',
|
|
_path_params,
|
|
_query_params,
|
|
_header_params,
|
|
body=_body_params,
|
|
post_params=_form_params,
|
|
files=_files,
|
|
response_types_map=_response_types_map,
|
|
auth_settings=_auth_settings,
|
|
async_req=_params.get('async_req'),
|
|
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
|
|
_preload_content=_params.get('_preload_content', True),
|
|
_request_timeout=_params.get('_request_timeout'),
|
|
collection_formats=_collection_formats,
|
|
_request_auth=_params.get('_request_auth'))
|
|
|
|
@validate_arguments
|
|
def get_all_entities(self, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> List[Entity]: # noqa: E501
|
|
"""Get All Entities # 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_entities(skip, limit, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param skip:
|
|
:type skip: int
|
|
:param limit:
|
|
:type limit: int
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _request_timeout: 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.
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: List[Entity]
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if '_preload_content' in kwargs:
|
|
message = "Error! Please call the get_all_entities_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
|
|
raise ValueError(message)
|
|
return self.get_all_entities_with_http_info(skip, limit, **kwargs) # noqa: E501
|
|
|
|
@validate_arguments
|
|
def get_all_entities_with_http_info(self, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
"""Get All Entities # 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_entities_with_http_info(skip, limit, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param skip:
|
|
:type skip: int
|
|
:param limit:
|
|
:type limit: int
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _preload_content: if False, the ApiResponse.data will
|
|
be set to none and raw_data will store the
|
|
HTTP response body without reading/decoding.
|
|
Default is True.
|
|
:type _preload_content: bool, optional
|
|
:param _return_http_data_only: response data instead of ApiResponse
|
|
object with status code, headers, etc
|
|
:type _return_http_data_only: bool, optional
|
|
:param _request_timeout: 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.
|
|
:param _request_auth: set to override the auth_settings for an a single
|
|
request; this effectively ignores the authentication
|
|
in the spec for a single request.
|
|
:type _request_auth: dict, optional
|
|
:type _content_type: string, optional: force content-type for the request
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: tuple(List[Entity], status_code(int), headers(HTTPHeaderDict))
|
|
"""
|
|
|
|
_params = locals()
|
|
|
|
_all_params = [
|
|
'skip',
|
|
'limit'
|
|
]
|
|
_all_params.extend(
|
|
[
|
|
'async_req',
|
|
'_return_http_data_only',
|
|
'_preload_content',
|
|
'_request_timeout',
|
|
'_request_auth',
|
|
'_content_type',
|
|
'_headers'
|
|
]
|
|
)
|
|
|
|
# validate the arguments
|
|
for _key, _val in _params['kwargs'].items():
|
|
if _key not in _all_params:
|
|
raise ApiTypeError(
|
|
"Got an unexpected keyword argument '%s'"
|
|
" to method get_all_entities" % _key
|
|
)
|
|
_params[_key] = _val
|
|
del _params['kwargs']
|
|
|
|
_collection_formats = {}
|
|
|
|
# process the path parameters
|
|
_path_params = {}
|
|
|
|
# process the query parameters
|
|
_query_params = []
|
|
if _params.get('skip') is not None: # noqa: E501
|
|
_query_params.append(('skip', _params['skip']))
|
|
|
|
if _params.get('limit') is not None: # noqa: E501
|
|
_query_params.append(('limit', _params['limit']))
|
|
|
|
# process the header parameters
|
|
_header_params = dict(_params.get('_headers', {}))
|
|
# process the form parameters
|
|
_form_params = []
|
|
_files = {}
|
|
# process the body parameter
|
|
_body_params = None
|
|
# set the HTTP header `Accept`
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# authentication setting
|
|
_auth_settings = [] # noqa: E501
|
|
|
|
_response_types_map = {
|
|
'200': "List[Entity]",
|
|
'422': "HTTPValidationError",
|
|
}
|
|
|
|
return self.api_client.call_api(
|
|
'/api/v1/entities', 'GET',
|
|
_path_params,
|
|
_query_params,
|
|
_header_params,
|
|
body=_body_params,
|
|
post_params=_form_params,
|
|
files=_files,
|
|
response_types_map=_response_types_map,
|
|
auth_settings=_auth_settings,
|
|
async_req=_params.get('async_req'),
|
|
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
|
|
_preload_content=_params.get('_preload_content', True),
|
|
_request_timeout=_params.get('_request_timeout'),
|
|
collection_formats=_collection_formats,
|
|
_request_auth=_params.get('_request_auth'))
|
|
|
|
@validate_arguments
|
|
def get_attached_entities(self, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> List[Entity]: # noqa: E501
|
|
"""Get Attached Entities # 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_attached_entities(skip, limit, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param skip:
|
|
:type skip: int
|
|
:param limit:
|
|
:type limit: int
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _request_timeout: 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.
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: List[Entity]
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if '_preload_content' in kwargs:
|
|
message = "Error! Please call the get_attached_entities_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
|
|
raise ValueError(message)
|
|
return self.get_attached_entities_with_http_info(skip, limit, **kwargs) # noqa: E501
|
|
|
|
@validate_arguments
|
|
def get_attached_entities_with_http_info(self, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
"""Get Attached Entities # 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_attached_entities_with_http_info(skip, limit, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param skip:
|
|
:type skip: int
|
|
:param limit:
|
|
:type limit: int
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _preload_content: if False, the ApiResponse.data will
|
|
be set to none and raw_data will store the
|
|
HTTP response body without reading/decoding.
|
|
Default is True.
|
|
:type _preload_content: bool, optional
|
|
:param _return_http_data_only: response data instead of ApiResponse
|
|
object with status code, headers, etc
|
|
:type _return_http_data_only: bool, optional
|
|
:param _request_timeout: 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.
|
|
:param _request_auth: set to override the auth_settings for an a single
|
|
request; this effectively ignores the authentication
|
|
in the spec for a single request.
|
|
:type _request_auth: dict, optional
|
|
:type _content_type: string, optional: force content-type for the request
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: tuple(List[Entity], status_code(int), headers(HTTPHeaderDict))
|
|
"""
|
|
|
|
_params = locals()
|
|
|
|
_all_params = [
|
|
'skip',
|
|
'limit'
|
|
]
|
|
_all_params.extend(
|
|
[
|
|
'async_req',
|
|
'_return_http_data_only',
|
|
'_preload_content',
|
|
'_request_timeout',
|
|
'_request_auth',
|
|
'_content_type',
|
|
'_headers'
|
|
]
|
|
)
|
|
|
|
# validate the arguments
|
|
for _key, _val in _params['kwargs'].items():
|
|
if _key not in _all_params:
|
|
raise ApiTypeError(
|
|
"Got an unexpected keyword argument '%s'"
|
|
" to method get_attached_entities" % _key
|
|
)
|
|
_params[_key] = _val
|
|
del _params['kwargs']
|
|
|
|
_collection_formats = {}
|
|
|
|
# process the path parameters
|
|
_path_params = {}
|
|
|
|
# process the query parameters
|
|
_query_params = []
|
|
if _params.get('skip') is not None: # noqa: E501
|
|
_query_params.append(('skip', _params['skip']))
|
|
|
|
if _params.get('limit') is not None: # noqa: E501
|
|
_query_params.append(('limit', _params['limit']))
|
|
|
|
# process the header parameters
|
|
_header_params = dict(_params.get('_headers', {}))
|
|
# process the form parameters
|
|
_form_params = []
|
|
_files = {}
|
|
# process the body parameter
|
|
_body_params = None
|
|
# set the HTTP header `Accept`
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# authentication setting
|
|
_auth_settings = [] # noqa: E501
|
|
|
|
_response_types_map = {
|
|
'200': "List[Entity]",
|
|
'422': "HTTPValidationError",
|
|
}
|
|
|
|
return self.api_client.call_api(
|
|
'/api/v1/attached_entities', 'GET',
|
|
_path_params,
|
|
_query_params,
|
|
_header_params,
|
|
body=_body_params,
|
|
post_params=_form_params,
|
|
files=_files,
|
|
response_types_map=_response_types_map,
|
|
auth_settings=_auth_settings,
|
|
async_req=_params.get('async_req'),
|
|
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
|
|
_preload_content=_params.get('_preload_content', True),
|
|
_request_timeout=_params.get('_request_timeout'),
|
|
collection_formats=_collection_formats,
|
|
_request_auth=_params.get('_request_auth'))
|
|
|
|
@validate_arguments
|
|
def get_entity_by_did(self, entity_did : Optional[StrictStr] = None, **kwargs) -> Entity: # noqa: E501
|
|
"""Get Entity By Did # 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_entity_by_did(entity_did, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_did:
|
|
:type entity_did: str
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _request_timeout: 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.
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: Entity
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if '_preload_content' in kwargs:
|
|
message = "Error! Please call the get_entity_by_did_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
|
|
raise ValueError(message)
|
|
return self.get_entity_by_did_with_http_info(entity_did, **kwargs) # noqa: E501
|
|
|
|
@validate_arguments
|
|
def get_entity_by_did_with_http_info(self, entity_did : Optional[StrictStr] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
"""Get Entity By Did # 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_entity_by_did_with_http_info(entity_did, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_did:
|
|
:type entity_did: str
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _preload_content: if False, the ApiResponse.data will
|
|
be set to none and raw_data will store the
|
|
HTTP response body without reading/decoding.
|
|
Default is True.
|
|
:type _preload_content: bool, optional
|
|
:param _return_http_data_only: response data instead of ApiResponse
|
|
object with status code, headers, etc
|
|
:type _return_http_data_only: bool, optional
|
|
:param _request_timeout: 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.
|
|
:param _request_auth: set to override the auth_settings for an a single
|
|
request; this effectively ignores the authentication
|
|
in the spec for a single request.
|
|
:type _request_auth: dict, optional
|
|
:type _content_type: string, optional: force content-type for the request
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: tuple(Entity, status_code(int), headers(HTTPHeaderDict))
|
|
"""
|
|
|
|
_params = locals()
|
|
|
|
_all_params = [
|
|
'entity_did'
|
|
]
|
|
_all_params.extend(
|
|
[
|
|
'async_req',
|
|
'_return_http_data_only',
|
|
'_preload_content',
|
|
'_request_timeout',
|
|
'_request_auth',
|
|
'_content_type',
|
|
'_headers'
|
|
]
|
|
)
|
|
|
|
# validate the arguments
|
|
for _key, _val in _params['kwargs'].items():
|
|
if _key not in _all_params:
|
|
raise ApiTypeError(
|
|
"Got an unexpected keyword argument '%s'"
|
|
" to method get_entity_by_did" % _key
|
|
)
|
|
_params[_key] = _val
|
|
del _params['kwargs']
|
|
|
|
_collection_formats = {}
|
|
|
|
# process the path parameters
|
|
_path_params = {}
|
|
|
|
# process the query parameters
|
|
_query_params = []
|
|
if _params.get('entity_did') is not None: # noqa: E501
|
|
_query_params.append(('entity_did', _params['entity_did']))
|
|
|
|
# process the header parameters
|
|
_header_params = dict(_params.get('_headers', {}))
|
|
# process the form parameters
|
|
_form_params = []
|
|
_files = {}
|
|
# process the body parameter
|
|
_body_params = None
|
|
# set the HTTP header `Accept`
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# authentication setting
|
|
_auth_settings = [] # noqa: E501
|
|
|
|
_response_types_map = {
|
|
'200': "Entity",
|
|
'422': "HTTPValidationError",
|
|
}
|
|
|
|
return self.api_client.call_api(
|
|
'/api/v1/entity', 'GET',
|
|
_path_params,
|
|
_query_params,
|
|
_header_params,
|
|
body=_body_params,
|
|
post_params=_form_params,
|
|
files=_files,
|
|
response_types_map=_response_types_map,
|
|
auth_settings=_auth_settings,
|
|
async_req=_params.get('async_req'),
|
|
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
|
|
_preload_content=_params.get('_preload_content', True),
|
|
_request_timeout=_params.get('_request_timeout'),
|
|
collection_formats=_collection_formats,
|
|
_request_auth=_params.get('_request_auth'))
|
|
|
|
@validate_arguments
|
|
def get_entity_by_name_or_did(self, entity_name_or_did : Optional[StrictStr] = None, **kwargs) -> Entity: # noqa: E501
|
|
"""Get Entity By Name Or Did # 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_entity_by_name_or_did(entity_name_or_did, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_name_or_did:
|
|
:type entity_name_or_did: str
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _request_timeout: 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.
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: Entity
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if '_preload_content' in kwargs:
|
|
message = "Error! Please call the get_entity_by_name_or_did_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
|
|
raise ValueError(message)
|
|
return self.get_entity_by_name_or_did_with_http_info(entity_name_or_did, **kwargs) # noqa: E501
|
|
|
|
@validate_arguments
|
|
def get_entity_by_name_or_did_with_http_info(self, entity_name_or_did : Optional[StrictStr] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
"""Get Entity By Name Or Did # 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_entity_by_name_or_did_with_http_info(entity_name_or_did, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_name_or_did:
|
|
:type entity_name_or_did: str
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _preload_content: if False, the ApiResponse.data will
|
|
be set to none and raw_data will store the
|
|
HTTP response body without reading/decoding.
|
|
Default is True.
|
|
:type _preload_content: bool, optional
|
|
:param _return_http_data_only: response data instead of ApiResponse
|
|
object with status code, headers, etc
|
|
:type _return_http_data_only: bool, optional
|
|
:param _request_timeout: 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.
|
|
:param _request_auth: set to override the auth_settings for an a single
|
|
request; this effectively ignores the authentication
|
|
in the spec for a single request.
|
|
:type _request_auth: dict, optional
|
|
:type _content_type: string, optional: force content-type for the request
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: tuple(Entity, status_code(int), headers(HTTPHeaderDict))
|
|
"""
|
|
|
|
_params = locals()
|
|
|
|
_all_params = [
|
|
'entity_name_or_did'
|
|
]
|
|
_all_params.extend(
|
|
[
|
|
'async_req',
|
|
'_return_http_data_only',
|
|
'_preload_content',
|
|
'_request_timeout',
|
|
'_request_auth',
|
|
'_content_type',
|
|
'_headers'
|
|
]
|
|
)
|
|
|
|
# validate the arguments
|
|
for _key, _val in _params['kwargs'].items():
|
|
if _key not in _all_params:
|
|
raise ApiTypeError(
|
|
"Got an unexpected keyword argument '%s'"
|
|
" to method get_entity_by_name_or_did" % _key
|
|
)
|
|
_params[_key] = _val
|
|
del _params['kwargs']
|
|
|
|
_collection_formats = {}
|
|
|
|
# process the path parameters
|
|
_path_params = {}
|
|
|
|
# process the query parameters
|
|
_query_params = []
|
|
if _params.get('entity_name_or_did') is not None: # noqa: E501
|
|
_query_params.append(('entity_name_or_did', _params['entity_name_or_did']))
|
|
|
|
# process the header parameters
|
|
_header_params = dict(_params.get('_headers', {}))
|
|
# process the form parameters
|
|
_form_params = []
|
|
_files = {}
|
|
# process the body parameter
|
|
_body_params = None
|
|
# set the HTTP header `Accept`
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# authentication setting
|
|
_auth_settings = [] # noqa: E501
|
|
|
|
_response_types_map = {
|
|
'200': "Entity",
|
|
'422': "HTTPValidationError",
|
|
}
|
|
|
|
return self.api_client.call_api(
|
|
'/api/v1/entity_by_name_or_did', 'GET',
|
|
_path_params,
|
|
_query_params,
|
|
_header_params,
|
|
body=_body_params,
|
|
post_params=_form_params,
|
|
files=_files,
|
|
response_types_map=_response_types_map,
|
|
auth_settings=_auth_settings,
|
|
async_req=_params.get('async_req'),
|
|
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
|
|
_preload_content=_params.get('_preload_content', True),
|
|
_request_timeout=_params.get('_request_timeout'),
|
|
collection_formats=_collection_formats,
|
|
_request_auth=_params.get('_request_auth'))
|
|
|
|
@validate_arguments
|
|
def get_entity_by_roles(self, roles : conlist(Role), **kwargs) -> List[Entity]: # noqa: E501
|
|
"""Get Entity By Roles # 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_entity_by_roles(roles, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param roles: (required)
|
|
:type roles: List[Role]
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _request_timeout: 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.
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: List[Entity]
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if '_preload_content' in kwargs:
|
|
message = "Error! Please call the get_entity_by_roles_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
|
|
raise ValueError(message)
|
|
return self.get_entity_by_roles_with_http_info(roles, **kwargs) # noqa: E501
|
|
|
|
@validate_arguments
|
|
def get_entity_by_roles_with_http_info(self, roles : conlist(Role), **kwargs) -> ApiResponse: # noqa: E501
|
|
"""Get Entity By Roles # 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_entity_by_roles_with_http_info(roles, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param roles: (required)
|
|
:type roles: List[Role]
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _preload_content: if False, the ApiResponse.data will
|
|
be set to none and raw_data will store the
|
|
HTTP response body without reading/decoding.
|
|
Default is True.
|
|
:type _preload_content: bool, optional
|
|
:param _return_http_data_only: response data instead of ApiResponse
|
|
object with status code, headers, etc
|
|
:type _return_http_data_only: bool, optional
|
|
:param _request_timeout: 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.
|
|
:param _request_auth: set to override the auth_settings for an a single
|
|
request; this effectively ignores the authentication
|
|
in the spec for a single request.
|
|
:type _request_auth: dict, optional
|
|
:type _content_type: string, optional: force content-type for the request
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: tuple(List[Entity], status_code(int), headers(HTTPHeaderDict))
|
|
"""
|
|
|
|
_params = locals()
|
|
|
|
_all_params = [
|
|
'roles'
|
|
]
|
|
_all_params.extend(
|
|
[
|
|
'async_req',
|
|
'_return_http_data_only',
|
|
'_preload_content',
|
|
'_request_timeout',
|
|
'_request_auth',
|
|
'_content_type',
|
|
'_headers'
|
|
]
|
|
)
|
|
|
|
# validate the arguments
|
|
for _key, _val in _params['kwargs'].items():
|
|
if _key not in _all_params:
|
|
raise ApiTypeError(
|
|
"Got an unexpected keyword argument '%s'"
|
|
" to method get_entity_by_roles" % _key
|
|
)
|
|
_params[_key] = _val
|
|
del _params['kwargs']
|
|
|
|
_collection_formats = {}
|
|
|
|
# process the path parameters
|
|
_path_params = {}
|
|
|
|
# process the query parameters
|
|
_query_params = []
|
|
if _params.get('roles') is not None: # noqa: E501
|
|
_query_params.append(('roles', _params['roles']))
|
|
_collection_formats['roles'] = 'multi'
|
|
|
|
# process the header parameters
|
|
_header_params = dict(_params.get('_headers', {}))
|
|
# process the form parameters
|
|
_form_params = []
|
|
_files = {}
|
|
# process the body parameter
|
|
_body_params = None
|
|
# set the HTTP header `Accept`
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# authentication setting
|
|
_auth_settings = [] # noqa: E501
|
|
|
|
_response_types_map = {
|
|
'200': "List[Entity]",
|
|
'422': "HTTPValidationError",
|
|
}
|
|
|
|
return self.api_client.call_api(
|
|
'/api/v1/entity_by_roles', 'GET',
|
|
_path_params,
|
|
_query_params,
|
|
_header_params,
|
|
body=_body_params,
|
|
post_params=_form_params,
|
|
files=_files,
|
|
response_types_map=_response_types_map,
|
|
auth_settings=_auth_settings,
|
|
async_req=_params.get('async_req'),
|
|
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
|
|
_preload_content=_params.get('_preload_content', True),
|
|
_request_timeout=_params.get('_request_timeout'),
|
|
collection_formats=_collection_formats,
|
|
_request_auth=_params.get('_request_auth'))
|
|
|
|
@validate_arguments
|
|
def is_attached(self, entity_did : Optional[StrictStr] = None, **kwargs) -> Dict[str, str]: # noqa: E501
|
|
"""Is Attached # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
|
|
>>> thread = api.is_attached(entity_did, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_did:
|
|
:type entity_did: str
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _request_timeout: 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.
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: Dict[str, str]
|
|
"""
|
|
kwargs['_return_http_data_only'] = True
|
|
if '_preload_content' in kwargs:
|
|
message = "Error! Please call the is_attached_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
|
|
raise ValueError(message)
|
|
return self.is_attached_with_http_info(entity_did, **kwargs) # noqa: E501
|
|
|
|
@validate_arguments
|
|
def is_attached_with_http_info(self, entity_did : Optional[StrictStr] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
"""Is Attached # noqa: E501
|
|
|
|
This method makes a synchronous HTTP request by default. To make an
|
|
asynchronous HTTP request, please pass async_req=True
|
|
|
|
>>> thread = api.is_attached_with_http_info(entity_did, async_req=True)
|
|
>>> result = thread.get()
|
|
|
|
:param entity_did:
|
|
:type entity_did: str
|
|
:param async_req: Whether to execute the request asynchronously.
|
|
:type async_req: bool, optional
|
|
:param _preload_content: if False, the ApiResponse.data will
|
|
be set to none and raw_data will store the
|
|
HTTP response body without reading/decoding.
|
|
Default is True.
|
|
:type _preload_content: bool, optional
|
|
:param _return_http_data_only: response data instead of ApiResponse
|
|
object with status code, headers, etc
|
|
:type _return_http_data_only: bool, optional
|
|
:param _request_timeout: 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.
|
|
:param _request_auth: set to override the auth_settings for an a single
|
|
request; this effectively ignores the authentication
|
|
in the spec for a single request.
|
|
:type _request_auth: dict, optional
|
|
:type _content_type: string, optional: force content-type for the request
|
|
:return: Returns the result object.
|
|
If the method is called asynchronously,
|
|
returns the request thread.
|
|
:rtype: tuple(Dict[str, str], status_code(int), headers(HTTPHeaderDict))
|
|
"""
|
|
|
|
_params = locals()
|
|
|
|
_all_params = [
|
|
'entity_did'
|
|
]
|
|
_all_params.extend(
|
|
[
|
|
'async_req',
|
|
'_return_http_data_only',
|
|
'_preload_content',
|
|
'_request_timeout',
|
|
'_request_auth',
|
|
'_content_type',
|
|
'_headers'
|
|
]
|
|
)
|
|
|
|
# validate the arguments
|
|
for _key, _val in _params['kwargs'].items():
|
|
if _key not in _all_params:
|
|
raise ApiTypeError(
|
|
"Got an unexpected keyword argument '%s'"
|
|
" to method is_attached" % _key
|
|
)
|
|
_params[_key] = _val
|
|
del _params['kwargs']
|
|
|
|
_collection_formats = {}
|
|
|
|
# process the path parameters
|
|
_path_params = {}
|
|
|
|
# process the query parameters
|
|
_query_params = []
|
|
if _params.get('entity_did') is not None: # noqa: E501
|
|
_query_params.append(('entity_did', _params['entity_did']))
|
|
|
|
# process the header parameters
|
|
_header_params = dict(_params.get('_headers', {}))
|
|
# process the form parameters
|
|
_form_params = []
|
|
_files = {}
|
|
# process the body parameter
|
|
_body_params = None
|
|
# set the HTTP header `Accept`
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
['application/json']) # noqa: E501
|
|
|
|
# authentication setting
|
|
_auth_settings = [] # noqa: E501
|
|
|
|
_response_types_map = {
|
|
'200': "Dict[str, str]",
|
|
'422': "HTTPValidationError",
|
|
}
|
|
|
|
return self.api_client.call_api(
|
|
'/api/v1/is_attached', 'GET',
|
|
_path_params,
|
|
_query_params,
|
|
_header_params,
|
|
body=_body_params,
|
|
post_params=_form_params,
|
|
files=_files,
|
|
response_types_map=_response_types_map,
|
|
auth_settings=_auth_settings,
|
|
async_req=_params.get('async_req'),
|
|
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
|
|
_preload_content=_params.get('_preload_content', True),
|
|
_request_timeout=_params.get('_request_timeout'),
|
|
collection_formats=_collection_formats,
|
|
_request_auth=_params.get('_request_auth'))
|