vectorize_client.api.pipelines_api
Vectorize API
API for Vectorize services (Beta)
The version of the OpenAPI document: 0.1.2 Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
1# coding: utf-8 2 3""" 4 Vectorize API 5 6 API for Vectorize services (Beta) 7 8 The version of the OpenAPI document: 0.1.2 9 Generated by OpenAPI Generator (https://openapi-generator.tech) 10 11 Do not edit the class manually. 12""" # noqa: E501 13 14import warnings 15from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt 16from typing import Any, Dict, List, Optional, Tuple, Union 17from typing_extensions import Annotated 18 19from pydantic import StrictStr 20from typing import Optional 21from vectorize_client.models.create_pipeline_response import CreatePipelineResponse 22from vectorize_client.models.delete_pipeline_response import DeletePipelineResponse 23from vectorize_client.models.get_deep_research_response import GetDeepResearchResponse 24from vectorize_client.models.get_pipeline_events_response import GetPipelineEventsResponse 25from vectorize_client.models.get_pipeline_metrics_response import GetPipelineMetricsResponse 26from vectorize_client.models.get_pipeline_response import GetPipelineResponse 27from vectorize_client.models.get_pipelines_response import GetPipelinesResponse 28from vectorize_client.models.pipeline_configuration_schema import PipelineConfigurationSchema 29from vectorize_client.models.retrieve_documents_request import RetrieveDocumentsRequest 30from vectorize_client.models.retrieve_documents_response import RetrieveDocumentsResponse 31from vectorize_client.models.start_deep_research_request import StartDeepResearchRequest 32from vectorize_client.models.start_deep_research_response import StartDeepResearchResponse 33from vectorize_client.models.start_pipeline_response import StartPipelineResponse 34from vectorize_client.models.stop_pipeline_response import StopPipelineResponse 35 36from vectorize_client.api_client import ApiClient, RequestSerialized 37from vectorize_client.api_response import ApiResponse 38from vectorize_client.rest import RESTResponseType 39 40 41class PipelinesApi: 42 """NOTE: This class is auto generated by OpenAPI Generator 43 Ref: https://openapi-generator.tech 44 45 Do not edit the class manually. 46 """ 47 48 def __init__(self, api_client=None) -> None: 49 if api_client is None: 50 api_client = ApiClient.get_default() 51 self.api_client = api_client 52 53 54 @validate_call 55 def create_pipeline( 56 self, 57 organization_id: StrictStr, 58 pipeline_configuration_schema: PipelineConfigurationSchema, 59 workspace_id: Optional[StrictStr] = None, 60 _request_timeout: Union[ 61 None, 62 Annotated[StrictFloat, Field(gt=0)], 63 Tuple[ 64 Annotated[StrictFloat, Field(gt=0)], 65 Annotated[StrictFloat, Field(gt=0)] 66 ] 67 ] = None, 68 _request_auth: Optional[Dict[StrictStr, Any]] = None, 69 _content_type: Optional[StrictStr] = None, 70 _headers: Optional[Dict[StrictStr, Any]] = None, 71 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 72 ) -> CreatePipelineResponse: 73 """Create a new pipeline 74 75 Creates a new pipeline with source connectors, destination connector, and AI platform configuration. The specific configuration fields required depend on the connector types selected. 76 77 :param organization_id: (required) 78 :type organization_id: str 79 :param pipeline_configuration_schema: (required) 80 :type pipeline_configuration_schema: PipelineConfigurationSchema 81 :param workspace_id: 82 :type workspace_id: str 83 :param _request_timeout: timeout setting for this request. If one 84 number provided, it will be total request 85 timeout. It can also be a pair (tuple) of 86 (connection, read) timeouts. 87 :type _request_timeout: int, tuple(int, int), optional 88 :param _request_auth: set to override the auth_settings for an a single 89 request; this effectively ignores the 90 authentication in the spec for a single request. 91 :type _request_auth: dict, optional 92 :param _content_type: force content-type for the request. 93 :type _content_type: str, Optional 94 :param _headers: set to override the headers for a single 95 request; this effectively ignores the headers 96 in the spec for a single request. 97 :type _headers: dict, optional 98 :param _host_index: set to override the host_index for a single 99 request; this effectively ignores the host_index 100 in the spec for a single request. 101 :type _host_index: int, optional 102 :return: Returns the result object. 103 """ # noqa: E501 104 105 _param = self._create_pipeline_serialize( 106 organization_id=organization_id, 107 pipeline_configuration_schema=pipeline_configuration_schema, 108 workspace_id=workspace_id, 109 _request_auth=_request_auth, 110 _content_type=_content_type, 111 _headers=_headers, 112 _host_index=_host_index 113 ) 114 115 _response_types_map: Dict[str, Optional[str]] = { 116 '200': "CreatePipelineResponse", 117 '400': "GetWorkspaces400Response", 118 '401': "GetWorkspaces400Response", 119 '403': "GetWorkspaces400Response", 120 '404': "GetWorkspaces400Response", 121 '500': "GetWorkspaces400Response", 122 } 123 response_data = self.api_client.call_api( 124 *_param, 125 _request_timeout=_request_timeout 126 ) 127 response_data.read() 128 return self.api_client.response_deserialize( 129 response_data=response_data, 130 response_types_map=_response_types_map, 131 ).data 132 133 134 @validate_call 135 def create_pipeline_with_http_info( 136 self, 137 organization_id: StrictStr, 138 pipeline_configuration_schema: PipelineConfigurationSchema, 139 workspace_id: Optional[StrictStr] = None, 140 _request_timeout: Union[ 141 None, 142 Annotated[StrictFloat, Field(gt=0)], 143 Tuple[ 144 Annotated[StrictFloat, Field(gt=0)], 145 Annotated[StrictFloat, Field(gt=0)] 146 ] 147 ] = None, 148 _request_auth: Optional[Dict[StrictStr, Any]] = None, 149 _content_type: Optional[StrictStr] = None, 150 _headers: Optional[Dict[StrictStr, Any]] = None, 151 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 152 ) -> ApiResponse[CreatePipelineResponse]: 153 """Create a new pipeline 154 155 Creates a new pipeline with source connectors, destination connector, and AI platform configuration. The specific configuration fields required depend on the connector types selected. 156 157 :param organization_id: (required) 158 :type organization_id: str 159 :param pipeline_configuration_schema: (required) 160 :type pipeline_configuration_schema: PipelineConfigurationSchema 161 :param workspace_id: 162 :type workspace_id: str 163 :param _request_timeout: timeout setting for this request. If one 164 number provided, it will be total request 165 timeout. It can also be a pair (tuple) of 166 (connection, read) timeouts. 167 :type _request_timeout: int, tuple(int, int), optional 168 :param _request_auth: set to override the auth_settings for an a single 169 request; this effectively ignores the 170 authentication in the spec for a single request. 171 :type _request_auth: dict, optional 172 :param _content_type: force content-type for the request. 173 :type _content_type: str, Optional 174 :param _headers: set to override the headers for a single 175 request; this effectively ignores the headers 176 in the spec for a single request. 177 :type _headers: dict, optional 178 :param _host_index: set to override the host_index for a single 179 request; this effectively ignores the host_index 180 in the spec for a single request. 181 :type _host_index: int, optional 182 :return: Returns the result object. 183 """ # noqa: E501 184 185 _param = self._create_pipeline_serialize( 186 organization_id=organization_id, 187 pipeline_configuration_schema=pipeline_configuration_schema, 188 workspace_id=workspace_id, 189 _request_auth=_request_auth, 190 _content_type=_content_type, 191 _headers=_headers, 192 _host_index=_host_index 193 ) 194 195 _response_types_map: Dict[str, Optional[str]] = { 196 '200': "CreatePipelineResponse", 197 '400': "GetWorkspaces400Response", 198 '401': "GetWorkspaces400Response", 199 '403': "GetWorkspaces400Response", 200 '404': "GetWorkspaces400Response", 201 '500': "GetWorkspaces400Response", 202 } 203 response_data = self.api_client.call_api( 204 *_param, 205 _request_timeout=_request_timeout 206 ) 207 response_data.read() 208 return self.api_client.response_deserialize( 209 response_data=response_data, 210 response_types_map=_response_types_map, 211 ) 212 213 214 @validate_call 215 def create_pipeline_without_preload_content( 216 self, 217 organization_id: StrictStr, 218 pipeline_configuration_schema: PipelineConfigurationSchema, 219 workspace_id: Optional[StrictStr] = None, 220 _request_timeout: Union[ 221 None, 222 Annotated[StrictFloat, Field(gt=0)], 223 Tuple[ 224 Annotated[StrictFloat, Field(gt=0)], 225 Annotated[StrictFloat, Field(gt=0)] 226 ] 227 ] = None, 228 _request_auth: Optional[Dict[StrictStr, Any]] = None, 229 _content_type: Optional[StrictStr] = None, 230 _headers: Optional[Dict[StrictStr, Any]] = None, 231 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 232 ) -> RESTResponseType: 233 """Create a new pipeline 234 235 Creates a new pipeline with source connectors, destination connector, and AI platform configuration. The specific configuration fields required depend on the connector types selected. 236 237 :param organization_id: (required) 238 :type organization_id: str 239 :param pipeline_configuration_schema: (required) 240 :type pipeline_configuration_schema: PipelineConfigurationSchema 241 :param workspace_id: 242 :type workspace_id: str 243 :param _request_timeout: timeout setting for this request. If one 244 number provided, it will be total request 245 timeout. It can also be a pair (tuple) of 246 (connection, read) timeouts. 247 :type _request_timeout: int, tuple(int, int), optional 248 :param _request_auth: set to override the auth_settings for an a single 249 request; this effectively ignores the 250 authentication in the spec for a single request. 251 :type _request_auth: dict, optional 252 :param _content_type: force content-type for the request. 253 :type _content_type: str, Optional 254 :param _headers: set to override the headers for a single 255 request; this effectively ignores the headers 256 in the spec for a single request. 257 :type _headers: dict, optional 258 :param _host_index: set to override the host_index for a single 259 request; this effectively ignores the host_index 260 in the spec for a single request. 261 :type _host_index: int, optional 262 :return: Returns the result object. 263 """ # noqa: E501 264 265 _param = self._create_pipeline_serialize( 266 organization_id=organization_id, 267 pipeline_configuration_schema=pipeline_configuration_schema, 268 workspace_id=workspace_id, 269 _request_auth=_request_auth, 270 _content_type=_content_type, 271 _headers=_headers, 272 _host_index=_host_index 273 ) 274 275 _response_types_map: Dict[str, Optional[str]] = { 276 '200': "CreatePipelineResponse", 277 '400': "GetWorkspaces400Response", 278 '401': "GetWorkspaces400Response", 279 '403': "GetWorkspaces400Response", 280 '404': "GetWorkspaces400Response", 281 '500': "GetWorkspaces400Response", 282 } 283 response_data = self.api_client.call_api( 284 *_param, 285 _request_timeout=_request_timeout 286 ) 287 return response_data.response 288 289 290 def _create_pipeline_serialize( 291 self, 292 organization_id, 293 pipeline_configuration_schema, 294 workspace_id, 295 _request_auth, 296 _content_type, 297 _headers, 298 _host_index, 299 ) -> RequestSerialized: 300 301 _host = None 302 303 _collection_formats: Dict[str, str] = { 304 } 305 306 _path_params: Dict[str, str] = {} 307 _query_params: List[Tuple[str, str]] = [] 308 _header_params: Dict[str, Optional[str]] = _headers or {} 309 _form_params: List[Tuple[str, str]] = [] 310 _files: Dict[ 311 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 312 ] = {} 313 _body_params: Optional[bytes] = None 314 315 # process the path parameters 316 if organization_id is not None: 317 _path_params['organizationId'] = organization_id 318 # process the query parameters 319 if workspace_id is not None: 320 321 _query_params.append(('workspaceId', workspace_id)) 322 323 # process the header parameters 324 # process the form parameters 325 # process the body parameter 326 if pipeline_configuration_schema is not None: 327 _body_params = pipeline_configuration_schema 328 329 330 # set the HTTP header `Accept` 331 if 'Accept' not in _header_params: 332 _header_params['Accept'] = self.api_client.select_header_accept( 333 [ 334 'application/json' 335 ] 336 ) 337 338 # set the HTTP header `Content-Type` 339 if _content_type: 340 _header_params['Content-Type'] = _content_type 341 else: 342 _default_content_type = ( 343 self.api_client.select_header_content_type( 344 [ 345 'application/json' 346 ] 347 ) 348 ) 349 if _default_content_type is not None: 350 _header_params['Content-Type'] = _default_content_type 351 352 # authentication setting 353 _auth_settings: List[str] = [ 354 'bearerAuth' 355 ] 356 357 return self.api_client.param_serialize( 358 method='POST', 359 resource_path='/org/{organizationId}/pipelines', 360 path_params=_path_params, 361 query_params=_query_params, 362 header_params=_header_params, 363 body=_body_params, 364 post_params=_form_params, 365 files=_files, 366 auth_settings=_auth_settings, 367 collection_formats=_collection_formats, 368 _host=_host, 369 _request_auth=_request_auth 370 ) 371 372 373 374 375 @validate_call 376 def delete_pipeline( 377 self, 378 organization_id: StrictStr, 379 pipeline_id: StrictStr, 380 _request_timeout: Union[ 381 None, 382 Annotated[StrictFloat, Field(gt=0)], 383 Tuple[ 384 Annotated[StrictFloat, Field(gt=0)], 385 Annotated[StrictFloat, Field(gt=0)] 386 ] 387 ] = None, 388 _request_auth: Optional[Dict[StrictStr, Any]] = None, 389 _content_type: Optional[StrictStr] = None, 390 _headers: Optional[Dict[StrictStr, Any]] = None, 391 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 392 ) -> DeletePipelineResponse: 393 """Delete a pipeline 394 395 Delete a pipeline 396 397 :param organization_id: (required) 398 :type organization_id: str 399 :param pipeline_id: (required) 400 :type pipeline_id: str 401 :param _request_timeout: timeout setting for this request. If one 402 number provided, it will be total request 403 timeout. It can also be a pair (tuple) of 404 (connection, read) timeouts. 405 :type _request_timeout: int, tuple(int, int), optional 406 :param _request_auth: set to override the auth_settings for an a single 407 request; this effectively ignores the 408 authentication in the spec for a single request. 409 :type _request_auth: dict, optional 410 :param _content_type: force content-type for the request. 411 :type _content_type: str, Optional 412 :param _headers: set to override the headers for a single 413 request; this effectively ignores the headers 414 in the spec for a single request. 415 :type _headers: dict, optional 416 :param _host_index: set to override the host_index for a single 417 request; this effectively ignores the host_index 418 in the spec for a single request. 419 :type _host_index: int, optional 420 :return: Returns the result object. 421 """ # noqa: E501 422 423 _param = self._delete_pipeline_serialize( 424 organization_id=organization_id, 425 pipeline_id=pipeline_id, 426 _request_auth=_request_auth, 427 _content_type=_content_type, 428 _headers=_headers, 429 _host_index=_host_index 430 ) 431 432 _response_types_map: Dict[str, Optional[str]] = { 433 '200': "DeletePipelineResponse", 434 '400': "GetWorkspaces400Response", 435 '401': "GetWorkspaces400Response", 436 '403': "GetWorkspaces400Response", 437 '404': "GetWorkspaces400Response", 438 '500': "GetWorkspaces400Response", 439 } 440 response_data = self.api_client.call_api( 441 *_param, 442 _request_timeout=_request_timeout 443 ) 444 response_data.read() 445 return self.api_client.response_deserialize( 446 response_data=response_data, 447 response_types_map=_response_types_map, 448 ).data 449 450 451 @validate_call 452 def delete_pipeline_with_http_info( 453 self, 454 organization_id: StrictStr, 455 pipeline_id: StrictStr, 456 _request_timeout: Union[ 457 None, 458 Annotated[StrictFloat, Field(gt=0)], 459 Tuple[ 460 Annotated[StrictFloat, Field(gt=0)], 461 Annotated[StrictFloat, Field(gt=0)] 462 ] 463 ] = None, 464 _request_auth: Optional[Dict[StrictStr, Any]] = None, 465 _content_type: Optional[StrictStr] = None, 466 _headers: Optional[Dict[StrictStr, Any]] = None, 467 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 468 ) -> ApiResponse[DeletePipelineResponse]: 469 """Delete a pipeline 470 471 Delete a pipeline 472 473 :param organization_id: (required) 474 :type organization_id: str 475 :param pipeline_id: (required) 476 :type pipeline_id: str 477 :param _request_timeout: timeout setting for this request. If one 478 number provided, it will be total request 479 timeout. It can also be a pair (tuple) of 480 (connection, read) timeouts. 481 :type _request_timeout: int, tuple(int, int), optional 482 :param _request_auth: set to override the auth_settings for an a single 483 request; this effectively ignores the 484 authentication in the spec for a single request. 485 :type _request_auth: dict, optional 486 :param _content_type: force content-type for the request. 487 :type _content_type: str, Optional 488 :param _headers: set to override the headers for a single 489 request; this effectively ignores the headers 490 in the spec for a single request. 491 :type _headers: dict, optional 492 :param _host_index: set to override the host_index for a single 493 request; this effectively ignores the host_index 494 in the spec for a single request. 495 :type _host_index: int, optional 496 :return: Returns the result object. 497 """ # noqa: E501 498 499 _param = self._delete_pipeline_serialize( 500 organization_id=organization_id, 501 pipeline_id=pipeline_id, 502 _request_auth=_request_auth, 503 _content_type=_content_type, 504 _headers=_headers, 505 _host_index=_host_index 506 ) 507 508 _response_types_map: Dict[str, Optional[str]] = { 509 '200': "DeletePipelineResponse", 510 '400': "GetWorkspaces400Response", 511 '401': "GetWorkspaces400Response", 512 '403': "GetWorkspaces400Response", 513 '404': "GetWorkspaces400Response", 514 '500': "GetWorkspaces400Response", 515 } 516 response_data = self.api_client.call_api( 517 *_param, 518 _request_timeout=_request_timeout 519 ) 520 response_data.read() 521 return self.api_client.response_deserialize( 522 response_data=response_data, 523 response_types_map=_response_types_map, 524 ) 525 526 527 @validate_call 528 def delete_pipeline_without_preload_content( 529 self, 530 organization_id: StrictStr, 531 pipeline_id: StrictStr, 532 _request_timeout: Union[ 533 None, 534 Annotated[StrictFloat, Field(gt=0)], 535 Tuple[ 536 Annotated[StrictFloat, Field(gt=0)], 537 Annotated[StrictFloat, Field(gt=0)] 538 ] 539 ] = None, 540 _request_auth: Optional[Dict[StrictStr, Any]] = None, 541 _content_type: Optional[StrictStr] = None, 542 _headers: Optional[Dict[StrictStr, Any]] = None, 543 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 544 ) -> RESTResponseType: 545 """Delete a pipeline 546 547 Delete a pipeline 548 549 :param organization_id: (required) 550 :type organization_id: str 551 :param pipeline_id: (required) 552 :type pipeline_id: str 553 :param _request_timeout: timeout setting for this request. If one 554 number provided, it will be total request 555 timeout. It can also be a pair (tuple) of 556 (connection, read) timeouts. 557 :type _request_timeout: int, tuple(int, int), optional 558 :param _request_auth: set to override the auth_settings for an a single 559 request; this effectively ignores the 560 authentication in the spec for a single request. 561 :type _request_auth: dict, optional 562 :param _content_type: force content-type for the request. 563 :type _content_type: str, Optional 564 :param _headers: set to override the headers for a single 565 request; this effectively ignores the headers 566 in the spec for a single request. 567 :type _headers: dict, optional 568 :param _host_index: set to override the host_index for a single 569 request; this effectively ignores the host_index 570 in the spec for a single request. 571 :type _host_index: int, optional 572 :return: Returns the result object. 573 """ # noqa: E501 574 575 _param = self._delete_pipeline_serialize( 576 organization_id=organization_id, 577 pipeline_id=pipeline_id, 578 _request_auth=_request_auth, 579 _content_type=_content_type, 580 _headers=_headers, 581 _host_index=_host_index 582 ) 583 584 _response_types_map: Dict[str, Optional[str]] = { 585 '200': "DeletePipelineResponse", 586 '400': "GetWorkspaces400Response", 587 '401': "GetWorkspaces400Response", 588 '403': "GetWorkspaces400Response", 589 '404': "GetWorkspaces400Response", 590 '500': "GetWorkspaces400Response", 591 } 592 response_data = self.api_client.call_api( 593 *_param, 594 _request_timeout=_request_timeout 595 ) 596 return response_data.response 597 598 599 def _delete_pipeline_serialize( 600 self, 601 organization_id, 602 pipeline_id, 603 _request_auth, 604 _content_type, 605 _headers, 606 _host_index, 607 ) -> RequestSerialized: 608 609 _host = None 610 611 _collection_formats: Dict[str, str] = { 612 } 613 614 _path_params: Dict[str, str] = {} 615 _query_params: List[Tuple[str, str]] = [] 616 _header_params: Dict[str, Optional[str]] = _headers or {} 617 _form_params: List[Tuple[str, str]] = [] 618 _files: Dict[ 619 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 620 ] = {} 621 _body_params: Optional[bytes] = None 622 623 # process the path parameters 624 if organization_id is not None: 625 _path_params['organizationId'] = organization_id 626 if pipeline_id is not None: 627 _path_params['pipelineId'] = pipeline_id 628 # process the query parameters 629 # process the header parameters 630 # process the form parameters 631 # process the body parameter 632 633 634 # set the HTTP header `Accept` 635 if 'Accept' not in _header_params: 636 _header_params['Accept'] = self.api_client.select_header_accept( 637 [ 638 'application/json' 639 ] 640 ) 641 642 643 # authentication setting 644 _auth_settings: List[str] = [ 645 'bearerAuth' 646 ] 647 648 return self.api_client.param_serialize( 649 method='DELETE', 650 resource_path='/org/{organizationId}/pipelines/{pipelineId}', 651 path_params=_path_params, 652 query_params=_query_params, 653 header_params=_header_params, 654 body=_body_params, 655 post_params=_form_params, 656 files=_files, 657 auth_settings=_auth_settings, 658 collection_formats=_collection_formats, 659 _host=_host, 660 _request_auth=_request_auth 661 ) 662 663 664 665 666 @validate_call 667 def get_deep_research_result( 668 self, 669 organization_id: StrictStr, 670 pipeline_id: StrictStr, 671 research_id: StrictStr, 672 _request_timeout: Union[ 673 None, 674 Annotated[StrictFloat, Field(gt=0)], 675 Tuple[ 676 Annotated[StrictFloat, Field(gt=0)], 677 Annotated[StrictFloat, Field(gt=0)] 678 ] 679 ] = None, 680 _request_auth: Optional[Dict[StrictStr, Any]] = None, 681 _content_type: Optional[StrictStr] = None, 682 _headers: Optional[Dict[StrictStr, Any]] = None, 683 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 684 ) -> GetDeepResearchResponse: 685 """Get deep research result 686 687 Get deep research result 688 689 :param organization_id: (required) 690 :type organization_id: str 691 :param pipeline_id: (required) 692 :type pipeline_id: str 693 :param research_id: (required) 694 :type research_id: str 695 :param _request_timeout: timeout setting for this request. If one 696 number provided, it will be total request 697 timeout. It can also be a pair (tuple) of 698 (connection, read) timeouts. 699 :type _request_timeout: int, tuple(int, int), optional 700 :param _request_auth: set to override the auth_settings for an a single 701 request; this effectively ignores the 702 authentication in the spec for a single request. 703 :type _request_auth: dict, optional 704 :param _content_type: force content-type for the request. 705 :type _content_type: str, Optional 706 :param _headers: set to override the headers for a single 707 request; this effectively ignores the headers 708 in the spec for a single request. 709 :type _headers: dict, optional 710 :param _host_index: set to override the host_index for a single 711 request; this effectively ignores the host_index 712 in the spec for a single request. 713 :type _host_index: int, optional 714 :return: Returns the result object. 715 """ # noqa: E501 716 717 _param = self._get_deep_research_result_serialize( 718 organization_id=organization_id, 719 pipeline_id=pipeline_id, 720 research_id=research_id, 721 _request_auth=_request_auth, 722 _content_type=_content_type, 723 _headers=_headers, 724 _host_index=_host_index 725 ) 726 727 _response_types_map: Dict[str, Optional[str]] = { 728 '200': "GetDeepResearchResponse", 729 '400': "GetWorkspaces400Response", 730 '401': "GetWorkspaces400Response", 731 '403': "GetWorkspaces400Response", 732 '404': "GetWorkspaces400Response", 733 '500': "GetWorkspaces400Response", 734 } 735 response_data = self.api_client.call_api( 736 *_param, 737 _request_timeout=_request_timeout 738 ) 739 response_data.read() 740 return self.api_client.response_deserialize( 741 response_data=response_data, 742 response_types_map=_response_types_map, 743 ).data 744 745 746 @validate_call 747 def get_deep_research_result_with_http_info( 748 self, 749 organization_id: StrictStr, 750 pipeline_id: StrictStr, 751 research_id: StrictStr, 752 _request_timeout: Union[ 753 None, 754 Annotated[StrictFloat, Field(gt=0)], 755 Tuple[ 756 Annotated[StrictFloat, Field(gt=0)], 757 Annotated[StrictFloat, Field(gt=0)] 758 ] 759 ] = None, 760 _request_auth: Optional[Dict[StrictStr, Any]] = None, 761 _content_type: Optional[StrictStr] = None, 762 _headers: Optional[Dict[StrictStr, Any]] = None, 763 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 764 ) -> ApiResponse[GetDeepResearchResponse]: 765 """Get deep research result 766 767 Get deep research result 768 769 :param organization_id: (required) 770 :type organization_id: str 771 :param pipeline_id: (required) 772 :type pipeline_id: str 773 :param research_id: (required) 774 :type research_id: str 775 :param _request_timeout: timeout setting for this request. If one 776 number provided, it will be total request 777 timeout. It can also be a pair (tuple) of 778 (connection, read) timeouts. 779 :type _request_timeout: int, tuple(int, int), optional 780 :param _request_auth: set to override the auth_settings for an a single 781 request; this effectively ignores the 782 authentication in the spec for a single request. 783 :type _request_auth: dict, optional 784 :param _content_type: force content-type for the request. 785 :type _content_type: str, Optional 786 :param _headers: set to override the headers for a single 787 request; this effectively ignores the headers 788 in the spec for a single request. 789 :type _headers: dict, optional 790 :param _host_index: set to override the host_index for a single 791 request; this effectively ignores the host_index 792 in the spec for a single request. 793 :type _host_index: int, optional 794 :return: Returns the result object. 795 """ # noqa: E501 796 797 _param = self._get_deep_research_result_serialize( 798 organization_id=organization_id, 799 pipeline_id=pipeline_id, 800 research_id=research_id, 801 _request_auth=_request_auth, 802 _content_type=_content_type, 803 _headers=_headers, 804 _host_index=_host_index 805 ) 806 807 _response_types_map: Dict[str, Optional[str]] = { 808 '200': "GetDeepResearchResponse", 809 '400': "GetWorkspaces400Response", 810 '401': "GetWorkspaces400Response", 811 '403': "GetWorkspaces400Response", 812 '404': "GetWorkspaces400Response", 813 '500': "GetWorkspaces400Response", 814 } 815 response_data = self.api_client.call_api( 816 *_param, 817 _request_timeout=_request_timeout 818 ) 819 response_data.read() 820 return self.api_client.response_deserialize( 821 response_data=response_data, 822 response_types_map=_response_types_map, 823 ) 824 825 826 @validate_call 827 def get_deep_research_result_without_preload_content( 828 self, 829 organization_id: StrictStr, 830 pipeline_id: StrictStr, 831 research_id: StrictStr, 832 _request_timeout: Union[ 833 None, 834 Annotated[StrictFloat, Field(gt=0)], 835 Tuple[ 836 Annotated[StrictFloat, Field(gt=0)], 837 Annotated[StrictFloat, Field(gt=0)] 838 ] 839 ] = None, 840 _request_auth: Optional[Dict[StrictStr, Any]] = None, 841 _content_type: Optional[StrictStr] = None, 842 _headers: Optional[Dict[StrictStr, Any]] = None, 843 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 844 ) -> RESTResponseType: 845 """Get deep research result 846 847 Get deep research result 848 849 :param organization_id: (required) 850 :type organization_id: str 851 :param pipeline_id: (required) 852 :type pipeline_id: str 853 :param research_id: (required) 854 :type research_id: str 855 :param _request_timeout: timeout setting for this request. If one 856 number provided, it will be total request 857 timeout. It can also be a pair (tuple) of 858 (connection, read) timeouts. 859 :type _request_timeout: int, tuple(int, int), optional 860 :param _request_auth: set to override the auth_settings for an a single 861 request; this effectively ignores the 862 authentication in the spec for a single request. 863 :type _request_auth: dict, optional 864 :param _content_type: force content-type for the request. 865 :type _content_type: str, Optional 866 :param _headers: set to override the headers for a single 867 request; this effectively ignores the headers 868 in the spec for a single request. 869 :type _headers: dict, optional 870 :param _host_index: set to override the host_index for a single 871 request; this effectively ignores the host_index 872 in the spec for a single request. 873 :type _host_index: int, optional 874 :return: Returns the result object. 875 """ # noqa: E501 876 877 _param = self._get_deep_research_result_serialize( 878 organization_id=organization_id, 879 pipeline_id=pipeline_id, 880 research_id=research_id, 881 _request_auth=_request_auth, 882 _content_type=_content_type, 883 _headers=_headers, 884 _host_index=_host_index 885 ) 886 887 _response_types_map: Dict[str, Optional[str]] = { 888 '200': "GetDeepResearchResponse", 889 '400': "GetWorkspaces400Response", 890 '401': "GetWorkspaces400Response", 891 '403': "GetWorkspaces400Response", 892 '404': "GetWorkspaces400Response", 893 '500': "GetWorkspaces400Response", 894 } 895 response_data = self.api_client.call_api( 896 *_param, 897 _request_timeout=_request_timeout 898 ) 899 return response_data.response 900 901 902 def _get_deep_research_result_serialize( 903 self, 904 organization_id, 905 pipeline_id, 906 research_id, 907 _request_auth, 908 _content_type, 909 _headers, 910 _host_index, 911 ) -> RequestSerialized: 912 913 _host = None 914 915 _collection_formats: Dict[str, str] = { 916 } 917 918 _path_params: Dict[str, str] = {} 919 _query_params: List[Tuple[str, str]] = [] 920 _header_params: Dict[str, Optional[str]] = _headers or {} 921 _form_params: List[Tuple[str, str]] = [] 922 _files: Dict[ 923 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 924 ] = {} 925 _body_params: Optional[bytes] = None 926 927 # process the path parameters 928 if organization_id is not None: 929 _path_params['organizationId'] = organization_id 930 if pipeline_id is not None: 931 _path_params['pipelineId'] = pipeline_id 932 if research_id is not None: 933 _path_params['researchId'] = research_id 934 # process the query parameters 935 # process the header parameters 936 # process the form parameters 937 # process the body parameter 938 939 940 # set the HTTP header `Accept` 941 if 'Accept' not in _header_params: 942 _header_params['Accept'] = self.api_client.select_header_accept( 943 [ 944 'application/json' 945 ] 946 ) 947 948 949 # authentication setting 950 _auth_settings: List[str] = [ 951 'bearerAuth' 952 ] 953 954 return self.api_client.param_serialize( 955 method='GET', 956 resource_path='/org/{organizationId}/pipelines/{pipelineId}/deep-research/{researchId}', 957 path_params=_path_params, 958 query_params=_query_params, 959 header_params=_header_params, 960 body=_body_params, 961 post_params=_form_params, 962 files=_files, 963 auth_settings=_auth_settings, 964 collection_formats=_collection_formats, 965 _host=_host, 966 _request_auth=_request_auth 967 ) 968 969 970 971 972 @validate_call 973 def get_pipeline( 974 self, 975 organization_id: StrictStr, 976 pipeline_id: StrictStr, 977 _request_timeout: Union[ 978 None, 979 Annotated[StrictFloat, Field(gt=0)], 980 Tuple[ 981 Annotated[StrictFloat, Field(gt=0)], 982 Annotated[StrictFloat, Field(gt=0)] 983 ] 984 ] = None, 985 _request_auth: Optional[Dict[StrictStr, Any]] = None, 986 _content_type: Optional[StrictStr] = None, 987 _headers: Optional[Dict[StrictStr, Any]] = None, 988 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 989 ) -> GetPipelineResponse: 990 """Get a pipeline 991 992 Get a pipeline 993 994 :param organization_id: (required) 995 :type organization_id: str 996 :param pipeline_id: (required) 997 :type pipeline_id: str 998 :param _request_timeout: timeout setting for this request. If one 999 number provided, it will be total request 1000 timeout. It can also be a pair (tuple) of 1001 (connection, read) timeouts. 1002 :type _request_timeout: int, tuple(int, int), optional 1003 :param _request_auth: set to override the auth_settings for an a single 1004 request; this effectively ignores the 1005 authentication in the spec for a single request. 1006 :type _request_auth: dict, optional 1007 :param _content_type: force content-type for the request. 1008 :type _content_type: str, Optional 1009 :param _headers: set to override the headers for a single 1010 request; this effectively ignores the headers 1011 in the spec for a single request. 1012 :type _headers: dict, optional 1013 :param _host_index: set to override the host_index for a single 1014 request; this effectively ignores the host_index 1015 in the spec for a single request. 1016 :type _host_index: int, optional 1017 :return: Returns the result object. 1018 """ # noqa: E501 1019 1020 _param = self._get_pipeline_serialize( 1021 organization_id=organization_id, 1022 pipeline_id=pipeline_id, 1023 _request_auth=_request_auth, 1024 _content_type=_content_type, 1025 _headers=_headers, 1026 _host_index=_host_index 1027 ) 1028 1029 _response_types_map: Dict[str, Optional[str]] = { 1030 '200': "GetPipelineResponse", 1031 '400': "GetWorkspaces400Response", 1032 '401': "GetWorkspaces400Response", 1033 '403': "GetWorkspaces400Response", 1034 '404': "GetWorkspaces400Response", 1035 '500': "GetWorkspaces400Response", 1036 } 1037 response_data = self.api_client.call_api( 1038 *_param, 1039 _request_timeout=_request_timeout 1040 ) 1041 response_data.read() 1042 return self.api_client.response_deserialize( 1043 response_data=response_data, 1044 response_types_map=_response_types_map, 1045 ).data 1046 1047 1048 @validate_call 1049 def get_pipeline_with_http_info( 1050 self, 1051 organization_id: StrictStr, 1052 pipeline_id: StrictStr, 1053 _request_timeout: Union[ 1054 None, 1055 Annotated[StrictFloat, Field(gt=0)], 1056 Tuple[ 1057 Annotated[StrictFloat, Field(gt=0)], 1058 Annotated[StrictFloat, Field(gt=0)] 1059 ] 1060 ] = None, 1061 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1062 _content_type: Optional[StrictStr] = None, 1063 _headers: Optional[Dict[StrictStr, Any]] = None, 1064 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1065 ) -> ApiResponse[GetPipelineResponse]: 1066 """Get a pipeline 1067 1068 Get a pipeline 1069 1070 :param organization_id: (required) 1071 :type organization_id: str 1072 :param pipeline_id: (required) 1073 :type pipeline_id: str 1074 :param _request_timeout: timeout setting for this request. If one 1075 number provided, it will be total request 1076 timeout. It can also be a pair (tuple) of 1077 (connection, read) timeouts. 1078 :type _request_timeout: int, tuple(int, int), optional 1079 :param _request_auth: set to override the auth_settings for an a single 1080 request; this effectively ignores the 1081 authentication in the spec for a single request. 1082 :type _request_auth: dict, optional 1083 :param _content_type: force content-type for the request. 1084 :type _content_type: str, Optional 1085 :param _headers: set to override the headers for a single 1086 request; this effectively ignores the headers 1087 in the spec for a single request. 1088 :type _headers: dict, optional 1089 :param _host_index: set to override the host_index for a single 1090 request; this effectively ignores the host_index 1091 in the spec for a single request. 1092 :type _host_index: int, optional 1093 :return: Returns the result object. 1094 """ # noqa: E501 1095 1096 _param = self._get_pipeline_serialize( 1097 organization_id=organization_id, 1098 pipeline_id=pipeline_id, 1099 _request_auth=_request_auth, 1100 _content_type=_content_type, 1101 _headers=_headers, 1102 _host_index=_host_index 1103 ) 1104 1105 _response_types_map: Dict[str, Optional[str]] = { 1106 '200': "GetPipelineResponse", 1107 '400': "GetWorkspaces400Response", 1108 '401': "GetWorkspaces400Response", 1109 '403': "GetWorkspaces400Response", 1110 '404': "GetWorkspaces400Response", 1111 '500': "GetWorkspaces400Response", 1112 } 1113 response_data = self.api_client.call_api( 1114 *_param, 1115 _request_timeout=_request_timeout 1116 ) 1117 response_data.read() 1118 return self.api_client.response_deserialize( 1119 response_data=response_data, 1120 response_types_map=_response_types_map, 1121 ) 1122 1123 1124 @validate_call 1125 def get_pipeline_without_preload_content( 1126 self, 1127 organization_id: StrictStr, 1128 pipeline_id: StrictStr, 1129 _request_timeout: Union[ 1130 None, 1131 Annotated[StrictFloat, Field(gt=0)], 1132 Tuple[ 1133 Annotated[StrictFloat, Field(gt=0)], 1134 Annotated[StrictFloat, Field(gt=0)] 1135 ] 1136 ] = None, 1137 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1138 _content_type: Optional[StrictStr] = None, 1139 _headers: Optional[Dict[StrictStr, Any]] = None, 1140 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1141 ) -> RESTResponseType: 1142 """Get a pipeline 1143 1144 Get a pipeline 1145 1146 :param organization_id: (required) 1147 :type organization_id: str 1148 :param pipeline_id: (required) 1149 :type pipeline_id: str 1150 :param _request_timeout: timeout setting for this request. If one 1151 number provided, it will be total request 1152 timeout. It can also be a pair (tuple) of 1153 (connection, read) timeouts. 1154 :type _request_timeout: int, tuple(int, int), optional 1155 :param _request_auth: set to override the auth_settings for an a single 1156 request; this effectively ignores the 1157 authentication in the spec for a single request. 1158 :type _request_auth: dict, optional 1159 :param _content_type: force content-type for the request. 1160 :type _content_type: str, Optional 1161 :param _headers: set to override the headers for a single 1162 request; this effectively ignores the headers 1163 in the spec for a single request. 1164 :type _headers: dict, optional 1165 :param _host_index: set to override the host_index for a single 1166 request; this effectively ignores the host_index 1167 in the spec for a single request. 1168 :type _host_index: int, optional 1169 :return: Returns the result object. 1170 """ # noqa: E501 1171 1172 _param = self._get_pipeline_serialize( 1173 organization_id=organization_id, 1174 pipeline_id=pipeline_id, 1175 _request_auth=_request_auth, 1176 _content_type=_content_type, 1177 _headers=_headers, 1178 _host_index=_host_index 1179 ) 1180 1181 _response_types_map: Dict[str, Optional[str]] = { 1182 '200': "GetPipelineResponse", 1183 '400': "GetWorkspaces400Response", 1184 '401': "GetWorkspaces400Response", 1185 '403': "GetWorkspaces400Response", 1186 '404': "GetWorkspaces400Response", 1187 '500': "GetWorkspaces400Response", 1188 } 1189 response_data = self.api_client.call_api( 1190 *_param, 1191 _request_timeout=_request_timeout 1192 ) 1193 return response_data.response 1194 1195 1196 def _get_pipeline_serialize( 1197 self, 1198 organization_id, 1199 pipeline_id, 1200 _request_auth, 1201 _content_type, 1202 _headers, 1203 _host_index, 1204 ) -> RequestSerialized: 1205 1206 _host = None 1207 1208 _collection_formats: Dict[str, str] = { 1209 } 1210 1211 _path_params: Dict[str, str] = {} 1212 _query_params: List[Tuple[str, str]] = [] 1213 _header_params: Dict[str, Optional[str]] = _headers or {} 1214 _form_params: List[Tuple[str, str]] = [] 1215 _files: Dict[ 1216 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 1217 ] = {} 1218 _body_params: Optional[bytes] = None 1219 1220 # process the path parameters 1221 if organization_id is not None: 1222 _path_params['organizationId'] = organization_id 1223 if pipeline_id is not None: 1224 _path_params['pipelineId'] = pipeline_id 1225 # process the query parameters 1226 # process the header parameters 1227 # process the form parameters 1228 # process the body parameter 1229 1230 1231 # set the HTTP header `Accept` 1232 if 'Accept' not in _header_params: 1233 _header_params['Accept'] = self.api_client.select_header_accept( 1234 [ 1235 'application/json' 1236 ] 1237 ) 1238 1239 1240 # authentication setting 1241 _auth_settings: List[str] = [ 1242 'bearerAuth' 1243 ] 1244 1245 return self.api_client.param_serialize( 1246 method='GET', 1247 resource_path='/org/{organizationId}/pipelines/{pipelineId}', 1248 path_params=_path_params, 1249 query_params=_query_params, 1250 header_params=_header_params, 1251 body=_body_params, 1252 post_params=_form_params, 1253 files=_files, 1254 auth_settings=_auth_settings, 1255 collection_formats=_collection_formats, 1256 _host=_host, 1257 _request_auth=_request_auth 1258 ) 1259 1260 1261 1262 1263 @validate_call 1264 def get_pipeline_events( 1265 self, 1266 organization_id: StrictStr, 1267 pipeline_id: StrictStr, 1268 next_token: Optional[StrictStr] = None, 1269 _request_timeout: Union[ 1270 None, 1271 Annotated[StrictFloat, Field(gt=0)], 1272 Tuple[ 1273 Annotated[StrictFloat, Field(gt=0)], 1274 Annotated[StrictFloat, Field(gt=0)] 1275 ] 1276 ] = None, 1277 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1278 _content_type: Optional[StrictStr] = None, 1279 _headers: Optional[Dict[StrictStr, Any]] = None, 1280 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1281 ) -> GetPipelineEventsResponse: 1282 """Get pipeline events 1283 1284 Get pipeline events 1285 1286 :param organization_id: (required) 1287 :type organization_id: str 1288 :param pipeline_id: (required) 1289 :type pipeline_id: str 1290 :param next_token: 1291 :type next_token: str 1292 :param _request_timeout: timeout setting for this request. If one 1293 number provided, it will be total request 1294 timeout. It can also be a pair (tuple) of 1295 (connection, read) timeouts. 1296 :type _request_timeout: int, tuple(int, int), optional 1297 :param _request_auth: set to override the auth_settings for an a single 1298 request; this effectively ignores the 1299 authentication in the spec for a single request. 1300 :type _request_auth: dict, optional 1301 :param _content_type: force content-type for the request. 1302 :type _content_type: str, Optional 1303 :param _headers: set to override the headers for a single 1304 request; this effectively ignores the headers 1305 in the spec for a single request. 1306 :type _headers: dict, optional 1307 :param _host_index: set to override the host_index for a single 1308 request; this effectively ignores the host_index 1309 in the spec for a single request. 1310 :type _host_index: int, optional 1311 :return: Returns the result object. 1312 """ # noqa: E501 1313 1314 _param = self._get_pipeline_events_serialize( 1315 organization_id=organization_id, 1316 pipeline_id=pipeline_id, 1317 next_token=next_token, 1318 _request_auth=_request_auth, 1319 _content_type=_content_type, 1320 _headers=_headers, 1321 _host_index=_host_index 1322 ) 1323 1324 _response_types_map: Dict[str, Optional[str]] = { 1325 '200': "GetPipelineEventsResponse", 1326 '400': "GetWorkspaces400Response", 1327 '401': "GetWorkspaces400Response", 1328 '403': "GetWorkspaces400Response", 1329 '404': "GetWorkspaces400Response", 1330 '500': "GetWorkspaces400Response", 1331 } 1332 response_data = self.api_client.call_api( 1333 *_param, 1334 _request_timeout=_request_timeout 1335 ) 1336 response_data.read() 1337 return self.api_client.response_deserialize( 1338 response_data=response_data, 1339 response_types_map=_response_types_map, 1340 ).data 1341 1342 1343 @validate_call 1344 def get_pipeline_events_with_http_info( 1345 self, 1346 organization_id: StrictStr, 1347 pipeline_id: StrictStr, 1348 next_token: Optional[StrictStr] = None, 1349 _request_timeout: Union[ 1350 None, 1351 Annotated[StrictFloat, Field(gt=0)], 1352 Tuple[ 1353 Annotated[StrictFloat, Field(gt=0)], 1354 Annotated[StrictFloat, Field(gt=0)] 1355 ] 1356 ] = None, 1357 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1358 _content_type: Optional[StrictStr] = None, 1359 _headers: Optional[Dict[StrictStr, Any]] = None, 1360 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1361 ) -> ApiResponse[GetPipelineEventsResponse]: 1362 """Get pipeline events 1363 1364 Get pipeline events 1365 1366 :param organization_id: (required) 1367 :type organization_id: str 1368 :param pipeline_id: (required) 1369 :type pipeline_id: str 1370 :param next_token: 1371 :type next_token: str 1372 :param _request_timeout: timeout setting for this request. If one 1373 number provided, it will be total request 1374 timeout. It can also be a pair (tuple) of 1375 (connection, read) timeouts. 1376 :type _request_timeout: int, tuple(int, int), optional 1377 :param _request_auth: set to override the auth_settings for an a single 1378 request; this effectively ignores the 1379 authentication in the spec for a single request. 1380 :type _request_auth: dict, optional 1381 :param _content_type: force content-type for the request. 1382 :type _content_type: str, Optional 1383 :param _headers: set to override the headers for a single 1384 request; this effectively ignores the headers 1385 in the spec for a single request. 1386 :type _headers: dict, optional 1387 :param _host_index: set to override the host_index for a single 1388 request; this effectively ignores the host_index 1389 in the spec for a single request. 1390 :type _host_index: int, optional 1391 :return: Returns the result object. 1392 """ # noqa: E501 1393 1394 _param = self._get_pipeline_events_serialize( 1395 organization_id=organization_id, 1396 pipeline_id=pipeline_id, 1397 next_token=next_token, 1398 _request_auth=_request_auth, 1399 _content_type=_content_type, 1400 _headers=_headers, 1401 _host_index=_host_index 1402 ) 1403 1404 _response_types_map: Dict[str, Optional[str]] = { 1405 '200': "GetPipelineEventsResponse", 1406 '400': "GetWorkspaces400Response", 1407 '401': "GetWorkspaces400Response", 1408 '403': "GetWorkspaces400Response", 1409 '404': "GetWorkspaces400Response", 1410 '500': "GetWorkspaces400Response", 1411 } 1412 response_data = self.api_client.call_api( 1413 *_param, 1414 _request_timeout=_request_timeout 1415 ) 1416 response_data.read() 1417 return self.api_client.response_deserialize( 1418 response_data=response_data, 1419 response_types_map=_response_types_map, 1420 ) 1421 1422 1423 @validate_call 1424 def get_pipeline_events_without_preload_content( 1425 self, 1426 organization_id: StrictStr, 1427 pipeline_id: StrictStr, 1428 next_token: Optional[StrictStr] = None, 1429 _request_timeout: Union[ 1430 None, 1431 Annotated[StrictFloat, Field(gt=0)], 1432 Tuple[ 1433 Annotated[StrictFloat, Field(gt=0)], 1434 Annotated[StrictFloat, Field(gt=0)] 1435 ] 1436 ] = None, 1437 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1438 _content_type: Optional[StrictStr] = None, 1439 _headers: Optional[Dict[StrictStr, Any]] = None, 1440 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1441 ) -> RESTResponseType: 1442 """Get pipeline events 1443 1444 Get pipeline events 1445 1446 :param organization_id: (required) 1447 :type organization_id: str 1448 :param pipeline_id: (required) 1449 :type pipeline_id: str 1450 :param next_token: 1451 :type next_token: str 1452 :param _request_timeout: timeout setting for this request. If one 1453 number provided, it will be total request 1454 timeout. It can also be a pair (tuple) of 1455 (connection, read) timeouts. 1456 :type _request_timeout: int, tuple(int, int), optional 1457 :param _request_auth: set to override the auth_settings for an a single 1458 request; this effectively ignores the 1459 authentication in the spec for a single request. 1460 :type _request_auth: dict, optional 1461 :param _content_type: force content-type for the request. 1462 :type _content_type: str, Optional 1463 :param _headers: set to override the headers for a single 1464 request; this effectively ignores the headers 1465 in the spec for a single request. 1466 :type _headers: dict, optional 1467 :param _host_index: set to override the host_index for a single 1468 request; this effectively ignores the host_index 1469 in the spec for a single request. 1470 :type _host_index: int, optional 1471 :return: Returns the result object. 1472 """ # noqa: E501 1473 1474 _param = self._get_pipeline_events_serialize( 1475 organization_id=organization_id, 1476 pipeline_id=pipeline_id, 1477 next_token=next_token, 1478 _request_auth=_request_auth, 1479 _content_type=_content_type, 1480 _headers=_headers, 1481 _host_index=_host_index 1482 ) 1483 1484 _response_types_map: Dict[str, Optional[str]] = { 1485 '200': "GetPipelineEventsResponse", 1486 '400': "GetWorkspaces400Response", 1487 '401': "GetWorkspaces400Response", 1488 '403': "GetWorkspaces400Response", 1489 '404': "GetWorkspaces400Response", 1490 '500': "GetWorkspaces400Response", 1491 } 1492 response_data = self.api_client.call_api( 1493 *_param, 1494 _request_timeout=_request_timeout 1495 ) 1496 return response_data.response 1497 1498 1499 def _get_pipeline_events_serialize( 1500 self, 1501 organization_id, 1502 pipeline_id, 1503 next_token, 1504 _request_auth, 1505 _content_type, 1506 _headers, 1507 _host_index, 1508 ) -> RequestSerialized: 1509 1510 _host = None 1511 1512 _collection_formats: Dict[str, str] = { 1513 } 1514 1515 _path_params: Dict[str, str] = {} 1516 _query_params: List[Tuple[str, str]] = [] 1517 _header_params: Dict[str, Optional[str]] = _headers or {} 1518 _form_params: List[Tuple[str, str]] = [] 1519 _files: Dict[ 1520 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 1521 ] = {} 1522 _body_params: Optional[bytes] = None 1523 1524 # process the path parameters 1525 if organization_id is not None: 1526 _path_params['organizationId'] = organization_id 1527 if pipeline_id is not None: 1528 _path_params['pipelineId'] = pipeline_id 1529 # process the query parameters 1530 if next_token is not None: 1531 1532 _query_params.append(('nextToken', next_token)) 1533 1534 # process the header parameters 1535 # process the form parameters 1536 # process the body parameter 1537 1538 1539 # set the HTTP header `Accept` 1540 if 'Accept' not in _header_params: 1541 _header_params['Accept'] = self.api_client.select_header_accept( 1542 [ 1543 'application/json' 1544 ] 1545 ) 1546 1547 1548 # authentication setting 1549 _auth_settings: List[str] = [ 1550 'bearerAuth' 1551 ] 1552 1553 return self.api_client.param_serialize( 1554 method='GET', 1555 resource_path='/org/{organizationId}/pipelines/{pipelineId}/events', 1556 path_params=_path_params, 1557 query_params=_query_params, 1558 header_params=_header_params, 1559 body=_body_params, 1560 post_params=_form_params, 1561 files=_files, 1562 auth_settings=_auth_settings, 1563 collection_formats=_collection_formats, 1564 _host=_host, 1565 _request_auth=_request_auth 1566 ) 1567 1568 1569 1570 1571 @validate_call 1572 def get_pipeline_metrics( 1573 self, 1574 organization_id: StrictStr, 1575 pipeline_id: StrictStr, 1576 _request_timeout: Union[ 1577 None, 1578 Annotated[StrictFloat, Field(gt=0)], 1579 Tuple[ 1580 Annotated[StrictFloat, Field(gt=0)], 1581 Annotated[StrictFloat, Field(gt=0)] 1582 ] 1583 ] = None, 1584 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1585 _content_type: Optional[StrictStr] = None, 1586 _headers: Optional[Dict[StrictStr, Any]] = None, 1587 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1588 ) -> GetPipelineMetricsResponse: 1589 """Get pipeline metrics 1590 1591 Get pipeline metrics 1592 1593 :param organization_id: (required) 1594 :type organization_id: str 1595 :param pipeline_id: (required) 1596 :type pipeline_id: str 1597 :param _request_timeout: timeout setting for this request. If one 1598 number provided, it will be total request 1599 timeout. It can also be a pair (tuple) of 1600 (connection, read) timeouts. 1601 :type _request_timeout: int, tuple(int, int), optional 1602 :param _request_auth: set to override the auth_settings for an a single 1603 request; this effectively ignores the 1604 authentication in the spec for a single request. 1605 :type _request_auth: dict, optional 1606 :param _content_type: force content-type for the request. 1607 :type _content_type: str, Optional 1608 :param _headers: set to override the headers for a single 1609 request; this effectively ignores the headers 1610 in the spec for a single request. 1611 :type _headers: dict, optional 1612 :param _host_index: set to override the host_index for a single 1613 request; this effectively ignores the host_index 1614 in the spec for a single request. 1615 :type _host_index: int, optional 1616 :return: Returns the result object. 1617 """ # noqa: E501 1618 1619 _param = self._get_pipeline_metrics_serialize( 1620 organization_id=organization_id, 1621 pipeline_id=pipeline_id, 1622 _request_auth=_request_auth, 1623 _content_type=_content_type, 1624 _headers=_headers, 1625 _host_index=_host_index 1626 ) 1627 1628 _response_types_map: Dict[str, Optional[str]] = { 1629 '200': "GetPipelineMetricsResponse", 1630 '400': "GetWorkspaces400Response", 1631 '401': "GetWorkspaces400Response", 1632 '403': "GetWorkspaces400Response", 1633 '404': "GetWorkspaces400Response", 1634 '500': "GetWorkspaces400Response", 1635 } 1636 response_data = self.api_client.call_api( 1637 *_param, 1638 _request_timeout=_request_timeout 1639 ) 1640 response_data.read() 1641 return self.api_client.response_deserialize( 1642 response_data=response_data, 1643 response_types_map=_response_types_map, 1644 ).data 1645 1646 1647 @validate_call 1648 def get_pipeline_metrics_with_http_info( 1649 self, 1650 organization_id: StrictStr, 1651 pipeline_id: StrictStr, 1652 _request_timeout: Union[ 1653 None, 1654 Annotated[StrictFloat, Field(gt=0)], 1655 Tuple[ 1656 Annotated[StrictFloat, Field(gt=0)], 1657 Annotated[StrictFloat, Field(gt=0)] 1658 ] 1659 ] = None, 1660 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1661 _content_type: Optional[StrictStr] = None, 1662 _headers: Optional[Dict[StrictStr, Any]] = None, 1663 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1664 ) -> ApiResponse[GetPipelineMetricsResponse]: 1665 """Get pipeline metrics 1666 1667 Get pipeline metrics 1668 1669 :param organization_id: (required) 1670 :type organization_id: str 1671 :param pipeline_id: (required) 1672 :type pipeline_id: str 1673 :param _request_timeout: timeout setting for this request. If one 1674 number provided, it will be total request 1675 timeout. It can also be a pair (tuple) of 1676 (connection, read) timeouts. 1677 :type _request_timeout: int, tuple(int, int), optional 1678 :param _request_auth: set to override the auth_settings for an a single 1679 request; this effectively ignores the 1680 authentication in the spec for a single request. 1681 :type _request_auth: dict, optional 1682 :param _content_type: force content-type for the request. 1683 :type _content_type: str, Optional 1684 :param _headers: set to override the headers for a single 1685 request; this effectively ignores the headers 1686 in the spec for a single request. 1687 :type _headers: dict, optional 1688 :param _host_index: set to override the host_index for a single 1689 request; this effectively ignores the host_index 1690 in the spec for a single request. 1691 :type _host_index: int, optional 1692 :return: Returns the result object. 1693 """ # noqa: E501 1694 1695 _param = self._get_pipeline_metrics_serialize( 1696 organization_id=organization_id, 1697 pipeline_id=pipeline_id, 1698 _request_auth=_request_auth, 1699 _content_type=_content_type, 1700 _headers=_headers, 1701 _host_index=_host_index 1702 ) 1703 1704 _response_types_map: Dict[str, Optional[str]] = { 1705 '200': "GetPipelineMetricsResponse", 1706 '400': "GetWorkspaces400Response", 1707 '401': "GetWorkspaces400Response", 1708 '403': "GetWorkspaces400Response", 1709 '404': "GetWorkspaces400Response", 1710 '500': "GetWorkspaces400Response", 1711 } 1712 response_data = self.api_client.call_api( 1713 *_param, 1714 _request_timeout=_request_timeout 1715 ) 1716 response_data.read() 1717 return self.api_client.response_deserialize( 1718 response_data=response_data, 1719 response_types_map=_response_types_map, 1720 ) 1721 1722 1723 @validate_call 1724 def get_pipeline_metrics_without_preload_content( 1725 self, 1726 organization_id: StrictStr, 1727 pipeline_id: StrictStr, 1728 _request_timeout: Union[ 1729 None, 1730 Annotated[StrictFloat, Field(gt=0)], 1731 Tuple[ 1732 Annotated[StrictFloat, Field(gt=0)], 1733 Annotated[StrictFloat, Field(gt=0)] 1734 ] 1735 ] = None, 1736 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1737 _content_type: Optional[StrictStr] = None, 1738 _headers: Optional[Dict[StrictStr, Any]] = None, 1739 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1740 ) -> RESTResponseType: 1741 """Get pipeline metrics 1742 1743 Get pipeline metrics 1744 1745 :param organization_id: (required) 1746 :type organization_id: str 1747 :param pipeline_id: (required) 1748 :type pipeline_id: str 1749 :param _request_timeout: timeout setting for this request. If one 1750 number provided, it will be total request 1751 timeout. It can also be a pair (tuple) of 1752 (connection, read) timeouts. 1753 :type _request_timeout: int, tuple(int, int), optional 1754 :param _request_auth: set to override the auth_settings for an a single 1755 request; this effectively ignores the 1756 authentication in the spec for a single request. 1757 :type _request_auth: dict, optional 1758 :param _content_type: force content-type for the request. 1759 :type _content_type: str, Optional 1760 :param _headers: set to override the headers for a single 1761 request; this effectively ignores the headers 1762 in the spec for a single request. 1763 :type _headers: dict, optional 1764 :param _host_index: set to override the host_index for a single 1765 request; this effectively ignores the host_index 1766 in the spec for a single request. 1767 :type _host_index: int, optional 1768 :return: Returns the result object. 1769 """ # noqa: E501 1770 1771 _param = self._get_pipeline_metrics_serialize( 1772 organization_id=organization_id, 1773 pipeline_id=pipeline_id, 1774 _request_auth=_request_auth, 1775 _content_type=_content_type, 1776 _headers=_headers, 1777 _host_index=_host_index 1778 ) 1779 1780 _response_types_map: Dict[str, Optional[str]] = { 1781 '200': "GetPipelineMetricsResponse", 1782 '400': "GetWorkspaces400Response", 1783 '401': "GetWorkspaces400Response", 1784 '403': "GetWorkspaces400Response", 1785 '404': "GetWorkspaces400Response", 1786 '500': "GetWorkspaces400Response", 1787 } 1788 response_data = self.api_client.call_api( 1789 *_param, 1790 _request_timeout=_request_timeout 1791 ) 1792 return response_data.response 1793 1794 1795 def _get_pipeline_metrics_serialize( 1796 self, 1797 organization_id, 1798 pipeline_id, 1799 _request_auth, 1800 _content_type, 1801 _headers, 1802 _host_index, 1803 ) -> RequestSerialized: 1804 1805 _host = None 1806 1807 _collection_formats: Dict[str, str] = { 1808 } 1809 1810 _path_params: Dict[str, str] = {} 1811 _query_params: List[Tuple[str, str]] = [] 1812 _header_params: Dict[str, Optional[str]] = _headers or {} 1813 _form_params: List[Tuple[str, str]] = [] 1814 _files: Dict[ 1815 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 1816 ] = {} 1817 _body_params: Optional[bytes] = None 1818 1819 # process the path parameters 1820 if organization_id is not None: 1821 _path_params['organizationId'] = organization_id 1822 if pipeline_id is not None: 1823 _path_params['pipelineId'] = pipeline_id 1824 # process the query parameters 1825 # process the header parameters 1826 # process the form parameters 1827 # process the body parameter 1828 1829 1830 # set the HTTP header `Accept` 1831 if 'Accept' not in _header_params: 1832 _header_params['Accept'] = self.api_client.select_header_accept( 1833 [ 1834 'application/json' 1835 ] 1836 ) 1837 1838 1839 # authentication setting 1840 _auth_settings: List[str] = [ 1841 'bearerAuth' 1842 ] 1843 1844 return self.api_client.param_serialize( 1845 method='GET', 1846 resource_path='/org/{organizationId}/pipelines/{pipelineId}/metrics', 1847 path_params=_path_params, 1848 query_params=_query_params, 1849 header_params=_header_params, 1850 body=_body_params, 1851 post_params=_form_params, 1852 files=_files, 1853 auth_settings=_auth_settings, 1854 collection_formats=_collection_formats, 1855 _host=_host, 1856 _request_auth=_request_auth 1857 ) 1858 1859 1860 1861 1862 @validate_call 1863 def get_pipelines( 1864 self, 1865 organization_id: StrictStr, 1866 workspace_id: Optional[StrictStr] = None, 1867 _request_timeout: Union[ 1868 None, 1869 Annotated[StrictFloat, Field(gt=0)], 1870 Tuple[ 1871 Annotated[StrictFloat, Field(gt=0)], 1872 Annotated[StrictFloat, Field(gt=0)] 1873 ] 1874 ] = None, 1875 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1876 _content_type: Optional[StrictStr] = None, 1877 _headers: Optional[Dict[StrictStr, Any]] = None, 1878 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1879 ) -> GetPipelinesResponse: 1880 """Get all pipelines 1881 1882 Returns a list of all pipelines in the organization 1883 1884 :param organization_id: (required) 1885 :type organization_id: str 1886 :param workspace_id: 1887 :type workspace_id: str 1888 :param _request_timeout: timeout setting for this request. If one 1889 number provided, it will be total request 1890 timeout. It can also be a pair (tuple) of 1891 (connection, read) timeouts. 1892 :type _request_timeout: int, tuple(int, int), optional 1893 :param _request_auth: set to override the auth_settings for an a single 1894 request; this effectively ignores the 1895 authentication in the spec for a single request. 1896 :type _request_auth: dict, optional 1897 :param _content_type: force content-type for the request. 1898 :type _content_type: str, Optional 1899 :param _headers: set to override the headers for a single 1900 request; this effectively ignores the headers 1901 in the spec for a single request. 1902 :type _headers: dict, optional 1903 :param _host_index: set to override the host_index for a single 1904 request; this effectively ignores the host_index 1905 in the spec for a single request. 1906 :type _host_index: int, optional 1907 :return: Returns the result object. 1908 """ # noqa: E501 1909 1910 _param = self._get_pipelines_serialize( 1911 organization_id=organization_id, 1912 workspace_id=workspace_id, 1913 _request_auth=_request_auth, 1914 _content_type=_content_type, 1915 _headers=_headers, 1916 _host_index=_host_index 1917 ) 1918 1919 _response_types_map: Dict[str, Optional[str]] = { 1920 '200': "GetPipelinesResponse", 1921 '400': "GetWorkspaces400Response", 1922 '401': "GetWorkspaces400Response", 1923 '403': "GetWorkspaces400Response", 1924 '404': "GetWorkspaces400Response", 1925 '500': "GetWorkspaces400Response", 1926 } 1927 response_data = self.api_client.call_api( 1928 *_param, 1929 _request_timeout=_request_timeout 1930 ) 1931 response_data.read() 1932 return self.api_client.response_deserialize( 1933 response_data=response_data, 1934 response_types_map=_response_types_map, 1935 ).data 1936 1937 1938 @validate_call 1939 def get_pipelines_with_http_info( 1940 self, 1941 organization_id: StrictStr, 1942 workspace_id: Optional[StrictStr] = None, 1943 _request_timeout: Union[ 1944 None, 1945 Annotated[StrictFloat, Field(gt=0)], 1946 Tuple[ 1947 Annotated[StrictFloat, Field(gt=0)], 1948 Annotated[StrictFloat, Field(gt=0)] 1949 ] 1950 ] = None, 1951 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1952 _content_type: Optional[StrictStr] = None, 1953 _headers: Optional[Dict[StrictStr, Any]] = None, 1954 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1955 ) -> ApiResponse[GetPipelinesResponse]: 1956 """Get all pipelines 1957 1958 Returns a list of all pipelines in the organization 1959 1960 :param organization_id: (required) 1961 :type organization_id: str 1962 :param workspace_id: 1963 :type workspace_id: str 1964 :param _request_timeout: timeout setting for this request. If one 1965 number provided, it will be total request 1966 timeout. It can also be a pair (tuple) of 1967 (connection, read) timeouts. 1968 :type _request_timeout: int, tuple(int, int), optional 1969 :param _request_auth: set to override the auth_settings for an a single 1970 request; this effectively ignores the 1971 authentication in the spec for a single request. 1972 :type _request_auth: dict, optional 1973 :param _content_type: force content-type for the request. 1974 :type _content_type: str, Optional 1975 :param _headers: set to override the headers for a single 1976 request; this effectively ignores the headers 1977 in the spec for a single request. 1978 :type _headers: dict, optional 1979 :param _host_index: set to override the host_index for a single 1980 request; this effectively ignores the host_index 1981 in the spec for a single request. 1982 :type _host_index: int, optional 1983 :return: Returns the result object. 1984 """ # noqa: E501 1985 1986 _param = self._get_pipelines_serialize( 1987 organization_id=organization_id, 1988 workspace_id=workspace_id, 1989 _request_auth=_request_auth, 1990 _content_type=_content_type, 1991 _headers=_headers, 1992 _host_index=_host_index 1993 ) 1994 1995 _response_types_map: Dict[str, Optional[str]] = { 1996 '200': "GetPipelinesResponse", 1997 '400': "GetWorkspaces400Response", 1998 '401': "GetWorkspaces400Response", 1999 '403': "GetWorkspaces400Response", 2000 '404': "GetWorkspaces400Response", 2001 '500': "GetWorkspaces400Response", 2002 } 2003 response_data = self.api_client.call_api( 2004 *_param, 2005 _request_timeout=_request_timeout 2006 ) 2007 response_data.read() 2008 return self.api_client.response_deserialize( 2009 response_data=response_data, 2010 response_types_map=_response_types_map, 2011 ) 2012 2013 2014 @validate_call 2015 def get_pipelines_without_preload_content( 2016 self, 2017 organization_id: StrictStr, 2018 workspace_id: Optional[StrictStr] = None, 2019 _request_timeout: Union[ 2020 None, 2021 Annotated[StrictFloat, Field(gt=0)], 2022 Tuple[ 2023 Annotated[StrictFloat, Field(gt=0)], 2024 Annotated[StrictFloat, Field(gt=0)] 2025 ] 2026 ] = None, 2027 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2028 _content_type: Optional[StrictStr] = None, 2029 _headers: Optional[Dict[StrictStr, Any]] = None, 2030 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2031 ) -> RESTResponseType: 2032 """Get all pipelines 2033 2034 Returns a list of all pipelines in the organization 2035 2036 :param organization_id: (required) 2037 :type organization_id: str 2038 :param workspace_id: 2039 :type workspace_id: str 2040 :param _request_timeout: timeout setting for this request. If one 2041 number provided, it will be total request 2042 timeout. It can also be a pair (tuple) of 2043 (connection, read) timeouts. 2044 :type _request_timeout: int, tuple(int, int), optional 2045 :param _request_auth: set to override the auth_settings for an a single 2046 request; this effectively ignores the 2047 authentication in the spec for a single request. 2048 :type _request_auth: dict, optional 2049 :param _content_type: force content-type for the request. 2050 :type _content_type: str, Optional 2051 :param _headers: set to override the headers for a single 2052 request; this effectively ignores the headers 2053 in the spec for a single request. 2054 :type _headers: dict, optional 2055 :param _host_index: set to override the host_index for a single 2056 request; this effectively ignores the host_index 2057 in the spec for a single request. 2058 :type _host_index: int, optional 2059 :return: Returns the result object. 2060 """ # noqa: E501 2061 2062 _param = self._get_pipelines_serialize( 2063 organization_id=organization_id, 2064 workspace_id=workspace_id, 2065 _request_auth=_request_auth, 2066 _content_type=_content_type, 2067 _headers=_headers, 2068 _host_index=_host_index 2069 ) 2070 2071 _response_types_map: Dict[str, Optional[str]] = { 2072 '200': "GetPipelinesResponse", 2073 '400': "GetWorkspaces400Response", 2074 '401': "GetWorkspaces400Response", 2075 '403': "GetWorkspaces400Response", 2076 '404': "GetWorkspaces400Response", 2077 '500': "GetWorkspaces400Response", 2078 } 2079 response_data = self.api_client.call_api( 2080 *_param, 2081 _request_timeout=_request_timeout 2082 ) 2083 return response_data.response 2084 2085 2086 def _get_pipelines_serialize( 2087 self, 2088 organization_id, 2089 workspace_id, 2090 _request_auth, 2091 _content_type, 2092 _headers, 2093 _host_index, 2094 ) -> RequestSerialized: 2095 2096 _host = None 2097 2098 _collection_formats: Dict[str, str] = { 2099 } 2100 2101 _path_params: Dict[str, str] = {} 2102 _query_params: List[Tuple[str, str]] = [] 2103 _header_params: Dict[str, Optional[str]] = _headers or {} 2104 _form_params: List[Tuple[str, str]] = [] 2105 _files: Dict[ 2106 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 2107 ] = {} 2108 _body_params: Optional[bytes] = None 2109 2110 # process the path parameters 2111 if organization_id is not None: 2112 _path_params['organizationId'] = organization_id 2113 # process the query parameters 2114 if workspace_id is not None: 2115 2116 _query_params.append(('workspaceId', workspace_id)) 2117 2118 # process the header parameters 2119 # process the form parameters 2120 # process the body parameter 2121 2122 2123 # set the HTTP header `Accept` 2124 if 'Accept' not in _header_params: 2125 _header_params['Accept'] = self.api_client.select_header_accept( 2126 [ 2127 'application/json' 2128 ] 2129 ) 2130 2131 2132 # authentication setting 2133 _auth_settings: List[str] = [ 2134 'bearerAuth' 2135 ] 2136 2137 return self.api_client.param_serialize( 2138 method='GET', 2139 resource_path='/org/{organizationId}/pipelines', 2140 path_params=_path_params, 2141 query_params=_query_params, 2142 header_params=_header_params, 2143 body=_body_params, 2144 post_params=_form_params, 2145 files=_files, 2146 auth_settings=_auth_settings, 2147 collection_formats=_collection_formats, 2148 _host=_host, 2149 _request_auth=_request_auth 2150 ) 2151 2152 2153 2154 2155 @validate_call 2156 def retrieve_documents( 2157 self, 2158 organization_id: StrictStr, 2159 pipeline_id: StrictStr, 2160 retrieve_documents_request: RetrieveDocumentsRequest, 2161 _request_timeout: Union[ 2162 None, 2163 Annotated[StrictFloat, Field(gt=0)], 2164 Tuple[ 2165 Annotated[StrictFloat, Field(gt=0)], 2166 Annotated[StrictFloat, Field(gt=0)] 2167 ] 2168 ] = None, 2169 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2170 _content_type: Optional[StrictStr] = None, 2171 _headers: Optional[Dict[StrictStr, Any]] = None, 2172 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2173 ) -> RetrieveDocumentsResponse: 2174 """Retrieve documents from a pipeline 2175 2176 Retrieve documents from a pipeline 2177 2178 :param organization_id: (required) 2179 :type organization_id: str 2180 :param pipeline_id: (required) 2181 :type pipeline_id: str 2182 :param retrieve_documents_request: (required) 2183 :type retrieve_documents_request: RetrieveDocumentsRequest 2184 :param _request_timeout: timeout setting for this request. If one 2185 number provided, it will be total request 2186 timeout. It can also be a pair (tuple) of 2187 (connection, read) timeouts. 2188 :type _request_timeout: int, tuple(int, int), optional 2189 :param _request_auth: set to override the auth_settings for an a single 2190 request; this effectively ignores the 2191 authentication in the spec for a single request. 2192 :type _request_auth: dict, optional 2193 :param _content_type: force content-type for the request. 2194 :type _content_type: str, Optional 2195 :param _headers: set to override the headers for a single 2196 request; this effectively ignores the headers 2197 in the spec for a single request. 2198 :type _headers: dict, optional 2199 :param _host_index: set to override the host_index for a single 2200 request; this effectively ignores the host_index 2201 in the spec for a single request. 2202 :type _host_index: int, optional 2203 :return: Returns the result object. 2204 """ # noqa: E501 2205 2206 _param = self._retrieve_documents_serialize( 2207 organization_id=organization_id, 2208 pipeline_id=pipeline_id, 2209 retrieve_documents_request=retrieve_documents_request, 2210 _request_auth=_request_auth, 2211 _content_type=_content_type, 2212 _headers=_headers, 2213 _host_index=_host_index 2214 ) 2215 2216 _response_types_map: Dict[str, Optional[str]] = { 2217 '200': "RetrieveDocumentsResponse", 2218 '400': "GetWorkspaces400Response", 2219 '401': "GetWorkspaces400Response", 2220 '403': "GetWorkspaces400Response", 2221 '404': "GetWorkspaces400Response", 2222 '500': "GetWorkspaces400Response", 2223 } 2224 response_data = self.api_client.call_api( 2225 *_param, 2226 _request_timeout=_request_timeout 2227 ) 2228 response_data.read() 2229 return self.api_client.response_deserialize( 2230 response_data=response_data, 2231 response_types_map=_response_types_map, 2232 ).data 2233 2234 2235 @validate_call 2236 def retrieve_documents_with_http_info( 2237 self, 2238 organization_id: StrictStr, 2239 pipeline_id: StrictStr, 2240 retrieve_documents_request: RetrieveDocumentsRequest, 2241 _request_timeout: Union[ 2242 None, 2243 Annotated[StrictFloat, Field(gt=0)], 2244 Tuple[ 2245 Annotated[StrictFloat, Field(gt=0)], 2246 Annotated[StrictFloat, Field(gt=0)] 2247 ] 2248 ] = None, 2249 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2250 _content_type: Optional[StrictStr] = None, 2251 _headers: Optional[Dict[StrictStr, Any]] = None, 2252 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2253 ) -> ApiResponse[RetrieveDocumentsResponse]: 2254 """Retrieve documents from a pipeline 2255 2256 Retrieve documents from a pipeline 2257 2258 :param organization_id: (required) 2259 :type organization_id: str 2260 :param pipeline_id: (required) 2261 :type pipeline_id: str 2262 :param retrieve_documents_request: (required) 2263 :type retrieve_documents_request: RetrieveDocumentsRequest 2264 :param _request_timeout: timeout setting for this request. If one 2265 number provided, it will be total request 2266 timeout. It can also be a pair (tuple) of 2267 (connection, read) timeouts. 2268 :type _request_timeout: int, tuple(int, int), optional 2269 :param _request_auth: set to override the auth_settings for an a single 2270 request; this effectively ignores the 2271 authentication in the spec for a single request. 2272 :type _request_auth: dict, optional 2273 :param _content_type: force content-type for the request. 2274 :type _content_type: str, Optional 2275 :param _headers: set to override the headers for a single 2276 request; this effectively ignores the headers 2277 in the spec for a single request. 2278 :type _headers: dict, optional 2279 :param _host_index: set to override the host_index for a single 2280 request; this effectively ignores the host_index 2281 in the spec for a single request. 2282 :type _host_index: int, optional 2283 :return: Returns the result object. 2284 """ # noqa: E501 2285 2286 _param = self._retrieve_documents_serialize( 2287 organization_id=organization_id, 2288 pipeline_id=pipeline_id, 2289 retrieve_documents_request=retrieve_documents_request, 2290 _request_auth=_request_auth, 2291 _content_type=_content_type, 2292 _headers=_headers, 2293 _host_index=_host_index 2294 ) 2295 2296 _response_types_map: Dict[str, Optional[str]] = { 2297 '200': "RetrieveDocumentsResponse", 2298 '400': "GetWorkspaces400Response", 2299 '401': "GetWorkspaces400Response", 2300 '403': "GetWorkspaces400Response", 2301 '404': "GetWorkspaces400Response", 2302 '500': "GetWorkspaces400Response", 2303 } 2304 response_data = self.api_client.call_api( 2305 *_param, 2306 _request_timeout=_request_timeout 2307 ) 2308 response_data.read() 2309 return self.api_client.response_deserialize( 2310 response_data=response_data, 2311 response_types_map=_response_types_map, 2312 ) 2313 2314 2315 @validate_call 2316 def retrieve_documents_without_preload_content( 2317 self, 2318 organization_id: StrictStr, 2319 pipeline_id: StrictStr, 2320 retrieve_documents_request: RetrieveDocumentsRequest, 2321 _request_timeout: Union[ 2322 None, 2323 Annotated[StrictFloat, Field(gt=0)], 2324 Tuple[ 2325 Annotated[StrictFloat, Field(gt=0)], 2326 Annotated[StrictFloat, Field(gt=0)] 2327 ] 2328 ] = None, 2329 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2330 _content_type: Optional[StrictStr] = None, 2331 _headers: Optional[Dict[StrictStr, Any]] = None, 2332 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2333 ) -> RESTResponseType: 2334 """Retrieve documents from a pipeline 2335 2336 Retrieve documents from a pipeline 2337 2338 :param organization_id: (required) 2339 :type organization_id: str 2340 :param pipeline_id: (required) 2341 :type pipeline_id: str 2342 :param retrieve_documents_request: (required) 2343 :type retrieve_documents_request: RetrieveDocumentsRequest 2344 :param _request_timeout: timeout setting for this request. If one 2345 number provided, it will be total request 2346 timeout. It can also be a pair (tuple) of 2347 (connection, read) timeouts. 2348 :type _request_timeout: int, tuple(int, int), optional 2349 :param _request_auth: set to override the auth_settings for an a single 2350 request; this effectively ignores the 2351 authentication in the spec for a single request. 2352 :type _request_auth: dict, optional 2353 :param _content_type: force content-type for the request. 2354 :type _content_type: str, Optional 2355 :param _headers: set to override the headers for a single 2356 request; this effectively ignores the headers 2357 in the spec for a single request. 2358 :type _headers: dict, optional 2359 :param _host_index: set to override the host_index for a single 2360 request; this effectively ignores the host_index 2361 in the spec for a single request. 2362 :type _host_index: int, optional 2363 :return: Returns the result object. 2364 """ # noqa: E501 2365 2366 _param = self._retrieve_documents_serialize( 2367 organization_id=organization_id, 2368 pipeline_id=pipeline_id, 2369 retrieve_documents_request=retrieve_documents_request, 2370 _request_auth=_request_auth, 2371 _content_type=_content_type, 2372 _headers=_headers, 2373 _host_index=_host_index 2374 ) 2375 2376 _response_types_map: Dict[str, Optional[str]] = { 2377 '200': "RetrieveDocumentsResponse", 2378 '400': "GetWorkspaces400Response", 2379 '401': "GetWorkspaces400Response", 2380 '403': "GetWorkspaces400Response", 2381 '404': "GetWorkspaces400Response", 2382 '500': "GetWorkspaces400Response", 2383 } 2384 response_data = self.api_client.call_api( 2385 *_param, 2386 _request_timeout=_request_timeout 2387 ) 2388 return response_data.response 2389 2390 2391 def _retrieve_documents_serialize( 2392 self, 2393 organization_id, 2394 pipeline_id, 2395 retrieve_documents_request, 2396 _request_auth, 2397 _content_type, 2398 _headers, 2399 _host_index, 2400 ) -> RequestSerialized: 2401 2402 _host = None 2403 2404 _collection_formats: Dict[str, str] = { 2405 } 2406 2407 _path_params: Dict[str, str] = {} 2408 _query_params: List[Tuple[str, str]] = [] 2409 _header_params: Dict[str, Optional[str]] = _headers or {} 2410 _form_params: List[Tuple[str, str]] = [] 2411 _files: Dict[ 2412 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 2413 ] = {} 2414 _body_params: Optional[bytes] = None 2415 2416 # process the path parameters 2417 if organization_id is not None: 2418 _path_params['organizationId'] = organization_id 2419 if pipeline_id is not None: 2420 _path_params['pipelineId'] = pipeline_id 2421 # process the query parameters 2422 # process the header parameters 2423 # process the form parameters 2424 # process the body parameter 2425 if retrieve_documents_request is not None: 2426 _body_params = retrieve_documents_request 2427 2428 2429 # set the HTTP header `Accept` 2430 if 'Accept' not in _header_params: 2431 _header_params['Accept'] = self.api_client.select_header_accept( 2432 [ 2433 'application/json' 2434 ] 2435 ) 2436 2437 # set the HTTP header `Content-Type` 2438 if _content_type: 2439 _header_params['Content-Type'] = _content_type 2440 else: 2441 _default_content_type = ( 2442 self.api_client.select_header_content_type( 2443 [ 2444 'application/json' 2445 ] 2446 ) 2447 ) 2448 if _default_content_type is not None: 2449 _header_params['Content-Type'] = _default_content_type 2450 2451 # authentication setting 2452 _auth_settings: List[str] = [ 2453 'bearerAuth' 2454 ] 2455 2456 return self.api_client.param_serialize( 2457 method='POST', 2458 resource_path='/org/{organizationId}/pipelines/{pipelineId}/retrieval', 2459 path_params=_path_params, 2460 query_params=_query_params, 2461 header_params=_header_params, 2462 body=_body_params, 2463 post_params=_form_params, 2464 files=_files, 2465 auth_settings=_auth_settings, 2466 collection_formats=_collection_formats, 2467 _host=_host, 2468 _request_auth=_request_auth 2469 ) 2470 2471 2472 2473 2474 @validate_call 2475 def start_deep_research( 2476 self, 2477 organization_id: StrictStr, 2478 pipeline_id: StrictStr, 2479 start_deep_research_request: StartDeepResearchRequest, 2480 _request_timeout: Union[ 2481 None, 2482 Annotated[StrictFloat, Field(gt=0)], 2483 Tuple[ 2484 Annotated[StrictFloat, Field(gt=0)], 2485 Annotated[StrictFloat, Field(gt=0)] 2486 ] 2487 ] = None, 2488 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2489 _content_type: Optional[StrictStr] = None, 2490 _headers: Optional[Dict[StrictStr, Any]] = None, 2491 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2492 ) -> StartDeepResearchResponse: 2493 """Start a deep research 2494 2495 Start a deep research 2496 2497 :param organization_id: (required) 2498 :type organization_id: str 2499 :param pipeline_id: (required) 2500 :type pipeline_id: str 2501 :param start_deep_research_request: (required) 2502 :type start_deep_research_request: StartDeepResearchRequest 2503 :param _request_timeout: timeout setting for this request. If one 2504 number provided, it will be total request 2505 timeout. It can also be a pair (tuple) of 2506 (connection, read) timeouts. 2507 :type _request_timeout: int, tuple(int, int), optional 2508 :param _request_auth: set to override the auth_settings for an a single 2509 request; this effectively ignores the 2510 authentication in the spec for a single request. 2511 :type _request_auth: dict, optional 2512 :param _content_type: force content-type for the request. 2513 :type _content_type: str, Optional 2514 :param _headers: set to override the headers for a single 2515 request; this effectively ignores the headers 2516 in the spec for a single request. 2517 :type _headers: dict, optional 2518 :param _host_index: set to override the host_index for a single 2519 request; this effectively ignores the host_index 2520 in the spec for a single request. 2521 :type _host_index: int, optional 2522 :return: Returns the result object. 2523 """ # noqa: E501 2524 2525 _param = self._start_deep_research_serialize( 2526 organization_id=organization_id, 2527 pipeline_id=pipeline_id, 2528 start_deep_research_request=start_deep_research_request, 2529 _request_auth=_request_auth, 2530 _content_type=_content_type, 2531 _headers=_headers, 2532 _host_index=_host_index 2533 ) 2534 2535 _response_types_map: Dict[str, Optional[str]] = { 2536 '200': "StartDeepResearchResponse", 2537 '400': "GetWorkspaces400Response", 2538 '401': "GetWorkspaces400Response", 2539 '403': "GetWorkspaces400Response", 2540 '404': "GetWorkspaces400Response", 2541 '500': "GetWorkspaces400Response", 2542 } 2543 response_data = self.api_client.call_api( 2544 *_param, 2545 _request_timeout=_request_timeout 2546 ) 2547 response_data.read() 2548 return self.api_client.response_deserialize( 2549 response_data=response_data, 2550 response_types_map=_response_types_map, 2551 ).data 2552 2553 2554 @validate_call 2555 def start_deep_research_with_http_info( 2556 self, 2557 organization_id: StrictStr, 2558 pipeline_id: StrictStr, 2559 start_deep_research_request: StartDeepResearchRequest, 2560 _request_timeout: Union[ 2561 None, 2562 Annotated[StrictFloat, Field(gt=0)], 2563 Tuple[ 2564 Annotated[StrictFloat, Field(gt=0)], 2565 Annotated[StrictFloat, Field(gt=0)] 2566 ] 2567 ] = None, 2568 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2569 _content_type: Optional[StrictStr] = None, 2570 _headers: Optional[Dict[StrictStr, Any]] = None, 2571 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2572 ) -> ApiResponse[StartDeepResearchResponse]: 2573 """Start a deep research 2574 2575 Start a deep research 2576 2577 :param organization_id: (required) 2578 :type organization_id: str 2579 :param pipeline_id: (required) 2580 :type pipeline_id: str 2581 :param start_deep_research_request: (required) 2582 :type start_deep_research_request: StartDeepResearchRequest 2583 :param _request_timeout: timeout setting for this request. If one 2584 number provided, it will be total request 2585 timeout. It can also be a pair (tuple) of 2586 (connection, read) timeouts. 2587 :type _request_timeout: int, tuple(int, int), optional 2588 :param _request_auth: set to override the auth_settings for an a single 2589 request; this effectively ignores the 2590 authentication in the spec for a single request. 2591 :type _request_auth: dict, optional 2592 :param _content_type: force content-type for the request. 2593 :type _content_type: str, Optional 2594 :param _headers: set to override the headers for a single 2595 request; this effectively ignores the headers 2596 in the spec for a single request. 2597 :type _headers: dict, optional 2598 :param _host_index: set to override the host_index for a single 2599 request; this effectively ignores the host_index 2600 in the spec for a single request. 2601 :type _host_index: int, optional 2602 :return: Returns the result object. 2603 """ # noqa: E501 2604 2605 _param = self._start_deep_research_serialize( 2606 organization_id=organization_id, 2607 pipeline_id=pipeline_id, 2608 start_deep_research_request=start_deep_research_request, 2609 _request_auth=_request_auth, 2610 _content_type=_content_type, 2611 _headers=_headers, 2612 _host_index=_host_index 2613 ) 2614 2615 _response_types_map: Dict[str, Optional[str]] = { 2616 '200': "StartDeepResearchResponse", 2617 '400': "GetWorkspaces400Response", 2618 '401': "GetWorkspaces400Response", 2619 '403': "GetWorkspaces400Response", 2620 '404': "GetWorkspaces400Response", 2621 '500': "GetWorkspaces400Response", 2622 } 2623 response_data = self.api_client.call_api( 2624 *_param, 2625 _request_timeout=_request_timeout 2626 ) 2627 response_data.read() 2628 return self.api_client.response_deserialize( 2629 response_data=response_data, 2630 response_types_map=_response_types_map, 2631 ) 2632 2633 2634 @validate_call 2635 def start_deep_research_without_preload_content( 2636 self, 2637 organization_id: StrictStr, 2638 pipeline_id: StrictStr, 2639 start_deep_research_request: StartDeepResearchRequest, 2640 _request_timeout: Union[ 2641 None, 2642 Annotated[StrictFloat, Field(gt=0)], 2643 Tuple[ 2644 Annotated[StrictFloat, Field(gt=0)], 2645 Annotated[StrictFloat, Field(gt=0)] 2646 ] 2647 ] = None, 2648 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2649 _content_type: Optional[StrictStr] = None, 2650 _headers: Optional[Dict[StrictStr, Any]] = None, 2651 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2652 ) -> RESTResponseType: 2653 """Start a deep research 2654 2655 Start a deep research 2656 2657 :param organization_id: (required) 2658 :type organization_id: str 2659 :param pipeline_id: (required) 2660 :type pipeline_id: str 2661 :param start_deep_research_request: (required) 2662 :type start_deep_research_request: StartDeepResearchRequest 2663 :param _request_timeout: timeout setting for this request. If one 2664 number provided, it will be total request 2665 timeout. It can also be a pair (tuple) of 2666 (connection, read) timeouts. 2667 :type _request_timeout: int, tuple(int, int), optional 2668 :param _request_auth: set to override the auth_settings for an a single 2669 request; this effectively ignores the 2670 authentication in the spec for a single request. 2671 :type _request_auth: dict, optional 2672 :param _content_type: force content-type for the request. 2673 :type _content_type: str, Optional 2674 :param _headers: set to override the headers for a single 2675 request; this effectively ignores the headers 2676 in the spec for a single request. 2677 :type _headers: dict, optional 2678 :param _host_index: set to override the host_index for a single 2679 request; this effectively ignores the host_index 2680 in the spec for a single request. 2681 :type _host_index: int, optional 2682 :return: Returns the result object. 2683 """ # noqa: E501 2684 2685 _param = self._start_deep_research_serialize( 2686 organization_id=organization_id, 2687 pipeline_id=pipeline_id, 2688 start_deep_research_request=start_deep_research_request, 2689 _request_auth=_request_auth, 2690 _content_type=_content_type, 2691 _headers=_headers, 2692 _host_index=_host_index 2693 ) 2694 2695 _response_types_map: Dict[str, Optional[str]] = { 2696 '200': "StartDeepResearchResponse", 2697 '400': "GetWorkspaces400Response", 2698 '401': "GetWorkspaces400Response", 2699 '403': "GetWorkspaces400Response", 2700 '404': "GetWorkspaces400Response", 2701 '500': "GetWorkspaces400Response", 2702 } 2703 response_data = self.api_client.call_api( 2704 *_param, 2705 _request_timeout=_request_timeout 2706 ) 2707 return response_data.response 2708 2709 2710 def _start_deep_research_serialize( 2711 self, 2712 organization_id, 2713 pipeline_id, 2714 start_deep_research_request, 2715 _request_auth, 2716 _content_type, 2717 _headers, 2718 _host_index, 2719 ) -> RequestSerialized: 2720 2721 _host = None 2722 2723 _collection_formats: Dict[str, str] = { 2724 } 2725 2726 _path_params: Dict[str, str] = {} 2727 _query_params: List[Tuple[str, str]] = [] 2728 _header_params: Dict[str, Optional[str]] = _headers or {} 2729 _form_params: List[Tuple[str, str]] = [] 2730 _files: Dict[ 2731 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 2732 ] = {} 2733 _body_params: Optional[bytes] = None 2734 2735 # process the path parameters 2736 if organization_id is not None: 2737 _path_params['organizationId'] = organization_id 2738 if pipeline_id is not None: 2739 _path_params['pipelineId'] = pipeline_id 2740 # process the query parameters 2741 # process the header parameters 2742 # process the form parameters 2743 # process the body parameter 2744 if start_deep_research_request is not None: 2745 _body_params = start_deep_research_request 2746 2747 2748 # set the HTTP header `Accept` 2749 if 'Accept' not in _header_params: 2750 _header_params['Accept'] = self.api_client.select_header_accept( 2751 [ 2752 'application/json' 2753 ] 2754 ) 2755 2756 # set the HTTP header `Content-Type` 2757 if _content_type: 2758 _header_params['Content-Type'] = _content_type 2759 else: 2760 _default_content_type = ( 2761 self.api_client.select_header_content_type( 2762 [ 2763 'application/json' 2764 ] 2765 ) 2766 ) 2767 if _default_content_type is not None: 2768 _header_params['Content-Type'] = _default_content_type 2769 2770 # authentication setting 2771 _auth_settings: List[str] = [ 2772 'bearerAuth' 2773 ] 2774 2775 return self.api_client.param_serialize( 2776 method='POST', 2777 resource_path='/org/{organizationId}/pipelines/{pipelineId}/deep-research', 2778 path_params=_path_params, 2779 query_params=_query_params, 2780 header_params=_header_params, 2781 body=_body_params, 2782 post_params=_form_params, 2783 files=_files, 2784 auth_settings=_auth_settings, 2785 collection_formats=_collection_formats, 2786 _host=_host, 2787 _request_auth=_request_auth 2788 ) 2789 2790 2791 2792 2793 @validate_call 2794 def start_pipeline( 2795 self, 2796 organization_id: StrictStr, 2797 pipeline_id: StrictStr, 2798 _request_timeout: Union[ 2799 None, 2800 Annotated[StrictFloat, Field(gt=0)], 2801 Tuple[ 2802 Annotated[StrictFloat, Field(gt=0)], 2803 Annotated[StrictFloat, Field(gt=0)] 2804 ] 2805 ] = None, 2806 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2807 _content_type: Optional[StrictStr] = None, 2808 _headers: Optional[Dict[StrictStr, Any]] = None, 2809 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2810 ) -> StartPipelineResponse: 2811 """Start a pipeline 2812 2813 Start a pipeline 2814 2815 :param organization_id: (required) 2816 :type organization_id: str 2817 :param pipeline_id: (required) 2818 :type pipeline_id: str 2819 :param _request_timeout: timeout setting for this request. If one 2820 number provided, it will be total request 2821 timeout. It can also be a pair (tuple) of 2822 (connection, read) timeouts. 2823 :type _request_timeout: int, tuple(int, int), optional 2824 :param _request_auth: set to override the auth_settings for an a single 2825 request; this effectively ignores the 2826 authentication in the spec for a single request. 2827 :type _request_auth: dict, optional 2828 :param _content_type: force content-type for the request. 2829 :type _content_type: str, Optional 2830 :param _headers: set to override the headers for a single 2831 request; this effectively ignores the headers 2832 in the spec for a single request. 2833 :type _headers: dict, optional 2834 :param _host_index: set to override the host_index for a single 2835 request; this effectively ignores the host_index 2836 in the spec for a single request. 2837 :type _host_index: int, optional 2838 :return: Returns the result object. 2839 """ # noqa: E501 2840 2841 _param = self._start_pipeline_serialize( 2842 organization_id=organization_id, 2843 pipeline_id=pipeline_id, 2844 _request_auth=_request_auth, 2845 _content_type=_content_type, 2846 _headers=_headers, 2847 _host_index=_host_index 2848 ) 2849 2850 _response_types_map: Dict[str, Optional[str]] = { 2851 '200': "StartPipelineResponse", 2852 '400': "GetWorkspaces400Response", 2853 '401': "GetWorkspaces400Response", 2854 '403': "GetWorkspaces400Response", 2855 '404': "GetWorkspaces400Response", 2856 '500': "GetWorkspaces400Response", 2857 } 2858 response_data = self.api_client.call_api( 2859 *_param, 2860 _request_timeout=_request_timeout 2861 ) 2862 response_data.read() 2863 return self.api_client.response_deserialize( 2864 response_data=response_data, 2865 response_types_map=_response_types_map, 2866 ).data 2867 2868 2869 @validate_call 2870 def start_pipeline_with_http_info( 2871 self, 2872 organization_id: StrictStr, 2873 pipeline_id: StrictStr, 2874 _request_timeout: Union[ 2875 None, 2876 Annotated[StrictFloat, Field(gt=0)], 2877 Tuple[ 2878 Annotated[StrictFloat, Field(gt=0)], 2879 Annotated[StrictFloat, Field(gt=0)] 2880 ] 2881 ] = None, 2882 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2883 _content_type: Optional[StrictStr] = None, 2884 _headers: Optional[Dict[StrictStr, Any]] = None, 2885 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2886 ) -> ApiResponse[StartPipelineResponse]: 2887 """Start a pipeline 2888 2889 Start a pipeline 2890 2891 :param organization_id: (required) 2892 :type organization_id: str 2893 :param pipeline_id: (required) 2894 :type pipeline_id: str 2895 :param _request_timeout: timeout setting for this request. If one 2896 number provided, it will be total request 2897 timeout. It can also be a pair (tuple) of 2898 (connection, read) timeouts. 2899 :type _request_timeout: int, tuple(int, int), optional 2900 :param _request_auth: set to override the auth_settings for an a single 2901 request; this effectively ignores the 2902 authentication in the spec for a single request. 2903 :type _request_auth: dict, optional 2904 :param _content_type: force content-type for the request. 2905 :type _content_type: str, Optional 2906 :param _headers: set to override the headers for a single 2907 request; this effectively ignores the headers 2908 in the spec for a single request. 2909 :type _headers: dict, optional 2910 :param _host_index: set to override the host_index for a single 2911 request; this effectively ignores the host_index 2912 in the spec for a single request. 2913 :type _host_index: int, optional 2914 :return: Returns the result object. 2915 """ # noqa: E501 2916 2917 _param = self._start_pipeline_serialize( 2918 organization_id=organization_id, 2919 pipeline_id=pipeline_id, 2920 _request_auth=_request_auth, 2921 _content_type=_content_type, 2922 _headers=_headers, 2923 _host_index=_host_index 2924 ) 2925 2926 _response_types_map: Dict[str, Optional[str]] = { 2927 '200': "StartPipelineResponse", 2928 '400': "GetWorkspaces400Response", 2929 '401': "GetWorkspaces400Response", 2930 '403': "GetWorkspaces400Response", 2931 '404': "GetWorkspaces400Response", 2932 '500': "GetWorkspaces400Response", 2933 } 2934 response_data = self.api_client.call_api( 2935 *_param, 2936 _request_timeout=_request_timeout 2937 ) 2938 response_data.read() 2939 return self.api_client.response_deserialize( 2940 response_data=response_data, 2941 response_types_map=_response_types_map, 2942 ) 2943 2944 2945 @validate_call 2946 def start_pipeline_without_preload_content( 2947 self, 2948 organization_id: StrictStr, 2949 pipeline_id: StrictStr, 2950 _request_timeout: Union[ 2951 None, 2952 Annotated[StrictFloat, Field(gt=0)], 2953 Tuple[ 2954 Annotated[StrictFloat, Field(gt=0)], 2955 Annotated[StrictFloat, Field(gt=0)] 2956 ] 2957 ] = None, 2958 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2959 _content_type: Optional[StrictStr] = None, 2960 _headers: Optional[Dict[StrictStr, Any]] = None, 2961 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2962 ) -> RESTResponseType: 2963 """Start a pipeline 2964 2965 Start a pipeline 2966 2967 :param organization_id: (required) 2968 :type organization_id: str 2969 :param pipeline_id: (required) 2970 :type pipeline_id: str 2971 :param _request_timeout: timeout setting for this request. If one 2972 number provided, it will be total request 2973 timeout. It can also be a pair (tuple) of 2974 (connection, read) timeouts. 2975 :type _request_timeout: int, tuple(int, int), optional 2976 :param _request_auth: set to override the auth_settings for an a single 2977 request; this effectively ignores the 2978 authentication in the spec for a single request. 2979 :type _request_auth: dict, optional 2980 :param _content_type: force content-type for the request. 2981 :type _content_type: str, Optional 2982 :param _headers: set to override the headers for a single 2983 request; this effectively ignores the headers 2984 in the spec for a single request. 2985 :type _headers: dict, optional 2986 :param _host_index: set to override the host_index for a single 2987 request; this effectively ignores the host_index 2988 in the spec for a single request. 2989 :type _host_index: int, optional 2990 :return: Returns the result object. 2991 """ # noqa: E501 2992 2993 _param = self._start_pipeline_serialize( 2994 organization_id=organization_id, 2995 pipeline_id=pipeline_id, 2996 _request_auth=_request_auth, 2997 _content_type=_content_type, 2998 _headers=_headers, 2999 _host_index=_host_index 3000 ) 3001 3002 _response_types_map: Dict[str, Optional[str]] = { 3003 '200': "StartPipelineResponse", 3004 '400': "GetWorkspaces400Response", 3005 '401': "GetWorkspaces400Response", 3006 '403': "GetWorkspaces400Response", 3007 '404': "GetWorkspaces400Response", 3008 '500': "GetWorkspaces400Response", 3009 } 3010 response_data = self.api_client.call_api( 3011 *_param, 3012 _request_timeout=_request_timeout 3013 ) 3014 return response_data.response 3015 3016 3017 def _start_pipeline_serialize( 3018 self, 3019 organization_id, 3020 pipeline_id, 3021 _request_auth, 3022 _content_type, 3023 _headers, 3024 _host_index, 3025 ) -> RequestSerialized: 3026 3027 _host = None 3028 3029 _collection_formats: Dict[str, str] = { 3030 } 3031 3032 _path_params: Dict[str, str] = {} 3033 _query_params: List[Tuple[str, str]] = [] 3034 _header_params: Dict[str, Optional[str]] = _headers or {} 3035 _form_params: List[Tuple[str, str]] = [] 3036 _files: Dict[ 3037 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 3038 ] = {} 3039 _body_params: Optional[bytes] = None 3040 3041 # process the path parameters 3042 if organization_id is not None: 3043 _path_params['organizationId'] = organization_id 3044 if pipeline_id is not None: 3045 _path_params['pipelineId'] = pipeline_id 3046 # process the query parameters 3047 # process the header parameters 3048 # process the form parameters 3049 # process the body parameter 3050 3051 3052 # set the HTTP header `Accept` 3053 if 'Accept' not in _header_params: 3054 _header_params['Accept'] = self.api_client.select_header_accept( 3055 [ 3056 'application/json' 3057 ] 3058 ) 3059 3060 3061 # authentication setting 3062 _auth_settings: List[str] = [ 3063 'bearerAuth' 3064 ] 3065 3066 return self.api_client.param_serialize( 3067 method='POST', 3068 resource_path='/org/{organizationId}/pipelines/{pipelineId}/start', 3069 path_params=_path_params, 3070 query_params=_query_params, 3071 header_params=_header_params, 3072 body=_body_params, 3073 post_params=_form_params, 3074 files=_files, 3075 auth_settings=_auth_settings, 3076 collection_formats=_collection_formats, 3077 _host=_host, 3078 _request_auth=_request_auth 3079 ) 3080 3081 3082 3083 3084 @validate_call 3085 def stop_pipeline( 3086 self, 3087 organization_id: StrictStr, 3088 pipeline_id: StrictStr, 3089 _request_timeout: Union[ 3090 None, 3091 Annotated[StrictFloat, Field(gt=0)], 3092 Tuple[ 3093 Annotated[StrictFloat, Field(gt=0)], 3094 Annotated[StrictFloat, Field(gt=0)] 3095 ] 3096 ] = None, 3097 _request_auth: Optional[Dict[StrictStr, Any]] = None, 3098 _content_type: Optional[StrictStr] = None, 3099 _headers: Optional[Dict[StrictStr, Any]] = None, 3100 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 3101 ) -> StopPipelineResponse: 3102 """Stop a pipeline 3103 3104 Stop a pipeline 3105 3106 :param organization_id: (required) 3107 :type organization_id: str 3108 :param pipeline_id: (required) 3109 :type pipeline_id: str 3110 :param _request_timeout: timeout setting for this request. If one 3111 number provided, it will be total request 3112 timeout. It can also be a pair (tuple) of 3113 (connection, read) timeouts. 3114 :type _request_timeout: int, tuple(int, int), optional 3115 :param _request_auth: set to override the auth_settings for an a single 3116 request; this effectively ignores the 3117 authentication in the spec for a single request. 3118 :type _request_auth: dict, optional 3119 :param _content_type: force content-type for the request. 3120 :type _content_type: str, Optional 3121 :param _headers: set to override the headers for a single 3122 request; this effectively ignores the headers 3123 in the spec for a single request. 3124 :type _headers: dict, optional 3125 :param _host_index: set to override the host_index for a single 3126 request; this effectively ignores the host_index 3127 in the spec for a single request. 3128 :type _host_index: int, optional 3129 :return: Returns the result object. 3130 """ # noqa: E501 3131 3132 _param = self._stop_pipeline_serialize( 3133 organization_id=organization_id, 3134 pipeline_id=pipeline_id, 3135 _request_auth=_request_auth, 3136 _content_type=_content_type, 3137 _headers=_headers, 3138 _host_index=_host_index 3139 ) 3140 3141 _response_types_map: Dict[str, Optional[str]] = { 3142 '200': "StopPipelineResponse", 3143 '400': "GetWorkspaces400Response", 3144 '401': "GetWorkspaces400Response", 3145 '403': "GetWorkspaces400Response", 3146 '404': "GetWorkspaces400Response", 3147 '500': "GetWorkspaces400Response", 3148 } 3149 response_data = self.api_client.call_api( 3150 *_param, 3151 _request_timeout=_request_timeout 3152 ) 3153 response_data.read() 3154 return self.api_client.response_deserialize( 3155 response_data=response_data, 3156 response_types_map=_response_types_map, 3157 ).data 3158 3159 3160 @validate_call 3161 def stop_pipeline_with_http_info( 3162 self, 3163 organization_id: StrictStr, 3164 pipeline_id: StrictStr, 3165 _request_timeout: Union[ 3166 None, 3167 Annotated[StrictFloat, Field(gt=0)], 3168 Tuple[ 3169 Annotated[StrictFloat, Field(gt=0)], 3170 Annotated[StrictFloat, Field(gt=0)] 3171 ] 3172 ] = None, 3173 _request_auth: Optional[Dict[StrictStr, Any]] = None, 3174 _content_type: Optional[StrictStr] = None, 3175 _headers: Optional[Dict[StrictStr, Any]] = None, 3176 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 3177 ) -> ApiResponse[StopPipelineResponse]: 3178 """Stop a pipeline 3179 3180 Stop a pipeline 3181 3182 :param organization_id: (required) 3183 :type organization_id: str 3184 :param pipeline_id: (required) 3185 :type pipeline_id: str 3186 :param _request_timeout: timeout setting for this request. If one 3187 number provided, it will be total request 3188 timeout. It can also be a pair (tuple) of 3189 (connection, read) timeouts. 3190 :type _request_timeout: int, tuple(int, int), optional 3191 :param _request_auth: set to override the auth_settings for an a single 3192 request; this effectively ignores the 3193 authentication in the spec for a single request. 3194 :type _request_auth: dict, optional 3195 :param _content_type: force content-type for the request. 3196 :type _content_type: str, Optional 3197 :param _headers: set to override the headers for a single 3198 request; this effectively ignores the headers 3199 in the spec for a single request. 3200 :type _headers: dict, optional 3201 :param _host_index: set to override the host_index for a single 3202 request; this effectively ignores the host_index 3203 in the spec for a single request. 3204 :type _host_index: int, optional 3205 :return: Returns the result object. 3206 """ # noqa: E501 3207 3208 _param = self._stop_pipeline_serialize( 3209 organization_id=organization_id, 3210 pipeline_id=pipeline_id, 3211 _request_auth=_request_auth, 3212 _content_type=_content_type, 3213 _headers=_headers, 3214 _host_index=_host_index 3215 ) 3216 3217 _response_types_map: Dict[str, Optional[str]] = { 3218 '200': "StopPipelineResponse", 3219 '400': "GetWorkspaces400Response", 3220 '401': "GetWorkspaces400Response", 3221 '403': "GetWorkspaces400Response", 3222 '404': "GetWorkspaces400Response", 3223 '500': "GetWorkspaces400Response", 3224 } 3225 response_data = self.api_client.call_api( 3226 *_param, 3227 _request_timeout=_request_timeout 3228 ) 3229 response_data.read() 3230 return self.api_client.response_deserialize( 3231 response_data=response_data, 3232 response_types_map=_response_types_map, 3233 ) 3234 3235 3236 @validate_call 3237 def stop_pipeline_without_preload_content( 3238 self, 3239 organization_id: StrictStr, 3240 pipeline_id: StrictStr, 3241 _request_timeout: Union[ 3242 None, 3243 Annotated[StrictFloat, Field(gt=0)], 3244 Tuple[ 3245 Annotated[StrictFloat, Field(gt=0)], 3246 Annotated[StrictFloat, Field(gt=0)] 3247 ] 3248 ] = None, 3249 _request_auth: Optional[Dict[StrictStr, Any]] = None, 3250 _content_type: Optional[StrictStr] = None, 3251 _headers: Optional[Dict[StrictStr, Any]] = None, 3252 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 3253 ) -> RESTResponseType: 3254 """Stop a pipeline 3255 3256 Stop a pipeline 3257 3258 :param organization_id: (required) 3259 :type organization_id: str 3260 :param pipeline_id: (required) 3261 :type pipeline_id: str 3262 :param _request_timeout: timeout setting for this request. If one 3263 number provided, it will be total request 3264 timeout. It can also be a pair (tuple) of 3265 (connection, read) timeouts. 3266 :type _request_timeout: int, tuple(int, int), optional 3267 :param _request_auth: set to override the auth_settings for an a single 3268 request; this effectively ignores the 3269 authentication in the spec for a single request. 3270 :type _request_auth: dict, optional 3271 :param _content_type: force content-type for the request. 3272 :type _content_type: str, Optional 3273 :param _headers: set to override the headers for a single 3274 request; this effectively ignores the headers 3275 in the spec for a single request. 3276 :type _headers: dict, optional 3277 :param _host_index: set to override the host_index for a single 3278 request; this effectively ignores the host_index 3279 in the spec for a single request. 3280 :type _host_index: int, optional 3281 :return: Returns the result object. 3282 """ # noqa: E501 3283 3284 _param = self._stop_pipeline_serialize( 3285 organization_id=organization_id, 3286 pipeline_id=pipeline_id, 3287 _request_auth=_request_auth, 3288 _content_type=_content_type, 3289 _headers=_headers, 3290 _host_index=_host_index 3291 ) 3292 3293 _response_types_map: Dict[str, Optional[str]] = { 3294 '200': "StopPipelineResponse", 3295 '400': "GetWorkspaces400Response", 3296 '401': "GetWorkspaces400Response", 3297 '403': "GetWorkspaces400Response", 3298 '404': "GetWorkspaces400Response", 3299 '500': "GetWorkspaces400Response", 3300 } 3301 response_data = self.api_client.call_api( 3302 *_param, 3303 _request_timeout=_request_timeout 3304 ) 3305 return response_data.response 3306 3307 3308 def _stop_pipeline_serialize( 3309 self, 3310 organization_id, 3311 pipeline_id, 3312 _request_auth, 3313 _content_type, 3314 _headers, 3315 _host_index, 3316 ) -> RequestSerialized: 3317 3318 _host = None 3319 3320 _collection_formats: Dict[str, str] = { 3321 } 3322 3323 _path_params: Dict[str, str] = {} 3324 _query_params: List[Tuple[str, str]] = [] 3325 _header_params: Dict[str, Optional[str]] = _headers or {} 3326 _form_params: List[Tuple[str, str]] = [] 3327 _files: Dict[ 3328 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 3329 ] = {} 3330 _body_params: Optional[bytes] = None 3331 3332 # process the path parameters 3333 if organization_id is not None: 3334 _path_params['organizationId'] = organization_id 3335 if pipeline_id is not None: 3336 _path_params['pipelineId'] = pipeline_id 3337 # process the query parameters 3338 # process the header parameters 3339 # process the form parameters 3340 # process the body parameter 3341 3342 3343 # set the HTTP header `Accept` 3344 if 'Accept' not in _header_params: 3345 _header_params['Accept'] = self.api_client.select_header_accept( 3346 [ 3347 'application/json' 3348 ] 3349 ) 3350 3351 3352 # authentication setting 3353 _auth_settings: List[str] = [ 3354 'bearerAuth' 3355 ] 3356 3357 return self.api_client.param_serialize( 3358 method='POST', 3359 resource_path='/org/{organizationId}/pipelines/{pipelineId}/stop', 3360 path_params=_path_params, 3361 query_params=_query_params, 3362 header_params=_header_params, 3363 body=_body_params, 3364 post_params=_form_params, 3365 files=_files, 3366 auth_settings=_auth_settings, 3367 collection_formats=_collection_formats, 3368 _host=_host, 3369 _request_auth=_request_auth 3370 )
class
PipelinesApi:
42class PipelinesApi: 43 """NOTE: This class is auto generated by OpenAPI Generator 44 Ref: https://openapi-generator.tech 45 46 Do not edit the class manually. 47 """ 48 49 def __init__(self, api_client=None) -> None: 50 if api_client is None: 51 api_client = ApiClient.get_default() 52 self.api_client = api_client 53 54 55 @validate_call 56 def create_pipeline( 57 self, 58 organization_id: StrictStr, 59 pipeline_configuration_schema: PipelineConfigurationSchema, 60 workspace_id: Optional[StrictStr] = None, 61 _request_timeout: Union[ 62 None, 63 Annotated[StrictFloat, Field(gt=0)], 64 Tuple[ 65 Annotated[StrictFloat, Field(gt=0)], 66 Annotated[StrictFloat, Field(gt=0)] 67 ] 68 ] = None, 69 _request_auth: Optional[Dict[StrictStr, Any]] = None, 70 _content_type: Optional[StrictStr] = None, 71 _headers: Optional[Dict[StrictStr, Any]] = None, 72 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 73 ) -> CreatePipelineResponse: 74 """Create a new pipeline 75 76 Creates a new pipeline with source connectors, destination connector, and AI platform configuration. The specific configuration fields required depend on the connector types selected. 77 78 :param organization_id: (required) 79 :type organization_id: str 80 :param pipeline_configuration_schema: (required) 81 :type pipeline_configuration_schema: PipelineConfigurationSchema 82 :param workspace_id: 83 :type workspace_id: str 84 :param _request_timeout: timeout setting for this request. If one 85 number provided, it will be total request 86 timeout. It can also be a pair (tuple) of 87 (connection, read) timeouts. 88 :type _request_timeout: int, tuple(int, int), optional 89 :param _request_auth: set to override the auth_settings for an a single 90 request; this effectively ignores the 91 authentication in the spec for a single request. 92 :type _request_auth: dict, optional 93 :param _content_type: force content-type for the request. 94 :type _content_type: str, Optional 95 :param _headers: set to override the headers for a single 96 request; this effectively ignores the headers 97 in the spec for a single request. 98 :type _headers: dict, optional 99 :param _host_index: set to override the host_index for a single 100 request; this effectively ignores the host_index 101 in the spec for a single request. 102 :type _host_index: int, optional 103 :return: Returns the result object. 104 """ # noqa: E501 105 106 _param = self._create_pipeline_serialize( 107 organization_id=organization_id, 108 pipeline_configuration_schema=pipeline_configuration_schema, 109 workspace_id=workspace_id, 110 _request_auth=_request_auth, 111 _content_type=_content_type, 112 _headers=_headers, 113 _host_index=_host_index 114 ) 115 116 _response_types_map: Dict[str, Optional[str]] = { 117 '200': "CreatePipelineResponse", 118 '400': "GetWorkspaces400Response", 119 '401': "GetWorkspaces400Response", 120 '403': "GetWorkspaces400Response", 121 '404': "GetWorkspaces400Response", 122 '500': "GetWorkspaces400Response", 123 } 124 response_data = self.api_client.call_api( 125 *_param, 126 _request_timeout=_request_timeout 127 ) 128 response_data.read() 129 return self.api_client.response_deserialize( 130 response_data=response_data, 131 response_types_map=_response_types_map, 132 ).data 133 134 135 @validate_call 136 def create_pipeline_with_http_info( 137 self, 138 organization_id: StrictStr, 139 pipeline_configuration_schema: PipelineConfigurationSchema, 140 workspace_id: Optional[StrictStr] = None, 141 _request_timeout: Union[ 142 None, 143 Annotated[StrictFloat, Field(gt=0)], 144 Tuple[ 145 Annotated[StrictFloat, Field(gt=0)], 146 Annotated[StrictFloat, Field(gt=0)] 147 ] 148 ] = None, 149 _request_auth: Optional[Dict[StrictStr, Any]] = None, 150 _content_type: Optional[StrictStr] = None, 151 _headers: Optional[Dict[StrictStr, Any]] = None, 152 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 153 ) -> ApiResponse[CreatePipelineResponse]: 154 """Create a new pipeline 155 156 Creates a new pipeline with source connectors, destination connector, and AI platform configuration. The specific configuration fields required depend on the connector types selected. 157 158 :param organization_id: (required) 159 :type organization_id: str 160 :param pipeline_configuration_schema: (required) 161 :type pipeline_configuration_schema: PipelineConfigurationSchema 162 :param workspace_id: 163 :type workspace_id: str 164 :param _request_timeout: timeout setting for this request. If one 165 number provided, it will be total request 166 timeout. It can also be a pair (tuple) of 167 (connection, read) timeouts. 168 :type _request_timeout: int, tuple(int, int), optional 169 :param _request_auth: set to override the auth_settings for an a single 170 request; this effectively ignores the 171 authentication in the spec for a single request. 172 :type _request_auth: dict, optional 173 :param _content_type: force content-type for the request. 174 :type _content_type: str, Optional 175 :param _headers: set to override the headers for a single 176 request; this effectively ignores the headers 177 in the spec for a single request. 178 :type _headers: dict, optional 179 :param _host_index: set to override the host_index for a single 180 request; this effectively ignores the host_index 181 in the spec for a single request. 182 :type _host_index: int, optional 183 :return: Returns the result object. 184 """ # noqa: E501 185 186 _param = self._create_pipeline_serialize( 187 organization_id=organization_id, 188 pipeline_configuration_schema=pipeline_configuration_schema, 189 workspace_id=workspace_id, 190 _request_auth=_request_auth, 191 _content_type=_content_type, 192 _headers=_headers, 193 _host_index=_host_index 194 ) 195 196 _response_types_map: Dict[str, Optional[str]] = { 197 '200': "CreatePipelineResponse", 198 '400': "GetWorkspaces400Response", 199 '401': "GetWorkspaces400Response", 200 '403': "GetWorkspaces400Response", 201 '404': "GetWorkspaces400Response", 202 '500': "GetWorkspaces400Response", 203 } 204 response_data = self.api_client.call_api( 205 *_param, 206 _request_timeout=_request_timeout 207 ) 208 response_data.read() 209 return self.api_client.response_deserialize( 210 response_data=response_data, 211 response_types_map=_response_types_map, 212 ) 213 214 215 @validate_call 216 def create_pipeline_without_preload_content( 217 self, 218 organization_id: StrictStr, 219 pipeline_configuration_schema: PipelineConfigurationSchema, 220 workspace_id: Optional[StrictStr] = None, 221 _request_timeout: Union[ 222 None, 223 Annotated[StrictFloat, Field(gt=0)], 224 Tuple[ 225 Annotated[StrictFloat, Field(gt=0)], 226 Annotated[StrictFloat, Field(gt=0)] 227 ] 228 ] = None, 229 _request_auth: Optional[Dict[StrictStr, Any]] = None, 230 _content_type: Optional[StrictStr] = None, 231 _headers: Optional[Dict[StrictStr, Any]] = None, 232 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 233 ) -> RESTResponseType: 234 """Create a new pipeline 235 236 Creates a new pipeline with source connectors, destination connector, and AI platform configuration. The specific configuration fields required depend on the connector types selected. 237 238 :param organization_id: (required) 239 :type organization_id: str 240 :param pipeline_configuration_schema: (required) 241 :type pipeline_configuration_schema: PipelineConfigurationSchema 242 :param workspace_id: 243 :type workspace_id: str 244 :param _request_timeout: timeout setting for this request. If one 245 number provided, it will be total request 246 timeout. It can also be a pair (tuple) of 247 (connection, read) timeouts. 248 :type _request_timeout: int, tuple(int, int), optional 249 :param _request_auth: set to override the auth_settings for an a single 250 request; this effectively ignores the 251 authentication in the spec for a single request. 252 :type _request_auth: dict, optional 253 :param _content_type: force content-type for the request. 254 :type _content_type: str, Optional 255 :param _headers: set to override the headers for a single 256 request; this effectively ignores the headers 257 in the spec for a single request. 258 :type _headers: dict, optional 259 :param _host_index: set to override the host_index for a single 260 request; this effectively ignores the host_index 261 in the spec for a single request. 262 :type _host_index: int, optional 263 :return: Returns the result object. 264 """ # noqa: E501 265 266 _param = self._create_pipeline_serialize( 267 organization_id=organization_id, 268 pipeline_configuration_schema=pipeline_configuration_schema, 269 workspace_id=workspace_id, 270 _request_auth=_request_auth, 271 _content_type=_content_type, 272 _headers=_headers, 273 _host_index=_host_index 274 ) 275 276 _response_types_map: Dict[str, Optional[str]] = { 277 '200': "CreatePipelineResponse", 278 '400': "GetWorkspaces400Response", 279 '401': "GetWorkspaces400Response", 280 '403': "GetWorkspaces400Response", 281 '404': "GetWorkspaces400Response", 282 '500': "GetWorkspaces400Response", 283 } 284 response_data = self.api_client.call_api( 285 *_param, 286 _request_timeout=_request_timeout 287 ) 288 return response_data.response 289 290 291 def _create_pipeline_serialize( 292 self, 293 organization_id, 294 pipeline_configuration_schema, 295 workspace_id, 296 _request_auth, 297 _content_type, 298 _headers, 299 _host_index, 300 ) -> RequestSerialized: 301 302 _host = None 303 304 _collection_formats: Dict[str, str] = { 305 } 306 307 _path_params: Dict[str, str] = {} 308 _query_params: List[Tuple[str, str]] = [] 309 _header_params: Dict[str, Optional[str]] = _headers or {} 310 _form_params: List[Tuple[str, str]] = [] 311 _files: Dict[ 312 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 313 ] = {} 314 _body_params: Optional[bytes] = None 315 316 # process the path parameters 317 if organization_id is not None: 318 _path_params['organizationId'] = organization_id 319 # process the query parameters 320 if workspace_id is not None: 321 322 _query_params.append(('workspaceId', workspace_id)) 323 324 # process the header parameters 325 # process the form parameters 326 # process the body parameter 327 if pipeline_configuration_schema is not None: 328 _body_params = pipeline_configuration_schema 329 330 331 # set the HTTP header `Accept` 332 if 'Accept' not in _header_params: 333 _header_params['Accept'] = self.api_client.select_header_accept( 334 [ 335 'application/json' 336 ] 337 ) 338 339 # set the HTTP header `Content-Type` 340 if _content_type: 341 _header_params['Content-Type'] = _content_type 342 else: 343 _default_content_type = ( 344 self.api_client.select_header_content_type( 345 [ 346 'application/json' 347 ] 348 ) 349 ) 350 if _default_content_type is not None: 351 _header_params['Content-Type'] = _default_content_type 352 353 # authentication setting 354 _auth_settings: List[str] = [ 355 'bearerAuth' 356 ] 357 358 return self.api_client.param_serialize( 359 method='POST', 360 resource_path='/org/{organizationId}/pipelines', 361 path_params=_path_params, 362 query_params=_query_params, 363 header_params=_header_params, 364 body=_body_params, 365 post_params=_form_params, 366 files=_files, 367 auth_settings=_auth_settings, 368 collection_formats=_collection_formats, 369 _host=_host, 370 _request_auth=_request_auth 371 ) 372 373 374 375 376 @validate_call 377 def delete_pipeline( 378 self, 379 organization_id: StrictStr, 380 pipeline_id: StrictStr, 381 _request_timeout: Union[ 382 None, 383 Annotated[StrictFloat, Field(gt=0)], 384 Tuple[ 385 Annotated[StrictFloat, Field(gt=0)], 386 Annotated[StrictFloat, Field(gt=0)] 387 ] 388 ] = None, 389 _request_auth: Optional[Dict[StrictStr, Any]] = None, 390 _content_type: Optional[StrictStr] = None, 391 _headers: Optional[Dict[StrictStr, Any]] = None, 392 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 393 ) -> DeletePipelineResponse: 394 """Delete a pipeline 395 396 Delete a pipeline 397 398 :param organization_id: (required) 399 :type organization_id: str 400 :param pipeline_id: (required) 401 :type pipeline_id: str 402 :param _request_timeout: timeout setting for this request. If one 403 number provided, it will be total request 404 timeout. It can also be a pair (tuple) of 405 (connection, read) timeouts. 406 :type _request_timeout: int, tuple(int, int), optional 407 :param _request_auth: set to override the auth_settings for an a single 408 request; this effectively ignores the 409 authentication in the spec for a single request. 410 :type _request_auth: dict, optional 411 :param _content_type: force content-type for the request. 412 :type _content_type: str, Optional 413 :param _headers: set to override the headers for a single 414 request; this effectively ignores the headers 415 in the spec for a single request. 416 :type _headers: dict, optional 417 :param _host_index: set to override the host_index for a single 418 request; this effectively ignores the host_index 419 in the spec for a single request. 420 :type _host_index: int, optional 421 :return: Returns the result object. 422 """ # noqa: E501 423 424 _param = self._delete_pipeline_serialize( 425 organization_id=organization_id, 426 pipeline_id=pipeline_id, 427 _request_auth=_request_auth, 428 _content_type=_content_type, 429 _headers=_headers, 430 _host_index=_host_index 431 ) 432 433 _response_types_map: Dict[str, Optional[str]] = { 434 '200': "DeletePipelineResponse", 435 '400': "GetWorkspaces400Response", 436 '401': "GetWorkspaces400Response", 437 '403': "GetWorkspaces400Response", 438 '404': "GetWorkspaces400Response", 439 '500': "GetWorkspaces400Response", 440 } 441 response_data = self.api_client.call_api( 442 *_param, 443 _request_timeout=_request_timeout 444 ) 445 response_data.read() 446 return self.api_client.response_deserialize( 447 response_data=response_data, 448 response_types_map=_response_types_map, 449 ).data 450 451 452 @validate_call 453 def delete_pipeline_with_http_info( 454 self, 455 organization_id: StrictStr, 456 pipeline_id: StrictStr, 457 _request_timeout: Union[ 458 None, 459 Annotated[StrictFloat, Field(gt=0)], 460 Tuple[ 461 Annotated[StrictFloat, Field(gt=0)], 462 Annotated[StrictFloat, Field(gt=0)] 463 ] 464 ] = None, 465 _request_auth: Optional[Dict[StrictStr, Any]] = None, 466 _content_type: Optional[StrictStr] = None, 467 _headers: Optional[Dict[StrictStr, Any]] = None, 468 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 469 ) -> ApiResponse[DeletePipelineResponse]: 470 """Delete a pipeline 471 472 Delete a pipeline 473 474 :param organization_id: (required) 475 :type organization_id: str 476 :param pipeline_id: (required) 477 :type pipeline_id: str 478 :param _request_timeout: timeout setting for this request. If one 479 number provided, it will be total request 480 timeout. It can also be a pair (tuple) of 481 (connection, read) timeouts. 482 :type _request_timeout: int, tuple(int, int), optional 483 :param _request_auth: set to override the auth_settings for an a single 484 request; this effectively ignores the 485 authentication in the spec for a single request. 486 :type _request_auth: dict, optional 487 :param _content_type: force content-type for the request. 488 :type _content_type: str, Optional 489 :param _headers: set to override the headers for a single 490 request; this effectively ignores the headers 491 in the spec for a single request. 492 :type _headers: dict, optional 493 :param _host_index: set to override the host_index for a single 494 request; this effectively ignores the host_index 495 in the spec for a single request. 496 :type _host_index: int, optional 497 :return: Returns the result object. 498 """ # noqa: E501 499 500 _param = self._delete_pipeline_serialize( 501 organization_id=organization_id, 502 pipeline_id=pipeline_id, 503 _request_auth=_request_auth, 504 _content_type=_content_type, 505 _headers=_headers, 506 _host_index=_host_index 507 ) 508 509 _response_types_map: Dict[str, Optional[str]] = { 510 '200': "DeletePipelineResponse", 511 '400': "GetWorkspaces400Response", 512 '401': "GetWorkspaces400Response", 513 '403': "GetWorkspaces400Response", 514 '404': "GetWorkspaces400Response", 515 '500': "GetWorkspaces400Response", 516 } 517 response_data = self.api_client.call_api( 518 *_param, 519 _request_timeout=_request_timeout 520 ) 521 response_data.read() 522 return self.api_client.response_deserialize( 523 response_data=response_data, 524 response_types_map=_response_types_map, 525 ) 526 527 528 @validate_call 529 def delete_pipeline_without_preload_content( 530 self, 531 organization_id: StrictStr, 532 pipeline_id: StrictStr, 533 _request_timeout: Union[ 534 None, 535 Annotated[StrictFloat, Field(gt=0)], 536 Tuple[ 537 Annotated[StrictFloat, Field(gt=0)], 538 Annotated[StrictFloat, Field(gt=0)] 539 ] 540 ] = None, 541 _request_auth: Optional[Dict[StrictStr, Any]] = None, 542 _content_type: Optional[StrictStr] = None, 543 _headers: Optional[Dict[StrictStr, Any]] = None, 544 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 545 ) -> RESTResponseType: 546 """Delete a pipeline 547 548 Delete a pipeline 549 550 :param organization_id: (required) 551 :type organization_id: str 552 :param pipeline_id: (required) 553 :type pipeline_id: str 554 :param _request_timeout: timeout setting for this request. If one 555 number provided, it will be total request 556 timeout. It can also be a pair (tuple) of 557 (connection, read) timeouts. 558 :type _request_timeout: int, tuple(int, int), optional 559 :param _request_auth: set to override the auth_settings for an a single 560 request; this effectively ignores the 561 authentication in the spec for a single request. 562 :type _request_auth: dict, optional 563 :param _content_type: force content-type for the request. 564 :type _content_type: str, Optional 565 :param _headers: set to override the headers for a single 566 request; this effectively ignores the headers 567 in the spec for a single request. 568 :type _headers: dict, optional 569 :param _host_index: set to override the host_index for a single 570 request; this effectively ignores the host_index 571 in the spec for a single request. 572 :type _host_index: int, optional 573 :return: Returns the result object. 574 """ # noqa: E501 575 576 _param = self._delete_pipeline_serialize( 577 organization_id=organization_id, 578 pipeline_id=pipeline_id, 579 _request_auth=_request_auth, 580 _content_type=_content_type, 581 _headers=_headers, 582 _host_index=_host_index 583 ) 584 585 _response_types_map: Dict[str, Optional[str]] = { 586 '200': "DeletePipelineResponse", 587 '400': "GetWorkspaces400Response", 588 '401': "GetWorkspaces400Response", 589 '403': "GetWorkspaces400Response", 590 '404': "GetWorkspaces400Response", 591 '500': "GetWorkspaces400Response", 592 } 593 response_data = self.api_client.call_api( 594 *_param, 595 _request_timeout=_request_timeout 596 ) 597 return response_data.response 598 599 600 def _delete_pipeline_serialize( 601 self, 602 organization_id, 603 pipeline_id, 604 _request_auth, 605 _content_type, 606 _headers, 607 _host_index, 608 ) -> RequestSerialized: 609 610 _host = None 611 612 _collection_formats: Dict[str, str] = { 613 } 614 615 _path_params: Dict[str, str] = {} 616 _query_params: List[Tuple[str, str]] = [] 617 _header_params: Dict[str, Optional[str]] = _headers or {} 618 _form_params: List[Tuple[str, str]] = [] 619 _files: Dict[ 620 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 621 ] = {} 622 _body_params: Optional[bytes] = None 623 624 # process the path parameters 625 if organization_id is not None: 626 _path_params['organizationId'] = organization_id 627 if pipeline_id is not None: 628 _path_params['pipelineId'] = pipeline_id 629 # process the query parameters 630 # process the header parameters 631 # process the form parameters 632 # process the body parameter 633 634 635 # set the HTTP header `Accept` 636 if 'Accept' not in _header_params: 637 _header_params['Accept'] = self.api_client.select_header_accept( 638 [ 639 'application/json' 640 ] 641 ) 642 643 644 # authentication setting 645 _auth_settings: List[str] = [ 646 'bearerAuth' 647 ] 648 649 return self.api_client.param_serialize( 650 method='DELETE', 651 resource_path='/org/{organizationId}/pipelines/{pipelineId}', 652 path_params=_path_params, 653 query_params=_query_params, 654 header_params=_header_params, 655 body=_body_params, 656 post_params=_form_params, 657 files=_files, 658 auth_settings=_auth_settings, 659 collection_formats=_collection_formats, 660 _host=_host, 661 _request_auth=_request_auth 662 ) 663 664 665 666 667 @validate_call 668 def get_deep_research_result( 669 self, 670 organization_id: StrictStr, 671 pipeline_id: StrictStr, 672 research_id: StrictStr, 673 _request_timeout: Union[ 674 None, 675 Annotated[StrictFloat, Field(gt=0)], 676 Tuple[ 677 Annotated[StrictFloat, Field(gt=0)], 678 Annotated[StrictFloat, Field(gt=0)] 679 ] 680 ] = None, 681 _request_auth: Optional[Dict[StrictStr, Any]] = None, 682 _content_type: Optional[StrictStr] = None, 683 _headers: Optional[Dict[StrictStr, Any]] = None, 684 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 685 ) -> GetDeepResearchResponse: 686 """Get deep research result 687 688 Get deep research result 689 690 :param organization_id: (required) 691 :type organization_id: str 692 :param pipeline_id: (required) 693 :type pipeline_id: str 694 :param research_id: (required) 695 :type research_id: str 696 :param _request_timeout: timeout setting for this request. If one 697 number provided, it will be total request 698 timeout. It can also be a pair (tuple) of 699 (connection, read) timeouts. 700 :type _request_timeout: int, tuple(int, int), optional 701 :param _request_auth: set to override the auth_settings for an a single 702 request; this effectively ignores the 703 authentication in the spec for a single request. 704 :type _request_auth: dict, optional 705 :param _content_type: force content-type for the request. 706 :type _content_type: str, Optional 707 :param _headers: set to override the headers for a single 708 request; this effectively ignores the headers 709 in the spec for a single request. 710 :type _headers: dict, optional 711 :param _host_index: set to override the host_index for a single 712 request; this effectively ignores the host_index 713 in the spec for a single request. 714 :type _host_index: int, optional 715 :return: Returns the result object. 716 """ # noqa: E501 717 718 _param = self._get_deep_research_result_serialize( 719 organization_id=organization_id, 720 pipeline_id=pipeline_id, 721 research_id=research_id, 722 _request_auth=_request_auth, 723 _content_type=_content_type, 724 _headers=_headers, 725 _host_index=_host_index 726 ) 727 728 _response_types_map: Dict[str, Optional[str]] = { 729 '200': "GetDeepResearchResponse", 730 '400': "GetWorkspaces400Response", 731 '401': "GetWorkspaces400Response", 732 '403': "GetWorkspaces400Response", 733 '404': "GetWorkspaces400Response", 734 '500': "GetWorkspaces400Response", 735 } 736 response_data = self.api_client.call_api( 737 *_param, 738 _request_timeout=_request_timeout 739 ) 740 response_data.read() 741 return self.api_client.response_deserialize( 742 response_data=response_data, 743 response_types_map=_response_types_map, 744 ).data 745 746 747 @validate_call 748 def get_deep_research_result_with_http_info( 749 self, 750 organization_id: StrictStr, 751 pipeline_id: StrictStr, 752 research_id: StrictStr, 753 _request_timeout: Union[ 754 None, 755 Annotated[StrictFloat, Field(gt=0)], 756 Tuple[ 757 Annotated[StrictFloat, Field(gt=0)], 758 Annotated[StrictFloat, Field(gt=0)] 759 ] 760 ] = None, 761 _request_auth: Optional[Dict[StrictStr, Any]] = None, 762 _content_type: Optional[StrictStr] = None, 763 _headers: Optional[Dict[StrictStr, Any]] = None, 764 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 765 ) -> ApiResponse[GetDeepResearchResponse]: 766 """Get deep research result 767 768 Get deep research result 769 770 :param organization_id: (required) 771 :type organization_id: str 772 :param pipeline_id: (required) 773 :type pipeline_id: str 774 :param research_id: (required) 775 :type research_id: str 776 :param _request_timeout: timeout setting for this request. If one 777 number provided, it will be total request 778 timeout. It can also be a pair (tuple) of 779 (connection, read) timeouts. 780 :type _request_timeout: int, tuple(int, int), optional 781 :param _request_auth: set to override the auth_settings for an a single 782 request; this effectively ignores the 783 authentication in the spec for a single request. 784 :type _request_auth: dict, optional 785 :param _content_type: force content-type for the request. 786 :type _content_type: str, Optional 787 :param _headers: set to override the headers for a single 788 request; this effectively ignores the headers 789 in the spec for a single request. 790 :type _headers: dict, optional 791 :param _host_index: set to override the host_index for a single 792 request; this effectively ignores the host_index 793 in the spec for a single request. 794 :type _host_index: int, optional 795 :return: Returns the result object. 796 """ # noqa: E501 797 798 _param = self._get_deep_research_result_serialize( 799 organization_id=organization_id, 800 pipeline_id=pipeline_id, 801 research_id=research_id, 802 _request_auth=_request_auth, 803 _content_type=_content_type, 804 _headers=_headers, 805 _host_index=_host_index 806 ) 807 808 _response_types_map: Dict[str, Optional[str]] = { 809 '200': "GetDeepResearchResponse", 810 '400': "GetWorkspaces400Response", 811 '401': "GetWorkspaces400Response", 812 '403': "GetWorkspaces400Response", 813 '404': "GetWorkspaces400Response", 814 '500': "GetWorkspaces400Response", 815 } 816 response_data = self.api_client.call_api( 817 *_param, 818 _request_timeout=_request_timeout 819 ) 820 response_data.read() 821 return self.api_client.response_deserialize( 822 response_data=response_data, 823 response_types_map=_response_types_map, 824 ) 825 826 827 @validate_call 828 def get_deep_research_result_without_preload_content( 829 self, 830 organization_id: StrictStr, 831 pipeline_id: StrictStr, 832 research_id: StrictStr, 833 _request_timeout: Union[ 834 None, 835 Annotated[StrictFloat, Field(gt=0)], 836 Tuple[ 837 Annotated[StrictFloat, Field(gt=0)], 838 Annotated[StrictFloat, Field(gt=0)] 839 ] 840 ] = None, 841 _request_auth: Optional[Dict[StrictStr, Any]] = None, 842 _content_type: Optional[StrictStr] = None, 843 _headers: Optional[Dict[StrictStr, Any]] = None, 844 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 845 ) -> RESTResponseType: 846 """Get deep research result 847 848 Get deep research result 849 850 :param organization_id: (required) 851 :type organization_id: str 852 :param pipeline_id: (required) 853 :type pipeline_id: str 854 :param research_id: (required) 855 :type research_id: str 856 :param _request_timeout: timeout setting for this request. If one 857 number provided, it will be total request 858 timeout. It can also be a pair (tuple) of 859 (connection, read) timeouts. 860 :type _request_timeout: int, tuple(int, int), optional 861 :param _request_auth: set to override the auth_settings for an a single 862 request; this effectively ignores the 863 authentication in the spec for a single request. 864 :type _request_auth: dict, optional 865 :param _content_type: force content-type for the request. 866 :type _content_type: str, Optional 867 :param _headers: set to override the headers for a single 868 request; this effectively ignores the headers 869 in the spec for a single request. 870 :type _headers: dict, optional 871 :param _host_index: set to override the host_index for a single 872 request; this effectively ignores the host_index 873 in the spec for a single request. 874 :type _host_index: int, optional 875 :return: Returns the result object. 876 """ # noqa: E501 877 878 _param = self._get_deep_research_result_serialize( 879 organization_id=organization_id, 880 pipeline_id=pipeline_id, 881 research_id=research_id, 882 _request_auth=_request_auth, 883 _content_type=_content_type, 884 _headers=_headers, 885 _host_index=_host_index 886 ) 887 888 _response_types_map: Dict[str, Optional[str]] = { 889 '200': "GetDeepResearchResponse", 890 '400': "GetWorkspaces400Response", 891 '401': "GetWorkspaces400Response", 892 '403': "GetWorkspaces400Response", 893 '404': "GetWorkspaces400Response", 894 '500': "GetWorkspaces400Response", 895 } 896 response_data = self.api_client.call_api( 897 *_param, 898 _request_timeout=_request_timeout 899 ) 900 return response_data.response 901 902 903 def _get_deep_research_result_serialize( 904 self, 905 organization_id, 906 pipeline_id, 907 research_id, 908 _request_auth, 909 _content_type, 910 _headers, 911 _host_index, 912 ) -> RequestSerialized: 913 914 _host = None 915 916 _collection_formats: Dict[str, str] = { 917 } 918 919 _path_params: Dict[str, str] = {} 920 _query_params: List[Tuple[str, str]] = [] 921 _header_params: Dict[str, Optional[str]] = _headers or {} 922 _form_params: List[Tuple[str, str]] = [] 923 _files: Dict[ 924 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 925 ] = {} 926 _body_params: Optional[bytes] = None 927 928 # process the path parameters 929 if organization_id is not None: 930 _path_params['organizationId'] = organization_id 931 if pipeline_id is not None: 932 _path_params['pipelineId'] = pipeline_id 933 if research_id is not None: 934 _path_params['researchId'] = research_id 935 # process the query parameters 936 # process the header parameters 937 # process the form parameters 938 # process the body parameter 939 940 941 # set the HTTP header `Accept` 942 if 'Accept' not in _header_params: 943 _header_params['Accept'] = self.api_client.select_header_accept( 944 [ 945 'application/json' 946 ] 947 ) 948 949 950 # authentication setting 951 _auth_settings: List[str] = [ 952 'bearerAuth' 953 ] 954 955 return self.api_client.param_serialize( 956 method='GET', 957 resource_path='/org/{organizationId}/pipelines/{pipelineId}/deep-research/{researchId}', 958 path_params=_path_params, 959 query_params=_query_params, 960 header_params=_header_params, 961 body=_body_params, 962 post_params=_form_params, 963 files=_files, 964 auth_settings=_auth_settings, 965 collection_formats=_collection_formats, 966 _host=_host, 967 _request_auth=_request_auth 968 ) 969 970 971 972 973 @validate_call 974 def get_pipeline( 975 self, 976 organization_id: StrictStr, 977 pipeline_id: StrictStr, 978 _request_timeout: Union[ 979 None, 980 Annotated[StrictFloat, Field(gt=0)], 981 Tuple[ 982 Annotated[StrictFloat, Field(gt=0)], 983 Annotated[StrictFloat, Field(gt=0)] 984 ] 985 ] = None, 986 _request_auth: Optional[Dict[StrictStr, Any]] = None, 987 _content_type: Optional[StrictStr] = None, 988 _headers: Optional[Dict[StrictStr, Any]] = None, 989 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 990 ) -> GetPipelineResponse: 991 """Get a pipeline 992 993 Get a pipeline 994 995 :param organization_id: (required) 996 :type organization_id: str 997 :param pipeline_id: (required) 998 :type pipeline_id: str 999 :param _request_timeout: timeout setting for this request. If one 1000 number provided, it will be total request 1001 timeout. It can also be a pair (tuple) of 1002 (connection, read) timeouts. 1003 :type _request_timeout: int, tuple(int, int), optional 1004 :param _request_auth: set to override the auth_settings for an a single 1005 request; this effectively ignores the 1006 authentication in the spec for a single request. 1007 :type _request_auth: dict, optional 1008 :param _content_type: force content-type for the request. 1009 :type _content_type: str, Optional 1010 :param _headers: set to override the headers for a single 1011 request; this effectively ignores the headers 1012 in the spec for a single request. 1013 :type _headers: dict, optional 1014 :param _host_index: set to override the host_index for a single 1015 request; this effectively ignores the host_index 1016 in the spec for a single request. 1017 :type _host_index: int, optional 1018 :return: Returns the result object. 1019 """ # noqa: E501 1020 1021 _param = self._get_pipeline_serialize( 1022 organization_id=organization_id, 1023 pipeline_id=pipeline_id, 1024 _request_auth=_request_auth, 1025 _content_type=_content_type, 1026 _headers=_headers, 1027 _host_index=_host_index 1028 ) 1029 1030 _response_types_map: Dict[str, Optional[str]] = { 1031 '200': "GetPipelineResponse", 1032 '400': "GetWorkspaces400Response", 1033 '401': "GetWorkspaces400Response", 1034 '403': "GetWorkspaces400Response", 1035 '404': "GetWorkspaces400Response", 1036 '500': "GetWorkspaces400Response", 1037 } 1038 response_data = self.api_client.call_api( 1039 *_param, 1040 _request_timeout=_request_timeout 1041 ) 1042 response_data.read() 1043 return self.api_client.response_deserialize( 1044 response_data=response_data, 1045 response_types_map=_response_types_map, 1046 ).data 1047 1048 1049 @validate_call 1050 def get_pipeline_with_http_info( 1051 self, 1052 organization_id: StrictStr, 1053 pipeline_id: StrictStr, 1054 _request_timeout: Union[ 1055 None, 1056 Annotated[StrictFloat, Field(gt=0)], 1057 Tuple[ 1058 Annotated[StrictFloat, Field(gt=0)], 1059 Annotated[StrictFloat, Field(gt=0)] 1060 ] 1061 ] = None, 1062 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1063 _content_type: Optional[StrictStr] = None, 1064 _headers: Optional[Dict[StrictStr, Any]] = None, 1065 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1066 ) -> ApiResponse[GetPipelineResponse]: 1067 """Get a pipeline 1068 1069 Get a pipeline 1070 1071 :param organization_id: (required) 1072 :type organization_id: str 1073 :param pipeline_id: (required) 1074 :type pipeline_id: str 1075 :param _request_timeout: timeout setting for this request. If one 1076 number provided, it will be total request 1077 timeout. It can also be a pair (tuple) of 1078 (connection, read) timeouts. 1079 :type _request_timeout: int, tuple(int, int), optional 1080 :param _request_auth: set to override the auth_settings for an a single 1081 request; this effectively ignores the 1082 authentication in the spec for a single request. 1083 :type _request_auth: dict, optional 1084 :param _content_type: force content-type for the request. 1085 :type _content_type: str, Optional 1086 :param _headers: set to override the headers for a single 1087 request; this effectively ignores the headers 1088 in the spec for a single request. 1089 :type _headers: dict, optional 1090 :param _host_index: set to override the host_index for a single 1091 request; this effectively ignores the host_index 1092 in the spec for a single request. 1093 :type _host_index: int, optional 1094 :return: Returns the result object. 1095 """ # noqa: E501 1096 1097 _param = self._get_pipeline_serialize( 1098 organization_id=organization_id, 1099 pipeline_id=pipeline_id, 1100 _request_auth=_request_auth, 1101 _content_type=_content_type, 1102 _headers=_headers, 1103 _host_index=_host_index 1104 ) 1105 1106 _response_types_map: Dict[str, Optional[str]] = { 1107 '200': "GetPipelineResponse", 1108 '400': "GetWorkspaces400Response", 1109 '401': "GetWorkspaces400Response", 1110 '403': "GetWorkspaces400Response", 1111 '404': "GetWorkspaces400Response", 1112 '500': "GetWorkspaces400Response", 1113 } 1114 response_data = self.api_client.call_api( 1115 *_param, 1116 _request_timeout=_request_timeout 1117 ) 1118 response_data.read() 1119 return self.api_client.response_deserialize( 1120 response_data=response_data, 1121 response_types_map=_response_types_map, 1122 ) 1123 1124 1125 @validate_call 1126 def get_pipeline_without_preload_content( 1127 self, 1128 organization_id: StrictStr, 1129 pipeline_id: StrictStr, 1130 _request_timeout: Union[ 1131 None, 1132 Annotated[StrictFloat, Field(gt=0)], 1133 Tuple[ 1134 Annotated[StrictFloat, Field(gt=0)], 1135 Annotated[StrictFloat, Field(gt=0)] 1136 ] 1137 ] = None, 1138 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1139 _content_type: Optional[StrictStr] = None, 1140 _headers: Optional[Dict[StrictStr, Any]] = None, 1141 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1142 ) -> RESTResponseType: 1143 """Get a pipeline 1144 1145 Get a pipeline 1146 1147 :param organization_id: (required) 1148 :type organization_id: str 1149 :param pipeline_id: (required) 1150 :type pipeline_id: str 1151 :param _request_timeout: timeout setting for this request. If one 1152 number provided, it will be total request 1153 timeout. It can also be a pair (tuple) of 1154 (connection, read) timeouts. 1155 :type _request_timeout: int, tuple(int, int), optional 1156 :param _request_auth: set to override the auth_settings for an a single 1157 request; this effectively ignores the 1158 authentication in the spec for a single request. 1159 :type _request_auth: dict, optional 1160 :param _content_type: force content-type for the request. 1161 :type _content_type: str, Optional 1162 :param _headers: set to override the headers for a single 1163 request; this effectively ignores the headers 1164 in the spec for a single request. 1165 :type _headers: dict, optional 1166 :param _host_index: set to override the host_index for a single 1167 request; this effectively ignores the host_index 1168 in the spec for a single request. 1169 :type _host_index: int, optional 1170 :return: Returns the result object. 1171 """ # noqa: E501 1172 1173 _param = self._get_pipeline_serialize( 1174 organization_id=organization_id, 1175 pipeline_id=pipeline_id, 1176 _request_auth=_request_auth, 1177 _content_type=_content_type, 1178 _headers=_headers, 1179 _host_index=_host_index 1180 ) 1181 1182 _response_types_map: Dict[str, Optional[str]] = { 1183 '200': "GetPipelineResponse", 1184 '400': "GetWorkspaces400Response", 1185 '401': "GetWorkspaces400Response", 1186 '403': "GetWorkspaces400Response", 1187 '404': "GetWorkspaces400Response", 1188 '500': "GetWorkspaces400Response", 1189 } 1190 response_data = self.api_client.call_api( 1191 *_param, 1192 _request_timeout=_request_timeout 1193 ) 1194 return response_data.response 1195 1196 1197 def _get_pipeline_serialize( 1198 self, 1199 organization_id, 1200 pipeline_id, 1201 _request_auth, 1202 _content_type, 1203 _headers, 1204 _host_index, 1205 ) -> RequestSerialized: 1206 1207 _host = None 1208 1209 _collection_formats: Dict[str, str] = { 1210 } 1211 1212 _path_params: Dict[str, str] = {} 1213 _query_params: List[Tuple[str, str]] = [] 1214 _header_params: Dict[str, Optional[str]] = _headers or {} 1215 _form_params: List[Tuple[str, str]] = [] 1216 _files: Dict[ 1217 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 1218 ] = {} 1219 _body_params: Optional[bytes] = None 1220 1221 # process the path parameters 1222 if organization_id is not None: 1223 _path_params['organizationId'] = organization_id 1224 if pipeline_id is not None: 1225 _path_params['pipelineId'] = pipeline_id 1226 # process the query parameters 1227 # process the header parameters 1228 # process the form parameters 1229 # process the body parameter 1230 1231 1232 # set the HTTP header `Accept` 1233 if 'Accept' not in _header_params: 1234 _header_params['Accept'] = self.api_client.select_header_accept( 1235 [ 1236 'application/json' 1237 ] 1238 ) 1239 1240 1241 # authentication setting 1242 _auth_settings: List[str] = [ 1243 'bearerAuth' 1244 ] 1245 1246 return self.api_client.param_serialize( 1247 method='GET', 1248 resource_path='/org/{organizationId}/pipelines/{pipelineId}', 1249 path_params=_path_params, 1250 query_params=_query_params, 1251 header_params=_header_params, 1252 body=_body_params, 1253 post_params=_form_params, 1254 files=_files, 1255 auth_settings=_auth_settings, 1256 collection_formats=_collection_formats, 1257 _host=_host, 1258 _request_auth=_request_auth 1259 ) 1260 1261 1262 1263 1264 @validate_call 1265 def get_pipeline_events( 1266 self, 1267 organization_id: StrictStr, 1268 pipeline_id: StrictStr, 1269 next_token: Optional[StrictStr] = None, 1270 _request_timeout: Union[ 1271 None, 1272 Annotated[StrictFloat, Field(gt=0)], 1273 Tuple[ 1274 Annotated[StrictFloat, Field(gt=0)], 1275 Annotated[StrictFloat, Field(gt=0)] 1276 ] 1277 ] = None, 1278 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1279 _content_type: Optional[StrictStr] = None, 1280 _headers: Optional[Dict[StrictStr, Any]] = None, 1281 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1282 ) -> GetPipelineEventsResponse: 1283 """Get pipeline events 1284 1285 Get pipeline events 1286 1287 :param organization_id: (required) 1288 :type organization_id: str 1289 :param pipeline_id: (required) 1290 :type pipeline_id: str 1291 :param next_token: 1292 :type next_token: str 1293 :param _request_timeout: timeout setting for this request. If one 1294 number provided, it will be total request 1295 timeout. It can also be a pair (tuple) of 1296 (connection, read) timeouts. 1297 :type _request_timeout: int, tuple(int, int), optional 1298 :param _request_auth: set to override the auth_settings for an a single 1299 request; this effectively ignores the 1300 authentication in the spec for a single request. 1301 :type _request_auth: dict, optional 1302 :param _content_type: force content-type for the request. 1303 :type _content_type: str, Optional 1304 :param _headers: set to override the headers for a single 1305 request; this effectively ignores the headers 1306 in the spec for a single request. 1307 :type _headers: dict, optional 1308 :param _host_index: set to override the host_index for a single 1309 request; this effectively ignores the host_index 1310 in the spec for a single request. 1311 :type _host_index: int, optional 1312 :return: Returns the result object. 1313 """ # noqa: E501 1314 1315 _param = self._get_pipeline_events_serialize( 1316 organization_id=organization_id, 1317 pipeline_id=pipeline_id, 1318 next_token=next_token, 1319 _request_auth=_request_auth, 1320 _content_type=_content_type, 1321 _headers=_headers, 1322 _host_index=_host_index 1323 ) 1324 1325 _response_types_map: Dict[str, Optional[str]] = { 1326 '200': "GetPipelineEventsResponse", 1327 '400': "GetWorkspaces400Response", 1328 '401': "GetWorkspaces400Response", 1329 '403': "GetWorkspaces400Response", 1330 '404': "GetWorkspaces400Response", 1331 '500': "GetWorkspaces400Response", 1332 } 1333 response_data = self.api_client.call_api( 1334 *_param, 1335 _request_timeout=_request_timeout 1336 ) 1337 response_data.read() 1338 return self.api_client.response_deserialize( 1339 response_data=response_data, 1340 response_types_map=_response_types_map, 1341 ).data 1342 1343 1344 @validate_call 1345 def get_pipeline_events_with_http_info( 1346 self, 1347 organization_id: StrictStr, 1348 pipeline_id: StrictStr, 1349 next_token: Optional[StrictStr] = None, 1350 _request_timeout: Union[ 1351 None, 1352 Annotated[StrictFloat, Field(gt=0)], 1353 Tuple[ 1354 Annotated[StrictFloat, Field(gt=0)], 1355 Annotated[StrictFloat, Field(gt=0)] 1356 ] 1357 ] = None, 1358 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1359 _content_type: Optional[StrictStr] = None, 1360 _headers: Optional[Dict[StrictStr, Any]] = None, 1361 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1362 ) -> ApiResponse[GetPipelineEventsResponse]: 1363 """Get pipeline events 1364 1365 Get pipeline events 1366 1367 :param organization_id: (required) 1368 :type organization_id: str 1369 :param pipeline_id: (required) 1370 :type pipeline_id: str 1371 :param next_token: 1372 :type next_token: str 1373 :param _request_timeout: timeout setting for this request. If one 1374 number provided, it will be total request 1375 timeout. It can also be a pair (tuple) of 1376 (connection, read) timeouts. 1377 :type _request_timeout: int, tuple(int, int), optional 1378 :param _request_auth: set to override the auth_settings for an a single 1379 request; this effectively ignores the 1380 authentication in the spec for a single request. 1381 :type _request_auth: dict, optional 1382 :param _content_type: force content-type for the request. 1383 :type _content_type: str, Optional 1384 :param _headers: set to override the headers for a single 1385 request; this effectively ignores the headers 1386 in the spec for a single request. 1387 :type _headers: dict, optional 1388 :param _host_index: set to override the host_index for a single 1389 request; this effectively ignores the host_index 1390 in the spec for a single request. 1391 :type _host_index: int, optional 1392 :return: Returns the result object. 1393 """ # noqa: E501 1394 1395 _param = self._get_pipeline_events_serialize( 1396 organization_id=organization_id, 1397 pipeline_id=pipeline_id, 1398 next_token=next_token, 1399 _request_auth=_request_auth, 1400 _content_type=_content_type, 1401 _headers=_headers, 1402 _host_index=_host_index 1403 ) 1404 1405 _response_types_map: Dict[str, Optional[str]] = { 1406 '200': "GetPipelineEventsResponse", 1407 '400': "GetWorkspaces400Response", 1408 '401': "GetWorkspaces400Response", 1409 '403': "GetWorkspaces400Response", 1410 '404': "GetWorkspaces400Response", 1411 '500': "GetWorkspaces400Response", 1412 } 1413 response_data = self.api_client.call_api( 1414 *_param, 1415 _request_timeout=_request_timeout 1416 ) 1417 response_data.read() 1418 return self.api_client.response_deserialize( 1419 response_data=response_data, 1420 response_types_map=_response_types_map, 1421 ) 1422 1423 1424 @validate_call 1425 def get_pipeline_events_without_preload_content( 1426 self, 1427 organization_id: StrictStr, 1428 pipeline_id: StrictStr, 1429 next_token: Optional[StrictStr] = None, 1430 _request_timeout: Union[ 1431 None, 1432 Annotated[StrictFloat, Field(gt=0)], 1433 Tuple[ 1434 Annotated[StrictFloat, Field(gt=0)], 1435 Annotated[StrictFloat, Field(gt=0)] 1436 ] 1437 ] = None, 1438 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1439 _content_type: Optional[StrictStr] = None, 1440 _headers: Optional[Dict[StrictStr, Any]] = None, 1441 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1442 ) -> RESTResponseType: 1443 """Get pipeline events 1444 1445 Get pipeline events 1446 1447 :param organization_id: (required) 1448 :type organization_id: str 1449 :param pipeline_id: (required) 1450 :type pipeline_id: str 1451 :param next_token: 1452 :type next_token: str 1453 :param _request_timeout: timeout setting for this request. If one 1454 number provided, it will be total request 1455 timeout. It can also be a pair (tuple) of 1456 (connection, read) timeouts. 1457 :type _request_timeout: int, tuple(int, int), optional 1458 :param _request_auth: set to override the auth_settings for an a single 1459 request; this effectively ignores the 1460 authentication in the spec for a single request. 1461 :type _request_auth: dict, optional 1462 :param _content_type: force content-type for the request. 1463 :type _content_type: str, Optional 1464 :param _headers: set to override the headers for a single 1465 request; this effectively ignores the headers 1466 in the spec for a single request. 1467 :type _headers: dict, optional 1468 :param _host_index: set to override the host_index for a single 1469 request; this effectively ignores the host_index 1470 in the spec for a single request. 1471 :type _host_index: int, optional 1472 :return: Returns the result object. 1473 """ # noqa: E501 1474 1475 _param = self._get_pipeline_events_serialize( 1476 organization_id=organization_id, 1477 pipeline_id=pipeline_id, 1478 next_token=next_token, 1479 _request_auth=_request_auth, 1480 _content_type=_content_type, 1481 _headers=_headers, 1482 _host_index=_host_index 1483 ) 1484 1485 _response_types_map: Dict[str, Optional[str]] = { 1486 '200': "GetPipelineEventsResponse", 1487 '400': "GetWorkspaces400Response", 1488 '401': "GetWorkspaces400Response", 1489 '403': "GetWorkspaces400Response", 1490 '404': "GetWorkspaces400Response", 1491 '500': "GetWorkspaces400Response", 1492 } 1493 response_data = self.api_client.call_api( 1494 *_param, 1495 _request_timeout=_request_timeout 1496 ) 1497 return response_data.response 1498 1499 1500 def _get_pipeline_events_serialize( 1501 self, 1502 organization_id, 1503 pipeline_id, 1504 next_token, 1505 _request_auth, 1506 _content_type, 1507 _headers, 1508 _host_index, 1509 ) -> RequestSerialized: 1510 1511 _host = None 1512 1513 _collection_formats: Dict[str, str] = { 1514 } 1515 1516 _path_params: Dict[str, str] = {} 1517 _query_params: List[Tuple[str, str]] = [] 1518 _header_params: Dict[str, Optional[str]] = _headers or {} 1519 _form_params: List[Tuple[str, str]] = [] 1520 _files: Dict[ 1521 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 1522 ] = {} 1523 _body_params: Optional[bytes] = None 1524 1525 # process the path parameters 1526 if organization_id is not None: 1527 _path_params['organizationId'] = organization_id 1528 if pipeline_id is not None: 1529 _path_params['pipelineId'] = pipeline_id 1530 # process the query parameters 1531 if next_token is not None: 1532 1533 _query_params.append(('nextToken', next_token)) 1534 1535 # process the header parameters 1536 # process the form parameters 1537 # process the body parameter 1538 1539 1540 # set the HTTP header `Accept` 1541 if 'Accept' not in _header_params: 1542 _header_params['Accept'] = self.api_client.select_header_accept( 1543 [ 1544 'application/json' 1545 ] 1546 ) 1547 1548 1549 # authentication setting 1550 _auth_settings: List[str] = [ 1551 'bearerAuth' 1552 ] 1553 1554 return self.api_client.param_serialize( 1555 method='GET', 1556 resource_path='/org/{organizationId}/pipelines/{pipelineId}/events', 1557 path_params=_path_params, 1558 query_params=_query_params, 1559 header_params=_header_params, 1560 body=_body_params, 1561 post_params=_form_params, 1562 files=_files, 1563 auth_settings=_auth_settings, 1564 collection_formats=_collection_formats, 1565 _host=_host, 1566 _request_auth=_request_auth 1567 ) 1568 1569 1570 1571 1572 @validate_call 1573 def get_pipeline_metrics( 1574 self, 1575 organization_id: StrictStr, 1576 pipeline_id: StrictStr, 1577 _request_timeout: Union[ 1578 None, 1579 Annotated[StrictFloat, Field(gt=0)], 1580 Tuple[ 1581 Annotated[StrictFloat, Field(gt=0)], 1582 Annotated[StrictFloat, Field(gt=0)] 1583 ] 1584 ] = None, 1585 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1586 _content_type: Optional[StrictStr] = None, 1587 _headers: Optional[Dict[StrictStr, Any]] = None, 1588 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1589 ) -> GetPipelineMetricsResponse: 1590 """Get pipeline metrics 1591 1592 Get pipeline metrics 1593 1594 :param organization_id: (required) 1595 :type organization_id: str 1596 :param pipeline_id: (required) 1597 :type pipeline_id: str 1598 :param _request_timeout: timeout setting for this request. If one 1599 number provided, it will be total request 1600 timeout. It can also be a pair (tuple) of 1601 (connection, read) timeouts. 1602 :type _request_timeout: int, tuple(int, int), optional 1603 :param _request_auth: set to override the auth_settings for an a single 1604 request; this effectively ignores the 1605 authentication in the spec for a single request. 1606 :type _request_auth: dict, optional 1607 :param _content_type: force content-type for the request. 1608 :type _content_type: str, Optional 1609 :param _headers: set to override the headers for a single 1610 request; this effectively ignores the headers 1611 in the spec for a single request. 1612 :type _headers: dict, optional 1613 :param _host_index: set to override the host_index for a single 1614 request; this effectively ignores the host_index 1615 in the spec for a single request. 1616 :type _host_index: int, optional 1617 :return: Returns the result object. 1618 """ # noqa: E501 1619 1620 _param = self._get_pipeline_metrics_serialize( 1621 organization_id=organization_id, 1622 pipeline_id=pipeline_id, 1623 _request_auth=_request_auth, 1624 _content_type=_content_type, 1625 _headers=_headers, 1626 _host_index=_host_index 1627 ) 1628 1629 _response_types_map: Dict[str, Optional[str]] = { 1630 '200': "GetPipelineMetricsResponse", 1631 '400': "GetWorkspaces400Response", 1632 '401': "GetWorkspaces400Response", 1633 '403': "GetWorkspaces400Response", 1634 '404': "GetWorkspaces400Response", 1635 '500': "GetWorkspaces400Response", 1636 } 1637 response_data = self.api_client.call_api( 1638 *_param, 1639 _request_timeout=_request_timeout 1640 ) 1641 response_data.read() 1642 return self.api_client.response_deserialize( 1643 response_data=response_data, 1644 response_types_map=_response_types_map, 1645 ).data 1646 1647 1648 @validate_call 1649 def get_pipeline_metrics_with_http_info( 1650 self, 1651 organization_id: StrictStr, 1652 pipeline_id: StrictStr, 1653 _request_timeout: Union[ 1654 None, 1655 Annotated[StrictFloat, Field(gt=0)], 1656 Tuple[ 1657 Annotated[StrictFloat, Field(gt=0)], 1658 Annotated[StrictFloat, Field(gt=0)] 1659 ] 1660 ] = None, 1661 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1662 _content_type: Optional[StrictStr] = None, 1663 _headers: Optional[Dict[StrictStr, Any]] = None, 1664 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1665 ) -> ApiResponse[GetPipelineMetricsResponse]: 1666 """Get pipeline metrics 1667 1668 Get pipeline metrics 1669 1670 :param organization_id: (required) 1671 :type organization_id: str 1672 :param pipeline_id: (required) 1673 :type pipeline_id: str 1674 :param _request_timeout: timeout setting for this request. If one 1675 number provided, it will be total request 1676 timeout. It can also be a pair (tuple) of 1677 (connection, read) timeouts. 1678 :type _request_timeout: int, tuple(int, int), optional 1679 :param _request_auth: set to override the auth_settings for an a single 1680 request; this effectively ignores the 1681 authentication in the spec for a single request. 1682 :type _request_auth: dict, optional 1683 :param _content_type: force content-type for the request. 1684 :type _content_type: str, Optional 1685 :param _headers: set to override the headers for a single 1686 request; this effectively ignores the headers 1687 in the spec for a single request. 1688 :type _headers: dict, optional 1689 :param _host_index: set to override the host_index for a single 1690 request; this effectively ignores the host_index 1691 in the spec for a single request. 1692 :type _host_index: int, optional 1693 :return: Returns the result object. 1694 """ # noqa: E501 1695 1696 _param = self._get_pipeline_metrics_serialize( 1697 organization_id=organization_id, 1698 pipeline_id=pipeline_id, 1699 _request_auth=_request_auth, 1700 _content_type=_content_type, 1701 _headers=_headers, 1702 _host_index=_host_index 1703 ) 1704 1705 _response_types_map: Dict[str, Optional[str]] = { 1706 '200': "GetPipelineMetricsResponse", 1707 '400': "GetWorkspaces400Response", 1708 '401': "GetWorkspaces400Response", 1709 '403': "GetWorkspaces400Response", 1710 '404': "GetWorkspaces400Response", 1711 '500': "GetWorkspaces400Response", 1712 } 1713 response_data = self.api_client.call_api( 1714 *_param, 1715 _request_timeout=_request_timeout 1716 ) 1717 response_data.read() 1718 return self.api_client.response_deserialize( 1719 response_data=response_data, 1720 response_types_map=_response_types_map, 1721 ) 1722 1723 1724 @validate_call 1725 def get_pipeline_metrics_without_preload_content( 1726 self, 1727 organization_id: StrictStr, 1728 pipeline_id: StrictStr, 1729 _request_timeout: Union[ 1730 None, 1731 Annotated[StrictFloat, Field(gt=0)], 1732 Tuple[ 1733 Annotated[StrictFloat, Field(gt=0)], 1734 Annotated[StrictFloat, Field(gt=0)] 1735 ] 1736 ] = None, 1737 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1738 _content_type: Optional[StrictStr] = None, 1739 _headers: Optional[Dict[StrictStr, Any]] = None, 1740 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1741 ) -> RESTResponseType: 1742 """Get pipeline metrics 1743 1744 Get pipeline metrics 1745 1746 :param organization_id: (required) 1747 :type organization_id: str 1748 :param pipeline_id: (required) 1749 :type pipeline_id: str 1750 :param _request_timeout: timeout setting for this request. If one 1751 number provided, it will be total request 1752 timeout. It can also be a pair (tuple) of 1753 (connection, read) timeouts. 1754 :type _request_timeout: int, tuple(int, int), optional 1755 :param _request_auth: set to override the auth_settings for an a single 1756 request; this effectively ignores the 1757 authentication in the spec for a single request. 1758 :type _request_auth: dict, optional 1759 :param _content_type: force content-type for the request. 1760 :type _content_type: str, Optional 1761 :param _headers: set to override the headers for a single 1762 request; this effectively ignores the headers 1763 in the spec for a single request. 1764 :type _headers: dict, optional 1765 :param _host_index: set to override the host_index for a single 1766 request; this effectively ignores the host_index 1767 in the spec for a single request. 1768 :type _host_index: int, optional 1769 :return: Returns the result object. 1770 """ # noqa: E501 1771 1772 _param = self._get_pipeline_metrics_serialize( 1773 organization_id=organization_id, 1774 pipeline_id=pipeline_id, 1775 _request_auth=_request_auth, 1776 _content_type=_content_type, 1777 _headers=_headers, 1778 _host_index=_host_index 1779 ) 1780 1781 _response_types_map: Dict[str, Optional[str]] = { 1782 '200': "GetPipelineMetricsResponse", 1783 '400': "GetWorkspaces400Response", 1784 '401': "GetWorkspaces400Response", 1785 '403': "GetWorkspaces400Response", 1786 '404': "GetWorkspaces400Response", 1787 '500': "GetWorkspaces400Response", 1788 } 1789 response_data = self.api_client.call_api( 1790 *_param, 1791 _request_timeout=_request_timeout 1792 ) 1793 return response_data.response 1794 1795 1796 def _get_pipeline_metrics_serialize( 1797 self, 1798 organization_id, 1799 pipeline_id, 1800 _request_auth, 1801 _content_type, 1802 _headers, 1803 _host_index, 1804 ) -> RequestSerialized: 1805 1806 _host = None 1807 1808 _collection_formats: Dict[str, str] = { 1809 } 1810 1811 _path_params: Dict[str, str] = {} 1812 _query_params: List[Tuple[str, str]] = [] 1813 _header_params: Dict[str, Optional[str]] = _headers or {} 1814 _form_params: List[Tuple[str, str]] = [] 1815 _files: Dict[ 1816 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 1817 ] = {} 1818 _body_params: Optional[bytes] = None 1819 1820 # process the path parameters 1821 if organization_id is not None: 1822 _path_params['organizationId'] = organization_id 1823 if pipeline_id is not None: 1824 _path_params['pipelineId'] = pipeline_id 1825 # process the query parameters 1826 # process the header parameters 1827 # process the form parameters 1828 # process the body parameter 1829 1830 1831 # set the HTTP header `Accept` 1832 if 'Accept' not in _header_params: 1833 _header_params['Accept'] = self.api_client.select_header_accept( 1834 [ 1835 'application/json' 1836 ] 1837 ) 1838 1839 1840 # authentication setting 1841 _auth_settings: List[str] = [ 1842 'bearerAuth' 1843 ] 1844 1845 return self.api_client.param_serialize( 1846 method='GET', 1847 resource_path='/org/{organizationId}/pipelines/{pipelineId}/metrics', 1848 path_params=_path_params, 1849 query_params=_query_params, 1850 header_params=_header_params, 1851 body=_body_params, 1852 post_params=_form_params, 1853 files=_files, 1854 auth_settings=_auth_settings, 1855 collection_formats=_collection_formats, 1856 _host=_host, 1857 _request_auth=_request_auth 1858 ) 1859 1860 1861 1862 1863 @validate_call 1864 def get_pipelines( 1865 self, 1866 organization_id: StrictStr, 1867 workspace_id: Optional[StrictStr] = None, 1868 _request_timeout: Union[ 1869 None, 1870 Annotated[StrictFloat, Field(gt=0)], 1871 Tuple[ 1872 Annotated[StrictFloat, Field(gt=0)], 1873 Annotated[StrictFloat, Field(gt=0)] 1874 ] 1875 ] = None, 1876 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1877 _content_type: Optional[StrictStr] = None, 1878 _headers: Optional[Dict[StrictStr, Any]] = None, 1879 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1880 ) -> GetPipelinesResponse: 1881 """Get all pipelines 1882 1883 Returns a list of all pipelines in the organization 1884 1885 :param organization_id: (required) 1886 :type organization_id: str 1887 :param workspace_id: 1888 :type workspace_id: str 1889 :param _request_timeout: timeout setting for this request. If one 1890 number provided, it will be total request 1891 timeout. It can also be a pair (tuple) of 1892 (connection, read) timeouts. 1893 :type _request_timeout: int, tuple(int, int), optional 1894 :param _request_auth: set to override the auth_settings for an a single 1895 request; this effectively ignores the 1896 authentication in the spec for a single request. 1897 :type _request_auth: dict, optional 1898 :param _content_type: force content-type for the request. 1899 :type _content_type: str, Optional 1900 :param _headers: set to override the headers for a single 1901 request; this effectively ignores the headers 1902 in the spec for a single request. 1903 :type _headers: dict, optional 1904 :param _host_index: set to override the host_index for a single 1905 request; this effectively ignores the host_index 1906 in the spec for a single request. 1907 :type _host_index: int, optional 1908 :return: Returns the result object. 1909 """ # noqa: E501 1910 1911 _param = self._get_pipelines_serialize( 1912 organization_id=organization_id, 1913 workspace_id=workspace_id, 1914 _request_auth=_request_auth, 1915 _content_type=_content_type, 1916 _headers=_headers, 1917 _host_index=_host_index 1918 ) 1919 1920 _response_types_map: Dict[str, Optional[str]] = { 1921 '200': "GetPipelinesResponse", 1922 '400': "GetWorkspaces400Response", 1923 '401': "GetWorkspaces400Response", 1924 '403': "GetWorkspaces400Response", 1925 '404': "GetWorkspaces400Response", 1926 '500': "GetWorkspaces400Response", 1927 } 1928 response_data = self.api_client.call_api( 1929 *_param, 1930 _request_timeout=_request_timeout 1931 ) 1932 response_data.read() 1933 return self.api_client.response_deserialize( 1934 response_data=response_data, 1935 response_types_map=_response_types_map, 1936 ).data 1937 1938 1939 @validate_call 1940 def get_pipelines_with_http_info( 1941 self, 1942 organization_id: StrictStr, 1943 workspace_id: Optional[StrictStr] = None, 1944 _request_timeout: Union[ 1945 None, 1946 Annotated[StrictFloat, Field(gt=0)], 1947 Tuple[ 1948 Annotated[StrictFloat, Field(gt=0)], 1949 Annotated[StrictFloat, Field(gt=0)] 1950 ] 1951 ] = None, 1952 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1953 _content_type: Optional[StrictStr] = None, 1954 _headers: Optional[Dict[StrictStr, Any]] = None, 1955 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1956 ) -> ApiResponse[GetPipelinesResponse]: 1957 """Get all pipelines 1958 1959 Returns a list of all pipelines in the organization 1960 1961 :param organization_id: (required) 1962 :type organization_id: str 1963 :param workspace_id: 1964 :type workspace_id: str 1965 :param _request_timeout: timeout setting for this request. If one 1966 number provided, it will be total request 1967 timeout. It can also be a pair (tuple) of 1968 (connection, read) timeouts. 1969 :type _request_timeout: int, tuple(int, int), optional 1970 :param _request_auth: set to override the auth_settings for an a single 1971 request; this effectively ignores the 1972 authentication in the spec for a single request. 1973 :type _request_auth: dict, optional 1974 :param _content_type: force content-type for the request. 1975 :type _content_type: str, Optional 1976 :param _headers: set to override the headers for a single 1977 request; this effectively ignores the headers 1978 in the spec for a single request. 1979 :type _headers: dict, optional 1980 :param _host_index: set to override the host_index for a single 1981 request; this effectively ignores the host_index 1982 in the spec for a single request. 1983 :type _host_index: int, optional 1984 :return: Returns the result object. 1985 """ # noqa: E501 1986 1987 _param = self._get_pipelines_serialize( 1988 organization_id=organization_id, 1989 workspace_id=workspace_id, 1990 _request_auth=_request_auth, 1991 _content_type=_content_type, 1992 _headers=_headers, 1993 _host_index=_host_index 1994 ) 1995 1996 _response_types_map: Dict[str, Optional[str]] = { 1997 '200': "GetPipelinesResponse", 1998 '400': "GetWorkspaces400Response", 1999 '401': "GetWorkspaces400Response", 2000 '403': "GetWorkspaces400Response", 2001 '404': "GetWorkspaces400Response", 2002 '500': "GetWorkspaces400Response", 2003 } 2004 response_data = self.api_client.call_api( 2005 *_param, 2006 _request_timeout=_request_timeout 2007 ) 2008 response_data.read() 2009 return self.api_client.response_deserialize( 2010 response_data=response_data, 2011 response_types_map=_response_types_map, 2012 ) 2013 2014 2015 @validate_call 2016 def get_pipelines_without_preload_content( 2017 self, 2018 organization_id: StrictStr, 2019 workspace_id: Optional[StrictStr] = None, 2020 _request_timeout: Union[ 2021 None, 2022 Annotated[StrictFloat, Field(gt=0)], 2023 Tuple[ 2024 Annotated[StrictFloat, Field(gt=0)], 2025 Annotated[StrictFloat, Field(gt=0)] 2026 ] 2027 ] = None, 2028 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2029 _content_type: Optional[StrictStr] = None, 2030 _headers: Optional[Dict[StrictStr, Any]] = None, 2031 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2032 ) -> RESTResponseType: 2033 """Get all pipelines 2034 2035 Returns a list of all pipelines in the organization 2036 2037 :param organization_id: (required) 2038 :type organization_id: str 2039 :param workspace_id: 2040 :type workspace_id: str 2041 :param _request_timeout: timeout setting for this request. If one 2042 number provided, it will be total request 2043 timeout. It can also be a pair (tuple) of 2044 (connection, read) timeouts. 2045 :type _request_timeout: int, tuple(int, int), optional 2046 :param _request_auth: set to override the auth_settings for an a single 2047 request; this effectively ignores the 2048 authentication in the spec for a single request. 2049 :type _request_auth: dict, optional 2050 :param _content_type: force content-type for the request. 2051 :type _content_type: str, Optional 2052 :param _headers: set to override the headers for a single 2053 request; this effectively ignores the headers 2054 in the spec for a single request. 2055 :type _headers: dict, optional 2056 :param _host_index: set to override the host_index for a single 2057 request; this effectively ignores the host_index 2058 in the spec for a single request. 2059 :type _host_index: int, optional 2060 :return: Returns the result object. 2061 """ # noqa: E501 2062 2063 _param = self._get_pipelines_serialize( 2064 organization_id=organization_id, 2065 workspace_id=workspace_id, 2066 _request_auth=_request_auth, 2067 _content_type=_content_type, 2068 _headers=_headers, 2069 _host_index=_host_index 2070 ) 2071 2072 _response_types_map: Dict[str, Optional[str]] = { 2073 '200': "GetPipelinesResponse", 2074 '400': "GetWorkspaces400Response", 2075 '401': "GetWorkspaces400Response", 2076 '403': "GetWorkspaces400Response", 2077 '404': "GetWorkspaces400Response", 2078 '500': "GetWorkspaces400Response", 2079 } 2080 response_data = self.api_client.call_api( 2081 *_param, 2082 _request_timeout=_request_timeout 2083 ) 2084 return response_data.response 2085 2086 2087 def _get_pipelines_serialize( 2088 self, 2089 organization_id, 2090 workspace_id, 2091 _request_auth, 2092 _content_type, 2093 _headers, 2094 _host_index, 2095 ) -> RequestSerialized: 2096 2097 _host = None 2098 2099 _collection_formats: Dict[str, str] = { 2100 } 2101 2102 _path_params: Dict[str, str] = {} 2103 _query_params: List[Tuple[str, str]] = [] 2104 _header_params: Dict[str, Optional[str]] = _headers or {} 2105 _form_params: List[Tuple[str, str]] = [] 2106 _files: Dict[ 2107 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 2108 ] = {} 2109 _body_params: Optional[bytes] = None 2110 2111 # process the path parameters 2112 if organization_id is not None: 2113 _path_params['organizationId'] = organization_id 2114 # process the query parameters 2115 if workspace_id is not None: 2116 2117 _query_params.append(('workspaceId', workspace_id)) 2118 2119 # process the header parameters 2120 # process the form parameters 2121 # process the body parameter 2122 2123 2124 # set the HTTP header `Accept` 2125 if 'Accept' not in _header_params: 2126 _header_params['Accept'] = self.api_client.select_header_accept( 2127 [ 2128 'application/json' 2129 ] 2130 ) 2131 2132 2133 # authentication setting 2134 _auth_settings: List[str] = [ 2135 'bearerAuth' 2136 ] 2137 2138 return self.api_client.param_serialize( 2139 method='GET', 2140 resource_path='/org/{organizationId}/pipelines', 2141 path_params=_path_params, 2142 query_params=_query_params, 2143 header_params=_header_params, 2144 body=_body_params, 2145 post_params=_form_params, 2146 files=_files, 2147 auth_settings=_auth_settings, 2148 collection_formats=_collection_formats, 2149 _host=_host, 2150 _request_auth=_request_auth 2151 ) 2152 2153 2154 2155 2156 @validate_call 2157 def retrieve_documents( 2158 self, 2159 organization_id: StrictStr, 2160 pipeline_id: StrictStr, 2161 retrieve_documents_request: RetrieveDocumentsRequest, 2162 _request_timeout: Union[ 2163 None, 2164 Annotated[StrictFloat, Field(gt=0)], 2165 Tuple[ 2166 Annotated[StrictFloat, Field(gt=0)], 2167 Annotated[StrictFloat, Field(gt=0)] 2168 ] 2169 ] = None, 2170 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2171 _content_type: Optional[StrictStr] = None, 2172 _headers: Optional[Dict[StrictStr, Any]] = None, 2173 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2174 ) -> RetrieveDocumentsResponse: 2175 """Retrieve documents from a pipeline 2176 2177 Retrieve documents from a pipeline 2178 2179 :param organization_id: (required) 2180 :type organization_id: str 2181 :param pipeline_id: (required) 2182 :type pipeline_id: str 2183 :param retrieve_documents_request: (required) 2184 :type retrieve_documents_request: RetrieveDocumentsRequest 2185 :param _request_timeout: timeout setting for this request. If one 2186 number provided, it will be total request 2187 timeout. It can also be a pair (tuple) of 2188 (connection, read) timeouts. 2189 :type _request_timeout: int, tuple(int, int), optional 2190 :param _request_auth: set to override the auth_settings for an a single 2191 request; this effectively ignores the 2192 authentication in the spec for a single request. 2193 :type _request_auth: dict, optional 2194 :param _content_type: force content-type for the request. 2195 :type _content_type: str, Optional 2196 :param _headers: set to override the headers for a single 2197 request; this effectively ignores the headers 2198 in the spec for a single request. 2199 :type _headers: dict, optional 2200 :param _host_index: set to override the host_index for a single 2201 request; this effectively ignores the host_index 2202 in the spec for a single request. 2203 :type _host_index: int, optional 2204 :return: Returns the result object. 2205 """ # noqa: E501 2206 2207 _param = self._retrieve_documents_serialize( 2208 organization_id=organization_id, 2209 pipeline_id=pipeline_id, 2210 retrieve_documents_request=retrieve_documents_request, 2211 _request_auth=_request_auth, 2212 _content_type=_content_type, 2213 _headers=_headers, 2214 _host_index=_host_index 2215 ) 2216 2217 _response_types_map: Dict[str, Optional[str]] = { 2218 '200': "RetrieveDocumentsResponse", 2219 '400': "GetWorkspaces400Response", 2220 '401': "GetWorkspaces400Response", 2221 '403': "GetWorkspaces400Response", 2222 '404': "GetWorkspaces400Response", 2223 '500': "GetWorkspaces400Response", 2224 } 2225 response_data = self.api_client.call_api( 2226 *_param, 2227 _request_timeout=_request_timeout 2228 ) 2229 response_data.read() 2230 return self.api_client.response_deserialize( 2231 response_data=response_data, 2232 response_types_map=_response_types_map, 2233 ).data 2234 2235 2236 @validate_call 2237 def retrieve_documents_with_http_info( 2238 self, 2239 organization_id: StrictStr, 2240 pipeline_id: StrictStr, 2241 retrieve_documents_request: RetrieveDocumentsRequest, 2242 _request_timeout: Union[ 2243 None, 2244 Annotated[StrictFloat, Field(gt=0)], 2245 Tuple[ 2246 Annotated[StrictFloat, Field(gt=0)], 2247 Annotated[StrictFloat, Field(gt=0)] 2248 ] 2249 ] = None, 2250 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2251 _content_type: Optional[StrictStr] = None, 2252 _headers: Optional[Dict[StrictStr, Any]] = None, 2253 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2254 ) -> ApiResponse[RetrieveDocumentsResponse]: 2255 """Retrieve documents from a pipeline 2256 2257 Retrieve documents from a pipeline 2258 2259 :param organization_id: (required) 2260 :type organization_id: str 2261 :param pipeline_id: (required) 2262 :type pipeline_id: str 2263 :param retrieve_documents_request: (required) 2264 :type retrieve_documents_request: RetrieveDocumentsRequest 2265 :param _request_timeout: timeout setting for this request. If one 2266 number provided, it will be total request 2267 timeout. It can also be a pair (tuple) of 2268 (connection, read) timeouts. 2269 :type _request_timeout: int, tuple(int, int), optional 2270 :param _request_auth: set to override the auth_settings for an a single 2271 request; this effectively ignores the 2272 authentication in the spec for a single request. 2273 :type _request_auth: dict, optional 2274 :param _content_type: force content-type for the request. 2275 :type _content_type: str, Optional 2276 :param _headers: set to override the headers for a single 2277 request; this effectively ignores the headers 2278 in the spec for a single request. 2279 :type _headers: dict, optional 2280 :param _host_index: set to override the host_index for a single 2281 request; this effectively ignores the host_index 2282 in the spec for a single request. 2283 :type _host_index: int, optional 2284 :return: Returns the result object. 2285 """ # noqa: E501 2286 2287 _param = self._retrieve_documents_serialize( 2288 organization_id=organization_id, 2289 pipeline_id=pipeline_id, 2290 retrieve_documents_request=retrieve_documents_request, 2291 _request_auth=_request_auth, 2292 _content_type=_content_type, 2293 _headers=_headers, 2294 _host_index=_host_index 2295 ) 2296 2297 _response_types_map: Dict[str, Optional[str]] = { 2298 '200': "RetrieveDocumentsResponse", 2299 '400': "GetWorkspaces400Response", 2300 '401': "GetWorkspaces400Response", 2301 '403': "GetWorkspaces400Response", 2302 '404': "GetWorkspaces400Response", 2303 '500': "GetWorkspaces400Response", 2304 } 2305 response_data = self.api_client.call_api( 2306 *_param, 2307 _request_timeout=_request_timeout 2308 ) 2309 response_data.read() 2310 return self.api_client.response_deserialize( 2311 response_data=response_data, 2312 response_types_map=_response_types_map, 2313 ) 2314 2315 2316 @validate_call 2317 def retrieve_documents_without_preload_content( 2318 self, 2319 organization_id: StrictStr, 2320 pipeline_id: StrictStr, 2321 retrieve_documents_request: RetrieveDocumentsRequest, 2322 _request_timeout: Union[ 2323 None, 2324 Annotated[StrictFloat, Field(gt=0)], 2325 Tuple[ 2326 Annotated[StrictFloat, Field(gt=0)], 2327 Annotated[StrictFloat, Field(gt=0)] 2328 ] 2329 ] = None, 2330 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2331 _content_type: Optional[StrictStr] = None, 2332 _headers: Optional[Dict[StrictStr, Any]] = None, 2333 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2334 ) -> RESTResponseType: 2335 """Retrieve documents from a pipeline 2336 2337 Retrieve documents from a pipeline 2338 2339 :param organization_id: (required) 2340 :type organization_id: str 2341 :param pipeline_id: (required) 2342 :type pipeline_id: str 2343 :param retrieve_documents_request: (required) 2344 :type retrieve_documents_request: RetrieveDocumentsRequest 2345 :param _request_timeout: timeout setting for this request. If one 2346 number provided, it will be total request 2347 timeout. It can also be a pair (tuple) of 2348 (connection, read) timeouts. 2349 :type _request_timeout: int, tuple(int, int), optional 2350 :param _request_auth: set to override the auth_settings for an a single 2351 request; this effectively ignores the 2352 authentication in the spec for a single request. 2353 :type _request_auth: dict, optional 2354 :param _content_type: force content-type for the request. 2355 :type _content_type: str, Optional 2356 :param _headers: set to override the headers for a single 2357 request; this effectively ignores the headers 2358 in the spec for a single request. 2359 :type _headers: dict, optional 2360 :param _host_index: set to override the host_index for a single 2361 request; this effectively ignores the host_index 2362 in the spec for a single request. 2363 :type _host_index: int, optional 2364 :return: Returns the result object. 2365 """ # noqa: E501 2366 2367 _param = self._retrieve_documents_serialize( 2368 organization_id=organization_id, 2369 pipeline_id=pipeline_id, 2370 retrieve_documents_request=retrieve_documents_request, 2371 _request_auth=_request_auth, 2372 _content_type=_content_type, 2373 _headers=_headers, 2374 _host_index=_host_index 2375 ) 2376 2377 _response_types_map: Dict[str, Optional[str]] = { 2378 '200': "RetrieveDocumentsResponse", 2379 '400': "GetWorkspaces400Response", 2380 '401': "GetWorkspaces400Response", 2381 '403': "GetWorkspaces400Response", 2382 '404': "GetWorkspaces400Response", 2383 '500': "GetWorkspaces400Response", 2384 } 2385 response_data = self.api_client.call_api( 2386 *_param, 2387 _request_timeout=_request_timeout 2388 ) 2389 return response_data.response 2390 2391 2392 def _retrieve_documents_serialize( 2393 self, 2394 organization_id, 2395 pipeline_id, 2396 retrieve_documents_request, 2397 _request_auth, 2398 _content_type, 2399 _headers, 2400 _host_index, 2401 ) -> RequestSerialized: 2402 2403 _host = None 2404 2405 _collection_formats: Dict[str, str] = { 2406 } 2407 2408 _path_params: Dict[str, str] = {} 2409 _query_params: List[Tuple[str, str]] = [] 2410 _header_params: Dict[str, Optional[str]] = _headers or {} 2411 _form_params: List[Tuple[str, str]] = [] 2412 _files: Dict[ 2413 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 2414 ] = {} 2415 _body_params: Optional[bytes] = None 2416 2417 # process the path parameters 2418 if organization_id is not None: 2419 _path_params['organizationId'] = organization_id 2420 if pipeline_id is not None: 2421 _path_params['pipelineId'] = pipeline_id 2422 # process the query parameters 2423 # process the header parameters 2424 # process the form parameters 2425 # process the body parameter 2426 if retrieve_documents_request is not None: 2427 _body_params = retrieve_documents_request 2428 2429 2430 # set the HTTP header `Accept` 2431 if 'Accept' not in _header_params: 2432 _header_params['Accept'] = self.api_client.select_header_accept( 2433 [ 2434 'application/json' 2435 ] 2436 ) 2437 2438 # set the HTTP header `Content-Type` 2439 if _content_type: 2440 _header_params['Content-Type'] = _content_type 2441 else: 2442 _default_content_type = ( 2443 self.api_client.select_header_content_type( 2444 [ 2445 'application/json' 2446 ] 2447 ) 2448 ) 2449 if _default_content_type is not None: 2450 _header_params['Content-Type'] = _default_content_type 2451 2452 # authentication setting 2453 _auth_settings: List[str] = [ 2454 'bearerAuth' 2455 ] 2456 2457 return self.api_client.param_serialize( 2458 method='POST', 2459 resource_path='/org/{organizationId}/pipelines/{pipelineId}/retrieval', 2460 path_params=_path_params, 2461 query_params=_query_params, 2462 header_params=_header_params, 2463 body=_body_params, 2464 post_params=_form_params, 2465 files=_files, 2466 auth_settings=_auth_settings, 2467 collection_formats=_collection_formats, 2468 _host=_host, 2469 _request_auth=_request_auth 2470 ) 2471 2472 2473 2474 2475 @validate_call 2476 def start_deep_research( 2477 self, 2478 organization_id: StrictStr, 2479 pipeline_id: StrictStr, 2480 start_deep_research_request: StartDeepResearchRequest, 2481 _request_timeout: Union[ 2482 None, 2483 Annotated[StrictFloat, Field(gt=0)], 2484 Tuple[ 2485 Annotated[StrictFloat, Field(gt=0)], 2486 Annotated[StrictFloat, Field(gt=0)] 2487 ] 2488 ] = None, 2489 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2490 _content_type: Optional[StrictStr] = None, 2491 _headers: Optional[Dict[StrictStr, Any]] = None, 2492 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2493 ) -> StartDeepResearchResponse: 2494 """Start a deep research 2495 2496 Start a deep research 2497 2498 :param organization_id: (required) 2499 :type organization_id: str 2500 :param pipeline_id: (required) 2501 :type pipeline_id: str 2502 :param start_deep_research_request: (required) 2503 :type start_deep_research_request: StartDeepResearchRequest 2504 :param _request_timeout: timeout setting for this request. If one 2505 number provided, it will be total request 2506 timeout. It can also be a pair (tuple) of 2507 (connection, read) timeouts. 2508 :type _request_timeout: int, tuple(int, int), optional 2509 :param _request_auth: set to override the auth_settings for an a single 2510 request; this effectively ignores the 2511 authentication in the spec for a single request. 2512 :type _request_auth: dict, optional 2513 :param _content_type: force content-type for the request. 2514 :type _content_type: str, Optional 2515 :param _headers: set to override the headers for a single 2516 request; this effectively ignores the headers 2517 in the spec for a single request. 2518 :type _headers: dict, optional 2519 :param _host_index: set to override the host_index for a single 2520 request; this effectively ignores the host_index 2521 in the spec for a single request. 2522 :type _host_index: int, optional 2523 :return: Returns the result object. 2524 """ # noqa: E501 2525 2526 _param = self._start_deep_research_serialize( 2527 organization_id=organization_id, 2528 pipeline_id=pipeline_id, 2529 start_deep_research_request=start_deep_research_request, 2530 _request_auth=_request_auth, 2531 _content_type=_content_type, 2532 _headers=_headers, 2533 _host_index=_host_index 2534 ) 2535 2536 _response_types_map: Dict[str, Optional[str]] = { 2537 '200': "StartDeepResearchResponse", 2538 '400': "GetWorkspaces400Response", 2539 '401': "GetWorkspaces400Response", 2540 '403': "GetWorkspaces400Response", 2541 '404': "GetWorkspaces400Response", 2542 '500': "GetWorkspaces400Response", 2543 } 2544 response_data = self.api_client.call_api( 2545 *_param, 2546 _request_timeout=_request_timeout 2547 ) 2548 response_data.read() 2549 return self.api_client.response_deserialize( 2550 response_data=response_data, 2551 response_types_map=_response_types_map, 2552 ).data 2553 2554 2555 @validate_call 2556 def start_deep_research_with_http_info( 2557 self, 2558 organization_id: StrictStr, 2559 pipeline_id: StrictStr, 2560 start_deep_research_request: StartDeepResearchRequest, 2561 _request_timeout: Union[ 2562 None, 2563 Annotated[StrictFloat, Field(gt=0)], 2564 Tuple[ 2565 Annotated[StrictFloat, Field(gt=0)], 2566 Annotated[StrictFloat, Field(gt=0)] 2567 ] 2568 ] = None, 2569 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2570 _content_type: Optional[StrictStr] = None, 2571 _headers: Optional[Dict[StrictStr, Any]] = None, 2572 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2573 ) -> ApiResponse[StartDeepResearchResponse]: 2574 """Start a deep research 2575 2576 Start a deep research 2577 2578 :param organization_id: (required) 2579 :type organization_id: str 2580 :param pipeline_id: (required) 2581 :type pipeline_id: str 2582 :param start_deep_research_request: (required) 2583 :type start_deep_research_request: StartDeepResearchRequest 2584 :param _request_timeout: timeout setting for this request. If one 2585 number provided, it will be total request 2586 timeout. It can also be a pair (tuple) of 2587 (connection, read) timeouts. 2588 :type _request_timeout: int, tuple(int, int), optional 2589 :param _request_auth: set to override the auth_settings for an a single 2590 request; this effectively ignores the 2591 authentication in the spec for a single request. 2592 :type _request_auth: dict, optional 2593 :param _content_type: force content-type for the request. 2594 :type _content_type: str, Optional 2595 :param _headers: set to override the headers for a single 2596 request; this effectively ignores the headers 2597 in the spec for a single request. 2598 :type _headers: dict, optional 2599 :param _host_index: set to override the host_index for a single 2600 request; this effectively ignores the host_index 2601 in the spec for a single request. 2602 :type _host_index: int, optional 2603 :return: Returns the result object. 2604 """ # noqa: E501 2605 2606 _param = self._start_deep_research_serialize( 2607 organization_id=organization_id, 2608 pipeline_id=pipeline_id, 2609 start_deep_research_request=start_deep_research_request, 2610 _request_auth=_request_auth, 2611 _content_type=_content_type, 2612 _headers=_headers, 2613 _host_index=_host_index 2614 ) 2615 2616 _response_types_map: Dict[str, Optional[str]] = { 2617 '200': "StartDeepResearchResponse", 2618 '400': "GetWorkspaces400Response", 2619 '401': "GetWorkspaces400Response", 2620 '403': "GetWorkspaces400Response", 2621 '404': "GetWorkspaces400Response", 2622 '500': "GetWorkspaces400Response", 2623 } 2624 response_data = self.api_client.call_api( 2625 *_param, 2626 _request_timeout=_request_timeout 2627 ) 2628 response_data.read() 2629 return self.api_client.response_deserialize( 2630 response_data=response_data, 2631 response_types_map=_response_types_map, 2632 ) 2633 2634 2635 @validate_call 2636 def start_deep_research_without_preload_content( 2637 self, 2638 organization_id: StrictStr, 2639 pipeline_id: StrictStr, 2640 start_deep_research_request: StartDeepResearchRequest, 2641 _request_timeout: Union[ 2642 None, 2643 Annotated[StrictFloat, Field(gt=0)], 2644 Tuple[ 2645 Annotated[StrictFloat, Field(gt=0)], 2646 Annotated[StrictFloat, Field(gt=0)] 2647 ] 2648 ] = None, 2649 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2650 _content_type: Optional[StrictStr] = None, 2651 _headers: Optional[Dict[StrictStr, Any]] = None, 2652 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2653 ) -> RESTResponseType: 2654 """Start a deep research 2655 2656 Start a deep research 2657 2658 :param organization_id: (required) 2659 :type organization_id: str 2660 :param pipeline_id: (required) 2661 :type pipeline_id: str 2662 :param start_deep_research_request: (required) 2663 :type start_deep_research_request: StartDeepResearchRequest 2664 :param _request_timeout: timeout setting for this request. If one 2665 number provided, it will be total request 2666 timeout. It can also be a pair (tuple) of 2667 (connection, read) timeouts. 2668 :type _request_timeout: int, tuple(int, int), optional 2669 :param _request_auth: set to override the auth_settings for an a single 2670 request; this effectively ignores the 2671 authentication in the spec for a single request. 2672 :type _request_auth: dict, optional 2673 :param _content_type: force content-type for the request. 2674 :type _content_type: str, Optional 2675 :param _headers: set to override the headers for a single 2676 request; this effectively ignores the headers 2677 in the spec for a single request. 2678 :type _headers: dict, optional 2679 :param _host_index: set to override the host_index for a single 2680 request; this effectively ignores the host_index 2681 in the spec for a single request. 2682 :type _host_index: int, optional 2683 :return: Returns the result object. 2684 """ # noqa: E501 2685 2686 _param = self._start_deep_research_serialize( 2687 organization_id=organization_id, 2688 pipeline_id=pipeline_id, 2689 start_deep_research_request=start_deep_research_request, 2690 _request_auth=_request_auth, 2691 _content_type=_content_type, 2692 _headers=_headers, 2693 _host_index=_host_index 2694 ) 2695 2696 _response_types_map: Dict[str, Optional[str]] = { 2697 '200': "StartDeepResearchResponse", 2698 '400': "GetWorkspaces400Response", 2699 '401': "GetWorkspaces400Response", 2700 '403': "GetWorkspaces400Response", 2701 '404': "GetWorkspaces400Response", 2702 '500': "GetWorkspaces400Response", 2703 } 2704 response_data = self.api_client.call_api( 2705 *_param, 2706 _request_timeout=_request_timeout 2707 ) 2708 return response_data.response 2709 2710 2711 def _start_deep_research_serialize( 2712 self, 2713 organization_id, 2714 pipeline_id, 2715 start_deep_research_request, 2716 _request_auth, 2717 _content_type, 2718 _headers, 2719 _host_index, 2720 ) -> RequestSerialized: 2721 2722 _host = None 2723 2724 _collection_formats: Dict[str, str] = { 2725 } 2726 2727 _path_params: Dict[str, str] = {} 2728 _query_params: List[Tuple[str, str]] = [] 2729 _header_params: Dict[str, Optional[str]] = _headers or {} 2730 _form_params: List[Tuple[str, str]] = [] 2731 _files: Dict[ 2732 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 2733 ] = {} 2734 _body_params: Optional[bytes] = None 2735 2736 # process the path parameters 2737 if organization_id is not None: 2738 _path_params['organizationId'] = organization_id 2739 if pipeline_id is not None: 2740 _path_params['pipelineId'] = pipeline_id 2741 # process the query parameters 2742 # process the header parameters 2743 # process the form parameters 2744 # process the body parameter 2745 if start_deep_research_request is not None: 2746 _body_params = start_deep_research_request 2747 2748 2749 # set the HTTP header `Accept` 2750 if 'Accept' not in _header_params: 2751 _header_params['Accept'] = self.api_client.select_header_accept( 2752 [ 2753 'application/json' 2754 ] 2755 ) 2756 2757 # set the HTTP header `Content-Type` 2758 if _content_type: 2759 _header_params['Content-Type'] = _content_type 2760 else: 2761 _default_content_type = ( 2762 self.api_client.select_header_content_type( 2763 [ 2764 'application/json' 2765 ] 2766 ) 2767 ) 2768 if _default_content_type is not None: 2769 _header_params['Content-Type'] = _default_content_type 2770 2771 # authentication setting 2772 _auth_settings: List[str] = [ 2773 'bearerAuth' 2774 ] 2775 2776 return self.api_client.param_serialize( 2777 method='POST', 2778 resource_path='/org/{organizationId}/pipelines/{pipelineId}/deep-research', 2779 path_params=_path_params, 2780 query_params=_query_params, 2781 header_params=_header_params, 2782 body=_body_params, 2783 post_params=_form_params, 2784 files=_files, 2785 auth_settings=_auth_settings, 2786 collection_formats=_collection_formats, 2787 _host=_host, 2788 _request_auth=_request_auth 2789 ) 2790 2791 2792 2793 2794 @validate_call 2795 def start_pipeline( 2796 self, 2797 organization_id: StrictStr, 2798 pipeline_id: StrictStr, 2799 _request_timeout: Union[ 2800 None, 2801 Annotated[StrictFloat, Field(gt=0)], 2802 Tuple[ 2803 Annotated[StrictFloat, Field(gt=0)], 2804 Annotated[StrictFloat, Field(gt=0)] 2805 ] 2806 ] = None, 2807 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2808 _content_type: Optional[StrictStr] = None, 2809 _headers: Optional[Dict[StrictStr, Any]] = None, 2810 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2811 ) -> StartPipelineResponse: 2812 """Start a pipeline 2813 2814 Start a pipeline 2815 2816 :param organization_id: (required) 2817 :type organization_id: str 2818 :param pipeline_id: (required) 2819 :type pipeline_id: str 2820 :param _request_timeout: timeout setting for this request. If one 2821 number provided, it will be total request 2822 timeout. It can also be a pair (tuple) of 2823 (connection, read) timeouts. 2824 :type _request_timeout: int, tuple(int, int), optional 2825 :param _request_auth: set to override the auth_settings for an a single 2826 request; this effectively ignores the 2827 authentication in the spec for a single request. 2828 :type _request_auth: dict, optional 2829 :param _content_type: force content-type for the request. 2830 :type _content_type: str, Optional 2831 :param _headers: set to override the headers for a single 2832 request; this effectively ignores the headers 2833 in the spec for a single request. 2834 :type _headers: dict, optional 2835 :param _host_index: set to override the host_index for a single 2836 request; this effectively ignores the host_index 2837 in the spec for a single request. 2838 :type _host_index: int, optional 2839 :return: Returns the result object. 2840 """ # noqa: E501 2841 2842 _param = self._start_pipeline_serialize( 2843 organization_id=organization_id, 2844 pipeline_id=pipeline_id, 2845 _request_auth=_request_auth, 2846 _content_type=_content_type, 2847 _headers=_headers, 2848 _host_index=_host_index 2849 ) 2850 2851 _response_types_map: Dict[str, Optional[str]] = { 2852 '200': "StartPipelineResponse", 2853 '400': "GetWorkspaces400Response", 2854 '401': "GetWorkspaces400Response", 2855 '403': "GetWorkspaces400Response", 2856 '404': "GetWorkspaces400Response", 2857 '500': "GetWorkspaces400Response", 2858 } 2859 response_data = self.api_client.call_api( 2860 *_param, 2861 _request_timeout=_request_timeout 2862 ) 2863 response_data.read() 2864 return self.api_client.response_deserialize( 2865 response_data=response_data, 2866 response_types_map=_response_types_map, 2867 ).data 2868 2869 2870 @validate_call 2871 def start_pipeline_with_http_info( 2872 self, 2873 organization_id: StrictStr, 2874 pipeline_id: StrictStr, 2875 _request_timeout: Union[ 2876 None, 2877 Annotated[StrictFloat, Field(gt=0)], 2878 Tuple[ 2879 Annotated[StrictFloat, Field(gt=0)], 2880 Annotated[StrictFloat, Field(gt=0)] 2881 ] 2882 ] = None, 2883 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2884 _content_type: Optional[StrictStr] = None, 2885 _headers: Optional[Dict[StrictStr, Any]] = None, 2886 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2887 ) -> ApiResponse[StartPipelineResponse]: 2888 """Start a pipeline 2889 2890 Start a pipeline 2891 2892 :param organization_id: (required) 2893 :type organization_id: str 2894 :param pipeline_id: (required) 2895 :type pipeline_id: str 2896 :param _request_timeout: timeout setting for this request. If one 2897 number provided, it will be total request 2898 timeout. It can also be a pair (tuple) of 2899 (connection, read) timeouts. 2900 :type _request_timeout: int, tuple(int, int), optional 2901 :param _request_auth: set to override the auth_settings for an a single 2902 request; this effectively ignores the 2903 authentication in the spec for a single request. 2904 :type _request_auth: dict, optional 2905 :param _content_type: force content-type for the request. 2906 :type _content_type: str, Optional 2907 :param _headers: set to override the headers for a single 2908 request; this effectively ignores the headers 2909 in the spec for a single request. 2910 :type _headers: dict, optional 2911 :param _host_index: set to override the host_index for a single 2912 request; this effectively ignores the host_index 2913 in the spec for a single request. 2914 :type _host_index: int, optional 2915 :return: Returns the result object. 2916 """ # noqa: E501 2917 2918 _param = self._start_pipeline_serialize( 2919 organization_id=organization_id, 2920 pipeline_id=pipeline_id, 2921 _request_auth=_request_auth, 2922 _content_type=_content_type, 2923 _headers=_headers, 2924 _host_index=_host_index 2925 ) 2926 2927 _response_types_map: Dict[str, Optional[str]] = { 2928 '200': "StartPipelineResponse", 2929 '400': "GetWorkspaces400Response", 2930 '401': "GetWorkspaces400Response", 2931 '403': "GetWorkspaces400Response", 2932 '404': "GetWorkspaces400Response", 2933 '500': "GetWorkspaces400Response", 2934 } 2935 response_data = self.api_client.call_api( 2936 *_param, 2937 _request_timeout=_request_timeout 2938 ) 2939 response_data.read() 2940 return self.api_client.response_deserialize( 2941 response_data=response_data, 2942 response_types_map=_response_types_map, 2943 ) 2944 2945 2946 @validate_call 2947 def start_pipeline_without_preload_content( 2948 self, 2949 organization_id: StrictStr, 2950 pipeline_id: StrictStr, 2951 _request_timeout: Union[ 2952 None, 2953 Annotated[StrictFloat, Field(gt=0)], 2954 Tuple[ 2955 Annotated[StrictFloat, Field(gt=0)], 2956 Annotated[StrictFloat, Field(gt=0)] 2957 ] 2958 ] = None, 2959 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2960 _content_type: Optional[StrictStr] = None, 2961 _headers: Optional[Dict[StrictStr, Any]] = None, 2962 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2963 ) -> RESTResponseType: 2964 """Start a pipeline 2965 2966 Start a pipeline 2967 2968 :param organization_id: (required) 2969 :type organization_id: str 2970 :param pipeline_id: (required) 2971 :type pipeline_id: str 2972 :param _request_timeout: timeout setting for this request. If one 2973 number provided, it will be total request 2974 timeout. It can also be a pair (tuple) of 2975 (connection, read) timeouts. 2976 :type _request_timeout: int, tuple(int, int), optional 2977 :param _request_auth: set to override the auth_settings for an a single 2978 request; this effectively ignores the 2979 authentication in the spec for a single request. 2980 :type _request_auth: dict, optional 2981 :param _content_type: force content-type for the request. 2982 :type _content_type: str, Optional 2983 :param _headers: set to override the headers for a single 2984 request; this effectively ignores the headers 2985 in the spec for a single request. 2986 :type _headers: dict, optional 2987 :param _host_index: set to override the host_index for a single 2988 request; this effectively ignores the host_index 2989 in the spec for a single request. 2990 :type _host_index: int, optional 2991 :return: Returns the result object. 2992 """ # noqa: E501 2993 2994 _param = self._start_pipeline_serialize( 2995 organization_id=organization_id, 2996 pipeline_id=pipeline_id, 2997 _request_auth=_request_auth, 2998 _content_type=_content_type, 2999 _headers=_headers, 3000 _host_index=_host_index 3001 ) 3002 3003 _response_types_map: Dict[str, Optional[str]] = { 3004 '200': "StartPipelineResponse", 3005 '400': "GetWorkspaces400Response", 3006 '401': "GetWorkspaces400Response", 3007 '403': "GetWorkspaces400Response", 3008 '404': "GetWorkspaces400Response", 3009 '500': "GetWorkspaces400Response", 3010 } 3011 response_data = self.api_client.call_api( 3012 *_param, 3013 _request_timeout=_request_timeout 3014 ) 3015 return response_data.response 3016 3017 3018 def _start_pipeline_serialize( 3019 self, 3020 organization_id, 3021 pipeline_id, 3022 _request_auth, 3023 _content_type, 3024 _headers, 3025 _host_index, 3026 ) -> RequestSerialized: 3027 3028 _host = None 3029 3030 _collection_formats: Dict[str, str] = { 3031 } 3032 3033 _path_params: Dict[str, str] = {} 3034 _query_params: List[Tuple[str, str]] = [] 3035 _header_params: Dict[str, Optional[str]] = _headers or {} 3036 _form_params: List[Tuple[str, str]] = [] 3037 _files: Dict[ 3038 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 3039 ] = {} 3040 _body_params: Optional[bytes] = None 3041 3042 # process the path parameters 3043 if organization_id is not None: 3044 _path_params['organizationId'] = organization_id 3045 if pipeline_id is not None: 3046 _path_params['pipelineId'] = pipeline_id 3047 # process the query parameters 3048 # process the header parameters 3049 # process the form parameters 3050 # process the body parameter 3051 3052 3053 # set the HTTP header `Accept` 3054 if 'Accept' not in _header_params: 3055 _header_params['Accept'] = self.api_client.select_header_accept( 3056 [ 3057 'application/json' 3058 ] 3059 ) 3060 3061 3062 # authentication setting 3063 _auth_settings: List[str] = [ 3064 'bearerAuth' 3065 ] 3066 3067 return self.api_client.param_serialize( 3068 method='POST', 3069 resource_path='/org/{organizationId}/pipelines/{pipelineId}/start', 3070 path_params=_path_params, 3071 query_params=_query_params, 3072 header_params=_header_params, 3073 body=_body_params, 3074 post_params=_form_params, 3075 files=_files, 3076 auth_settings=_auth_settings, 3077 collection_formats=_collection_formats, 3078 _host=_host, 3079 _request_auth=_request_auth 3080 ) 3081 3082 3083 3084 3085 @validate_call 3086 def stop_pipeline( 3087 self, 3088 organization_id: StrictStr, 3089 pipeline_id: StrictStr, 3090 _request_timeout: Union[ 3091 None, 3092 Annotated[StrictFloat, Field(gt=0)], 3093 Tuple[ 3094 Annotated[StrictFloat, Field(gt=0)], 3095 Annotated[StrictFloat, Field(gt=0)] 3096 ] 3097 ] = None, 3098 _request_auth: Optional[Dict[StrictStr, Any]] = None, 3099 _content_type: Optional[StrictStr] = None, 3100 _headers: Optional[Dict[StrictStr, Any]] = None, 3101 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 3102 ) -> StopPipelineResponse: 3103 """Stop a pipeline 3104 3105 Stop a pipeline 3106 3107 :param organization_id: (required) 3108 :type organization_id: str 3109 :param pipeline_id: (required) 3110 :type pipeline_id: str 3111 :param _request_timeout: timeout setting for this request. If one 3112 number provided, it will be total request 3113 timeout. It can also be a pair (tuple) of 3114 (connection, read) timeouts. 3115 :type _request_timeout: int, tuple(int, int), optional 3116 :param _request_auth: set to override the auth_settings for an a single 3117 request; this effectively ignores the 3118 authentication in the spec for a single request. 3119 :type _request_auth: dict, optional 3120 :param _content_type: force content-type for the request. 3121 :type _content_type: str, Optional 3122 :param _headers: set to override the headers for a single 3123 request; this effectively ignores the headers 3124 in the spec for a single request. 3125 :type _headers: dict, optional 3126 :param _host_index: set to override the host_index for a single 3127 request; this effectively ignores the host_index 3128 in the spec for a single request. 3129 :type _host_index: int, optional 3130 :return: Returns the result object. 3131 """ # noqa: E501 3132 3133 _param = self._stop_pipeline_serialize( 3134 organization_id=organization_id, 3135 pipeline_id=pipeline_id, 3136 _request_auth=_request_auth, 3137 _content_type=_content_type, 3138 _headers=_headers, 3139 _host_index=_host_index 3140 ) 3141 3142 _response_types_map: Dict[str, Optional[str]] = { 3143 '200': "StopPipelineResponse", 3144 '400': "GetWorkspaces400Response", 3145 '401': "GetWorkspaces400Response", 3146 '403': "GetWorkspaces400Response", 3147 '404': "GetWorkspaces400Response", 3148 '500': "GetWorkspaces400Response", 3149 } 3150 response_data = self.api_client.call_api( 3151 *_param, 3152 _request_timeout=_request_timeout 3153 ) 3154 response_data.read() 3155 return self.api_client.response_deserialize( 3156 response_data=response_data, 3157 response_types_map=_response_types_map, 3158 ).data 3159 3160 3161 @validate_call 3162 def stop_pipeline_with_http_info( 3163 self, 3164 organization_id: StrictStr, 3165 pipeline_id: StrictStr, 3166 _request_timeout: Union[ 3167 None, 3168 Annotated[StrictFloat, Field(gt=0)], 3169 Tuple[ 3170 Annotated[StrictFloat, Field(gt=0)], 3171 Annotated[StrictFloat, Field(gt=0)] 3172 ] 3173 ] = None, 3174 _request_auth: Optional[Dict[StrictStr, Any]] = None, 3175 _content_type: Optional[StrictStr] = None, 3176 _headers: Optional[Dict[StrictStr, Any]] = None, 3177 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 3178 ) -> ApiResponse[StopPipelineResponse]: 3179 """Stop a pipeline 3180 3181 Stop a pipeline 3182 3183 :param organization_id: (required) 3184 :type organization_id: str 3185 :param pipeline_id: (required) 3186 :type pipeline_id: str 3187 :param _request_timeout: timeout setting for this request. If one 3188 number provided, it will be total request 3189 timeout. It can also be a pair (tuple) of 3190 (connection, read) timeouts. 3191 :type _request_timeout: int, tuple(int, int), optional 3192 :param _request_auth: set to override the auth_settings for an a single 3193 request; this effectively ignores the 3194 authentication in the spec for a single request. 3195 :type _request_auth: dict, optional 3196 :param _content_type: force content-type for the request. 3197 :type _content_type: str, Optional 3198 :param _headers: set to override the headers for a single 3199 request; this effectively ignores the headers 3200 in the spec for a single request. 3201 :type _headers: dict, optional 3202 :param _host_index: set to override the host_index for a single 3203 request; this effectively ignores the host_index 3204 in the spec for a single request. 3205 :type _host_index: int, optional 3206 :return: Returns the result object. 3207 """ # noqa: E501 3208 3209 _param = self._stop_pipeline_serialize( 3210 organization_id=organization_id, 3211 pipeline_id=pipeline_id, 3212 _request_auth=_request_auth, 3213 _content_type=_content_type, 3214 _headers=_headers, 3215 _host_index=_host_index 3216 ) 3217 3218 _response_types_map: Dict[str, Optional[str]] = { 3219 '200': "StopPipelineResponse", 3220 '400': "GetWorkspaces400Response", 3221 '401': "GetWorkspaces400Response", 3222 '403': "GetWorkspaces400Response", 3223 '404': "GetWorkspaces400Response", 3224 '500': "GetWorkspaces400Response", 3225 } 3226 response_data = self.api_client.call_api( 3227 *_param, 3228 _request_timeout=_request_timeout 3229 ) 3230 response_data.read() 3231 return self.api_client.response_deserialize( 3232 response_data=response_data, 3233 response_types_map=_response_types_map, 3234 ) 3235 3236 3237 @validate_call 3238 def stop_pipeline_without_preload_content( 3239 self, 3240 organization_id: StrictStr, 3241 pipeline_id: StrictStr, 3242 _request_timeout: Union[ 3243 None, 3244 Annotated[StrictFloat, Field(gt=0)], 3245 Tuple[ 3246 Annotated[StrictFloat, Field(gt=0)], 3247 Annotated[StrictFloat, Field(gt=0)] 3248 ] 3249 ] = None, 3250 _request_auth: Optional[Dict[StrictStr, Any]] = None, 3251 _content_type: Optional[StrictStr] = None, 3252 _headers: Optional[Dict[StrictStr, Any]] = None, 3253 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 3254 ) -> RESTResponseType: 3255 """Stop a pipeline 3256 3257 Stop a pipeline 3258 3259 :param organization_id: (required) 3260 :type organization_id: str 3261 :param pipeline_id: (required) 3262 :type pipeline_id: str 3263 :param _request_timeout: timeout setting for this request. If one 3264 number provided, it will be total request 3265 timeout. It can also be a pair (tuple) of 3266 (connection, read) timeouts. 3267 :type _request_timeout: int, tuple(int, int), optional 3268 :param _request_auth: set to override the auth_settings for an a single 3269 request; this effectively ignores the 3270 authentication in the spec for a single request. 3271 :type _request_auth: dict, optional 3272 :param _content_type: force content-type for the request. 3273 :type _content_type: str, Optional 3274 :param _headers: set to override the headers for a single 3275 request; this effectively ignores the headers 3276 in the spec for a single request. 3277 :type _headers: dict, optional 3278 :param _host_index: set to override the host_index for a single 3279 request; this effectively ignores the host_index 3280 in the spec for a single request. 3281 :type _host_index: int, optional 3282 :return: Returns the result object. 3283 """ # noqa: E501 3284 3285 _param = self._stop_pipeline_serialize( 3286 organization_id=organization_id, 3287 pipeline_id=pipeline_id, 3288 _request_auth=_request_auth, 3289 _content_type=_content_type, 3290 _headers=_headers, 3291 _host_index=_host_index 3292 ) 3293 3294 _response_types_map: Dict[str, Optional[str]] = { 3295 '200': "StopPipelineResponse", 3296 '400': "GetWorkspaces400Response", 3297 '401': "GetWorkspaces400Response", 3298 '403': "GetWorkspaces400Response", 3299 '404': "GetWorkspaces400Response", 3300 '500': "GetWorkspaces400Response", 3301 } 3302 response_data = self.api_client.call_api( 3303 *_param, 3304 _request_timeout=_request_timeout 3305 ) 3306 return response_data.response 3307 3308 3309 def _stop_pipeline_serialize( 3310 self, 3311 organization_id, 3312 pipeline_id, 3313 _request_auth, 3314 _content_type, 3315 _headers, 3316 _host_index, 3317 ) -> RequestSerialized: 3318 3319 _host = None 3320 3321 _collection_formats: Dict[str, str] = { 3322 } 3323 3324 _path_params: Dict[str, str] = {} 3325 _query_params: List[Tuple[str, str]] = [] 3326 _header_params: Dict[str, Optional[str]] = _headers or {} 3327 _form_params: List[Tuple[str, str]] = [] 3328 _files: Dict[ 3329 str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] 3330 ] = {} 3331 _body_params: Optional[bytes] = None 3332 3333 # process the path parameters 3334 if organization_id is not None: 3335 _path_params['organizationId'] = organization_id 3336 if pipeline_id is not None: 3337 _path_params['pipelineId'] = pipeline_id 3338 # process the query parameters 3339 # process the header parameters 3340 # process the form parameters 3341 # process the body parameter 3342 3343 3344 # set the HTTP header `Accept` 3345 if 'Accept' not in _header_params: 3346 _header_params['Accept'] = self.api_client.select_header_accept( 3347 [ 3348 'application/json' 3349 ] 3350 ) 3351 3352 3353 # authentication setting 3354 _auth_settings: List[str] = [ 3355 'bearerAuth' 3356 ] 3357 3358 return self.api_client.param_serialize( 3359 method='POST', 3360 resource_path='/org/{organizationId}/pipelines/{pipelineId}/stop', 3361 path_params=_path_params, 3362 query_params=_query_params, 3363 header_params=_header_params, 3364 body=_body_params, 3365 post_params=_form_params, 3366 files=_files, 3367 auth_settings=_auth_settings, 3368 collection_formats=_collection_formats, 3369 _host=_host, 3370 _request_auth=_request_auth 3371 )
NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech
Do not edit the class manually.
@validate_call
def
create_pipeline( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_configuration_schema: vectorize_client.models.pipeline_configuration_schema.PipelineConfigurationSchema, workspace_id: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.create_pipeline_response.CreatePipelineResponse:
55 @validate_call 56 def create_pipeline( 57 self, 58 organization_id: StrictStr, 59 pipeline_configuration_schema: PipelineConfigurationSchema, 60 workspace_id: Optional[StrictStr] = None, 61 _request_timeout: Union[ 62 None, 63 Annotated[StrictFloat, Field(gt=0)], 64 Tuple[ 65 Annotated[StrictFloat, Field(gt=0)], 66 Annotated[StrictFloat, Field(gt=0)] 67 ] 68 ] = None, 69 _request_auth: Optional[Dict[StrictStr, Any]] = None, 70 _content_type: Optional[StrictStr] = None, 71 _headers: Optional[Dict[StrictStr, Any]] = None, 72 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 73 ) -> CreatePipelineResponse: 74 """Create a new pipeline 75 76 Creates a new pipeline with source connectors, destination connector, and AI platform configuration. The specific configuration fields required depend on the connector types selected. 77 78 :param organization_id: (required) 79 :type organization_id: str 80 :param pipeline_configuration_schema: (required) 81 :type pipeline_configuration_schema: PipelineConfigurationSchema 82 :param workspace_id: 83 :type workspace_id: str 84 :param _request_timeout: timeout setting for this request. If one 85 number provided, it will be total request 86 timeout. It can also be a pair (tuple) of 87 (connection, read) timeouts. 88 :type _request_timeout: int, tuple(int, int), optional 89 :param _request_auth: set to override the auth_settings for an a single 90 request; this effectively ignores the 91 authentication in the spec for a single request. 92 :type _request_auth: dict, optional 93 :param _content_type: force content-type for the request. 94 :type _content_type: str, Optional 95 :param _headers: set to override the headers for a single 96 request; this effectively ignores the headers 97 in the spec for a single request. 98 :type _headers: dict, optional 99 :param _host_index: set to override the host_index for a single 100 request; this effectively ignores the host_index 101 in the spec for a single request. 102 :type _host_index: int, optional 103 :return: Returns the result object. 104 """ # noqa: E501 105 106 _param = self._create_pipeline_serialize( 107 organization_id=organization_id, 108 pipeline_configuration_schema=pipeline_configuration_schema, 109 workspace_id=workspace_id, 110 _request_auth=_request_auth, 111 _content_type=_content_type, 112 _headers=_headers, 113 _host_index=_host_index 114 ) 115 116 _response_types_map: Dict[str, Optional[str]] = { 117 '200': "CreatePipelineResponse", 118 '400': "GetWorkspaces400Response", 119 '401': "GetWorkspaces400Response", 120 '403': "GetWorkspaces400Response", 121 '404': "GetWorkspaces400Response", 122 '500': "GetWorkspaces400Response", 123 } 124 response_data = self.api_client.call_api( 125 *_param, 126 _request_timeout=_request_timeout 127 ) 128 response_data.read() 129 return self.api_client.response_deserialize( 130 response_data=response_data, 131 response_types_map=_response_types_map, 132 ).data
Create a new pipeline
Creates a new pipeline with source connectors, destination connector, and AI platform configuration. The specific configuration fields required depend on the connector types selected.
Parameters
- organization_id: (required)
- pipeline_configuration_schema: (required)
- workspace_id:
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
create_pipeline_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_configuration_schema: vectorize_client.models.pipeline_configuration_schema.PipelineConfigurationSchema, workspace_id: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[CreatePipelineResponse]:
135 @validate_call 136 def create_pipeline_with_http_info( 137 self, 138 organization_id: StrictStr, 139 pipeline_configuration_schema: PipelineConfigurationSchema, 140 workspace_id: Optional[StrictStr] = None, 141 _request_timeout: Union[ 142 None, 143 Annotated[StrictFloat, Field(gt=0)], 144 Tuple[ 145 Annotated[StrictFloat, Field(gt=0)], 146 Annotated[StrictFloat, Field(gt=0)] 147 ] 148 ] = None, 149 _request_auth: Optional[Dict[StrictStr, Any]] = None, 150 _content_type: Optional[StrictStr] = None, 151 _headers: Optional[Dict[StrictStr, Any]] = None, 152 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 153 ) -> ApiResponse[CreatePipelineResponse]: 154 """Create a new pipeline 155 156 Creates a new pipeline with source connectors, destination connector, and AI platform configuration. The specific configuration fields required depend on the connector types selected. 157 158 :param organization_id: (required) 159 :type organization_id: str 160 :param pipeline_configuration_schema: (required) 161 :type pipeline_configuration_schema: PipelineConfigurationSchema 162 :param workspace_id: 163 :type workspace_id: str 164 :param _request_timeout: timeout setting for this request. If one 165 number provided, it will be total request 166 timeout. It can also be a pair (tuple) of 167 (connection, read) timeouts. 168 :type _request_timeout: int, tuple(int, int), optional 169 :param _request_auth: set to override the auth_settings for an a single 170 request; this effectively ignores the 171 authentication in the spec for a single request. 172 :type _request_auth: dict, optional 173 :param _content_type: force content-type for the request. 174 :type _content_type: str, Optional 175 :param _headers: set to override the headers for a single 176 request; this effectively ignores the headers 177 in the spec for a single request. 178 :type _headers: dict, optional 179 :param _host_index: set to override the host_index for a single 180 request; this effectively ignores the host_index 181 in the spec for a single request. 182 :type _host_index: int, optional 183 :return: Returns the result object. 184 """ # noqa: E501 185 186 _param = self._create_pipeline_serialize( 187 organization_id=organization_id, 188 pipeline_configuration_schema=pipeline_configuration_schema, 189 workspace_id=workspace_id, 190 _request_auth=_request_auth, 191 _content_type=_content_type, 192 _headers=_headers, 193 _host_index=_host_index 194 ) 195 196 _response_types_map: Dict[str, Optional[str]] = { 197 '200': "CreatePipelineResponse", 198 '400': "GetWorkspaces400Response", 199 '401': "GetWorkspaces400Response", 200 '403': "GetWorkspaces400Response", 201 '404': "GetWorkspaces400Response", 202 '500': "GetWorkspaces400Response", 203 } 204 response_data = self.api_client.call_api( 205 *_param, 206 _request_timeout=_request_timeout 207 ) 208 response_data.read() 209 return self.api_client.response_deserialize( 210 response_data=response_data, 211 response_types_map=_response_types_map, 212 )
Create a new pipeline
Creates a new pipeline with source connectors, destination connector, and AI platform configuration. The specific configuration fields required depend on the connector types selected.
Parameters
- organization_id: (required)
- pipeline_configuration_schema: (required)
- workspace_id:
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
create_pipeline_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_configuration_schema: vectorize_client.models.pipeline_configuration_schema.PipelineConfigurationSchema, workspace_id: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse:
215 @validate_call 216 def create_pipeline_without_preload_content( 217 self, 218 organization_id: StrictStr, 219 pipeline_configuration_schema: PipelineConfigurationSchema, 220 workspace_id: Optional[StrictStr] = None, 221 _request_timeout: Union[ 222 None, 223 Annotated[StrictFloat, Field(gt=0)], 224 Tuple[ 225 Annotated[StrictFloat, Field(gt=0)], 226 Annotated[StrictFloat, Field(gt=0)] 227 ] 228 ] = None, 229 _request_auth: Optional[Dict[StrictStr, Any]] = None, 230 _content_type: Optional[StrictStr] = None, 231 _headers: Optional[Dict[StrictStr, Any]] = None, 232 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 233 ) -> RESTResponseType: 234 """Create a new pipeline 235 236 Creates a new pipeline with source connectors, destination connector, and AI platform configuration. The specific configuration fields required depend on the connector types selected. 237 238 :param organization_id: (required) 239 :type organization_id: str 240 :param pipeline_configuration_schema: (required) 241 :type pipeline_configuration_schema: PipelineConfigurationSchema 242 :param workspace_id: 243 :type workspace_id: str 244 :param _request_timeout: timeout setting for this request. If one 245 number provided, it will be total request 246 timeout. It can also be a pair (tuple) of 247 (connection, read) timeouts. 248 :type _request_timeout: int, tuple(int, int), optional 249 :param _request_auth: set to override the auth_settings for an a single 250 request; this effectively ignores the 251 authentication in the spec for a single request. 252 :type _request_auth: dict, optional 253 :param _content_type: force content-type for the request. 254 :type _content_type: str, Optional 255 :param _headers: set to override the headers for a single 256 request; this effectively ignores the headers 257 in the spec for a single request. 258 :type _headers: dict, optional 259 :param _host_index: set to override the host_index for a single 260 request; this effectively ignores the host_index 261 in the spec for a single request. 262 :type _host_index: int, optional 263 :return: Returns the result object. 264 """ # noqa: E501 265 266 _param = self._create_pipeline_serialize( 267 organization_id=organization_id, 268 pipeline_configuration_schema=pipeline_configuration_schema, 269 workspace_id=workspace_id, 270 _request_auth=_request_auth, 271 _content_type=_content_type, 272 _headers=_headers, 273 _host_index=_host_index 274 ) 275 276 _response_types_map: Dict[str, Optional[str]] = { 277 '200': "CreatePipelineResponse", 278 '400': "GetWorkspaces400Response", 279 '401': "GetWorkspaces400Response", 280 '403': "GetWorkspaces400Response", 281 '404': "GetWorkspaces400Response", 282 '500': "GetWorkspaces400Response", 283 } 284 response_data = self.api_client.call_api( 285 *_param, 286 _request_timeout=_request_timeout 287 ) 288 return response_data.response
Create a new pipeline
Creates a new pipeline with source connectors, destination connector, and AI platform configuration. The specific configuration fields required depend on the connector types selected.
Parameters
- organization_id: (required)
- pipeline_configuration_schema: (required)
- workspace_id:
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
delete_pipeline( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.delete_pipeline_response.DeletePipelineResponse:
376 @validate_call 377 def delete_pipeline( 378 self, 379 organization_id: StrictStr, 380 pipeline_id: StrictStr, 381 _request_timeout: Union[ 382 None, 383 Annotated[StrictFloat, Field(gt=0)], 384 Tuple[ 385 Annotated[StrictFloat, Field(gt=0)], 386 Annotated[StrictFloat, Field(gt=0)] 387 ] 388 ] = None, 389 _request_auth: Optional[Dict[StrictStr, Any]] = None, 390 _content_type: Optional[StrictStr] = None, 391 _headers: Optional[Dict[StrictStr, Any]] = None, 392 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 393 ) -> DeletePipelineResponse: 394 """Delete a pipeline 395 396 Delete a pipeline 397 398 :param organization_id: (required) 399 :type organization_id: str 400 :param pipeline_id: (required) 401 :type pipeline_id: str 402 :param _request_timeout: timeout setting for this request. If one 403 number provided, it will be total request 404 timeout. It can also be a pair (tuple) of 405 (connection, read) timeouts. 406 :type _request_timeout: int, tuple(int, int), optional 407 :param _request_auth: set to override the auth_settings for an a single 408 request; this effectively ignores the 409 authentication in the spec for a single request. 410 :type _request_auth: dict, optional 411 :param _content_type: force content-type for the request. 412 :type _content_type: str, Optional 413 :param _headers: set to override the headers for a single 414 request; this effectively ignores the headers 415 in the spec for a single request. 416 :type _headers: dict, optional 417 :param _host_index: set to override the host_index for a single 418 request; this effectively ignores the host_index 419 in the spec for a single request. 420 :type _host_index: int, optional 421 :return: Returns the result object. 422 """ # noqa: E501 423 424 _param = self._delete_pipeline_serialize( 425 organization_id=organization_id, 426 pipeline_id=pipeline_id, 427 _request_auth=_request_auth, 428 _content_type=_content_type, 429 _headers=_headers, 430 _host_index=_host_index 431 ) 432 433 _response_types_map: Dict[str, Optional[str]] = { 434 '200': "DeletePipelineResponse", 435 '400': "GetWorkspaces400Response", 436 '401': "GetWorkspaces400Response", 437 '403': "GetWorkspaces400Response", 438 '404': "GetWorkspaces400Response", 439 '500': "GetWorkspaces400Response", 440 } 441 response_data = self.api_client.call_api( 442 *_param, 443 _request_timeout=_request_timeout 444 ) 445 response_data.read() 446 return self.api_client.response_deserialize( 447 response_data=response_data, 448 response_types_map=_response_types_map, 449 ).data
Delete a pipeline
Delete a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
delete_pipeline_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[DeletePipelineResponse]:
452 @validate_call 453 def delete_pipeline_with_http_info( 454 self, 455 organization_id: StrictStr, 456 pipeline_id: StrictStr, 457 _request_timeout: Union[ 458 None, 459 Annotated[StrictFloat, Field(gt=0)], 460 Tuple[ 461 Annotated[StrictFloat, Field(gt=0)], 462 Annotated[StrictFloat, Field(gt=0)] 463 ] 464 ] = None, 465 _request_auth: Optional[Dict[StrictStr, Any]] = None, 466 _content_type: Optional[StrictStr] = None, 467 _headers: Optional[Dict[StrictStr, Any]] = None, 468 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 469 ) -> ApiResponse[DeletePipelineResponse]: 470 """Delete a pipeline 471 472 Delete a pipeline 473 474 :param organization_id: (required) 475 :type organization_id: str 476 :param pipeline_id: (required) 477 :type pipeline_id: str 478 :param _request_timeout: timeout setting for this request. If one 479 number provided, it will be total request 480 timeout. It can also be a pair (tuple) of 481 (connection, read) timeouts. 482 :type _request_timeout: int, tuple(int, int), optional 483 :param _request_auth: set to override the auth_settings for an a single 484 request; this effectively ignores the 485 authentication in the spec for a single request. 486 :type _request_auth: dict, optional 487 :param _content_type: force content-type for the request. 488 :type _content_type: str, Optional 489 :param _headers: set to override the headers for a single 490 request; this effectively ignores the headers 491 in the spec for a single request. 492 :type _headers: dict, optional 493 :param _host_index: set to override the host_index for a single 494 request; this effectively ignores the host_index 495 in the spec for a single request. 496 :type _host_index: int, optional 497 :return: Returns the result object. 498 """ # noqa: E501 499 500 _param = self._delete_pipeline_serialize( 501 organization_id=organization_id, 502 pipeline_id=pipeline_id, 503 _request_auth=_request_auth, 504 _content_type=_content_type, 505 _headers=_headers, 506 _host_index=_host_index 507 ) 508 509 _response_types_map: Dict[str, Optional[str]] = { 510 '200': "DeletePipelineResponse", 511 '400': "GetWorkspaces400Response", 512 '401': "GetWorkspaces400Response", 513 '403': "GetWorkspaces400Response", 514 '404': "GetWorkspaces400Response", 515 '500': "GetWorkspaces400Response", 516 } 517 response_data = self.api_client.call_api( 518 *_param, 519 _request_timeout=_request_timeout 520 ) 521 response_data.read() 522 return self.api_client.response_deserialize( 523 response_data=response_data, 524 response_types_map=_response_types_map, 525 )
Delete a pipeline
Delete a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
delete_pipeline_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse:
528 @validate_call 529 def delete_pipeline_without_preload_content( 530 self, 531 organization_id: StrictStr, 532 pipeline_id: StrictStr, 533 _request_timeout: Union[ 534 None, 535 Annotated[StrictFloat, Field(gt=0)], 536 Tuple[ 537 Annotated[StrictFloat, Field(gt=0)], 538 Annotated[StrictFloat, Field(gt=0)] 539 ] 540 ] = None, 541 _request_auth: Optional[Dict[StrictStr, Any]] = None, 542 _content_type: Optional[StrictStr] = None, 543 _headers: Optional[Dict[StrictStr, Any]] = None, 544 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 545 ) -> RESTResponseType: 546 """Delete a pipeline 547 548 Delete a pipeline 549 550 :param organization_id: (required) 551 :type organization_id: str 552 :param pipeline_id: (required) 553 :type pipeline_id: str 554 :param _request_timeout: timeout setting for this request. If one 555 number provided, it will be total request 556 timeout. It can also be a pair (tuple) of 557 (connection, read) timeouts. 558 :type _request_timeout: int, tuple(int, int), optional 559 :param _request_auth: set to override the auth_settings for an a single 560 request; this effectively ignores the 561 authentication in the spec for a single request. 562 :type _request_auth: dict, optional 563 :param _content_type: force content-type for the request. 564 :type _content_type: str, Optional 565 :param _headers: set to override the headers for a single 566 request; this effectively ignores the headers 567 in the spec for a single request. 568 :type _headers: dict, optional 569 :param _host_index: set to override the host_index for a single 570 request; this effectively ignores the host_index 571 in the spec for a single request. 572 :type _host_index: int, optional 573 :return: Returns the result object. 574 """ # noqa: E501 575 576 _param = self._delete_pipeline_serialize( 577 organization_id=organization_id, 578 pipeline_id=pipeline_id, 579 _request_auth=_request_auth, 580 _content_type=_content_type, 581 _headers=_headers, 582 _host_index=_host_index 583 ) 584 585 _response_types_map: Dict[str, Optional[str]] = { 586 '200': "DeletePipelineResponse", 587 '400': "GetWorkspaces400Response", 588 '401': "GetWorkspaces400Response", 589 '403': "GetWorkspaces400Response", 590 '404': "GetWorkspaces400Response", 591 '500': "GetWorkspaces400Response", 592 } 593 response_data = self.api_client.call_api( 594 *_param, 595 _request_timeout=_request_timeout 596 ) 597 return response_data.response
Delete a pipeline
Delete a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_deep_research_result( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], research_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.get_deep_research_response.GetDeepResearchResponse:
667 @validate_call 668 def get_deep_research_result( 669 self, 670 organization_id: StrictStr, 671 pipeline_id: StrictStr, 672 research_id: StrictStr, 673 _request_timeout: Union[ 674 None, 675 Annotated[StrictFloat, Field(gt=0)], 676 Tuple[ 677 Annotated[StrictFloat, Field(gt=0)], 678 Annotated[StrictFloat, Field(gt=0)] 679 ] 680 ] = None, 681 _request_auth: Optional[Dict[StrictStr, Any]] = None, 682 _content_type: Optional[StrictStr] = None, 683 _headers: Optional[Dict[StrictStr, Any]] = None, 684 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 685 ) -> GetDeepResearchResponse: 686 """Get deep research result 687 688 Get deep research result 689 690 :param organization_id: (required) 691 :type organization_id: str 692 :param pipeline_id: (required) 693 :type pipeline_id: str 694 :param research_id: (required) 695 :type research_id: str 696 :param _request_timeout: timeout setting for this request. If one 697 number provided, it will be total request 698 timeout. It can also be a pair (tuple) of 699 (connection, read) timeouts. 700 :type _request_timeout: int, tuple(int, int), optional 701 :param _request_auth: set to override the auth_settings for an a single 702 request; this effectively ignores the 703 authentication in the spec for a single request. 704 :type _request_auth: dict, optional 705 :param _content_type: force content-type for the request. 706 :type _content_type: str, Optional 707 :param _headers: set to override the headers for a single 708 request; this effectively ignores the headers 709 in the spec for a single request. 710 :type _headers: dict, optional 711 :param _host_index: set to override the host_index for a single 712 request; this effectively ignores the host_index 713 in the spec for a single request. 714 :type _host_index: int, optional 715 :return: Returns the result object. 716 """ # noqa: E501 717 718 _param = self._get_deep_research_result_serialize( 719 organization_id=organization_id, 720 pipeline_id=pipeline_id, 721 research_id=research_id, 722 _request_auth=_request_auth, 723 _content_type=_content_type, 724 _headers=_headers, 725 _host_index=_host_index 726 ) 727 728 _response_types_map: Dict[str, Optional[str]] = { 729 '200': "GetDeepResearchResponse", 730 '400': "GetWorkspaces400Response", 731 '401': "GetWorkspaces400Response", 732 '403': "GetWorkspaces400Response", 733 '404': "GetWorkspaces400Response", 734 '500': "GetWorkspaces400Response", 735 } 736 response_data = self.api_client.call_api( 737 *_param, 738 _request_timeout=_request_timeout 739 ) 740 response_data.read() 741 return self.api_client.response_deserialize( 742 response_data=response_data, 743 response_types_map=_response_types_map, 744 ).data
Get deep research result
Get deep research result
Parameters
- organization_id: (required)
- pipeline_id: (required)
- research_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_deep_research_result_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], research_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[GetDeepResearchResponse]:
747 @validate_call 748 def get_deep_research_result_with_http_info( 749 self, 750 organization_id: StrictStr, 751 pipeline_id: StrictStr, 752 research_id: StrictStr, 753 _request_timeout: Union[ 754 None, 755 Annotated[StrictFloat, Field(gt=0)], 756 Tuple[ 757 Annotated[StrictFloat, Field(gt=0)], 758 Annotated[StrictFloat, Field(gt=0)] 759 ] 760 ] = None, 761 _request_auth: Optional[Dict[StrictStr, Any]] = None, 762 _content_type: Optional[StrictStr] = None, 763 _headers: Optional[Dict[StrictStr, Any]] = None, 764 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 765 ) -> ApiResponse[GetDeepResearchResponse]: 766 """Get deep research result 767 768 Get deep research result 769 770 :param organization_id: (required) 771 :type organization_id: str 772 :param pipeline_id: (required) 773 :type pipeline_id: str 774 :param research_id: (required) 775 :type research_id: str 776 :param _request_timeout: timeout setting for this request. If one 777 number provided, it will be total request 778 timeout. It can also be a pair (tuple) of 779 (connection, read) timeouts. 780 :type _request_timeout: int, tuple(int, int), optional 781 :param _request_auth: set to override the auth_settings for an a single 782 request; this effectively ignores the 783 authentication in the spec for a single request. 784 :type _request_auth: dict, optional 785 :param _content_type: force content-type for the request. 786 :type _content_type: str, Optional 787 :param _headers: set to override the headers for a single 788 request; this effectively ignores the headers 789 in the spec for a single request. 790 :type _headers: dict, optional 791 :param _host_index: set to override the host_index for a single 792 request; this effectively ignores the host_index 793 in the spec for a single request. 794 :type _host_index: int, optional 795 :return: Returns the result object. 796 """ # noqa: E501 797 798 _param = self._get_deep_research_result_serialize( 799 organization_id=organization_id, 800 pipeline_id=pipeline_id, 801 research_id=research_id, 802 _request_auth=_request_auth, 803 _content_type=_content_type, 804 _headers=_headers, 805 _host_index=_host_index 806 ) 807 808 _response_types_map: Dict[str, Optional[str]] = { 809 '200': "GetDeepResearchResponse", 810 '400': "GetWorkspaces400Response", 811 '401': "GetWorkspaces400Response", 812 '403': "GetWorkspaces400Response", 813 '404': "GetWorkspaces400Response", 814 '500': "GetWorkspaces400Response", 815 } 816 response_data = self.api_client.call_api( 817 *_param, 818 _request_timeout=_request_timeout 819 ) 820 response_data.read() 821 return self.api_client.response_deserialize( 822 response_data=response_data, 823 response_types_map=_response_types_map, 824 )
Get deep research result
Get deep research result
Parameters
- organization_id: (required)
- pipeline_id: (required)
- research_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_deep_research_result_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], research_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse:
827 @validate_call 828 def get_deep_research_result_without_preload_content( 829 self, 830 organization_id: StrictStr, 831 pipeline_id: StrictStr, 832 research_id: StrictStr, 833 _request_timeout: Union[ 834 None, 835 Annotated[StrictFloat, Field(gt=0)], 836 Tuple[ 837 Annotated[StrictFloat, Field(gt=0)], 838 Annotated[StrictFloat, Field(gt=0)] 839 ] 840 ] = None, 841 _request_auth: Optional[Dict[StrictStr, Any]] = None, 842 _content_type: Optional[StrictStr] = None, 843 _headers: Optional[Dict[StrictStr, Any]] = None, 844 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 845 ) -> RESTResponseType: 846 """Get deep research result 847 848 Get deep research result 849 850 :param organization_id: (required) 851 :type organization_id: str 852 :param pipeline_id: (required) 853 :type pipeline_id: str 854 :param research_id: (required) 855 :type research_id: str 856 :param _request_timeout: timeout setting for this request. If one 857 number provided, it will be total request 858 timeout. It can also be a pair (tuple) of 859 (connection, read) timeouts. 860 :type _request_timeout: int, tuple(int, int), optional 861 :param _request_auth: set to override the auth_settings for an a single 862 request; this effectively ignores the 863 authentication in the spec for a single request. 864 :type _request_auth: dict, optional 865 :param _content_type: force content-type for the request. 866 :type _content_type: str, Optional 867 :param _headers: set to override the headers for a single 868 request; this effectively ignores the headers 869 in the spec for a single request. 870 :type _headers: dict, optional 871 :param _host_index: set to override the host_index for a single 872 request; this effectively ignores the host_index 873 in the spec for a single request. 874 :type _host_index: int, optional 875 :return: Returns the result object. 876 """ # noqa: E501 877 878 _param = self._get_deep_research_result_serialize( 879 organization_id=organization_id, 880 pipeline_id=pipeline_id, 881 research_id=research_id, 882 _request_auth=_request_auth, 883 _content_type=_content_type, 884 _headers=_headers, 885 _host_index=_host_index 886 ) 887 888 _response_types_map: Dict[str, Optional[str]] = { 889 '200': "GetDeepResearchResponse", 890 '400': "GetWorkspaces400Response", 891 '401': "GetWorkspaces400Response", 892 '403': "GetWorkspaces400Response", 893 '404': "GetWorkspaces400Response", 894 '500': "GetWorkspaces400Response", 895 } 896 response_data = self.api_client.call_api( 897 *_param, 898 _request_timeout=_request_timeout 899 ) 900 return response_data.response
Get deep research result
Get deep research result
Parameters
- organization_id: (required)
- pipeline_id: (required)
- research_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_pipeline( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.get_pipeline_response.GetPipelineResponse:
973 @validate_call 974 def get_pipeline( 975 self, 976 organization_id: StrictStr, 977 pipeline_id: StrictStr, 978 _request_timeout: Union[ 979 None, 980 Annotated[StrictFloat, Field(gt=0)], 981 Tuple[ 982 Annotated[StrictFloat, Field(gt=0)], 983 Annotated[StrictFloat, Field(gt=0)] 984 ] 985 ] = None, 986 _request_auth: Optional[Dict[StrictStr, Any]] = None, 987 _content_type: Optional[StrictStr] = None, 988 _headers: Optional[Dict[StrictStr, Any]] = None, 989 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 990 ) -> GetPipelineResponse: 991 """Get a pipeline 992 993 Get a pipeline 994 995 :param organization_id: (required) 996 :type organization_id: str 997 :param pipeline_id: (required) 998 :type pipeline_id: str 999 :param _request_timeout: timeout setting for this request. If one 1000 number provided, it will be total request 1001 timeout. It can also be a pair (tuple) of 1002 (connection, read) timeouts. 1003 :type _request_timeout: int, tuple(int, int), optional 1004 :param _request_auth: set to override the auth_settings for an a single 1005 request; this effectively ignores the 1006 authentication in the spec for a single request. 1007 :type _request_auth: dict, optional 1008 :param _content_type: force content-type for the request. 1009 :type _content_type: str, Optional 1010 :param _headers: set to override the headers for a single 1011 request; this effectively ignores the headers 1012 in the spec for a single request. 1013 :type _headers: dict, optional 1014 :param _host_index: set to override the host_index for a single 1015 request; this effectively ignores the host_index 1016 in the spec for a single request. 1017 :type _host_index: int, optional 1018 :return: Returns the result object. 1019 """ # noqa: E501 1020 1021 _param = self._get_pipeline_serialize( 1022 organization_id=organization_id, 1023 pipeline_id=pipeline_id, 1024 _request_auth=_request_auth, 1025 _content_type=_content_type, 1026 _headers=_headers, 1027 _host_index=_host_index 1028 ) 1029 1030 _response_types_map: Dict[str, Optional[str]] = { 1031 '200': "GetPipelineResponse", 1032 '400': "GetWorkspaces400Response", 1033 '401': "GetWorkspaces400Response", 1034 '403': "GetWorkspaces400Response", 1035 '404': "GetWorkspaces400Response", 1036 '500': "GetWorkspaces400Response", 1037 } 1038 response_data = self.api_client.call_api( 1039 *_param, 1040 _request_timeout=_request_timeout 1041 ) 1042 response_data.read() 1043 return self.api_client.response_deserialize( 1044 response_data=response_data, 1045 response_types_map=_response_types_map, 1046 ).data
Get a pipeline
Get a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_pipeline_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[GetPipelineResponse]:
1049 @validate_call 1050 def get_pipeline_with_http_info( 1051 self, 1052 organization_id: StrictStr, 1053 pipeline_id: StrictStr, 1054 _request_timeout: Union[ 1055 None, 1056 Annotated[StrictFloat, Field(gt=0)], 1057 Tuple[ 1058 Annotated[StrictFloat, Field(gt=0)], 1059 Annotated[StrictFloat, Field(gt=0)] 1060 ] 1061 ] = None, 1062 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1063 _content_type: Optional[StrictStr] = None, 1064 _headers: Optional[Dict[StrictStr, Any]] = None, 1065 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1066 ) -> ApiResponse[GetPipelineResponse]: 1067 """Get a pipeline 1068 1069 Get a pipeline 1070 1071 :param organization_id: (required) 1072 :type organization_id: str 1073 :param pipeline_id: (required) 1074 :type pipeline_id: str 1075 :param _request_timeout: timeout setting for this request. If one 1076 number provided, it will be total request 1077 timeout. It can also be a pair (tuple) of 1078 (connection, read) timeouts. 1079 :type _request_timeout: int, tuple(int, int), optional 1080 :param _request_auth: set to override the auth_settings for an a single 1081 request; this effectively ignores the 1082 authentication in the spec for a single request. 1083 :type _request_auth: dict, optional 1084 :param _content_type: force content-type for the request. 1085 :type _content_type: str, Optional 1086 :param _headers: set to override the headers for a single 1087 request; this effectively ignores the headers 1088 in the spec for a single request. 1089 :type _headers: dict, optional 1090 :param _host_index: set to override the host_index for a single 1091 request; this effectively ignores the host_index 1092 in the spec for a single request. 1093 :type _host_index: int, optional 1094 :return: Returns the result object. 1095 """ # noqa: E501 1096 1097 _param = self._get_pipeline_serialize( 1098 organization_id=organization_id, 1099 pipeline_id=pipeline_id, 1100 _request_auth=_request_auth, 1101 _content_type=_content_type, 1102 _headers=_headers, 1103 _host_index=_host_index 1104 ) 1105 1106 _response_types_map: Dict[str, Optional[str]] = { 1107 '200': "GetPipelineResponse", 1108 '400': "GetWorkspaces400Response", 1109 '401': "GetWorkspaces400Response", 1110 '403': "GetWorkspaces400Response", 1111 '404': "GetWorkspaces400Response", 1112 '500': "GetWorkspaces400Response", 1113 } 1114 response_data = self.api_client.call_api( 1115 *_param, 1116 _request_timeout=_request_timeout 1117 ) 1118 response_data.read() 1119 return self.api_client.response_deserialize( 1120 response_data=response_data, 1121 response_types_map=_response_types_map, 1122 )
Get a pipeline
Get a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_pipeline_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse:
1125 @validate_call 1126 def get_pipeline_without_preload_content( 1127 self, 1128 organization_id: StrictStr, 1129 pipeline_id: StrictStr, 1130 _request_timeout: Union[ 1131 None, 1132 Annotated[StrictFloat, Field(gt=0)], 1133 Tuple[ 1134 Annotated[StrictFloat, Field(gt=0)], 1135 Annotated[StrictFloat, Field(gt=0)] 1136 ] 1137 ] = None, 1138 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1139 _content_type: Optional[StrictStr] = None, 1140 _headers: Optional[Dict[StrictStr, Any]] = None, 1141 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1142 ) -> RESTResponseType: 1143 """Get a pipeline 1144 1145 Get a pipeline 1146 1147 :param organization_id: (required) 1148 :type organization_id: str 1149 :param pipeline_id: (required) 1150 :type pipeline_id: str 1151 :param _request_timeout: timeout setting for this request. If one 1152 number provided, it will be total request 1153 timeout. It can also be a pair (tuple) of 1154 (connection, read) timeouts. 1155 :type _request_timeout: int, tuple(int, int), optional 1156 :param _request_auth: set to override the auth_settings for an a single 1157 request; this effectively ignores the 1158 authentication in the spec for a single request. 1159 :type _request_auth: dict, optional 1160 :param _content_type: force content-type for the request. 1161 :type _content_type: str, Optional 1162 :param _headers: set to override the headers for a single 1163 request; this effectively ignores the headers 1164 in the spec for a single request. 1165 :type _headers: dict, optional 1166 :param _host_index: set to override the host_index for a single 1167 request; this effectively ignores the host_index 1168 in the spec for a single request. 1169 :type _host_index: int, optional 1170 :return: Returns the result object. 1171 """ # noqa: E501 1172 1173 _param = self._get_pipeline_serialize( 1174 organization_id=organization_id, 1175 pipeline_id=pipeline_id, 1176 _request_auth=_request_auth, 1177 _content_type=_content_type, 1178 _headers=_headers, 1179 _host_index=_host_index 1180 ) 1181 1182 _response_types_map: Dict[str, Optional[str]] = { 1183 '200': "GetPipelineResponse", 1184 '400': "GetWorkspaces400Response", 1185 '401': "GetWorkspaces400Response", 1186 '403': "GetWorkspaces400Response", 1187 '404': "GetWorkspaces400Response", 1188 '500': "GetWorkspaces400Response", 1189 } 1190 response_data = self.api_client.call_api( 1191 *_param, 1192 _request_timeout=_request_timeout 1193 ) 1194 return response_data.response
Get a pipeline
Get a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_pipeline_events( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], next_token: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.get_pipeline_events_response.GetPipelineEventsResponse:
1264 @validate_call 1265 def get_pipeline_events( 1266 self, 1267 organization_id: StrictStr, 1268 pipeline_id: StrictStr, 1269 next_token: Optional[StrictStr] = None, 1270 _request_timeout: Union[ 1271 None, 1272 Annotated[StrictFloat, Field(gt=0)], 1273 Tuple[ 1274 Annotated[StrictFloat, Field(gt=0)], 1275 Annotated[StrictFloat, Field(gt=0)] 1276 ] 1277 ] = None, 1278 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1279 _content_type: Optional[StrictStr] = None, 1280 _headers: Optional[Dict[StrictStr, Any]] = None, 1281 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1282 ) -> GetPipelineEventsResponse: 1283 """Get pipeline events 1284 1285 Get pipeline events 1286 1287 :param organization_id: (required) 1288 :type organization_id: str 1289 :param pipeline_id: (required) 1290 :type pipeline_id: str 1291 :param next_token: 1292 :type next_token: str 1293 :param _request_timeout: timeout setting for this request. If one 1294 number provided, it will be total request 1295 timeout. It can also be a pair (tuple) of 1296 (connection, read) timeouts. 1297 :type _request_timeout: int, tuple(int, int), optional 1298 :param _request_auth: set to override the auth_settings for an a single 1299 request; this effectively ignores the 1300 authentication in the spec for a single request. 1301 :type _request_auth: dict, optional 1302 :param _content_type: force content-type for the request. 1303 :type _content_type: str, Optional 1304 :param _headers: set to override the headers for a single 1305 request; this effectively ignores the headers 1306 in the spec for a single request. 1307 :type _headers: dict, optional 1308 :param _host_index: set to override the host_index for a single 1309 request; this effectively ignores the host_index 1310 in the spec for a single request. 1311 :type _host_index: int, optional 1312 :return: Returns the result object. 1313 """ # noqa: E501 1314 1315 _param = self._get_pipeline_events_serialize( 1316 organization_id=organization_id, 1317 pipeline_id=pipeline_id, 1318 next_token=next_token, 1319 _request_auth=_request_auth, 1320 _content_type=_content_type, 1321 _headers=_headers, 1322 _host_index=_host_index 1323 ) 1324 1325 _response_types_map: Dict[str, Optional[str]] = { 1326 '200': "GetPipelineEventsResponse", 1327 '400': "GetWorkspaces400Response", 1328 '401': "GetWorkspaces400Response", 1329 '403': "GetWorkspaces400Response", 1330 '404': "GetWorkspaces400Response", 1331 '500': "GetWorkspaces400Response", 1332 } 1333 response_data = self.api_client.call_api( 1334 *_param, 1335 _request_timeout=_request_timeout 1336 ) 1337 response_data.read() 1338 return self.api_client.response_deserialize( 1339 response_data=response_data, 1340 response_types_map=_response_types_map, 1341 ).data
Get pipeline events
Get pipeline events
Parameters
- organization_id: (required)
- pipeline_id: (required)
- next_token:
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_pipeline_events_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], next_token: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[GetPipelineEventsResponse]:
1344 @validate_call 1345 def get_pipeline_events_with_http_info( 1346 self, 1347 organization_id: StrictStr, 1348 pipeline_id: StrictStr, 1349 next_token: Optional[StrictStr] = None, 1350 _request_timeout: Union[ 1351 None, 1352 Annotated[StrictFloat, Field(gt=0)], 1353 Tuple[ 1354 Annotated[StrictFloat, Field(gt=0)], 1355 Annotated[StrictFloat, Field(gt=0)] 1356 ] 1357 ] = None, 1358 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1359 _content_type: Optional[StrictStr] = None, 1360 _headers: Optional[Dict[StrictStr, Any]] = None, 1361 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1362 ) -> ApiResponse[GetPipelineEventsResponse]: 1363 """Get pipeline events 1364 1365 Get pipeline events 1366 1367 :param organization_id: (required) 1368 :type organization_id: str 1369 :param pipeline_id: (required) 1370 :type pipeline_id: str 1371 :param next_token: 1372 :type next_token: str 1373 :param _request_timeout: timeout setting for this request. If one 1374 number provided, it will be total request 1375 timeout. It can also be a pair (tuple) of 1376 (connection, read) timeouts. 1377 :type _request_timeout: int, tuple(int, int), optional 1378 :param _request_auth: set to override the auth_settings for an a single 1379 request; this effectively ignores the 1380 authentication in the spec for a single request. 1381 :type _request_auth: dict, optional 1382 :param _content_type: force content-type for the request. 1383 :type _content_type: str, Optional 1384 :param _headers: set to override the headers for a single 1385 request; this effectively ignores the headers 1386 in the spec for a single request. 1387 :type _headers: dict, optional 1388 :param _host_index: set to override the host_index for a single 1389 request; this effectively ignores the host_index 1390 in the spec for a single request. 1391 :type _host_index: int, optional 1392 :return: Returns the result object. 1393 """ # noqa: E501 1394 1395 _param = self._get_pipeline_events_serialize( 1396 organization_id=organization_id, 1397 pipeline_id=pipeline_id, 1398 next_token=next_token, 1399 _request_auth=_request_auth, 1400 _content_type=_content_type, 1401 _headers=_headers, 1402 _host_index=_host_index 1403 ) 1404 1405 _response_types_map: Dict[str, Optional[str]] = { 1406 '200': "GetPipelineEventsResponse", 1407 '400': "GetWorkspaces400Response", 1408 '401': "GetWorkspaces400Response", 1409 '403': "GetWorkspaces400Response", 1410 '404': "GetWorkspaces400Response", 1411 '500': "GetWorkspaces400Response", 1412 } 1413 response_data = self.api_client.call_api( 1414 *_param, 1415 _request_timeout=_request_timeout 1416 ) 1417 response_data.read() 1418 return self.api_client.response_deserialize( 1419 response_data=response_data, 1420 response_types_map=_response_types_map, 1421 )
Get pipeline events
Get pipeline events
Parameters
- organization_id: (required)
- pipeline_id: (required)
- next_token:
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_pipeline_events_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], next_token: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse:
1424 @validate_call 1425 def get_pipeline_events_without_preload_content( 1426 self, 1427 organization_id: StrictStr, 1428 pipeline_id: StrictStr, 1429 next_token: Optional[StrictStr] = None, 1430 _request_timeout: Union[ 1431 None, 1432 Annotated[StrictFloat, Field(gt=0)], 1433 Tuple[ 1434 Annotated[StrictFloat, Field(gt=0)], 1435 Annotated[StrictFloat, Field(gt=0)] 1436 ] 1437 ] = None, 1438 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1439 _content_type: Optional[StrictStr] = None, 1440 _headers: Optional[Dict[StrictStr, Any]] = None, 1441 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1442 ) -> RESTResponseType: 1443 """Get pipeline events 1444 1445 Get pipeline events 1446 1447 :param organization_id: (required) 1448 :type organization_id: str 1449 :param pipeline_id: (required) 1450 :type pipeline_id: str 1451 :param next_token: 1452 :type next_token: str 1453 :param _request_timeout: timeout setting for this request. If one 1454 number provided, it will be total request 1455 timeout. It can also be a pair (tuple) of 1456 (connection, read) timeouts. 1457 :type _request_timeout: int, tuple(int, int), optional 1458 :param _request_auth: set to override the auth_settings for an a single 1459 request; this effectively ignores the 1460 authentication in the spec for a single request. 1461 :type _request_auth: dict, optional 1462 :param _content_type: force content-type for the request. 1463 :type _content_type: str, Optional 1464 :param _headers: set to override the headers for a single 1465 request; this effectively ignores the headers 1466 in the spec for a single request. 1467 :type _headers: dict, optional 1468 :param _host_index: set to override the host_index for a single 1469 request; this effectively ignores the host_index 1470 in the spec for a single request. 1471 :type _host_index: int, optional 1472 :return: Returns the result object. 1473 """ # noqa: E501 1474 1475 _param = self._get_pipeline_events_serialize( 1476 organization_id=organization_id, 1477 pipeline_id=pipeline_id, 1478 next_token=next_token, 1479 _request_auth=_request_auth, 1480 _content_type=_content_type, 1481 _headers=_headers, 1482 _host_index=_host_index 1483 ) 1484 1485 _response_types_map: Dict[str, Optional[str]] = { 1486 '200': "GetPipelineEventsResponse", 1487 '400': "GetWorkspaces400Response", 1488 '401': "GetWorkspaces400Response", 1489 '403': "GetWorkspaces400Response", 1490 '404': "GetWorkspaces400Response", 1491 '500': "GetWorkspaces400Response", 1492 } 1493 response_data = self.api_client.call_api( 1494 *_param, 1495 _request_timeout=_request_timeout 1496 ) 1497 return response_data.response
Get pipeline events
Get pipeline events
Parameters
- organization_id: (required)
- pipeline_id: (required)
- next_token:
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_pipeline_metrics( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.get_pipeline_metrics_response.GetPipelineMetricsResponse:
1572 @validate_call 1573 def get_pipeline_metrics( 1574 self, 1575 organization_id: StrictStr, 1576 pipeline_id: StrictStr, 1577 _request_timeout: Union[ 1578 None, 1579 Annotated[StrictFloat, Field(gt=0)], 1580 Tuple[ 1581 Annotated[StrictFloat, Field(gt=0)], 1582 Annotated[StrictFloat, Field(gt=0)] 1583 ] 1584 ] = None, 1585 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1586 _content_type: Optional[StrictStr] = None, 1587 _headers: Optional[Dict[StrictStr, Any]] = None, 1588 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1589 ) -> GetPipelineMetricsResponse: 1590 """Get pipeline metrics 1591 1592 Get pipeline metrics 1593 1594 :param organization_id: (required) 1595 :type organization_id: str 1596 :param pipeline_id: (required) 1597 :type pipeline_id: str 1598 :param _request_timeout: timeout setting for this request. If one 1599 number provided, it will be total request 1600 timeout. It can also be a pair (tuple) of 1601 (connection, read) timeouts. 1602 :type _request_timeout: int, tuple(int, int), optional 1603 :param _request_auth: set to override the auth_settings for an a single 1604 request; this effectively ignores the 1605 authentication in the spec for a single request. 1606 :type _request_auth: dict, optional 1607 :param _content_type: force content-type for the request. 1608 :type _content_type: str, Optional 1609 :param _headers: set to override the headers for a single 1610 request; this effectively ignores the headers 1611 in the spec for a single request. 1612 :type _headers: dict, optional 1613 :param _host_index: set to override the host_index for a single 1614 request; this effectively ignores the host_index 1615 in the spec for a single request. 1616 :type _host_index: int, optional 1617 :return: Returns the result object. 1618 """ # noqa: E501 1619 1620 _param = self._get_pipeline_metrics_serialize( 1621 organization_id=organization_id, 1622 pipeline_id=pipeline_id, 1623 _request_auth=_request_auth, 1624 _content_type=_content_type, 1625 _headers=_headers, 1626 _host_index=_host_index 1627 ) 1628 1629 _response_types_map: Dict[str, Optional[str]] = { 1630 '200': "GetPipelineMetricsResponse", 1631 '400': "GetWorkspaces400Response", 1632 '401': "GetWorkspaces400Response", 1633 '403': "GetWorkspaces400Response", 1634 '404': "GetWorkspaces400Response", 1635 '500': "GetWorkspaces400Response", 1636 } 1637 response_data = self.api_client.call_api( 1638 *_param, 1639 _request_timeout=_request_timeout 1640 ) 1641 response_data.read() 1642 return self.api_client.response_deserialize( 1643 response_data=response_data, 1644 response_types_map=_response_types_map, 1645 ).data
Get pipeline metrics
Get pipeline metrics
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_pipeline_metrics_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[GetPipelineMetricsResponse]:
1648 @validate_call 1649 def get_pipeline_metrics_with_http_info( 1650 self, 1651 organization_id: StrictStr, 1652 pipeline_id: StrictStr, 1653 _request_timeout: Union[ 1654 None, 1655 Annotated[StrictFloat, Field(gt=0)], 1656 Tuple[ 1657 Annotated[StrictFloat, Field(gt=0)], 1658 Annotated[StrictFloat, Field(gt=0)] 1659 ] 1660 ] = None, 1661 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1662 _content_type: Optional[StrictStr] = None, 1663 _headers: Optional[Dict[StrictStr, Any]] = None, 1664 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1665 ) -> ApiResponse[GetPipelineMetricsResponse]: 1666 """Get pipeline metrics 1667 1668 Get pipeline metrics 1669 1670 :param organization_id: (required) 1671 :type organization_id: str 1672 :param pipeline_id: (required) 1673 :type pipeline_id: str 1674 :param _request_timeout: timeout setting for this request. If one 1675 number provided, it will be total request 1676 timeout. It can also be a pair (tuple) of 1677 (connection, read) timeouts. 1678 :type _request_timeout: int, tuple(int, int), optional 1679 :param _request_auth: set to override the auth_settings for an a single 1680 request; this effectively ignores the 1681 authentication in the spec for a single request. 1682 :type _request_auth: dict, optional 1683 :param _content_type: force content-type for the request. 1684 :type _content_type: str, Optional 1685 :param _headers: set to override the headers for a single 1686 request; this effectively ignores the headers 1687 in the spec for a single request. 1688 :type _headers: dict, optional 1689 :param _host_index: set to override the host_index for a single 1690 request; this effectively ignores the host_index 1691 in the spec for a single request. 1692 :type _host_index: int, optional 1693 :return: Returns the result object. 1694 """ # noqa: E501 1695 1696 _param = self._get_pipeline_metrics_serialize( 1697 organization_id=organization_id, 1698 pipeline_id=pipeline_id, 1699 _request_auth=_request_auth, 1700 _content_type=_content_type, 1701 _headers=_headers, 1702 _host_index=_host_index 1703 ) 1704 1705 _response_types_map: Dict[str, Optional[str]] = { 1706 '200': "GetPipelineMetricsResponse", 1707 '400': "GetWorkspaces400Response", 1708 '401': "GetWorkspaces400Response", 1709 '403': "GetWorkspaces400Response", 1710 '404': "GetWorkspaces400Response", 1711 '500': "GetWorkspaces400Response", 1712 } 1713 response_data = self.api_client.call_api( 1714 *_param, 1715 _request_timeout=_request_timeout 1716 ) 1717 response_data.read() 1718 return self.api_client.response_deserialize( 1719 response_data=response_data, 1720 response_types_map=_response_types_map, 1721 )
Get pipeline metrics
Get pipeline metrics
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_pipeline_metrics_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse:
1724 @validate_call 1725 def get_pipeline_metrics_without_preload_content( 1726 self, 1727 organization_id: StrictStr, 1728 pipeline_id: StrictStr, 1729 _request_timeout: Union[ 1730 None, 1731 Annotated[StrictFloat, Field(gt=0)], 1732 Tuple[ 1733 Annotated[StrictFloat, Field(gt=0)], 1734 Annotated[StrictFloat, Field(gt=0)] 1735 ] 1736 ] = None, 1737 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1738 _content_type: Optional[StrictStr] = None, 1739 _headers: Optional[Dict[StrictStr, Any]] = None, 1740 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1741 ) -> RESTResponseType: 1742 """Get pipeline metrics 1743 1744 Get pipeline metrics 1745 1746 :param organization_id: (required) 1747 :type organization_id: str 1748 :param pipeline_id: (required) 1749 :type pipeline_id: str 1750 :param _request_timeout: timeout setting for this request. If one 1751 number provided, it will be total request 1752 timeout. It can also be a pair (tuple) of 1753 (connection, read) timeouts. 1754 :type _request_timeout: int, tuple(int, int), optional 1755 :param _request_auth: set to override the auth_settings for an a single 1756 request; this effectively ignores the 1757 authentication in the spec for a single request. 1758 :type _request_auth: dict, optional 1759 :param _content_type: force content-type for the request. 1760 :type _content_type: str, Optional 1761 :param _headers: set to override the headers for a single 1762 request; this effectively ignores the headers 1763 in the spec for a single request. 1764 :type _headers: dict, optional 1765 :param _host_index: set to override the host_index for a single 1766 request; this effectively ignores the host_index 1767 in the spec for a single request. 1768 :type _host_index: int, optional 1769 :return: Returns the result object. 1770 """ # noqa: E501 1771 1772 _param = self._get_pipeline_metrics_serialize( 1773 organization_id=organization_id, 1774 pipeline_id=pipeline_id, 1775 _request_auth=_request_auth, 1776 _content_type=_content_type, 1777 _headers=_headers, 1778 _host_index=_host_index 1779 ) 1780 1781 _response_types_map: Dict[str, Optional[str]] = { 1782 '200': "GetPipelineMetricsResponse", 1783 '400': "GetWorkspaces400Response", 1784 '401': "GetWorkspaces400Response", 1785 '403': "GetWorkspaces400Response", 1786 '404': "GetWorkspaces400Response", 1787 '500': "GetWorkspaces400Response", 1788 } 1789 response_data = self.api_client.call_api( 1790 *_param, 1791 _request_timeout=_request_timeout 1792 ) 1793 return response_data.response
Get pipeline metrics
Get pipeline metrics
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_pipelines( self, organization_id: typing.Annotated[str, Strict(strict=True)], workspace_id: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.get_pipelines_response.GetPipelinesResponse:
1863 @validate_call 1864 def get_pipelines( 1865 self, 1866 organization_id: StrictStr, 1867 workspace_id: Optional[StrictStr] = None, 1868 _request_timeout: Union[ 1869 None, 1870 Annotated[StrictFloat, Field(gt=0)], 1871 Tuple[ 1872 Annotated[StrictFloat, Field(gt=0)], 1873 Annotated[StrictFloat, Field(gt=0)] 1874 ] 1875 ] = None, 1876 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1877 _content_type: Optional[StrictStr] = None, 1878 _headers: Optional[Dict[StrictStr, Any]] = None, 1879 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1880 ) -> GetPipelinesResponse: 1881 """Get all pipelines 1882 1883 Returns a list of all pipelines in the organization 1884 1885 :param organization_id: (required) 1886 :type organization_id: str 1887 :param workspace_id: 1888 :type workspace_id: str 1889 :param _request_timeout: timeout setting for this request. If one 1890 number provided, it will be total request 1891 timeout. It can also be a pair (tuple) of 1892 (connection, read) timeouts. 1893 :type _request_timeout: int, tuple(int, int), optional 1894 :param _request_auth: set to override the auth_settings for an a single 1895 request; this effectively ignores the 1896 authentication in the spec for a single request. 1897 :type _request_auth: dict, optional 1898 :param _content_type: force content-type for the request. 1899 :type _content_type: str, Optional 1900 :param _headers: set to override the headers for a single 1901 request; this effectively ignores the headers 1902 in the spec for a single request. 1903 :type _headers: dict, optional 1904 :param _host_index: set to override the host_index for a single 1905 request; this effectively ignores the host_index 1906 in the spec for a single request. 1907 :type _host_index: int, optional 1908 :return: Returns the result object. 1909 """ # noqa: E501 1910 1911 _param = self._get_pipelines_serialize( 1912 organization_id=organization_id, 1913 workspace_id=workspace_id, 1914 _request_auth=_request_auth, 1915 _content_type=_content_type, 1916 _headers=_headers, 1917 _host_index=_host_index 1918 ) 1919 1920 _response_types_map: Dict[str, Optional[str]] = { 1921 '200': "GetPipelinesResponse", 1922 '400': "GetWorkspaces400Response", 1923 '401': "GetWorkspaces400Response", 1924 '403': "GetWorkspaces400Response", 1925 '404': "GetWorkspaces400Response", 1926 '500': "GetWorkspaces400Response", 1927 } 1928 response_data = self.api_client.call_api( 1929 *_param, 1930 _request_timeout=_request_timeout 1931 ) 1932 response_data.read() 1933 return self.api_client.response_deserialize( 1934 response_data=response_data, 1935 response_types_map=_response_types_map, 1936 ).data
Get all pipelines
Returns a list of all pipelines in the organization
Parameters
- organization_id: (required)
- workspace_id:
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_pipelines_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], workspace_id: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[GetPipelinesResponse]:
1939 @validate_call 1940 def get_pipelines_with_http_info( 1941 self, 1942 organization_id: StrictStr, 1943 workspace_id: Optional[StrictStr] = None, 1944 _request_timeout: Union[ 1945 None, 1946 Annotated[StrictFloat, Field(gt=0)], 1947 Tuple[ 1948 Annotated[StrictFloat, Field(gt=0)], 1949 Annotated[StrictFloat, Field(gt=0)] 1950 ] 1951 ] = None, 1952 _request_auth: Optional[Dict[StrictStr, Any]] = None, 1953 _content_type: Optional[StrictStr] = None, 1954 _headers: Optional[Dict[StrictStr, Any]] = None, 1955 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 1956 ) -> ApiResponse[GetPipelinesResponse]: 1957 """Get all pipelines 1958 1959 Returns a list of all pipelines in the organization 1960 1961 :param organization_id: (required) 1962 :type organization_id: str 1963 :param workspace_id: 1964 :type workspace_id: str 1965 :param _request_timeout: timeout setting for this request. If one 1966 number provided, it will be total request 1967 timeout. It can also be a pair (tuple) of 1968 (connection, read) timeouts. 1969 :type _request_timeout: int, tuple(int, int), optional 1970 :param _request_auth: set to override the auth_settings for an a single 1971 request; this effectively ignores the 1972 authentication in the spec for a single request. 1973 :type _request_auth: dict, optional 1974 :param _content_type: force content-type for the request. 1975 :type _content_type: str, Optional 1976 :param _headers: set to override the headers for a single 1977 request; this effectively ignores the headers 1978 in the spec for a single request. 1979 :type _headers: dict, optional 1980 :param _host_index: set to override the host_index for a single 1981 request; this effectively ignores the host_index 1982 in the spec for a single request. 1983 :type _host_index: int, optional 1984 :return: Returns the result object. 1985 """ # noqa: E501 1986 1987 _param = self._get_pipelines_serialize( 1988 organization_id=organization_id, 1989 workspace_id=workspace_id, 1990 _request_auth=_request_auth, 1991 _content_type=_content_type, 1992 _headers=_headers, 1993 _host_index=_host_index 1994 ) 1995 1996 _response_types_map: Dict[str, Optional[str]] = { 1997 '200': "GetPipelinesResponse", 1998 '400': "GetWorkspaces400Response", 1999 '401': "GetWorkspaces400Response", 2000 '403': "GetWorkspaces400Response", 2001 '404': "GetWorkspaces400Response", 2002 '500': "GetWorkspaces400Response", 2003 } 2004 response_data = self.api_client.call_api( 2005 *_param, 2006 _request_timeout=_request_timeout 2007 ) 2008 response_data.read() 2009 return self.api_client.response_deserialize( 2010 response_data=response_data, 2011 response_types_map=_response_types_map, 2012 )
Get all pipelines
Returns a list of all pipelines in the organization
Parameters
- organization_id: (required)
- workspace_id:
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
get_pipelines_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], workspace_id: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse:
2015 @validate_call 2016 def get_pipelines_without_preload_content( 2017 self, 2018 organization_id: StrictStr, 2019 workspace_id: Optional[StrictStr] = None, 2020 _request_timeout: Union[ 2021 None, 2022 Annotated[StrictFloat, Field(gt=0)], 2023 Tuple[ 2024 Annotated[StrictFloat, Field(gt=0)], 2025 Annotated[StrictFloat, Field(gt=0)] 2026 ] 2027 ] = None, 2028 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2029 _content_type: Optional[StrictStr] = None, 2030 _headers: Optional[Dict[StrictStr, Any]] = None, 2031 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2032 ) -> RESTResponseType: 2033 """Get all pipelines 2034 2035 Returns a list of all pipelines in the organization 2036 2037 :param organization_id: (required) 2038 :type organization_id: str 2039 :param workspace_id: 2040 :type workspace_id: str 2041 :param _request_timeout: timeout setting for this request. If one 2042 number provided, it will be total request 2043 timeout. It can also be a pair (tuple) of 2044 (connection, read) timeouts. 2045 :type _request_timeout: int, tuple(int, int), optional 2046 :param _request_auth: set to override the auth_settings for an a single 2047 request; this effectively ignores the 2048 authentication in the spec for a single request. 2049 :type _request_auth: dict, optional 2050 :param _content_type: force content-type for the request. 2051 :type _content_type: str, Optional 2052 :param _headers: set to override the headers for a single 2053 request; this effectively ignores the headers 2054 in the spec for a single request. 2055 :type _headers: dict, optional 2056 :param _host_index: set to override the host_index for a single 2057 request; this effectively ignores the host_index 2058 in the spec for a single request. 2059 :type _host_index: int, optional 2060 :return: Returns the result object. 2061 """ # noqa: E501 2062 2063 _param = self._get_pipelines_serialize( 2064 organization_id=organization_id, 2065 workspace_id=workspace_id, 2066 _request_auth=_request_auth, 2067 _content_type=_content_type, 2068 _headers=_headers, 2069 _host_index=_host_index 2070 ) 2071 2072 _response_types_map: Dict[str, Optional[str]] = { 2073 '200': "GetPipelinesResponse", 2074 '400': "GetWorkspaces400Response", 2075 '401': "GetWorkspaces400Response", 2076 '403': "GetWorkspaces400Response", 2077 '404': "GetWorkspaces400Response", 2078 '500': "GetWorkspaces400Response", 2079 } 2080 response_data = self.api_client.call_api( 2081 *_param, 2082 _request_timeout=_request_timeout 2083 ) 2084 return response_data.response
Get all pipelines
Returns a list of all pipelines in the organization
Parameters
- organization_id: (required)
- workspace_id:
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
retrieve_documents( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], retrieve_documents_request: vectorize_client.models.retrieve_documents_request.RetrieveDocumentsRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.retrieve_documents_response.RetrieveDocumentsResponse:
2156 @validate_call 2157 def retrieve_documents( 2158 self, 2159 organization_id: StrictStr, 2160 pipeline_id: StrictStr, 2161 retrieve_documents_request: RetrieveDocumentsRequest, 2162 _request_timeout: Union[ 2163 None, 2164 Annotated[StrictFloat, Field(gt=0)], 2165 Tuple[ 2166 Annotated[StrictFloat, Field(gt=0)], 2167 Annotated[StrictFloat, Field(gt=0)] 2168 ] 2169 ] = None, 2170 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2171 _content_type: Optional[StrictStr] = None, 2172 _headers: Optional[Dict[StrictStr, Any]] = None, 2173 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2174 ) -> RetrieveDocumentsResponse: 2175 """Retrieve documents from a pipeline 2176 2177 Retrieve documents from a pipeline 2178 2179 :param organization_id: (required) 2180 :type organization_id: str 2181 :param pipeline_id: (required) 2182 :type pipeline_id: str 2183 :param retrieve_documents_request: (required) 2184 :type retrieve_documents_request: RetrieveDocumentsRequest 2185 :param _request_timeout: timeout setting for this request. If one 2186 number provided, it will be total request 2187 timeout. It can also be a pair (tuple) of 2188 (connection, read) timeouts. 2189 :type _request_timeout: int, tuple(int, int), optional 2190 :param _request_auth: set to override the auth_settings for an a single 2191 request; this effectively ignores the 2192 authentication in the spec for a single request. 2193 :type _request_auth: dict, optional 2194 :param _content_type: force content-type for the request. 2195 :type _content_type: str, Optional 2196 :param _headers: set to override the headers for a single 2197 request; this effectively ignores the headers 2198 in the spec for a single request. 2199 :type _headers: dict, optional 2200 :param _host_index: set to override the host_index for a single 2201 request; this effectively ignores the host_index 2202 in the spec for a single request. 2203 :type _host_index: int, optional 2204 :return: Returns the result object. 2205 """ # noqa: E501 2206 2207 _param = self._retrieve_documents_serialize( 2208 organization_id=organization_id, 2209 pipeline_id=pipeline_id, 2210 retrieve_documents_request=retrieve_documents_request, 2211 _request_auth=_request_auth, 2212 _content_type=_content_type, 2213 _headers=_headers, 2214 _host_index=_host_index 2215 ) 2216 2217 _response_types_map: Dict[str, Optional[str]] = { 2218 '200': "RetrieveDocumentsResponse", 2219 '400': "GetWorkspaces400Response", 2220 '401': "GetWorkspaces400Response", 2221 '403': "GetWorkspaces400Response", 2222 '404': "GetWorkspaces400Response", 2223 '500': "GetWorkspaces400Response", 2224 } 2225 response_data = self.api_client.call_api( 2226 *_param, 2227 _request_timeout=_request_timeout 2228 ) 2229 response_data.read() 2230 return self.api_client.response_deserialize( 2231 response_data=response_data, 2232 response_types_map=_response_types_map, 2233 ).data
Retrieve documents from a pipeline
Retrieve documents from a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- retrieve_documents_request: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
retrieve_documents_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], retrieve_documents_request: vectorize_client.models.retrieve_documents_request.RetrieveDocumentsRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[RetrieveDocumentsResponse]:
2236 @validate_call 2237 def retrieve_documents_with_http_info( 2238 self, 2239 organization_id: StrictStr, 2240 pipeline_id: StrictStr, 2241 retrieve_documents_request: RetrieveDocumentsRequest, 2242 _request_timeout: Union[ 2243 None, 2244 Annotated[StrictFloat, Field(gt=0)], 2245 Tuple[ 2246 Annotated[StrictFloat, Field(gt=0)], 2247 Annotated[StrictFloat, Field(gt=0)] 2248 ] 2249 ] = None, 2250 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2251 _content_type: Optional[StrictStr] = None, 2252 _headers: Optional[Dict[StrictStr, Any]] = None, 2253 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2254 ) -> ApiResponse[RetrieveDocumentsResponse]: 2255 """Retrieve documents from a pipeline 2256 2257 Retrieve documents from a pipeline 2258 2259 :param organization_id: (required) 2260 :type organization_id: str 2261 :param pipeline_id: (required) 2262 :type pipeline_id: str 2263 :param retrieve_documents_request: (required) 2264 :type retrieve_documents_request: RetrieveDocumentsRequest 2265 :param _request_timeout: timeout setting for this request. If one 2266 number provided, it will be total request 2267 timeout. It can also be a pair (tuple) of 2268 (connection, read) timeouts. 2269 :type _request_timeout: int, tuple(int, int), optional 2270 :param _request_auth: set to override the auth_settings for an a single 2271 request; this effectively ignores the 2272 authentication in the spec for a single request. 2273 :type _request_auth: dict, optional 2274 :param _content_type: force content-type for the request. 2275 :type _content_type: str, Optional 2276 :param _headers: set to override the headers for a single 2277 request; this effectively ignores the headers 2278 in the spec for a single request. 2279 :type _headers: dict, optional 2280 :param _host_index: set to override the host_index for a single 2281 request; this effectively ignores the host_index 2282 in the spec for a single request. 2283 :type _host_index: int, optional 2284 :return: Returns the result object. 2285 """ # noqa: E501 2286 2287 _param = self._retrieve_documents_serialize( 2288 organization_id=organization_id, 2289 pipeline_id=pipeline_id, 2290 retrieve_documents_request=retrieve_documents_request, 2291 _request_auth=_request_auth, 2292 _content_type=_content_type, 2293 _headers=_headers, 2294 _host_index=_host_index 2295 ) 2296 2297 _response_types_map: Dict[str, Optional[str]] = { 2298 '200': "RetrieveDocumentsResponse", 2299 '400': "GetWorkspaces400Response", 2300 '401': "GetWorkspaces400Response", 2301 '403': "GetWorkspaces400Response", 2302 '404': "GetWorkspaces400Response", 2303 '500': "GetWorkspaces400Response", 2304 } 2305 response_data = self.api_client.call_api( 2306 *_param, 2307 _request_timeout=_request_timeout 2308 ) 2309 response_data.read() 2310 return self.api_client.response_deserialize( 2311 response_data=response_data, 2312 response_types_map=_response_types_map, 2313 )
Retrieve documents from a pipeline
Retrieve documents from a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- retrieve_documents_request: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
retrieve_documents_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], retrieve_documents_request: vectorize_client.models.retrieve_documents_request.RetrieveDocumentsRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse:
2316 @validate_call 2317 def retrieve_documents_without_preload_content( 2318 self, 2319 organization_id: StrictStr, 2320 pipeline_id: StrictStr, 2321 retrieve_documents_request: RetrieveDocumentsRequest, 2322 _request_timeout: Union[ 2323 None, 2324 Annotated[StrictFloat, Field(gt=0)], 2325 Tuple[ 2326 Annotated[StrictFloat, Field(gt=0)], 2327 Annotated[StrictFloat, Field(gt=0)] 2328 ] 2329 ] = None, 2330 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2331 _content_type: Optional[StrictStr] = None, 2332 _headers: Optional[Dict[StrictStr, Any]] = None, 2333 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2334 ) -> RESTResponseType: 2335 """Retrieve documents from a pipeline 2336 2337 Retrieve documents from a pipeline 2338 2339 :param organization_id: (required) 2340 :type organization_id: str 2341 :param pipeline_id: (required) 2342 :type pipeline_id: str 2343 :param retrieve_documents_request: (required) 2344 :type retrieve_documents_request: RetrieveDocumentsRequest 2345 :param _request_timeout: timeout setting for this request. If one 2346 number provided, it will be total request 2347 timeout. It can also be a pair (tuple) of 2348 (connection, read) timeouts. 2349 :type _request_timeout: int, tuple(int, int), optional 2350 :param _request_auth: set to override the auth_settings for an a single 2351 request; this effectively ignores the 2352 authentication in the spec for a single request. 2353 :type _request_auth: dict, optional 2354 :param _content_type: force content-type for the request. 2355 :type _content_type: str, Optional 2356 :param _headers: set to override the headers for a single 2357 request; this effectively ignores the headers 2358 in the spec for a single request. 2359 :type _headers: dict, optional 2360 :param _host_index: set to override the host_index for a single 2361 request; this effectively ignores the host_index 2362 in the spec for a single request. 2363 :type _host_index: int, optional 2364 :return: Returns the result object. 2365 """ # noqa: E501 2366 2367 _param = self._retrieve_documents_serialize( 2368 organization_id=organization_id, 2369 pipeline_id=pipeline_id, 2370 retrieve_documents_request=retrieve_documents_request, 2371 _request_auth=_request_auth, 2372 _content_type=_content_type, 2373 _headers=_headers, 2374 _host_index=_host_index 2375 ) 2376 2377 _response_types_map: Dict[str, Optional[str]] = { 2378 '200': "RetrieveDocumentsResponse", 2379 '400': "GetWorkspaces400Response", 2380 '401': "GetWorkspaces400Response", 2381 '403': "GetWorkspaces400Response", 2382 '404': "GetWorkspaces400Response", 2383 '500': "GetWorkspaces400Response", 2384 } 2385 response_data = self.api_client.call_api( 2386 *_param, 2387 _request_timeout=_request_timeout 2388 ) 2389 return response_data.response
Retrieve documents from a pipeline
Retrieve documents from a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- retrieve_documents_request: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
start_deep_research( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], start_deep_research_request: vectorize_client.models.start_deep_research_request.StartDeepResearchRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.start_deep_research_response.StartDeepResearchResponse:
2475 @validate_call 2476 def start_deep_research( 2477 self, 2478 organization_id: StrictStr, 2479 pipeline_id: StrictStr, 2480 start_deep_research_request: StartDeepResearchRequest, 2481 _request_timeout: Union[ 2482 None, 2483 Annotated[StrictFloat, Field(gt=0)], 2484 Tuple[ 2485 Annotated[StrictFloat, Field(gt=0)], 2486 Annotated[StrictFloat, Field(gt=0)] 2487 ] 2488 ] = None, 2489 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2490 _content_type: Optional[StrictStr] = None, 2491 _headers: Optional[Dict[StrictStr, Any]] = None, 2492 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2493 ) -> StartDeepResearchResponse: 2494 """Start a deep research 2495 2496 Start a deep research 2497 2498 :param organization_id: (required) 2499 :type organization_id: str 2500 :param pipeline_id: (required) 2501 :type pipeline_id: str 2502 :param start_deep_research_request: (required) 2503 :type start_deep_research_request: StartDeepResearchRequest 2504 :param _request_timeout: timeout setting for this request. If one 2505 number provided, it will be total request 2506 timeout. It can also be a pair (tuple) of 2507 (connection, read) timeouts. 2508 :type _request_timeout: int, tuple(int, int), optional 2509 :param _request_auth: set to override the auth_settings for an a single 2510 request; this effectively ignores the 2511 authentication in the spec for a single request. 2512 :type _request_auth: dict, optional 2513 :param _content_type: force content-type for the request. 2514 :type _content_type: str, Optional 2515 :param _headers: set to override the headers for a single 2516 request; this effectively ignores the headers 2517 in the spec for a single request. 2518 :type _headers: dict, optional 2519 :param _host_index: set to override the host_index for a single 2520 request; this effectively ignores the host_index 2521 in the spec for a single request. 2522 :type _host_index: int, optional 2523 :return: Returns the result object. 2524 """ # noqa: E501 2525 2526 _param = self._start_deep_research_serialize( 2527 organization_id=organization_id, 2528 pipeline_id=pipeline_id, 2529 start_deep_research_request=start_deep_research_request, 2530 _request_auth=_request_auth, 2531 _content_type=_content_type, 2532 _headers=_headers, 2533 _host_index=_host_index 2534 ) 2535 2536 _response_types_map: Dict[str, Optional[str]] = { 2537 '200': "StartDeepResearchResponse", 2538 '400': "GetWorkspaces400Response", 2539 '401': "GetWorkspaces400Response", 2540 '403': "GetWorkspaces400Response", 2541 '404': "GetWorkspaces400Response", 2542 '500': "GetWorkspaces400Response", 2543 } 2544 response_data = self.api_client.call_api( 2545 *_param, 2546 _request_timeout=_request_timeout 2547 ) 2548 response_data.read() 2549 return self.api_client.response_deserialize( 2550 response_data=response_data, 2551 response_types_map=_response_types_map, 2552 ).data
Start a deep research
Start a deep research
Parameters
- organization_id: (required)
- pipeline_id: (required)
- start_deep_research_request: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
start_deep_research_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], start_deep_research_request: vectorize_client.models.start_deep_research_request.StartDeepResearchRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[StartDeepResearchResponse]:
2555 @validate_call 2556 def start_deep_research_with_http_info( 2557 self, 2558 organization_id: StrictStr, 2559 pipeline_id: StrictStr, 2560 start_deep_research_request: StartDeepResearchRequest, 2561 _request_timeout: Union[ 2562 None, 2563 Annotated[StrictFloat, Field(gt=0)], 2564 Tuple[ 2565 Annotated[StrictFloat, Field(gt=0)], 2566 Annotated[StrictFloat, Field(gt=0)] 2567 ] 2568 ] = None, 2569 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2570 _content_type: Optional[StrictStr] = None, 2571 _headers: Optional[Dict[StrictStr, Any]] = None, 2572 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2573 ) -> ApiResponse[StartDeepResearchResponse]: 2574 """Start a deep research 2575 2576 Start a deep research 2577 2578 :param organization_id: (required) 2579 :type organization_id: str 2580 :param pipeline_id: (required) 2581 :type pipeline_id: str 2582 :param start_deep_research_request: (required) 2583 :type start_deep_research_request: StartDeepResearchRequest 2584 :param _request_timeout: timeout setting for this request. If one 2585 number provided, it will be total request 2586 timeout. It can also be a pair (tuple) of 2587 (connection, read) timeouts. 2588 :type _request_timeout: int, tuple(int, int), optional 2589 :param _request_auth: set to override the auth_settings for an a single 2590 request; this effectively ignores the 2591 authentication in the spec for a single request. 2592 :type _request_auth: dict, optional 2593 :param _content_type: force content-type for the request. 2594 :type _content_type: str, Optional 2595 :param _headers: set to override the headers for a single 2596 request; this effectively ignores the headers 2597 in the spec for a single request. 2598 :type _headers: dict, optional 2599 :param _host_index: set to override the host_index for a single 2600 request; this effectively ignores the host_index 2601 in the spec for a single request. 2602 :type _host_index: int, optional 2603 :return: Returns the result object. 2604 """ # noqa: E501 2605 2606 _param = self._start_deep_research_serialize( 2607 organization_id=organization_id, 2608 pipeline_id=pipeline_id, 2609 start_deep_research_request=start_deep_research_request, 2610 _request_auth=_request_auth, 2611 _content_type=_content_type, 2612 _headers=_headers, 2613 _host_index=_host_index 2614 ) 2615 2616 _response_types_map: Dict[str, Optional[str]] = { 2617 '200': "StartDeepResearchResponse", 2618 '400': "GetWorkspaces400Response", 2619 '401': "GetWorkspaces400Response", 2620 '403': "GetWorkspaces400Response", 2621 '404': "GetWorkspaces400Response", 2622 '500': "GetWorkspaces400Response", 2623 } 2624 response_data = self.api_client.call_api( 2625 *_param, 2626 _request_timeout=_request_timeout 2627 ) 2628 response_data.read() 2629 return self.api_client.response_deserialize( 2630 response_data=response_data, 2631 response_types_map=_response_types_map, 2632 )
Start a deep research
Start a deep research
Parameters
- organization_id: (required)
- pipeline_id: (required)
- start_deep_research_request: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
start_deep_research_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], start_deep_research_request: vectorize_client.models.start_deep_research_request.StartDeepResearchRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse:
2635 @validate_call 2636 def start_deep_research_without_preload_content( 2637 self, 2638 organization_id: StrictStr, 2639 pipeline_id: StrictStr, 2640 start_deep_research_request: StartDeepResearchRequest, 2641 _request_timeout: Union[ 2642 None, 2643 Annotated[StrictFloat, Field(gt=0)], 2644 Tuple[ 2645 Annotated[StrictFloat, Field(gt=0)], 2646 Annotated[StrictFloat, Field(gt=0)] 2647 ] 2648 ] = None, 2649 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2650 _content_type: Optional[StrictStr] = None, 2651 _headers: Optional[Dict[StrictStr, Any]] = None, 2652 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2653 ) -> RESTResponseType: 2654 """Start a deep research 2655 2656 Start a deep research 2657 2658 :param organization_id: (required) 2659 :type organization_id: str 2660 :param pipeline_id: (required) 2661 :type pipeline_id: str 2662 :param start_deep_research_request: (required) 2663 :type start_deep_research_request: StartDeepResearchRequest 2664 :param _request_timeout: timeout setting for this request. If one 2665 number provided, it will be total request 2666 timeout. It can also be a pair (tuple) of 2667 (connection, read) timeouts. 2668 :type _request_timeout: int, tuple(int, int), optional 2669 :param _request_auth: set to override the auth_settings for an a single 2670 request; this effectively ignores the 2671 authentication in the spec for a single request. 2672 :type _request_auth: dict, optional 2673 :param _content_type: force content-type for the request. 2674 :type _content_type: str, Optional 2675 :param _headers: set to override the headers for a single 2676 request; this effectively ignores the headers 2677 in the spec for a single request. 2678 :type _headers: dict, optional 2679 :param _host_index: set to override the host_index for a single 2680 request; this effectively ignores the host_index 2681 in the spec for a single request. 2682 :type _host_index: int, optional 2683 :return: Returns the result object. 2684 """ # noqa: E501 2685 2686 _param = self._start_deep_research_serialize( 2687 organization_id=organization_id, 2688 pipeline_id=pipeline_id, 2689 start_deep_research_request=start_deep_research_request, 2690 _request_auth=_request_auth, 2691 _content_type=_content_type, 2692 _headers=_headers, 2693 _host_index=_host_index 2694 ) 2695 2696 _response_types_map: Dict[str, Optional[str]] = { 2697 '200': "StartDeepResearchResponse", 2698 '400': "GetWorkspaces400Response", 2699 '401': "GetWorkspaces400Response", 2700 '403': "GetWorkspaces400Response", 2701 '404': "GetWorkspaces400Response", 2702 '500': "GetWorkspaces400Response", 2703 } 2704 response_data = self.api_client.call_api( 2705 *_param, 2706 _request_timeout=_request_timeout 2707 ) 2708 return response_data.response
Start a deep research
Start a deep research
Parameters
- organization_id: (required)
- pipeline_id: (required)
- start_deep_research_request: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
start_pipeline( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.start_pipeline_response.StartPipelineResponse:
2794 @validate_call 2795 def start_pipeline( 2796 self, 2797 organization_id: StrictStr, 2798 pipeline_id: StrictStr, 2799 _request_timeout: Union[ 2800 None, 2801 Annotated[StrictFloat, Field(gt=0)], 2802 Tuple[ 2803 Annotated[StrictFloat, Field(gt=0)], 2804 Annotated[StrictFloat, Field(gt=0)] 2805 ] 2806 ] = None, 2807 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2808 _content_type: Optional[StrictStr] = None, 2809 _headers: Optional[Dict[StrictStr, Any]] = None, 2810 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2811 ) -> StartPipelineResponse: 2812 """Start a pipeline 2813 2814 Start a pipeline 2815 2816 :param organization_id: (required) 2817 :type organization_id: str 2818 :param pipeline_id: (required) 2819 :type pipeline_id: str 2820 :param _request_timeout: timeout setting for this request. If one 2821 number provided, it will be total request 2822 timeout. It can also be a pair (tuple) of 2823 (connection, read) timeouts. 2824 :type _request_timeout: int, tuple(int, int), optional 2825 :param _request_auth: set to override the auth_settings for an a single 2826 request; this effectively ignores the 2827 authentication in the spec for a single request. 2828 :type _request_auth: dict, optional 2829 :param _content_type: force content-type for the request. 2830 :type _content_type: str, Optional 2831 :param _headers: set to override the headers for a single 2832 request; this effectively ignores the headers 2833 in the spec for a single request. 2834 :type _headers: dict, optional 2835 :param _host_index: set to override the host_index for a single 2836 request; this effectively ignores the host_index 2837 in the spec for a single request. 2838 :type _host_index: int, optional 2839 :return: Returns the result object. 2840 """ # noqa: E501 2841 2842 _param = self._start_pipeline_serialize( 2843 organization_id=organization_id, 2844 pipeline_id=pipeline_id, 2845 _request_auth=_request_auth, 2846 _content_type=_content_type, 2847 _headers=_headers, 2848 _host_index=_host_index 2849 ) 2850 2851 _response_types_map: Dict[str, Optional[str]] = { 2852 '200': "StartPipelineResponse", 2853 '400': "GetWorkspaces400Response", 2854 '401': "GetWorkspaces400Response", 2855 '403': "GetWorkspaces400Response", 2856 '404': "GetWorkspaces400Response", 2857 '500': "GetWorkspaces400Response", 2858 } 2859 response_data = self.api_client.call_api( 2860 *_param, 2861 _request_timeout=_request_timeout 2862 ) 2863 response_data.read() 2864 return self.api_client.response_deserialize( 2865 response_data=response_data, 2866 response_types_map=_response_types_map, 2867 ).data
Start a pipeline
Start a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
start_pipeline_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[StartPipelineResponse]:
2870 @validate_call 2871 def start_pipeline_with_http_info( 2872 self, 2873 organization_id: StrictStr, 2874 pipeline_id: StrictStr, 2875 _request_timeout: Union[ 2876 None, 2877 Annotated[StrictFloat, Field(gt=0)], 2878 Tuple[ 2879 Annotated[StrictFloat, Field(gt=0)], 2880 Annotated[StrictFloat, Field(gt=0)] 2881 ] 2882 ] = None, 2883 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2884 _content_type: Optional[StrictStr] = None, 2885 _headers: Optional[Dict[StrictStr, Any]] = None, 2886 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2887 ) -> ApiResponse[StartPipelineResponse]: 2888 """Start a pipeline 2889 2890 Start a pipeline 2891 2892 :param organization_id: (required) 2893 :type organization_id: str 2894 :param pipeline_id: (required) 2895 :type pipeline_id: str 2896 :param _request_timeout: timeout setting for this request. If one 2897 number provided, it will be total request 2898 timeout. It can also be a pair (tuple) of 2899 (connection, read) timeouts. 2900 :type _request_timeout: int, tuple(int, int), optional 2901 :param _request_auth: set to override the auth_settings for an a single 2902 request; this effectively ignores the 2903 authentication in the spec for a single request. 2904 :type _request_auth: dict, optional 2905 :param _content_type: force content-type for the request. 2906 :type _content_type: str, Optional 2907 :param _headers: set to override the headers for a single 2908 request; this effectively ignores the headers 2909 in the spec for a single request. 2910 :type _headers: dict, optional 2911 :param _host_index: set to override the host_index for a single 2912 request; this effectively ignores the host_index 2913 in the spec for a single request. 2914 :type _host_index: int, optional 2915 :return: Returns the result object. 2916 """ # noqa: E501 2917 2918 _param = self._start_pipeline_serialize( 2919 organization_id=organization_id, 2920 pipeline_id=pipeline_id, 2921 _request_auth=_request_auth, 2922 _content_type=_content_type, 2923 _headers=_headers, 2924 _host_index=_host_index 2925 ) 2926 2927 _response_types_map: Dict[str, Optional[str]] = { 2928 '200': "StartPipelineResponse", 2929 '400': "GetWorkspaces400Response", 2930 '401': "GetWorkspaces400Response", 2931 '403': "GetWorkspaces400Response", 2932 '404': "GetWorkspaces400Response", 2933 '500': "GetWorkspaces400Response", 2934 } 2935 response_data = self.api_client.call_api( 2936 *_param, 2937 _request_timeout=_request_timeout 2938 ) 2939 response_data.read() 2940 return self.api_client.response_deserialize( 2941 response_data=response_data, 2942 response_types_map=_response_types_map, 2943 )
Start a pipeline
Start a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
start_pipeline_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse:
2946 @validate_call 2947 def start_pipeline_without_preload_content( 2948 self, 2949 organization_id: StrictStr, 2950 pipeline_id: StrictStr, 2951 _request_timeout: Union[ 2952 None, 2953 Annotated[StrictFloat, Field(gt=0)], 2954 Tuple[ 2955 Annotated[StrictFloat, Field(gt=0)], 2956 Annotated[StrictFloat, Field(gt=0)] 2957 ] 2958 ] = None, 2959 _request_auth: Optional[Dict[StrictStr, Any]] = None, 2960 _content_type: Optional[StrictStr] = None, 2961 _headers: Optional[Dict[StrictStr, Any]] = None, 2962 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 2963 ) -> RESTResponseType: 2964 """Start a pipeline 2965 2966 Start a pipeline 2967 2968 :param organization_id: (required) 2969 :type organization_id: str 2970 :param pipeline_id: (required) 2971 :type pipeline_id: str 2972 :param _request_timeout: timeout setting for this request. If one 2973 number provided, it will be total request 2974 timeout. It can also be a pair (tuple) of 2975 (connection, read) timeouts. 2976 :type _request_timeout: int, tuple(int, int), optional 2977 :param _request_auth: set to override the auth_settings for an a single 2978 request; this effectively ignores the 2979 authentication in the spec for a single request. 2980 :type _request_auth: dict, optional 2981 :param _content_type: force content-type for the request. 2982 :type _content_type: str, Optional 2983 :param _headers: set to override the headers for a single 2984 request; this effectively ignores the headers 2985 in the spec for a single request. 2986 :type _headers: dict, optional 2987 :param _host_index: set to override the host_index for a single 2988 request; this effectively ignores the host_index 2989 in the spec for a single request. 2990 :type _host_index: int, optional 2991 :return: Returns the result object. 2992 """ # noqa: E501 2993 2994 _param = self._start_pipeline_serialize( 2995 organization_id=organization_id, 2996 pipeline_id=pipeline_id, 2997 _request_auth=_request_auth, 2998 _content_type=_content_type, 2999 _headers=_headers, 3000 _host_index=_host_index 3001 ) 3002 3003 _response_types_map: Dict[str, Optional[str]] = { 3004 '200': "StartPipelineResponse", 3005 '400': "GetWorkspaces400Response", 3006 '401': "GetWorkspaces400Response", 3007 '403': "GetWorkspaces400Response", 3008 '404': "GetWorkspaces400Response", 3009 '500': "GetWorkspaces400Response", 3010 } 3011 response_data = self.api_client.call_api( 3012 *_param, 3013 _request_timeout=_request_timeout 3014 ) 3015 return response_data.response
Start a pipeline
Start a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
stop_pipeline( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.stop_pipeline_response.StopPipelineResponse:
3085 @validate_call 3086 def stop_pipeline( 3087 self, 3088 organization_id: StrictStr, 3089 pipeline_id: StrictStr, 3090 _request_timeout: Union[ 3091 None, 3092 Annotated[StrictFloat, Field(gt=0)], 3093 Tuple[ 3094 Annotated[StrictFloat, Field(gt=0)], 3095 Annotated[StrictFloat, Field(gt=0)] 3096 ] 3097 ] = None, 3098 _request_auth: Optional[Dict[StrictStr, Any]] = None, 3099 _content_type: Optional[StrictStr] = None, 3100 _headers: Optional[Dict[StrictStr, Any]] = None, 3101 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 3102 ) -> StopPipelineResponse: 3103 """Stop a pipeline 3104 3105 Stop a pipeline 3106 3107 :param organization_id: (required) 3108 :type organization_id: str 3109 :param pipeline_id: (required) 3110 :type pipeline_id: str 3111 :param _request_timeout: timeout setting for this request. If one 3112 number provided, it will be total request 3113 timeout. It can also be a pair (tuple) of 3114 (connection, read) timeouts. 3115 :type _request_timeout: int, tuple(int, int), optional 3116 :param _request_auth: set to override the auth_settings for an a single 3117 request; this effectively ignores the 3118 authentication in the spec for a single request. 3119 :type _request_auth: dict, optional 3120 :param _content_type: force content-type for the request. 3121 :type _content_type: str, Optional 3122 :param _headers: set to override the headers for a single 3123 request; this effectively ignores the headers 3124 in the spec for a single request. 3125 :type _headers: dict, optional 3126 :param _host_index: set to override the host_index for a single 3127 request; this effectively ignores the host_index 3128 in the spec for a single request. 3129 :type _host_index: int, optional 3130 :return: Returns the result object. 3131 """ # noqa: E501 3132 3133 _param = self._stop_pipeline_serialize( 3134 organization_id=organization_id, 3135 pipeline_id=pipeline_id, 3136 _request_auth=_request_auth, 3137 _content_type=_content_type, 3138 _headers=_headers, 3139 _host_index=_host_index 3140 ) 3141 3142 _response_types_map: Dict[str, Optional[str]] = { 3143 '200': "StopPipelineResponse", 3144 '400': "GetWorkspaces400Response", 3145 '401': "GetWorkspaces400Response", 3146 '403': "GetWorkspaces400Response", 3147 '404': "GetWorkspaces400Response", 3148 '500': "GetWorkspaces400Response", 3149 } 3150 response_data = self.api_client.call_api( 3151 *_param, 3152 _request_timeout=_request_timeout 3153 ) 3154 response_data.read() 3155 return self.api_client.response_deserialize( 3156 response_data=response_data, 3157 response_types_map=_response_types_map, 3158 ).data
Stop a pipeline
Stop a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
stop_pipeline_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[StopPipelineResponse]:
3161 @validate_call 3162 def stop_pipeline_with_http_info( 3163 self, 3164 organization_id: StrictStr, 3165 pipeline_id: StrictStr, 3166 _request_timeout: Union[ 3167 None, 3168 Annotated[StrictFloat, Field(gt=0)], 3169 Tuple[ 3170 Annotated[StrictFloat, Field(gt=0)], 3171 Annotated[StrictFloat, Field(gt=0)] 3172 ] 3173 ] = None, 3174 _request_auth: Optional[Dict[StrictStr, Any]] = None, 3175 _content_type: Optional[StrictStr] = None, 3176 _headers: Optional[Dict[StrictStr, Any]] = None, 3177 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 3178 ) -> ApiResponse[StopPipelineResponse]: 3179 """Stop a pipeline 3180 3181 Stop a pipeline 3182 3183 :param organization_id: (required) 3184 :type organization_id: str 3185 :param pipeline_id: (required) 3186 :type pipeline_id: str 3187 :param _request_timeout: timeout setting for this request. If one 3188 number provided, it will be total request 3189 timeout. It can also be a pair (tuple) of 3190 (connection, read) timeouts. 3191 :type _request_timeout: int, tuple(int, int), optional 3192 :param _request_auth: set to override the auth_settings for an a single 3193 request; this effectively ignores the 3194 authentication in the spec for a single request. 3195 :type _request_auth: dict, optional 3196 :param _content_type: force content-type for the request. 3197 :type _content_type: str, Optional 3198 :param _headers: set to override the headers for a single 3199 request; this effectively ignores the headers 3200 in the spec for a single request. 3201 :type _headers: dict, optional 3202 :param _host_index: set to override the host_index for a single 3203 request; this effectively ignores the host_index 3204 in the spec for a single request. 3205 :type _host_index: int, optional 3206 :return: Returns the result object. 3207 """ # noqa: E501 3208 3209 _param = self._stop_pipeline_serialize( 3210 organization_id=organization_id, 3211 pipeline_id=pipeline_id, 3212 _request_auth=_request_auth, 3213 _content_type=_content_type, 3214 _headers=_headers, 3215 _host_index=_host_index 3216 ) 3217 3218 _response_types_map: Dict[str, Optional[str]] = { 3219 '200': "StopPipelineResponse", 3220 '400': "GetWorkspaces400Response", 3221 '401': "GetWorkspaces400Response", 3222 '403': "GetWorkspaces400Response", 3223 '404': "GetWorkspaces400Response", 3224 '500': "GetWorkspaces400Response", 3225 } 3226 response_data = self.api_client.call_api( 3227 *_param, 3228 _request_timeout=_request_timeout 3229 ) 3230 response_data.read() 3231 return self.api_client.response_deserialize( 3232 response_data=response_data, 3233 response_types_map=_response_types_map, 3234 )
Stop a pipeline
Stop a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.
@validate_call
def
stop_pipeline_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], pipeline_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse:
3237 @validate_call 3238 def stop_pipeline_without_preload_content( 3239 self, 3240 organization_id: StrictStr, 3241 pipeline_id: StrictStr, 3242 _request_timeout: Union[ 3243 None, 3244 Annotated[StrictFloat, Field(gt=0)], 3245 Tuple[ 3246 Annotated[StrictFloat, Field(gt=0)], 3247 Annotated[StrictFloat, Field(gt=0)] 3248 ] 3249 ] = None, 3250 _request_auth: Optional[Dict[StrictStr, Any]] = None, 3251 _content_type: Optional[StrictStr] = None, 3252 _headers: Optional[Dict[StrictStr, Any]] = None, 3253 _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, 3254 ) -> RESTResponseType: 3255 """Stop a pipeline 3256 3257 Stop a pipeline 3258 3259 :param organization_id: (required) 3260 :type organization_id: str 3261 :param pipeline_id: (required) 3262 :type pipeline_id: str 3263 :param _request_timeout: timeout setting for this request. If one 3264 number provided, it will be total request 3265 timeout. It can also be a pair (tuple) of 3266 (connection, read) timeouts. 3267 :type _request_timeout: int, tuple(int, int), optional 3268 :param _request_auth: set to override the auth_settings for an a single 3269 request; this effectively ignores the 3270 authentication in the spec for a single request. 3271 :type _request_auth: dict, optional 3272 :param _content_type: force content-type for the request. 3273 :type _content_type: str, Optional 3274 :param _headers: set to override the headers for a single 3275 request; this effectively ignores the headers 3276 in the spec for a single request. 3277 :type _headers: dict, optional 3278 :param _host_index: set to override the host_index for a single 3279 request; this effectively ignores the host_index 3280 in the spec for a single request. 3281 :type _host_index: int, optional 3282 :return: Returns the result object. 3283 """ # noqa: E501 3284 3285 _param = self._stop_pipeline_serialize( 3286 organization_id=organization_id, 3287 pipeline_id=pipeline_id, 3288 _request_auth=_request_auth, 3289 _content_type=_content_type, 3290 _headers=_headers, 3291 _host_index=_host_index 3292 ) 3293 3294 _response_types_map: Dict[str, Optional[str]] = { 3295 '200': "StopPipelineResponse", 3296 '400': "GetWorkspaces400Response", 3297 '401': "GetWorkspaces400Response", 3298 '403': "GetWorkspaces400Response", 3299 '404': "GetWorkspaces400Response", 3300 '500': "GetWorkspaces400Response", 3301 } 3302 response_data = self.api_client.call_api( 3303 *_param, 3304 _request_timeout=_request_timeout 3305 ) 3306 return response_data.response
Stop a pipeline
Stop a pipeline
Parameters
- organization_id: (required)
- pipeline_id: (required)
- _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
- _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
- _content_type: force content-type for the request.
- _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
- _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.
Returns
Returns the result object.