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 )