docusign_esign.apis.bulk_process_data_api

  1# coding: utf-8
  2
  3"""
  4    Docusign eSignature REST API
  5
  6    The Docusign eSignature REST API provides you with a powerful, convenient, and simple Web services API for interacting with Docusign.  # noqa: E501
  7
  8    OpenAPI spec version: v2.1
  9    Contact: devcenter@docusign.com
 10    Generated by: https://github.com/swagger-api/swagger-codegen.git
 11"""
 12
 13
 14from __future__ import absolute_import
 15
 16import sys
 17import os
 18import re
 19
 20# python 2 and python 3 compatibility library
 21from six import iteritems
 22
 23from ..client.configuration import Configuration
 24from ..client.api_client import ApiClient
 25
 26
 27class BulkProcessDataApi(object):
 28    """
 29    NOTE: This class is auto generated by the swagger code generator program.
 30    Do not edit the class manually.
 31    Ref: https://github.com/swagger-api/swagger-codegen
 32    """
 33
 34    def __init__(self, api_client=None):
 35        config = Configuration()
 36        if api_client:
 37            self.api_client = api_client
 38        else:
 39            if not config.api_client:
 40                config.api_client = ApiClient()
 41            self.api_client = config.api_client
 42
 43    def create_bulk_process_request(self, account_id, process_action, **kwargs):
 44        """
 45        Uses the specified bulk envelopes list to update the envelopes specified in the payload
 46        
 47        This method makes a synchronous HTTP request by default. To make an
 48        asynchronous HTTP request, please define a `callback` function
 49        to be invoked when receiving the response.
 50        >>> def callback_function(response):
 51        >>>     pprint(response)
 52        >>>
 53        >>> thread = api.create_bulk_process_request(account_id, process_action, callback=callback_function)
 54
 55        :param callback function: The callback function
 56            for asynchronous request. (optional)
 57        :param str account_id: The external account number (int) or account ID Guid. (required)
 58        :param str process_action: (required)
 59        :return: None
 60                 If the method is called asynchronously,
 61                 returns the request thread.
 62        """
 63        kwargs['_return_http_data_only'] = True
 64        if kwargs.get('callback'):
 65            return self.create_bulk_process_request_with_http_info(account_id, process_action, **kwargs)
 66        else:
 67            (data) = self.create_bulk_process_request_with_http_info(account_id, process_action, **kwargs)
 68            return data
 69
 70    def create_bulk_process_request_with_http_info(self, account_id, process_action, **kwargs):
 71        """
 72        Uses the specified bulk envelopes list to update the envelopes specified in the payload
 73        
 74        This method makes a synchronous HTTP request by default. To make an
 75        asynchronous HTTP request, please define a `callback` function
 76        to be invoked when receiving the response.
 77        >>> def callback_function(response):
 78        >>>     pprint(response)
 79        >>>
 80        >>> thread = api.create_bulk_process_request_with_http_info(account_id, process_action, callback=callback_function)
 81
 82        :param callback function: The callback function
 83            for asynchronous request. (optional)
 84        :param str account_id: The external account number (int) or account ID Guid. (required)
 85        :param str process_action: (required)
 86        :return: None
 87                 If the method is called asynchronously,
 88                 returns the request thread.
 89        """
 90
 91        all_params = ['account_id', 'process_action']
 92        all_params.append('callback')
 93        all_params.append('_return_http_data_only')
 94        all_params.append('_preload_content')
 95        all_params.append('_request_timeout')
 96
 97        params = locals()
 98        for key, val in iteritems(params['kwargs']):
 99            if key not in all_params:
