def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.v1_positions_get_endpoint = _Endpoint(
settings={
'response_type': (Positions,),
'auth': [],
'endpoint_path': '/v1/positions',
'operation_id': 'v1_positions_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'exchange_id',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'exchange_id':
(str,),
},
'attribute_map': {
'exchange_id': 'exchange_id',
},
'location_map': {
'exchange_id': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json',
'appliction/json'
],
'content_type': [],
},
api_client=api_client
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __getlocatie(
self,
identificatie,
**kwargs
):
"""getlocatie # noqa: E501
<body><p>Het bericht dat de JSON/REST API voor het ophalen van gegevens van een amendement retourneert.</p></body> # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.getlocatie(identificatie, async_req=True)
>>> result = thread.get()
Args:
identificatie (str): <body><p>De unieke identificatie waaronder elk object van dit type bekend is.</p></body><body><p>Een inhoudelijke toelichting op de toepassing van het informatie-element.</p></body><body><p>De verzameling van waarden die gegevens van dit attribuutsoort kunnen hebben, dat wil zeggen het waardenbereik, uitgedrukt in een specifieke structuur.</p></body>
Keyword Args:
accept_crs (CrsEnum): Gewenste CRS van de coördinaten in de response.. [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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
LocatieHal
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')
kwargs['identificatie'] = \
identificatie
return self.call_with_http_info(**kwargs)
self.getlocatie = _Endpoint(
settings={
'response_type': (LocatieHal,),
'auth': [],
'endpoint_path': '/locaties/{identificatie}',
'operation_id': 'getlocatie',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'identificatie',
'accept_crs',
],
'required': [
'identificatie',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'identificatie':
(str,),
'accept_crs':
(CrsEnum,),
},
'attribute_map': {
'identificatie': 'identificatie',
'accept_crs': 'Accept-Crs',
},
'location_map': {
'identificatie': 'path',
'accept_crs': 'header',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/hal+json',
'application/problem+json'
],
'content_type': [],
},
api_client=api_client,
callable=__getlocatie
)
def __getlocaties(
self,
**kwargs
):
"""getlocaties # noqa: E501
<body><p>Het bericht dat de JSON/REST API voor het ophalen van een collectie amendementen retourneert.</p></body> # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.getlocaties(async_req=True)
>>> result = thread.get()
Keyword Args:
accept_crs (CrsEnum): Gewenste CRS van de coördinaten in de response.. [optional]
page (int): Een pagina binnen de gepagineerde resultatenset.. [optional]
page_size (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
LocatieHalCollectie
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')
return self.call_with_http_info(**kwargs)
self.getlocaties = _Endpoint(
settings={
'response_type': (LocatieHalCollectie,),
'auth': [],
'endpoint_path': '/locaties',
'operation_id': 'getlocaties',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'accept_crs',
'page',
'page_size',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
'page',
'page_size',
]
},
root_map={
'validations': {
('page',): {
'inclusive_minimum': 1,
},
('page_size',): {
'inclusive_maximum': 100,
'inclusive_minimum': 1,
},
},
'allowed_values': {
},
'openapi_types': {
'accept_crs':
(CrsEnum,),
'page':
(int,),
'page_size':
(int,),
},
'attribute_map': {
'accept_crs': 'Accept-Crs',
'page': 'page',
'page_size': 'pageSize',
},
'location_map': {
'accept_crs': 'header',
'page': 'query',
'page_size': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/hal+json',
'application/problem+json'
],
'content_type': [],
},
api_client=api_client,
callable=__getlocaties
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __auth_login_create(
self,
username,
password,
token,
**kwargs
):
"""auth_login_create # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.auth_login_create(username, password, token, async_req=True)
>>> result = thread.get()
Args:
username (str):
password (str):
token (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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
AuthToken
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')
kwargs['username'] = \
username
kwargs['password'] = \
password
kwargs['token'] = \
token
return self.call_with_http_info(**kwargs)
self.auth_login_create = _Endpoint(
settings={
'response_type': (AuthToken,),
'auth': [
'basicAuth',
'cookieAuth',
'jwtAuth',
'tokenAuth'
],
'endpoint_path': '/auth/login',
'operation_id': 'auth_login_create',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'username',
'password',
'token',
],
'required': [
'username',
'password',
'token',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'username':
(str,),
'password':
(str,),
'token':
(str,),
},
'attribute_map': {
'username': '******',
'password': '******',
'token': 'token',
},
'location_map': {
'username': '******',
'password': '******',
'token': 'form',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/x-www-form-urlencoded',
'multipart/form-data',
'application/json'
]
},
api_client=api_client,
callable=__auth_login_create
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __change_speed(self, change_speed, **kwargs):
"""change_speed # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.change_speed(change_speed, async_req=True)
>>> result = thread.get()
Args:
change_speed (ChangeSpeed):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
SimpleResponse
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')
kwargs['change_speed'] = \
change_speed
return self.call_with_http_info(**kwargs)
self.change_speed = _Endpoint(settings={
'response_type': (SimpleResponse, ),
'auth': ['bearer_access_token'],
'endpoint_path': '/replay/changespeed',
'operation_id': 'change_speed',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'change_speed',
],
'required': [
'change_speed',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'change_speed': (ChangeSpeed, ),
},
'attribute_map': {},
'location_map': {
'change_speed': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__change_speed)
def __check_replay_session(self, check_replay_session, **kwargs):
"""check_replay_session # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.check_replay_session(check_replay_session, async_req=True)
>>> result = thread.get()
Args:
check_replay_session (CheckReplaySession):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
CheckReplaySessionResponse
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')
kwargs['check_replay_session'] = \
check_replay_session
return self.call_with_http_info(**kwargs)
self.check_replay_session = _Endpoint(settings={
'response_type': (CheckReplaySessionResponse, ),
'auth': ['bearer_access_token'],
'endpoint_path':
'/replay/checkreplaysession',
'operation_id':
'check_replay_session',
'http_method':
'POST',
'servers':
None,
},
params_map={
'all': [
'check_replay_session',
],
'required': [
'check_replay_session',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'check_replay_session':
(CheckReplaySession, ),
},
'attribute_map': {},
'location_map': {
'check_replay_session':
'body',
},
'collection_format_map': {}
},
headers_map={
'accept':
['application/json'],
'content_type':
['application/json']
},
api_client=api_client,
callable=__check_replay_session)
def __initialize_clock(self, initialize_clock, **kwargs):
"""initialize_clock # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.initialize_clock(initialize_clock, async_req=True)
>>> result = thread.get()
Args:
initialize_clock (InitializeClock):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
SimpleResponse
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')
kwargs['initialize_clock'] = \
initialize_clock
return self.call_with_http_info(**kwargs)
self.initialize_clock = _Endpoint(settings={
'response_type': (SimpleResponse, ),
'auth': ['bearer_access_token'],
'endpoint_path': '/replay/initializeclock',
'operation_id': 'initialize_clock',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'initialize_clock',
],
'required': [
'initialize_clock',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'initialize_clock':
(InitializeClock, ),
},
'attribute_map': {},
'location_map': {
'initialize_clock': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type':
['application/json']
},
api_client=api_client,
callable=__initialize_clock)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_waarde(
self,
tabelidentificatie,
code,
**kwargs
):
"""get_waarde # noqa: E501
Het ophalen van de gegevens van een enkele waarde uit een landelijke tabel. # 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_waarde(tabelidentificatie, code, async_req=True)
>>> result = thread.get()
Args:
tabelidentificatie (str): De identificatie van een landelijke tabel.
code (str): De code, behorende bij de tabelwaarde.
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
Waarde
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')
kwargs['tabelidentificatie'] = \
tabelidentificatie
kwargs['code'] = \
code
return self.call_with_http_info(**kwargs)
self.get_waarde = _Endpoint(
settings={
'response_type': (Waarde,),
'auth': [],
'endpoint_path': '/tabellen/{tabelidentificatie}/waarden/{code}',
'operation_id': 'get_waarde',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'tabelidentificatie',
'code',
],
'required': [
'tabelidentificatie',
'code',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'tabelidentificatie':
(str,),
'code':
(str,),
},
'attribute_map': {
'tabelidentificatie': 'tabelidentificatie',
'code': 'code',
},
'location_map': {
'tabelidentificatie': 'path',
'code': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json',
'application/problem+json'
],
'content_type': [],
},
api_client=api_client,
callable=__get_waarde
)
def __get_waarden(
self,
tabelidentificatie,
**kwargs
):
"""get_waarden # noqa: E501
Het ophalen van de tabelwaarden van een landelijke tabel.<br>Als er op omschrijving of code gezocht wordt worden alleen actuele waarden geretourneerd. <br> Als de parameter <b> inclusief beeindigd </b> met waarde <i> true </i> wordt meegegeven bij de call worden ook beeindigde waarden geretourneerd. # 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_waarden(tabelidentificatie, async_req=True)
>>> result = thread.get()
Args:
tabelidentificatie (str): De identificatie van een landelijke tabel.
Keyword Args:
code (str): De code, behorende bij de tabelwaarde.. [optional]
omschrijving (str): De omschrijving van de tabelwaarde. <br> Bij het zoeken mag er gebruik worden gemaakt van <b>[wildcards](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/master/features/wildcard.feature)</b>. <br>Zoeken is <b>[case-Insensitive](https://github.com/VNG-Realisatie/Bevragingen-ingeschreven-personen/blob/master/features/case_insensitive.feature)</b></a>. [optional]
inclusiefbeeindigd (bool): De indicatie waarmee aangegeven wordt of beëindigde waarden moeten worden meegeleverd. Default worden alleen actuele tabelwaarden geretourneerd. Wanneer deze wordt opgenomen met de waarde true, dan worden ook beëindigde tabelwaarden meegeleverd.. [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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
WaardeCollectie
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')
kwargs['tabelidentificatie'] = \
tabelidentificatie
return self.call_with_http_info(**kwargs)
self.get_waarden = _Endpoint(
settings={
'response_type': (WaardeCollectie,),
'auth': [],
'endpoint_path': '/tabellen/{tabelidentificatie}/waarden',
'operation_id': 'get_waarden',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'tabelidentificatie',
'code',
'omschrijving',
'inclusiefbeeindigd',
],
'required': [
'tabelidentificatie',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'tabelidentificatie':
(str,),
'code':
(str,),
'omschrijving':
(str,),
'inclusiefbeeindigd':
(bool,),
},
'attribute_map': {
'tabelidentificatie': 'tabelidentificatie',
'code': 'code',
'omschrijving': 'omschrijving',
'inclusiefbeeindigd': 'inclusiefbeeindigd',
},
'location_map': {
'tabelidentificatie': 'path',
'code': 'query',
'omschrijving': 'query',
'inclusiefbeeindigd': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json',
'application/problem+json'
],
'content_type': [],
},
api_client=api_client,
callable=__get_waarden
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_fixed_cost_auto_fills(self, fact_id, model, **kwargs):
"""get_fixed_cost_auto_fills # 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_fixed_cost_auto_fills(fact_id, model, async_req=True)
>>> result = thread.get()
Args:
fact_id (str):
model (Model):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[FixedCostAutoFill]
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')
kwargs['fact_id'] = \
fact_id
kwargs['model'] = \
model
return self.call_with_http_info(**kwargs)
self.get_fixed_cost_auto_fills = _Endpoint(
settings={
'response_type': ([FixedCostAutoFill], ),
'auth': [],
'endpoint_path': '/api/fact-auto-filler/{factId}/fixed-cost',
'operation_id': 'get_fixed_cost_auto_fills',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'fact_id',
'model',
],
'required': [
'fact_id',
'model',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'fact_id': (str, ),
'model': (Model, ),
},
'attribute_map': {
'fact_id': 'factId',
},
'location_map': {
'fact_id': 'path',
'model': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__get_fixed_cost_auto_fills)
def __get_percent_of_items_auto_fills(self, item_name,
dependent_item_name, model,
**kwargs):
"""get_percent_of_items_auto_fills # 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_percent_of_items_auto_fills(item_name, dependent_item_name, model, async_req=True)
>>> result = thread.get()
Args:
item_name (str):
dependent_item_name (str):
model (Model):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[PercentOfAnotherItemAutoFill]
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')
kwargs['item_name'] = \
item_name
kwargs['dependent_item_name'] = \
dependent_item_name
kwargs['model'] = \
model
return self.call_with_http_info(**kwargs)
self.get_percent_of_items_auto_fills = _Endpoint(
settings={
'response_type': ([PercentOfAnotherItemAutoFill], ),
'auth': [],
'endpoint_path':
'/api/fact-auto-filler/{itemName}/percent-of-another-item',
'operation_id': 'get_percent_of_items_auto_fills',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'item_name',
'dependent_item_name',
'model',
],
'required': [
'item_name',
'dependent_item_name',
'model',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'item_name': (str, ),
'dependent_item_name': (str, ),
'model': (Model, ),
},
'attribute_map': {
'item_name': 'itemName',
'dependent_item_name': 'dependentItemName',
},
'location_map': {
'item_name': 'path',
'dependent_item_name': 'query',
'model': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__get_percent_of_items_auto_fills)
def __get_percent_of_revenue_auto_fills(self, item_name, model,
**kwargs):
"""get_percent_of_revenue_auto_fills # 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_percent_of_revenue_auto_fills(item_name, model, async_req=True)
>>> result = thread.get()
Args:
item_name (str):
model (Model):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[PercentOfRevenueAutoFill]
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')
kwargs['item_name'] = \
item_name
kwargs['model'] = \
model
return self.call_with_http_info(**kwargs)
self.get_percent_of_revenue_auto_fills = _Endpoint(
settings={
'response_type': ([PercentOfRevenueAutoFill], ),
'auth': [],
'endpoint_path':
'/api/fact-auto-filler/{itemName}/percent-of-revenue',
'operation_id': 'get_percent_of_revenue_auto_fills',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'item_name',
'model',
],
'required': [
'item_name',
'model',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'item_name': (str, ),
'model': (Model, ),
},
'attribute_map': {
'item_name': 'itemName',
},
'location_map': {
'item_name': 'path',
'model': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__get_percent_of_revenue_auto_fills)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __create(self, cik, **kwargs):
"""create # 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(cik, async_req=True)
>>> result = thread.get()
Args:
cik (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
StockAnalysis2
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')
kwargs['cik'] = \
cik
return self.call_with_http_info(**kwargs)
self.create = _Endpoint(settings={
'response_type': (StockAnalysis2, ),
'auth': [],
'endpoint_path': '/api/stock-analyzer/workflow/{cik}',
'operation_id': 'create',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'cik',
],
'required': [
'cik',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'cik': (str, ),
},
'attribute_map': {
'cik': 'cik',
},
'location_map': {
'cik': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': [],
},
api_client=api_client,
callable=__create)
def __evaluate(self, evaluate_model_request, **kwargs):
"""evaluate # noqa: E501
This API evaluates a model you've assembled and return a stock analysis object The passed in Model represents high level relationship between the various financial statement items of underlying a stock Calling this method evaluates those relationships and turn them into real numbers This API does not persist (save) the stock analysis. Please call the stock analysis service API to save the analysis This is a stateless calculator # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.evaluate(evaluate_model_request, async_req=True)
>>> result = thread.get()
Args:
evaluate_model_request (EvaluateModelRequest):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
StockAnalysis2
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')
kwargs['evaluate_model_request'] = \
evaluate_model_request
return self.call_with_http_info(**kwargs)
self.evaluate = _Endpoint(settings={
'response_type': (StockAnalysis2, ),
'auth': [],
'endpoint_path': '/api/stock-analyzer/workflow/evaluate',
'operation_id': 'evaluate',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'evaluate_model_request',
],
'required': [
'evaluate_model_request',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'evaluate_model_request':
(EvaluateModelRequest, ),
},
'attribute_map': {},
'location_map': {
'evaluate_model_request': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__evaluate)
def __refresh(self, stock_analysis2, **kwargs):
"""refresh # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.refresh(stock_analysis2, async_req=True)
>>> result = thread.get()
Args:
stock_analysis2 (StockAnalysis2):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
StockAnalysis2
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')
kwargs['stock_analysis2'] = \
stock_analysis2
return self.call_with_http_info(**kwargs)
self.refresh = _Endpoint(settings={
'response_type': (StockAnalysis2, ),
'auth': [],
'endpoint_path': '/api/stock-analyzer/workflow/refresh',
'operation_id': 'refresh',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'stock_analysis2',
],
'required': [
'stock_analysis2',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'stock_analysis2': (StockAnalysis2, ),
},
'attribute_map': {},
'location_map': {
'stock_analysis2': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__refresh)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __v1_orders_cancel_all_post(self, order_cancel_all_request,
**kwargs):
"""Cancel all orders request # noqa: E501
This request cancels all open orders on single specified exchange. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.v1_orders_cancel_all_post(order_cancel_all_request, async_req=True)
>>> result = thread.get()
Args:
order_cancel_all_request (OrderCancelAllRequest): OrderCancelAllRequest object.
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
Message
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')
kwargs['order_cancel_all_request'] = \
order_cancel_all_request
return self.call_with_http_info(**kwargs)
self.v1_orders_cancel_all_post = _Endpoint(
settings={
'response_type': (Message, ),
'auth': [],
'endpoint_path': '/v1/orders/cancel/all',
'operation_id': 'v1_orders_cancel_all_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'order_cancel_all_request',
],
'required': [
'order_cancel_all_request',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'order_cancel_all_request': (OrderCancelAllRequest, ),
},
'attribute_map': {},
'location_map': {
'order_cancel_all_request': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json', 'appliction/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__v1_orders_cancel_all_post)
def __v1_orders_cancel_post(self, order_cancel_single_request,
**kwargs):
"""Cancel order request # noqa: E501
Request cancel for an existing order. The order can be canceled using the `client_order_id` or `exchange_order_id`. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.v1_orders_cancel_post(order_cancel_single_request, async_req=True)
>>> result = thread.get()
Args:
order_cancel_single_request (OrderCancelSingleRequest): OrderCancelSingleRequest object.
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
OrderExecutionReport
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')
kwargs['order_cancel_single_request'] = \
order_cancel_single_request
return self.call_with_http_info(**kwargs)
self.v1_orders_cancel_post = _Endpoint(
settings={
'response_type': (OrderExecutionReport, ),
'auth': [],
'endpoint_path': '/v1/orders/cancel',
'operation_id': 'v1_orders_cancel_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'order_cancel_single_request',
],
'required': [
'order_cancel_single_request',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'order_cancel_single_request':
(OrderCancelSingleRequest, ),
},
'attribute_map': {},
'location_map': {
'order_cancel_single_request': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json', 'appliction/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__v1_orders_cancel_post)
def __v1_orders_get(self, **kwargs):
"""Get open orders # noqa: E501
Get last execution reports for open orders across all or single exchange. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.v1_orders_get(async_req=True)
>>> result = thread.get()
Keyword Args:
exchange_id (str): Filter the open orders to the specific exchange.. [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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
OrderExecutionReports
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')
return self.call_with_http_info(**kwargs)
self.v1_orders_get = _Endpoint(
settings={
'response_type': (OrderExecutionReports, ),
'auth': [],
'endpoint_path': '/v1/orders',
'operation_id': 'v1_orders_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'exchange_id',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'exchange_id': (str, ),
},
'attribute_map': {
'exchange_id': 'exchange_id',
},
'location_map': {
'exchange_id': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json', 'appliction/json'],
'content_type': [],
},
api_client=api_client,
callable=__v1_orders_get)
def __v1_orders_post(self, order_new_single_request, **kwargs):
"""Send new order # noqa: E501
This request creating new order for the specific exchange. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.v1_orders_post(order_new_single_request, async_req=True)
>>> result = thread.get()
Args:
order_new_single_request (OrderNewSingleRequest): OrderNewSingleRequest object.
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
OrderExecutionReport
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')
kwargs['order_new_single_request'] = \
order_new_single_request
return self.call_with_http_info(**kwargs)
self.v1_orders_post = _Endpoint(
settings={
'response_type': (OrderExecutionReport, ),
'auth': [],
'endpoint_path': '/v1/orders',
'operation_id': 'v1_orders_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'order_new_single_request',
],
'required': [
'order_new_single_request',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'order_new_single_request': (OrderNewSingleRequest, ),
},
'attribute_map': {},
'location_map': {
'order_new_single_request': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json', 'appliction/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__v1_orders_post)
def __v1_orders_status_client_order_id_get(self, client_order_id,
**kwargs):
"""Get order execution report # noqa: E501
Get the last order execution report for the specified order. The requested order does not need to be active or opened. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.v1_orders_status_client_order_id_get(client_order_id, async_req=True)
>>> result = thread.get()
Args:
client_order_id (str): The unique identifier of the order assigned by the client.
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
OrderExecutionReport
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')
kwargs['client_order_id'] = \
client_order_id
return self.call_with_http_info(**kwargs)
self.v1_orders_status_client_order_id_get = _Endpoint(
settings={
'response_type': (OrderExecutionReport, ),
'auth': [],
'endpoint_path': '/v1/orders/status/{client_order_id}',
'operation_id': 'v1_orders_status_client_order_id_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'client_order_id',
],
'required': [
'client_order_id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'client_order_id': (str, ),
},
'attribute_map': {
'client_order_id': 'client_order_id',
},
'location_map': {
'client_order_id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__v1_orders_status_client_order_id_get)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __early_access_requests(
self,
early_access_request,
**kwargs
):
"""early_access_requests # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.early_access_requests(early_access_request, async_req=True)
>>> result = thread.get()
Args:
early_access_request (EarlyAccessRequest):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['early_access_request'] = \
early_access_request
return self.call_with_http_info(**kwargs)
self.early_access_requests = _Endpoint(
settings={
'response_type': None,
'auth': [],
'endpoint_path': '/public/marketing/early-access-requests',
'operation_id': 'early_access_requests',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'early_access_request',
],
'required': [
'early_access_request',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'early_access_request':
(EarlyAccessRequest,),
},
'attribute_map': {
},
'location_map': {
'early_access_request': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__early_access_requests
)
def __feedback20210329(
self,
feedback,
**kwargs
):
"""feedback20210329 # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.feedback20210329(feedback, async_req=True)
>>> result = thread.get()
Args:
feedback (Feedback):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['feedback'] = \
feedback
return self.call_with_http_info(**kwargs)
self.feedback20210329 = _Endpoint(
settings={
'response_type': None,
'auth': [],
'endpoint_path': '/public/marketing/2021-03-29/feedback',
'operation_id': 'feedback20210329',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'feedback',
],
'required': [
'feedback',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'feedback':
(Feedback,),
},
'attribute_map': {
},
'location_map': {
'feedback': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__feedback20210329
)
def __stock_analysis_interest(
self,
stock_analysis_interest,
**kwargs
):
"""stock_analysis_interest # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.stock_analysis_interest(stock_analysis_interest, async_req=True)
>>> result = thread.get()
Args:
stock_analysis_interest (StockAnalysisInterest):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['stock_analysis_interest'] = \
stock_analysis_interest
return self.call_with_http_info(**kwargs)
self.stock_analysis_interest = _Endpoint(
settings={
'response_type': None,
'auth': [],
'endpoint_path': '/public/marketing/stock-analysis-interest',
'operation_id': 'stock_analysis_interest',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'stock_analysis_interest',
],
'required': [
'stock_analysis_interest',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'stock_analysis_interest':
(StockAnalysisInterest,),
},
'attribute_map': {
},
'location_map': {
'stock_analysis_interest': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__stock_analysis_interest
)
def __stock_analysis_request(
self,
stock_analysis_request,
**kwargs
):
"""stock_analysis_request # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.stock_analysis_request(stock_analysis_request, async_req=True)
>>> result = thread.get()
Args:
stock_analysis_request ([StockAnalysisRequest]):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['stock_analysis_request'] = \
stock_analysis_request
return self.call_with_http_info(**kwargs)
self.stock_analysis_request = _Endpoint(
settings={
'response_type': None,
'auth': [],
'endpoint_path': '/public/marketing/stock-analysis-request',
'operation_id': 'stock_analysis_request',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'stock_analysis_request',
],
'required': [
'stock_analysis_request',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'stock_analysis_request':
([StockAnalysisRequest],),
},
'attribute_map': {
},
'location_map': {
'stock_analysis_request': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__stock_analysis_request
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __api_schema_retrieve(self, **kwargs):
"""api_schema_retrieve # noqa: E501
OpenApi3 schema for this API. Format can be selected via content negotiation. - YAML: application/vnd.oai.openapi - JSON: application/vnd.oai.openapi+json **Permission restrictions:** + `AllowAny`: *Allow any access. This isn't strictly required, since you could use an empty permission_classes list, but it's useful because it makes the intention more explicit.* # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.api_schema_retrieve(async_req=True)
>>> result = thread.get()
Keyword Args:
format (str): [optional]
lang (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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
{str: (bool, date, datetime, dict, float, int, list, str, none_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')
return self.call_with_http_info(**kwargs)
self.api_schema_retrieve = _Endpoint(
settings={
'response_type': ({
str: (bool, date, datetime, dict, float, int, list, str,
none_type)
}, ),
'auth': ['basicAuth', 'cookieAuth', 'jwtAuth', 'tokenAuth'],
'endpoint_path':
'/api/schema/',
'operation_id':
'api_schema_retrieve',
'http_method':
'GET',
'servers':
None,
},
params_map={
'all': [
'format',
'lang',
],
'required': [],
'nullable': [],
'enum': [
'format',
'lang',
],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {
('format', ): {
"JSON": "json",
"YAML": "yaml"
},
('lang', ): {
"AF": "af",
"AR": "ar",
"AR-DZ": "ar-dz",
"AST": "ast",
"AZ": "az",
"BE": "be",
"BG": "bg",
"BN": "bn",
"BR": "br",
"BS": "bs",
"CA": "ca",
"CS": "cs",
"CY": "cy",
"DA": "da",
"DE": "de",
"DSB": "dsb",
"EL": "el",
"EN": "en",
"EN-AU": "en-au",
"EN-GB": "en-gb",
"EO": "eo",
"ES": "es",
"ES-AR": "es-ar",
"ES-CO": "es-co",
"ES-MX": "es-mx",
"ES-NI": "es-ni",
"ES-VE": "es-ve",
"ET": "et",
"EU": "eu",
"FA": "fa",
"FI": "fi",
"FR": "fr",
"FY": "fy",
"GA": "ga",
"GD": "gd",
"GL": "gl",
"HE": "he",
"HI": "hi",
"HR": "hr",
"HSB": "hsb",
"HU": "hu",
"HY": "hy",
"IA": "ia",
"ID": "id",
"IG": "ig",
"IO": "io",
"IS": "is",
"IT": "it",
"JA": "ja",
"KA": "ka",
"KAB": "kab",
"KK": "kk",
"KM": "km",
"KN": "kn",
"KO": "ko",
"KY": "ky",
"LB": "lb",
"LT": "lt",
"LV": "lv",
"MK": "mk",
"ML": "ml",
"MN": "mn",
"MR": "mr",
"MY": "my",
"NB": "nb",
"NE": "ne",
"NL": "nl",
"NN": "nn",
"OS": "os",
"PA": "pa",
"PL": "pl",
"PT": "pt",
"PT-BR": "pt-br",
"RO": "ro",
"RU": "ru",
"SK": "sk",
"SL": "sl",
"SQ": "sq",
"SR": "sr",
"SR-LATN": "sr-latn",
"SV": "sv",
"SW": "sw",
"TA": "ta",
"TE": "te",
"TG": "tg",
"TH": "th",
"TK": "tk",
"TR": "tr",
"TT": "tt",
"UDM": "udm",
"UK": "uk",
"UR": "ur",
"UZ": "uz",
"VI": "vi",
"ZH-HANS": "zh-hans",
"ZH-HANT": "zh-hant"
},
},
'openapi_types': {
'format': (str, ),
'lang': (str, ),
},
'attribute_map': {
'format': 'format',
'lang': 'lang',
},
'location_map': {
'format': 'query',
'lang': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': [
'application/vnd.oai.openapi', 'application/yaml',
'application/vnd.oai.openapi+json', 'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__api_schema_retrieve)
def __api_token_create(self, token_obtain_pair, **kwargs):
"""api_token_create # noqa: E501
Takes a set of user credentials and returns an access and refresh JSON web token pair to prove the authentication of those credentials. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.api_token_create(token_obtain_pair, async_req=True)
>>> result = thread.get()
Args:
token_obtain_pair (TokenObtainPair):
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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
TokenObtainPair
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')
kwargs['token_obtain_pair'] = \
token_obtain_pair
return self.call_with_http_info(**kwargs)
self.api_token_create = _Endpoint(
settings={
'response_type': (TokenObtainPair, ),
'auth': [],
'endpoint_path': '/api/token/',
'operation_id': 'api_token_create',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'token_obtain_pair',
],
'required': [
'token_obtain_pair',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'token_obtain_pair': (TokenObtainPair, ),
},
'attribute_map': {},
'location_map': {
'token_obtain_pair': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [
'application/json', 'application/x-www-form-urlencoded',
'multipart/form-data'
]
},
api_client=api_client,
callable=__api_token_create)
def __api_token_refresh_create(self, token_refresh, **kwargs):
"""api_token_refresh_create # noqa: E501
Takes a refresh type JSON web token and returns an access type JSON web token if the refresh token is valid. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.api_token_refresh_create(token_refresh, async_req=True)
>>> result = thread.get()
Args:
token_refresh (TokenRefresh):
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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
TokenRefresh
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')
kwargs['token_refresh'] = \
token_refresh
return self.call_with_http_info(**kwargs)
self.api_token_refresh_create = _Endpoint(
settings={
'response_type': (TokenRefresh, ),
'auth': [],
'endpoint_path': '/api/token/refresh/',
'operation_id': 'api_token_refresh_create',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'token_refresh',
],
'required': [
'token_refresh',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'token_refresh': (TokenRefresh, ),
},
'attribute_map': {},
'location_map': {
'token_refresh': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [
'application/json', 'application/x-www-form-urlencoded',
'multipart/form-data'
]
},
api_client=api_client,
callable=__api_token_refresh_create)
def __api_token_verify_create(self, token_verify, **kwargs):
"""api_token_verify_create # noqa: E501
Takes a token and indicates if it is valid. This view provides no information about a token's fitness for a particular use. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.api_token_verify_create(token_verify, async_req=True)
>>> result = thread.get()
Args:
token_verify (TokenVerify):
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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
TokenVerify
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')
kwargs['token_verify'] = \
token_verify
return self.call_with_http_info(**kwargs)
self.api_token_verify_create = _Endpoint(
settings={
'response_type': (TokenVerify, ),
'auth': [],
'endpoint_path': '/api/token/verify/',
'operation_id': 'api_token_verify_create',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'token_verify',
],
'required': [
'token_verify',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'token_verify': (TokenVerify, ),
},
'attribute_map': {},
'location_map': {
'token_verify': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [
'application/json', 'application/x-www-form-urlencoded',
'multipart/form-data'
]
},
api_client=api_client,
callable=__api_token_verify_create)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __daily_prices(
self,
symbol,
**kwargs
):
"""Get Ticker price # noqa: E501
# noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.daily_prices(symbol, async_req=True)
>>> result = thread.get()
Args:
symbol (str): Name of ticker
Keyword Args:
_from (date): From date. [optional]
to (date): To date. [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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
EndOfDayPriceHistory
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')
kwargs['symbol'] = \
symbol
return self.call_with_http_info(**kwargs)
self.daily_prices = _Endpoint(
settings={
'response_type': (EndOfDayPriceHistory,),
'auth': [
'api_key'
],
'endpoint_path': '/historical-price-full/{symbol}',
'operation_id': 'daily_prices',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'symbol',
'_from',
'to',
],
'required': [
'symbol',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'symbol':
(str,),
'_from':
(date,),
'to':
(date,),
},
'attribute_map': {
'symbol': 'symbol',
'_from': 'from',
'to': 'to',
},
'location_map': {
'symbol': 'path',
'_from': 'query',
'to': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__daily_prices
)
def __intra_day_prices(
self,
symbol,
resolution,
**kwargs
):
"""Get Ticker price # noqa: E501
# noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.intra_day_prices(symbol, resolution, async_req=True)
>>> result = thread.get()
Args:
symbol (str): Name of ticker
resolution (str): Time resolution
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
OHVCVPrices
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')
kwargs['symbol'] = \
symbol
kwargs['resolution'] = \
resolution
return self.call_with_http_info(**kwargs)
self.intra_day_prices = _Endpoint(
settings={
'response_type': (OHVCVPrices,),
'auth': [
'api_key'
],
'endpoint_path': '/historical-chart/{resolution}/{symbol}',
'operation_id': 'intra_day_prices',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'symbol',
'resolution',
],
'required': [
'symbol',
'resolution',
],
'nullable': [
],
'enum': [
'resolution',
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
('resolution',): {
"1MIN": "1min",
"5MIN": "5min",
"15MIN": "15min",
"30MIN": "30min",
"1HOUR": "1hour",
"4HOUR": "4hour"
},
},
'openapi_types': {
'symbol':
(str,),
'resolution':
(str,),
},
'attribute_map': {
'symbol': 'symbol',
'resolution': 'resolution',
},
'location_map': {
'symbol': 'path',
'resolution': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__intra_day_prices
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __event_service_list_workflow_event_bindings(
self, namespace, **kwargs):
"""event_service_list_workflow_event_bindings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.event_service_list_workflow_event_bindings(namespace, async_req=True)
>>> result = thread.get()
Args:
namespace (str):
Keyword Args:
list_options_label_selector (str): A selector to restrict the list of returned objects by their labels. Defaults to everything. +optional.. [optional]
list_options_field_selector (str): A selector to restrict the list of returned objects by their fields. Defaults to everything. +optional.. [optional]
list_options_watch (bool): Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. +optional.. [optional]
list_options_allow_watch_bookmarks (bool): allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored. +optional.. [optional]
list_options_resource_version (str): resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. Defaults to unset +optional. [optional]
list_options_resource_version_match (str): resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. Defaults to unset +optional. [optional]
list_options_timeout_seconds (str): Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. +optional.. [optional]
list_options_limit (str): limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.. [optional]
list_options_continue (str): The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.. [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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
IoArgoprojWorkflowV1alpha1WorkflowEventBindingList
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')
kwargs['namespace'] = \
namespace
return self.call_with_http_info(**kwargs)
self.event_service_list_workflow_event_bindings = _Endpoint(
settings={
'response_type':
(IoArgoprojWorkflowV1alpha1WorkflowEventBindingList, ),
'auth': [],
'endpoint_path':
'/api/v1/workflow-event-bindings/{namespace}',
'operation_id':
'event_service_list_workflow_event_bindings',
'http_method':
'GET',
'servers':
None,
},
params_map={
'all': [
'namespace',
'list_options_label_selector',
'list_options_field_selector',
'list_options_watch',
'list_options_allow_watch_bookmarks',
'list_options_resource_version',
'list_options_resource_version_match',
'list_options_timeout_seconds',
'list_options_limit',
'list_options_continue',
],
'required': [
'namespace',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'namespace': (str, ),
'list_options_label_selector': (str, ),
'list_options_field_selector': (str, ),
'list_options_watch': (bool, ),
'list_options_allow_watch_bookmarks': (bool, ),
'list_options_resource_version': (str, ),
'list_options_resource_version_match': (str, ),
'list_options_timeout_seconds': (str, ),
'list_options_limit': (str, ),
'list_options_continue': (str, ),
},
'attribute_map': {
'namespace': 'namespace',
'list_options_label_selector': 'listOptions.labelSelector',
'list_options_field_selector': 'listOptions.fieldSelector',
'list_options_watch': 'listOptions.watch',
'list_options_allow_watch_bookmarks':
'listOptions.allowWatchBookmarks',
'list_options_resource_version':
'listOptions.resourceVersion',
'list_options_resource_version_match':
'listOptions.resourceVersionMatch',
'list_options_timeout_seconds':
'listOptions.timeoutSeconds',
'list_options_limit': 'listOptions.limit',
'list_options_continue': 'listOptions.continue',
},
'location_map': {
'namespace': 'path',
'list_options_label_selector': 'query',
'list_options_field_selector': 'query',
'list_options_watch': 'query',
'list_options_allow_watch_bookmarks': 'query',
'list_options_resource_version': 'query',
'list_options_resource_version_match': 'query',
'list_options_timeout_seconds': 'query',
'list_options_limit': 'query',
'list_options_continue': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__event_service_list_workflow_event_bindings)
def __event_service_receive_event(self, namespace, discriminator, body,
**kwargs):
"""event_service_receive_event # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.event_service_receive_event(namespace, discriminator, body, async_req=True)
>>> result = thread.get()
Args:
namespace (str): The namespace for the io.argoproj.workflow.v1alpha1. This can be empty if the client has cluster scoped permissions. If empty, then the event is \"broadcast\" to workflow event binding in all namespaces.
discriminator (str): Optional discriminator for the io.argoproj.workflow.v1alpha1. This should almost always be empty. Used for edge-cases where the event payload alone is not provide enough information to discriminate the event. This MUST NOT be used as security mechanism, e.g. to allow two clients to use the same access token, or to support webhooks on unsecured server. Instead, use access tokens. This is made available as `discriminator` in the event binding selector (`/spec/event/selector)`
body (bool, date, datetime, dict, float, int, list, str, none_type): The event itself can be any data.
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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
bool, date, datetime, dict, float, int, list, str, none_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')
kwargs['namespace'] = \
namespace
kwargs['discriminator'] = \
discriminator
kwargs['body'] = \
body
return self.call_with_http_info(**kwargs)
self.event_service_receive_event = _Endpoint(
settings={
'response_type': (
bool,
date,
datetime,
dict,
float,
int,
list,
str,
none_type,
),
'auth': [],
'endpoint_path':
'/api/v1/events/{namespace}/{discriminator}',
'operation_id':
'event_service_receive_event',
'http_method':
'POST',
'servers':
None,
},
params_map={
'all': [
'namespace',
'discriminator',
'body',
],
'required': [
'namespace',
'discriminator',
'body',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'namespace': (str, ),
'discriminator': (str, ),
'body': (
bool,
date,
datetime,
dict,
float,
int,
list,
str,
none_type,
),
},
'attribute_map': {
'namespace': 'namespace',
'discriminator': 'discriminator',
},
'location_map': {
'namespace': 'path',
'discriminator': 'path',
'body': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__event_service_receive_event)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __delete_stock_analysis(self, id, **kwargs):
"""delete_stock_analysis # 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_stock_analysis(id, async_req=True)
>>> result = thread.get()
Args:
id (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['id'] = \
id
return self.call_with_http_info(**kwargs)
self.delete_stock_analysis = _Endpoint(
settings={
'response_type': None,
'auth': [],
'endpoint_path': '/api/stock-analyzer/stock-analyses/{id}',
'operation_id': 'delete_stock_analysis',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__delete_stock_analysis)
def __evaluate_stock_analysis(self, evaluate_model_request, **kwargs):
"""evaluate_stock_analysis # noqa: E501
This API evaluates a model you've assembled and return a stock analysis object The passed in Model represents high level relationship between the various financial statement items of underlying a stock Calling this method evaluates those relationships and turn them into real numbers This API does not persist (save) the stock analysis. Please call the stock analysis service API to save the analysis This is a stateless calculator # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.evaluate_stock_analysis(evaluate_model_request, async_req=True)
>>> result = thread.get()
Args:
evaluate_model_request (EvaluateModelRequest):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
EvaluateModelResponse
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')
kwargs['evaluate_model_request'] = \
evaluate_model_request
return self.call_with_http_info(**kwargs)
self.evaluate_stock_analysis = _Endpoint(
settings={
'response_type': (EvaluateModelResponse, ),
'auth': [],
'endpoint_path': '/api/stock-analyzer/stock-analyses/evaluate',
'operation_id': 'evaluate_stock_analysis',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'evaluate_model_request',
],
'required': [
'evaluate_model_request',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'evaluate_model_request': (EvaluateModelRequest, ),
},
'attribute_map': {},
'location_map': {
'evaluate_model_request': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__evaluate_stock_analysis)
def __find_stock_analyses(self, **kwargs):
"""find_stock_analyses # 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_stock_analyses(async_req=True)
>>> result = thread.get()
Keyword Args:
published (bool): [optional]
user_id (str): [optional]
cik (str): [optional]
ticker (str): [optional]
skip (int): [optional]
limit (int): [optional]
term (str): [optional]
tags ([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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
FindStockAnalysisResponse
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')
return self.call_with_http_info(**kwargs)
self.find_stock_analyses = _Endpoint(settings={
'response_type': (FindStockAnalysisResponse, ),
'auth': [],
'endpoint_path':
'/api/stock-analyzer/stock-analyses',
'operation_id':
'find_stock_analyses',
'http_method':
'GET',
'servers':
None,
},
params_map={
'all': [
'published',
'user_id',
'cik',
'ticker',
'skip',
'limit',
'term',
'tags',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'published': (bool, ),
'user_id': (str, ),
'cik': (str, ),
'ticker': (str, ),
'skip': (int, ),
'limit': (int, ),
'term': (str, ),
'tags': ([str], ),
},
'attribute_map': {
'published': 'published',
'user_id': 'userId',
'cik': 'cik',
'ticker': 'ticker',
'skip': 'skip',
'limit': 'limit',
'term': 'term',
'tags': 'tags',
},
'location_map': {
'published': 'query',
'user_id': 'query',
'cik': 'query',
'ticker': 'query',
'skip': 'query',
'limit': 'query',
'term': 'query',
'tags': 'query',
},
'collection_format_map': {
'tags': 'multi',
}
},
headers_map={
'accept': ['*/*'],
'content_type': [],
},
api_client=api_client,
callable=__find_stock_analyses)
def __get_stock_analysis(self, id, **kwargs):
"""get_stock_analysis # 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_stock_analysis(id, async_req=True)
>>> result = thread.get()
Args:
id (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
StockAnalysis2
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')
kwargs['id'] = \
id
return self.call_with_http_info(**kwargs)
self.get_stock_analysis = _Endpoint(settings={
'response_type': (StockAnalysis2, ),
'auth': [],
'endpoint_path': '/api/stock-analyzer/stock-analyses/{id}',
'operation_id': 'get_stock_analysis',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': [],
},
api_client=api_client,
callable=__get_stock_analysis)
def __publish(self, id, **kwargs):
"""publish # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.publish(id, async_req=True)
>>> result = thread.get()
Args:
id (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
StockAnalysis2
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')
kwargs['id'] = \
id
return self.call_with_http_info(**kwargs)
self.publish = _Endpoint(settings={
'response_type': (StockAnalysis2, ),
'auth': [],
'endpoint_path': '/api/stock-analyzer/stock-analyses/{id}/publish',
'operation_id': 'publish',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': [],
},
api_client=api_client,
callable=__publish)
def __refresh_stock_analysis(self, stock_analysis2, **kwargs):
"""Refresh a stock analysis by rerunning the model # noqa: E501
This API refreshes an existing stock analysis and re-evaluate the model attached to it to produce renewed outputs. Call this API when you are in possession of a previously run stock analysis The returned refreshed stock analysis preserve all the metadata, model overrides of the original analysis This API does not persist (save) the new analysis. This API is a stateless calculator # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.refresh_stock_analysis(stock_analysis2, async_req=True)
>>> result = thread.get()
Args:
stock_analysis2 (StockAnalysis2):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
StockAnalysis2
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')
kwargs['stock_analysis2'] = \
stock_analysis2
return self.call_with_http_info(**kwargs)
self.refresh_stock_analysis = _Endpoint(
settings={
'response_type': (StockAnalysis2, ),
'auth': [],
'endpoint_path': '/api/stock-analyzer/stock-analyses/refresh',
'operation_id': 'refresh_stock_analysis',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'stock_analysis2',
],
'required': [
'stock_analysis2',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'stock_analysis2': (StockAnalysis2, ),
},
'attribute_map': {},
'location_map': {
'stock_analysis2': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__refresh_stock_analysis)
def __save_stock_analysis(self, stock_analysis2, **kwargs):
"""save_stock_analysis # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.save_stock_analysis(stock_analysis2, async_req=True)
>>> result = thread.get()
Args:
stock_analysis2 (StockAnalysis2):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['stock_analysis2'] = \
stock_analysis2
return self.call_with_http_info(**kwargs)
self.save_stock_analysis = _Endpoint(settings={
'response_type': None,
'auth': [],
'endpoint_path': '/api/stock-analyzer/stock-analyses',
'operation_id': 'save_stock_analysis',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'stock_analysis2',
],
'required': [
'stock_analysis2',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'stock_analysis2':
(StockAnalysis2, ),
},
'attribute_map': {},
'location_map': {
'stock_analysis2': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type':
['application/json']
},
api_client=api_client,
callable=__save_stock_analysis)
def __unpublish(self, id, **kwargs):
"""unpublish # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.unpublish(id, async_req=True)
>>> result = thread.get()
Args:
id (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
StockAnalysis2
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')
kwargs['id'] = \
id
return self.call_with_http_info(**kwargs)
self.unpublish = _Endpoint(settings={
'response_type': (StockAnalysis2, ),
'auth': [],
'endpoint_path':
'/api/stock-analyzer/stock-analyses/{id}/unpublish',
'operation_id': 'unpublish',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': [],
},
api_client=api_client,
callable=__unpublish)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_annual_time_series(
self,
fact_id,
**kwargs
):
"""get_annual_time_series # 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_annual_time_series(fact_id, async_req=True)
>>> result = thread.get()
Args:
fact_id (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[Fact]
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')
kwargs['fact_id'] = \
fact_id
return self.call_with_http_info(**kwargs)
self.get_annual_time_series = _Endpoint(
settings={
'response_type': ([Fact],),
'auth': [],
'endpoint_path': '/public/fact-base/{factId}/time-series',
'operation_id': 'get_annual_time_series',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'fact_id',
],
'required': [
'fact_id',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'fact_id':
(str,),
},
'attribute_map': {
'fact_id': 'factId',
},
'location_map': {
'fact_id': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'*/*'
],
'content_type': [],
},
api_client=api_client,
callable=__get_annual_time_series
)
def __get_annual_time_series1(
self,
fact_ids,
**kwargs
):
"""get_annual_time_series1 # 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_annual_time_series1(fact_ids, async_req=True)
>>> result = thread.get()
Args:
fact_ids ([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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[AggregatedFact]
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')
kwargs['fact_ids'] = \
fact_ids
return self.call_with_http_info(**kwargs)
self.get_annual_time_series1 = _Endpoint(
settings={
'response_type': ([AggregatedFact],),
'auth': [],
'endpoint_path': '/public/fact-base/time-series',
'operation_id': 'get_annual_time_series1',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'fact_ids',
],
'required': [
'fact_ids',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'fact_ids':
([str],),
},
'attribute_map': {
'fact_ids': 'factIds',
},
'location_map': {
'fact_ids': 'query',
},
'collection_format_map': {
'fact_ids': 'multi',
}
},
headers_map={
'accept': [
'*/*'
],
'content_type': [],
},
api_client=api_client,
callable=__get_annual_time_series1
)
def __get_fact(
self,
fact_id,
**kwargs
):
"""get_fact # 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_fact(fact_id, async_req=True)
>>> result = thread.get()
Args:
fact_id (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
Fact
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')
kwargs['fact_id'] = \
fact_id
return self.call_with_http_info(**kwargs)
self.get_fact = _Endpoint(
settings={
'response_type': (Fact,),
'auth': [],
'endpoint_path': '/public/fact-base/{factId}',
'operation_id': 'get_fact',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'fact_id',
],
'required': [
'fact_id',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'fact_id':
(str,),
},
'attribute_map': {
'fact_id': 'factId',
},
'location_map': {
'fact_id': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'*/*'
],
'content_type': [],
},
api_client=api_client,
callable=__get_fact
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __best_effort_model(
self,
cik,
adsh,
**kwargs
):
"""best_effort_model # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.best_effort_model(cik, adsh, async_req=True)
>>> result = thread.get()
Args:
cik (str):
adsh (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
Model
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')
kwargs['cik'] = \
cik
kwargs['adsh'] = \
adsh
return self.call_with_http_info(**kwargs)
self.best_effort_model = _Endpoint(
settings={
'response_type': (Model,),
'auth': [],
'endpoint_path': '/api/sec/model-builder-factory',
'operation_id': 'best_effort_model',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'cik',
'adsh',
],
'required': [
'cik',
'adsh',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'cik':
(str,),
'adsh':
(str,),
},
'attribute_map': {
'cik': 'cik',
'adsh': 'adsh',
},
'location_map': {
'cik': 'query',
'adsh': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'*/*'
],
'content_type': [],
},
api_client=api_client,
callable=__best_effort_model
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __votes_destroy(
self,
id,
**kwargs
):
"""votes_destroy # noqa: E501
Vote management, through /votes (put, patch, destroy) or through **Permission restrictions:** + `IsAuthenticated`: *Rejects all operations if the user is not authenticated* + `IsOwnerOrModeratorOrStaff`: *Blocks update/partial_updated/destroy if: * the user is NOT in the staff group * AND if the model has a property called 'owner' and its value differs from the request user * AND if the user is not in the Moderators group Everything else is allowed* + `DjangoModelPermissions`: *The request is authenticated using `django.contrib.auth` permissions. See: https://docs.djangoproject.com/en/dev/topics/auth/#permissions It ensures that the user is authenticated, and has the appropriate `add`/`change`/`delete` permissions on the model. This permission can only be applied against view classes that provide a `.queryset` attribute.* # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.votes_destroy(id, async_req=True)
>>> result = thread.get()
Args:
id (int): A unique integer value identifying this vote.
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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['id'] = \
id
return self.call_with_http_info(**kwargs)
self.votes_destroy = _Endpoint(
settings={
'response_type': None,
'auth': [
'basicAuth',
'cookieAuth',
'jwtAuth',
'tokenAuth'
],
'endpoint_path': '/votes/{id}',
'operation_id': 'votes_destroy',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'id':
(int,),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__votes_destroy
)
def __votes_retrieve(
self,
id,
**kwargs
):
"""votes_retrieve # noqa: E501
Vote management, through /votes (put, patch, destroy) or through **Permission restrictions:** + `IsAuthenticated`: *Rejects all operations if the user is not authenticated* + `IsOwnerOrModeratorOrStaff`: *Blocks update/partial_updated/destroy if: * the user is NOT in the staff group * AND if the model has a property called 'owner' and its value differs from the request user * AND if the user is not in the Moderators group Everything else is allowed* + `DjangoModelPermissions`: *The request is authenticated using `django.contrib.auth` permissions. See: https://docs.djangoproject.com/en/dev/topics/auth/#permissions It ensures that the user is authenticated, and has the appropriate `add`/`change`/`delete` permissions on the model. This permission can only be applied against view classes that provide a `.queryset` attribute.* # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.votes_retrieve(id, async_req=True)
>>> result = thread.get()
Args:
id (int): A unique integer value identifying this vote.
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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
Vote
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')
kwargs['id'] = \
id
return self.call_with_http_info(**kwargs)
self.votes_retrieve = _Endpoint(
settings={
'response_type': (Vote,),
'auth': [
'basicAuth',
'cookieAuth',
'jwtAuth',
'tokenAuth'
],
'endpoint_path': '/votes/{id}',
'operation_id': 'votes_retrieve',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'id':
(int,),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__votes_retrieve
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.raadpleeg_actueel_wozobject_endpoint = _Endpoint(
settings={
'response_type': (WozObjectHal, ),
'auth': [],
'endpoint_path': '/wozobjecten/{identificatie}',
'operation_id': 'raadpleeg_actueel_wozobject',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'identificatie',
'fields',
],
'required': [
'identificatie',
],
'nullable': [],
'enum': [],
'validation': [
'identificatie',
]
},
root_map={
'validations': {
('identificatie', ): {
'regex': {
'pattern': r'^[0-9]{12}$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'identificatie': (str, ),
'fields': (str, ),
},
'attribute_map': {
'identificatie': 'identificatie',
'fields': 'fields',
},
'location_map': {
'identificatie': 'path',
'fields': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/hal+json', 'application/problem+json'],
'content_type': [],
},
api_client=api_client)
self.zoek_actuele_wozobjecten_endpoint = _Endpoint(
settings={
'response_type': (WozObjectHalCollectie, ),
'auth': [],
'endpoint_path': '/wozobjecten',
'operation_id': 'zoek_actuele_wozobjecten',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'rsin',
'kvk_nummer',
'adresseerbaar_object_identificatie',
'nummeraanduiding_identificatie',
'postcode',
'huisnummer',
'huisnummertoevoeging',
'huisletter',
'fields',
'page',
'page_size',
],
'required': [],
'nullable': [],
'enum': [],
'validation': [
'rsin',
'kvk_nummer',
'adresseerbaar_object_identificatie',
'nummeraanduiding_identificatie',
'postcode',
'huisnummer',
'huisnummertoevoeging',
'huisletter',
'page',
'page_size',
]
},
root_map={
'validations': {
('rsin', ): {
'regex': {
'pattern': r'^[0-9]{9}$', # noqa: E501
},
},
('kvk_nummer', ): {
'regex': {
'pattern': r'^[0-9]{8}$', # noqa: E501
},
},
('adresseerbaar_object_identificatie', ): {
'regex': {
'pattern': r'^[0-9]{16}$', # noqa: E501
},
},
('nummeraanduiding_identificatie', ): {
'regex': {
'pattern': r'^[0-9]{16}$', # noqa: E501
},
},
('postcode', ): {
'regex': {
'pattern':
r'^[1-9][0-9]{3}[A-Z]{2}$', # noqa: E501
},
},
('huisnummer', ): {
'inclusive_maximum': 99999,
'inclusive_minimum': 1,
},
('huisnummertoevoeging', ): {
'regex': {
'pattern': r'^[0-9a-zA-Z]{1,4}$', # noqa: E501
},
},
('huisletter', ): {
'regex': {
'pattern': r'^[a-zA-Z]$', # noqa: E501
},
},
('page', ): {
'inclusive_minimum': 1,
},
('page_size', ): {
'inclusive_maximum': 100,
'inclusive_minimum': 1,
},
},
'allowed_values': {},
'openapi_types': {
'rsin': (str, ),
'kvk_nummer': (str, ),
'adresseerbaar_object_identificatie': (str, ),
'nummeraanduiding_identificatie': (str, ),
'postcode': (str, ),
'huisnummer': (int, ),
'huisnummertoevoeging': (str, ),
'huisletter': (str, ),
'fields': (str, ),
'page': (int, ),
'page_size': (int, ),
},
'attribute_map': {
'rsin': 'rsin',
'kvk_nummer': 'kvkNummer',
'adresseerbaar_object_identificatie':
'adresseerbaarObjectIdentificatie',
'nummeraanduiding_identificatie':
'nummeraanduidingIdentificatie',
'postcode': 'postcode',
'huisnummer': 'huisnummer',
'huisnummertoevoeging': 'huisnummertoevoeging',
'huisletter': 'huisletter',
'fields': 'fields',
'page': 'page',
'page_size': 'pageSize',
},
'location_map': {
'rsin': 'query',
'kvk_nummer': 'query',
'adresseerbaar_object_identificatie': 'query',
'nummeraanduiding_identificatie': 'query',
'postcode': 'query',
'huisnummer': 'query',
'huisnummertoevoeging': 'query',
'huisletter': 'query',
'fields': 'query',
'page': 'query',
'page_size': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/hal+json', 'application/problem+json'],
'content_type': [],
},
api_client=api_client)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __fetchs_create(
self,
**kwargs
):
"""fetchs_create # noqa: E501
SFetching results attached to a submission **Permission restrictions:** + `IsAuthenticated`: *Rejects all operations if the user is not authenticated* + `IsOwnerOrStaff`: *Blocks update/partial_updated/destroy if: * the user is NOT in the staff group * AND if the model has a property called 'owner' and its value differs from the request user Everything else is allowed* + `DjangoModelPermissions`: *The request is authenticated using `django.contrib.auth` permissions. See: https://docs.djangoproject.com/en/dev/topics/auth/#permissions It ensures that the user is authenticated, and has the appropriate `add`/`change`/`delete` permissions on the model. This permission can only be applied against view classes that provide a `.queryset` attribute.* # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.fetchs_create(async_req=True)
>>> result = thread.get()
Keyword Args:
fetch (Fetch): [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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
Fetch
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')
return self.call_with_http_info(**kwargs)
self.fetchs_create = _Endpoint(
settings={
'response_type': (Fetch,),
'auth': [
'basicAuth',
'cookieAuth',
'jwtAuth',
'tokenAuth'
],
'endpoint_path': '/fetchs',
'operation_id': 'fetchs_create',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'fetch',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'fetch':
(Fetch,),
},
'attribute_map': {
},
'location_map': {
'fetch': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json',
'application/x-www-form-urlencoded',
'multipart/form-data'
]
},
api_client=api_client,
callable=__fetchs_create
)
def __fetchs_destroy(
self,
submission,
**kwargs
):
"""fetchs_destroy # noqa: E501
SFetching results attached to a submission **Permission restrictions:** + `IsAuthenticated`: *Rejects all operations if the user is not authenticated* + `IsOwnerOrStaff`: *Blocks update/partial_updated/destroy if: * the user is NOT in the staff group * AND if the model has a property called 'owner' and its value differs from the request user Everything else is allowed* + `DjangoModelPermissions`: *The request is authenticated using `django.contrib.auth` permissions. See: https://docs.djangoproject.com/en/dev/topics/auth/#permissions It ensures that the user is authenticated, and has the appropriate `add`/`change`/`delete` permissions on the model. This permission can only be applied against view classes that provide a `.queryset` attribute.* # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.fetchs_destroy(submission, async_req=True)
>>> result = thread.get()
Args:
submission (int): A unique value identifying this fetch.
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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['submission'] = \
submission
return self.call_with_http_info(**kwargs)
self.fetchs_destroy = _Endpoint(
settings={
'response_type': None,
'auth': [
'basicAuth',
'cookieAuth',
'jwtAuth',
'tokenAuth'
],
'endpoint_path': '/fetchs/{submission}',
'operation_id': 'fetchs_destroy',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'submission',
],
'required': [
'submission',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'submission':
(int,),
},
'attribute_map': {
'submission': 'submission',
},
'location_map': {
'submission': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__fetchs_destroy
)
def __fetchs_list(
self,
**kwargs
):
"""fetchs_list # noqa: E501
SFetching results attached to a submission **Permission restrictions:** + `IsAuthenticated`: *Rejects all operations if the user is not authenticated* + `IsOwnerOrStaff`: *Blocks update/partial_updated/destroy if: * the user is NOT in the staff group * AND if the model has a property called 'owner' and its value differs from the request user Everything else is allowed* + `DjangoModelPermissions`: *The request is authenticated using `django.contrib.auth` permissions. See: https://docs.djangoproject.com/en/dev/topics/auth/#permissions It ensures that the user is authenticated, and has the appropriate `add`/`change`/`delete` permissions on the model. This permission can only be applied against view classes that provide a `.queryset` attribute.* # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.fetchs_list(async_req=True)
>>> result = thread.get()
Keyword Args:
limit (int): Number of results to return per page.. [optional]
offset (int): The initial index from which to return the results.. [optional]
ordering (str): Which field to use when ordering the results.. [optional]
status (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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
PaginatedFetchList
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')
return self.call_with_http_info(**kwargs)
self.fetchs_list = _Endpoint(
settings={
'response_type': (PaginatedFetchList,),
'auth': [
'basicAuth',
'cookieAuth',
'jwtAuth',
'tokenAuth'
],
'endpoint_path': '/fetchs',
'operation_id': 'fetchs_list',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'limit',
'offset',
'ordering',
'status',
],
'required': [],
'nullable': [
],
'enum': [
'status',
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
('status',): {
"FETCHED": "fetched",
"PENDING": "pending",
"REJ_ERROR": "rej_error",
"REJ_FETCH": "rej_fetch"
},
},
'openapi_types': {
'limit':
(int,),
'offset':
(int,),
'ordering':
(str,),
'status':
(str,),
},
'attribute_map': {
'limit': 'limit',
'offset': 'offset',
'ordering': 'ordering',
'status': 'status',
},
'location_map': {
'limit': 'query',
'offset': 'query',
'ordering': 'query',
'status': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__fetchs_list
)
def __fetchs_partial_update(
self,
submission,
**kwargs
):
"""fetchs_partial_update # noqa: E501
SFetching results attached to a submission **Permission restrictions:** + `IsAuthenticated`: *Rejects all operations if the user is not authenticated* + `IsOwnerOrStaff`: *Blocks update/partial_updated/destroy if: * the user is NOT in the staff group * AND if the model has a property called 'owner' and its value differs from the request user Everything else is allowed* + `DjangoModelPermissions`: *The request is authenticated using `django.contrib.auth` permissions. See: https://docs.djangoproject.com/en/dev/topics/auth/#permissions It ensures that the user is authenticated, and has the appropriate `add`/`change`/`delete` permissions on the model. This permission can only be applied against view classes that provide a `.queryset` attribute.* # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.fetchs_partial_update(submission, async_req=True)
>>> result = thread.get()
Args:
submission (int): A unique value identifying this fetch.
Keyword Args:
patched_fetch (PatchedFetch): [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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
Fetch
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')
kwargs['submission'] = \
submission
return self.call_with_http_info(**kwargs)
self.fetchs_partial_update = _Endpoint(
settings={
'response_type': (Fetch,),
'auth': [
'basicAuth',
'cookieAuth',
'jwtAuth',
'tokenAuth'
],
'endpoint_path': '/fetchs/{submission}',
'operation_id': 'fetchs_partial_update',
'http_method': 'PATCH',
'servers': None,
},
params_map={
'all': [
'submission',
'patched_fetch',
],
'required': [
'submission',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'submission':
(int,),
'patched_fetch':
(PatchedFetch,),
},
'attribute_map': {
'submission': 'submission',
},
'location_map': {
'submission': 'path',
'patched_fetch': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json',
'application/x-www-form-urlencoded',
'multipart/form-data'
]
},
api_client=api_client,
callable=__fetchs_partial_update
)
def __fetchs_retrieve(
self,
submission,
**kwargs
):
"""fetchs_retrieve # noqa: E501
SFetching results attached to a submission **Permission restrictions:** + `IsAuthenticated`: *Rejects all operations if the user is not authenticated* + `IsOwnerOrStaff`: *Blocks update/partial_updated/destroy if: * the user is NOT in the staff group * AND if the model has a property called 'owner' and its value differs from the request user Everything else is allowed* + `DjangoModelPermissions`: *The request is authenticated using `django.contrib.auth` permissions. See: https://docs.djangoproject.com/en/dev/topics/auth/#permissions It ensures that the user is authenticated, and has the appropriate `add`/`change`/`delete` permissions on the model. This permission can only be applied against view classes that provide a `.queryset` attribute.* # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.fetchs_retrieve(submission, async_req=True)
>>> result = thread.get()
Args:
submission (int): A unique value identifying this fetch.
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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
Fetch
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')
kwargs['submission'] = \
submission
return self.call_with_http_info(**kwargs)
self.fetchs_retrieve = _Endpoint(
settings={
'response_type': (Fetch,),
'auth': [
'basicAuth',
'cookieAuth',
'jwtAuth',
'tokenAuth'
],
'endpoint_path': '/fetchs/{submission}',
'operation_id': 'fetchs_retrieve',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'submission',
],
'required': [
'submission',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'submission':
(int,),
},
'attribute_map': {
'submission': 'submission',
},
'location_map': {
'submission': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__fetchs_retrieve
)
def __fetchs_update(
self,
submission,
**kwargs
):
"""fetchs_update # noqa: E501
SFetching results attached to a submission **Permission restrictions:** + `IsAuthenticated`: *Rejects all operations if the user is not authenticated* + `IsOwnerOrStaff`: *Blocks update/partial_updated/destroy if: * the user is NOT in the staff group * AND if the model has a property called 'owner' and its value differs from the request user Everything else is allowed* + `DjangoModelPermissions`: *The request is authenticated using `django.contrib.auth` permissions. See: https://docs.djangoproject.com/en/dev/topics/auth/#permissions It ensures that the user is authenticated, and has the appropriate `add`/`change`/`delete` permissions on the model. This permission can only be applied against view classes that provide a `.queryset` attribute.* # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.fetchs_update(submission, async_req=True)
>>> result = thread.get()
Args:
submission (int): A unique value identifying this fetch.
Keyword Args:
fetch (Fetch): [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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
Fetch
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')
kwargs['submission'] = \
submission
return self.call_with_http_info(**kwargs)
self.fetchs_update = _Endpoint(
settings={
'response_type': (Fetch,),
'auth': [
'basicAuth',
'cookieAuth',
'jwtAuth',
'tokenAuth'
],
'endpoint_path': '/fetchs/{submission}',
'operation_id': 'fetchs_update',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'submission',
'fetch',
],
'required': [
'submission',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'submission':
(int,),
'fetch':
(Fetch,),
},
'attribute_map': {
'submission': 'submission',
},
'location_map': {
'submission': 'path',
'fetch': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json',
'application/x-www-form-urlencoded',
'multipart/form-data'
]
},
api_client=api_client,
callable=__fetchs_update
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __add_area(
self,
area,
**kwargs
):
"""Add new/modify Area resource # noqa: E501
Add a new Area resource or modify existing if unique name already exist # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_area(async_req=True)
>>> result = thread.get()
Keyword Args:
area (Area): Area resource to add/substitute. [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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
return self.call_with_http_info(**kwargs)
self.add_area = _Endpoint(
settings={
'response_type': None,
'auth': [],
'endpoint_path': '/areas',
'operation_id': 'add_area',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'area',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'area':
(Area,),
},
'attribute_map': {
},
'location_map': {
'area': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__add_area
)
def __delete_are_by_name(
self,
name,
**kwargs
):
"""Delete a Area resource by name. # noqa: E501
Delete a Area resource by name. # 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_are_by_name(name, async_req=True)
>>> result = thread.get()
Args:
name (str): resource unique name
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[Area]
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')
kwargs['name'] = \
name
return self.call_with_http_info(**kwargs)
self.delete_are_by_name = _Endpoint(
settings={
'response_type': ([Area],),
'auth': [],
'endpoint_path': '/areas/{name}',
'operation_id': 'delete_are_by_name',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'name':
(str,),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__delete_are_by_name
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __machines_list(
self,
**kwargs
):
"""machines_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.machines_list(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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[Machine]
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')
return self.call_with_http_info(**kwargs)
self.machines_list = _Endpoint(
settings={
'response_type': ([Machine],),
'auth': [
'Basic'
],
'endpoint_path': '/machines/',
'operation_id': 'machines_list',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
"owner"
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'owner':
(str,),
},
'attribute_map': {
"owner": "owner"
},
'location_map': {
"owner": "query"
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__machines_list
)
def __machines_read(
self,
id,
**kwargs
):
"""machines_read # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.machines_read(id, async_req=True)
>>> result = thread.get()
Args:
id (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
Machine
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')
kwargs['id'] = \
id
return self.call_with_http_info(**kwargs)
self.machines_read = _Endpoint(
settings={
'response_type': (Machine,),
'auth': [
'Basic'
],
'endpoint_path': '/machines/{id}/',
'operation_id': 'machines_read',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'id',
"owner",
],
'required': [
'id',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'id':
(str,),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
"owner": "query"
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__machines_read
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __workflow_template_service_create_workflow_template(
self,
namespace,
body,
**kwargs
):
"""workflow_template_service_create_workflow_template # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.workflow_template_service_create_workflow_template(namespace, body, async_req=True)
>>> result = thread.get()
Args:
namespace (str):
body (IoArgoprojWorkflowV1alpha1WorkflowTemplateCreateRequest):
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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
IoArgoprojWorkflowV1alpha1WorkflowTemplate
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')
kwargs['namespace'] = \
namespace
kwargs['body'] = \
body
return self.call_with_http_info(**kwargs)
self.workflow_template_service_create_workflow_template = _Endpoint(
settings={
'response_type': (IoArgoprojWorkflowV1alpha1WorkflowTemplate,),
'auth': [],
'endpoint_path': '/api/v1/workflow-templates/{namespace}',
'operation_id': 'workflow_template_service_create_workflow_template',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'namespace',
'body',
],
'required': [
'namespace',
'body',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'namespace':
(str,),
'body':
(IoArgoprojWorkflowV1alpha1WorkflowTemplateCreateRequest,),
},
'attribute_map': {
'namespace': 'namespace',
},
'location_map': {
'namespace': 'path',
'body': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__workflow_template_service_create_workflow_template
)
def __workflow_template_service_delete_workflow_template(
self,
namespace,
name,
**kwargs
):
"""workflow_template_service_delete_workflow_template # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.workflow_template_service_delete_workflow_template(namespace, name, async_req=True)
>>> result = thread.get()
Args:
namespace (str):
name (str):
Keyword Args:
delete_options_grace_period_seconds (str): The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. +optional.. [optional]
delete_options_preconditions_uid (str): Specifies the target UID. +optional.. [optional]
delete_options_preconditions_resource_version (str): Specifies the target ResourceVersion +optional.. [optional]
delete_options_orphan_dependents (bool): Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. +optional.. [optional]
delete_options_propagation_policy (str): Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. +optional.. [optional]
delete_options_dry_run ([str]): When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed +optional.. [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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
bool, date, datetime, dict, float, int, list, str, none_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')
kwargs['namespace'] = \
namespace
kwargs['name'] = \
name
return self.call_with_http_info(**kwargs)
self.workflow_template_service_delete_workflow_template = _Endpoint(
settings={
'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
'auth': [],
'endpoint_path': '/api/v1/workflow-templates/{namespace}/{name}',
'operation_id': 'workflow_template_service_delete_workflow_template',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'namespace',
'name',
'delete_options_grace_period_seconds',
'delete_options_preconditions_uid',
'delete_options_preconditions_resource_version',
'delete_options_orphan_dependents',
'delete_options_propagation_policy',
'delete_options_dry_run',
],
'required': [
'namespace',
'name',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'namespace':
(str,),
'name':
(str,),
'delete_options_grace_period_seconds':
(str,),
'delete_options_preconditions_uid':
(str,),
'delete_options_preconditions_resource_version':
(str,),
'delete_options_orphan_dependents':
(bool,),
'delete_options_propagation_policy':
(str,),
'delete_options_dry_run':
([str],),
},
'attribute_map': {
'namespace': 'namespace',
'name': 'name',
'delete_options_grace_period_seconds': 'deleteOptions.gracePeriodSeconds',
'delete_options_preconditions_uid': 'deleteOptions.preconditions.uid',
'delete_options_preconditions_resource_version': 'deleteOptions.preconditions.resourceVersion',
'delete_options_orphan_dependents': 'deleteOptions.orphanDependents',
'delete_options_propagation_policy': 'deleteOptions.propagationPolicy',
'delete_options_dry_run': 'deleteOptions.dryRun',
},
'location_map': {
'namespace': 'path',
'name': 'path',
'delete_options_grace_period_seconds': 'query',
'delete_options_preconditions_uid': 'query',
'delete_options_preconditions_resource_version': 'query',
'delete_options_orphan_dependents': 'query',
'delete_options_propagation_policy': 'query',
'delete_options_dry_run': 'query',
},
'collection_format_map': {
'delete_options_dry_run': 'multi',
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__workflow_template_service_delete_workflow_template
)
def __workflow_template_service_get_workflow_template(
self,
namespace,
name,
**kwargs
):
"""workflow_template_service_get_workflow_template # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.workflow_template_service_get_workflow_template(namespace, name, async_req=True)
>>> result = thread.get()
Args:
namespace (str):
name (str):
Keyword Args:
get_options_resource_version (str): resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. Defaults to unset +optional. [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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
IoArgoprojWorkflowV1alpha1WorkflowTemplate
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')
kwargs['namespace'] = \
namespace
kwargs['name'] = \
name
return self.call_with_http_info(**kwargs)
self.workflow_template_service_get_workflow_template = _Endpoint(
settings={
'response_type': (IoArgoprojWorkflowV1alpha1WorkflowTemplate,),
'auth': [],
'endpoint_path': '/api/v1/workflow-templates/{namespace}/{name}',
'operation_id': 'workflow_template_service_get_workflow_template',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'namespace',
'name',
'get_options_resource_version',
],
'required': [
'namespace',
'name',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'namespace':
(str,),
'name':
(str,),
'get_options_resource_version':
(str,),
},
'attribute_map': {
'namespace': 'namespace',
'name': 'name',
'get_options_resource_version': 'getOptions.resourceVersion',
},
'location_map': {
'namespace': 'path',
'name': 'path',
'get_options_resource_version': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__workflow_template_service_get_workflow_template
)
def __workflow_template_service_lint_workflow_template(
self,
namespace,
body,
**kwargs
):
"""workflow_template_service_lint_workflow_template # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.workflow_template_service_lint_workflow_template(namespace, body, async_req=True)
>>> result = thread.get()
Args:
namespace (str):
body (IoArgoprojWorkflowV1alpha1WorkflowTemplateLintRequest):
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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
IoArgoprojWorkflowV1alpha1WorkflowTemplate
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')
kwargs['namespace'] = \
namespace
kwargs['body'] = \
body
return self.call_with_http_info(**kwargs)
self.workflow_template_service_lint_workflow_template = _Endpoint(
settings={
'response_type': (IoArgoprojWorkflowV1alpha1WorkflowTemplate,),
'auth': [],
'endpoint_path': '/api/v1/workflow-templates/{namespace}/lint',
'operation_id': 'workflow_template_service_lint_workflow_template',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'namespace',
'body',
],
'required': [
'namespace',
'body',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'namespace':
(str,),
'body':
(IoArgoprojWorkflowV1alpha1WorkflowTemplateLintRequest,),
},
'attribute_map': {
'namespace': 'namespace',
},
'location_map': {
'namespace': 'path',
'body': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__workflow_template_service_lint_workflow_template
)
def __workflow_template_service_list_workflow_templates(
self,
namespace,
**kwargs
):
"""workflow_template_service_list_workflow_templates # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.workflow_template_service_list_workflow_templates(namespace, async_req=True)
>>> result = thread.get()
Args:
namespace (str):
Keyword Args:
list_options_label_selector (str): A selector to restrict the list of returned objects by their labels. Defaults to everything. +optional.. [optional]
list_options_field_selector (str): A selector to restrict the list of returned objects by their fields. Defaults to everything. +optional.. [optional]
list_options_watch (bool): Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. +optional.. [optional]
list_options_allow_watch_bookmarks (bool): allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored. +optional.. [optional]
list_options_resource_version (str): resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. Defaults to unset +optional. [optional]
list_options_resource_version_match (str): resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. Defaults to unset +optional. [optional]
list_options_timeout_seconds (str): Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. +optional.. [optional]
list_options_limit (str): limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.. [optional]
list_options_continue (str): The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.. [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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
IoArgoprojWorkflowV1alpha1WorkflowTemplateList
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')
kwargs['namespace'] = \
namespace
return self.call_with_http_info(**kwargs)
self.workflow_template_service_list_workflow_templates = _Endpoint(
settings={
'response_type': (IoArgoprojWorkflowV1alpha1WorkflowTemplateList,),
'auth': [],
'endpoint_path': '/api/v1/workflow-templates/{namespace}',
'operation_id': 'workflow_template_service_list_workflow_templates',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'namespace',
'list_options_label_selector',
'list_options_field_selector',
'list_options_watch',
'list_options_allow_watch_bookmarks',
'list_options_resource_version',
'list_options_resource_version_match',
'list_options_timeout_seconds',
'list_options_limit',
'list_options_continue',
],
'required': [
'namespace',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'namespace':
(str,),
'list_options_label_selector':
(str,),
'list_options_field_selector':
(str,),
'list_options_watch':
(bool,),
'list_options_allow_watch_bookmarks':
(bool,),
'list_options_resource_version':
(str,),
'list_options_resource_version_match':
(str,),
'list_options_timeout_seconds':
(str,),
'list_options_limit':
(str,),
'list_options_continue':
(str,),
},
'attribute_map': {
'namespace': 'namespace',
'list_options_label_selector': 'listOptions.labelSelector',
'list_options_field_selector': 'listOptions.fieldSelector',
'list_options_watch': 'listOptions.watch',
'list_options_allow_watch_bookmarks': 'listOptions.allowWatchBookmarks',
'list_options_resource_version': 'listOptions.resourceVersion',
'list_options_resource_version_match': 'listOptions.resourceVersionMatch',
'list_options_timeout_seconds': 'listOptions.timeoutSeconds',
'list_options_limit': 'listOptions.limit',
'list_options_continue': 'listOptions.continue',
},
'location_map': {
'namespace': 'path',
'list_options_label_selector': 'query',
'list_options_field_selector': 'query',
'list_options_watch': 'query',
'list_options_allow_watch_bookmarks': 'query',
'list_options_resource_version': 'query',
'list_options_resource_version_match': 'query',
'list_options_timeout_seconds': 'query',
'list_options_limit': 'query',
'list_options_continue': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__workflow_template_service_list_workflow_templates
)
def __workflow_template_service_update_workflow_template(
self,
namespace,
name,
body,
**kwargs
):
"""workflow_template_service_update_workflow_template # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.workflow_template_service_update_workflow_template(namespace, name, body, async_req=True)
>>> result = thread.get()
Args:
namespace (str):
name (str): DEPRECATED: This field is ignored.
body (IoArgoprojWorkflowV1alpha1WorkflowTemplateUpdateRequest):
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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
IoArgoprojWorkflowV1alpha1WorkflowTemplate
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')
kwargs['namespace'] = \
namespace
kwargs['name'] = \
name
kwargs['body'] = \
body
return self.call_with_http_info(**kwargs)
self.workflow_template_service_update_workflow_template = _Endpoint(
settings={
'response_type': (IoArgoprojWorkflowV1alpha1WorkflowTemplate,),
'auth': [],
'endpoint_path': '/api/v1/workflow-templates/{namespace}/{name}',
'operation_id': 'workflow_template_service_update_workflow_template',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'namespace',
'name',
'body',
],
'required': [
'namespace',
'name',
'body',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'namespace':
(str,),
'name':
(str,),
'body':
(IoArgoprojWorkflowV1alpha1WorkflowTemplateUpdateRequest,),
},
'attribute_map': {
'namespace': 'namespace',
'name': 'name',
},
'location_map': {
'namespace': 'path',
'name': 'path',
'body': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__workflow_template_service_update_workflow_template
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __getjuridische_regel_voor_iedereen(
self,
identificatie,
**kwargs
):
"""getjuridische_regel_voor_iedereen # noqa: E501
<body><p>Het bericht dat de JSON/REST API voor het ophalen van gegevens van een amendement retourneert. I.h.k.v. deze API zijn alleen juridische regels die minimaal één activiteit bevatten van belang.</p></body> # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.getjuridische_regel_voor_iedereen(identificatie, async_req=True)
>>> result = thread.get()
Args:
identificatie (Identificatie): <body><p>De unieke identificatie van de juridischeRegelVoorIedereen.</p></body><body><p>De verzameling van waarden die gegevens van dit attribuutsoort kunnen hebben, dat wil zeggen het waardenbereik, uitgedrukt in een specifieke structuur.</p></body>
Keyword Args:
accept_crs (CrsEnum): Gewenste CRS van de coördinaten in de response.. [optional]
expand (str): Hiermee kun je opgeven welke gerelateerde resources meegeleverd moeten worden, en hun inhoud naar behoefte aanpassen. Hele resources of enkele properties geef je in de expand parameter kommagescheiden op. Properties die je wil ontvangen geef je op met de resource-naam gevolgd door de property naam, met daartussen een punt. In de definitie van het antwoord kun je bij _embedded zien welke gerelateerde resources meegeleverd kunnen worden. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.2.0/features/expand.feature).. [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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
JuridischeRegelVoorIedereenHal
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')
kwargs['identificatie'] = \
identificatie
return self.call_with_http_info(**kwargs)
self.getjuridische_regel_voor_iedereen = _Endpoint(
settings={
'response_type': (JuridischeRegelVoorIedereenHal,),
'auth': [],
'endpoint_path': '/juridischeregelsvooriedereen/{identificatie}',
'operation_id': 'getjuridische_regel_voor_iedereen',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'identificatie',
'accept_crs',
'expand',
],
'required': [
'identificatie',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'identificatie':
(Identificatie,),
'accept_crs':
(CrsEnum,),
'expand':
(str,),
},
'attribute_map': {
'identificatie': 'identificatie',
'accept_crs': 'Accept-Crs',
'expand': 'expand',
},
'location_map': {
'identificatie': 'path',
'accept_crs': 'header',
'expand': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/hal+json',
'application/problem+json'
],
'content_type': [],
},
api_client=api_client,
callable=__getjuridische_regel_voor_iedereen
)
def __getjuridische_regels_voor_iedereen(
self,
**kwargs
):
"""getjuridische_regels_voor_iedereen # noqa: E501
<body><p>Het bericht dat de JSON/REST API voor het ophalen van een collectie amendementen retourneert. I.h.k.v. deze API zijn alleen juridische regels die minimaal één activiteit bevatten van belang.</p></body> # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.getjuridische_regels_voor_iedereen(async_req=True)
>>> result = thread.get()
Keyword Args:
accept_crs (CrsEnum): Gewenste CRS van de coördinaten in de response.. [optional]
page (int): Een pagina binnen de gepagineerde resultatenset.. [optional]
expand (str): Hiermee kun je opgeven welke gerelateerde resources meegeleverd moeten worden, en hun inhoud naar behoefte aanpassen. Hele resources of enkele properties geef je in de expand parameter kommagescheiden op. Properties die je wil ontvangen geef je op met de resource-naam gevolgd door de property naam, met daartussen een punt. In de definitie van het antwoord kun je bij _embedded zien welke gerelateerde resources meegeleverd kunnen worden. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.2.0/features/expand.feature).. [optional]
page_size (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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
JuridischeRegelVoorIedereenHalCollectie
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')
return self.call_with_http_info(**kwargs)
self.getjuridische_regels_voor_iedereen = _Endpoint(
settings={
'response_type': (JuridischeRegelVoorIedereenHalCollectie,),
'auth': [],
'endpoint_path': '/juridischeregelsvooriedereen',
'operation_id': 'getjuridische_regels_voor_iedereen',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'accept_crs',
'page',
'expand',
'page_size',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
'page',
'page_size',
]
},
root_map={
'validations': {
('page',): {
'inclusive_minimum': 1,
},
('page_size',): {
'inclusive_maximum': 100,
'inclusive_minimum': 1,
},
},
'allowed_values': {
},
'openapi_types': {
'accept_crs':
(CrsEnum,),
'page':
(int,),
'expand':
(str,),
'page_size':
(int,),
},
'attribute_map': {
'accept_crs': 'Accept-Crs',
'page': 'page',
'expand': 'expand',
'page_size': 'pageSize',
},
'location_map': {
'accept_crs': 'header',
'page': 'query',
'expand': 'query',
'page_size': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/hal+json',
'application/problem+json'
],
'content_type': [],
},
api_client=api_client,
callable=__getjuridische_regels_voor_iedereen
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.v1_orders_cancel_all_post_endpoint = _Endpoint(
settings={
'response_type': (MessageReject, ),
'auth': [],
'endpoint_path': '/v1/orders/cancel/all',
'operation_id': 'v1_orders_cancel_all_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'order_cancel_all_request',
],
'required': [
'order_cancel_all_request',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'order_cancel_all_request': (OrderCancelAllRequest, ),
},
'attribute_map': {},
'location_map': {
'order_cancel_all_request': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json', 'appliction/json'],
'content_type': ['application/json']
},
api_client=api_client)
self.v1_orders_cancel_post_endpoint = _Endpoint(
settings={
'response_type': (OrderExecutionReport, ),
'auth': [],
'endpoint_path': '/v1/orders/cancel',
'operation_id': 'v1_orders_cancel_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'order_cancel_single_request',
],
'required': [
'order_cancel_single_request',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'order_cancel_single_request':
(OrderCancelSingleRequest, ),
},
'attribute_map': {},
'location_map': {
'order_cancel_single_request': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json', 'appliction/json'],
'content_type': ['application/json']
},
api_client=api_client)
self.v1_orders_get_endpoint = _Endpoint(
settings={
'response_type': (OrderExecutionReports, ),
'auth': [],
'endpoint_path': '/v1/orders',
'operation_id': 'v1_orders_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'exchange_id',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'exchange_id': (str, ),
},
'attribute_map': {
'exchange_id': 'exchange_id',
},
'location_map': {
'exchange_id': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json', 'appliction/json'],
'content_type': [],
},
api_client=api_client)
self.v1_orders_post_endpoint = _Endpoint(
settings={
'response_type': (OrderExecutionReport, ),
'auth': [],
'endpoint_path': '/v1/orders',
'operation_id': 'v1_orders_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'order_new_single_request',
],
'required': [
'order_new_single_request',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'order_new_single_request': (OrderNewSingleRequest, ),
},
'attribute_map': {},
'location_map': {
'order_new_single_request': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json', 'appliction/json'],
'content_type': ['application/json']
},
api_client=api_client)
self.v1_orders_status_client_order_id_get_endpoint = _Endpoint(
settings={
'response_type': (OrderExecutionReport, ),
'auth': [],
'endpoint_path': '/v1/orders/status/{client_order_id}',
'operation_id': 'v1_orders_status_client_order_id_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'client_order_id',
],
'required': [
'client_order_id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'client_order_id': (str, ),
},
'attribute_map': {
'client_order_id': 'client_order_id',
},
'location_map': {
'client_order_id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __find_published_stock_analyses(self, **kwargs):
"""find_published_stock_analyses # 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_published_stock_analyses(async_req=True)
>>> result = thread.get()
Keyword Args:
user_id (str): [optional]
cik (str): [optional]
ticker (str): [optional]
skip (int): [optional]
limit (int): [optional]
term (str): [optional]
tags ([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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
FindStockAnalysisResponse
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')
return self.call_with_http_info(**kwargs)
self.find_published_stock_analyses = _Endpoint(
settings={
'response_type': (FindStockAnalysisResponse, ),
'auth': [],
'endpoint_path': '/public/published-stock-analyses',
'operation_id': 'find_published_stock_analyses',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'user_id',
'cik',
'ticker',
'skip',
'limit',
'term',
'tags',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'user_id': (str, ),
'cik': (str, ),
'ticker': (str, ),
'skip': (int, ),
'limit': (int, ),
'term': (str, ),
'tags': ([str], ),
},
'attribute_map': {
'user_id': 'userId',
'cik': 'cik',
'ticker': 'ticker',
'skip': 'skip',
'limit': 'limit',
'term': 'term',
'tags': 'tags',
},
'location_map': {
'user_id': 'query',
'cik': 'query',
'ticker': 'query',
'skip': 'query',
'limit': 'query',
'term': 'query',
'tags': 'query',
},
'collection_format_map': {
'tags': 'multi',
}
},
headers_map={
'accept': ['*/*'],
'content_type': [],
},
api_client=api_client,
callable=__find_published_stock_analyses)
def __get_published_stock_analysis(self, id, **kwargs):
"""get_published_stock_analysis # 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_published_stock_analysis(id, async_req=True)
>>> result = thread.get()
Args:
id (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
StockAnalysis2
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')
kwargs['id'] = \
id
return self.call_with_http_info(**kwargs)
self.get_published_stock_analysis = _Endpoint(
settings={
'response_type': (StockAnalysis2, ),
'auth': [],
'endpoint_path': '/public/published-stock-analyses/{id}',
'operation_id': 'get_published_stock_analysis',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': [],
},
api_client=api_client,
callable=__get_published_stock_analysis)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __raadpleeg_pand(
self,
pandidentificatie,
**kwargs
):
"""levert een pand # noqa: E501
Raadpleeg een actueel pand met de identificatie. Een pand is een bouwkundige, constructief zelfstandige eenheid die direct en duurzaam met de aarde is verbonden en betreedbaar en afsluitbaar is. Gebruik de fields-parameter als je alleen specifieke velden in het antwoord wil zien, zie [functionele specificaties fields-parameter](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.1.0/features/fields.feature). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.raadpleeg_pand(pandidentificatie, async_req=True)
>>> result = thread.get()
Args:
pandidentificatie (str): Identificatie van een pand uit de BAG. Deze is 16 cijfers lang.
Keyword Args:
fields (str): Hiermee kun je de inhoud van de resource naar behoefte aanpassen door een door komma's gescheiden lijst van property namen op te geven. Bij opgave van niet-bestaande properties wordt een 400 Bad Request teruggegeven. Wanneer de fields parameter niet is opgegeven, worden alle properties met een waarde teruggegeven. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.1.0/features/fields.feature). [optional]
accept_crs (str): Gewenste CRS van de coördinaten in de response.. [optional] if omitted the server will use the default value of "epsg:28992"
_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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
PandHalBasis
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')
kwargs['pandidentificatie'] = \
pandidentificatie
return self.call_with_http_info(**kwargs)
self.raadpleeg_pand = _Endpoint(
settings={
'response_type': (PandHalBasis,),
'auth': [
'apiKeyBAG'
],
'endpoint_path': '/panden/{pandidentificatie}',
'operation_id': 'raadpleeg_pand',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'pandidentificatie',
'fields',
'accept_crs',
],
'required': [
'pandidentificatie',
],
'nullable': [
],
'enum': [
'accept_crs',
],
'validation': [
'pandidentificatie',
]
},
root_map={
'validations': {
('pandidentificatie',): {
'regex': {
'pattern': r'^[0-9]{16}$', # noqa: E501
},
},
},
'allowed_values': {
('accept_crs',): {
"EPSG:28992": "epsg:28992"
},
},
'openapi_types': {
'pandidentificatie':
(str,),
'fields':
(str,),
'accept_crs':
(str,),
},
'attribute_map': {
'pandidentificatie': 'pandidentificatie',
'fields': 'fields',
'accept_crs': 'Accept-Crs',
},
'location_map': {
'pandidentificatie': 'path',
'fields': 'query',
'accept_crs': 'header',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/hal+json',
'application/problem+json'
],
'content_type': [],
},
api_client=api_client,
callable=__raadpleeg_pand
)
def __raadpleeg_panden(
self,
**kwargs
):
"""vindt panden # noqa: E501
Zoek actuele panden met de identificatie van een adresseerbaar object, nummeraanduiding of een locatie. Gebruik de fields-parameter als je alleen specifieke velden in het antwoord wil zien, zie [functionele specificaties fields-parameter](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.1.0/features/fields.feature). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.raadpleeg_panden(async_req=True)
>>> result = thread.get()
Keyword Args:
adresseerbaar_object_identificatie (str): De identificatie van een adresseerbaar object uit de BAG. Deze is 16 cijfers lang en kan een verblijfsobject, een standplaats of een ligplaats zijn.. [optional]
nummeraanduiding_identificatie (str): Identificatie van een nummeraanduiding uit de BAG. Deze is 16 cijfers lang.. [optional]
locatie ([float]): Coordinaten van een locatie die als query-parameter gebruikt wordt om een object te zoeken. Let op, explode is false dus het formaat is ?locatie=194602.722,464154.308. [optional]
fields (str): Hiermee kun je de inhoud van de resource naar behoefte aanpassen door een door komma's gescheiden lijst van property namen op te geven. Bij opgave van niet-bestaande properties wordt een 400 Bad Request teruggegeven. Wanneer de fields parameter niet is opgegeven, worden alle properties met een waarde teruggegeven. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.1.0/features/fields.feature). [optional]
accept_crs (str): Gewenste CRS van de coördinaten in de response.. [optional] if omitted the server will use the default value of "epsg:28992"
content_crs (str): CRS van de meegegeven geometrie. epsg:28992 mapt op het RD New Nederlands coordinatenstelsel.. [optional] if omitted the server will use the default value of "epsg:28992"
_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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
PandHalCollectie
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')
return self.call_with_http_info(**kwargs)
self.raadpleeg_panden = _Endpoint(
settings={
'response_type': (PandHalCollectie,),
'auth': [
'apiKeyBAG'
],
'endpoint_path': '/panden',
'operation_id': 'raadpleeg_panden',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'adresseerbaar_object_identificatie',
'nummeraanduiding_identificatie',
'locatie',
'fields',
'accept_crs',
'content_crs',
],
'required': [],
'nullable': [
],
'enum': [
'accept_crs',
'content_crs',
],
'validation': [
'adresseerbaar_object_identificatie',
'nummeraanduiding_identificatie',
'locatie',
]
},
root_map={
'validations': {
('adresseerbaar_object_identificatie',): {
'regex': {
'pattern': r'^[0-9]{16}$', # noqa: E501
},
},
('nummeraanduiding_identificatie',): {
'regex': {
'pattern': r'^[0-9]{16}$', # noqa: E501
},
},
('locatie',): {
'max_items': 2,
'min_items': 2,
},
},
'allowed_values': {
('accept_crs',): {
"EPSG:28992": "epsg:28992"
},
('content_crs',): {
"EPSG:28992": "epsg:28992"
},
},
'openapi_types': {
'adresseerbaar_object_identificatie':
(str,),
'nummeraanduiding_identificatie':
(str,),
'locatie':
([float],),
'fields':
(str,),
'accept_crs':
(str,),
'content_crs':
(str,),
},
'attribute_map': {
'adresseerbaar_object_identificatie': 'adresseerbaarObjectIdentificatie',
'nummeraanduiding_identificatie': 'nummeraanduidingIdentificatie',
'locatie': 'locatie',
'fields': 'fields',
'accept_crs': 'Accept-Crs',
'content_crs': 'Content-Crs',
},
'location_map': {
'adresseerbaar_object_identificatie': 'query',
'nummeraanduiding_identificatie': 'query',
'locatie': 'query',
'fields': 'query',
'accept_crs': 'header',
'content_crs': 'header',
},
'collection_format_map': {
'locatie': 'csv',
}
},
headers_map={
'accept': [
'application/hal+json',
'application/problem+json'
],
'content_type': [],
},
api_client=api_client,
callable=__raadpleeg_panden
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __getregeltekst(self, identificatie, **kwargs):
"""getregeltekst # noqa: E501
<body><p>Het bericht dat de JSON/REST API voor het ophalen van gegevens van een amendement retourneert.</p></body> # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.getregeltekst(identificatie, async_req=True)
>>> result = thread.get()
Args:
identificatie (str): <body><p>De unieke identificatie waaronder elk object van dit type bekend is.</p></body>
Keyword Args:
accept_crs (CrsEnum): Gewenste CRS van de coördinaten in de response.. [optional]
expand (str): Hiermee kun je opgeven welke gerelateerde resources meegeleverd moeten worden, en hun inhoud naar behoefte aanpassen. Hele resources of enkele properties geef je in de expand parameter kommagescheiden op. Properties die je wil ontvangen geef je op met de resource-naam gevolgd door de property naam, met daartussen een punt. In de definitie van het antwoord kun je bij _embedded zien welke gerelateerde resources meegeleverd kunnen worden. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.2.0/features/expand.feature).. [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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
RegeltekstHal
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')
kwargs['identificatie'] = \
identificatie
return self.call_with_http_info(**kwargs)
self.getregeltekst = _Endpoint(
settings={
'response_type': (RegeltekstHal, ),
'auth': [],
'endpoint_path': '/regelteksten/{identificatie}',
'operation_id': 'getregeltekst',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'identificatie',
'accept_crs',
'expand',
],
'required': [
'identificatie',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'identificatie': (str, ),
'accept_crs': (CrsEnum, ),
'expand': (str, ),
},
'attribute_map': {
'identificatie': 'identificatie',
'accept_crs': 'Accept-Crs',
'expand': 'expand',
},
'location_map': {
'identificatie': 'path',
'accept_crs': 'header',
'expand': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/hal+json', 'application/problem+json'],
'content_type': [],
},
api_client=api_client,
callable=__getregeltekst)
def __getregelteksten(self, **kwargs):
"""getregelteksten # noqa: E501
<body><p>Het bericht dat de JSON/REST API voor het ophalen van een collectie amendementen retourneert.</p></body> # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.getregelteksten(async_req=True)
>>> result = thread.get()
Keyword Args:
accept_crs (CrsEnum): Gewenste CRS van de coördinaten in de response.. [optional]
page (int): Een pagina binnen de gepagineerde resultatenset.. [optional]
expand (str): Hiermee kun je opgeven welke gerelateerde resources meegeleverd moeten worden, en hun inhoud naar behoefte aanpassen. Hele resources of enkele properties geef je in de expand parameter kommagescheiden op. Properties die je wil ontvangen geef je op met de resource-naam gevolgd door de property naam, met daartussen een punt. In de definitie van het antwoord kun je bij _embedded zien welke gerelateerde resources meegeleverd kunnen worden. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.2.0/features/expand.feature).. [optional]
inclusiefvervallen (bool): <body><p>Als de parameter 'vanafdatum' een waarde heeft dan moet een evt. waarde van dit attribute worden genegeerd.</p></body>. [optional]
omgevingsdocumentidentificatie (str): <body><p>Een inhoudelijke toelichting op de toepassing van het informatie-element.</p></body>. [optional]
page_size (int): [optional] if omitted the server will use the default value of 20
werkpakketcode (str): <body><p>Een unieke aanduiding van de verzameling samenhangende activiteiten gericht op het publiceren van een nieuwe versie van een omgevingsdocument.</p></body><body><p>Er kunnen tegelijkertijd meerdere trajecten gaande zijn waarin bijvoorbeeld een omgevingsplan gewijzigd wordt, die elk leiden tot een apart te publiceren nieuwe versie van het omgevingsplan. De werkpakketcode biedt de mogelijkheid om de regelteksten te markeren die betrokken zijn in zo'n traject. Daarvan kan gebruik gemaakt worden om alleen de regels met bijhorende annotaties op te vragen voor een specifiek werkpakket. </p></body>. [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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
RegeltekstHalCollectie
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')
return self.call_with_http_info(**kwargs)
self.getregelteksten = _Endpoint(
settings={
'response_type': (RegeltekstHalCollectie, ),
'auth': [],
'endpoint_path': '/regelteksten',
'operation_id': 'getregelteksten',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'accept_crs',
'page',
'expand',
'inclusiefvervallen',
'omgevingsdocumentidentificatie',
'page_size',
'werkpakketcode',
],
'required': [],
'nullable': [],
'enum': [],
'validation': [
'page',
'page_size',
]
},
root_map={
'validations': {
('page', ): {
'inclusive_minimum': 1,
},
('page_size', ): {
'inclusive_maximum': 100,
'inclusive_minimum': 1,
},
},
'allowed_values': {},
'openapi_types': {
'accept_crs': (CrsEnum, ),
'page': (int, ),
'expand': (str, ),
'inclusiefvervallen': (bool, ),
'omgevingsdocumentidentificatie': (str, ),
'page_size': (int, ),
'werkpakketcode': (str, ),
},
'attribute_map': {
'accept_crs': 'Accept-Crs',
'page': 'page',
'expand': 'expand',
'inclusiefvervallen': 'inclusiefvervallen',
'omgevingsdocumentidentificatie':
'omgevingsdocumentidentificatie',
'page_size': 'pageSize',
'werkpakketcode': 'werkpakketcode',
},
'location_map': {
'accept_crs': 'header',
'page': 'query',
'expand': 'query',
'inclusiefvervallen': 'query',
'omgevingsdocumentidentificatie': 'query',
'page_size': 'query',
'werkpakketcode': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/hal+json', 'application/problem+json'],
'content_type': [],
},
api_client=api_client,
callable=__getregelteksten)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __delete_tag(self, id, **kwargs):
"""delete_tag # 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_tag(id, async_req=True)
>>> result = thread.get()
Args:
id (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['id'] = \
id
return self.call_with_http_info(**kwargs)
self.delete_tag = _Endpoint(settings={
'response_type': None,
'auth': [],
'endpoint_path': '/api/tags/{id}',
'operation_id': 'delete_tag',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__delete_tag)
def __find_tag(self, term, **kwargs):
"""find_tag # 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_tag(term, async_req=True)
>>> result = thread.get()
Args:
term (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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[Tag]
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')
kwargs['term'] = \
term
return self.call_with_http_info(**kwargs)
self.find_tag = _Endpoint(settings={
'response_type': ([Tag], ),
'auth': [],
'endpoint_path': '/api/tags',
'operation_id': 'find_tag',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'term',
],
'required': [
'term',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'term': (str, ),
},
'attribute_map': {
'term': 'term',
},
'location_map': {
'term': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': [],
},
api_client=api_client,
callable=__find_tag)
def __save_tag(self, tag, **kwargs):
"""save_tag # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.save_tag(tag, async_req=True)
>>> result = thread.get()
Args:
tag (Tag):
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['tag'] = \
tag
return self.call_with_http_info(**kwargs)
self.save_tag = _Endpoint(settings={
'response_type': None,
'auth': [],
'endpoint_path': '/api/tags',
'operation_id': 'save_tag',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'tag',
],
'required': [
'tag',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'tag': (Tag, ),
},
'attribute_map': {},
'location_map': {
'tag': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': ['application/json']
},
api_client=api_client,
callable=__save_tag)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __artifact_service_get_input_artifact(self, namespace, name,
pod_name, artifact_name,
**kwargs):
"""Get an input artifact. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.artifact_service_get_input_artifact(namespace, name, pod_name, artifact_name, async_req=True)
>>> result = thread.get()
Args:
namespace (str):
name (str):
pod_name (str):
artifact_name (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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['namespace'] = \
namespace
kwargs['name'] = \
name
kwargs['pod_name'] = \
pod_name
kwargs['artifact_name'] = \
artifact_name
return self.call_with_http_info(**kwargs)
self.artifact_service_get_input_artifact = _Endpoint(
settings={
'response_type': None,
'auth': [],
'endpoint_path':
'/input-artifacts/{namespace}/{name}/{podName}/{artifactName}',
'operation_id': 'artifact_service_get_input_artifact',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'namespace',
'name',
'pod_name',
'artifact_name',
],
'required': [
'namespace',
'name',
'pod_name',
'artifact_name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'namespace': (str, ),
'name': (str, ),
'pod_name': (str, ),
'artifact_name': (str, ),
},
'attribute_map': {
'namespace': 'namespace',
'name': 'name',
'pod_name': 'podName',
'artifact_name': 'artifactName',
},
'location_map': {
'namespace': 'path',
'name': 'path',
'pod_name': 'path',
'artifact_name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__artifact_service_get_input_artifact)
def __artifact_service_get_input_artifact_by_uid(
self, namespace, uid, pod_name, artifact_name, **kwargs):
"""Get an input artifact by UID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.artifact_service_get_input_artifact_by_uid(namespace, uid, pod_name, artifact_name, async_req=True)
>>> result = thread.get()
Args:
namespace (str):
uid (str):
pod_name (str):
artifact_name (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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['namespace'] = \
namespace
kwargs['uid'] = \
uid
kwargs['pod_name'] = \
pod_name
kwargs['artifact_name'] = \
artifact_name
return self.call_with_http_info(**kwargs)
self.artifact_service_get_input_artifact_by_uid = _Endpoint(
settings={
'response_type': None,
'auth': [],
'endpoint_path':
'/input-artifacts-by-uid/{uid}/{podName}/{artifactName}',
'operation_id': 'artifact_service_get_input_artifact_by_uid',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'namespace',
'uid',
'pod_name',
'artifact_name',
],
'required': [
'namespace',
'uid',
'pod_name',
'artifact_name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'namespace': (str, ),
'uid': (str, ),
'pod_name': (str, ),
'artifact_name': (str, ),
},
'attribute_map': {
'namespace': 'namespace',
'uid': 'uid',
'pod_name': 'podName',
'artifact_name': 'artifactName',
},
'location_map': {
'namespace': 'path',
'uid': 'path',
'pod_name': 'path',
'artifact_name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__artifact_service_get_input_artifact_by_uid)
def __artifact_service_get_output_artifact(self, namespace, name,
pod_name, artifact_name,
**kwargs):
"""Get an output artifact. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.artifact_service_get_output_artifact(namespace, name, pod_name, artifact_name, async_req=True)
>>> result = thread.get()
Args:
namespace (str):
name (str):
pod_name (str):
artifact_name (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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['namespace'] = \
namespace
kwargs['name'] = \
name
kwargs['pod_name'] = \
pod_name
kwargs['artifact_name'] = \
artifact_name
return self.call_with_http_info(**kwargs)
self.artifact_service_get_output_artifact = _Endpoint(
settings={
'response_type': None,
'auth': [],
'endpoint_path':
'/artifacts/{namespace}/{name}/{podName}/{artifactName}',
'operation_id': 'artifact_service_get_output_artifact',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'namespace',
'name',
'pod_name',
'artifact_name',
],
'required': [
'namespace',
'name',
'pod_name',
'artifact_name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'namespace': (str, ),
'name': (str, ),
'pod_name': (str, ),
'artifact_name': (str, ),
},
'attribute_map': {
'namespace': 'namespace',
'name': 'name',
'pod_name': 'podName',
'artifact_name': 'artifactName',
},
'location_map': {
'namespace': 'path',
'name': 'path',
'pod_name': 'path',
'artifact_name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__artifact_service_get_output_artifact)
def __artifact_service_get_output_artifact_by_uid(
self, uid, pod_name, artifact_name, **kwargs):
"""Get an output artifact by UID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.artifact_service_get_output_artifact_by_uid(uid, pod_name, artifact_name, async_req=True)
>>> result = thread.get()
Args:
uid (str):
pod_name (str):
artifact_name (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 (int/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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
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')
kwargs['uid'] = \
uid
kwargs['pod_name'] = \
pod_name
kwargs['artifact_name'] = \
artifact_name
return self.call_with_http_info(**kwargs)
self.artifact_service_get_output_artifact_by_uid = _Endpoint(
settings={
'response_type': None,
'auth': [],
'endpoint_path':
'/artifacts-by-uid/{uid}/{podName}/{artifactName}',
'operation_id': 'artifact_service_get_output_artifact_by_uid',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'uid',
'pod_name',
'artifact_name',
],
'required': [
'uid',
'pod_name',
'artifact_name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'uid': (str, ),
'pod_name': (str, ),
'artifact_name': (str, ),
},
'attribute_map': {
'uid': 'uid',
'pod_name': 'podName',
'artifact_name': 'artifactName',
},
'location_map': {
'uid': 'path',
'pod_name': 'path',
'artifact_name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__artifact_service_get_output_artifact_by_uid)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __getactiviteit(
self,
identificatie,
**kwargs
):
"""getactiviteit # noqa: E501
<body><p>Het bericht dat de JSON/REST API voor het ophalen van gegevens van een amendement retourneert.</p></body> # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.getactiviteit(identificatie, async_req=True)
>>> result = thread.get()
Args:
identificatie (str): <body><p>De unieke identificatie waaronder elk object van dit type bekend is.</p></body>
Keyword Args:
expand (str): Hiermee kun je opgeven welke gerelateerde resources meegeleverd moeten worden, en hun inhoud naar behoefte aanpassen. Hele resources of enkele properties geef je in de expand parameter kommagescheiden op. Properties die je wil ontvangen geef je op met de resource-naam gevolgd door de property naam, met daartussen een punt. In de definitie van het antwoord kun je bij _embedded zien welke gerelateerde resources meegeleverd kunnen worden. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.2.0/features/expand.feature).. [optional]
inclusiefvervallen (bool): <body><p>Als de parameter 'vanafdatum' een waarde heeft dan moet een evt. waarde van dit attribute worden genegeerd.</p></body>. [optional]
vanafdatum (date): [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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
ActiviteitHal
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')
kwargs['identificatie'] = \
identificatie
return self.call_with_http_info(**kwargs)
self.getactiviteit = _Endpoint(
settings={
'response_type': (ActiviteitHal,),
'auth': [],
'endpoint_path': '/activiteiten/{identificatie}',
'operation_id': 'getactiviteit',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'identificatie',
'expand',
'inclusiefvervallen',
'vanafdatum',
],
'required': [
'identificatie',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'identificatie':
(str,),
'expand':
(str,),
'inclusiefvervallen':
(bool,),
'vanafdatum':
(date,),
},
'attribute_map': {
'identificatie': 'identificatie',
'expand': 'expand',
'inclusiefvervallen': 'inclusiefvervallen',
'vanafdatum': 'vanafdatum',
},
'location_map': {
'identificatie': 'path',
'expand': 'query',
'inclusiefvervallen': 'query',
'vanafdatum': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/hal+json',
'application/problem+json'
],
'content_type': [],
},
api_client=api_client,
callable=__getactiviteit
)
def __getactiviteiten(
self,
**kwargs
):
"""getactiviteiten # noqa: E501
<body><p>Het bericht dat de JSON/REST API voor het ophalen van een collectie amendementen retourneert.</p></body> # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.getactiviteiten(async_req=True)
>>> result = thread.get()
Keyword Args:
page (int): Een pagina binnen de gepagineerde resultatenset.. [optional]
expand (str): Hiermee kun je opgeven welke gerelateerde resources meegeleverd moeten worden, en hun inhoud naar behoefte aanpassen. Hele resources of enkele properties geef je in de expand parameter kommagescheiden op. Properties die je wil ontvangen geef je op met de resource-naam gevolgd door de property naam, met daartussen een punt. In de definitie van het antwoord kun je bij _embedded zien welke gerelateerde resources meegeleverd kunnen worden. Zie [functionele specificaties](https://github.com/VNG-Realisatie/Haal-Centraal-common/blob/v1.2.0/features/expand.feature).. [optional]
begindatum (date): [optional]
bovenliggendeactiviteitidentificatie (str): [optional]
einddatum (date): [optional]
gerelateerdeactiviteitidentificaties (str): [optional]
inclusiefvervallen (bool): <body><p>Als de parameter 'vanafdatum' een waarde heeft dan moet een evt. waarde van dit attribute worden genegeerd.</p></body>. [optional]
juridischeregelvooriedereenidentificaties (str): [optional]
laatstewijzigingsdatum (date): [optional]
naam (str): <body><p>Een (korte) omschrijving van de activiteit.</p></body>. [optional]
vanafdatum (date): [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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
ActiviteitHalCollectie
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')
return self.call_with_http_info(**kwargs)
self.getactiviteiten = _Endpoint(
settings={
'response_type': (ActiviteitHalCollectie,),
'auth': [],
'endpoint_path': '/activiteiten',
'operation_id': 'getactiviteiten',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'page',
'expand',
'begindatum',
'bovenliggendeactiviteitidentificatie',
'einddatum',
'gerelateerdeactiviteitidentificaties',
'inclusiefvervallen',
'juridischeregelvooriedereenidentificaties',
'laatstewijzigingsdatum',
'naam',
'vanafdatum',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
'page',
]
},
root_map={
'validations': {
('page',): {
'inclusive_minimum': 1,
},
},
'allowed_values': {
},
'openapi_types': {
'page':
(int,),
'expand':
(str,),
'begindatum':
(date,),
'bovenliggendeactiviteitidentificatie':
(str,),
'einddatum':
(date,),
'gerelateerdeactiviteitidentificaties':
(str,),
'inclusiefvervallen':
(bool,),
'juridischeregelvooriedereenidentificaties':
(str,),
'laatstewijzigingsdatum':
(date,),
'naam':
(str,),
'vanafdatum':
(date,),
},
'attribute_map': {
'page': 'page',
'expand': 'expand',
'begindatum': 'begindatum',
'bovenliggendeactiviteitidentificatie': 'bovenliggendeactiviteitidentificatie',
'einddatum': 'einddatum',
'gerelateerdeactiviteitidentificaties': 'gerelateerdeactiviteitidentificaties',
'inclusiefvervallen': 'inclusiefvervallen',
'juridischeregelvooriedereenidentificaties': 'juridischeregelvooriedereenidentificaties',
'laatstewijzigingsdatum': 'laatstewijzigingsdatum',
'naam': 'naam',
'vanafdatum': 'vanafdatum',
},
'location_map': {
'page': 'query',
'expand': 'query',
'begindatum': 'query',
'bovenliggendeactiviteitidentificatie': 'query',
'einddatum': 'query',
'gerelateerdeactiviteitidentificaties': 'query',
'inclusiefvervallen': 'query',
'juridischeregelvooriedereenidentificaties': 'query',
'laatstewijzigingsdatum': 'query',
'naam': 'query',
'vanafdatum': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/hal+json',
'application/problem+json'
],
'content_type': [],
},
api_client=api_client,
callable=__getactiviteiten
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_area_by_date(self, date, **kwargs):
"""Retrieve a Area with a specified data. # noqa: E501
Retrieve a Area resource by date. # 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_area_by_date(date, async_req=True)
>>> result = thread.get()
Args:
date (str): Get all resources containing the name
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[Area]
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')
kwargs['date'] = \
date
return self.call_with_http_info(**kwargs)
self.get_area_by_date = _Endpoint(
settings={
'response_type': ([Area], ),
'auth': [],
'endpoint_path': '/areas/date/{date}',
'operation_id': 'get_area_by_date',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'date',
],
'required': [
'date',
],
'nullable': [],
'enum': [],
'validation': [
'date',
]
},
root_map={
'validations': {
('date', ): {
'regex': {
'pattern':
r'^\d{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'date': (str, ),
},
'attribute_map': {
'date': 'date',
},
'location_map': {
'date': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_area_by_date)
def __get_area_by_name(self, name, **kwargs):
"""Retrieve a Area resource by unique name. # noqa: E501
Retrieve a Area resource by unique name. # 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_area_by_name(name, async_req=True)
>>> result = thread.get()
Args:
name (str): resource unique name
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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[Area]
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')
kwargs['name'] = \
name
return self.call_with_http_info(**kwargs)
self.get_area_by_name = _Endpoint(settings={
'response_type': ([Area], ),
'auth': [],
'endpoint_path': '/areas/{name}',
'operation_id': 'get_area_by_name',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_area_by_name)
def __get_area_by_properties(self, **kwargs):
"""Retrieve a Area with a specified data set of properties. # noqa: E501
Retrieve a Area resource by properties dict. # 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_area_by_properties(async_req=True)
>>> result = thread.get()
Keyword Args:
props (Props): Area to retrieve with matching properties. [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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[Area]
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')
return self.call_with_http_info(**kwargs)
self.get_area_by_properties = _Endpoint(
settings={
'response_type': ([Area], ),
'auth': [],
'endpoint_path': '/areas/properties',
'operation_id': 'get_area_by_properties',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'props',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'props': (Props, ),
},
'attribute_map': {},
'location_map': {
'props': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__get_area_by_properties)
def __get_intersect(self, **kwargs):
"""Retrieve a Area inteersecting posted polygon. # noqa: E501
Retrieve intersecting Area resources # 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_intersect(async_req=True)
>>> result = thread.get()
Keyword Args:
polygon (Polygon): Polygon to retrieve intersecting Area resources. [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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[Area]
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')
return self.call_with_http_info(**kwargs)
self.get_intersect = _Endpoint(settings={
'response_type': ([Area], ),
'auth': [],
'endpoint_path': '/areas/intersect',
'operation_id': 'get_intersect',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'polygon',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'polygon': (Polygon, ),
},
'attribute_map': {},
'location_map': {
'polygon': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type':
['application/json']
},
api_client=api_client,
callable=__get_intersect)
def __get_intersection(self, **kwargs):
"""Retrieve Area inside input polygon. # noqa: E501
Retrieve Area inside input polygon # 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_intersection(async_req=True)
>>> result = thread.get()
Keyword Args:
polygon (Polygon): Polygon to retrieve inner Area resources. [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/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
[Area]
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')
return self.call_with_http_info(**kwargs)
self.get_intersection = _Endpoint(settings={
'response_type': ([Area], ),
'auth': [],
'endpoint_path': '/areas/intersection',
'operation_id': 'get_intersection',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'polygon',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'polygon': (Polygon, ),
},
'attribute_map': {},
'location_map': {
'polygon': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type':
['application/json']
},
api_client=api_client,
callable=__get_intersection)
