github.com/filecoin-project/bacalhau@v0.3.23-0.20230228154132-45c989550ace/clients/python/bacalhau_apiclient/api/utils_api.py (about) 1 # coding: utf-8 2 3 """ 4 Bacalhau API 5 6 This page is the reference of the Bacalhau REST API. Project docs are available at https://docs.bacalhau.org/. Find more information about Bacalhau at https://github.com/filecoin-project/bacalhau. # noqa: E501 7 8 OpenAPI spec version: 0.3.22.post4 9 Contact: team@bacalhau.org 10 Generated by: https://github.com/swagger-api/swagger-codegen.git 11 """ 12 13 14 from __future__ import absolute_import 15 16 import re # noqa: F401 17 18 # python 2 and python 3 compatibility library 19 import six 20 21 from bacalhau_apiclient.api_client import ApiClient 22 23 24 class UtilsApi(object): 25 """NOTE: This class is auto generated by the swagger code generator program. 26 27 Do not edit the class manually. 28 Ref: https://github.com/swagger-api/swagger-codegen 29 """ 30 31 def __init__(self, api_client=None): 32 if api_client is None: 33 api_client = ApiClient() 34 self.api_client = api_client 35 36 def healthz(self, **kwargs): # noqa: E501 37 """healthz # noqa: E501 38 39 This method makes a synchronous HTTP request by default. To make an 40 asynchronous HTTP request, please pass async_req=True 41 >>> thread = api.healthz(async_req=True) 42 >>> result = thread.get() 43 44 :param async_req bool 45 :return: HealthInfo 46 If the method is called asynchronously, 47 returns the request thread. 48 """ 49 kwargs['_return_http_data_only'] = True 50 if kwargs.get('async_req'): 51 return self.healthz_with_http_info(**kwargs) # noqa: E501 52 else: 53 (data) = self.healthz_with_http_info(**kwargs) # noqa: E501 54 return data 55 56 def healthz_with_http_info(self, **kwargs): # noqa: E501 57 """healthz # noqa: E501 58 59 This method makes a synchronous HTTP request by default. To make an 60 asynchronous HTTP request, please pass async_req=True 61 >>> thread = api.healthz_with_http_info(async_req=True) 62 >>> result = thread.get() 63 64 :param async_req bool 65 :return: HealthInfo 66 If the method is called asynchronously, 67 returns the request thread. 68 """ 69 70 all_params = [] # noqa: E501 71 all_params.append('async_req') 72 all_params.append('_return_http_data_only') 73 all_params.append('_preload_content') 74 all_params.append('_request_timeout') 75 76 params = locals() 77 for key, val in six.iteritems(params['kwargs']): 78 if key not in all_params: 79 raise TypeError( 80 "Got an unexpected keyword argument '%s'" 81 " to method healthz" % key 82 ) 83 params[key] = val 84 del params['kwargs'] 85 86 collection_formats = {} 87 88 path_params = {} 89 90 query_params = [] 91 92 header_params = {} 93 94 form_params = [] 95 local_var_files = {} 96 97 body_params = None 98 # HTTP header `Accept` 99 header_params['Accept'] = self.api_client.select_header_accept( 100 ['application/json']) # noqa: E501 101 102 # Authentication setting 103 auth_settings = [] # noqa: E501 104 105 return self.api_client.call_api( 106 '/healthz', 'GET', 107 path_params, 108 query_params, 109 header_params, 110 body=body_params, 111 post_params=form_params, 112 files=local_var_files, 113 response_type='HealthInfo', # noqa: E501 114 auth_settings=auth_settings, 115 async_req=params.get('async_req'), 116 _return_http_data_only=params.get('_return_http_data_only'), 117 _preload_content=params.get('_preload_content', True), 118 _request_timeout=params.get('_request_timeout'), 119 collection_formats=collection_formats) 120 121 def id(self, **kwargs): # noqa: E501 122 """Returns the id of the host node. # noqa: E501 123 124 This method makes a synchronous HTTP request by default. To make an 125 asynchronous HTTP request, please pass async_req=True 126 >>> thread = api.id(async_req=True) 127 >>> result = thread.get() 128 129 :param async_req bool 130 :return: str 131 If the method is called asynchronously, 132 returns the request thread. 133 """ 134 kwargs['_return_http_data_only'] = True 135 if kwargs.get('async_req'): 136 return self.id_with_http_info(**kwargs) # noqa: E501 137 else: 138 (data) = self.id_with_http_info(**kwargs) # noqa: E501 139 return data 140 141 def id_with_http_info(self, **kwargs): # noqa: E501 142 """Returns the id of the host node. # noqa: E501 143 144 This method makes a synchronous HTTP request by default. To make an 145 asynchronous HTTP request, please pass async_req=True 146 >>> thread = api.id_with_http_info(async_req=True) 147 >>> result = thread.get() 148 149 :param async_req bool 150 :return: str 151 If the method is called asynchronously, 152 returns the request thread. 153 """ 154 155 all_params = [] # noqa: E501 156 all_params.append('async_req') 157 all_params.append('_return_http_data_only') 158 all_params.append('_preload_content') 159 all_params.append('_request_timeout') 160 161 params = locals() 162 for key, val in six.iteritems(params['kwargs']): 163 if key not in all_params: 164 raise TypeError( 165 "Got an unexpected keyword argument '%s'" 166 " to method id" % key 167 ) 168 params[key] = val 169 del params['kwargs'] 170 171 collection_formats = {} 172 173 path_params = {} 174 175 query_params = [] 176 177 header_params = {} 178 179 form_params = [] 180 local_var_files = {} 181 182 body_params = None 183 # HTTP header `Accept` 184 header_params['Accept'] = self.api_client.select_header_accept( 185 ['text/plain']) # noqa: E501 186 187 # Authentication setting 188 auth_settings = [] # noqa: E501 189 190 return self.api_client.call_api( 191 '/id', 'GET', 192 path_params, 193 query_params, 194 header_params, 195 body=body_params, 196 post_params=form_params, 197 files=local_var_files, 198 response_type='str', # noqa: E501 199 auth_settings=auth_settings, 200 async_req=params.get('async_req'), 201 _return_http_data_only=params.get('_return_http_data_only'), 202 _preload_content=params.get('_preload_content', True), 203 _request_timeout=params.get('_request_timeout'), 204 collection_formats=collection_formats) 205 206 def livez(self, **kwargs): # noqa: E501 207 """livez # noqa: E501 208 209 This method makes a synchronous HTTP request by default. To make an 210 asynchronous HTTP request, please pass async_req=True 211 >>> thread = api.livez(async_req=True) 212 >>> result = thread.get() 213 214 :param async_req bool 215 :return: str 216 If the method is called asynchronously, 217 returns the request thread. 218 """ 219 kwargs['_return_http_data_only'] = True 220 if kwargs.get('async_req'): 221 return self.livez_with_http_info(**kwargs) # noqa: E501 222 else: 223 (data) = self.livez_with_http_info(**kwargs) # noqa: E501 224 return data 225 226 def livez_with_http_info(self, **kwargs): # noqa: E501 227 """livez # noqa: E501 228 229 This method makes a synchronous HTTP request by default. To make an 230 asynchronous HTTP request, please pass async_req=True 231 >>> thread = api.livez_with_http_info(async_req=True) 232 >>> result = thread.get() 233 234 :param async_req bool 235 :return: str 236 If the method is called asynchronously, 237 returns the request thread. 238 """ 239 240 all_params = [] # noqa: E501 241 all_params.append('async_req') 242 all_params.append('_return_http_data_only') 243 all_params.append('_preload_content') 244 all_params.append('_request_timeout') 245 246 params = locals() 247 for key, val in six.iteritems(params['kwargs']): 248 if key not in all_params: 249 raise TypeError( 250 "Got an unexpected keyword argument '%s'" 251 " to method livez" % key 252 ) 253 params[key] = val 254 del params['kwargs'] 255 256 collection_formats = {} 257 258 path_params = {} 259 260 query_params = [] 261 262 header_params = {} 263 264 form_params = [] 265 local_var_files = {} 266 267 body_params = None 268 # HTTP header `Accept` 269 header_params['Accept'] = self.api_client.select_header_accept( 270 ['text/plain']) # noqa: E501 271 272 # Authentication setting 273 auth_settings = [] # noqa: E501 274 275 return self.api_client.call_api( 276 '/livez', 'GET', 277 path_params, 278 query_params, 279 header_params, 280 body=body_params, 281 post_params=form_params, 282 files=local_var_files, 283 response_type='str', # noqa: E501 284 auth_settings=auth_settings, 285 async_req=params.get('async_req'), 286 _return_http_data_only=params.get('_return_http_data_only'), 287 _preload_content=params.get('_preload_content', True), 288 _request_timeout=params.get('_request_timeout'), 289 collection_formats=collection_formats) 290 291 def logz(self, **kwargs): # noqa: E501 292 """logz # noqa: E501 293 294 This method makes a synchronous HTTP request by default. To make an 295 asynchronous HTTP request, please pass async_req=True 296 >>> thread = api.logz(async_req=True) 297 >>> result = thread.get() 298 299 :param async_req bool 300 :return: str 301 If the method is called asynchronously, 302 returns the request thread. 303 """ 304 kwargs['_return_http_data_only'] = True 305 if kwargs.get('async_req'): 306 return self.logz_with_http_info(**kwargs) # noqa: E501 307 else: 308 (data) = self.logz_with_http_info(**kwargs) # noqa: E501 309 return data 310 311 def logz_with_http_info(self, **kwargs): # noqa: E501 312 """logz # noqa: E501 313 314 This method makes a synchronous HTTP request by default. To make an 315 asynchronous HTTP request, please pass async_req=True 316 >>> thread = api.logz_with_http_info(async_req=True) 317 >>> result = thread.get() 318 319 :param async_req bool 320 :return: str 321 If the method is called asynchronously, 322 returns the request thread. 323 """ 324 325 all_params = [] # noqa: E501 326 all_params.append('async_req') 327 all_params.append('_return_http_data_only') 328 all_params.append('_preload_content') 329 all_params.append('_request_timeout') 330 331 params = locals() 332 for key, val in six.iteritems(params['kwargs']): 333 if key not in all_params: 334 raise TypeError( 335 "Got an unexpected keyword argument '%s'" 336 " to method logz" % key 337 ) 338 params[key] = val 339 del params['kwargs'] 340 341 collection_formats = {} 342 343 path_params = {} 344 345 query_params = [] 346 347 header_params = {} 348 349 form_params = [] 350 local_var_files = {} 351 352 body_params = None 353 # HTTP header `Accept` 354 header_params['Accept'] = self.api_client.select_header_accept( 355 ['text/plain']) # noqa: E501 356 357 # Authentication setting 358 auth_settings = [] # noqa: E501 359 360 return self.api_client.call_api( 361 '/logz', 'GET', 362 path_params, 363 query_params, 364 header_params, 365 body=body_params, 366 post_params=form_params, 367 files=local_var_files, 368 response_type='str', # noqa: E501 369 auth_settings=auth_settings, 370 async_req=params.get('async_req'), 371 _return_http_data_only=params.get('_return_http_data_only'), 372 _preload_content=params.get('_preload_content', True), 373 _request_timeout=params.get('_request_timeout'), 374 collection_formats=collection_formats) 375 376 def node_info(self, **kwargs): # noqa: E501 377 """Returns the info of the node. # noqa: E501 378 379 This method makes a synchronous HTTP request by default. To make an 380 asynchronous HTTP request, please pass async_req=True 381 >>> thread = api.node_info(async_req=True) 382 >>> result = thread.get() 383 384 :param async_req bool 385 :return: NodeInfo 386 If the method is called asynchronously, 387 returns the request thread. 388 """ 389 kwargs['_return_http_data_only'] = True 390 if kwargs.get('async_req'): 391 return self.node_info_with_http_info(**kwargs) # noqa: E501 392 else: 393 (data) = self.node_info_with_http_info(**kwargs) # noqa: E501 394 return data 395 396 def node_info_with_http_info(self, **kwargs): # noqa: E501 397 """Returns the info of the node. # noqa: E501 398 399 This method makes a synchronous HTTP request by default. To make an 400 asynchronous HTTP request, please pass async_req=True 401 >>> thread = api.node_info_with_http_info(async_req=True) 402 >>> result = thread.get() 403 404 :param async_req bool 405 :return: NodeInfo 406 If the method is called asynchronously, 407 returns the request thread. 408 """ 409 410 all_params = [] # noqa: E501 411 all_params.append('async_req') 412 all_params.append('_return_http_data_only') 413 all_params.append('_preload_content') 414 all_params.append('_request_timeout') 415 416 params = locals() 417 for key, val in six.iteritems(params['kwargs']): 418 if key not in all_params: 419 raise TypeError( 420 "Got an unexpected keyword argument '%s'" 421 " to method node_info" % key 422 ) 423 params[key] = val 424 del params['kwargs'] 425 426 collection_formats = {} 427 428 path_params = {} 429 430 query_params = [] 431 432 header_params = {} 433 434 form_params = [] 435 local_var_files = {} 436 437 body_params = None 438 # HTTP header `Accept` 439 header_params['Accept'] = self.api_client.select_header_accept( 440 ['application/json']) # noqa: E501 441 442 # Authentication setting 443 auth_settings = [] # noqa: E501 444 445 return self.api_client.call_api( 446 '/node_info', 'GET', 447 path_params, 448 query_params, 449 header_params, 450 body=body_params, 451 post_params=form_params, 452 files=local_var_files, 453 response_type='NodeInfo', # noqa: E501 454 auth_settings=auth_settings, 455 async_req=params.get('async_req'), 456 _return_http_data_only=params.get('_return_http_data_only'), 457 _preload_content=params.get('_preload_content', True), 458 _request_timeout=params.get('_request_timeout'), 459 collection_formats=collection_formats) 460 461 def peers(self, **kwargs): # noqa: E501 462 """Returns the peers connected to the host via the transport layer. # noqa: E501 463 464 As described in the [architecture docs](https://docs.bacalhau.org/about-bacalhau/architecture), each node is connected to a number of peer nodes. Example response: ```json { \"bacalhau-job-event\": [ \"QmdZQ7ZbhnvWY1J12XYKGHApJ6aufKyLNSvf8jZBrBaAVL\", \"QmXaXu9N5GNetatsvwnTfQqNtSeKAD6uCmarbh3LMRYAcF\", \"QmVAb7r2pKWCuyLpYWoZr9syhhFnTWeFaByHdb8PkkhLQG\", \"QmUDAXvv31WPZ8U9CzuRTMn9iFGiopGE7rHiah1X8a6PkT\", \"QmSyJ8VUd4YSPwZFJSJsHmmmmg7sd4BAc2yHY73nisJo86\" ] } ``` # noqa: E501 465 This method makes a synchronous HTTP request by default. To make an 466 asynchronous HTTP request, please pass async_req=True 467 >>> thread = api.peers(async_req=True) 468 >>> result = thread.get() 469 470 :param async_req bool 471 :return: list[PeerAddrInfo] 472 If the method is called asynchronously, 473 returns the request thread. 474 """ 475 kwargs['_return_http_data_only'] = True 476 if kwargs.get('async_req'): 477 return self.peers_with_http_info(**kwargs) # noqa: E501 478 else: 479 (data) = self.peers_with_http_info(**kwargs) # noqa: E501 480 return data 481 482 def peers_with_http_info(self, **kwargs): # noqa: E501 483 """Returns the peers connected to the host via the transport layer. # noqa: E501 484 485 As described in the [architecture docs](https://docs.bacalhau.org/about-bacalhau/architecture), each node is connected to a number of peer nodes. Example response: ```json { \"bacalhau-job-event\": [ \"QmdZQ7ZbhnvWY1J12XYKGHApJ6aufKyLNSvf8jZBrBaAVL\", \"QmXaXu9N5GNetatsvwnTfQqNtSeKAD6uCmarbh3LMRYAcF\", \"QmVAb7r2pKWCuyLpYWoZr9syhhFnTWeFaByHdb8PkkhLQG\", \"QmUDAXvv31WPZ8U9CzuRTMn9iFGiopGE7rHiah1X8a6PkT\", \"QmSyJ8VUd4YSPwZFJSJsHmmmmg7sd4BAc2yHY73nisJo86\" ] } ``` # noqa: E501 486 This method makes a synchronous HTTP request by default. To make an 487 asynchronous HTTP request, please pass async_req=True 488 >>> thread = api.peers_with_http_info(async_req=True) 489 >>> result = thread.get() 490 491 :param async_req bool 492 :return: list[PeerAddrInfo] 493 If the method is called asynchronously, 494 returns the request thread. 495 """ 496 497 all_params = [] # noqa: E501 498 all_params.append('async_req') 499 all_params.append('_return_http_data_only') 500 all_params.append('_preload_content') 501 all_params.append('_request_timeout') 502 503 params = locals() 504 for key, val in six.iteritems(params['kwargs']): 505 if key not in all_params: 506 raise TypeError( 507 "Got an unexpected keyword argument '%s'" 508 " to method peers" % key 509 ) 510 params[key] = val 511 del params['kwargs'] 512 513 collection_formats = {} 514 515 path_params = {} 516 517 query_params = [] 518 519 header_params = {} 520 521 form_params = [] 522 local_var_files = {} 523 524 body_params = None 525 # HTTP header `Accept` 526 header_params['Accept'] = self.api_client.select_header_accept( 527 ['application/json']) # noqa: E501 528 529 # Authentication setting 530 auth_settings = [] # noqa: E501 531 532 return self.api_client.call_api( 533 '/peers', 'GET', 534 path_params, 535 query_params, 536 header_params, 537 body=body_params, 538 post_params=form_params, 539 files=local_var_files, 540 response_type='list[PeerAddrInfo]', # noqa: E501 541 auth_settings=auth_settings, 542 async_req=params.get('async_req'), 543 _return_http_data_only=params.get('_return_http_data_only'), 544 _preload_content=params.get('_preload_content', True), 545 _request_timeout=params.get('_request_timeout'), 546 collection_formats=collection_formats) 547 548 def readyz(self, **kwargs): # noqa: E501 549 """readyz # noqa: E501 550 551 This method makes a synchronous HTTP request by default. To make an 552 asynchronous HTTP request, please pass async_req=True 553 >>> thread = api.readyz(async_req=True) 554 >>> result = thread.get() 555 556 :param async_req bool 557 :return: str 558 If the method is called asynchronously, 559 returns the request thread. 560 """ 561 kwargs['_return_http_data_only'] = True 562 if kwargs.get('async_req'): 563 return self.readyz_with_http_info(**kwargs) # noqa: E501 564 else: 565 (data) = self.readyz_with_http_info(**kwargs) # noqa: E501 566 return data 567 568 def readyz_with_http_info(self, **kwargs): # noqa: E501 569 """readyz # noqa: E501 570 571 This method makes a synchronous HTTP request by default. To make an 572 asynchronous HTTP request, please pass async_req=True 573 >>> thread = api.readyz_with_http_info(async_req=True) 574 >>> result = thread.get() 575 576 :param async_req bool 577 :return: str 578 If the method is called asynchronously, 579 returns the request thread. 580 """ 581 582 all_params = [] # noqa: E501 583 all_params.append('async_req') 584 all_params.append('_return_http_data_only') 585 all_params.append('_preload_content') 586 all_params.append('_request_timeout') 587 588 params = locals() 589 for key, val in six.iteritems(params['kwargs']): 590 if key not in all_params: 591 raise TypeError( 592 "Got an unexpected keyword argument '%s'" 593 " to method readyz" % key 594 ) 595 params[key] = val 596 del params['kwargs'] 597 598 collection_formats = {} 599 600 path_params = {} 601 602 query_params = [] 603 604 header_params = {} 605 606 form_params = [] 607 local_var_files = {} 608 609 body_params = None 610 # HTTP header `Accept` 611 header_params['Accept'] = self.api_client.select_header_accept( 612 ['text/plain']) # noqa: E501 613 614 # Authentication setting 615 auth_settings = [] # noqa: E501 616 617 return self.api_client.call_api( 618 '/readyz', 'GET', 619 path_params, 620 query_params, 621 header_params, 622 body=body_params, 623 post_params=form_params, 624 files=local_var_files, 625 response_type='str', # noqa: E501 626 auth_settings=auth_settings, 627 async_req=params.get('async_req'), 628 _return_http_data_only=params.get('_return_http_data_only'), 629 _preload_content=params.get('_preload_content', True), 630 _request_timeout=params.get('_request_timeout'), 631 collection_formats=collection_formats) 632 633 def varz(self, **kwargs): # noqa: E501 634 """varz # noqa: E501 635 636 This method makes a synchronous HTTP request by default. To make an 637 asynchronous HTTP request, please pass async_req=True 638 >>> thread = api.varz(async_req=True) 639 >>> result = thread.get() 640 641 :param async_req bool 642 :return: list[int] 643 If the method is called asynchronously, 644 returns the request thread. 645 """ 646 kwargs['_return_http_data_only'] = True 647 if kwargs.get('async_req'): 648 return self.varz_with_http_info(**kwargs) # noqa: E501 649 else: 650 (data) = self.varz_with_http_info(**kwargs) # noqa: E501 651 return data 652 653 def varz_with_http_info(self, **kwargs): # noqa: E501 654 """varz # noqa: E501 655 656 This method makes a synchronous HTTP request by default. To make an 657 asynchronous HTTP request, please pass async_req=True 658 >>> thread = api.varz_with_http_info(async_req=True) 659 >>> result = thread.get() 660 661 :param async_req bool 662 :return: list[int] 663 If the method is called asynchronously, 664 returns the request thread. 665 """ 666 667 all_params = [] # noqa: E501 668 all_params.append('async_req') 669 all_params.append('_return_http_data_only') 670 all_params.append('_preload_content') 671 all_params.append('_request_timeout') 672 673 params = locals() 674 for key, val in six.iteritems(params['kwargs']): 675 if key not in all_params: 676 raise TypeError( 677 "Got an unexpected keyword argument '%s'" 678 " to method varz" % key 679 ) 680 params[key] = val 681 del params['kwargs'] 682 683 collection_formats = {} 684 685 path_params = {} 686 687 query_params = [] 688 689 header_params = {} 690 691 form_params = [] 692 local_var_files = {} 693 694 body_params = None 695 # HTTP header `Accept` 696 header_params['Accept'] = self.api_client.select_header_accept( 697 ['application/json']) # noqa: E501 698 699 # Authentication setting 700 auth_settings = [] # noqa: E501 701 702 return self.api_client.call_api( 703 '/varz', 'GET', 704 path_params, 705 query_params, 706 header_params, 707 body=body_params, 708 post_params=form_params, 709 files=local_var_files, 710 response_type='list[int]', # noqa: E501 711 auth_settings=auth_settings, 712 async_req=params.get('async_req'), 713 _return_http_data_only=params.get('_return_http_data_only'), 714 _preload_content=params.get('_preload_content', True), 715 _request_timeout=params.get('_request_timeout'), 716 collection_formats=collection_formats)