100                raise TypeError(
101                    "Got an unexpected keyword argument '%s'"
102                    " to method create_bulk_process_request" % key
103                )
104            params[key] = val
105        del params['kwargs']
106        # verify the required parameter 'account_id' is set
107        if ('account_id' not in params) or (params['account_id'] is None):
108            raise ValueError("Missing the required parameter `account_id` when calling `create_bulk_process_request`")
109        # verify the required parameter 'process_action' is set
110        if ('process_action' not in params) or (params['process_action'] is None):
111            raise ValueError("Missing the required parameter `process_action` when calling `create_bulk_process_request`")
112
113
114        collection_formats = {}
115
116        resource_path = '/v2.1/accounts/{accountId}/bulk_process_data/actions/{processAction}'.replace('{format}', 'json')
117        path_params = {}
118        if 'account_id' in params:
119            path_params['accountId'] = params['account_id']
120        if 'process_action' in params:
121            path_params['processAction'] = params['process_action']
122
123        query_params = {}
124
125        header_params = {}
126
127        form_params = []
128        local_var_files = {}
129
130        body_params = None
131        # HTTP header `Accept`
132        header_params['Accept'] = self.api_client.\
133            select_header_accept(['application/json'])
134
135        # Authentication setting
136        auth_settings = []
137
138        return self.api_client.call_api(resource_path, 'POST',
139                                        path_params,
140                                        query_params,
141                                        header_params,
142                                        body=body_params,
143                                        post_params=form_params,
144                                        files=local_var_files,
145                                        response_type=None,
146                                        auth_settings=auth_settings,
147                                        callback=params.get('callback'),
148                                        _return_http_data_only=params.get('_return_http_data_only'),
149                                        _preload_content=params.get('_preload_content', True),
150                                        _request_timeout=params.get('_request_timeout'),
151                                        collection_formats=collection_formats)
152
153    def create_bulk_process_request_to_queue(self, account_id, bulk_process_list_id, process_action, **kwargs):
154        """
155        Uses the specified bulk envelopes list to update the envelopes specified in the payload
156        
157        This method makes a synchronous HTTP request by default. To make an
158        asynchronous HTTP request, please define a `callback` function
159        to be invoked when receiving the response.
160        >>> def callback_function(response):
161        >>>     pprint(response)
162        >>>
163        >>> thread = api.create_bulk_process_request_to_queue(account_id, bulk_process_list_id, process_action, callback=callback_function)
164
165        :param callback function: The callback function
166            for asynchronous request. (optional)
167        :param str account_id: The external account number (int) or account ID Guid. (required)
168        :param str bulk_process_list_id: (required)
169        :param str process_action: (required)
170        :param BulkProcessRequest bulk_process_request:
171        :return: BulkProcessResponse
172                 If the method is called asynchronously,
173                 returns the request thread.
174        """
175        kwargs['_return_http_data_only'] = True
176        if kwargs.get('callback'):
177            return self.create_bulk_process_request_to_queue_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
178        else:
179            (data) = self.create_bulk_process_request_to_queue_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
180            return data
181
182    def create_bulk_process_request_to_queue_with_http_info(self, account_id, bulk_process_list_id, process_action, **kwargs):
183        """
184        Uses the specified bulk envelopes list to update the envelopes specified in the payload
185        
186        This method makes a synchronous HTTP request by default. To make an
187        asynchronous HTTP request, please define a `callback` function
188        to be invoked when receiving the response.
189        >>> def callback_function(response):
190        >>>     pprint(response)
191        >>>
192        >>> thread = api.create_bulk_process_request_to_queue_with_http_info(account_id, bulk_process_list_id, process_action, callback=callback_function)
193
194        :param callback function: The callback function
195            for asynchronous request. (optional)
196        :param str account_id: The external account number (int) or account ID Guid. (required)
197        :param str bulk_process_list_id: (required)
198        :param str process_action: (required)
199        :param BulkProcessRequest bulk_process_request:
200        :return: BulkProcessResponse
201                 If the method is called asynchronously,
202                 returns the request thread.
203        """
204
205        all_params = ['account_id', 'bulk_process_list_id', 'process_action', 'bulk_process_request']
206        all_params.append('callback')
207        all_params.append('_return_http_data_only')
208        all_params.append('_preload_content')
209        all_params.append('_request_timeout')
210
211        params = locals()
212        for key, val in iteritems(params['kwargs']):
213            if key not in all_params:
214                raise TypeError(
215                    "Got an unexpected keyword argument '%s'"
216                    " to method create_bulk_process_request_to_queue" % key
217                )
218            params[key] = val
219        del params['kwargs']
220        # verify the required parameter 'account_id' is set
221        if ('account_id' not in params) or (params['account_id'] is None):
222            raise ValueError("Missing the required parameter `account_id` when calling `create_bulk_process_request_to_queue`")
223        # verify the required parameter 'bulk_process_list_id' is set
224        if ('bulk_process_list_id' not in params) or (params['bulk_process_list_id'] is None):
225            raise ValueError("Missing the required parameter `bulk_process_list_id` when calling `create_bulk_process_request_to_queue`")
226        # verify the required parameter 'process_action' is set
227        if ('process_action' not in params) or (params['process_action'] is None):
228            raise ValueError("Missing the required parameter `process_action` when calling `create_bulk_process_request_to_queue`")
229
230
231        collection_formats = {}
232
233        resource_path = '/v2.1/accounts/{accountId}/bulk_process_data/actions/{processAction}/{bulkProcessListId}'.replace('{format}', 'json')
234        path_params = {}
235        if 'account_id' in params:
236            path_params['accountId'] = params['account_id']
237        if 'bulk_process_list_id' in params:
238            path_params['bulkProcessListId'] = params['bulk_process_list_id']
239        if 'process_action' in params:
240            path_params['processAction'] = params['process_action']
241
242        query_params = {}
243
244        header_params = {}
245
246        form_params = []
247        local_var_files = {}
248
249        body_params = None
250        if 'bulk_process_request' in params:
251            body_params = params['bulk_process_request']
252        # HTTP header `Accept`
253        header_params['Accept'] = self.api_client.\
254            select_header_accept(['application/json'])
255
256        # Authentication setting
257        auth_settings = []
258
259        return self.api_client.call_api(resource_path, 'POST',
260                                        path_params,
261                                        query_params,
262                                        header_params,
263                                        body=body_params,
264                                        post_params=form_params,
265                                        files=local_var_files,
266                                        response_type='BulkProcessResponse',
267                                        auth_settings=auth_settings,
268                                        callback=params.get('callback'),
269                                        _return_http_data_only=params.get('_return_http_data_only'),
270                                        _preload_content=params.get('_preload_content', True),
271                                        _request_timeout=params.get('_request_timeout'),
272                                        collection_formats=collection_formats)
273
274    def delete_bulk_process_list(self, account_id, bulk_process_list_id, process_action, **kwargs):
275        """
276        Deletes a specific bulk process list
277        
278        This method makes a synchronous HTTP request by default. To make an
279        asynchronous HTTP request, please define a `callback` function
280        to be invoked when receiving the response.
281        >>> def callback_function(response):
282        >>>     pprint(response)
283        >>>
284        >>> thread = api.delete_bulk_process_list(account_id, bulk_process_list_id, process_action, callback=callback_function)
285
286        :param callback function: The callback function
287            for asynchronous request. (optional)
288        :param str account_id: The external account number (int) or account ID Guid. (required)
289        :param str bulk_process_list_id: (required)
290        :param str process_action: (required)
291        :return: BulkProcessResult
292                 If the method is called asynchronously,
293                 returns the request thread.
294        """
295        kwargs['_return_http_data_only'] = True
296        if kwargs.get('callback'):
297            return self.delete_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
298        else:
299            (data) = self.delete_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
300            return data
301
302    def delete_bulk_process_list_with_http_info(self, account_id, bulk_process_list_id, process_action, **kwargs):
303        """
304        Deletes a specific bulk process list
305        
306        This method makes a synchronous HTTP request by default. To make an
307        asynchronous HTTP request, please define a `callback` function
308        to be invoked when receiving the response.
309        >>> def callback_function(response):
310        >>>     pprint(response)
311        >>>
312        >>> thread = api.delete_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, callback=callback_function)
313
314        :param callback function: The callback function
315            for asynchronous request. (optional)
316        :param str account_id: The external account number (int) or account ID Guid. (required)
317        :param str bulk_process_list_id: (required)
318        :param str process_action: (required)
319        :return: BulkProcessResult
320                 If the method is called asynchronously,
321                 returns the request thread.
322        """
323
324        all_params = ['account_id', 'bulk_process_list_id', 'process_action']
325        all_params.append('callback')
326        all_params.append('_return_http_data_only')
327        all_params.append('_preload_content')
328        all_params.append('_request_timeout')
329
330        params = locals()
331        for key, val in iteritems(params['kwargs']):
332            if key not in all_params:
333                raise TypeError(
334                    "Got an unexpected keyword argument '%s'"
335                    " to method delete_bulk_process_list" % key
336                )
337            params[key] = val
338        del params['kwargs']
339        # verify the required parameter 'account_id' is set
340        if ('account_id' not in params) or (params['account_id'] is None):
341            raise ValueError("Missing the required parameter `account_id` when calling `delete_bulk_process_list`")
342        # verify the required parameter 'bulk_process_list_id' is set
343        if ('bulk_process_list_id' not in params) or (params['bulk_process_list_id'] is None):
344            raise ValueError("Missing the required parameter `bulk_process_list_id` when calling `delete_bulk_process_list`")
345        # verify the required parameter 'process_action' is set
346        if ('process_action' not in params) or (params['process_action'] is None):
347            raise ValueError("Missing the required parameter `process_action` when calling `delete_bulk_process_list`")
348
349
350        collection_formats = {}
351
352        resource_path = '/v2.1/accounts/{accountId}/bulk_process_data/actions/{processAction}/{bulkProcessListId}'.replace('{format}', 'json')
353        path_params = {}
354        if 'account_id' in params:
355            path_params['accountId'] = params['account_id']
356        if 'bulk_process_list_id' in params:
357            path_params['bulkProcessListId'] = params['bulk_process_list_id']
358        if 'process_action' in params:
359            path_params['processAction'] = params['process_action']
360
361        query_params = {}
362
363        header_params = {}
364
365        form_params = []
366        local_var_files = {}
367
368        body_params = None
369        # HTTP header `Accept`
370        header_params['Accept'] = self.api_client.\
371            select_header_accept(['application/json'])
372
373        # Authentication setting
374        auth_settings = []
375
376        return self.api_client.call_api(resource_path, 'DELETE',
377                                        path_params,
378                                        query_params,
379                                        header_params,
380                                        body=body_params,
381                                        post_params=form_params,
382                                        files=local_var_files,
383                                        response_type='BulkProcessResult',
384                                        auth_settings=auth_settings,
385                                        callback=params.get('callback'),
386                                        _return_http_data_only=params.get('_return_http_data_only'),
387                                        _preload_content=params.get('_preload_content', True),
388                                        _request_timeout=params.get('_request_timeout'),
389                                        collection_formats=collection_formats)
390
391    def delete_bulk_process_lists(self, account_id, process_action, **kwargs):
392        """
393        Deletes a specific bulk process list
394        
395        This method makes a synchronous HTTP request by default. To make an
396        asynchronous HTTP request, please define a `callback` function
397        to be invoked when receiving the response.
398        >>> def callback_function(response):
399        >>>     pprint(response)
400        >>>
401        >>> thread = api.delete_bulk_process_lists(account_id, process_action, callback=callback_function)
402
403        :param callback function: The callback function
404            for asynchronous request. (optional)
405        :param str account_id: The external account number (int) or account ID Guid. (required)
406        :param str process_action: (required)
407        :param BulkProcessingLists bulk_processing_lists:
408        :return: BulkProcessResult
409                 If the method is called asynchronously,
410                 returns the request thread.
411        """
412        kwargs['_return_http_data_only'] = True
413        if kwargs.get('callback'):
414            return self.delete_bulk_process_lists_with_http_info(account_id, process_action, **kwargs)
415        else:
416            (data) = self.delete_bulk_process_lists_with_http_info(account_id, process_action, **kwargs)
417            return data
418
419    def delete_bulk_process_lists_with_http_info(self, account_id, process_action, **kwargs):
420        """
421        Deletes a specific bulk process list
422        
423        This method makes a synchronous HTTP request by default. To make an
424        asynchronous HTTP request, please define a `callback` function
425        to be invoked when receiving the response.
426        >>> def callback_function(response):
427        >>>     pprint(response)
428        >>>
429        >>> thread = api.delete_bulk_process_lists_with_http_info(account_id, process_action, callback=callback_function)
430
431        :param callback function: The callback function
432            for asynchronous request. (optional)
433        :param str account_id: The external account number (int) or account ID Guid. (required)
434        :param str process_action: (required)
435        :param BulkProcessingLists bulk_processing_lists:
436        :return: BulkProcessResult
437                 If the method is called asynchronously,
438                 returns the request thread.
439        """
440
441        all_params = ['account_id', 'process_action', 'bulk_processing_lists']
442        all_params.append('callback')
443        all_params.append('_return_http_data_only')
444        all_params.append('_preload_content')
445        all_params.append('_request_timeout')
446
447        params = locals()
448        for key, val in iteritems(params['kwargs']):
449            if key not in all_params:
450                raise TypeError(
451                    "Got an unexpected keyword argument '%s'"
452                    " to method delete_bulk_process_lists" % key
453                )
454            params[key] = val
455        del params['kwargs']
456        # verify the required parameter 'account_id' is set
457        if ('account_id' not in params) or (params['account_id'] is None):
458            raise ValueError("Missing the required parameter `account_id` when calling `delete_bulk_process_lists`")
459        # verify the required parameter 'process_action' is set
460        if ('process_action' not in params) or (params['process_action'] is None):
461            raise ValueError("Missing the required parameter `process_action` when calling `delete_bulk_process_lists`")
462
463
464        collection_formats = {}
465
466        resource_path = '/v2.1/accounts/{accountId}/bulk_process_data/actions/{processAction}'.replace('{format}', 'json')
467        path_params = {}
468        if 'account_id' in params:
469            path_params['accountId'] = params['account_id']
470        if 'process_action' in params:
471            path_params['processAction'] = params['process_action']
472
473        query_params = {}
474
475        header_params = {}
476
477        form_params = []
478        local_var_files = {}
479
480        body_params = None
481        if 'bulk_processing_lists' in params:
482            body_params = params['bulk_processing_lists']
483        # HTTP header `Accept`
484        header_params['Accept'] = self.api_client.\
485            select_header_accept(['application/json'])
486
487        # Authentication setting
488        auth_settings = []
489
490        return self.api_client.call_api(resource_path, 'DELETE',
491                                        path_params,
492                                        query_params,
493                                        header_params,
494                                        body=body_params,
495                                        post_params=form_params,
496                                        files=local_var_files,
497                                        response_type='BulkProcessResult',
498                                        auth_settings=auth_settings,
499                                        callback=params.get('callback'),
500                                        _return_http_data_only=params.get('_return_http_data_only'),
501                                        _preload_content=params.get('_preload_content', True),
502                                        _request_timeout=params.get('_request_timeout'),
503                                        collection_formats=collection_formats)
504
505    def get_bulk_process_list(self, account_id, bulk_process_list_id, process_action, **kwargs):
506        """
507        Gets a specific bulk process list
508        
509        This method makes a synchronous HTTP request by default. To make an
510        asynchronous HTTP request, please define a `callback` function
511        to be invoked when receiving the response.
512        >>> def callback_function(response):
513        >>>     pprint(response)
514        >>>
515        >>> thread = api.get_bulk_process_list(account_id, bulk_process_list_id, process_action, callback=callback_function)
516
517        :param callback function: The callback function
518            for asynchronous request. (optional)
519        :param str account_id: The external account number (int) or account ID Guid. (required)
520        :param str bulk_process_list_id: (required)
521        :param str process_action: (required)
522        :return: None
523                 If the method is called asynchronously,
524                 returns the request thread.
525        """
526        kwargs['_return_http_data_only'] = True
527        if kwargs.get('callback'):
528            return self.get_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
529        else:
530            (data) = self.get_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
531            return data
532
533    def get_bulk_process_list_with_http_info(self, account_id, bulk_process_list_id, process_action, **kwargs):
534        """
535        Gets a specific bulk process list
536        
537        This method makes a synchronous HTTP request by default. To make an
538        asynchronous HTTP request, please define a `callback` function
539        to be invoked when receiving the response.
540        >>> def callback_function(response):
541        >>>     pprint(response)
542        >>>
543        >>> thread = api.get_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, callback=callback_function)
544
545        :param callback function: The callback function
546            for asynchronous request. (optional)
547        :param str account_id: The external account number (int) or account ID Guid. (required)
548        :param str bulk_process_list_id: (required)
549        :param str process_action: (required)
550        :return: None
551                 If the method is called asynchronously,
552                 returns the request thread.
553        """
554
555        all_params = ['account_id', 'bulk_process_list_id', 'process_action']
556        all_params.append('callback')
557        all_params.append('_return_http_data_only')
558        all_params.append('_preload_content')
559        all_params.append('_request_timeout')
560
561        params = locals()
562        for key, val in iteritems(params['kwargs']):
563            if key not in all_params:
564                raise TypeError(
565                    "Got an unexpected keyword argument '%s'"
566                    " to method get_bulk_process_list" % key
567                )
568            params[key] = val
569        del params['kwargs']
570        # verify the required parameter 'account_id' is set
571        if ('account_id' not in params) or (params['account_id'] is None):
572            raise ValueError("Missing the required parameter `account_id` when calling `get_bulk_process_list`")
573        # verify the required parameter 'bulk_process_list_id' is set
574        if ('bulk_process_list_id' not in params) or (params['bulk_process_list_id'] is None):
575            raise ValueError("Missing the required parameter `bulk_process_list_id` when calling `get_bulk_process_list`")
576        # verify the required parameter 'process_action' is set
577        if ('process_action' not in params) or (params['process_action'] is None):
578            raise ValueError("Missing the required parameter `process_action` when calling `get_bulk_process_list`")
579
580
581        collection_formats = {}
582
583        resource_path = '/v2.1/accounts/{accountId}/bulk_process_data/actions/{processAction}/{bulkProcessListId}'.replace('{format}', 'json')
584        path_params = {}
585        if 'account_id' in params:
586            path_params['accountId'] = params['account_id']
587        if 'bulk_process_list_id' in params:
588            path_params['bulkProcessListId'] = params['bulk_process_list_id']
589        if 'process_action' in params:
590            path_params['processAction'] = params['process_action']
591
592        query_params = {}
593
594        header_params = {}
595
596        form_params = []
597        local_var_files = {}
598
599        body_params = None
600        # HTTP header `Accept`
601        header_params['Accept'] = self.api_client.\
602            select_header_accept(['application/json'])
603
604        # Authentication setting
605        auth_settings = []
606
607        return self.api_client.call_api(resource_path, 'GET',
608                                        path_params,
609                                        query_params,
610                                        header_params,
611                                        body=body_params,
612                                        post_params=form_params,
613                                        files=local_var_files,
614                                        response_type=None,
615                                        auth_settings=auth_settings,
616                                        callback=params.get('callback'),
617                                        _return_http_data_only=params.get('_return_http_data_only'),
618                                        _preload_content=params.get('_preload_content', True),
619                                        _request_timeout=params.get('_request_timeout'),
620                                        collection_formats=collection_formats)
621
622    def get_bulk_process_lists(self, account_id, process_action, **kwargs):
623        """
624        Lists top-level details for all bulk process lists visible to the current user
625        
626        This method makes a synchronous HTTP request by default. To make an
627        asynchronous HTTP request, please define a `callback` function
628        to be invoked when receiving the response.
629        >>> def callback_function(response):
630        >>>     pprint(response)
631        >>>
632        >>> thread = api.get_bulk_process_lists(account_id, process_action, callback=callback_function)
633
634        :param callback function: The callback function
635            for asynchronous request. (optional)
636        :param str account_id: The external account number (int) or account ID Guid. (required)
637        :param str process_action: (required)
638        :return: BulkProcessingListSummaries
639                 If the method is called asynchronously,
640                 returns the request thread.
641        """
642        kwargs['_return_http_data_only'] = True
643        if kwargs.get('callback'):
644            return self.get_bulk_process_lists_with_http_info(account_id, process_action, **kwargs)
645        else:
646            (data) = self.get_bulk_process_lists_with_http_info(account_id, process_action, **kwargs)
647            return data
648
649    def get_bulk_process_lists_with_http_info(self, account_id, process_action, **kwargs):
650        """
651        Lists top-level details for all bulk process lists visible to the current user
652        
653        This method makes a synchronous HTTP request by default. To make an
654        asynchronous HTTP request, please define a `callback` function
655        to be invoked when receiving the response.
656        >>> def callback_function(response):
657        >>>     pprint(response)
658        >>>
659        >>> thread = api.get_bulk_process_lists_with_http_info(account_id, process_action, callback=callback_function)
660
661        :param callback function: The callback function
662            for asynchronous request. (optional)
663        :param str account_id: The external account number (int) or account ID Guid. (required)
664        :param str process_action: (required)
665        :return: BulkProcessingListSummaries
666                 If the method is called asynchronously,
667                 returns the request thread.
668        """
669
670        all_params = ['account_id', 'process_action']
671        all_params.append('callback')
672        all_params.append('_return_http_data_only')
673        all_params.append('_preload_content')
674        all_params.append('_request_timeout')
675
676        params = locals()
677        for key, val in iteritems(params['kwargs']):
678            if key not in all_params:
679                raise TypeError(
680                    "Got an unexpected keyword argument '%s'"
681                    " to method get_bulk_process_lists" % key
682                )
683            params[key] = val
684        del params['kwargs']
685        # verify the required parameter 'account_id' is set
686        if ('account_id' not in params) or (params['account_id'] is None):
687            raise ValueError("Missing the required parameter `account_id` when calling `get_bulk_process_lists`")
688        # verify the required parameter 'process_action' is set
689        if ('process_action' not in params) or (params['process_action'] is None):
690            raise ValueError("Missing the required parameter `process_action` when calling `get_bulk_process_lists`")
691
692
693        collection_formats = {}
694
695        resource_path = '/v2.1/accounts/{accountId}/bulk_process_data/actions/{processAction}'.replace('{format}', 'json')
696        path_params = {}
697        if 'account_id' in params:
698            path_params['accountId'] = params['account_id']
699        if 'process_action' in params:
700            path_params['processAction'] = params['process_action']
701
702        query_params = {}
703
704        header_params = {}
705
706        form_params = []
707        local_var_files = {}
708
709        body_params = None
710        # HTTP header `Accept`
711        header_params['Accept'] = self.api_client.\
712            select_header_accept(['application/json'])
713
714        # Authentication setting
715        auth_settings = []
716
717        return self.api_client.call_api(resource_path, 'GET',
718                                        path_params,
719                                        query_params,
720                                        header_params,
721                                        body=body_params,
722                                        post_params=form_params,
723                                        files=local_var_files,
724                                        response_type='BulkProcessingListSummaries',
725                                        auth_settings=auth_settings,
726                                        callback=params.get('callback'),
727                                        _return_http_data_only=params.get('_return_http_data_only'),
728                                        _preload_content=params.get('_preload_content', True),
729                                        _request_timeout=params.get('_request_timeout'),
730                                        collection_formats=collection_formats)
731
732    def update_bulk_process_list(self, account_id, bulk_process_list_id, process_action, **kwargs):
733        """
734        Updates a specific bulk process list
735        
736        This method makes a synchronous HTTP request by default. To make an
737        asynchronous HTTP request, please define a `callback` function
738        to be invoked when receiving the response.
739        >>> def callback_function(response):
740        >>>     pprint(response)
741        >>>
742        >>> thread = api.update_bulk_process_list(account_id, bulk_process_list_id, process_action, callback=callback_function)
743
744        :param callback function: The callback function
745            for asynchronous request. (optional)
746        :param str account_id: The external account number (int) or account ID Guid. (required)
747        :param str bulk_process_list_id: (required)
748        :param str process_action: (required)
749        :return: None
750                 If the method is called asynchronously,
751                 returns the request thread.
752        """
753        kwargs['_return_http_data_only'] = True
754        if kwargs.get('callback'):
755            return self.update_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
756        else:
757            (data) = self.update_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, **kwargs)
758            return data
759
760    def update_bulk_process_list_with_http_info(self, account_id, bulk_process_list_id, process_action, **kwargs):
761        """
762        Updates a specific bulk process list
763        
764        This method makes a synchronous HTTP request by default. To make an
765        asynchronous HTTP request, please define a `callback` function
766        to be invoked when receiving the response.
767        >>> def callback_function(response):
768        >>>     pprint(response)
769        >>>
770        >>> thread = api.update_bulk_process_list_with_http_info(account_id, bulk_process_list_id, process_action, callback=callback_function)
771
772        :param callback function: The callback function
773            for asynchronous request. (optional)
774        :param str account_id: The external account number (int) or account ID Guid. (required)
775        :param str bulk_process_list_id: (required)
776        :param str process_action: (required)
777        :return: None
778                 If the method is called asynchronously,
779                 returns the request thread.
780        """
781
782        all_params = ['account_id', 'bulk_process_list_id', 'process_action']
783        all_params.append('callback')
784        all_params.append('_return_http_data_only')
785        all_params.append('_preload_content')
786        all_params.append('_request_timeout')
787
788        params = locals()
789        for key, val in iteritems(params['kwargs']):
790            if key not in all_params:
791                raise TypeError(
792                    "Got an unexpected keyword argument '%s'"
793                    " to method update_bulk_process_list" % key
794                )
795            params[key] = val
796        del params['kwargs']
797        # verify the required parameter 'account_id' is set
798        if ('account_id' not in params) or (params['account_id'] is None):
799            raise ValueError("Missing the required parameter `account_id` when calling `update_bulk_process_list`")
800        # verify the required parameter 'bulk_process_list_id' is set
801        if ('bulk_process_list_id' not in params) or (params['bulk_process_list_id'] is None):
802            raise ValueError("Missing the required parameter `bulk_process_list_id` when calling `update_bulk_process_list`")
803        # verify the required parameter 'process_action' is set
804        if ('process_action' not in params) or (params['process_action'] is None):
805            raise ValueError("Missing the required parameter `process_action` when calling `update_bulk_process_list`")
806
807
808        collection_formats = {}
809
810        resource_path = '/v2.1/accounts/{accountId}/bulk_process_data/actions/{processAction}/{bulkProcessListId}'.replace('{format}', 'json')
811        path_params = {}
812        if 'account_id' in params:
813            path_params['accountId'] = params['account_id']
814        if 'bulk_process_list_id' in params:
815            path_params['bulkProcessListId'] = params['bulk_process_list_id']
816        if 'process_action' in params:
817            path_params['processAction'] = params['process_action']
818
819        query_params = {}
820
821        header_params = {}
822
823        form_params = []
824        local_var_files = {}
825
826        body_params = None
827        # HTTP header `Accept`
828        header_params['Accept'] = self.api_client.\
829            select_header_accept(['application/json'])
830
831        # Authentication setting
832        auth_settings = []
833
834        return self.api_client.call_api(resource_path, 'PUT',
835                                        path_params,
836                                        query_params,
837                                        header_params,
838                                        body=body_params,
839                                        post_params=form_params,
840                                        files=local_var_files,
841                                        response_type=None,
842                                        auth_settings=auth_settings,
843                                        callback=params.get('callback'),
844                                        _return_http_data_only=params.get('_return_http_data_only'),
845                                        _preload_content=params.get('_preload_content', True),
846                                        _request_timeout=params.get('_request_timeout'),
847                                        collection_formats=collection_formats)