def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __bootstrap_filing_entity(self, cik, **kwargs):
"""bootstrap_filing_entity # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.bootstrap_filing_entity(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:
FilingEntity
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.bootstrap_filing_entity = _Endpoint(
settings={
'response_type': (FilingEntity, ),
'auth': [],
'endpoint_path': '/api/filing-entity-manager/{cik}',
'operation_id': 'bootstrap_filing_entity',
'http_method': 'POST',
'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=__bootstrap_filing_entity)
def __bootstrap_filing_entity_sync(self, cik, **kwargs):
"""bootstrap_filing_entity_sync # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.bootstrap_filing_entity_sync(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:
FilingEntity
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.bootstrap_filing_entity_sync = _Endpoint(
settings={
'response_type': (FilingEntity, ),
'auth': [],
'endpoint_path': '/api/filing-entity-manager/{cik}/sync',
'operation_id': 'bootstrap_filing_entity_sync',
'http_method': 'POST',
'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=__bootstrap_filing_entity_sync)
def __create_filing_entity(self, cik, **kwargs):
"""create_filing_entity # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_filing_entity(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:
FilingEntity
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_filing_entity = _Endpoint(settings={
'response_type': (FilingEntity, ),
'auth': [],
'endpoint_path': '/api/filing-entity-manager/{cik}/create',
'operation_id': 'create_filing_entity',
'http_method': 'POST',
'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_filing_entity)
def __save_filing_entity(self, filing_entity, **kwargs):
"""save_filing_entity # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.save_filing_entity(filing_entity, async_req=True)
>>> result = thread.get()
Args:
filing_entity (FilingEntity):
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['filing_entity'] = \
filing_entity
return self.call_with_http_info(**kwargs)
self.save_filing_entity = _Endpoint(settings={
'response_type': None,
'auth': [],
'endpoint_path': '/api/filing-entity-manager',
'operation_id': 'save_filing_entity',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'filing_entity',
],
'required': [
'filing_entity',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'filing_entity':
(FilingEntity, ),
},
'attribute_map': {},
'location_map': {
'filing_entity': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type':
['application/json']
},
api_client=api_client,
callable=__save_filing_entity)
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, creds, env="CERT"): self.config = Configuration(host=self.PRODUCTION_URL) if env is "PROD" else Configuration(host=self.SANDBOX_URL) self.client = ApiClient(self.config) self.credentials = creds
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 __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 __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 __v1_positions_get(self, **kwargs):
"""Get open positions # noqa: E501
Get current open positions 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_positions_get(async_req=True)
>>> result = thread.get()
Keyword Args:
exchange_id (str): Filter the balances 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:
Positions
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_positions_get = 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,
callable=__v1_positions_get)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __moderations_create(self, **kwargs):
"""moderations_create # noqa: E501
Moderation 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.moderations_create(async_req=True)
>>> result = thread.get()
Keyword Args:
moderation (Moderation): [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:
Moderation
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.moderations_create = _Endpoint(
settings={
'response_type': (Moderation, ),
'auth': ['basicAuth', 'cookieAuth', 'jwtAuth', 'tokenAuth'],
'endpoint_path': '/moderations',
'operation_id': 'moderations_create',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'moderation',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'moderation': (Moderation, ),
},
'attribute_map': {},
'location_map': {
'moderation': '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=__moderations_create)
def __moderations_destroy(self, submission, **kwargs):
"""moderations_destroy # noqa: E501
Moderation 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.moderations_destroy(submission, async_req=True)
>>> result = thread.get()
Args:
submission (int): A unique value identifying this moderation.
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.moderations_destroy = _Endpoint(settings={
'response_type':
None,
'auth': ['basicAuth', 'cookieAuth', 'jwtAuth', 'tokenAuth'],
'endpoint_path':
'/moderations/{submission}',
'operation_id':
'moderations_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=__moderations_destroy)
def __moderations_list(self, **kwargs):
"""moderations_list # noqa: E501
Moderation 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.moderations_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:
PaginatedModerationList
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.moderations_list = _Endpoint(settings={
'response_type': (PaginatedModerationList, ),
'auth': ['basicAuth', 'cookieAuth', 'jwtAuth', 'tokenAuth'],
'endpoint_path':
'/moderations',
'operation_id':
'moderations_list',
'http_method':
'GET',
'servers':
None,
},
params_map={
'all': [
'limit',
'offset',
'ordering',
'status',
],
'required': [],
'nullable': [],
'enum': [
'status',
],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {
('status', ): {
"ACCEPTED": "accepted",
"PENDING": "pending",
"REJECTED": "rejected"
},
},
'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=__moderations_list)
def __moderations_partial_update(self, submission, **kwargs):
"""moderations_partial_update # noqa: E501
Moderation 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.moderations_partial_update(submission, async_req=True)
>>> result = thread.get()
Args:
submission (int): A unique value identifying this moderation.
Keyword Args:
patched_moderation (PatchedModeration): [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:
Moderation
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.moderations_partial_update = _Endpoint(
settings={
'response_type': (Moderation, ),
'auth': ['basicAuth', 'cookieAuth', 'jwtAuth', 'tokenAuth'],
'endpoint_path': '/moderations/{submission}',
'operation_id': 'moderations_partial_update',
'http_method': 'PATCH',
'servers': None,
},
params_map={
'all': [
'submission',
'patched_moderation',
],
'required': [
'submission',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'submission': (int, ),
'patched_moderation': (PatchedModeration, ),
},
'attribute_map': {
'submission': 'submission',
},
'location_map': {
'submission': 'path',
'patched_moderation': '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=__moderations_partial_update)
def __moderations_retrieve(self, submission, **kwargs):
"""moderations_retrieve # noqa: E501
Moderation 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.moderations_retrieve(submission, async_req=True)
>>> result = thread.get()
Args:
submission (int): A unique value identifying this moderation.
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:
Moderation
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.moderations_retrieve = _Endpoint(settings={
'response_type': (Moderation, ),
'auth': ['basicAuth', 'cookieAuth', 'jwtAuth', 'tokenAuth'],
'endpoint_path':
'/moderations/{submission}',
'operation_id':
'moderations_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=__moderations_retrieve)
def __moderations_update(self, submission, **kwargs):
"""moderations_update # noqa: E501
Moderation 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.moderations_update(submission, async_req=True)
>>> result = thread.get()
Args:
submission (int): A unique value identifying this moderation.
Keyword Args:
moderation (Moderation): [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:
Moderation
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.moderations_update = _Endpoint(
settings={
'response_type': (Moderation, ),
'auth': ['basicAuth', 'cookieAuth', 'jwtAuth', 'tokenAuth'],
'endpoint_path': '/moderations/{submission}',
'operation_id': 'moderations_update',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'submission',
'moderation',
],
'required': [
'submission',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'submission': (int, ),
'moderation': (Moderation, ),
},
'attribute_map': {
'submission': 'submission',
},
'location_map': {
'submission': 'path',
'moderation': '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=__moderations_update)
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 (Identificatie): <body><p>De unieke identificatie van de activiteit.</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:
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',
'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=__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:
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]
naam (str): <body><p>Een (korte) omschrijving van de activiteit.</p></body>. [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:
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': [
'accept_crs',
'page',
'expand',
'naam',
'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, ),
'naam': (str, ),
'page_size': (int, ),
},
'attribute_map': {
'accept_crs': 'Accept-Crs',
'page': 'page',
'expand': 'expand',
'naam': 'naam',
'page_size': 'pageSize',
},
'location_map': {
'accept_crs': 'header',
'page': 'query',
'expand': 'query',
'naam': 'query',
'page_size': '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 __email_validation_single_validation_get(
self,
email,
**kwargs
):
"""email_validation_single_validation_get # noqa: E501
POST request contains additional parameters for detailed configuration # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.email_validation_single_validation_get(email, async_req=True)
>>> result = thread.get()
Args:
email (str):
Keyword Args:
result_type (ResultType): ResultTypeDescription. [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:
EmailResponse
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['email'] = \
email
return self.call_with_http_info(**kwargs)
self.email_validation_single_validation_get = _Endpoint(
settings={
'response_type': (EmailResponse,),
'auth': [
'AuthKey',
'RapidApiKey',
'RapidApiSecret'
],
'endpoint_path': '/v1/validation/single/{email}',
'operation_id': 'email_validation_single_validation_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'email',
'result_type',
],
'required': [
'email',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'email':
(str,),
'result_type':
(ResultType,),
},
'attribute_map': {
'email': 'email',
'result_type': 'result_type',
},
'location_map': {
'email': 'path',
'result_type': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__email_validation_single_validation_get
)
def __email_validation_single_validation_post(
self,
body,
**kwargs
):
"""email_validation_single_validation_post # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.email_validation_single_validation_post(body, async_req=True)
>>> result = thread.get()
Args:
body (EmailRequest):
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:
EmailResponse
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['body'] = \
body
return self.call_with_http_info(**kwargs)
self.email_validation_single_validation_post = _Endpoint(
settings={
'response_type': (EmailResponse,),
'auth': [
'AuthKey',
'RapidApiKey',
'RapidApiSecret'
],
'endpoint_path': '/v1/validation/single',
'operation_id': 'email_validation_single_validation_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'body',
],
'required': [
'body',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'body':
(EmailRequest,),
},
'attribute_map': {
},
'location_map': {
'body': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__email_validation_single_validation_post
)
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)
from openapi_client.models.duration_interval import DurationInterval from openapi_client.models.duration_interval_legacy import DurationIntervalLegacy from openapi_client.models.dynamic_attachment import DynamicAttachment from openapi_client.models.error import Error from openapi_client.models.metadata import Metadata from openapi_client.models.participant import Participant from openapi_client.models.researcher import Researcher from openapi_client.models.result_event import ResultEvent from openapi_client.models.sensor_event import SensorEvent from openapi_client.models.sensor_spec import SensorSpec from openapi_client.models.study import Study from openapi_client.models.temporal_event import TemporalEvent HOST = "https://api.lamp.digital" KEY = "" # your login credentials go here BETA_VALUES_FILEPATH = "BETA_FILEPATH" #filepath to folder holding beta values configuration = Configuration(host=HOST) configuration.api_key['Authorization'] = KEY configuration.api_key_prefix['Authorization'] = 'Basic' activity = ActivityApi(ApiClient(configuration)) activity_spec = ActivitySpecApi(ApiClient(configuration)) credential = CredentialApi(ApiClient(configuration)) participant = ParticipantApi(ApiClient(configuration)) researcher = ResearcherApi(ApiClient(configuration)) result_event = ResultEventApi(ApiClient(configuration)) sensor_event = SensorEventApi(ApiClient(configuration)) study = StudyApi(ApiClient(configuration)) type = TypeApi(ApiClient(configuration))
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __clear_task_instance(self, dag_id,
clear_task_instance_clear_task_instance,
**kwargs):
"""Clears a set of task instances associated with the DAG for a specified date range. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.clear_task_instance(dag_id, clear_task_instance_clear_task_instance, async_req=True)
>>> result = thread.get()
Args:
dag_id (str): The DAG ID.
clear_task_instance_clear_task_instance (clear_task_instance.ClearTaskInstance): Parameters of action
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
task_instance_reference_collection.TaskInstanceReferenceCollection
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['dag_id'] = \
dag_id
kwargs['clear_task_instance_clear_task_instance'] = \
clear_task_instance_clear_task_instance
return self.call_with_http_info(**kwargs)
self.clear_task_instance = Endpoint(
settings={
'response_type': (task_instance_reference_collection.
TaskInstanceReferenceCollection, ),
'auth': [],
'endpoint_path':
'/dags/{dag_id}/clearTaskInstances',
'operation_id':
'clear_task_instance',
'http_method':
'POST',
'servers': [],
},
params_map={
'all': [
'dag_id',
'clear_task_instance_clear_task_instance',
],
'required': [
'dag_id',
'clear_task_instance_clear_task_instance',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'dag_id': (str, ),
'clear_task_instance_clear_task_instance':
(clear_task_instance.ClearTaskInstance, ),
},
'attribute_map': {
'dag_id': 'dag_id',
},
'location_map': {
'dag_id': 'path',
'clear_task_instance_clear_task_instance': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__clear_task_instance)
def __get_dag(self, dag_id, **kwargs):
"""Get basic information about a DAG # noqa: E501
Presents only information available in database (DAGModel). If you need detailed information, consider using GET /dags/{dag_id}/detail. # 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_dag(dag_id, async_req=True)
>>> result = thread.get()
Args:
dag_id (str): The DAG ID.
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
dag.DAG
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['dag_id'] = \
dag_id
return self.call_with_http_info(**kwargs)
self.get_dag = Endpoint(settings={
'response_type': (dag.DAG, ),
'auth': [],
'endpoint_path': '/dags/{dag_id}',
'operation_id': 'get_dag',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'dag_id',
],
'required': [
'dag_id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'dag_id': (str, ),
},
'attribute_map': {
'dag_id': 'dag_id',
},
'location_map': {
'dag_id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_dag)
def __get_dag_detail(self, dag_id, **kwargs):
"""Get a simplified representation of DAG. # noqa: E501
The response contains many DAG attributes, so the response can be large. If possible, consider using GET /dags/{dag_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.get_dag_detail(dag_id, async_req=True)
>>> result = thread.get()
Args:
dag_id (str): The DAG ID.
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
dag_detail.DAGDetail
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['dag_id'] = \
dag_id
return self.call_with_http_info(**kwargs)
self.get_dag_detail = Endpoint(settings={
'response_type': (dag_detail.DAGDetail, ),
'auth': [],
'endpoint_path': '/dags/{dag_id}/details',
'operation_id': 'get_dag_detail',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'dag_id',
],
'required': [
'dag_id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'dag_id': (str, ),
},
'attribute_map': {
'dag_id': 'dag_id',
},
'location_map': {
'dag_id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_dag_detail)
def __get_dag_source(self, file_token, **kwargs):
"""Get source code using file token # 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_dag_source(file_token, async_req=True)
>>> result = thread.get()
Args:
file_token (str): The key containing the encrypted path to the file. Encryption and decryption take place only on the server. This prevents the client from reading an non-DAG file. This also ensures API extensibility, because the format of encrypted data may change.
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
inline_response2001.InlineResponse2001
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['file_token'] = \
file_token
return self.call_with_http_info(**kwargs)
self.get_dag_source = Endpoint(settings={
'response_type': (inline_response2001.InlineResponse2001, ),
'auth': [],
'endpoint_path':
'/dagSources/{file_token}',
'operation_id':
'get_dag_source',
'http_method':
'GET',
'servers': [],
},
params_map={
'all': [
'file_token',
],
'required': [
'file_token',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'file_token': (str, ),
},
'attribute_map': {
'file_token': 'file_token',
},
'location_map': {
'file_token': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_dag_source)
def __get_dags(self, **kwargs):
"""Get all DAGs # 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_dags(async_req=True)
>>> result = thread.get()
Keyword Args:
limit (int): The numbers of items to return.. [optional] if omitted the server will use the default value of 100
offset (int): The number of items to skip before starting to collect the result set.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
dag_collection.DAGCollection
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
return self.call_with_http_info(**kwargs)
self.get_dags = Endpoint(settings={
'response_type': (dag_collection.DAGCollection, ),
'auth': [],
'endpoint_path':
'/dags',
'operation_id':
'get_dags',
'http_method':
'GET',
'servers': [],
},
params_map={
'all': [
'limit',
'offset',
],
'required': [],
'nullable': [],
'enum': [],
'validation': [
'limit',
'offset',
]
},
root_map={
'validations': {
('limit', ): {
'inclusive_minimum': 1,
},
('offset', ): {
'inclusive_minimum': 0,
},
},
'allowed_values': {},
'openapi_types': {
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_dags)
def __get_task(self, dag_id, task_id, **kwargs):
"""Get simplified representation of a task. # 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_task(dag_id, task_id, async_req=True)
>>> result = thread.get()
Args:
dag_id (str): The DAG ID.
task_id (str): The Task ID.
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
task.Task
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['dag_id'] = \
dag_id
kwargs['task_id'] = \
task_id
return self.call_with_http_info(**kwargs)
self.get_task = Endpoint(settings={
'response_type': (task.Task, ),
'auth': [],
'endpoint_path': '/dags/{dag_id}/tasks/{task_id}',
'operation_id': 'get_task',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'dag_id',
'task_id',
],
'required': [
'dag_id',
'task_id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'dag_id': (str, ),
'task_id': (str, ),
},
'attribute_map': {
'dag_id': 'dag_id',
'task_id': 'task_id',
},
'location_map': {
'dag_id': 'path',
'task_id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_task)
def __get_tasks(self, dag_id, **kwargs):
"""Get tasks for DAG # 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_tasks(dag_id, async_req=True)
>>> result = thread.get()
Args:
dag_id (str): The DAG ID.
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
task_collection.TaskCollection
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['dag_id'] = \
dag_id
return self.call_with_http_info(**kwargs)
self.get_tasks = Endpoint(settings={
'response_type': (task_collection.TaskCollection, ),
'auth': [],
'endpoint_path':
'/dags/{dag_id}/tasks',
'operation_id':
'get_tasks',
'http_method':
'GET',
'servers': [],
},
params_map={
'all': [
'dag_id',
],
'required': [
'dag_id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'dag_id': (str, ),
},
'attribute_map': {
'dag_id': 'dag_id',
},
'location_map': {
'dag_id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_tasks)
def __update_dag(self, dag_id, dag_dag, **kwargs):
"""Update a DAG # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_dag(dag_id, dag_dag, async_req=True)
>>> result = thread.get()
Args:
dag_id (str): The DAG ID.
dag_dag (dag.DAG):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
dag.DAG
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['dag_id'] = \
dag_id
kwargs['dag_dag'] = \
dag_dag
return self.call_with_http_info(**kwargs)
self.update_dag = Endpoint(settings={
'response_type': (dag.DAG, ),
'auth': [],
'endpoint_path': '/dags/{dag_id}',
'operation_id': 'update_dag',
'http_method': 'PATCH',
'servers': [],
},
params_map={
'all': [
'dag_id',
'dag_dag',
],
'required': [
'dag_id',
'dag_dag',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'dag_id': (str, ),
'dag_dag': (dag.DAG, ),
},
'attribute_map': {
'dag_id': 'dag_id',
},
'location_map': {
'dag_id': 'path',
'dag_dag': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__update_dag)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __profile(
self,
symbol,
**kwargs
):
"""Get the Company profile # 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.profile(symbol, async_req=True)
>>> result = thread.get()
Args:
symbol (str): Name of ticker
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:
[CompanyProfile]
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.profile = _Endpoint(
settings={
'response_type': ([CompanyProfile],),
'auth': [
'api_key'
],
'endpoint_path': '/profile/{symbol}',
'operation_id': 'profile',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'symbol',
],
'required': [
'symbol',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'symbol':
(str,),
},
'attribute_map': {
'symbol': 'symbol',
},
'location_map': {
'symbol': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__profile
)
def __quote(
self,
symbol,
**kwargs
):
"""Get the Company Quote # 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.quote(symbol, async_req=True)
>>> result = thread.get()
Args:
symbol (str): Name of ticker
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:
[CompanyQuote]
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.quote = _Endpoint(
settings={
'response_type': ([CompanyQuote],),
'auth': [
'api_key'
],
'endpoint_path': '/quote/{symbol}',
'operation_id': 'quote',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'symbol',
],
'required': [
'symbol',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'symbol':
(str,),
},
'attribute_map': {
'symbol': 'symbol',
},
'location_map': {
'symbol': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__quote
)
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 __convert_image(self, file, format="PNG", **kwargs):
"""Files - Convert Image # noqa: E501
Convert an image from one format to another # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.convert_image(file, format="PNG", async_req=True)
>>> result = thread.get()
Args:
file (file_type): Source image file
format (str): Output file format. defaults to "PNG", must be one of ["PNG"]
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:
file_type
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['format'] = \
format
kwargs['file'] = \
file
return self.call_with_http_info(**kwargs)
self.convert_image = Endpoint(
settings={
'response_type': (file_type, ),
'auth': ['apiKeyHeader'],
'endpoint_path': '/ConvertImage',
'operation_id': 'convert_image',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'format',
'file',
],
'required': [
'format',
'file',
],
'nullable': [],
'enum': [
'format',
],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {
('format', ): {
"PNG": "PNG",
"JPG": "JPG",
"GIF": "GIF",
"BMP": "BMP",
"TIF": "TIF"
},
},
'openapi_types': {
'format': (str, ),
'file': (file_type, ),
},
'attribute_map': {
'format': 'format',
'file': 'file',
},
'location_map': {
'format': 'form',
'file': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept':
['image/png', 'image/gif', 'image/jpeg', 'image/bmp'],
'content_type': ['multipart/form-data']
},
api_client=api_client,
callable=__convert_image)
def __crop_image(self,
width,
height,
file,
position="TopLeft",
**kwargs):
"""Files - Crop Image # noqa: E501
Crop an image # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.crop_image(width, height, file, position="TopLeft", async_req=True)
>>> result = thread.get()
Args:
width (float): Width (X-axis right, negative to reverse)
height (float): Height (Y-axis down, negative to reverse)
file (file_type): Source image file
position (str): Crop start position (use negative values to reverse crop area). defaults to "TopLeft", must be one of ["TopLeft"]
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:
file_type
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['position'] = \
position
kwargs['width'] = \
width
kwargs['height'] = \
height
kwargs['file'] = \
file
return self.call_with_http_info(**kwargs)
self.crop_image = Endpoint(
settings={
'response_type': (file_type, ),
'auth': ['apiKeyHeader'],
'endpoint_path': '/CropImage',
'operation_id': 'crop_image',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'position',
'width',
'height',
'file',
],
'required': [
'position',
'width',
'height',
'file',
],
'nullable': [],
'enum': [
'position',
],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {
('position', ): {
"TOPLEFT": "TopLeft",
"TOPCENTER": "TopCenter",
"TOPRIGHT": "TopRight",
"MIDDLELEFT": "MiddleLeft",
"MIDDLECENTER": "MiddleCenter",
"MIDDLERIGHT": "MiddleRight",
"BOTTOMLEFT": "BottomLeft",
"BOTTOMCENTER": "BottomCenter",
"BOTTOMRIGHT": "BottomRight"
},
},
'openapi_types': {
'position': (str, ),
'width': (float, ),
'height': (float, ),
'file': (file_type, ),
},
'attribute_map': {
'position': 'position',
'width': 'Width',
'height': 'Height',
'file': 'file',
},
'location_map': {
'position': 'form',
'width': 'form',
'height': 'form',
'file': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept':
['image/png', 'image/gif', 'image/jpeg', 'image/bmp'],
'content_type': ['multipart/form-data']
},
api_client=api_client,
callable=__crop_image)
def __file_to_string(self, file, **kwargs):
"""Files - File to string # noqa: E501
Convert a file to a Base64 string # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.file_to_string(file, async_req=True)
>>> result = thread.get()
Args:
file (file_type): Source file (10MB limit)
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:
OutputString
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['file'] = \
file
return self.call_with_http_info(**kwargs)
self.file_to_string = Endpoint(settings={
'response_type': (OutputString, ),
'auth': ['apiKeyHeader'],
'endpoint_path': '/FileToString',
'operation_id': 'file_to_string',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'file',
],
'required': [
'file',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'file': (file_type, ),
},
'attribute_map': {
'file': 'file',
},
'location_map': {
'file': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type':
['multipart/form-data']
},
api_client=api_client,
callable=__file_to_string)
def __flip_image(self, file, orientation="Horizontal", **kwargs):
"""Files - Flip Image # noqa: E501
Flip an image (horizontal or vertical) # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.flip_image(file, orientation="Horizontal", async_req=True)
>>> result = thread.get()
Args:
file (file_type): Source image file
orientation (str): Horizontal or Vertical. defaults to "Horizontal", must be one of ["Horizontal"]
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:
file_type
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['orientation'] = \
orientation
kwargs['file'] = \
file
return self.call_with_http_info(**kwargs)
self.flip_image = Endpoint(settings={
'response_type': (file_type, ),
'auth': ['apiKeyHeader'],
'endpoint_path': '/FlipImage',
'operation_id': 'flip_image',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'orientation',
'file',
],
'required': [
'orientation',
'file',
],
'nullable': [],
'enum': [
'orientation',
],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {
('orientation', ): {
"HORIZONTAL": "Horizontal",
"VERTICAL": "Vertical"
},
},
'openapi_types': {
'orientation': (str, ),
'file': (file_type, ),
},
'attribute_map': {
'orientation': 'orientation',
'file': 'file',
},
'location_map': {
'orientation': 'form',
'file': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': ['multipart/form-data']
},
api_client=api_client,
callable=__flip_image)
def __generate_qr_code(self, **kwargs):
"""Files - Generate QR code # noqa: E501
Generate a QR code image # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.generate_qr_code(async_req=True)
>>> result = thread.get()
Keyword Args:
input_qr_code (InputQRCode): [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:
file_type
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.generate_qr_code = Endpoint(settings={
'response_type': (file_type, ),
'auth': ['apiKeyHeader'],
'endpoint_path': '/GenerateQRCode',
'operation_id': 'generate_qr_code',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'input_qr_code',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'input_qr_code':
(InputQRCode, ),
},
'attribute_map': {},
'location_map': {
'input_qr_code': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['image/png'],
'content_type':
['application/json']
},
api_client=api_client,
callable=__generate_qr_code)
def __resize_image(self,
file,
algorithm="Bicubic (default)",
units="Pixels",
**kwargs):
"""Files - Resize Image # noqa: E501
Resize an image # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.resize_image(file, algorithm="Bicubic (default)", units="Pixels", async_req=True)
>>> result = thread.get()
Args:
file (file_type): Source image file
algorithm (str): Optimize output quality of the target image. defaults to "Bicubic (default)", must be one of ["Bicubic (default)"]
units (str): Image adjustment units. defaults to "Pixels", must be one of ["Pixels"]
Keyword Args:
height (float): Image height (pixels or percent). [optional]
width (float): Image width (pixels or percent). [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:
file_type
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['algorithm'] = \
algorithm
kwargs['units'] = \
units
kwargs['file'] = \
file
return self.call_with_http_info(**kwargs)
self.resize_image = Endpoint(
settings={
'response_type': (file_type, ),
'auth': ['apiKeyHeader'],
'endpoint_path': '/ResizeImage',
'operation_id': 'resize_image',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'algorithm',
'units',
'file',
'height',
'width',
],
'required': [
'algorithm',
'units',
'file',
],
'nullable': [],
'enum': [
'algorithm',
'units',
],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {
('algorithm', ): {
"BICUBIC_(DEFAULT)": "Bicubic (default)",
"BILINEAR": "Bilinear",
"CUBIC_(BOX)": "Cubic (Box)",
"CUBIC_(CATMULL-ROM)": "Cubic (Catmull-Rom)",
"CUBIC_(HERMITE)": "Cubic (Hermite)",
"CUBIC_(SPLINE)": "Cubic (Spline)",
"NEAREST_NEIGHBOR": "Nearest Neighbor",
"SINC_(LANCZOS2)": "Sinc (Lanczos2)",
"SINC_(LANCZOS3)": "Sinc (Lanczos3)",
"SINC_(LANCZOS5)": "Sinc (Lanczos5)",
"SINC_(LANCZOS8)": "Sinc (Lanczos8)",
"ROBIDOUX": "Robidoux",
"ROBIDOUX_SHARP": "Robidoux Sharp"
},
('units', ): {
"PIXELS": "Pixels",
"PERCENT": "Percent"
},
},
'openapi_types': {
'algorithm': (str, ),
'units': (str, ),
'file': (file_type, ),
'height': (float, ),
'width': (float, ),
},
'attribute_map': {
'algorithm': 'algorithm',
'units': 'units',
'file': 'file',
'height': 'height',
'width': 'width',
},
'location_map': {
'algorithm': 'form',
'units': 'form',
'file': 'form',
'height': 'form',
'width': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept':
['image/png', 'image/gif', 'image/jpeg', 'image/bmp'],
'content_type': ['multipart/form-data']
},
api_client=api_client,
callable=__resize_image)
def __rotate_image(self, degrees, file, **kwargs):
"""Files - Rotate Image # noqa: E501
Rotate an image by specified number of degrees # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.rotate_image(degrees, file, async_req=True)
>>> result = thread.get()
Args:
degrees (str): Number of degrees
file (file_type): Source image file
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:
file_type
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['degrees'] = \
degrees
kwargs['file'] = \
file
return self.call_with_http_info(**kwargs)
self.rotate_image = Endpoint(settings={
'response_type': (file_type, ),
'auth': ['apiKeyHeader'],
'endpoint_path': '/RotateImage',
'operation_id': 'rotate_image',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'degrees',
'file',
],
'required': [
'degrees',
'file',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'degrees': (str, ),
'file': (file_type, ),
},
'attribute_map': {
'degrees': 'degrees',
'file': 'file',
},
'location_map': {
'degrees': 'form',
'file': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type':
['multipart/form-data']
},
api_client=api_client,
callable=__rotate_image)
def __watermark_image(self,
text,
size,
file,
font="Arial",
color="000000",
horizontal="Center",
vertical="Center",
**kwargs):
"""Files - Watermark Image # noqa: E501
Add watermark text to an image # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.watermark_image(text, size, file, font="Arial", color="000000", horizontal="Center", vertical="Center", async_req=True)
>>> result = thread.get()
Args:
text (str): Watermark text
size (float): Font size (points)
file (file_type): Source image file
font (str): Text font. defaults to "Arial", must be one of ["Arial"]
color (str): Text color hex value. defaults to "000000", must be one of ["000000"]
horizontal (str): Horizontal alignment. defaults to "Center", must be one of ["Center"]
vertical (str): Vertical alignment. defaults to "Center", must be one of ["Center"]
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:
file_type
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['text'] = \
text
kwargs['font'] = \
font
kwargs['size'] = \
size
kwargs['color'] = \
color
kwargs['horizontal'] = \
horizontal
kwargs['vertical'] = \
vertical
kwargs['file'] = \
file
return self.call_with_http_info(**kwargs)
self.watermark_image = Endpoint(
settings={
'response_type': (file_type, ),
'auth': ['apiKeyHeader'],
'endpoint_path': '/WatermarkImage',
'operation_id': 'watermark_image',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'text',
'font',
'size',
'color',
'horizontal',
'vertical',
'file',
],
'required': [
'text',
'font',
'size',
'color',
'horizontal',
'vertical',
'file',
],
'nullable': [],
'enum': [
'font',
'horizontal',
'vertical',
],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {
('font', ): {
"ARIAL": "Arial",
"ARIAL_BLACK": "Arial Black",
"ARIAL_NARROW": "Arial Narrow",
"BOOK_ANTIQUA": "Book Antiqua",
"BRITANNIC_BOLD": "Britannic Bold",
"BRUSH_SCRIPT_MT": "Brush Script MT",
"CALISTO_MT": "Calisto MT",
"CENTURY_GOTHIC": "Century Gothic",
"CENTURY_SCHOOLBOOK": "Century Schoolbook",
"COLONNA_MT": "Colonna MT",
"COMIC_SANS_MS": "Comic Sans MS",
"COOPER_BLACK": "Cooper Black",
"COPPERPLATE_GOTHIC_BOLD": "Copperplate Gothic Bold",
"COPPERPLATE_GOTHIC_LIGHT": "Copperplate Gothic Light",
"COURIER_NEW": "Courier New",
"EDWARDIAN_SCRIPT_ITC": "Edwardian Script ITC",
"ENGRAVERS_MT": "Engravers MT",
"FRANKLIN_GOTHIC_DEMI": "Franklin Gothic Demi",
"FRANKLIN_GOTHIC_HEAVY": "Franklin Gothic Heavy",
"FRANKLIN_GOTHIC_MEDIUM": "Franklin Gothic Medium",
"GARAMOND": "Garamond",
"GEORGIA": "Georgia",
"GILL_SANS_MT": "Gill Sans MT",
"GILL_SANS_MT_CONDENSED": "Gill Sans MT Condensed",
"GILL_SANS_ULTRA_BOLD": "Gill Sans Ultra Bold",
"GILL_SANS_ULTRA_BOLD_CONDENSED":
"Gill Sans Ultra Bold Condensed",
"GOUDY_OLD_STYLE": "Goudy Old Style",
"HAETTENSCHWEILER": "Haettenschweiler",
"HOLIDAYS_MT": "Holidays MT",
"IMPACT": "Impact",
"LUCIDA_CALLIGRAPHY": "Lucida Calligraphy",
"LUCIDA_CONSOLE": "Lucida Console",
"LUCIDA_HANDWRITING": "Lucida Handwriting",
"LUCIDA_SANS_TYPEWRITER": "Lucida Sans Typewriter",
"LUCIDA_SANS_UNICODE": "Lucida Sans Unicode",
"MARLETT": "Marlett",
"MICROSOFT_SANS_SERIF": "Microsoft Sans Serif",
"MS_OUTLOOK": "MS Outlook",
"PALACE_SCRIPT_MT": "Palace Script MT",
"PALATINO_LINOTYPE": "Palatino Linotype",
"PAPYRUS": "Papyrus",
"PLAYBILL": "Playbill",
"ROCKWELL": "Rockwell",
"ROCKWELL_CONDENSED": "Rockwell Condensed",
"ROCKWELL_EXTRA_BOLD": "Rockwell Extra Bold",
"SCRIPT_MT_BOLD": "Script MT Bold",
"STENCIL": "Stencil",
"SYMBOL": "Symbol",
"TAHOMA": "Tahoma",
"TIMES_NEW_ROMAN": "Times New Roman",
"TREBUCHET_MS": "Trebuchet MS",
"VERDANA": "Verdana",
"VIVALDI": "Vivaldi",
"WEBDINGS": "Webdings",
"WINGDINGS_1": "Wingdings 1",
"WINGDINGS_2": "Wingdings 2",
"WINGDINGS_3": "Wingdings 3"
},
('horizontal', ): {
"LEFT": "Left",
"CENTER": "Center",
"RIGHT": "Right"
},
('vertical', ): {
"TOP": "Top",
"CENTER": "Center",
"BOTTOM": "Bottom"
},
},
'openapi_types': {
'text': (str, ),
'font': (str, ),
'size': (float, ),
'color': (str, ),
'horizontal': (str, ),
'vertical': (str, ),
'file': (file_type, ),
},
'attribute_map': {
'text': 'text',
'font': 'font',
'size': 'size',
'color': 'color',
'horizontal': 'horizontal',
'vertical': 'vertical',
'file': 'file',
},
'location_map': {
'text': 'form',
'font': 'form',
'size': 'form',
'color': 'form',
'horizontal': 'form',
'vertical': 'form',
'file': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept': ['*/*'],
'content_type': ['multipart/form-data']
},
api_client=api_client,
callable=__watermark_image)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_extra_links(self, dag_id, dag_run_id, task_id, **kwargs):
"""Get extra links for task instance # 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_extra_links(dag_id, dag_run_id, task_id, async_req=True)
>>> result = thread.get()
Args:
dag_id (str): The DAG ID.
dag_run_id (str): The DAG Run ID.
task_id (str): The Task ID.
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
extra_link_collection.ExtraLinkCollection
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['dag_id'] = \
dag_id
kwargs['dag_run_id'] = \
dag_run_id
kwargs['task_id'] = \
task_id
return self.call_with_http_info(**kwargs)
self.get_extra_links = Endpoint(settings={
'response_type': (extra_link_collection.ExtraLinkCollection, ),
'auth': [],
'endpoint_path':
'/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id}/links',
'operation_id':
'get_extra_links',
'http_method':
'GET',
'servers': [],
},
params_map={
'all': [
'dag_id',
'dag_run_id',
'task_id',
],
'required': [
'dag_id',
'dag_run_id',
'task_id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'dag_id': (str, ),
'dag_run_id': (str, ),
'task_id': (str, ),
},
'attribute_map': {
'dag_id': 'dag_id',
'dag_run_id': 'dag_run_id',
'task_id': 'task_id',
},
'location_map': {
'dag_id': 'path',
'dag_run_id': 'path',
'task_id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_extra_links)
def __get_logs(self, dag_id, dag_run_id, task_id, task_try_number,
**kwargs):
"""Get logs for a task instance # noqa: E501
Get logs for a specific task instance and its try number # 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_logs(dag_id, dag_run_id, task_id, task_try_number, async_req=True)
>>> result = thread.get()
Args:
dag_id (str): The DAG ID.
dag_run_id (str): The DAG Run ID.
task_id (str): The Task ID.
task_try_number (int): The Task Try Number.
Keyword Args:
full_content (bool): A full content will be returned. By default, only the first fragment will be returned. . [optional]
token (str): A token that allows you to continue fetching logs. If passed, it will specify the location from which the download should be continued. . [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
inline_response200.InlineResponse200
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['dag_id'] = \
dag_id
kwargs['dag_run_id'] = \
dag_run_id
kwargs['task_id'] = \
task_id
kwargs['task_try_number'] = \
task_try_number
return self.call_with_http_info(**kwargs)
self.get_logs = Endpoint(settings={
'response_type': (inline_response200.InlineResponse200, ),
'auth': [],
'endpoint_path':
'/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id}/logs/{task_try_number}',
'operation_id':
'get_logs',
'http_method':
'GET',
'servers': [],
},
params_map={
'all': [
'dag_id',
'dag_run_id',
'task_id',
'task_try_number',
'full_content',
'token',
],
'required': [
'dag_id',
'dag_run_id',
'task_id',
'task_try_number',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'dag_id': (str, ),
'dag_run_id': (str, ),
'task_id': (str, ),
'task_try_number': (int, ),
'full_content': (bool, ),
'token': (str, ),
},
'attribute_map': {
'dag_id': 'dag_id',
'dag_run_id': 'dag_run_id',
'task_id': 'task_id',
'task_try_number': 'task_try_number',
'full_content': 'full_content',
'token': 'token',
},
'location_map': {
'dag_id': 'path',
'dag_run_id': 'path',
'task_id': 'path',
'task_try_number': 'path',
'full_content': 'query',
'token': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept':
['application/json', 'text/plain'],
'content_type': [],
},
api_client=api_client,
callable=__get_logs)
def __get_task_instance(self, dag_id, dag_run_id, task_id, **kwargs):
"""Get a task instance # 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_task_instance(dag_id, dag_run_id, task_id, async_req=True)
>>> result = thread.get()
Args:
dag_id (str): The DAG ID.
dag_run_id (str): The DAG Run ID.
task_id (str): The Task ID.
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
task_instance.TaskInstance
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['dag_id'] = \
dag_id
kwargs['dag_run_id'] = \
dag_run_id
kwargs['task_id'] = \
task_id
return self.call_with_http_info(**kwargs)
self.get_task_instance = Endpoint(settings={
'response_type': (task_instance.TaskInstance, ),
'auth': [],
'endpoint_path':
'/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id}',
'operation_id':
'get_task_instance',
'http_method':
'GET',
'servers': [],
},
params_map={
'all': [
'dag_id',
'dag_run_id',
'task_id',
],
'required': [
'dag_id',
'dag_run_id',
'task_id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'dag_id': (str, ),
'dag_run_id': (str, ),
'task_id': (str, ),
},
'attribute_map': {
'dag_id': 'dag_id',
'dag_run_id': 'dag_run_id',
'task_id': 'task_id',
},
'location_map': {
'dag_id': 'path',
'dag_run_id': 'path',
'task_id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_task_instance)
def __get_task_instances(self, dag_id, dag_run_id, **kwargs):
"""Get a list of task instance of DAG. # noqa: E501
This endpoint allows specifying `~` as the dag_id, dag_run_id to retrieve DAG Runs for all DAGs and DAG Runs. # 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_task_instances(dag_id, dag_run_id, async_req=True)
>>> result = thread.get()
Args:
dag_id (str): The DAG ID.
dag_run_id (str): The DAG Run ID.
Keyword Args:
execution_date_gte (datetime): Returns objects greater or equal to the specified date. This can be combined with execution_date_lte parameter to receive only the selected period. . [optional]
execution_date_lte (datetime): Returns objects less than or equal to the specified date. This can be combined with execution_date_gte parameter to receive only the selected period. . [optional]
start_date_gte (datetime): Returns objects greater or equal the specified date. This can be combined with startd_ate_lte parameter to receive only the selected period. . [optional]
start_date_lte (datetime): Returns objects less or equal the specified date. This can be combined with start_date_gte parameter to receive only the selected period. . [optional]
end_date_gte (datetime): Returns objects greater or equal the specified date. This can be combined with start_date_lte parameter to receive only the selected period. . [optional]
end_date_lte (datetime): Returns objects less than or equal to the specified date. This can be combined with start_date_gte parameter to receive only the selected period. . [optional]
duration_gte (float): Returns objects greater than or equal to the specified values. This can be combined with duration_lte parameter to receive only the selected period. . [optional]
duration_lte (float): Returns objects less than or equal to the specified values. This can be combined with duration_gte parameter to receive only the selected range. . [optional]
state ([str]): The value can be repeated to retrieve multiple matching values (OR condition).. [optional]
pool ([str]): The value can be repeated to retrieve multiple matching values (OR condition).. [optional]
queue ([str]): The value can be repeated to retrieve multiple matching values (OR condition).. [optional]
limit (int): The numbers of items to return.. [optional] if omitted the server will use the default value of 100
offset (int): The number of items to skip before starting to collect the result set.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
task_instance_collection.TaskInstanceCollection
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['dag_id'] = \
dag_id
kwargs['dag_run_id'] = \
dag_run_id
return self.call_with_http_info(**kwargs)
self.get_task_instances = Endpoint(
settings={
'response_type':
(task_instance_collection.TaskInstanceCollection, ),
'auth': [],
'endpoint_path':
'/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances',
'operation_id': 'get_task_instances',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'dag_id',
'dag_run_id',
'execution_date_gte',
'execution_date_lte',
'start_date_gte',
'start_date_lte',
'end_date_gte',
'end_date_lte',
'duration_gte',
'duration_lte',
'state',
'pool',
'queue',
'limit',
'offset',
],
'required': [
'dag_id',
'dag_run_id',
],
'nullable': [],
'enum': [],
'validation': [
'limit',
'offset',
]
},
root_map={
'validations': {
('limit', ): {
'inclusive_minimum': 1,
},
('offset', ): {
'inclusive_minimum': 0,
},
},
'allowed_values': {},
'openapi_types': {
'dag_id': (str, ),
'dag_run_id': (str, ),
'execution_date_gte': (datetime, ),
'execution_date_lte': (datetime, ),
'start_date_gte': (datetime, ),
'start_date_lte': (datetime, ),
'end_date_gte': (datetime, ),
'end_date_lte': (datetime, ),
'duration_gte': (float, ),
'duration_lte': (float, ),
'state': ([str], ),
'pool': ([str], ),
'queue': ([str], ),
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'dag_id': 'dag_id',
'dag_run_id': 'dag_run_id',
'execution_date_gte': 'execution_date_gte',
'execution_date_lte': 'execution_date_lte',
'start_date_gte': 'start_date_gte',
'start_date_lte': 'start_date_lte',
'end_date_gte': 'end_date_gte',
'end_date_lte': 'end_date_lte',
'duration_gte': 'duration_gte',
'duration_lte': 'duration_lte',
'state': 'state',
'pool': 'pool',
'queue': 'Queue',
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'dag_id': 'path',
'dag_run_id': 'path',
'execution_date_gte': 'query',
'execution_date_lte': 'query',
'start_date_gte': 'query',
'start_date_lte': 'query',
'end_date_gte': 'query',
'end_date_lte': 'query',
'duration_gte': 'query',
'duration_lte': 'query',
'state': 'query',
'pool': 'query',
'queue': 'query',
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {
'state': 'multi',
'pool': 'multi',
'queue': 'multi',
}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_task_instances)
def __get_task_instances_batch(
self, list_task_instance_form_list_task_instance_form,
**kwargs):
"""Get list of task instances from all DAGs and DAG Runs. # noqa: E501
This endpoint is a POST to allow filtering across a large number of DAG IDs, where as a GET it would run in to maximum HTTP request URL lengthlimits # 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_task_instances_batch(list_task_instance_form_list_task_instance_form, async_req=True)
>>> result = thread.get()
Args:
list_task_instance_form_list_task_instance_form (list_task_instance_form.ListTaskInstanceForm):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
task_instance_collection.TaskInstanceCollection
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['list_task_instance_form_list_task_instance_form'] = \
list_task_instance_form_list_task_instance_form
return self.call_with_http_info(**kwargs)
self.get_task_instances_batch = Endpoint(
settings={
'response_type':
(task_instance_collection.TaskInstanceCollection, ),
'auth': [],
'endpoint_path': '/dags/~/dagRuns/~/taskInstances/list',
'operation_id': 'get_task_instances_batch',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'list_task_instance_form_list_task_instance_form',
],
'required': [
'list_task_instance_form_list_task_instance_form',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'list_task_instance_form_list_task_instance_form':
(list_task_instance_form.ListTaskInstanceForm, ),
},
'attribute_map': {},
'location_map': {
'list_task_instance_form_list_task_instance_form': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__get_task_instances_batch)
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 __set_webhook(
self,
webhook_url_webhook_url,
**kwargs
):
"""Sets the URL for receiving webhook # noqa: E501
Sets the URL for receiving webhook notifications of new messages and message delivery events (ack). **API responses in \"Callbacks\" tab** # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.set_webhook(webhook_url_webhook_url, async_req=True)
>>> result = thread.get()
Args:
webhook_url_webhook_url (webhook_url.WebhookUrl):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
set_webhook_status.SetWebhookStatus
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['webhook_url_webhook_url'] = \
webhook_url_webhook_url
return self.call_with_http_info(**kwargs)
self.set_webhook = Endpoint(
settings={
'response_type': (set_webhook_status.SetWebhookStatus,),
'auth': [
'instanceId',
'token'
],
'endpoint_path': '/webhook',
'operation_id': 'set_webhook',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'webhook_url_webhook_url',
],
'required': [
'webhook_url_webhook_url',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'webhook_url_webhook_url':
(webhook_url.WebhookUrl,),
},
'attribute_map': {
},
'location_map': {
'webhook_url_webhook_url': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/x-www-form-urlencoded',
'application/json'
]
},
api_client=api_client,
callable=__set_webhook
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_tabel(self, tabelidentificatie, **kwargs):
"""get_tabel # noqa: E501
Het ophalen van de gegevens van een enkele 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_tabel(tabelidentificatie, async_req=True)
>>> result = thread.get()
Args:
tabelidentificatie (str): De identificatie van een landelijke tabel.
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:
Tabel
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_tabel = _Endpoint(
settings={
'response_type': (Tabel, ),
'auth': [],
'endpoint_path': '/tabellen/{tabelidentificatie}',
'operation_id': 'get_tabel',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'tabelidentificatie',
],
'required': [
'tabelidentificatie',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'tabelidentificatie': (str, ),
},
'attribute_map': {
'tabelidentificatie': 'tabelidentificatie',
},
'location_map': {
'tabelidentificatie': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/hal+json', 'application/problem+json'],
'content_type': [],
},
api_client=api_client,
callable=__get_tabel)
def __get_tabellen(self, **kwargs):
"""get_tabellen # noqa: E501
Het ophalen van een collectie landelijke tabellen. # 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_tabellen(async_req=True)
>>> result = thread.get()
Keyword Args:
tabelidentificatie (str): De identificatie van een landelijke tabel.. [optional]
omschrijving (str): De naam van de tabel. <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]
_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:
TabelCollectie
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_tabellen = _Endpoint(
settings={
'response_type': (TabelCollectie, ),
'auth': [],
'endpoint_path': '/tabellen',
'operation_id': 'get_tabellen',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'tabelidentificatie',
'omschrijving',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'tabelidentificatie': (str, ),
'omschrijving': (str, ),
},
'attribute_map': {
'tabelidentificatie': 'tabelidentificatie',
'omschrijving': 'omschrijving',
},
'location_map': {
'tabelidentificatie': 'query',
'omschrijving': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json', 'application/problem+json'],
'content_type': [],
},
api_client=api_client,
callable=__get_tabellen)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __raadpleeg_actueel_wozobject(
self,
identificatie,
**kwargs
):
"""Raadpleeg een WOZ-object # noqa: E501
Raadpleeg de actuele eigenschappen van een WOZ-object # 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_actueel_wozobject(identificatie, async_req=True)
>>> result = thread.get()
Args:
identificatie (str): Unieke identificatie van een WOZ-object
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.2.0/features/fields.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:
WozObjectHal
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.raadpleeg_actueel_wozobject = 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': [
]
},
root_map={
'validations': {
},
'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,
callable=__raadpleeg_actueel_wozobject
)
def __zoek_actuele_wozobjecten(
self,
**kwargs
):
"""Zoek WOZ-objecten # noqa: E501
Zoek WOZ-objecten op eigenaar of adres. Het resultaat zijn de actuele gegevens van de gevonden objecten. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.zoek_actuele_wozobjecten(async_req=True)
>>> result = thread.get()
Keyword Args:
rsin (str): Zoek WOZ-objecten in eigendom van een bij het Handelsregister ingeschreven niet-natuurlijk persoon. [optional]
kvk_nummer (str): Zoek WOZ-objecten in eigendom van een bij het Handelsregister ingeschreven maatschappelijke activiteit of een van de daaronder vallende ondernemingen en vestigingen. [optional]
adresseerbaar_object_identificatie (str): Zoek op de BAG identificatie van een adresseerbaar object (verblijfsobject, standplaats of ligplaats) waar het WOZ-object aan verbonden is of waar het object zijn aanduiding aan ontleent. [optional]
nummeraanduiding_identificatie (str): Zoek op de BAG identificatie van een nummeraanduiding (adres) waarmee het WOZ-object wordt aangeduid. [optional]
postcode (str): Zoek WOZ-objecten met postcode. [optional]
huisnummer (int): Zoek WOZ-objecten met huisnummer\". [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.2.0/features/fields.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:
WozObjectHalCollectie
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.zoek_actuele_wozobjecten = 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',
'fields',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
'postcode',
'huisnummer',
]
},
root_map={
'validations': {
('postcode',): {
'regex': {
'pattern': r'^[1-9][0-9][0-9][0-9][A-Z][A-Z]$', # noqa: E501
},
},
('huisnummer',): {
'inclusive_maximum': 99999,
'inclusive_minimum': 1,
},
},
'allowed_values': {
},
'openapi_types': {
'rsin':
(str,),
'kvk_nummer':
(str,),
'adresseerbaar_object_identificatie':
(str,),
'nummeraanduiding_identificatie':
(str,),
'postcode':
(str,),
'huisnummer':
(int,),
'fields':
(str,),
},
'attribute_map': {
'rsin': 'rsin',
'kvk_nummer': 'kvkNummer',
'adresseerbaar_object_identificatie': 'adresseerbaarObjectIdentificatie',
'nummeraanduiding_identificatie': 'nummeraanduidingIdentificatie',
'postcode': 'postcode',
'huisnummer': 'huisnummer',
'fields': 'fields',
},
'location_map': {
'rsin': 'query',
'kvk_nummer': 'query',
'adresseerbaar_object_identificatie': 'query',
'nummeraanduiding_identificatie': 'query',
'postcode': 'query',
'huisnummer': 'query',
'fields': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/hal+json',
'application/problem+json'
],
'content_type': [],
},
api_client=api_client,
callable=__zoek_actuele_wozobjecten
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_item_by_asin(self, asin, **kwargs):
"""Find item by asin code # noqa: E501
Returns a single item # 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_item_by_asin(asin, async_req=True)
>>> result = thread.get()
Args:
asin (str): ASIN code of item to return
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
item.Item
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['asin'] = \
asin
return self.call_with_http_info(**kwargs)
self.get_item_by_asin = Endpoint(settings={
'response_type': (item.Item, ),
'auth': [],
'endpoint_path': '/api/v1/asin/{asin}',
'operation_id': 'get_item_by_asin',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'asin',
],
'required': [
'asin',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'asin': (str, ),
},
'attribute_map': {
'asin': 'asin',
},
'location_map': {
'asin': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_item_by_asin)
def __get_item_by_ean(self, ean, **kwargs):
"""Find item by UPC code # noqa: E501
Returns a single item # 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_item_by_ean(ean, async_req=True)
>>> result = thread.get()
Args:
ean (str): EAN code of item to return
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
item.Item
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['ean'] = \
ean
return self.call_with_http_info(**kwargs)
self.get_item_by_ean = Endpoint(settings={
'response_type': (item.Item, ),
'auth': [],
'endpoint_path': '/api/v1/ean/{ean}',
'operation_id': 'get_item_by_ean',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'ean',
],
'required': [
'ean',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'ean': (str, ),
},
'attribute_map': {
'ean': 'ean',
},
'location_map': {
'ean': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_item_by_ean)
def __get_item_by_upc(self, upc, **kwargs):
"""Find item by UPC code # noqa: E501
Returns a single item # 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_item_by_upc(upc, async_req=True)
>>> result = thread.get()
Args:
upc (str): UPC code of item to return
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
item.Item
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['upc'] = \
upc
return self.call_with_http_info(**kwargs)
self.get_item_by_upc = Endpoint(settings={
'response_type': (item.Item, ),
'auth': [],
'endpoint_path': '/api/v1/upc/{upc}',
'operation_id': 'get_item_by_upc',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
'upc',
],
'required': [
'upc',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'upc': (str, ),
},
'attribute_map': {
'upc': 'upc',
},
'location_map': {
'upc': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_item_by_upc)
from openapi_client.api_client import ApiClient
from openapi_client.configuration import Configuration
from openapi_client.api.test_api import TestApi
if __name__ == '__main__':
api_client = ApiClient()
configuration = Configuration(host="http://localhost:9090")
api_client.configuration = configuration
test_api = TestApi(api_client)
print(test_api.get_test(3232))
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 __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 __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 __delete_import_error(self, import_error_id, **kwargs):
"""Delete an import error # 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_import_error(import_error_id, async_req=True)
>>> result = thread.get()
Args:
import_error_id (int): The Import Error ID.
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['import_error_id'] = \
import_error_id
return self.call_with_http_info(**kwargs)
self.delete_import_error = Endpoint(settings={
'response_type': None,
'auth': [],
'endpoint_path': '/importErrors/{import_error_id}',
'operation_id': 'delete_import_error',
'http_method': 'DELETE',
'servers': [],
},
params_map={
'all': [
'import_error_id',
],
'required': [
'import_error_id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'import_error_id': (int, ),
},
'attribute_map': {
'import_error_id':
'import_error_id',
},
'location_map': {
'import_error_id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__delete_import_error)
def __get_import_error(self, import_error_id, **kwargs):
"""Get an import error # 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_import_error(import_error_id, async_req=True)
>>> result = thread.get()
Args:
import_error_id (int): The Import Error ID.
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
import_error.ImportError
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['import_error_id'] = \
import_error_id
return self.call_with_http_info(**kwargs)
self.get_import_error = Endpoint(settings={
'response_type': (import_error.ImportError, ),
'auth': [],
'endpoint_path':
'/importErrors/{import_error_id}',
'operation_id':
'get_import_error',
'http_method':
'GET',
'servers': [],
},
params_map={
'all': [
'import_error_id',
],
'required': [
'import_error_id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'import_error_id': (int, ),
},
'attribute_map': {
'import_error_id':
'import_error_id',
},
'location_map': {
'import_error_id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_import_error)
def __get_import_errors(self, **kwargs):
"""Get all import errors # 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_import_errors(async_req=True)
>>> result = thread.get()
Keyword Args:
limit (int): The numbers of items to return.. [optional] if omitted the server will use the default value of 100
offset (int): The number of items to skip before starting to collect the result set.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
import_error_collection.ImportErrorCollection
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
return self.call_with_http_info(**kwargs)
self.get_import_errors = Endpoint(settings={
'response_type': (import_error_collection.ImportErrorCollection, ),
'auth': [],
'endpoint_path':
'/importErrors',
'operation_id':
'get_import_errors',
'http_method':
'GET',
'servers': [],
},
params_map={
'all': [
'limit',
'offset',
],
'required': [],
'nullable': [],
'enum': [],
'validation': [
'limit',
'offset',
]
},
root_map={
'validations': {
('limit', ): {
'inclusive_minimum': 1,
},
('offset', ): {
'inclusive_minimum': 0,
},
},
'allowed_values': {},
'openapi_types': {
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_import_errors)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __ban_test(
self,
ban_test_action_ban_test_action,
**kwargs
):
"""Test ban settings # noqa: E501
Send the phone number to find out if the instance is banning it # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.ban_test(ban_test_action_ban_test_action, async_req=True)
>>> result = thread.get()
Args:
ban_test_action_ban_test_action (ban_test_action.BanTestAction):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
ban_test_status.BanTestStatus
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['ban_test_action_ban_test_action'] = \
ban_test_action_ban_test_action
return self.call_with_http_info(**kwargs)
self.ban_test = Endpoint(
settings={
'response_type': (ban_test_status.BanTestStatus,),
'auth': [
'instanceId',
'token'
],
'endpoint_path': '/banTest',
'operation_id': 'ban_test',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'ban_test_action_ban_test_action',
],
'required': [
'ban_test_action_ban_test_action',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'ban_test_action_ban_test_action':
(ban_test_action.BanTestAction,),
},
'attribute_map': {
},
'location_map': {
'ban_test_action_ban_test_action': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json',
'application/x-www-form-urlencoded'
]
},
api_client=api_client,
callable=__ban_test
)
def __get_ban_settings(
self,
**kwargs
):
"""Get settings # noqa: E501
**banPhoneMask** - Regular expression on which bans on numbers will be sent **preBanMessage** - Warning message If it is set, a message will be sent before sending the ban. # 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_ban_settings(async_req=True)
>>> result = thread.get()
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
ban_settings.BanSettings
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
return self.call_with_http_info(**kwargs)
self.get_ban_settings = Endpoint(
settings={
'response_type': (ban_settings.BanSettings,),
'auth': [
'instanceId',
'token'
],
'endpoint_path': '/banSettings',
'operation_id': 'get_ban_settings',
'http_method': 'GET',
'servers': [],
},
params_map={
'all': [
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
},
'attribute_map': {
},
'location_map': {
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__get_ban_settings
)
def __set_ban_settings(
self,
ban_settings_ban_settings,
**kwargs
):
"""Set settings # noqa: E501
**banPhoneMask** - Regular expression on which bans on numbers will be sent **preBanMessage** - Warning message If it is set, a message will be sent before sending the ban. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.set_ban_settings(ban_settings_ban_settings, async_req=True)
>>> result = thread.get()
Args:
ban_settings_ban_settings (ban_settings.BanSettings):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int): specifies the index of the server
that we want to use.
Default is 0.
async_req (bool): execute request asynchronously
Returns:
ban_settings.BanSettings
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_host_index'] = kwargs.get('_host_index', 0)
kwargs['ban_settings_ban_settings'] = \
ban_settings_ban_settings
return self.call_with_http_info(**kwargs)
self.set_ban_settings = Endpoint(
settings={
'response_type': (ban_settings.BanSettings,),
'auth': [
'instanceId',
'token'
],
'endpoint_path': '/banSettings',
'operation_id': 'set_ban_settings',
'http_method': 'POST',
'servers': [],
},
params_map={
'all': [
'ban_settings_ban_settings',
],
'required': [
'ban_settings_ban_settings',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'ban_settings_ban_settings':
(ban_settings.BanSettings,),
},
'attribute_map': {
},
'location_map': {
'ban_settings_ban_settings': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json',
'application/x-www-form-urlencoded'
]
},
api_client=api_client,
callable=__set_ban_settings
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __info_service_get_info(
self,
**kwargs
):
"""info_service_get_info # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.info_service_get_info(async_req=True)
>>> result = thread.get()
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (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:
IoArgoprojWorkflowV1alpha1InfoResponse
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.info_service_get_info = _Endpoint(
settings={
'response_type': (IoArgoprojWorkflowV1alpha1InfoResponse,),
'auth': [],
'endpoint_path': '/api/v1/info',
'operation_id': 'info_service_get_info',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
},
'attribute_map': {
},
'location_map': {
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__info_service_get_info
)
def __info_service_get_user_info(
self,
**kwargs
):
"""info_service_get_user_info # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.info_service_get_user_info(async_req=True)
>>> result = thread.get()
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (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:
IoArgoprojWorkflowV1alpha1GetUserInfoResponse
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.info_service_get_user_info = _Endpoint(
settings={
'response_type': (IoArgoprojWorkflowV1alpha1GetUserInfoResponse,),
'auth': [],
'endpoint_path': '/api/v1/userinfo',
'operation_id': 'info_service_get_user_info',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
},
'attribute_map': {
},
'location_map': {
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__info_service_get_user_info
)
def __info_service_get_version(
self,
**kwargs
):
"""info_service_get_version # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.info_service_get_version(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 (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:
IoArgoprojWorkflowV1alpha1Version
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.info_service_get_version = _Endpoint(
settings={
'response_type': (IoArgoprojWorkflowV1alpha1Version,),
'auth': [],
'endpoint_path': '/api/v1/version',
'operation_id': 'info_service_get_version',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
},
'attribute_map': {
},
'location_map': {
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__info_service_get_version
)
