vectorize_client.api.source_connectors_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.add_user_from_source_connector_response import AddUserFromSourceConnectorResponse
  22from vectorize_client.models.add_user_to_source_connector_request import AddUserToSourceConnectorRequest
  23from vectorize_client.models.create_source_connector_request import CreateSourceConnectorRequest
  24from vectorize_client.models.create_source_connector_response import CreateSourceConnectorResponse
  25from vectorize_client.models.delete_source_connector_response import DeleteSourceConnectorResponse
  26from vectorize_client.models.get_source_connectors200_response import GetSourceConnectors200Response
  27from vectorize_client.models.remove_user_from_source_connector_request import RemoveUserFromSourceConnectorRequest
  28from vectorize_client.models.remove_user_from_source_connector_response import RemoveUserFromSourceConnectorResponse
  29from vectorize_client.models.source_connector import SourceConnector
  30from vectorize_client.models.update_source_connector_request import UpdateSourceConnectorRequest
  31from vectorize_client.models.update_source_connector_response import UpdateSourceConnectorResponse
  32from vectorize_client.models.update_user_in_source_connector_request import UpdateUserInSourceConnectorRequest
  33from vectorize_client.models.update_user_in_source_connector_response import UpdateUserInSourceConnectorResponse
  34
  35from vectorize_client.api_client import ApiClient, RequestSerialized
  36from vectorize_client.api_response import ApiResponse
  37from vectorize_client.rest import RESTResponseType
  38
  39
  40class SourceConnectorsApi:
  41    """NOTE: This class is auto generated by OpenAPI Generator
  42    Ref: https://openapi-generator.tech
  43
  44    Do not edit the class manually.
  45    """
  46
  47    def __init__(self, api_client=None) -> None:
  48        if api_client is None:
  49            api_client = ApiClient.get_default()
  50        self.api_client = api_client
  51
  52
  53    @validate_call
  54    def add_user_to_source_connector(
  55        self,
  56        organization_id: StrictStr,
  57        source_connector_id: StrictStr,
  58        add_user_to_source_connector_request: AddUserToSourceConnectorRequest,
  59        _request_timeout: Union[
  60            None,
  61            Annotated[StrictFloat, Field(gt=0)],
  62            Tuple[
  63                Annotated[StrictFloat, Field(gt=0)],
  64                Annotated[StrictFloat, Field(gt=0)]
  65            ]
  66        ] = None,
  67        _request_auth: Optional[Dict[StrictStr, Any]] = None,
  68        _content_type: Optional[StrictStr] = None,
  69        _headers: Optional[Dict[StrictStr, Any]] = None,
  70        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
  71    ) -> AddUserFromSourceConnectorResponse:
  72        """Add a user to a source connector
  73
  74        Add a user to a source connector
  75
  76        :param organization_id: (required)
  77        :type organization_id: str
  78        :param source_connector_id: (required)
  79        :type source_connector_id: str
  80        :param add_user_to_source_connector_request: (required)
  81        :type add_user_to_source_connector_request: AddUserToSourceConnectorRequest
  82        :param _request_timeout: timeout setting for this request. If one
  83                                 number provided, it will be total request
  84                                 timeout. It can also be a pair (tuple) of
  85                                 (connection, read) timeouts.
  86        :type _request_timeout: int, tuple(int, int), optional
  87        :param _request_auth: set to override the auth_settings for an a single
  88                              request; this effectively ignores the
  89                              authentication in the spec for a single request.
  90        :type _request_auth: dict, optional
  91        :param _content_type: force content-type for the request.
  92        :type _content_type: str, Optional
  93        :param _headers: set to override the headers for a single
  94                         request; this effectively ignores the headers
  95                         in the spec for a single request.
  96        :type _headers: dict, optional
  97        :param _host_index: set to override the host_index for a single
  98                            request; this effectively ignores the host_index
  99                            in the spec for a single request.
 100        :type _host_index: int, optional
 101        :return: Returns the result object.
 102        """ # noqa: E501
 103
 104        _param = self._add_user_to_source_connector_serialize(
 105            organization_id=organization_id,
 106            source_connector_id=source_connector_id,
 107            add_user_to_source_connector_request=add_user_to_source_connector_request,
 108            _request_auth=_request_auth,
 109            _content_type=_content_type,
 110            _headers=_headers,
 111            _host_index=_host_index
 112        )
 113
 114        _response_types_map: Dict[str, Optional[str]] = {
 115            '200': "AddUserFromSourceConnectorResponse",
 116            '400': "GetPipelines400Response",
 117            '401': "GetPipelines400Response",
 118            '403': "GetPipelines400Response",
 119            '404': "GetPipelines400Response",
 120            '500': "GetPipelines400Response",
 121        }
 122        response_data = self.api_client.call_api(
 123            *_param,
 124            _request_timeout=_request_timeout
 125        )
 126        response_data.read()
 127        return self.api_client.response_deserialize(
 128            response_data=response_data,
 129            response_types_map=_response_types_map,
 130        ).data
 131
 132
 133    @validate_call
 134    def add_user_to_source_connector_with_http_info(
 135        self,
 136        organization_id: StrictStr,
 137        source_connector_id: StrictStr,
 138        add_user_to_source_connector_request: AddUserToSourceConnectorRequest,
 139        _request_timeout: Union[
 140            None,
 141            Annotated[StrictFloat, Field(gt=0)],
 142            Tuple[
 143                Annotated[StrictFloat, Field(gt=0)],
 144                Annotated[StrictFloat, Field(gt=0)]
 145            ]
 146        ] = None,
 147        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 148        _content_type: Optional[StrictStr] = None,
 149        _headers: Optional[Dict[StrictStr, Any]] = None,
 150        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 151    ) -> ApiResponse[AddUserFromSourceConnectorResponse]:
 152        """Add a user to a source connector
 153
 154        Add a user to a source connector
 155
 156        :param organization_id: (required)
 157        :type organization_id: str
 158        :param source_connector_id: (required)
 159        :type source_connector_id: str
 160        :param add_user_to_source_connector_request: (required)
 161        :type add_user_to_source_connector_request: AddUserToSourceConnectorRequest
 162        :param _request_timeout: timeout setting for this request. If one
 163                                 number provided, it will be total request
 164                                 timeout. It can also be a pair (tuple) of
 165                                 (connection, read) timeouts.
 166        :type _request_timeout: int, tuple(int, int), optional
 167        :param _request_auth: set to override the auth_settings for an a single
 168                              request; this effectively ignores the
 169                              authentication in the spec for a single request.
 170        :type _request_auth: dict, optional
 171        :param _content_type: force content-type for the request.
 172        :type _content_type: str, Optional
 173        :param _headers: set to override the headers for a single
 174                         request; this effectively ignores the headers
 175                         in the spec for a single request.
 176        :type _headers: dict, optional
 177        :param _host_index: set to override the host_index for a single
 178                            request; this effectively ignores the host_index
 179                            in the spec for a single request.
 180        :type _host_index: int, optional
 181        :return: Returns the result object.
 182        """ # noqa: E501
 183
 184        _param = self._add_user_to_source_connector_serialize(
 185            organization_id=organization_id,
 186            source_connector_id=source_connector_id,
 187            add_user_to_source_connector_request=add_user_to_source_connector_request,
 188            _request_auth=_request_auth,
 189            _content_type=_content_type,
 190            _headers=_headers,
 191            _host_index=_host_index
 192        )
 193
 194        _response_types_map: Dict[str, Optional[str]] = {
 195            '200': "AddUserFromSourceConnectorResponse",
 196            '400': "GetPipelines400Response",
 197            '401': "GetPipelines400Response",
 198            '403': "GetPipelines400Response",
 199            '404': "GetPipelines400Response",
 200            '500': "GetPipelines400Response",
 201        }
 202        response_data = self.api_client.call_api(
 203            *_param,
 204            _request_timeout=_request_timeout
 205        )
 206        response_data.read()
 207        return self.api_client.response_deserialize(
 208            response_data=response_data,
 209            response_types_map=_response_types_map,
 210        )
 211
 212
 213    @validate_call
 214    def add_user_to_source_connector_without_preload_content(
 215        self,
 216        organization_id: StrictStr,
 217        source_connector_id: StrictStr,
 218        add_user_to_source_connector_request: AddUserToSourceConnectorRequest,
 219        _request_timeout: Union[
 220            None,
 221            Annotated[StrictFloat, Field(gt=0)],
 222            Tuple[
 223                Annotated[StrictFloat, Field(gt=0)],
 224                Annotated[StrictFloat, Field(gt=0)]
 225            ]
 226        ] = None,
 227        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 228        _content_type: Optional[StrictStr] = None,
 229        _headers: Optional[Dict[StrictStr, Any]] = None,
 230        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 231    ) -> RESTResponseType:
 232        """Add a user to a source connector
 233
 234        Add a user to a source connector
 235
 236        :param organization_id: (required)
 237        :type organization_id: str
 238        :param source_connector_id: (required)
 239        :type source_connector_id: str
 240        :param add_user_to_source_connector_request: (required)
 241        :type add_user_to_source_connector_request: AddUserToSourceConnectorRequest
 242        :param _request_timeout: timeout setting for this request. If one
 243                                 number provided, it will be total request
 244                                 timeout. It can also be a pair (tuple) of
 245                                 (connection, read) timeouts.
 246        :type _request_timeout: int, tuple(int, int), optional
 247        :param _request_auth: set to override the auth_settings for an a single
 248                              request; this effectively ignores the
 249                              authentication in the spec for a single request.
 250        :type _request_auth: dict, optional
 251        :param _content_type: force content-type for the request.
 252        :type _content_type: str, Optional
 253        :param _headers: set to override the headers for a single
 254                         request; this effectively ignores the headers
 255                         in the spec for a single request.
 256        :type _headers: dict, optional
 257        :param _host_index: set to override the host_index for a single
 258                            request; this effectively ignores the host_index
 259                            in the spec for a single request.
 260        :type _host_index: int, optional
 261        :return: Returns the result object.
 262        """ # noqa: E501
 263
 264        _param = self._add_user_to_source_connector_serialize(
 265            organization_id=organization_id,
 266            source_connector_id=source_connector_id,
 267            add_user_to_source_connector_request=add_user_to_source_connector_request,
 268            _request_auth=_request_auth,
 269            _content_type=_content_type,
 270            _headers=_headers,
 271            _host_index=_host_index
 272        )
 273
 274        _response_types_map: Dict[str, Optional[str]] = {
 275            '200': "AddUserFromSourceConnectorResponse",
 276            '400': "GetPipelines400Response",
 277            '401': "GetPipelines400Response",
 278            '403': "GetPipelines400Response",
 279            '404': "GetPipelines400Response",
 280            '500': "GetPipelines400Response",
 281        }
 282        response_data = self.api_client.call_api(
 283            *_param,
 284            _request_timeout=_request_timeout
 285        )
 286        return response_data.response
 287
 288
 289    def _add_user_to_source_connector_serialize(
 290        self,
 291        organization_id,
 292        source_connector_id,
 293        add_user_to_source_connector_request,
 294        _request_auth,
 295        _content_type,
 296        _headers,
 297        _host_index,
 298    ) -> RequestSerialized:
 299
 300        _host = None
 301
 302        _collection_formats: Dict[str, str] = {
 303        }
 304
 305        _path_params: Dict[str, str] = {}
 306        _query_params: List[Tuple[str, str]] = []
 307        _header_params: Dict[str, Optional[str]] = _headers or {}
 308        _form_params: List[Tuple[str, str]] = []
 309        _files: Dict[
 310            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
 311        ] = {}
 312        _body_params: Optional[bytes] = None
 313
 314        # process the path parameters
 315        if organization_id is not None:
 316            _path_params['organizationId'] = organization_id
 317        if source_connector_id is not None:
 318            _path_params['sourceConnectorId'] = source_connector_id
 319        # process the query parameters
 320        # process the header parameters
 321        # process the form parameters
 322        # process the body parameter
 323        if add_user_to_source_connector_request is not None:
 324            _body_params = add_user_to_source_connector_request
 325
 326
 327        # set the HTTP header `Accept`
 328        if 'Accept' not in _header_params:
 329            _header_params['Accept'] = self.api_client.select_header_accept(
 330                [
 331                    'application/json'
 332                ]
 333            )
 334
 335        # set the HTTP header `Content-Type`
 336        if _content_type:
 337            _header_params['Content-Type'] = _content_type
 338        else:
 339            _default_content_type = (
 340                self.api_client.select_header_content_type(
 341                    [
 342                        'application/json'
 343                    ]
 344                )
 345            )
 346            if _default_content_type is not None:
 347                _header_params['Content-Type'] = _default_content_type
 348
 349        # authentication setting
 350        _auth_settings: List[str] = [
 351            'bearerAuth'
 352        ]
 353
 354        return self.api_client.param_serialize(
 355            method='POST',
 356            resource_path='/org/{organizationId}/connectors/sources/{sourceConnectorId}/users',
 357            path_params=_path_params,
 358            query_params=_query_params,
 359            header_params=_header_params,
 360            body=_body_params,
 361            post_params=_form_params,
 362            files=_files,
 363            auth_settings=_auth_settings,
 364            collection_formats=_collection_formats,
 365            _host=_host,
 366            _request_auth=_request_auth
 367        )
 368
 369
 370
 371
 372    @validate_call
 373    def create_source_connector(
 374        self,
 375        organization_id: StrictStr,
 376        create_source_connector_request: CreateSourceConnectorRequest,
 377        workspace_id: Optional[StrictStr] = None,
 378        _request_timeout: Union[
 379            None,
 380            Annotated[StrictFloat, Field(gt=0)],
 381            Tuple[
 382                Annotated[StrictFloat, Field(gt=0)],
 383                Annotated[StrictFloat, Field(gt=0)]
 384            ]
 385        ] = None,
 386        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 387        _content_type: Optional[StrictStr] = None,
 388        _headers: Optional[Dict[StrictStr, Any]] = None,
 389        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 390    ) -> CreateSourceConnectorResponse:
 391        """Create a new source connector
 392
 393        Creates a new source connector for data ingestion. The specific configuration fields required depend on the connector type selected.
 394
 395        :param organization_id: (required)
 396        :type organization_id: str
 397        :param create_source_connector_request: (required)
 398        :type create_source_connector_request: CreateSourceConnectorRequest
 399        :param workspace_id:
 400        :type workspace_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._create_source_connector_serialize(
 424            organization_id=organization_id,
 425            create_source_connector_request=create_source_connector_request,
 426            workspace_id=workspace_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': "CreateSourceConnectorResponse",
 435            '400': "GetPipelines400Response",
 436            '401': "GetPipelines400Response",
 437            '403': "GetPipelines400Response",
 438            '404': "GetPipelines400Response",
 439            '500': "GetPipelines400Response",
 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 create_source_connector_with_http_info(
 454        self,
 455        organization_id: StrictStr,
 456        create_source_connector_request: CreateSourceConnectorRequest,
 457        workspace_id: Optional[StrictStr] = None,
 458        _request_timeout: Union[
 459            None,
 460            Annotated[StrictFloat, Field(gt=0)],
 461            Tuple[
 462                Annotated[StrictFloat, Field(gt=0)],
 463                Annotated[StrictFloat, Field(gt=0)]
 464            ]
 465        ] = None,
 466        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 467        _content_type: Optional[StrictStr] = None,
 468        _headers: Optional[Dict[StrictStr, Any]] = None,
 469        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 470    ) -> ApiResponse[CreateSourceConnectorResponse]:
 471        """Create a new source connector
 472
 473        Creates a new source connector for data ingestion. The specific configuration fields required depend on the connector type selected.
 474
 475        :param organization_id: (required)
 476        :type organization_id: str
 477        :param create_source_connector_request: (required)
 478        :type create_source_connector_request: CreateSourceConnectorRequest
 479        :param workspace_id:
 480        :type workspace_id: str
 481        :param _request_timeout: timeout setting for this request. If one
 482                                 number provided, it will be total request
 483                                 timeout. It can also be a pair (tuple) of
 484                                 (connection, read) timeouts.
 485        :type _request_timeout: int, tuple(int, int), optional
 486        :param _request_auth: set to override the auth_settings for an a single
 487                              request; this effectively ignores the
 488                              authentication in the spec for a single request.
 489        :type _request_auth: dict, optional
 490        :param _content_type: force content-type for the request.
 491        :type _content_type: str, Optional
 492        :param _headers: set to override the headers for a single
 493                         request; this effectively ignores the headers
 494                         in the spec for a single request.
 495        :type _headers: dict, optional
 496        :param _host_index: set to override the host_index for a single
 497                            request; this effectively ignores the host_index
 498                            in the spec for a single request.
 499        :type _host_index: int, optional
 500        :return: Returns the result object.
 501        """ # noqa: E501
 502
 503        _param = self._create_source_connector_serialize(
 504            organization_id=organization_id,
 505            create_source_connector_request=create_source_connector_request,
 506            workspace_id=workspace_id,
 507            _request_auth=_request_auth,
 508            _content_type=_content_type,
 509            _headers=_headers,
 510            _host_index=_host_index
 511        )
 512
 513        _response_types_map: Dict[str, Optional[str]] = {
 514            '200': "CreateSourceConnectorResponse",
 515            '400': "GetPipelines400Response",
 516            '401': "GetPipelines400Response",
 517            '403': "GetPipelines400Response",
 518            '404': "GetPipelines400Response",
 519            '500': "GetPipelines400Response",
 520        }
 521        response_data = self.api_client.call_api(
 522            *_param,
 523            _request_timeout=_request_timeout
 524        )
 525        response_data.read()
 526        return self.api_client.response_deserialize(
 527            response_data=response_data,
 528            response_types_map=_response_types_map,
 529        )
 530
 531
 532    @validate_call
 533    def create_source_connector_without_preload_content(
 534        self,
 535        organization_id: StrictStr,
 536        create_source_connector_request: CreateSourceConnectorRequest,
 537        workspace_id: Optional[StrictStr] = None,
 538        _request_timeout: Union[
 539            None,
 540            Annotated[StrictFloat, Field(gt=0)],
 541            Tuple[
 542                Annotated[StrictFloat, Field(gt=0)],
 543                Annotated[StrictFloat, Field(gt=0)]
 544            ]
 545        ] = None,
 546        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 547        _content_type: Optional[StrictStr] = None,
 548        _headers: Optional[Dict[StrictStr, Any]] = None,
 549        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 550    ) -> RESTResponseType:
 551        """Create a new source connector
 552
 553        Creates a new source connector for data ingestion. The specific configuration fields required depend on the connector type selected.
 554
 555        :param organization_id: (required)
 556        :type organization_id: str
 557        :param create_source_connector_request: (required)
 558        :type create_source_connector_request: CreateSourceConnectorRequest
 559        :param workspace_id:
 560        :type workspace_id: str
 561        :param _request_timeout: timeout setting for this request. If one
 562                                 number provided, it will be total request
 563                                 timeout. It can also be a pair (tuple) of
 564                                 (connection, read) timeouts.
 565        :type _request_timeout: int, tuple(int, int), optional
 566        :param _request_auth: set to override the auth_settings for an a single
 567                              request; this effectively ignores the
 568                              authentication in the spec for a single request.
 569        :type _request_auth: dict, optional
 570        :param _content_type: force content-type for the request.
 571        :type _content_type: str, Optional
 572        :param _headers: set to override the headers for a single
 573                         request; this effectively ignores the headers
 574                         in the spec for a single request.
 575        :type _headers: dict, optional
 576        :param _host_index: set to override the host_index for a single
 577                            request; this effectively ignores the host_index
 578                            in the spec for a single request.
 579        :type _host_index: int, optional
 580        :return: Returns the result object.
 581        """ # noqa: E501
 582
 583        _param = self._create_source_connector_serialize(
 584            organization_id=organization_id,
 585            create_source_connector_request=create_source_connector_request,
 586            workspace_id=workspace_id,
 587            _request_auth=_request_auth,
 588            _content_type=_content_type,
 589            _headers=_headers,
 590            _host_index=_host_index
 591        )
 592
 593        _response_types_map: Dict[str, Optional[str]] = {
 594            '200': "CreateSourceConnectorResponse",
 595            '400': "GetPipelines400Response",
 596            '401': "GetPipelines400Response",
 597            '403': "GetPipelines400Response",
 598            '404': "GetPipelines400Response",
 599            '500': "GetPipelines400Response",
 600        }
 601        response_data = self.api_client.call_api(
 602            *_param,
 603            _request_timeout=_request_timeout
 604        )
 605        return response_data.response
 606
 607
 608    def _create_source_connector_serialize(
 609        self,
 610        organization_id,
 611        create_source_connector_request,
 612        workspace_id,
 613        _request_auth,
 614        _content_type,
 615        _headers,
 616        _host_index,
 617    ) -> RequestSerialized:
 618
 619        _host = None
 620
 621        _collection_formats: Dict[str, str] = {
 622        }
 623
 624        _path_params: Dict[str, str] = {}
 625        _query_params: List[Tuple[str, str]] = []
 626        _header_params: Dict[str, Optional[str]] = _headers or {}
 627        _form_params: List[Tuple[str, str]] = []
 628        _files: Dict[
 629            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
 630        ] = {}
 631        _body_params: Optional[bytes] = None
 632
 633        # process the path parameters
 634        if organization_id is not None:
 635            _path_params['organizationId'] = organization_id
 636        # process the query parameters
 637        if workspace_id is not None:
 638            
 639            _query_params.append(('workspaceId', workspace_id))
 640            
 641        # process the header parameters
 642        # process the form parameters
 643        # process the body parameter
 644        if create_source_connector_request is not None:
 645            _body_params = create_source_connector_request
 646
 647
 648        # set the HTTP header `Accept`
 649        if 'Accept' not in _header_params:
 650            _header_params['Accept'] = self.api_client.select_header_accept(
 651                [
 652                    'application/json'
 653                ]
 654            )
 655
 656        # set the HTTP header `Content-Type`
 657        if _content_type:
 658            _header_params['Content-Type'] = _content_type
 659        else:
 660            _default_content_type = (
 661                self.api_client.select_header_content_type(
 662                    [
 663                        'application/json'
 664                    ]
 665                )
 666            )
 667            if _default_content_type is not None:
 668                _header_params['Content-Type'] = _default_content_type
 669
 670        # authentication setting
 671        _auth_settings: List[str] = [
 672            'bearerAuth'
 673        ]
 674
 675        return self.api_client.param_serialize(
 676            method='POST',
 677            resource_path='/org/{organizationId}/connectors/sources',
 678            path_params=_path_params,
 679            query_params=_query_params,
 680            header_params=_header_params,
 681            body=_body_params,
 682            post_params=_form_params,
 683            files=_files,
 684            auth_settings=_auth_settings,
 685            collection_formats=_collection_formats,
 686            _host=_host,
 687            _request_auth=_request_auth
 688        )
 689
 690
 691
 692
 693    @validate_call
 694    def delete_source_connector(
 695        self,
 696        organization_id: StrictStr,
 697        source_connector_id: StrictStr,
 698        _request_timeout: Union[
 699            None,
 700            Annotated[StrictFloat, Field(gt=0)],
 701            Tuple[
 702                Annotated[StrictFloat, Field(gt=0)],
 703                Annotated[StrictFloat, Field(gt=0)]
 704            ]
 705        ] = None,
 706        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 707        _content_type: Optional[StrictStr] = None,
 708        _headers: Optional[Dict[StrictStr, Any]] = None,
 709        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 710    ) -> DeleteSourceConnectorResponse:
 711        """Delete a source connector
 712
 713        Delete a source connector
 714
 715        :param organization_id: (required)
 716        :type organization_id: str
 717        :param source_connector_id: (required)
 718        :type source_connector_id: str
 719        :param _request_timeout: timeout setting for this request. If one
 720                                 number provided, it will be total request
 721                                 timeout. It can also be a pair (tuple) of
 722                                 (connection, read) timeouts.
 723        :type _request_timeout: int, tuple(int, int), optional
 724        :param _request_auth: set to override the auth_settings for an a single
 725                              request; this effectively ignores the
 726                              authentication in the spec for a single request.
 727        :type _request_auth: dict, optional
 728        :param _content_type: force content-type for the request.
 729        :type _content_type: str, Optional
 730        :param _headers: set to override the headers for a single
 731                         request; this effectively ignores the headers
 732                         in the spec for a single request.
 733        :type _headers: dict, optional
 734        :param _host_index: set to override the host_index for a single
 735                            request; this effectively ignores the host_index
 736                            in the spec for a single request.
 737        :type _host_index: int, optional
 738        :return: Returns the result object.
 739        """ # noqa: E501
 740
 741        _param = self._delete_source_connector_serialize(
 742            organization_id=organization_id,
 743            source_connector_id=source_connector_id,
 744            _request_auth=_request_auth,
 745            _content_type=_content_type,
 746            _headers=_headers,
 747            _host_index=_host_index
 748        )
 749
 750        _response_types_map: Dict[str, Optional[str]] = {
 751            '200': "DeleteSourceConnectorResponse",
 752            '400': "GetPipelines400Response",
 753            '401': "GetPipelines400Response",
 754            '403': "GetPipelines400Response",
 755            '404': "GetPipelines400Response",
 756            '500': "GetPipelines400Response",
 757        }
 758        response_data = self.api_client.call_api(
 759            *_param,
 760            _request_timeout=_request_timeout
 761        )
 762        response_data.read()
 763        return self.api_client.response_deserialize(
 764            response_data=response_data,
 765            response_types_map=_response_types_map,
 766        ).data
 767
 768
 769    @validate_call
 770    def delete_source_connector_with_http_info(
 771        self,
 772        organization_id: StrictStr,
 773        source_connector_id: StrictStr,
 774        _request_timeout: Union[
 775            None,
 776            Annotated[StrictFloat, Field(gt=0)],
 777            Tuple[
 778                Annotated[StrictFloat, Field(gt=0)],
 779                Annotated[StrictFloat, Field(gt=0)]
 780            ]
 781        ] = None,
 782        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 783        _content_type: Optional[StrictStr] = None,
 784        _headers: Optional[Dict[StrictStr, Any]] = None,
 785        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 786    ) -> ApiResponse[DeleteSourceConnectorResponse]:
 787        """Delete a source connector
 788
 789        Delete a source connector
 790
 791        :param organization_id: (required)
 792        :type organization_id: str
 793        :param source_connector_id: (required)
 794        :type source_connector_id: str
 795        :param _request_timeout: timeout setting for this request. If one
 796                                 number provided, it will be total request
 797                                 timeout. It can also be a pair (tuple) of
 798                                 (connection, read) timeouts.
 799        :type _request_timeout: int, tuple(int, int), optional
 800        :param _request_auth: set to override the auth_settings for an a single
 801                              request; this effectively ignores the
 802                              authentication in the spec for a single request.
 803        :type _request_auth: dict, optional
 804        :param _content_type: force content-type for the request.
 805        :type _content_type: str, Optional
 806        :param _headers: set to override the headers for a single
 807                         request; this effectively ignores the headers
 808                         in the spec for a single request.
 809        :type _headers: dict, optional
 810        :param _host_index: set to override the host_index for a single
 811                            request; this effectively ignores the host_index
 812                            in the spec for a single request.
 813        :type _host_index: int, optional
 814        :return: Returns the result object.
 815        """ # noqa: E501
 816
 817        _param = self._delete_source_connector_serialize(
 818            organization_id=organization_id,
 819            source_connector_id=source_connector_id,
 820            _request_auth=_request_auth,
 821            _content_type=_content_type,
 822            _headers=_headers,
 823            _host_index=_host_index
 824        )
 825
 826        _response_types_map: Dict[str, Optional[str]] = {
 827            '200': "DeleteSourceConnectorResponse",
 828            '400': "GetPipelines400Response",
 829            '401': "GetPipelines400Response",
 830            '403': "GetPipelines400Response",
 831            '404': "GetPipelines400Response",
 832            '500': "GetPipelines400Response",
 833        }
 834        response_data = self.api_client.call_api(
 835            *_param,
 836            _request_timeout=_request_timeout
 837        )
 838        response_data.read()
 839        return self.api_client.response_deserialize(
 840            response_data=response_data,
 841            response_types_map=_response_types_map,
 842        )
 843
 844
 845    @validate_call
 846    def delete_source_connector_without_preload_content(
 847        self,
 848        organization_id: StrictStr,
 849        source_connector_id: StrictStr,
 850        _request_timeout: Union[
 851            None,
 852            Annotated[StrictFloat, Field(gt=0)],
 853            Tuple[
 854                Annotated[StrictFloat, Field(gt=0)],
 855                Annotated[StrictFloat, Field(gt=0)]
 856            ]
 857        ] = None,
 858        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 859        _content_type: Optional[StrictStr] = None,
 860        _headers: Optional[Dict[StrictStr, Any]] = None,
 861        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 862    ) -> RESTResponseType:
 863        """Delete a source connector
 864
 865        Delete a source connector
 866
 867        :param organization_id: (required)
 868        :type organization_id: str
 869        :param source_connector_id: (required)
 870        :type source_connector_id: str
 871        :param _request_timeout: timeout setting for this request. If one
 872                                 number provided, it will be total request
 873                                 timeout. It can also be a pair (tuple) of
 874                                 (connection, read) timeouts.
 875        :type _request_timeout: int, tuple(int, int), optional
 876        :param _request_auth: set to override the auth_settings for an a single
 877                              request; this effectively ignores the
 878                              authentication in the spec for a single request.
 879        :type _request_auth: dict, optional
 880        :param _content_type: force content-type for the request.
 881        :type _content_type: str, Optional
 882        :param _headers: set to override the headers for a single
 883                         request; this effectively ignores the headers
 884                         in the spec for a single request.
 885        :type _headers: dict, optional
 886        :param _host_index: set to override the host_index for a single
 887                            request; this effectively ignores the host_index
 888                            in the spec for a single request.
 889        :type _host_index: int, optional
 890        :return: Returns the result object.
 891        """ # noqa: E501
 892
 893        _param = self._delete_source_connector_serialize(
 894            organization_id=organization_id,
 895            source_connector_id=source_connector_id,
 896            _request_auth=_request_auth,
 897            _content_type=_content_type,
 898            _headers=_headers,
 899            _host_index=_host_index
 900        )
 901
 902        _response_types_map: Dict[str, Optional[str]] = {
 903            '200': "DeleteSourceConnectorResponse",
 904            '400': "GetPipelines400Response",
 905            '401': "GetPipelines400Response",
 906            '403': "GetPipelines400Response",
 907            '404': "GetPipelines400Response",
 908            '500': "GetPipelines400Response",
 909        }
 910        response_data = self.api_client.call_api(
 911            *_param,
 912            _request_timeout=_request_timeout
 913        )
 914        return response_data.response
 915
 916
 917    def _delete_source_connector_serialize(
 918        self,
 919        organization_id,
 920        source_connector_id,
 921        _request_auth,
 922        _content_type,
 923        _headers,
 924        _host_index,
 925    ) -> RequestSerialized:
 926
 927        _host = None
 928
 929        _collection_formats: Dict[str, str] = {
 930        }
 931
 932        _path_params: Dict[str, str] = {}
 933        _query_params: List[Tuple[str, str]] = []
 934        _header_params: Dict[str, Optional[str]] = _headers or {}
 935        _form_params: List[Tuple[str, str]] = []
 936        _files: Dict[
 937            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
 938        ] = {}
 939        _body_params: Optional[bytes] = None
 940
 941        # process the path parameters
 942        if organization_id is not None:
 943            _path_params['organizationId'] = organization_id
 944        if source_connector_id is not None:
 945            _path_params['sourceConnectorId'] = source_connector_id
 946        # process the query parameters
 947        # process the header parameters
 948        # process the form parameters
 949        # process the body parameter
 950
 951
 952        # set the HTTP header `Accept`
 953        if 'Accept' not in _header_params:
 954            _header_params['Accept'] = self.api_client.select_header_accept(
 955                [
 956                    'application/json'
 957                ]
 958            )
 959
 960
 961        # authentication setting
 962        _auth_settings: List[str] = [
 963            'bearerAuth'
 964        ]
 965
 966        return self.api_client.param_serialize(
 967            method='DELETE',
 968            resource_path='/org/{organizationId}/connectors/sources/{sourceConnectorId}',
 969            path_params=_path_params,
 970            query_params=_query_params,
 971            header_params=_header_params,
 972            body=_body_params,
 973            post_params=_form_params,
 974            files=_files,
 975            auth_settings=_auth_settings,
 976            collection_formats=_collection_formats,
 977            _host=_host,
 978            _request_auth=_request_auth
 979        )
 980
 981
 982
 983
 984    @validate_call
 985    def delete_user_from_source_connector(
 986        self,
 987        organization_id: StrictStr,
 988        source_connector_id: StrictStr,
 989        remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest,
 990        _request_timeout: Union[
 991            None,
 992            Annotated[StrictFloat, Field(gt=0)],
 993            Tuple[
 994                Annotated[StrictFloat, Field(gt=0)],
 995                Annotated[StrictFloat, Field(gt=0)]
 996            ]
 997        ] = None,
 998        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 999        _content_type: Optional[StrictStr] = None,
1000        _headers: Optional[Dict[StrictStr, Any]] = None,
1001        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1002    ) -> RemoveUserFromSourceConnectorResponse:
1003        """Delete a source connector user
1004
1005        Delete a source connector user
1006
1007        :param organization_id: (required)
1008        :type organization_id: str
1009        :param source_connector_id: (required)
1010        :type source_connector_id: str
1011        :param remove_user_from_source_connector_request: (required)
1012        :type remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest
1013        :param _request_timeout: timeout setting for this request. If one
1014                                 number provided, it will be total request
1015                                 timeout. It can also be a pair (tuple) of
1016                                 (connection, read) timeouts.
1017        :type _request_timeout: int, tuple(int, int), optional
1018        :param _request_auth: set to override the auth_settings for an a single
1019                              request; this effectively ignores the
1020                              authentication in the spec for a single request.
1021        :type _request_auth: dict, optional
1022        :param _content_type: force content-type for the request.
1023        :type _content_type: str, Optional
1024        :param _headers: set to override the headers for a single
1025                         request; this effectively ignores the headers
1026                         in the spec for a single request.
1027        :type _headers: dict, optional
1028        :param _host_index: set to override the host_index for a single
1029                            request; this effectively ignores the host_index
1030                            in the spec for a single request.
1031        :type _host_index: int, optional
1032        :return: Returns the result object.
1033        """ # noqa: E501
1034
1035        _param = self._delete_user_from_source_connector_serialize(
1036            organization_id=organization_id,
1037            source_connector_id=source_connector_id,
1038            remove_user_from_source_connector_request=remove_user_from_source_connector_request,
1039            _request_auth=_request_auth,
1040            _content_type=_content_type,
1041            _headers=_headers,
1042            _host_index=_host_index
1043        )
1044
1045        _response_types_map: Dict[str, Optional[str]] = {
1046            '200': "RemoveUserFromSourceConnectorResponse",
1047            '400': "GetPipelines400Response",
1048            '401': "GetPipelines400Response",
1049            '403': "GetPipelines400Response",
1050            '404': "GetPipelines400Response",
1051            '500': "GetPipelines400Response",
1052        }
1053        response_data = self.api_client.call_api(
1054            *_param,
1055            _request_timeout=_request_timeout
1056        )
1057        response_data.read()
1058        return self.api_client.response_deserialize(
1059            response_data=response_data,
1060            response_types_map=_response_types_map,
1061        ).data
1062
1063
1064    @validate_call
1065    def delete_user_from_source_connector_with_http_info(
1066        self,
1067        organization_id: StrictStr,
1068        source_connector_id: StrictStr,
1069        remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest,
1070        _request_timeout: Union[
1071            None,
1072            Annotated[StrictFloat, Field(gt=0)],
1073            Tuple[
1074                Annotated[StrictFloat, Field(gt=0)],
1075                Annotated[StrictFloat, Field(gt=0)]
1076            ]
1077        ] = None,
1078        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1079        _content_type: Optional[StrictStr] = None,
1080        _headers: Optional[Dict[StrictStr, Any]] = None,
1081        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1082    ) -> ApiResponse[RemoveUserFromSourceConnectorResponse]:
1083        """Delete a source connector user
1084
1085        Delete a source connector user
1086
1087        :param organization_id: (required)
1088        :type organization_id: str
1089        :param source_connector_id: (required)
1090        :type source_connector_id: str
1091        :param remove_user_from_source_connector_request: (required)
1092        :type remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest
1093        :param _request_timeout: timeout setting for this request. If one
1094                                 number provided, it will be total request
1095                                 timeout. It can also be a pair (tuple) of
1096                                 (connection, read) timeouts.
1097        :type _request_timeout: int, tuple(int, int), optional
1098        :param _request_auth: set to override the auth_settings for an a single
1099                              request; this effectively ignores the
1100                              authentication in the spec for a single request.
1101        :type _request_auth: dict, optional
1102        :param _content_type: force content-type for the request.
1103        :type _content_type: str, Optional
1104        :param _headers: set to override the headers for a single
1105                         request; this effectively ignores the headers
1106                         in the spec for a single request.
1107        :type _headers: dict, optional
1108        :param _host_index: set to override the host_index for a single
1109                            request; this effectively ignores the host_index
1110                            in the spec for a single request.
1111        :type _host_index: int, optional
1112        :return: Returns the result object.
1113        """ # noqa: E501
1114
1115        _param = self._delete_user_from_source_connector_serialize(
1116            organization_id=organization_id,
1117            source_connector_id=source_connector_id,
1118            remove_user_from_source_connector_request=remove_user_from_source_connector_request,
1119            _request_auth=_request_auth,
1120            _content_type=_content_type,
1121            _headers=_headers,
1122            _host_index=_host_index
1123        )
1124
1125        _response_types_map: Dict[str, Optional[str]] = {
1126            '200': "RemoveUserFromSourceConnectorResponse",
1127            '400': "GetPipelines400Response",
1128            '401': "GetPipelines400Response",
1129            '403': "GetPipelines400Response",
1130            '404': "GetPipelines400Response",
1131            '500': "GetPipelines400Response",
1132        }
1133        response_data = self.api_client.call_api(
1134            *_param,
1135            _request_timeout=_request_timeout
1136        )
1137        response_data.read()
1138        return self.api_client.response_deserialize(
1139            response_data=response_data,
1140            response_types_map=_response_types_map,
1141        )
1142
1143
1144    @validate_call
1145    def delete_user_from_source_connector_without_preload_content(
1146        self,
1147        organization_id: StrictStr,
1148        source_connector_id: StrictStr,
1149        remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest,
1150        _request_timeout: Union[
1151            None,
1152            Annotated[StrictFloat, Field(gt=0)],
1153            Tuple[
1154                Annotated[StrictFloat, Field(gt=0)],
1155                Annotated[StrictFloat, Field(gt=0)]
1156            ]
1157        ] = None,
1158        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1159        _content_type: Optional[StrictStr] = None,
1160        _headers: Optional[Dict[StrictStr, Any]] = None,
1161        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1162    ) -> RESTResponseType:
1163        """Delete a source connector user
1164
1165        Delete a source connector user
1166
1167        :param organization_id: (required)
1168        :type organization_id: str
1169        :param source_connector_id: (required)
1170        :type source_connector_id: str
1171        :param remove_user_from_source_connector_request: (required)
1172        :type remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest
1173        :param _request_timeout: timeout setting for this request. If one
1174                                 number provided, it will be total request
1175                                 timeout. It can also be a pair (tuple) of
1176                                 (connection, read) timeouts.
1177        :type _request_timeout: int, tuple(int, int), optional
1178        :param _request_auth: set to override the auth_settings for an a single
1179                              request; this effectively ignores the
1180                              authentication in the spec for a single request.
1181        :type _request_auth: dict, optional
1182        :param _content_type: force content-type for the request.
1183        :type _content_type: str, Optional
1184        :param _headers: set to override the headers for a single
1185                         request; this effectively ignores the headers
1186                         in the spec for a single request.
1187        :type _headers: dict, optional
1188        :param _host_index: set to override the host_index for a single
1189                            request; this effectively ignores the host_index
1190                            in the spec for a single request.
1191        :type _host_index: int, optional
1192        :return: Returns the result object.
1193        """ # noqa: E501
1194
1195        _param = self._delete_user_from_source_connector_serialize(
1196            organization_id=organization_id,
1197            source_connector_id=source_connector_id,
1198            remove_user_from_source_connector_request=remove_user_from_source_connector_request,
1199            _request_auth=_request_auth,
1200            _content_type=_content_type,
1201            _headers=_headers,
1202            _host_index=_host_index
1203        )
1204
1205        _response_types_map: Dict[str, Optional[str]] = {
1206            '200': "RemoveUserFromSourceConnectorResponse",
1207            '400': "GetPipelines400Response",
1208            '401': "GetPipelines400Response",
1209            '403': "GetPipelines400Response",
1210            '404': "GetPipelines400Response",
1211            '500': "GetPipelines400Response",
1212        }
1213        response_data = self.api_client.call_api(
1214            *_param,
1215            _request_timeout=_request_timeout
1216        )
1217        return response_data.response
1218
1219
1220    def _delete_user_from_source_connector_serialize(
1221        self,
1222        organization_id,
1223        source_connector_id,
1224        remove_user_from_source_connector_request,
1225        _request_auth,
1226        _content_type,
1227        _headers,
1228        _host_index,
1229    ) -> RequestSerialized:
1230
1231        _host = None
1232
1233        _collection_formats: Dict[str, str] = {
1234        }
1235
1236        _path_params: Dict[str, str] = {}
1237        _query_params: List[Tuple[str, str]] = []
1238        _header_params: Dict[str, Optional[str]] = _headers or {}
1239        _form_params: List[Tuple[str, str]] = []
1240        _files: Dict[
1241            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1242        ] = {}
1243        _body_params: Optional[bytes] = None
1244
1245        # process the path parameters
1246        if organization_id is not None:
1247            _path_params['organizationId'] = organization_id
1248        if source_connector_id is not None:
1249            _path_params['sourceConnectorId'] = source_connector_id
1250        # process the query parameters
1251        # process the header parameters
1252        # process the form parameters
1253        # process the body parameter
1254        if remove_user_from_source_connector_request is not None:
1255            _body_params = remove_user_from_source_connector_request
1256
1257
1258        # set the HTTP header `Accept`
1259        if 'Accept' not in _header_params:
1260            _header_params['Accept'] = self.api_client.select_header_accept(
1261                [
1262                    'application/json'
1263                ]
1264            )
1265
1266        # set the HTTP header `Content-Type`
1267        if _content_type:
1268            _header_params['Content-Type'] = _content_type
1269        else:
1270            _default_content_type = (
1271                self.api_client.select_header_content_type(
1272                    [
1273                        'application/json'
1274                    ]
1275                )
1276            )
1277            if _default_content_type is not None:
1278                _header_params['Content-Type'] = _default_content_type
1279
1280        # authentication setting
1281        _auth_settings: List[str] = [
1282            'bearerAuth'
1283        ]
1284
1285        return self.api_client.param_serialize(
1286            method='DELETE',
1287            resource_path='/org/{organizationId}/connectors/sources/{sourceConnectorId}/users',
1288            path_params=_path_params,
1289            query_params=_query_params,
1290            header_params=_header_params,
1291            body=_body_params,
1292            post_params=_form_params,
1293            files=_files,
1294            auth_settings=_auth_settings,
1295            collection_formats=_collection_formats,
1296            _host=_host,
1297            _request_auth=_request_auth
1298        )
1299
1300
1301
1302
1303    @validate_call
1304    def get_source_connector(
1305        self,
1306        organization_id: StrictStr,
1307        source_connector_id: StrictStr,
1308        _request_timeout: Union[
1309            None,
1310            Annotated[StrictFloat, Field(gt=0)],
1311            Tuple[
1312                Annotated[StrictFloat, Field(gt=0)],
1313                Annotated[StrictFloat, Field(gt=0)]
1314            ]
1315        ] = None,
1316        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1317        _content_type: Optional[StrictStr] = None,
1318        _headers: Optional[Dict[StrictStr, Any]] = None,
1319        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1320    ) -> SourceConnector:
1321        """Get a source connector
1322
1323        Get a source connector
1324
1325        :param organization_id: (required)
1326        :type organization_id: str
1327        :param source_connector_id: (required)
1328        :type source_connector_id: str
1329        :param _request_timeout: timeout setting for this request. If one
1330                                 number provided, it will be total request
1331                                 timeout. It can also be a pair (tuple) of
1332                                 (connection, read) timeouts.
1333        :type _request_timeout: int, tuple(int, int), optional
1334        :param _request_auth: set to override the auth_settings for an a single
1335                              request; this effectively ignores the
1336                              authentication in the spec for a single request.
1337        :type _request_auth: dict, optional
1338        :param _content_type: force content-type for the request.
1339        :type _content_type: str, Optional
1340        :param _headers: set to override the headers for a single
1341                         request; this effectively ignores the headers
1342                         in the spec for a single request.
1343        :type _headers: dict, optional
1344        :param _host_index: set to override the host_index for a single
1345                            request; this effectively ignores the host_index
1346                            in the spec for a single request.
1347        :type _host_index: int, optional
1348        :return: Returns the result object.
1349        """ # noqa: E501
1350
1351        _param = self._get_source_connector_serialize(
1352            organization_id=organization_id,
1353            source_connector_id=source_connector_id,
1354            _request_auth=_request_auth,
1355            _content_type=_content_type,
1356            _headers=_headers,
1357            _host_index=_host_index
1358        )
1359
1360        _response_types_map: Dict[str, Optional[str]] = {
1361            '200': "SourceConnector",
1362            '400': "GetPipelines400Response",
1363            '401': "GetPipelines400Response",
1364            '403': "GetPipelines400Response",
1365            '404': "GetPipelines400Response",
1366            '500': "GetPipelines400Response",
1367        }
1368        response_data = self.api_client.call_api(
1369            *_param,
1370            _request_timeout=_request_timeout
1371        )
1372        response_data.read()
1373        return self.api_client.response_deserialize(
1374            response_data=response_data,
1375            response_types_map=_response_types_map,
1376        ).data
1377
1378
1379    @validate_call
1380    def get_source_connector_with_http_info(
1381        self,
1382        organization_id: StrictStr,
1383        source_connector_id: StrictStr,
1384        _request_timeout: Union[
1385            None,
1386            Annotated[StrictFloat, Field(gt=0)],
1387            Tuple[
1388                Annotated[StrictFloat, Field(gt=0)],
1389                Annotated[StrictFloat, Field(gt=0)]
1390            ]
1391        ] = None,
1392        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1393        _content_type: Optional[StrictStr] = None,
1394        _headers: Optional[Dict[StrictStr, Any]] = None,
1395        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1396    ) -> ApiResponse[SourceConnector]:
1397        """Get a source connector
1398
1399        Get a source connector
1400
1401        :param organization_id: (required)
1402        :type organization_id: str
1403        :param source_connector_id: (required)
1404        :type source_connector_id: str
1405        :param _request_timeout: timeout setting for this request. If one
1406                                 number provided, it will be total request
1407                                 timeout. It can also be a pair (tuple) of
1408                                 (connection, read) timeouts.
1409        :type _request_timeout: int, tuple(int, int), optional
1410        :param _request_auth: set to override the auth_settings for an a single
1411                              request; this effectively ignores the
1412                              authentication in the spec for a single request.
1413        :type _request_auth: dict, optional
1414        :param _content_type: force content-type for the request.
1415        :type _content_type: str, Optional
1416        :param _headers: set to override the headers for a single
1417                         request; this effectively ignores the headers
1418                         in the spec for a single request.
1419        :type _headers: dict, optional
1420        :param _host_index: set to override the host_index for a single
1421                            request; this effectively ignores the host_index
1422                            in the spec for a single request.
1423        :type _host_index: int, optional
1424        :return: Returns the result object.
1425        """ # noqa: E501
1426
1427        _param = self._get_source_connector_serialize(
1428            organization_id=organization_id,
1429            source_connector_id=source_connector_id,
1430            _request_auth=_request_auth,
1431            _content_type=_content_type,
1432            _headers=_headers,
1433            _host_index=_host_index
1434        )
1435
1436        _response_types_map: Dict[str, Optional[str]] = {
1437            '200': "SourceConnector",
1438            '400': "GetPipelines400Response",
1439            '401': "GetPipelines400Response",
1440            '403': "GetPipelines400Response",
1441            '404': "GetPipelines400Response",
1442            '500': "GetPipelines400Response",
1443        }
1444        response_data = self.api_client.call_api(
1445            *_param,
1446            _request_timeout=_request_timeout
1447        )
1448        response_data.read()
1449        return self.api_client.response_deserialize(
1450            response_data=response_data,
1451            response_types_map=_response_types_map,
1452        )
1453
1454
1455    @validate_call
1456    def get_source_connector_without_preload_content(
1457        self,
1458        organization_id: StrictStr,
1459        source_connector_id: StrictStr,
1460        _request_timeout: Union[
1461            None,
1462            Annotated[StrictFloat, Field(gt=0)],
1463            Tuple[
1464                Annotated[StrictFloat, Field(gt=0)],
1465                Annotated[StrictFloat, Field(gt=0)]
1466            ]
1467        ] = None,
1468        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1469        _content_type: Optional[StrictStr] = None,
1470        _headers: Optional[Dict[StrictStr, Any]] = None,
1471        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1472    ) -> RESTResponseType:
1473        """Get a source connector
1474
1475        Get a source connector
1476
1477        :param organization_id: (required)
1478        :type organization_id: str
1479        :param source_connector_id: (required)
1480        :type source_connector_id: str
1481        :param _request_timeout: timeout setting for this request. If one
1482                                 number provided, it will be total request
1483                                 timeout. It can also be a pair (tuple) of
1484                                 (connection, read) timeouts.
1485        :type _request_timeout: int, tuple(int, int), optional
1486        :param _request_auth: set to override the auth_settings for an a single
1487                              request; this effectively ignores the
1488                              authentication in the spec for a single request.
1489        :type _request_auth: dict, optional
1490        :param _content_type: force content-type for the request.
1491        :type _content_type: str, Optional
1492        :param _headers: set to override the headers for a single
1493                         request; this effectively ignores the headers
1494                         in the spec for a single request.
1495        :type _headers: dict, optional
1496        :param _host_index: set to override the host_index for a single
1497                            request; this effectively ignores the host_index
1498                            in the spec for a single request.
1499        :type _host_index: int, optional
1500        :return: Returns the result object.
1501        """ # noqa: E501
1502
1503        _param = self._get_source_connector_serialize(
1504            organization_id=organization_id,
1505            source_connector_id=source_connector_id,
1506            _request_auth=_request_auth,
1507            _content_type=_content_type,
1508            _headers=_headers,
1509            _host_index=_host_index
1510        )
1511
1512        _response_types_map: Dict[str, Optional[str]] = {
1513            '200': "SourceConnector",
1514            '400': "GetPipelines400Response",
1515            '401': "GetPipelines400Response",
1516            '403': "GetPipelines400Response",
1517            '404': "GetPipelines400Response",
1518            '500': "GetPipelines400Response",
1519        }
1520        response_data = self.api_client.call_api(
1521            *_param,
1522            _request_timeout=_request_timeout
1523        )
1524        return response_data.response
1525
1526
1527    def _get_source_connector_serialize(
1528        self,
1529        organization_id,
1530        source_connector_id,
1531        _request_auth,
1532        _content_type,
1533        _headers,
1534        _host_index,
1535    ) -> RequestSerialized:
1536
1537        _host = None
1538
1539        _collection_formats: Dict[str, str] = {
1540        }
1541
1542        _path_params: Dict[str, str] = {}
1543        _query_params: List[Tuple[str, str]] = []
1544        _header_params: Dict[str, Optional[str]] = _headers or {}
1545        _form_params: List[Tuple[str, str]] = []
1546        _files: Dict[
1547            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1548        ] = {}
1549        _body_params: Optional[bytes] = None
1550
1551        # process the path parameters
1552        if organization_id is not None:
1553            _path_params['organizationId'] = organization_id
1554        if source_connector_id is not None:
1555            _path_params['sourceConnectorId'] = source_connector_id
1556        # process the query parameters
1557        # process the header parameters
1558        # process the form parameters
1559        # process the body parameter
1560
1561
1562        # set the HTTP header `Accept`
1563        if 'Accept' not in _header_params:
1564            _header_params['Accept'] = self.api_client.select_header_accept(
1565                [
1566                    'application/json'
1567                ]
1568            )
1569
1570
1571        # authentication setting
1572        _auth_settings: List[str] = [
1573            'bearerAuth'
1574        ]
1575
1576        return self.api_client.param_serialize(
1577            method='GET',
1578            resource_path='/org/{organizationId}/connectors/sources/{sourceConnectorId}',
1579            path_params=_path_params,
1580            query_params=_query_params,
1581            header_params=_header_params,
1582            body=_body_params,
1583            post_params=_form_params,
1584            files=_files,
1585            auth_settings=_auth_settings,
1586            collection_formats=_collection_formats,
1587            _host=_host,
1588            _request_auth=_request_auth
1589        )
1590
1591
1592
1593
1594    @validate_call
1595    def get_source_connectors(
1596        self,
1597        organization_id: StrictStr,
1598        workspace_id: Optional[StrictStr] = None,
1599        _request_timeout: Union[
1600            None,
1601            Annotated[StrictFloat, Field(gt=0)],
1602            Tuple[
1603                Annotated[StrictFloat, Field(gt=0)],
1604                Annotated[StrictFloat, Field(gt=0)]
1605            ]
1606        ] = None,
1607        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1608        _content_type: Optional[StrictStr] = None,
1609        _headers: Optional[Dict[StrictStr, Any]] = None,
1610        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1611    ) -> GetSourceConnectors200Response:
1612        """Get all existing source connectors
1613
1614        Get all existing source connectors
1615
1616        :param organization_id: (required)
1617        :type organization_id: str
1618        :param workspace_id:
1619        :type workspace_id: str
1620        :param _request_timeout: timeout setting for this request. If one
1621                                 number provided, it will be total request
1622                                 timeout. It can also be a pair (tuple) of
1623                                 (connection, read) timeouts.
1624        :type _request_timeout: int, tuple(int, int), optional
1625        :param _request_auth: set to override the auth_settings for an a single
1626                              request; this effectively ignores the
1627                              authentication in the spec for a single request.
1628        :type _request_auth: dict, optional
1629        :param _content_type: force content-type for the request.
1630        :type _content_type: str, Optional
1631        :param _headers: set to override the headers for a single
1632                         request; this effectively ignores the headers
1633                         in the spec for a single request.
1634        :type _headers: dict, optional
1635        :param _host_index: set to override the host_index for a single
1636                            request; this effectively ignores the host_index
1637                            in the spec for a single request.
1638        :type _host_index: int, optional
1639        :return: Returns the result object.
1640        """ # noqa: E501
1641
1642        _param = self._get_source_connectors_serialize(
1643            organization_id=organization_id,
1644            workspace_id=workspace_id,
1645            _request_auth=_request_auth,
1646            _content_type=_content_type,
1647            _headers=_headers,
1648            _host_index=_host_index
1649        )
1650
1651        _response_types_map: Dict[str, Optional[str]] = {
1652            '200': "GetSourceConnectors200Response",
1653            '400': "GetPipelines400Response",
1654            '401': "GetPipelines400Response",
1655            '403': "GetPipelines400Response",
1656            '404': "GetPipelines400Response",
1657            '500': "GetPipelines400Response",
1658        }
1659        response_data = self.api_client.call_api(
1660            *_param,
1661            _request_timeout=_request_timeout
1662        )
1663        response_data.read()
1664        return self.api_client.response_deserialize(
1665            response_data=response_data,
1666            response_types_map=_response_types_map,
1667        ).data
1668
1669
1670    @validate_call
1671    def get_source_connectors_with_http_info(
1672        self,
1673        organization_id: StrictStr,
1674        workspace_id: Optional[StrictStr] = None,
1675        _request_timeout: Union[
1676            None,
1677            Annotated[StrictFloat, Field(gt=0)],
1678            Tuple[
1679                Annotated[StrictFloat, Field(gt=0)],
1680                Annotated[StrictFloat, Field(gt=0)]
1681            ]
1682        ] = None,
1683        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1684        _content_type: Optional[StrictStr] = None,
1685        _headers: Optional[Dict[StrictStr, Any]] = None,
1686        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1687    ) -> ApiResponse[GetSourceConnectors200Response]:
1688        """Get all existing source connectors
1689
1690        Get all existing source connectors
1691
1692        :param organization_id: (required)
1693        :type organization_id: str
1694        :param workspace_id:
1695        :type workspace_id: str
1696        :param _request_timeout: timeout setting for this request. If one
1697                                 number provided, it will be total request
1698                                 timeout. It can also be a pair (tuple) of
1699                                 (connection, read) timeouts.
1700        :type _request_timeout: int, tuple(int, int), optional
1701        :param _request_auth: set to override the auth_settings for an a single
1702                              request; this effectively ignores the
1703                              authentication in the spec for a single request.
1704        :type _request_auth: dict, optional
1705        :param _content_type: force content-type for the request.
1706        :type _content_type: str, Optional
1707        :param _headers: set to override the headers for a single
1708                         request; this effectively ignores the headers
1709                         in the spec for a single request.
1710        :type _headers: dict, optional
1711        :param _host_index: set to override the host_index for a single
1712                            request; this effectively ignores the host_index
1713                            in the spec for a single request.
1714        :type _host_index: int, optional
1715        :return: Returns the result object.
1716        """ # noqa: E501
1717
1718        _param = self._get_source_connectors_serialize(
1719            organization_id=organization_id,
1720            workspace_id=workspace_id,
1721            _request_auth=_request_auth,
1722            _content_type=_content_type,
1723            _headers=_headers,
1724            _host_index=_host_index
1725        )
1726
1727        _response_types_map: Dict[str, Optional[str]] = {
1728            '200': "GetSourceConnectors200Response",
1729            '400': "GetPipelines400Response",
1730            '401': "GetPipelines400Response",
1731            '403': "GetPipelines400Response",
1732            '404': "GetPipelines400Response",
1733            '500': "GetPipelines400Response",
1734        }
1735        response_data = self.api_client.call_api(
1736            *_param,
1737            _request_timeout=_request_timeout
1738        )
1739        response_data.read()
1740        return self.api_client.response_deserialize(
1741            response_data=response_data,
1742            response_types_map=_response_types_map,
1743        )
1744
1745
1746    @validate_call
1747    def get_source_connectors_without_preload_content(
1748        self,
1749        organization_id: StrictStr,
1750        workspace_id: Optional[StrictStr] = None,
1751        _request_timeout: Union[
1752            None,
1753            Annotated[StrictFloat, Field(gt=0)],
1754            Tuple[
1755                Annotated[StrictFloat, Field(gt=0)],
1756                Annotated[StrictFloat, Field(gt=0)]
1757            ]
1758        ] = None,
1759        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1760        _content_type: Optional[StrictStr] = None,
1761        _headers: Optional[Dict[StrictStr, Any]] = None,
1762        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1763    ) -> RESTResponseType:
1764        """Get all existing source connectors
1765
1766        Get all existing source connectors
1767
1768        :param organization_id: (required)
1769        :type organization_id: str
1770        :param workspace_id:
1771        :type workspace_id: str
1772        :param _request_timeout: timeout setting for this request. If one
1773                                 number provided, it will be total request
1774                                 timeout. It can also be a pair (tuple) of
1775                                 (connection, read) timeouts.
1776        :type _request_timeout: int, tuple(int, int), optional
1777        :param _request_auth: set to override the auth_settings for an a single
1778                              request; this effectively ignores the
1779                              authentication in the spec for a single request.
1780        :type _request_auth: dict, optional
1781        :param _content_type: force content-type for the request.
1782        :type _content_type: str, Optional
1783        :param _headers: set to override the headers for a single
1784                         request; this effectively ignores the headers
1785                         in the spec for a single request.
1786        :type _headers: dict, optional
1787        :param _host_index: set to override the host_index for a single
1788                            request; this effectively ignores the host_index
1789                            in the spec for a single request.
1790        :type _host_index: int, optional
1791        :return: Returns the result object.
1792        """ # noqa: E501
1793
1794        _param = self._get_source_connectors_serialize(
1795            organization_id=organization_id,
1796            workspace_id=workspace_id,
1797            _request_auth=_request_auth,
1798            _content_type=_content_type,
1799            _headers=_headers,
1800            _host_index=_host_index
1801        )
1802
1803        _response_types_map: Dict[str, Optional[str]] = {
1804            '200': "GetSourceConnectors200Response",
1805            '400': "GetPipelines400Response",
1806            '401': "GetPipelines400Response",
1807            '403': "GetPipelines400Response",
1808            '404': "GetPipelines400Response",
1809            '500': "GetPipelines400Response",
1810        }
1811        response_data = self.api_client.call_api(
1812            *_param,
1813            _request_timeout=_request_timeout
1814        )
1815        return response_data.response
1816
1817
1818    def _get_source_connectors_serialize(
1819        self,
1820        organization_id,
1821        workspace_id,
1822        _request_auth,
1823        _content_type,
1824        _headers,
1825        _host_index,
1826    ) -> RequestSerialized:
1827
1828        _host = None
1829
1830        _collection_formats: Dict[str, str] = {
1831        }
1832
1833        _path_params: Dict[str, str] = {}
1834        _query_params: List[Tuple[str, str]] = []
1835        _header_params: Dict[str, Optional[str]] = _headers or {}
1836        _form_params: List[Tuple[str, str]] = []
1837        _files: Dict[
1838            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1839        ] = {}
1840        _body_params: Optional[bytes] = None
1841
1842        # process the path parameters
1843        if organization_id is not None:
1844            _path_params['organizationId'] = organization_id
1845        # process the query parameters
1846        if workspace_id is not None:
1847            
1848            _query_params.append(('workspaceId', workspace_id))
1849            
1850        # process the header parameters
1851        # process the form parameters
1852        # process the body parameter
1853
1854
1855        # set the HTTP header `Accept`
1856        if 'Accept' not in _header_params:
1857            _header_params['Accept'] = self.api_client.select_header_accept(
1858                [
1859                    'application/json'
1860                ]
1861            )
1862
1863
1864        # authentication setting
1865        _auth_settings: List[str] = [
1866            'bearerAuth'
1867        ]
1868
1869        return self.api_client.param_serialize(
1870            method='GET',
1871            resource_path='/org/{organizationId}/connectors/sources',
1872            path_params=_path_params,
1873            query_params=_query_params,
1874            header_params=_header_params,
1875            body=_body_params,
1876            post_params=_form_params,
1877            files=_files,
1878            auth_settings=_auth_settings,
1879            collection_formats=_collection_formats,
1880            _host=_host,
1881            _request_auth=_request_auth
1882        )
1883
1884
1885
1886
1887    @validate_call
1888    def update_source_connector(
1889        self,
1890        organization_id: StrictStr,
1891        source_connector_id: StrictStr,
1892        update_source_connector_request: UpdateSourceConnectorRequest,
1893        _request_timeout: Union[
1894            None,
1895            Annotated[StrictFloat, Field(gt=0)],
1896            Tuple[
1897                Annotated[StrictFloat, Field(gt=0)],
1898                Annotated[StrictFloat, Field(gt=0)]
1899            ]
1900        ] = None,
1901        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1902        _content_type: Optional[StrictStr] = None,
1903        _headers: Optional[Dict[StrictStr, Any]] = None,
1904        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1905    ) -> UpdateSourceConnectorResponse:
1906        """Update a source connector
1907
1908        Update a source connector
1909
1910        :param organization_id: (required)
1911        :type organization_id: str
1912        :param source_connector_id: (required)
1913        :type source_connector_id: str
1914        :param update_source_connector_request: (required)
1915        :type update_source_connector_request: UpdateSourceConnectorRequest
1916        :param _request_timeout: timeout setting for this request. If one
1917                                 number provided, it will be total request
1918                                 timeout. It can also be a pair (tuple) of
1919                                 (connection, read) timeouts.
1920        :type _request_timeout: int, tuple(int, int), optional
1921        :param _request_auth: set to override the auth_settings for an a single
1922                              request; this effectively ignores the
1923                              authentication in the spec for a single request.
1924        :type _request_auth: dict, optional
1925        :param _content_type: force content-type for the request.
1926        :type _content_type: str, Optional
1927        :param _headers: set to override the headers for a single
1928                         request; this effectively ignores the headers
1929                         in the spec for a single request.
1930        :type _headers: dict, optional
1931        :param _host_index: set to override the host_index for a single
1932                            request; this effectively ignores the host_index
1933                            in the spec for a single request.
1934        :type _host_index: int, optional
1935        :return: Returns the result object.
1936        """ # noqa: E501
1937
1938        _param = self._update_source_connector_serialize(
1939            organization_id=organization_id,
1940            source_connector_id=source_connector_id,
1941            update_source_connector_request=update_source_connector_request,
1942            _request_auth=_request_auth,
1943            _content_type=_content_type,
1944            _headers=_headers,
1945            _host_index=_host_index
1946        )
1947
1948        _response_types_map: Dict[str, Optional[str]] = {
1949            '200': "UpdateSourceConnectorResponse",
1950            '400': "GetPipelines400Response",
1951            '401': "GetPipelines400Response",
1952            '403': "GetPipelines400Response",
1953            '404': "GetPipelines400Response",
1954            '500': "GetPipelines400Response",
1955        }
1956        response_data = self.api_client.call_api(
1957            *_param,
1958            _request_timeout=_request_timeout
1959        )
1960        response_data.read()
1961        return self.api_client.response_deserialize(
1962            response_data=response_data,
1963            response_types_map=_response_types_map,
1964        ).data
1965
1966
1967    @validate_call
1968    def update_source_connector_with_http_info(
1969        self,
1970        organization_id: StrictStr,
1971        source_connector_id: StrictStr,
1972        update_source_connector_request: UpdateSourceConnectorRequest,
1973        _request_timeout: Union[
1974            None,
1975            Annotated[StrictFloat, Field(gt=0)],
1976            Tuple[
1977                Annotated[StrictFloat, Field(gt=0)],
1978                Annotated[StrictFloat, Field(gt=0)]
1979            ]
1980        ] = None,
1981        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1982        _content_type: Optional[StrictStr] = None,
1983        _headers: Optional[Dict[StrictStr, Any]] = None,
1984        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1985    ) -> ApiResponse[UpdateSourceConnectorResponse]:
1986        """Update a source connector
1987
1988        Update a source connector
1989
1990        :param organization_id: (required)
1991        :type organization_id: str
1992        :param source_connector_id: (required)
1993        :type source_connector_id: str
1994        :param update_source_connector_request: (required)
1995        :type update_source_connector_request: UpdateSourceConnectorRequest
1996        :param _request_timeout: timeout setting for this request. If one
1997                                 number provided, it will be total request
1998                                 timeout. It can also be a pair (tuple) of
1999                                 (connection, read) timeouts.
2000        :type _request_timeout: int, tuple(int, int), optional
2001        :param _request_auth: set to override the auth_settings for an a single
2002                              request; this effectively ignores the
2003                              authentication in the spec for a single request.
2004        :type _request_auth: dict, optional
2005        :param _content_type: force content-type for the request.
2006        :type _content_type: str, Optional
2007        :param _headers: set to override the headers for a single
2008                         request; this effectively ignores the headers
2009                         in the spec for a single request.
2010        :type _headers: dict, optional
2011        :param _host_index: set to override the host_index for a single
2012                            request; this effectively ignores the host_index
2013                            in the spec for a single request.
2014        :type _host_index: int, optional
2015        :return: Returns the result object.
2016        """ # noqa: E501
2017
2018        _param = self._update_source_connector_serialize(
2019            organization_id=organization_id,
2020            source_connector_id=source_connector_id,
2021            update_source_connector_request=update_source_connector_request,
2022            _request_auth=_request_auth,
2023            _content_type=_content_type,
2024            _headers=_headers,
2025            _host_index=_host_index
2026        )
2027
2028        _response_types_map: Dict[str, Optional[str]] = {
2029            '200': "UpdateSourceConnectorResponse",
2030            '400': "GetPipelines400Response",
2031            '401': "GetPipelines400Response",
2032            '403': "GetPipelines400Response",
2033            '404': "GetPipelines400Response",
2034            '500': "GetPipelines400Response",
2035        }
2036        response_data = self.api_client.call_api(
2037            *_param,
2038            _request_timeout=_request_timeout
2039        )
2040        response_data.read()
2041        return self.api_client.response_deserialize(
2042            response_data=response_data,
2043            response_types_map=_response_types_map,
2044        )
2045
2046
2047    @validate_call
2048    def update_source_connector_without_preload_content(
2049        self,
2050        organization_id: StrictStr,
2051        source_connector_id: StrictStr,
2052        update_source_connector_request: UpdateSourceConnectorRequest,
2053        _request_timeout: Union[
2054            None,
2055            Annotated[StrictFloat, Field(gt=0)],
2056            Tuple[
2057                Annotated[StrictFloat, Field(gt=0)],
2058                Annotated[StrictFloat, Field(gt=0)]
2059            ]
2060        ] = None,
2061        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2062        _content_type: Optional[StrictStr] = None,
2063        _headers: Optional[Dict[StrictStr, Any]] = None,
2064        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2065    ) -> RESTResponseType:
2066        """Update a source connector
2067
2068        Update a source connector
2069
2070        :param organization_id: (required)
2071        :type organization_id: str
2072        :param source_connector_id: (required)
2073        :type source_connector_id: str
2074        :param update_source_connector_request: (required)
2075        :type update_source_connector_request: UpdateSourceConnectorRequest
2076        :param _request_timeout: timeout setting for this request. If one
2077                                 number provided, it will be total request
2078                                 timeout. It can also be a pair (tuple) of
2079                                 (connection, read) timeouts.
2080        :type _request_timeout: int, tuple(int, int), optional
2081        :param _request_auth: set to override the auth_settings for an a single
2082                              request; this effectively ignores the
2083                              authentication in the spec for a single request.
2084        :type _request_auth: dict, optional
2085        :param _content_type: force content-type for the request.
2086        :type _content_type: str, Optional
2087        :param _headers: set to override the headers for a single
2088                         request; this effectively ignores the headers
2089                         in the spec for a single request.
2090        :type _headers: dict, optional
2091        :param _host_index: set to override the host_index for a single
2092                            request; this effectively ignores the host_index
2093                            in the spec for a single request.
2094        :type _host_index: int, optional
2095        :return: Returns the result object.
2096        """ # noqa: E501
2097
2098        _param = self._update_source_connector_serialize(
2099            organization_id=organization_id,
2100            source_connector_id=source_connector_id,
2101            update_source_connector_request=update_source_connector_request,
2102            _request_auth=_request_auth,
2103            _content_type=_content_type,
2104            _headers=_headers,
2105            _host_index=_host_index
2106        )
2107
2108        _response_types_map: Dict[str, Optional[str]] = {
2109            '200': "UpdateSourceConnectorResponse",
2110            '400': "GetPipelines400Response",
2111            '401': "GetPipelines400Response",
2112            '403': "GetPipelines400Response",
2113            '404': "GetPipelines400Response",
2114            '500': "GetPipelines400Response",
2115        }
2116        response_data = self.api_client.call_api(
2117            *_param,
2118            _request_timeout=_request_timeout
2119        )
2120        return response_data.response
2121
2122
2123    def _update_source_connector_serialize(
2124        self,
2125        organization_id,
2126        source_connector_id,
2127        update_source_connector_request,
2128        _request_auth,
2129        _content_type,
2130        _headers,
2131        _host_index,
2132    ) -> RequestSerialized:
2133
2134        _host = None
2135
2136        _collection_formats: Dict[str, str] = {
2137        }
2138
2139        _path_params: Dict[str, str] = {}
2140        _query_params: List[Tuple[str, str]] = []
2141        _header_params: Dict[str, Optional[str]] = _headers or {}
2142        _form_params: List[Tuple[str, str]] = []
2143        _files: Dict[
2144            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
2145        ] = {}
2146        _body_params: Optional[bytes] = None
2147
2148        # process the path parameters
2149        if organization_id is not None:
2150            _path_params['organizationId'] = organization_id
2151        if source_connector_id is not None:
2152            _path_params['sourceConnectorId'] = source_connector_id
2153        # process the query parameters
2154        # process the header parameters
2155        # process the form parameters
2156        # process the body parameter
2157        if update_source_connector_request is not None:
2158            _body_params = update_source_connector_request
2159
2160
2161        # set the HTTP header `Accept`
2162        if 'Accept' not in _header_params:
2163            _header_params['Accept'] = self.api_client.select_header_accept(
2164                [
2165                    'application/json'
2166                ]
2167            )
2168
2169        # set the HTTP header `Content-Type`
2170        if _content_type:
2171            _header_params['Content-Type'] = _content_type
2172        else:
2173            _default_content_type = (
2174                self.api_client.select_header_content_type(
2175                    [
2176                        'application/json'
2177                    ]
2178                )
2179            )
2180            if _default_content_type is not None:
2181                _header_params['Content-Type'] = _default_content_type
2182
2183        # authentication setting
2184        _auth_settings: List[str] = [
2185            'bearerAuth'
2186        ]
2187
2188        return self.api_client.param_serialize(
2189            method='PATCH',
2190            resource_path='/org/{organizationId}/connectors/sources/{sourceConnectorId}',
2191            path_params=_path_params,
2192            query_params=_query_params,
2193            header_params=_header_params,
2194            body=_body_params,
2195            post_params=_form_params,
2196            files=_files,
2197            auth_settings=_auth_settings,
2198            collection_formats=_collection_formats,
2199            _host=_host,
2200            _request_auth=_request_auth
2201        )
2202
2203
2204
2205
2206    @validate_call
2207    def update_user_in_source_connector(
2208        self,
2209        organization_id: StrictStr,
2210        source_connector_id: StrictStr,
2211        update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest,
2212        _request_timeout: Union[
2213            None,
2214            Annotated[StrictFloat, Field(gt=0)],
2215            Tuple[
2216                Annotated[StrictFloat, Field(gt=0)],
2217                Annotated[StrictFloat, Field(gt=0)]
2218            ]
2219        ] = None,
2220        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2221        _content_type: Optional[StrictStr] = None,
2222        _headers: Optional[Dict[StrictStr, Any]] = None,
2223        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2224    ) -> UpdateUserInSourceConnectorResponse:
2225        """Update a source connector user
2226
2227        Update a source connector user
2228
2229        :param organization_id: (required)
2230        :type organization_id: str
2231        :param source_connector_id: (required)
2232        :type source_connector_id: str
2233        :param update_user_in_source_connector_request: (required)
2234        :type update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest
2235        :param _request_timeout: timeout setting for this request. If one
2236                                 number provided, it will be total request
2237                                 timeout. It can also be a pair (tuple) of
2238                                 (connection, read) timeouts.
2239        :type _request_timeout: int, tuple(int, int), optional
2240        :param _request_auth: set to override the auth_settings for an a single
2241                              request; this effectively ignores the
2242                              authentication in the spec for a single request.
2243        :type _request_auth: dict, optional
2244        :param _content_type: force content-type for the request.
2245        :type _content_type: str, Optional
2246        :param _headers: set to override the headers for a single
2247                         request; this effectively ignores the headers
2248                         in the spec for a single request.
2249        :type _headers: dict, optional
2250        :param _host_index: set to override the host_index for a single
2251                            request; this effectively ignores the host_index
2252                            in the spec for a single request.
2253        :type _host_index: int, optional
2254        :return: Returns the result object.
2255        """ # noqa: E501
2256
2257        _param = self._update_user_in_source_connector_serialize(
2258            organization_id=organization_id,
2259            source_connector_id=source_connector_id,
2260            update_user_in_source_connector_request=update_user_in_source_connector_request,
2261            _request_auth=_request_auth,
2262            _content_type=_content_type,
2263            _headers=_headers,
2264            _host_index=_host_index
2265        )
2266
2267        _response_types_map: Dict[str, Optional[str]] = {
2268            '200': "UpdateUserInSourceConnectorResponse",
2269            '400': "GetPipelines400Response",
2270            '401': "GetPipelines400Response",
2271            '403': "GetPipelines400Response",
2272            '404': "GetPipelines400Response",
2273            '500': "GetPipelines400Response",
2274        }
2275        response_data = self.api_client.call_api(
2276            *_param,
2277            _request_timeout=_request_timeout
2278        )
2279        response_data.read()
2280        return self.api_client.response_deserialize(
2281            response_data=response_data,
2282            response_types_map=_response_types_map,
2283        ).data
2284
2285
2286    @validate_call
2287    def update_user_in_source_connector_with_http_info(
2288        self,
2289        organization_id: StrictStr,
2290        source_connector_id: StrictStr,
2291        update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest,
2292        _request_timeout: Union[
2293            None,
2294            Annotated[StrictFloat, Field(gt=0)],
2295            Tuple[
2296                Annotated[StrictFloat, Field(gt=0)],
2297                Annotated[StrictFloat, Field(gt=0)]
2298            ]
2299        ] = None,
2300        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2301        _content_type: Optional[StrictStr] = None,
2302        _headers: Optional[Dict[StrictStr, Any]] = None,
2303        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2304    ) -> ApiResponse[UpdateUserInSourceConnectorResponse]:
2305        """Update a source connector user
2306
2307        Update a source connector user
2308
2309        :param organization_id: (required)
2310        :type organization_id: str
2311        :param source_connector_id: (required)
2312        :type source_connector_id: str
2313        :param update_user_in_source_connector_request: (required)
2314        :type update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest
2315        :param _request_timeout: timeout setting for this request. If one
2316                                 number provided, it will be total request
2317                                 timeout. It can also be a pair (tuple) of
2318                                 (connection, read) timeouts.
2319        :type _request_timeout: int, tuple(int, int), optional
2320        :param _request_auth: set to override the auth_settings for an a single
2321                              request; this effectively ignores the
2322                              authentication in the spec for a single request.
2323        :type _request_auth: dict, optional
2324        :param _content_type: force content-type for the request.
2325        :type _content_type: str, Optional
2326        :param _headers: set to override the headers for a single
2327                         request; this effectively ignores the headers
2328                         in the spec for a single request.
2329        :type _headers: dict, optional
2330        :param _host_index: set to override the host_index for a single
2331                            request; this effectively ignores the host_index
2332                            in the spec for a single request.
2333        :type _host_index: int, optional
2334        :return: Returns the result object.
2335        """ # noqa: E501
2336
2337        _param = self._update_user_in_source_connector_serialize(
2338            organization_id=organization_id,
2339            source_connector_id=source_connector_id,
2340            update_user_in_source_connector_request=update_user_in_source_connector_request,
2341            _request_auth=_request_auth,
2342            _content_type=_content_type,
2343            _headers=_headers,
2344            _host_index=_host_index
2345        )
2346
2347        _response_types_map: Dict[str, Optional[str]] = {
2348            '200': "UpdateUserInSourceConnectorResponse",
2349            '400': "GetPipelines400Response",
2350            '401': "GetPipelines400Response",
2351            '403': "GetPipelines400Response",
2352            '404': "GetPipelines400Response",
2353            '500': "GetPipelines400Response",
2354        }
2355        response_data = self.api_client.call_api(
2356            *_param,
2357            _request_timeout=_request_timeout
2358        )
2359        response_data.read()
2360        return self.api_client.response_deserialize(
2361            response_data=response_data,
2362            response_types_map=_response_types_map,
2363        )
2364
2365
2366    @validate_call
2367    def update_user_in_source_connector_without_preload_content(
2368        self,
2369        organization_id: StrictStr,
2370        source_connector_id: StrictStr,
2371        update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest,
2372        _request_timeout: Union[
2373            None,
2374            Annotated[StrictFloat, Field(gt=0)],
2375            Tuple[
2376                Annotated[StrictFloat, Field(gt=0)],
2377                Annotated[StrictFloat, Field(gt=0)]
2378            ]
2379        ] = None,
2380        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2381        _content_type: Optional[StrictStr] = None,
2382        _headers: Optional[Dict[StrictStr, Any]] = None,
2383        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2384    ) -> RESTResponseType:
2385        """Update a source connector user
2386
2387        Update a source connector user
2388
2389        :param organization_id: (required)
2390        :type organization_id: str
2391        :param source_connector_id: (required)
2392        :type source_connector_id: str
2393        :param update_user_in_source_connector_request: (required)
2394        :type update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest
2395        :param _request_timeout: timeout setting for this request. If one
2396                                 number provided, it will be total request
2397                                 timeout. It can also be a pair (tuple) of
2398                                 (connection, read) timeouts.
2399        :type _request_timeout: int, tuple(int, int), optional
2400        :param _request_auth: set to override the auth_settings for an a single
2401                              request; this effectively ignores the
2402                              authentication in the spec for a single request.
2403        :type _request_auth: dict, optional
2404        :param _content_type: force content-type for the request.
2405        :type _content_type: str, Optional
2406        :param _headers: set to override the headers for a single
2407                         request; this effectively ignores the headers
2408                         in the spec for a single request.
2409        :type _headers: dict, optional
2410        :param _host_index: set to override the host_index for a single
2411                            request; this effectively ignores the host_index
2412                            in the spec for a single request.
2413        :type _host_index: int, optional
2414        :return: Returns the result object.
2415        """ # noqa: E501
2416
2417        _param = self._update_user_in_source_connector_serialize(
2418            organization_id=organization_id,
2419            source_connector_id=source_connector_id,
2420            update_user_in_source_connector_request=update_user_in_source_connector_request,
2421            _request_auth=_request_auth,
2422            _content_type=_content_type,
2423            _headers=_headers,
2424            _host_index=_host_index
2425        )
2426
2427        _response_types_map: Dict[str, Optional[str]] = {
2428            '200': "UpdateUserInSourceConnectorResponse",
2429            '400': "GetPipelines400Response",
2430            '401': "GetPipelines400Response",
2431            '403': "GetPipelines400Response",
2432            '404': "GetPipelines400Response",
2433            '500': "GetPipelines400Response",
2434        }
2435        response_data = self.api_client.call_api(
2436            *_param,
2437            _request_timeout=_request_timeout
2438        )
2439        return response_data.response
2440
2441
2442    def _update_user_in_source_connector_serialize(
2443        self,
2444        organization_id,
2445        source_connector_id,
2446        update_user_in_source_connector_request,
2447        _request_auth,
2448        _content_type,
2449        _headers,
2450        _host_index,
2451    ) -> RequestSerialized:
2452
2453        _host = None
2454
2455        _collection_formats: Dict[str, str] = {
2456        }
2457
2458        _path_params: Dict[str, str] = {}
2459        _query_params: List[Tuple[str, str]] = []
2460        _header_params: Dict[str, Optional[str]] = _headers or {}
2461        _form_params: List[Tuple[str, str]] = []
2462        _files: Dict[
2463            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
2464        ] = {}
2465        _body_params: Optional[bytes] = None
2466
2467        # process the path parameters
2468        if organization_id is not None:
2469            _path_params['organizationId'] = organization_id
2470        if source_connector_id is not None:
2471            _path_params['sourceConnectorId'] = source_connector_id
2472        # process the query parameters
2473        # process the header parameters
2474        # process the form parameters
2475        # process the body parameter
2476        if update_user_in_source_connector_request is not None:
2477            _body_params = update_user_in_source_connector_request
2478
2479
2480        # set the HTTP header `Accept`
2481        if 'Accept' not in _header_params:
2482            _header_params['Accept'] = self.api_client.select_header_accept(
2483                [
2484                    'application/json'
2485                ]
2486            )
2487
2488        # set the HTTP header `Content-Type`
2489        if _content_type:
2490            _header_params['Content-Type'] = _content_type
2491        else:
2492            _default_content_type = (
2493                self.api_client.select_header_content_type(
2494                    [
2495                        'application/json'
2496                    ]
2497                )
2498            )
2499            if _default_content_type is not None:
2500                _header_params['Content-Type'] = _default_content_type
2501
2502        # authentication setting
2503        _auth_settings: List[str] = [
2504            'bearerAuth'
2505        ]
2506
2507        return self.api_client.param_serialize(
2508            method='PATCH',
2509            resource_path='/org/{organizationId}/connectors/sources/{sourceConnectorId}/users',
2510            path_params=_path_params,
2511            query_params=_query_params,
2512            header_params=_header_params,
2513            body=_body_params,
2514            post_params=_form_params,
2515            files=_files,
2516            auth_settings=_auth_settings,
2517            collection_formats=_collection_formats,
2518            _host=_host,
2519            _request_auth=_request_auth
2520        )
class SourceConnectorsApi:
  41class SourceConnectorsApi:
  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 add_user_to_source_connector(
  56        self,
  57        organization_id: StrictStr,
  58        source_connector_id: StrictStr,
  59        add_user_to_source_connector_request: AddUserToSourceConnectorRequest,
  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    ) -> AddUserFromSourceConnectorResponse:
  73        """Add a user to a source connector
  74
  75        Add a user to a source connector
  76
  77        :param organization_id: (required)
  78        :type organization_id: str
  79        :param source_connector_id: (required)
  80        :type source_connector_id: str
  81        :param add_user_to_source_connector_request: (required)
  82        :type add_user_to_source_connector_request: AddUserToSourceConnectorRequest
  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._add_user_to_source_connector_serialize(
 106            organization_id=organization_id,
 107            source_connector_id=source_connector_id,
 108            add_user_to_source_connector_request=add_user_to_source_connector_request,
 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': "AddUserFromSourceConnectorResponse",
 117            '400': "GetPipelines400Response",
 118            '401': "GetPipelines400Response",
 119            '403': "GetPipelines400Response",
 120            '404': "GetPipelines400Response",
 121            '500': "GetPipelines400Response",
 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 add_user_to_source_connector_with_http_info(
 136        self,
 137        organization_id: StrictStr,
 138        source_connector_id: StrictStr,
 139        add_user_to_source_connector_request: AddUserToSourceConnectorRequest,
 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[AddUserFromSourceConnectorResponse]:
 153        """Add a user to a source connector
 154
 155        Add a user to a source connector
 156
 157        :param organization_id: (required)
 158        :type organization_id: str
 159        :param source_connector_id: (required)
 160        :type source_connector_id: str
 161        :param add_user_to_source_connector_request: (required)
 162        :type add_user_to_source_connector_request: AddUserToSourceConnectorRequest
 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._add_user_to_source_connector_serialize(
 186            organization_id=organization_id,
 187            source_connector_id=source_connector_id,
 188            add_user_to_source_connector_request=add_user_to_source_connector_request,
 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': "AddUserFromSourceConnectorResponse",
 197            '400': "GetPipelines400Response",
 198            '401': "GetPipelines400Response",
 199            '403': "GetPipelines400Response",
 200            '404': "GetPipelines400Response",
 201            '500': "GetPipelines400Response",
 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 add_user_to_source_connector_without_preload_content(
 216        self,
 217        organization_id: StrictStr,
 218        source_connector_id: StrictStr,
 219        add_user_to_source_connector_request: AddUserToSourceConnectorRequest,
 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        """Add a user to a source connector
 234
 235        Add a user to a source connector
 236
 237        :param organization_id: (required)
 238        :type organization_id: str
 239        :param source_connector_id: (required)
 240        :type source_connector_id: str
 241        :param add_user_to_source_connector_request: (required)
 242        :type add_user_to_source_connector_request: AddUserToSourceConnectorRequest
 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._add_user_to_source_connector_serialize(
 266            organization_id=organization_id,
 267            source_connector_id=source_connector_id,
 268            add_user_to_source_connector_request=add_user_to_source_connector_request,
 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': "AddUserFromSourceConnectorResponse",
 277            '400': "GetPipelines400Response",
 278            '401': "GetPipelines400Response",
 279            '403': "GetPipelines400Response",
 280            '404': "GetPipelines400Response",
 281            '500': "GetPipelines400Response",
 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 _add_user_to_source_connector_serialize(
 291        self,
 292        organization_id,
 293        source_connector_id,
 294        add_user_to_source_connector_request,
 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        if source_connector_id is not None:
 319            _path_params['sourceConnectorId'] = source_connector_id
 320        # process the query parameters
 321        # process the header parameters
 322        # process the form parameters
 323        # process the body parameter
 324        if add_user_to_source_connector_request is not None:
 325            _body_params = add_user_to_source_connector_request
 326
 327
 328        # set the HTTP header `Accept`
 329        if 'Accept' not in _header_params:
 330            _header_params['Accept'] = self.api_client.select_header_accept(
 331                [
 332                    'application/json'
 333                ]
 334            )
 335
 336        # set the HTTP header `Content-Type`
 337        if _content_type:
 338            _header_params['Content-Type'] = _content_type
 339        else:
 340            _default_content_type = (
 341                self.api_client.select_header_content_type(
 342                    [
 343                        'application/json'
 344                    ]
 345                )
 346            )
 347            if _default_content_type is not None:
 348                _header_params['Content-Type'] = _default_content_type
 349
 350        # authentication setting
 351        _auth_settings: List[str] = [
 352            'bearerAuth'
 353        ]
 354
 355        return self.api_client.param_serialize(
 356            method='POST',
 357            resource_path='/org/{organizationId}/connectors/sources/{sourceConnectorId}/users',
 358            path_params=_path_params,
 359            query_params=_query_params,
 360            header_params=_header_params,
 361            body=_body_params,
 362            post_params=_form_params,
 363            files=_files,
 364            auth_settings=_auth_settings,
 365            collection_formats=_collection_formats,
 366            _host=_host,
 367            _request_auth=_request_auth
 368        )
 369
 370
 371
 372
 373    @validate_call
 374    def create_source_connector(
 375        self,
 376        organization_id: StrictStr,
 377        create_source_connector_request: CreateSourceConnectorRequest,
 378        workspace_id: Optional[StrictStr] = None,
 379        _request_timeout: Union[
 380            None,
 381            Annotated[StrictFloat, Field(gt=0)],
 382            Tuple[
 383                Annotated[StrictFloat, Field(gt=0)],
 384                Annotated[StrictFloat, Field(gt=0)]
 385            ]
 386        ] = None,
 387        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 388        _content_type: Optional[StrictStr] = None,
 389        _headers: Optional[Dict[StrictStr, Any]] = None,
 390        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 391    ) -> CreateSourceConnectorResponse:
 392        """Create a new source connector
 393
 394        Creates a new source connector for data ingestion. The specific configuration fields required depend on the connector type selected.
 395
 396        :param organization_id: (required)
 397        :type organization_id: str
 398        :param create_source_connector_request: (required)
 399        :type create_source_connector_request: CreateSourceConnectorRequest
 400        :param workspace_id:
 401        :type workspace_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._create_source_connector_serialize(
 425            organization_id=organization_id,
 426            create_source_connector_request=create_source_connector_request,
 427            workspace_id=workspace_id,
 428            _request_auth=_request_auth,
 429            _content_type=_content_type,
 430            _headers=_headers,
 431            _host_index=_host_index
 432        )
 433
 434        _response_types_map: Dict[str, Optional[str]] = {
 435            '200': "CreateSourceConnectorResponse",
 436            '400': "GetPipelines400Response",
 437            '401': "GetPipelines400Response",
 438            '403': "GetPipelines400Response",
 439            '404': "GetPipelines400Response",
 440            '500': "GetPipelines400Response",
 441        }
 442        response_data = self.api_client.call_api(
 443            *_param,
 444            _request_timeout=_request_timeout
 445        )
 446        response_data.read()
 447        return self.api_client.response_deserialize(
 448            response_data=response_data,
 449            response_types_map=_response_types_map,
 450        ).data
 451
 452
 453    @validate_call
 454    def create_source_connector_with_http_info(
 455        self,
 456        organization_id: StrictStr,
 457        create_source_connector_request: CreateSourceConnectorRequest,
 458        workspace_id: Optional[StrictStr] = None,
 459        _request_timeout: Union[
 460            None,
 461            Annotated[StrictFloat, Field(gt=0)],
 462            Tuple[
 463                Annotated[StrictFloat, Field(gt=0)],
 464                Annotated[StrictFloat, Field(gt=0)]
 465            ]
 466        ] = None,
 467        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 468        _content_type: Optional[StrictStr] = None,
 469        _headers: Optional[Dict[StrictStr, Any]] = None,
 470        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 471    ) -> ApiResponse[CreateSourceConnectorResponse]:
 472        """Create a new source connector
 473
 474        Creates a new source connector for data ingestion. The specific configuration fields required depend on the connector type selected.
 475
 476        :param organization_id: (required)
 477        :type organization_id: str
 478        :param create_source_connector_request: (required)
 479        :type create_source_connector_request: CreateSourceConnectorRequest
 480        :param workspace_id:
 481        :type workspace_id: str
 482        :param _request_timeout: timeout setting for this request. If one
 483                                 number provided, it will be total request
 484                                 timeout. It can also be a pair (tuple) of
 485                                 (connection, read) timeouts.
 486        :type _request_timeout: int, tuple(int, int), optional
 487        :param _request_auth: set to override the auth_settings for an a single
 488                              request; this effectively ignores the
 489                              authentication in the spec for a single request.
 490        :type _request_auth: dict, optional
 491        :param _content_type: force content-type for the request.
 492        :type _content_type: str, Optional
 493        :param _headers: set to override the headers for a single
 494                         request; this effectively ignores the headers
 495                         in the spec for a single request.
 496        :type _headers: dict, optional
 497        :param _host_index: set to override the host_index for a single
 498                            request; this effectively ignores the host_index
 499                            in the spec for a single request.
 500        :type _host_index: int, optional
 501        :return: Returns the result object.
 502        """ # noqa: E501
 503
 504        _param = self._create_source_connector_serialize(
 505            organization_id=organization_id,
 506            create_source_connector_request=create_source_connector_request,
 507            workspace_id=workspace_id,
 508            _request_auth=_request_auth,
 509            _content_type=_content_type,
 510            _headers=_headers,
 511            _host_index=_host_index
 512        )
 513
 514        _response_types_map: Dict[str, Optional[str]] = {
 515            '200': "CreateSourceConnectorResponse",
 516            '400': "GetPipelines400Response",
 517            '401': "GetPipelines400Response",
 518            '403': "GetPipelines400Response",
 519            '404': "GetPipelines400Response",
 520            '500': "GetPipelines400Response",
 521        }
 522        response_data = self.api_client.call_api(
 523            *_param,
 524            _request_timeout=_request_timeout
 525        )
 526        response_data.read()
 527        return self.api_client.response_deserialize(
 528            response_data=response_data,
 529            response_types_map=_response_types_map,
 530        )
 531
 532
 533    @validate_call
 534    def create_source_connector_without_preload_content(
 535        self,
 536        organization_id: StrictStr,
 537        create_source_connector_request: CreateSourceConnectorRequest,
 538        workspace_id: Optional[StrictStr] = None,
 539        _request_timeout: Union[
 540            None,
 541            Annotated[StrictFloat, Field(gt=0)],
 542            Tuple[
 543                Annotated[StrictFloat, Field(gt=0)],
 544                Annotated[StrictFloat, Field(gt=0)]
 545            ]
 546        ] = None,
 547        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 548        _content_type: Optional[StrictStr] = None,
 549        _headers: Optional[Dict[StrictStr, Any]] = None,
 550        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 551    ) -> RESTResponseType:
 552        """Create a new source connector
 553
 554        Creates a new source connector for data ingestion. The specific configuration fields required depend on the connector type selected.
 555
 556        :param organization_id: (required)
 557        :type organization_id: str
 558        :param create_source_connector_request: (required)
 559        :type create_source_connector_request: CreateSourceConnectorRequest
 560        :param workspace_id:
 561        :type workspace_id: str
 562        :param _request_timeout: timeout setting for this request. If one
 563                                 number provided, it will be total request
 564                                 timeout. It can also be a pair (tuple) of
 565                                 (connection, read) timeouts.
 566        :type _request_timeout: int, tuple(int, int), optional
 567        :param _request_auth: set to override the auth_settings for an a single
 568                              request; this effectively ignores the
 569                              authentication in the spec for a single request.
 570        :type _request_auth: dict, optional
 571        :param _content_type: force content-type for the request.
 572        :type _content_type: str, Optional
 573        :param _headers: set to override the headers for a single
 574                         request; this effectively ignores the headers
 575                         in the spec for a single request.
 576        :type _headers: dict, optional
 577        :param _host_index: set to override the host_index for a single
 578                            request; this effectively ignores the host_index
 579                            in the spec for a single request.
 580        :type _host_index: int, optional
 581        :return: Returns the result object.
 582        """ # noqa: E501
 583
 584        _param = self._create_source_connector_serialize(
 585            organization_id=organization_id,
 586            create_source_connector_request=create_source_connector_request,
 587            workspace_id=workspace_id,
 588            _request_auth=_request_auth,
 589            _content_type=_content_type,
 590            _headers=_headers,
 591            _host_index=_host_index
 592        )
 593
 594        _response_types_map: Dict[str, Optional[str]] = {
 595            '200': "CreateSourceConnectorResponse",
 596            '400': "GetPipelines400Response",
 597            '401': "GetPipelines400Response",
 598            '403': "GetPipelines400Response",
 599            '404': "GetPipelines400Response",
 600            '500': "GetPipelines400Response",
 601        }
 602        response_data = self.api_client.call_api(
 603            *_param,
 604            _request_timeout=_request_timeout
 605        )
 606        return response_data.response
 607
 608
 609    def _create_source_connector_serialize(
 610        self,
 611        organization_id,
 612        create_source_connector_request,
 613        workspace_id,
 614        _request_auth,
 615        _content_type,
 616        _headers,
 617        _host_index,
 618    ) -> RequestSerialized:
 619
 620        _host = None
 621
 622        _collection_formats: Dict[str, str] = {
 623        }
 624
 625        _path_params: Dict[str, str] = {}
 626        _query_params: List[Tuple[str, str]] = []
 627        _header_params: Dict[str, Optional[str]] = _headers or {}
 628        _form_params: List[Tuple[str, str]] = []
 629        _files: Dict[
 630            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
 631        ] = {}
 632        _body_params: Optional[bytes] = None
 633
 634        # process the path parameters
 635        if organization_id is not None:
 636            _path_params['organizationId'] = organization_id
 637        # process the query parameters
 638        if workspace_id is not None:
 639            
 640            _query_params.append(('workspaceId', workspace_id))
 641            
 642        # process the header parameters
 643        # process the form parameters
 644        # process the body parameter
 645        if create_source_connector_request is not None:
 646            _body_params = create_source_connector_request
 647
 648
 649        # set the HTTP header `Accept`
 650        if 'Accept' not in _header_params:
 651            _header_params['Accept'] = self.api_client.select_header_accept(
 652                [
 653                    'application/json'
 654                ]
 655            )
 656
 657        # set the HTTP header `Content-Type`
 658        if _content_type:
 659            _header_params['Content-Type'] = _content_type
 660        else:
 661            _default_content_type = (
 662                self.api_client.select_header_content_type(
 663                    [
 664                        'application/json'
 665                    ]
 666                )
 667            )
 668            if _default_content_type is not None:
 669                _header_params['Content-Type'] = _default_content_type
 670
 671        # authentication setting
 672        _auth_settings: List[str] = [
 673            'bearerAuth'
 674        ]
 675
 676        return self.api_client.param_serialize(
 677            method='POST',
 678            resource_path='/org/{organizationId}/connectors/sources',
 679            path_params=_path_params,
 680            query_params=_query_params,
 681            header_params=_header_params,
 682            body=_body_params,
 683            post_params=_form_params,
 684            files=_files,
 685            auth_settings=_auth_settings,
 686            collection_formats=_collection_formats,
 687            _host=_host,
 688            _request_auth=_request_auth
 689        )
 690
 691
 692
 693
 694    @validate_call
 695    def delete_source_connector(
 696        self,
 697        organization_id: StrictStr,
 698        source_connector_id: StrictStr,
 699        _request_timeout: Union[
 700            None,
 701            Annotated[StrictFloat, Field(gt=0)],
 702            Tuple[
 703                Annotated[StrictFloat, Field(gt=0)],
 704                Annotated[StrictFloat, Field(gt=0)]
 705            ]
 706        ] = None,
 707        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 708        _content_type: Optional[StrictStr] = None,
 709        _headers: Optional[Dict[StrictStr, Any]] = None,
 710        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 711    ) -> DeleteSourceConnectorResponse:
 712        """Delete a source connector
 713
 714        Delete a source connector
 715
 716        :param organization_id: (required)
 717        :type organization_id: str
 718        :param source_connector_id: (required)
 719        :type source_connector_id: str
 720        :param _request_timeout: timeout setting for this request. If one
 721                                 number provided, it will be total request
 722                                 timeout. It can also be a pair (tuple) of
 723                                 (connection, read) timeouts.
 724        :type _request_timeout: int, tuple(int, int), optional
 725        :param _request_auth: set to override the auth_settings for an a single
 726                              request; this effectively ignores the
 727                              authentication in the spec for a single request.
 728        :type _request_auth: dict, optional
 729        :param _content_type: force content-type for the request.
 730        :type _content_type: str, Optional
 731        :param _headers: set to override the headers for a single
 732                         request; this effectively ignores the headers
 733                         in the spec for a single request.
 734        :type _headers: dict, optional
 735        :param _host_index: set to override the host_index for a single
 736                            request; this effectively ignores the host_index
 737                            in the spec for a single request.
 738        :type _host_index: int, optional
 739        :return: Returns the result object.
 740        """ # noqa: E501
 741
 742        _param = self._delete_source_connector_serialize(
 743            organization_id=organization_id,
 744            source_connector_id=source_connector_id,
 745            _request_auth=_request_auth,
 746            _content_type=_content_type,
 747            _headers=_headers,
 748            _host_index=_host_index
 749        )
 750
 751        _response_types_map: Dict[str, Optional[str]] = {
 752            '200': "DeleteSourceConnectorResponse",
 753            '400': "GetPipelines400Response",
 754            '401': "GetPipelines400Response",
 755            '403': "GetPipelines400Response",
 756            '404': "GetPipelines400Response",
 757            '500': "GetPipelines400Response",
 758        }
 759        response_data = self.api_client.call_api(
 760            *_param,
 761            _request_timeout=_request_timeout
 762        )
 763        response_data.read()
 764        return self.api_client.response_deserialize(
 765            response_data=response_data,
 766            response_types_map=_response_types_map,
 767        ).data
 768
 769
 770    @validate_call
 771    def delete_source_connector_with_http_info(
 772        self,
 773        organization_id: StrictStr,
 774        source_connector_id: StrictStr,
 775        _request_timeout: Union[
 776            None,
 777            Annotated[StrictFloat, Field(gt=0)],
 778            Tuple[
 779                Annotated[StrictFloat, Field(gt=0)],
 780                Annotated[StrictFloat, Field(gt=0)]
 781            ]
 782        ] = None,
 783        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 784        _content_type: Optional[StrictStr] = None,
 785        _headers: Optional[Dict[StrictStr, Any]] = None,
 786        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 787    ) -> ApiResponse[DeleteSourceConnectorResponse]:
 788        """Delete a source connector
 789
 790        Delete a source connector
 791
 792        :param organization_id: (required)
 793        :type organization_id: str
 794        :param source_connector_id: (required)
 795        :type source_connector_id: str
 796        :param _request_timeout: timeout setting for this request. If one
 797                                 number provided, it will be total request
 798                                 timeout. It can also be a pair (tuple) of
 799                                 (connection, read) timeouts.
 800        :type _request_timeout: int, tuple(int, int), optional
 801        :param _request_auth: set to override the auth_settings for an a single
 802                              request; this effectively ignores the
 803                              authentication in the spec for a single request.
 804        :type _request_auth: dict, optional
 805        :param _content_type: force content-type for the request.
 806        :type _content_type: str, Optional
 807        :param _headers: set to override the headers for a single
 808                         request; this effectively ignores the headers
 809                         in the spec for a single request.
 810        :type _headers: dict, optional
 811        :param _host_index: set to override the host_index for a single
 812                            request; this effectively ignores the host_index
 813                            in the spec for a single request.
 814        :type _host_index: int, optional
 815        :return: Returns the result object.
 816        """ # noqa: E501
 817
 818        _param = self._delete_source_connector_serialize(
 819            organization_id=organization_id,
 820            source_connector_id=source_connector_id,
 821            _request_auth=_request_auth,
 822            _content_type=_content_type,
 823            _headers=_headers,
 824            _host_index=_host_index
 825        )
 826
 827        _response_types_map: Dict[str, Optional[str]] = {
 828            '200': "DeleteSourceConnectorResponse",
 829            '400': "GetPipelines400Response",
 830            '401': "GetPipelines400Response",
 831            '403': "GetPipelines400Response",
 832            '404': "GetPipelines400Response",
 833            '500': "GetPipelines400Response",
 834        }
 835        response_data = self.api_client.call_api(
 836            *_param,
 837            _request_timeout=_request_timeout
 838        )
 839        response_data.read()
 840        return self.api_client.response_deserialize(
 841            response_data=response_data,
 842            response_types_map=_response_types_map,
 843        )
 844
 845
 846    @validate_call
 847    def delete_source_connector_without_preload_content(
 848        self,
 849        organization_id: StrictStr,
 850        source_connector_id: StrictStr,
 851        _request_timeout: Union[
 852            None,
 853            Annotated[StrictFloat, Field(gt=0)],
 854            Tuple[
 855                Annotated[StrictFloat, Field(gt=0)],
 856                Annotated[StrictFloat, Field(gt=0)]
 857            ]
 858        ] = None,
 859        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 860        _content_type: Optional[StrictStr] = None,
 861        _headers: Optional[Dict[StrictStr, Any]] = None,
 862        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 863    ) -> RESTResponseType:
 864        """Delete a source connector
 865
 866        Delete a source connector
 867
 868        :param organization_id: (required)
 869        :type organization_id: str
 870        :param source_connector_id: (required)
 871        :type source_connector_id: str
 872        :param _request_timeout: timeout setting for this request. If one
 873                                 number provided, it will be total request
 874                                 timeout. It can also be a pair (tuple) of
 875                                 (connection, read) timeouts.
 876        :type _request_timeout: int, tuple(int, int), optional
 877        :param _request_auth: set to override the auth_settings for an a single
 878                              request; this effectively ignores the
 879                              authentication in the spec for a single request.
 880        :type _request_auth: dict, optional
 881        :param _content_type: force content-type for the request.
 882        :type _content_type: str, Optional
 883        :param _headers: set to override the headers for a single
 884                         request; this effectively ignores the headers
 885                         in the spec for a single request.
 886        :type _headers: dict, optional
 887        :param _host_index: set to override the host_index for a single
 888                            request; this effectively ignores the host_index
 889                            in the spec for a single request.
 890        :type _host_index: int, optional
 891        :return: Returns the result object.
 892        """ # noqa: E501
 893
 894        _param = self._delete_source_connector_serialize(
 895            organization_id=organization_id,
 896            source_connector_id=source_connector_id,
 897            _request_auth=_request_auth,
 898            _content_type=_content_type,
 899            _headers=_headers,
 900            _host_index=_host_index
 901        )
 902
 903        _response_types_map: Dict[str, Optional[str]] = {
 904            '200': "DeleteSourceConnectorResponse",
 905            '400': "GetPipelines400Response",
 906            '401': "GetPipelines400Response",
 907            '403': "GetPipelines400Response",
 908            '404': "GetPipelines400Response",
 909            '500': "GetPipelines400Response",
 910        }
 911        response_data = self.api_client.call_api(
 912            *_param,
 913            _request_timeout=_request_timeout
 914        )
 915        return response_data.response
 916
 917
 918    def _delete_source_connector_serialize(
 919        self,
 920        organization_id,
 921        source_connector_id,
 922        _request_auth,
 923        _content_type,
 924        _headers,
 925        _host_index,
 926    ) -> RequestSerialized:
 927
 928        _host = None
 929
 930        _collection_formats: Dict[str, str] = {
 931        }
 932
 933        _path_params: Dict[str, str] = {}
 934        _query_params: List[Tuple[str, str]] = []
 935        _header_params: Dict[str, Optional[str]] = _headers or {}
 936        _form_params: List[Tuple[str, str]] = []
 937        _files: Dict[
 938            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
 939        ] = {}
 940        _body_params: Optional[bytes] = None
 941
 942        # process the path parameters
 943        if organization_id is not None:
 944            _path_params['organizationId'] = organization_id
 945        if source_connector_id is not None:
 946            _path_params['sourceConnectorId'] = source_connector_id
 947        # process the query parameters
 948        # process the header parameters
 949        # process the form parameters
 950        # process the body parameter
 951
 952
 953        # set the HTTP header `Accept`
 954        if 'Accept' not in _header_params:
 955            _header_params['Accept'] = self.api_client.select_header_accept(
 956                [
 957                    'application/json'
 958                ]
 959            )
 960
 961
 962        # authentication setting
 963        _auth_settings: List[str] = [
 964            'bearerAuth'
 965        ]
 966
 967        return self.api_client.param_serialize(
 968            method='DELETE',
 969            resource_path='/org/{organizationId}/connectors/sources/{sourceConnectorId}',
 970            path_params=_path_params,
 971            query_params=_query_params,
 972            header_params=_header_params,
 973            body=_body_params,
 974            post_params=_form_params,
 975            files=_files,
 976            auth_settings=_auth_settings,
 977            collection_formats=_collection_formats,
 978            _host=_host,
 979            _request_auth=_request_auth
 980        )
 981
 982
 983
 984
 985    @validate_call
 986    def delete_user_from_source_connector(
 987        self,
 988        organization_id: StrictStr,
 989        source_connector_id: StrictStr,
 990        remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest,
 991        _request_timeout: Union[
 992            None,
 993            Annotated[StrictFloat, Field(gt=0)],
 994            Tuple[
 995                Annotated[StrictFloat, Field(gt=0)],
 996                Annotated[StrictFloat, Field(gt=0)]
 997            ]
 998        ] = None,
 999        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1000        _content_type: Optional[StrictStr] = None,
1001        _headers: Optional[Dict[StrictStr, Any]] = None,
1002        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1003    ) -> RemoveUserFromSourceConnectorResponse:
1004        """Delete a source connector user
1005
1006        Delete a source connector user
1007
1008        :param organization_id: (required)
1009        :type organization_id: str
1010        :param source_connector_id: (required)
1011        :type source_connector_id: str
1012        :param remove_user_from_source_connector_request: (required)
1013        :type remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest
1014        :param _request_timeout: timeout setting for this request. If one
1015                                 number provided, it will be total request
1016                                 timeout. It can also be a pair (tuple) of
1017                                 (connection, read) timeouts.
1018        :type _request_timeout: int, tuple(int, int), optional
1019        :param _request_auth: set to override the auth_settings for an a single
1020                              request; this effectively ignores the
1021                              authentication in the spec for a single request.
1022        :type _request_auth: dict, optional
1023        :param _content_type: force content-type for the request.
1024        :type _content_type: str, Optional
1025        :param _headers: set to override the headers for a single
1026                         request; this effectively ignores the headers
1027                         in the spec for a single request.
1028        :type _headers: dict, optional
1029        :param _host_index: set to override the host_index for a single
1030                            request; this effectively ignores the host_index
1031                            in the spec for a single request.
1032        :type _host_index: int, optional
1033        :return: Returns the result object.
1034        """ # noqa: E501
1035
1036        _param = self._delete_user_from_source_connector_serialize(
1037            organization_id=organization_id,
1038            source_connector_id=source_connector_id,
1039            remove_user_from_source_connector_request=remove_user_from_source_connector_request,
1040            _request_auth=_request_auth,
1041            _content_type=_content_type,
1042            _headers=_headers,
1043            _host_index=_host_index
1044        )
1045
1046        _response_types_map: Dict[str, Optional[str]] = {
1047            '200': "RemoveUserFromSourceConnectorResponse",
1048            '400': "GetPipelines400Response",
1049            '401': "GetPipelines400Response",
1050            '403': "GetPipelines400Response",
1051            '404': "GetPipelines400Response",
1052            '500': "GetPipelines400Response",
1053        }
1054        response_data = self.api_client.call_api(
1055            *_param,
1056            _request_timeout=_request_timeout
1057        )
1058        response_data.read()
1059        return self.api_client.response_deserialize(
1060            response_data=response_data,
1061            response_types_map=_response_types_map,
1062        ).data
1063
1064
1065    @validate_call
1066    def delete_user_from_source_connector_with_http_info(
1067        self,
1068        organization_id: StrictStr,
1069        source_connector_id: StrictStr,
1070        remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest,
1071        _request_timeout: Union[
1072            None,
1073            Annotated[StrictFloat, Field(gt=0)],
1074            Tuple[
1075                Annotated[StrictFloat, Field(gt=0)],
1076                Annotated[StrictFloat, Field(gt=0)]
1077            ]
1078        ] = None,
1079        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1080        _content_type: Optional[StrictStr] = None,
1081        _headers: Optional[Dict[StrictStr, Any]] = None,
1082        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1083    ) -> ApiResponse[RemoveUserFromSourceConnectorResponse]:
1084        """Delete a source connector user
1085
1086        Delete a source connector user
1087
1088        :param organization_id: (required)
1089        :type organization_id: str
1090        :param source_connector_id: (required)
1091        :type source_connector_id: str
1092        :param remove_user_from_source_connector_request: (required)
1093        :type remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest
1094        :param _request_timeout: timeout setting for this request. If one
1095                                 number provided, it will be total request
1096                                 timeout. It can also be a pair (tuple) of
1097                                 (connection, read) timeouts.
1098        :type _request_timeout: int, tuple(int, int), optional
1099        :param _request_auth: set to override the auth_settings for an a single
1100                              request; this effectively ignores the
1101                              authentication in the spec for a single request.
1102        :type _request_auth: dict, optional
1103        :param _content_type: force content-type for the request.
1104        :type _content_type: str, Optional
1105        :param _headers: set to override the headers for a single
1106                         request; this effectively ignores the headers
1107                         in the spec for a single request.
1108        :type _headers: dict, optional
1109        :param _host_index: set to override the host_index for a single
1110                            request; this effectively ignores the host_index
1111                            in the spec for a single request.
1112        :type _host_index: int, optional
1113        :return: Returns the result object.
1114        """ # noqa: E501
1115
1116        _param = self._delete_user_from_source_connector_serialize(
1117            organization_id=organization_id,
1118            source_connector_id=source_connector_id,
1119            remove_user_from_source_connector_request=remove_user_from_source_connector_request,
1120            _request_auth=_request_auth,
1121            _content_type=_content_type,
1122            _headers=_headers,
1123            _host_index=_host_index
1124        )
1125
1126        _response_types_map: Dict[str, Optional[str]] = {
1127            '200': "RemoveUserFromSourceConnectorResponse",
1128            '400': "GetPipelines400Response",
1129            '401': "GetPipelines400Response",
1130            '403': "GetPipelines400Response",
1131            '404': "GetPipelines400Response",
1132            '500': "GetPipelines400Response",
1133        }
1134        response_data = self.api_client.call_api(
1135            *_param,
1136            _request_timeout=_request_timeout
1137        )
1138        response_data.read()
1139        return self.api_client.response_deserialize(
1140            response_data=response_data,
1141            response_types_map=_response_types_map,
1142        )
1143
1144
1145    @validate_call
1146    def delete_user_from_source_connector_without_preload_content(
1147        self,
1148        organization_id: StrictStr,
1149        source_connector_id: StrictStr,
1150        remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest,
1151        _request_timeout: Union[
1152            None,
1153            Annotated[StrictFloat, Field(gt=0)],
1154            Tuple[
1155                Annotated[StrictFloat, Field(gt=0)],
1156                Annotated[StrictFloat, Field(gt=0)]
1157            ]
1158        ] = None,
1159        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1160        _content_type: Optional[StrictStr] = None,
1161        _headers: Optional[Dict[StrictStr, Any]] = None,
1162        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1163    ) -> RESTResponseType:
1164        """Delete a source connector user
1165
1166        Delete a source connector user
1167
1168        :param organization_id: (required)
1169        :type organization_id: str
1170        :param source_connector_id: (required)
1171        :type source_connector_id: str
1172        :param remove_user_from_source_connector_request: (required)
1173        :type remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest
1174        :param _request_timeout: timeout setting for this request. If one
1175                                 number provided, it will be total request
1176                                 timeout. It can also be a pair (tuple) of
1177                                 (connection, read) timeouts.
1178        :type _request_timeout: int, tuple(int, int), optional
1179        :param _request_auth: set to override the auth_settings for an a single
1180                              request; this effectively ignores the
1181                              authentication in the spec for a single request.
1182        :type _request_auth: dict, optional
1183        :param _content_type: force content-type for the request.
1184        :type _content_type: str, Optional
1185        :param _headers: set to override the headers for a single
1186                         request; this effectively ignores the headers
1187                         in the spec for a single request.
1188        :type _headers: dict, optional
1189        :param _host_index: set to override the host_index for a single
1190                            request; this effectively ignores the host_index
1191                            in the spec for a single request.
1192        :type _host_index: int, optional
1193        :return: Returns the result object.
1194        """ # noqa: E501
1195
1196        _param = self._delete_user_from_source_connector_serialize(
1197            organization_id=organization_id,
1198            source_connector_id=source_connector_id,
1199            remove_user_from_source_connector_request=remove_user_from_source_connector_request,
1200            _request_auth=_request_auth,
1201            _content_type=_content_type,
1202            _headers=_headers,
1203            _host_index=_host_index
1204        )
1205
1206        _response_types_map: Dict[str, Optional[str]] = {
1207            '200': "RemoveUserFromSourceConnectorResponse",
1208            '400': "GetPipelines400Response",
1209            '401': "GetPipelines400Response",
1210            '403': "GetPipelines400Response",
1211            '404': "GetPipelines400Response",
1212            '500': "GetPipelines400Response",
1213        }
1214        response_data = self.api_client.call_api(
1215            *_param,
1216            _request_timeout=_request_timeout
1217        )
1218        return response_data.response
1219
1220
1221    def _delete_user_from_source_connector_serialize(
1222        self,
1223        organization_id,
1224        source_connector_id,
1225        remove_user_from_source_connector_request,
1226        _request_auth,
1227        _content_type,
1228        _headers,
1229        _host_index,
1230    ) -> RequestSerialized:
1231
1232        _host = None
1233
1234        _collection_formats: Dict[str, str] = {
1235        }
1236
1237        _path_params: Dict[str, str] = {}
1238        _query_params: List[Tuple[str, str]] = []
1239        _header_params: Dict[str, Optional[str]] = _headers or {}
1240        _form_params: List[Tuple[str, str]] = []
1241        _files: Dict[
1242            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1243        ] = {}
1244        _body_params: Optional[bytes] = None
1245
1246        # process the path parameters
1247        if organization_id is not None:
1248            _path_params['organizationId'] = organization_id
1249        if source_connector_id is not None:
1250            _path_params['sourceConnectorId'] = source_connector_id
1251        # process the query parameters
1252        # process the header parameters
1253        # process the form parameters
1254        # process the body parameter
1255        if remove_user_from_source_connector_request is not None:
1256            _body_params = remove_user_from_source_connector_request
1257
1258
1259        # set the HTTP header `Accept`
1260        if 'Accept' not in _header_params:
1261            _header_params['Accept'] = self.api_client.select_header_accept(
1262                [
1263                    'application/json'
1264                ]
1265            )
1266
1267        # set the HTTP header `Content-Type`
1268        if _content_type:
1269            _header_params['Content-Type'] = _content_type
1270        else:
1271            _default_content_type = (
1272                self.api_client.select_header_content_type(
1273                    [
1274                        'application/json'
1275                    ]
1276                )
1277            )
1278            if _default_content_type is not None:
1279                _header_params['Content-Type'] = _default_content_type
1280
1281        # authentication setting
1282        _auth_settings: List[str] = [
1283            'bearerAuth'
1284        ]
1285
1286        return self.api_client.param_serialize(
1287            method='DELETE',
1288            resource_path='/org/{organizationId}/connectors/sources/{sourceConnectorId}/users',
1289            path_params=_path_params,
1290            query_params=_query_params,
1291            header_params=_header_params,
1292            body=_body_params,
1293            post_params=_form_params,
1294            files=_files,
1295            auth_settings=_auth_settings,
1296            collection_formats=_collection_formats,
1297            _host=_host,
1298            _request_auth=_request_auth
1299        )
1300
1301
1302
1303
1304    @validate_call
1305    def get_source_connector(
1306        self,
1307        organization_id: StrictStr,
1308        source_connector_id: StrictStr,
1309        _request_timeout: Union[
1310            None,
1311            Annotated[StrictFloat, Field(gt=0)],
1312            Tuple[
1313                Annotated[StrictFloat, Field(gt=0)],
1314                Annotated[StrictFloat, Field(gt=0)]
1315            ]
1316        ] = None,
1317        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1318        _content_type: Optional[StrictStr] = None,
1319        _headers: Optional[Dict[StrictStr, Any]] = None,
1320        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1321    ) -> SourceConnector:
1322        """Get a source connector
1323
1324        Get a source connector
1325
1326        :param organization_id: (required)
1327        :type organization_id: str
1328        :param source_connector_id: (required)
1329        :type source_connector_id: str
1330        :param _request_timeout: timeout setting for this request. If one
1331                                 number provided, it will be total request
1332                                 timeout. It can also be a pair (tuple) of
1333                                 (connection, read) timeouts.
1334        :type _request_timeout: int, tuple(int, int), optional
1335        :param _request_auth: set to override the auth_settings for an a single
1336                              request; this effectively ignores the
1337                              authentication in the spec for a single request.
1338        :type _request_auth: dict, optional
1339        :param _content_type: force content-type for the request.
1340        :type _content_type: str, Optional
1341        :param _headers: set to override the headers for a single
1342                         request; this effectively ignores the headers
1343                         in the spec for a single request.
1344        :type _headers: dict, optional
1345        :param _host_index: set to override the host_index for a single
1346                            request; this effectively ignores the host_index
1347                            in the spec for a single request.
1348        :type _host_index: int, optional
1349        :return: Returns the result object.
1350        """ # noqa: E501
1351
1352        _param = self._get_source_connector_serialize(
1353            organization_id=organization_id,
1354            source_connector_id=source_connector_id,
1355            _request_auth=_request_auth,
1356            _content_type=_content_type,
1357            _headers=_headers,
1358            _host_index=_host_index
1359        )
1360
1361        _response_types_map: Dict[str, Optional[str]] = {
1362            '200': "SourceConnector",
1363            '400': "GetPipelines400Response",
1364            '401': "GetPipelines400Response",
1365            '403': "GetPipelines400Response",
1366            '404': "GetPipelines400Response",
1367            '500': "GetPipelines400Response",
1368        }
1369        response_data = self.api_client.call_api(
1370            *_param,
1371            _request_timeout=_request_timeout
1372        )
1373        response_data.read()
1374        return self.api_client.response_deserialize(
1375            response_data=response_data,
1376            response_types_map=_response_types_map,
1377        ).data
1378
1379
1380    @validate_call
1381    def get_source_connector_with_http_info(
1382        self,
1383        organization_id: StrictStr,
1384        source_connector_id: StrictStr,
1385        _request_timeout: Union[
1386            None,
1387            Annotated[StrictFloat, Field(gt=0)],
1388            Tuple[
1389                Annotated[StrictFloat, Field(gt=0)],
1390                Annotated[StrictFloat, Field(gt=0)]
1391            ]
1392        ] = None,
1393        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1394        _content_type: Optional[StrictStr] = None,
1395        _headers: Optional[Dict[StrictStr, Any]] = None,
1396        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1397    ) -> ApiResponse[SourceConnector]:
1398        """Get a source connector
1399
1400        Get a source connector
1401
1402        :param organization_id: (required)
1403        :type organization_id: str
1404        :param source_connector_id: (required)
1405        :type source_connector_id: str
1406        :param _request_timeout: timeout setting for this request. If one
1407                                 number provided, it will be total request
1408                                 timeout. It can also be a pair (tuple) of
1409                                 (connection, read) timeouts.
1410        :type _request_timeout: int, tuple(int, int), optional
1411        :param _request_auth: set to override the auth_settings for an a single
1412                              request; this effectively ignores the
1413                              authentication in the spec for a single request.
1414        :type _request_auth: dict, optional
1415        :param _content_type: force content-type for the request.
1416        :type _content_type: str, Optional
1417        :param _headers: set to override the headers for a single
1418                         request; this effectively ignores the headers
1419                         in the spec for a single request.
1420        :type _headers: dict, optional
1421        :param _host_index: set to override the host_index for a single
1422                            request; this effectively ignores the host_index
1423                            in the spec for a single request.
1424        :type _host_index: int, optional
1425        :return: Returns the result object.
1426        """ # noqa: E501
1427
1428        _param = self._get_source_connector_serialize(
1429            organization_id=organization_id,
1430            source_connector_id=source_connector_id,
1431            _request_auth=_request_auth,
1432            _content_type=_content_type,
1433            _headers=_headers,
1434            _host_index=_host_index
1435        )
1436
1437        _response_types_map: Dict[str, Optional[str]] = {
1438            '200': "SourceConnector",
1439            '400': "GetPipelines400Response",
1440            '401': "GetPipelines400Response",
1441            '403': "GetPipelines400Response",
1442            '404': "GetPipelines400Response",
1443            '500': "GetPipelines400Response",
1444        }
1445        response_data = self.api_client.call_api(
1446            *_param,
1447            _request_timeout=_request_timeout
1448        )
1449        response_data.read()
1450        return self.api_client.response_deserialize(
1451            response_data=response_data,
1452            response_types_map=_response_types_map,
1453        )
1454
1455
1456    @validate_call
1457    def get_source_connector_without_preload_content(
1458        self,
1459        organization_id: StrictStr,
1460        source_connector_id: StrictStr,
1461        _request_timeout: Union[
1462            None,
1463            Annotated[StrictFloat, Field(gt=0)],
1464            Tuple[
1465                Annotated[StrictFloat, Field(gt=0)],
1466                Annotated[StrictFloat, Field(gt=0)]
1467            ]
1468        ] = None,
1469        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1470        _content_type: Optional[StrictStr] = None,
1471        _headers: Optional[Dict[StrictStr, Any]] = None,
1472        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1473    ) -> RESTResponseType:
1474        """Get a source connector
1475
1476        Get a source connector
1477
1478        :param organization_id: (required)
1479        :type organization_id: str
1480        :param source_connector_id: (required)
1481        :type source_connector_id: str
1482        :param _request_timeout: timeout setting for this request. If one
1483                                 number provided, it will be total request
1484                                 timeout. It can also be a pair (tuple) of
1485                                 (connection, read) timeouts.
1486        :type _request_timeout: int, tuple(int, int), optional
1487        :param _request_auth: set to override the auth_settings for an a single
1488                              request; this effectively ignores the
1489                              authentication in the spec for a single request.
1490        :type _request_auth: dict, optional
1491        :param _content_type: force content-type for the request.
1492        :type _content_type: str, Optional
1493        :param _headers: set to override the headers for a single
1494                         request; this effectively ignores the headers
1495                         in the spec for a single request.
1496        :type _headers: dict, optional
1497        :param _host_index: set to override the host_index for a single
1498                            request; this effectively ignores the host_index
1499                            in the spec for a single request.
1500        :type _host_index: int, optional
1501        :return: Returns the result object.
1502        """ # noqa: E501
1503
1504        _param = self._get_source_connector_serialize(
1505            organization_id=organization_id,
1506            source_connector_id=source_connector_id,
1507            _request_auth=_request_auth,
1508            _content_type=_content_type,
1509            _headers=_headers,
1510            _host_index=_host_index
1511        )
1512
1513        _response_types_map: Dict[str, Optional[str]] = {
1514            '200': "SourceConnector",
1515            '400': "GetPipelines400Response",
1516            '401': "GetPipelines400Response",
1517            '403': "GetPipelines400Response",
1518            '404': "GetPipelines400Response",
1519            '500': "GetPipelines400Response",
1520        }
1521        response_data = self.api_client.call_api(
1522            *_param,
1523            _request_timeout=_request_timeout
1524        )
1525        return response_data.response
1526
1527
1528    def _get_source_connector_serialize(
1529        self,
1530        organization_id,
1531        source_connector_id,
1532        _request_auth,
1533        _content_type,
1534        _headers,
1535        _host_index,
1536    ) -> RequestSerialized:
1537
1538        _host = None
1539
1540        _collection_formats: Dict[str, str] = {
1541        }
1542
1543        _path_params: Dict[str, str] = {}
1544        _query_params: List[Tuple[str, str]] = []
1545        _header_params: Dict[str, Optional[str]] = _headers or {}
1546        _form_params: List[Tuple[str, str]] = []
1547        _files: Dict[
1548            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1549        ] = {}
1550        _body_params: Optional[bytes] = None
1551
1552        # process the path parameters
1553        if organization_id is not None:
1554            _path_params['organizationId'] = organization_id
1555        if source_connector_id is not None:
1556            _path_params['sourceConnectorId'] = source_connector_id
1557        # process the query parameters
1558        # process the header parameters
1559        # process the form parameters
1560        # process the body parameter
1561
1562
1563        # set the HTTP header `Accept`
1564        if 'Accept' not in _header_params:
1565            _header_params['Accept'] = self.api_client.select_header_accept(
1566                [
1567                    'application/json'
1568                ]
1569            )
1570
1571
1572        # authentication setting
1573        _auth_settings: List[str] = [
1574            'bearerAuth'
1575        ]
1576
1577        return self.api_client.param_serialize(
1578            method='GET',
1579            resource_path='/org/{organizationId}/connectors/sources/{sourceConnectorId}',
1580            path_params=_path_params,
1581            query_params=_query_params,
1582            header_params=_header_params,
1583            body=_body_params,
1584            post_params=_form_params,
1585            files=_files,
1586            auth_settings=_auth_settings,
1587            collection_formats=_collection_formats,
1588            _host=_host,
1589            _request_auth=_request_auth
1590        )
1591
1592
1593
1594
1595    @validate_call
1596    def get_source_connectors(
1597        self,
1598        organization_id: StrictStr,
1599        workspace_id: Optional[StrictStr] = None,
1600        _request_timeout: Union[
1601            None,
1602            Annotated[StrictFloat, Field(gt=0)],
1603            Tuple[
1604                Annotated[StrictFloat, Field(gt=0)],
1605                Annotated[StrictFloat, Field(gt=0)]
1606            ]
1607        ] = None,
1608        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1609        _content_type: Optional[StrictStr] = None,
1610        _headers: Optional[Dict[StrictStr, Any]] = None,
1611        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1612    ) -> GetSourceConnectors200Response:
1613        """Get all existing source connectors
1614
1615        Get all existing source connectors
1616
1617        :param organization_id: (required)
1618        :type organization_id: str
1619        :param workspace_id:
1620        :type workspace_id: str
1621        :param _request_timeout: timeout setting for this request. If one
1622                                 number provided, it will be total request
1623                                 timeout. It can also be a pair (tuple) of
1624                                 (connection, read) timeouts.
1625        :type _request_timeout: int, tuple(int, int), optional
1626        :param _request_auth: set to override the auth_settings for an a single
1627                              request; this effectively ignores the
1628                              authentication in the spec for a single request.
1629        :type _request_auth: dict, optional
1630        :param _content_type: force content-type for the request.
1631        :type _content_type: str, Optional
1632        :param _headers: set to override the headers for a single
1633                         request; this effectively ignores the headers
1634                         in the spec for a single request.
1635        :type _headers: dict, optional
1636        :param _host_index: set to override the host_index for a single
1637                            request; this effectively ignores the host_index
1638                            in the spec for a single request.
1639        :type _host_index: int, optional
1640        :return: Returns the result object.
1641        """ # noqa: E501
1642
1643        _param = self._get_source_connectors_serialize(
1644            organization_id=organization_id,
1645            workspace_id=workspace_id,
1646            _request_auth=_request_auth,
1647            _content_type=_content_type,
1648            _headers=_headers,
1649            _host_index=_host_index
1650        )
1651
1652        _response_types_map: Dict[str, Optional[str]] = {
1653            '200': "GetSourceConnectors200Response",
1654            '400': "GetPipelines400Response",
1655            '401': "GetPipelines400Response",
1656            '403': "GetPipelines400Response",
1657            '404': "GetPipelines400Response",
1658            '500': "GetPipelines400Response",
1659        }
1660        response_data = self.api_client.call_api(
1661            *_param,
1662            _request_timeout=_request_timeout
1663        )
1664        response_data.read()
1665        return self.api_client.response_deserialize(
1666            response_data=response_data,
1667            response_types_map=_response_types_map,
1668        ).data
1669
1670
1671    @validate_call
1672    def get_source_connectors_with_http_info(
1673        self,
1674        organization_id: StrictStr,
1675        workspace_id: Optional[StrictStr] = None,
1676        _request_timeout: Union[
1677            None,
1678            Annotated[StrictFloat, Field(gt=0)],
1679            Tuple[
1680                Annotated[StrictFloat, Field(gt=0)],
1681                Annotated[StrictFloat, Field(gt=0)]
1682            ]
1683        ] = None,
1684        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1685        _content_type: Optional[StrictStr] = None,
1686        _headers: Optional[Dict[StrictStr, Any]] = None,
1687        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1688    ) -> ApiResponse[GetSourceConnectors200Response]:
1689        """Get all existing source connectors
1690
1691        Get all existing source connectors
1692
1693        :param organization_id: (required)
1694        :type organization_id: str
1695        :param workspace_id:
1696        :type workspace_id: str
1697        :param _request_timeout: timeout setting for this request. If one
1698                                 number provided, it will be total request
1699                                 timeout. It can also be a pair (tuple) of
1700                                 (connection, read) timeouts.
1701        :type _request_timeout: int, tuple(int, int), optional
1702        :param _request_auth: set to override the auth_settings for an a single
1703                              request; this effectively ignores the
1704                              authentication in the spec for a single request.
1705        :type _request_auth: dict, optional
1706        :param _content_type: force content-type for the request.
1707        :type _content_type: str, Optional
1708        :param _headers: set to override the headers for a single
1709                         request; this effectively ignores the headers
1710                         in the spec for a single request.
1711        :type _headers: dict, optional
1712        :param _host_index: set to override the host_index for a single
1713                            request; this effectively ignores the host_index
1714                            in the spec for a single request.
1715        :type _host_index: int, optional
1716        :return: Returns the result object.
1717        """ # noqa: E501
1718
1719        _param = self._get_source_connectors_serialize(
1720            organization_id=organization_id,
1721            workspace_id=workspace_id,
1722            _request_auth=_request_auth,
1723            _content_type=_content_type,
1724            _headers=_headers,
1725            _host_index=_host_index
1726        )
1727
1728        _response_types_map: Dict[str, Optional[str]] = {
1729            '200': "GetSourceConnectors200Response",
1730            '400': "GetPipelines400Response",
1731            '401': "GetPipelines400Response",
1732            '403': "GetPipelines400Response",
1733            '404': "GetPipelines400Response",
1734            '500': "GetPipelines400Response",
1735        }
1736        response_data = self.api_client.call_api(
1737            *_param,
1738            _request_timeout=_request_timeout
1739        )
1740        response_data.read()
1741        return self.api_client.response_deserialize(
1742            response_data=response_data,
1743            response_types_map=_response_types_map,
1744        )
1745
1746
1747    @validate_call
1748    def get_source_connectors_without_preload_content(
1749        self,
1750        organization_id: StrictStr,
1751        workspace_id: Optional[StrictStr] = None,
1752        _request_timeout: Union[
1753            None,
1754            Annotated[StrictFloat, Field(gt=0)],
1755            Tuple[
1756                Annotated[StrictFloat, Field(gt=0)],
1757                Annotated[StrictFloat, Field(gt=0)]
1758            ]
1759        ] = None,
1760        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1761        _content_type: Optional[StrictStr] = None,
1762        _headers: Optional[Dict[StrictStr, Any]] = None,
1763        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1764    ) -> RESTResponseType:
1765        """Get all existing source connectors
1766
1767        Get all existing source connectors
1768
1769        :param organization_id: (required)
1770        :type organization_id: str
1771        :param workspace_id:
1772        :type workspace_id: str
1773        :param _request_timeout: timeout setting for this request. If one
1774                                 number provided, it will be total request
1775                                 timeout. It can also be a pair (tuple) of
1776                                 (connection, read) timeouts.
1777        :type _request_timeout: int, tuple(int, int), optional
1778        :param _request_auth: set to override the auth_settings for an a single
1779                              request; this effectively ignores the
1780                              authentication in the spec for a single request.
1781        :type _request_auth: dict, optional
1782        :param _content_type: force content-type for the request.
1783        :type _content_type: str, Optional
1784        :param _headers: set to override the headers for a single
1785                         request; this effectively ignores the headers
1786                         in the spec for a single request.
1787        :type _headers: dict, optional
1788        :param _host_index: set to override the host_index for a single
1789                            request; this effectively ignores the host_index
1790                            in the spec for a single request.
1791        :type _host_index: int, optional
1792        :return: Returns the result object.
1793        """ # noqa: E501
1794
1795        _param = self._get_source_connectors_serialize(
1796            organization_id=organization_id,
1797            workspace_id=workspace_id,
1798            _request_auth=_request_auth,
1799            _content_type=_content_type,
1800            _headers=_headers,
1801            _host_index=_host_index
1802        )
1803
1804        _response_types_map: Dict[str, Optional[str]] = {
1805            '200': "GetSourceConnectors200Response",
1806            '400': "GetPipelines400Response",
1807            '401': "GetPipelines400Response",
1808            '403': "GetPipelines400Response",
1809            '404': "GetPipelines400Response",
1810            '500': "GetPipelines400Response",
1811        }
1812        response_data = self.api_client.call_api(
1813            *_param,
1814            _request_timeout=_request_timeout
1815        )
1816        return response_data.response
1817
1818
1819    def _get_source_connectors_serialize(
1820        self,
1821        organization_id,
1822        workspace_id,
1823        _request_auth,
1824        _content_type,
1825        _headers,
1826        _host_index,
1827    ) -> RequestSerialized:
1828
1829        _host = None
1830
1831        _collection_formats: Dict[str, str] = {
1832        }
1833
1834        _path_params: Dict[str, str] = {}
1835        _query_params: List[Tuple[str, str]] = []
1836        _header_params: Dict[str, Optional[str]] = _headers or {}
1837        _form_params: List[Tuple[str, str]] = []
1838        _files: Dict[
1839            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1840        ] = {}
1841        _body_params: Optional[bytes] = None
1842
1843        # process the path parameters
1844        if organization_id is not None:
1845            _path_params['organizationId'] = organization_id
1846        # process the query parameters
1847        if workspace_id is not None:
1848            
1849            _query_params.append(('workspaceId', workspace_id))
1850            
1851        # process the header parameters
1852        # process the form parameters
1853        # process the body parameter
1854
1855
1856        # set the HTTP header `Accept`
1857        if 'Accept' not in _header_params:
1858            _header_params['Accept'] = self.api_client.select_header_accept(
1859                [
1860                    'application/json'
1861                ]
1862            )
1863
1864
1865        # authentication setting
1866        _auth_settings: List[str] = [
1867            'bearerAuth'
1868        ]
1869
1870        return self.api_client.param_serialize(
1871            method='GET',
1872            resource_path='/org/{organizationId}/connectors/sources',
1873            path_params=_path_params,
1874            query_params=_query_params,
1875            header_params=_header_params,
1876            body=_body_params,
1877            post_params=_form_params,
1878            files=_files,
1879            auth_settings=_auth_settings,
1880            collection_formats=_collection_formats,
1881            _host=_host,
1882            _request_auth=_request_auth
1883        )
1884
1885
1886
1887
1888    @validate_call
1889    def update_source_connector(
1890        self,
1891        organization_id: StrictStr,
1892        source_connector_id: StrictStr,
1893        update_source_connector_request: UpdateSourceConnectorRequest,
1894        _request_timeout: Union[
1895            None,
1896            Annotated[StrictFloat, Field(gt=0)],
1897            Tuple[
1898                Annotated[StrictFloat, Field(gt=0)],
1899                Annotated[StrictFloat, Field(gt=0)]
1900            ]
1901        ] = None,
1902        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1903        _content_type: Optional[StrictStr] = None,
1904        _headers: Optional[Dict[StrictStr, Any]] = None,
1905        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1906    ) -> UpdateSourceConnectorResponse:
1907        """Update a source connector
1908
1909        Update a source connector
1910
1911        :param organization_id: (required)
1912        :type organization_id: str
1913        :param source_connector_id: (required)
1914        :type source_connector_id: str
1915        :param update_source_connector_request: (required)
1916        :type update_source_connector_request: UpdateSourceConnectorRequest
1917        :param _request_timeout: timeout setting for this request. If one
1918                                 number provided, it will be total request
1919                                 timeout. It can also be a pair (tuple) of
1920                                 (connection, read) timeouts.
1921        :type _request_timeout: int, tuple(int, int), optional
1922        :param _request_auth: set to override the auth_settings for an a single
1923                              request; this effectively ignores the
1924                              authentication in the spec for a single request.
1925        :type _request_auth: dict, optional
1926        :param _content_type: force content-type for the request.
1927        :type _content_type: str, Optional
1928        :param _headers: set to override the headers for a single
1929                         request; this effectively ignores the headers
1930                         in the spec for a single request.
1931        :type _headers: dict, optional
1932        :param _host_index: set to override the host_index for a single
1933                            request; this effectively ignores the host_index
1934                            in the spec for a single request.
1935        :type _host_index: int, optional
1936        :return: Returns the result object.
1937        """ # noqa: E501
1938
1939        _param = self._update_source_connector_serialize(
1940            organization_id=organization_id,
1941            source_connector_id=source_connector_id,
1942            update_source_connector_request=update_source_connector_request,
1943            _request_auth=_request_auth,
1944            _content_type=_content_type,
1945            _headers=_headers,
1946            _host_index=_host_index
1947        )
1948
1949        _response_types_map: Dict[str, Optional[str]] = {
1950            '200': "UpdateSourceConnectorResponse",
1951            '400': "GetPipelines400Response",
1952            '401': "GetPipelines400Response",
1953            '403': "GetPipelines400Response",
1954            '404': "GetPipelines400Response",
1955            '500': "GetPipelines400Response",
1956        }
1957        response_data = self.api_client.call_api(
1958            *_param,
1959            _request_timeout=_request_timeout
1960        )
1961        response_data.read()
1962        return self.api_client.response_deserialize(
1963            response_data=response_data,
1964            response_types_map=_response_types_map,
1965        ).data
1966
1967
1968    @validate_call
1969    def update_source_connector_with_http_info(
1970        self,
1971        organization_id: StrictStr,
1972        source_connector_id: StrictStr,
1973        update_source_connector_request: UpdateSourceConnectorRequest,
1974        _request_timeout: Union[
1975            None,
1976            Annotated[StrictFloat, Field(gt=0)],
1977            Tuple[
1978                Annotated[StrictFloat, Field(gt=0)],
1979                Annotated[StrictFloat, Field(gt=0)]
1980            ]
1981        ] = None,
1982        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1983        _content_type: Optional[StrictStr] = None,
1984        _headers: Optional[Dict[StrictStr, Any]] = None,
1985        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1986    ) -> ApiResponse[UpdateSourceConnectorResponse]:
1987        """Update a source connector
1988
1989        Update a source connector
1990
1991        :param organization_id: (required)
1992        :type organization_id: str
1993        :param source_connector_id: (required)
1994        :type source_connector_id: str
1995        :param update_source_connector_request: (required)
1996        :type update_source_connector_request: UpdateSourceConnectorRequest
1997        :param _request_timeout: timeout setting for this request. If one
1998                                 number provided, it will be total request
1999                                 timeout. It can also be a pair (tuple) of
2000                                 (connection, read) timeouts.
2001        :type _request_timeout: int, tuple(int, int), optional
2002        :param _request_auth: set to override the auth_settings for an a single
2003                              request; this effectively ignores the
2004                              authentication in the spec for a single request.
2005        :type _request_auth: dict, optional
2006        :param _content_type: force content-type for the request.
2007        :type _content_type: str, Optional
2008        :param _headers: set to override the headers for a single
2009                         request; this effectively ignores the headers
2010                         in the spec for a single request.
2011        :type _headers: dict, optional
2012        :param _host_index: set to override the host_index for a single
2013                            request; this effectively ignores the host_index
2014                            in the spec for a single request.
2015        :type _host_index: int, optional
2016        :return: Returns the result object.
2017        """ # noqa: E501
2018
2019        _param = self._update_source_connector_serialize(
2020            organization_id=organization_id,
2021            source_connector_id=source_connector_id,
2022            update_source_connector_request=update_source_connector_request,
2023            _request_auth=_request_auth,
2024            _content_type=_content_type,
2025            _headers=_headers,
2026            _host_index=_host_index
2027        )
2028
2029        _response_types_map: Dict[str, Optional[str]] = {
2030            '200': "UpdateSourceConnectorResponse",
2031            '400': "GetPipelines400Response",
2032            '401': "GetPipelines400Response",
2033            '403': "GetPipelines400Response",
2034            '404': "GetPipelines400Response",
2035            '500': "GetPipelines400Response",
2036        }
2037        response_data = self.api_client.call_api(
2038            *_param,
2039            _request_timeout=_request_timeout
2040        )
2041        response_data.read()
2042        return self.api_client.response_deserialize(
2043            response_data=response_data,
2044            response_types_map=_response_types_map,
2045        )
2046
2047
2048    @validate_call
2049    def update_source_connector_without_preload_content(
2050        self,
2051        organization_id: StrictStr,
2052        source_connector_id: StrictStr,
2053        update_source_connector_request: UpdateSourceConnectorRequest,
2054        _request_timeout: Union[
2055            None,
2056            Annotated[StrictFloat, Field(gt=0)],
2057            Tuple[
2058                Annotated[StrictFloat, Field(gt=0)],
2059                Annotated[StrictFloat, Field(gt=0)]
2060            ]
2061        ] = None,
2062        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2063        _content_type: Optional[StrictStr] = None,
2064        _headers: Optional[Dict[StrictStr, Any]] = None,
2065        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2066    ) -> RESTResponseType:
2067        """Update a source connector
2068
2069        Update a source connector
2070
2071        :param organization_id: (required)
2072        :type organization_id: str
2073        :param source_connector_id: (required)
2074        :type source_connector_id: str
2075        :param update_source_connector_request: (required)
2076        :type update_source_connector_request: UpdateSourceConnectorRequest
2077        :param _request_timeout: timeout setting for this request. If one
2078                                 number provided, it will be total request
2079                                 timeout. It can also be a pair (tuple) of
2080                                 (connection, read) timeouts.
2081        :type _request_timeout: int, tuple(int, int), optional
2082        :param _request_auth: set to override the auth_settings for an a single
2083                              request; this effectively ignores the
2084                              authentication in the spec for a single request.
2085        :type _request_auth: dict, optional
2086        :param _content_type: force content-type for the request.
2087        :type _content_type: str, Optional
2088        :param _headers: set to override the headers for a single
2089                         request; this effectively ignores the headers
2090                         in the spec for a single request.
2091        :type _headers: dict, optional
2092        :param _host_index: set to override the host_index for a single
2093                            request; this effectively ignores the host_index
2094                            in the spec for a single request.
2095        :type _host_index: int, optional
2096        :return: Returns the result object.
2097        """ # noqa: E501
2098
2099        _param = self._update_source_connector_serialize(
2100            organization_id=organization_id,
2101            source_connector_id=source_connector_id,
2102            update_source_connector_request=update_source_connector_request,
2103            _request_auth=_request_auth,
2104            _content_type=_content_type,
2105            _headers=_headers,
2106            _host_index=_host_index
2107        )
2108
2109        _response_types_map: Dict[str, Optional[str]] = {
2110            '200': "UpdateSourceConnectorResponse",
2111            '400': "GetPipelines400Response",
2112            '401': "GetPipelines400Response",
2113            '403': "GetPipelines400Response",
2114            '404': "GetPipelines400Response",
2115            '500': "GetPipelines400Response",
2116        }
2117        response_data = self.api_client.call_api(
2118            *_param,
2119            _request_timeout=_request_timeout
2120        )
2121        return response_data.response
2122
2123
2124    def _update_source_connector_serialize(
2125        self,
2126        organization_id,
2127        source_connector_id,
2128        update_source_connector_request,
2129        _request_auth,
2130        _content_type,
2131        _headers,
2132        _host_index,
2133    ) -> RequestSerialized:
2134
2135        _host = None
2136
2137        _collection_formats: Dict[str, str] = {
2138        }
2139
2140        _path_params: Dict[str, str] = {}
2141        _query_params: List[Tuple[str, str]] = []
2142        _header_params: Dict[str, Optional[str]] = _headers or {}
2143        _form_params: List[Tuple[str, str]] = []
2144        _files: Dict[
2145            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
2146        ] = {}
2147        _body_params: Optional[bytes] = None
2148
2149        # process the path parameters
2150        if organization_id is not None:
2151            _path_params['organizationId'] = organization_id
2152        if source_connector_id is not None:
2153            _path_params['sourceConnectorId'] = source_connector_id
2154        # process the query parameters
2155        # process the header parameters
2156        # process the form parameters
2157        # process the body parameter
2158        if update_source_connector_request is not None:
2159            _body_params = update_source_connector_request
2160
2161
2162        # set the HTTP header `Accept`
2163        if 'Accept' not in _header_params:
2164            _header_params['Accept'] = self.api_client.select_header_accept(
2165                [
2166                    'application/json'
2167                ]
2168            )
2169
2170        # set the HTTP header `Content-Type`
2171        if _content_type:
2172            _header_params['Content-Type'] = _content_type
2173        else:
2174            _default_content_type = (
2175                self.api_client.select_header_content_type(
2176                    [
2177                        'application/json'
2178                    ]
2179                )
2180            )
2181            if _default_content_type is not None:
2182                _header_params['Content-Type'] = _default_content_type
2183
2184        # authentication setting
2185        _auth_settings: List[str] = [
2186            'bearerAuth'
2187        ]
2188
2189        return self.api_client.param_serialize(
2190            method='PATCH',
2191            resource_path='/org/{organizationId}/connectors/sources/{sourceConnectorId}',
2192            path_params=_path_params,
2193            query_params=_query_params,
2194            header_params=_header_params,
2195            body=_body_params,
2196            post_params=_form_params,
2197            files=_files,
2198            auth_settings=_auth_settings,
2199            collection_formats=_collection_formats,
2200            _host=_host,
2201            _request_auth=_request_auth
2202        )
2203
2204
2205
2206
2207    @validate_call
2208    def update_user_in_source_connector(
2209        self,
2210        organization_id: StrictStr,
2211        source_connector_id: StrictStr,
2212        update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest,
2213        _request_timeout: Union[
2214            None,
2215            Annotated[StrictFloat, Field(gt=0)],
2216            Tuple[
2217                Annotated[StrictFloat, Field(gt=0)],
2218                Annotated[StrictFloat, Field(gt=0)]
2219            ]
2220        ] = None,
2221        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2222        _content_type: Optional[StrictStr] = None,
2223        _headers: Optional[Dict[StrictStr, Any]] = None,
2224        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2225    ) -> UpdateUserInSourceConnectorResponse:
2226        """Update a source connector user
2227
2228        Update a source connector user
2229
2230        :param organization_id: (required)
2231        :type organization_id: str
2232        :param source_connector_id: (required)
2233        :type source_connector_id: str
2234        :param update_user_in_source_connector_request: (required)
2235        :type update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest
2236        :param _request_timeout: timeout setting for this request. If one
2237                                 number provided, it will be total request
2238                                 timeout. It can also be a pair (tuple) of
2239                                 (connection, read) timeouts.
2240        :type _request_timeout: int, tuple(int, int), optional
2241        :param _request_auth: set to override the auth_settings for an a single
2242                              request; this effectively ignores the
2243                              authentication in the spec for a single request.
2244        :type _request_auth: dict, optional
2245        :param _content_type: force content-type for the request.
2246        :type _content_type: str, Optional
2247        :param _headers: set to override the headers for a single
2248                         request; this effectively ignores the headers
2249                         in the spec for a single request.
2250        :type _headers: dict, optional
2251        :param _host_index: set to override the host_index for a single
2252                            request; this effectively ignores the host_index
2253                            in the spec for a single request.
2254        :type _host_index: int, optional
2255        :return: Returns the result object.
2256        """ # noqa: E501
2257
2258        _param = self._update_user_in_source_connector_serialize(
2259            organization_id=organization_id,
2260            source_connector_id=source_connector_id,
2261            update_user_in_source_connector_request=update_user_in_source_connector_request,
2262            _request_auth=_request_auth,
2263            _content_type=_content_type,
2264            _headers=_headers,
2265            _host_index=_host_index
2266        )
2267
2268        _response_types_map: Dict[str, Optional[str]] = {
2269            '200': "UpdateUserInSourceConnectorResponse",
2270            '400': "GetPipelines400Response",
2271            '401': "GetPipelines400Response",
2272            '403': "GetPipelines400Response",
2273            '404': "GetPipelines400Response",
2274            '500': "GetPipelines400Response",
2275        }
2276        response_data = self.api_client.call_api(
2277            *_param,
2278            _request_timeout=_request_timeout
2279        )
2280        response_data.read()
2281        return self.api_client.response_deserialize(
2282            response_data=response_data,
2283            response_types_map=_response_types_map,
2284        ).data
2285
2286
2287    @validate_call
2288    def update_user_in_source_connector_with_http_info(
2289        self,
2290        organization_id: StrictStr,
2291        source_connector_id: StrictStr,
2292        update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest,
2293        _request_timeout: Union[
2294            None,
2295            Annotated[StrictFloat, Field(gt=0)],
2296            Tuple[
2297                Annotated[StrictFloat, Field(gt=0)],
2298                Annotated[StrictFloat, Field(gt=0)]
2299            ]
2300        ] = None,
2301        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2302        _content_type: Optional[StrictStr] = None,
2303        _headers: Optional[Dict[StrictStr, Any]] = None,
2304        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2305    ) -> ApiResponse[UpdateUserInSourceConnectorResponse]:
2306        """Update a source connector user
2307
2308        Update a source connector user
2309
2310        :param organization_id: (required)
2311        :type organization_id: str
2312        :param source_connector_id: (required)
2313        :type source_connector_id: str
2314        :param update_user_in_source_connector_request: (required)
2315        :type update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest
2316        :param _request_timeout: timeout setting for this request. If one
2317                                 number provided, it will be total request
2318                                 timeout. It can also be a pair (tuple) of
2319                                 (connection, read) timeouts.
2320        :type _request_timeout: int, tuple(int, int), optional
2321        :param _request_auth: set to override the auth_settings for an a single
2322                              request; this effectively ignores the
2323                              authentication in the spec for a single request.
2324        :type _request_auth: dict, optional
2325        :param _content_type: force content-type for the request.
2326        :type _content_type: str, Optional
2327        :param _headers: set to override the headers for a single
2328                         request; this effectively ignores the headers
2329                         in the spec for a single request.
2330        :type _headers: dict, optional
2331        :param _host_index: set to override the host_index for a single
2332                            request; this effectively ignores the host_index
2333                            in the spec for a single request.
2334        :type _host_index: int, optional
2335        :return: Returns the result object.
2336        """ # noqa: E501
2337
2338        _param = self._update_user_in_source_connector_serialize(
2339            organization_id=organization_id,
2340            source_connector_id=source_connector_id,
2341            update_user_in_source_connector_request=update_user_in_source_connector_request,
2342            _request_auth=_request_auth,
2343            _content_type=_content_type,
2344            _headers=_headers,
2345            _host_index=_host_index
2346        )
2347
2348        _response_types_map: Dict[str, Optional[str]] = {
2349            '200': "UpdateUserInSourceConnectorResponse",
2350            '400': "GetPipelines400Response",
2351            '401': "GetPipelines400Response",
2352            '403': "GetPipelines400Response",
2353            '404': "GetPipelines400Response",
2354            '500': "GetPipelines400Response",
2355        }
2356        response_data = self.api_client.call_api(
2357            *_param,
2358            _request_timeout=_request_timeout
2359        )
2360        response_data.read()
2361        return self.api_client.response_deserialize(
2362            response_data=response_data,
2363            response_types_map=_response_types_map,
2364        )
2365
2366
2367    @validate_call
2368    def update_user_in_source_connector_without_preload_content(
2369        self,
2370        organization_id: StrictStr,
2371        source_connector_id: StrictStr,
2372        update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest,
2373        _request_timeout: Union[
2374            None,
2375            Annotated[StrictFloat, Field(gt=0)],
2376            Tuple[
2377                Annotated[StrictFloat, Field(gt=0)],
2378                Annotated[StrictFloat, Field(gt=0)]
2379            ]
2380        ] = None,
2381        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2382        _content_type: Optional[StrictStr] = None,
2383        _headers: Optional[Dict[StrictStr, Any]] = None,
2384        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2385    ) -> RESTResponseType:
2386        """Update a source connector user
2387
2388        Update a source connector user
2389
2390        :param organization_id: (required)
2391        :type organization_id: str
2392        :param source_connector_id: (required)
2393        :type source_connector_id: str
2394        :param update_user_in_source_connector_request: (required)
2395        :type update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest
2396        :param _request_timeout: timeout setting for this request. If one
2397                                 number provided, it will be total request
2398                                 timeout. It can also be a pair (tuple) of
2399                                 (connection, read) timeouts.
2400        :type _request_timeout: int, tuple(int, int), optional
2401        :param _request_auth: set to override the auth_settings for an a single
2402                              request; this effectively ignores the
2403                              authentication in the spec for a single request.
2404        :type _request_auth: dict, optional
2405        :param _content_type: force content-type for the request.
2406        :type _content_type: str, Optional
2407        :param _headers: set to override the headers for a single
2408                         request; this effectively ignores the headers
2409                         in the spec for a single request.
2410        :type _headers: dict, optional
2411        :param _host_index: set to override the host_index for a single
2412                            request; this effectively ignores the host_index
2413                            in the spec for a single request.
2414        :type _host_index: int, optional
2415        :return: Returns the result object.
2416        """ # noqa: E501
2417
2418        _param = self._update_user_in_source_connector_serialize(
2419            organization_id=organization_id,
2420            source_connector_id=source_connector_id,
2421            update_user_in_source_connector_request=update_user_in_source_connector_request,
2422            _request_auth=_request_auth,
2423            _content_type=_content_type,
2424            _headers=_headers,
2425            _host_index=_host_index
2426        )
2427
2428        _response_types_map: Dict[str, Optional[str]] = {
2429            '200': "UpdateUserInSourceConnectorResponse",
2430            '400': "GetPipelines400Response",
2431            '401': "GetPipelines400Response",
2432            '403': "GetPipelines400Response",
2433            '404': "GetPipelines400Response",
2434            '500': "GetPipelines400Response",
2435        }
2436        response_data = self.api_client.call_api(
2437            *_param,
2438            _request_timeout=_request_timeout
2439        )
2440        return response_data.response
2441
2442
2443    def _update_user_in_source_connector_serialize(
2444        self,
2445        organization_id,
2446        source_connector_id,
2447        update_user_in_source_connector_request,
2448        _request_auth,
2449        _content_type,
2450        _headers,
2451        _host_index,
2452    ) -> RequestSerialized:
2453
2454        _host = None
2455
2456        _collection_formats: Dict[str, str] = {
2457        }
2458
2459        _path_params: Dict[str, str] = {}
2460        _query_params: List[Tuple[str, str]] = []
2461        _header_params: Dict[str, Optional[str]] = _headers or {}
2462        _form_params: List[Tuple[str, str]] = []
2463        _files: Dict[
2464            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
2465        ] = {}
2466        _body_params: Optional[bytes] = None
2467
2468        # process the path parameters
2469        if organization_id is not None:
2470            _path_params['organizationId'] = organization_id
2471        if source_connector_id is not None:
2472            _path_params['sourceConnectorId'] = source_connector_id
2473        # process the query parameters
2474        # process the header parameters
2475        # process the form parameters
2476        # process the body parameter
2477        if update_user_in_source_connector_request is not None:
2478            _body_params = update_user_in_source_connector_request
2479
2480
2481        # set the HTTP header `Accept`
2482        if 'Accept' not in _header_params:
2483            _header_params['Accept'] = self.api_client.select_header_accept(
2484                [
2485                    'application/json'
2486                ]
2487            )
2488
2489        # set the HTTP header `Content-Type`
2490        if _content_type:
2491            _header_params['Content-Type'] = _content_type
2492        else:
2493            _default_content_type = (
2494                self.api_client.select_header_content_type(
2495                    [
2496                        'application/json'
2497                    ]
2498                )
2499            )
2500            if _default_content_type is not None:
2501                _header_params['Content-Type'] = _default_content_type
2502
2503        # authentication setting
2504        _auth_settings: List[str] = [
2505            'bearerAuth'
2506        ]
2507
2508        return self.api_client.param_serialize(
2509            method='PATCH',
2510            resource_path='/org/{organizationId}/connectors/sources/{sourceConnectorId}/users',
2511            path_params=_path_params,
2512            query_params=_query_params,
2513            header_params=_header_params,
2514            body=_body_params,
2515            post_params=_form_params,
2516            files=_files,
2517            auth_settings=_auth_settings,
2518            collection_formats=_collection_formats,
2519            _host=_host,
2520            _request_auth=_request_auth
2521        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

SourceConnectorsApi(api_client=None)
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
api_client
@validate_call
def add_user_to_source_connector( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_id: typing.Annotated[str, Strict(strict=True)], add_user_to_source_connector_request: vectorize_client.models.add_user_to_source_connector_request.AddUserToSourceConnectorRequest, _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.add_user_from_source_connector_response.AddUserFromSourceConnectorResponse:
 54    @validate_call
 55    def add_user_to_source_connector(
 56        self,
 57        organization_id: StrictStr,
 58        source_connector_id: StrictStr,
 59        add_user_to_source_connector_request: AddUserToSourceConnectorRequest,
 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    ) -> AddUserFromSourceConnectorResponse:
 73        """Add a user to a source connector
 74
 75        Add a user to a source connector
 76
 77        :param organization_id: (required)
 78        :type organization_id: str
 79        :param source_connector_id: (required)
 80        :type source_connector_id: str
 81        :param add_user_to_source_connector_request: (required)
 82        :type add_user_to_source_connector_request: AddUserToSourceConnectorRequest
 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._add_user_to_source_connector_serialize(
106            organization_id=organization_id,
107            source_connector_id=source_connector_id,
108            add_user_to_source_connector_request=add_user_to_source_connector_request,
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': "AddUserFromSourceConnectorResponse",
117            '400': "GetPipelines400Response",
118            '401': "GetPipelines400Response",
119            '403': "GetPipelines400Response",
120            '404': "GetPipelines400Response",
121            '500': "GetPipelines400Response",
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

Add a user to a source connector

Add a user to a source connector

Parameters
  • organization_id: (required)
  • source_connector_id: (required)
  • add_user_to_source_connector_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 add_user_to_source_connector_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_id: typing.Annotated[str, Strict(strict=True)], add_user_to_source_connector_request: vectorize_client.models.add_user_to_source_connector_request.AddUserToSourceConnectorRequest, _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[AddUserFromSourceConnectorResponse]:
134    @validate_call
135    def add_user_to_source_connector_with_http_info(
136        self,
137        organization_id: StrictStr,
138        source_connector_id: StrictStr,
139        add_user_to_source_connector_request: AddUserToSourceConnectorRequest,
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[AddUserFromSourceConnectorResponse]:
153        """Add a user to a source connector
154
155        Add a user to a source connector
156
157        :param organization_id: (required)
158        :type organization_id: str
159        :param source_connector_id: (required)
160        :type source_connector_id: str
161        :param add_user_to_source_connector_request: (required)
162        :type add_user_to_source_connector_request: AddUserToSourceConnectorRequest
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._add_user_to_source_connector_serialize(
186            organization_id=organization_id,
187            source_connector_id=source_connector_id,
188            add_user_to_source_connector_request=add_user_to_source_connector_request,
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': "AddUserFromSourceConnectorResponse",
197            '400': "GetPipelines400Response",
198            '401': "GetPipelines400Response",
199            '403': "GetPipelines400Response",
200            '404': "GetPipelines400Response",
201            '500': "GetPipelines400Response",
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        )

Add a user to a source connector

Add a user to a source connector

Parameters
  • organization_id: (required)
  • source_connector_id: (required)
  • add_user_to_source_connector_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 add_user_to_source_connector_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_id: typing.Annotated[str, Strict(strict=True)], add_user_to_source_connector_request: vectorize_client.models.add_user_to_source_connector_request.AddUserToSourceConnectorRequest, _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:
214    @validate_call
215    def add_user_to_source_connector_without_preload_content(
216        self,
217        organization_id: StrictStr,
218        source_connector_id: StrictStr,
219        add_user_to_source_connector_request: AddUserToSourceConnectorRequest,
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        """Add a user to a source connector
234
235        Add a user to a source connector
236
237        :param organization_id: (required)
238        :type organization_id: str
239        :param source_connector_id: (required)
240        :type source_connector_id: str
241        :param add_user_to_source_connector_request: (required)
242        :type add_user_to_source_connector_request: AddUserToSourceConnectorRequest
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._add_user_to_source_connector_serialize(
266            organization_id=organization_id,
267            source_connector_id=source_connector_id,
268            add_user_to_source_connector_request=add_user_to_source_connector_request,
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': "AddUserFromSourceConnectorResponse",
277            '400': "GetPipelines400Response",
278            '401': "GetPipelines400Response",
279            '403': "GetPipelines400Response",
280            '404': "GetPipelines400Response",
281            '500': "GetPipelines400Response",
282        }
283        response_data = self.api_client.call_api(
284            *_param,
285            _request_timeout=_request_timeout
286        )
287        return response_data.response

Add a user to a source connector

Add a user to a source connector

Parameters
  • organization_id: (required)
  • source_connector_id: (required)
  • add_user_to_source_connector_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 create_source_connector( self, organization_id: typing.Annotated[str, Strict(strict=True)], create_source_connector_request: vectorize_client.models.create_source_connector_request.CreateSourceConnectorRequest, 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_source_connector_response.CreateSourceConnectorResponse:
373    @validate_call
374    def create_source_connector(
375        self,
376        organization_id: StrictStr,
377        create_source_connector_request: CreateSourceConnectorRequest,
378        workspace_id: Optional[StrictStr] = None,
379        _request_timeout: Union[
380            None,
381            Annotated[StrictFloat, Field(gt=0)],
382            Tuple[
383                Annotated[StrictFloat, Field(gt=0)],
384                Annotated[StrictFloat, Field(gt=0)]
385            ]
386        ] = None,
387        _request_auth: Optional[Dict[StrictStr, Any]] = None,
388        _content_type: Optional[StrictStr] = None,
389        _headers: Optional[Dict[StrictStr, Any]] = None,
390        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
391    ) -> CreateSourceConnectorResponse:
392        """Create a new source connector
393
394        Creates a new source connector for data ingestion. The specific configuration fields required depend on the connector type selected.
395
396        :param organization_id: (required)
397        :type organization_id: str
398        :param create_source_connector_request: (required)
399        :type create_source_connector_request: CreateSourceConnectorRequest
400        :param workspace_id:
401        :type workspace_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._create_source_connector_serialize(
425            organization_id=organization_id,
426            create_source_connector_request=create_source_connector_request,
427            workspace_id=workspace_id,
428            _request_auth=_request_auth,
429            _content_type=_content_type,
430            _headers=_headers,
431            _host_index=_host_index
432        )
433
434        _response_types_map: Dict[str, Optional[str]] = {
435            '200': "CreateSourceConnectorResponse",
436            '400': "GetPipelines400Response",
437            '401': "GetPipelines400Response",
438            '403': "GetPipelines400Response",
439            '404': "GetPipelines400Response",
440            '500': "GetPipelines400Response",
441        }
442        response_data = self.api_client.call_api(
443            *_param,
444            _request_timeout=_request_timeout
445        )
446        response_data.read()
447        return self.api_client.response_deserialize(
448            response_data=response_data,
449            response_types_map=_response_types_map,
450        ).data

Create a new source connector

Creates a new source connector for data ingestion. The specific configuration fields required depend on the connector type selected.

Parameters
  • organization_id: (required)
  • create_source_connector_request: (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_source_connector_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], create_source_connector_request: vectorize_client.models.create_source_connector_request.CreateSourceConnectorRequest, 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[CreateSourceConnectorResponse]:
453    @validate_call
454    def create_source_connector_with_http_info(
455        self,
456        organization_id: StrictStr,
457        create_source_connector_request: CreateSourceConnectorRequest,
458        workspace_id: Optional[StrictStr] = None,
459        _request_timeout: Union[
460            None,
461            Annotated[StrictFloat, Field(gt=0)],
462            Tuple[
463                Annotated[StrictFloat, Field(gt=0)],
464                Annotated[StrictFloat, Field(gt=0)]
465            ]
466        ] = None,
467        _request_auth: Optional[Dict[StrictStr, Any]] = None,
468        _content_type: Optional[StrictStr] = None,
469        _headers: Optional[Dict[StrictStr, Any]] = None,
470        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
471    ) -> ApiResponse[CreateSourceConnectorResponse]:
472        """Create a new source connector
473
474        Creates a new source connector for data ingestion. The specific configuration fields required depend on the connector type selected.
475
476        :param organization_id: (required)
477        :type organization_id: str
478        :param create_source_connector_request: (required)
479        :type create_source_connector_request: CreateSourceConnectorRequest
480        :param workspace_id:
481        :type workspace_id: str
482        :param _request_timeout: timeout setting for this request. If one
483                                 number provided, it will be total request
484                                 timeout. It can also be a pair (tuple) of
485                                 (connection, read) timeouts.
486        :type _request_timeout: int, tuple(int, int), optional
487        :param _request_auth: set to override the auth_settings for an a single
488                              request; this effectively ignores the
489                              authentication in the spec for a single request.
490        :type _request_auth: dict, optional
491        :param _content_type: force content-type for the request.
492        :type _content_type: str, Optional
493        :param _headers: set to override the headers for a single
494                         request; this effectively ignores the headers
495                         in the spec for a single request.
496        :type _headers: dict, optional
497        :param _host_index: set to override the host_index for a single
498                            request; this effectively ignores the host_index
499                            in the spec for a single request.
500        :type _host_index: int, optional
501        :return: Returns the result object.
502        """ # noqa: E501
503
504        _param = self._create_source_connector_serialize(
505            organization_id=organization_id,
506            create_source_connector_request=create_source_connector_request,
507            workspace_id=workspace_id,
508            _request_auth=_request_auth,
509            _content_type=_content_type,
510            _headers=_headers,
511            _host_index=_host_index
512        )
513
514        _response_types_map: Dict[str, Optional[str]] = {
515            '200': "CreateSourceConnectorResponse",
516            '400': "GetPipelines400Response",
517            '401': "GetPipelines400Response",
518            '403': "GetPipelines400Response",
519            '404': "GetPipelines400Response",
520            '500': "GetPipelines400Response",
521        }
522        response_data = self.api_client.call_api(
523            *_param,
524            _request_timeout=_request_timeout
525        )
526        response_data.read()
527        return self.api_client.response_deserialize(
528            response_data=response_data,
529            response_types_map=_response_types_map,
530        )

Create a new source connector

Creates a new source connector for data ingestion. The specific configuration fields required depend on the connector type selected.

Parameters
  • organization_id: (required)
  • create_source_connector_request: (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_source_connector_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], create_source_connector_request: vectorize_client.models.create_source_connector_request.CreateSourceConnectorRequest, 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:
533    @validate_call
534    def create_source_connector_without_preload_content(
535        self,
536        organization_id: StrictStr,
537        create_source_connector_request: CreateSourceConnectorRequest,
538        workspace_id: Optional[StrictStr] = None,
539        _request_timeout: Union[
540            None,
541            Annotated[StrictFloat, Field(gt=0)],
542            Tuple[
543                Annotated[StrictFloat, Field(gt=0)],
544                Annotated[StrictFloat, Field(gt=0)]
545            ]
546        ] = None,
547        _request_auth: Optional[Dict[StrictStr, Any]] = None,
548        _content_type: Optional[StrictStr] = None,
549        _headers: Optional[Dict[StrictStr, Any]] = None,
550        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
551    ) -> RESTResponseType:
552        """Create a new source connector
553
554        Creates a new source connector for data ingestion. The specific configuration fields required depend on the connector type selected.
555
556        :param organization_id: (required)
557        :type organization_id: str
558        :param create_source_connector_request: (required)
559        :type create_source_connector_request: CreateSourceConnectorRequest
560        :param workspace_id:
561        :type workspace_id: str
562        :param _request_timeout: timeout setting for this request. If one
563                                 number provided, it will be total request
564                                 timeout. It can also be a pair (tuple) of
565                                 (connection, read) timeouts.
566        :type _request_timeout: int, tuple(int, int), optional
567        :param _request_auth: set to override the auth_settings for an a single
568                              request; this effectively ignores the
569                              authentication in the spec for a single request.
570        :type _request_auth: dict, optional
571        :param _content_type: force content-type for the request.
572        :type _content_type: str, Optional
573        :param _headers: set to override the headers for a single
574                         request; this effectively ignores the headers
575                         in the spec for a single request.
576        :type _headers: dict, optional
577        :param _host_index: set to override the host_index for a single
578                            request; this effectively ignores the host_index
579                            in the spec for a single request.
580        :type _host_index: int, optional
581        :return: Returns the result object.
582        """ # noqa: E501
583
584        _param = self._create_source_connector_serialize(
585            organization_id=organization_id,
586            create_source_connector_request=create_source_connector_request,
587            workspace_id=workspace_id,
588            _request_auth=_request_auth,
589            _content_type=_content_type,
590            _headers=_headers,
591            _host_index=_host_index
592        )
593
594        _response_types_map: Dict[str, Optional[str]] = {
595            '200': "CreateSourceConnectorResponse",
596            '400': "GetPipelines400Response",
597            '401': "GetPipelines400Response",
598            '403': "GetPipelines400Response",
599            '404': "GetPipelines400Response",
600            '500': "GetPipelines400Response",
601        }
602        response_data = self.api_client.call_api(
603            *_param,
604            _request_timeout=_request_timeout
605        )
606        return response_data.response

Create a new source connector

Creates a new source connector for data ingestion. The specific configuration fields required depend on the connector type selected.

Parameters
  • organization_id: (required)
  • create_source_connector_request: (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_source_connector( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_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_source_connector_response.DeleteSourceConnectorResponse:
694    @validate_call
695    def delete_source_connector(
696        self,
697        organization_id: StrictStr,
698        source_connector_id: StrictStr,
699        _request_timeout: Union[
700            None,
701            Annotated[StrictFloat, Field(gt=0)],
702            Tuple[
703                Annotated[StrictFloat, Field(gt=0)],
704                Annotated[StrictFloat, Field(gt=0)]
705            ]
706        ] = None,
707        _request_auth: Optional[Dict[StrictStr, Any]] = None,
708        _content_type: Optional[StrictStr] = None,
709        _headers: Optional[Dict[StrictStr, Any]] = None,
710        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
711    ) -> DeleteSourceConnectorResponse:
712        """Delete a source connector
713
714        Delete a source connector
715
716        :param organization_id: (required)
717        :type organization_id: str
718        :param source_connector_id: (required)
719        :type source_connector_id: str
720        :param _request_timeout: timeout setting for this request. If one
721                                 number provided, it will be total request
722                                 timeout. It can also be a pair (tuple) of
723                                 (connection, read) timeouts.
724        :type _request_timeout: int, tuple(int, int), optional
725        :param _request_auth: set to override the auth_settings for an a single
726                              request; this effectively ignores the
727                              authentication in the spec for a single request.
728        :type _request_auth: dict, optional
729        :param _content_type: force content-type for the request.
730        :type _content_type: str, Optional
731        :param _headers: set to override the headers for a single
732                         request; this effectively ignores the headers
733                         in the spec for a single request.
734        :type _headers: dict, optional
735        :param _host_index: set to override the host_index for a single
736                            request; this effectively ignores the host_index
737                            in the spec for a single request.
738        :type _host_index: int, optional
739        :return: Returns the result object.
740        """ # noqa: E501
741
742        _param = self._delete_source_connector_serialize(
743            organization_id=organization_id,
744            source_connector_id=source_connector_id,
745            _request_auth=_request_auth,
746            _content_type=_content_type,
747            _headers=_headers,
748            _host_index=_host_index
749        )
750
751        _response_types_map: Dict[str, Optional[str]] = {
752            '200': "DeleteSourceConnectorResponse",
753            '400': "GetPipelines400Response",
754            '401': "GetPipelines400Response",
755            '403': "GetPipelines400Response",
756            '404': "GetPipelines400Response",
757            '500': "GetPipelines400Response",
758        }
759        response_data = self.api_client.call_api(
760            *_param,
761            _request_timeout=_request_timeout
762        )
763        response_data.read()
764        return self.api_client.response_deserialize(
765            response_data=response_data,
766            response_types_map=_response_types_map,
767        ).data

Delete a source connector

Delete a source connector

Parameters
  • organization_id: (required)
  • source_connector_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_source_connector_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_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[DeleteSourceConnectorResponse]:
770    @validate_call
771    def delete_source_connector_with_http_info(
772        self,
773        organization_id: StrictStr,
774        source_connector_id: StrictStr,
775        _request_timeout: Union[
776            None,
777            Annotated[StrictFloat, Field(gt=0)],
778            Tuple[
779                Annotated[StrictFloat, Field(gt=0)],
780                Annotated[StrictFloat, Field(gt=0)]
781            ]
782        ] = None,
783        _request_auth: Optional[Dict[StrictStr, Any]] = None,
784        _content_type: Optional[StrictStr] = None,
785        _headers: Optional[Dict[StrictStr, Any]] = None,
786        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
787    ) -> ApiResponse[DeleteSourceConnectorResponse]:
788        """Delete a source connector
789
790        Delete a source connector
791
792        :param organization_id: (required)
793        :type organization_id: str
794        :param source_connector_id: (required)
795        :type source_connector_id: str
796        :param _request_timeout: timeout setting for this request. If one
797                                 number provided, it will be total request
798                                 timeout. It can also be a pair (tuple) of
799                                 (connection, read) timeouts.
800        :type _request_timeout: int, tuple(int, int), optional
801        :param _request_auth: set to override the auth_settings for an a single
802                              request; this effectively ignores the
803                              authentication in the spec for a single request.
804        :type _request_auth: dict, optional
805        :param _content_type: force content-type for the request.
806        :type _content_type: str, Optional
807        :param _headers: set to override the headers for a single
808                         request; this effectively ignores the headers
809                         in the spec for a single request.
810        :type _headers: dict, optional
811        :param _host_index: set to override the host_index for a single
812                            request; this effectively ignores the host_index
813                            in the spec for a single request.
814        :type _host_index: int, optional
815        :return: Returns the result object.
816        """ # noqa: E501
817
818        _param = self._delete_source_connector_serialize(
819            organization_id=organization_id,
820            source_connector_id=source_connector_id,
821            _request_auth=_request_auth,
822            _content_type=_content_type,
823            _headers=_headers,
824            _host_index=_host_index
825        )
826
827        _response_types_map: Dict[str, Optional[str]] = {
828            '200': "DeleteSourceConnectorResponse",
829            '400': "GetPipelines400Response",
830            '401': "GetPipelines400Response",
831            '403': "GetPipelines400Response",
832            '404': "GetPipelines400Response",
833            '500': "GetPipelines400Response",
834        }
835        response_data = self.api_client.call_api(
836            *_param,
837            _request_timeout=_request_timeout
838        )
839        response_data.read()
840        return self.api_client.response_deserialize(
841            response_data=response_data,
842            response_types_map=_response_types_map,
843        )

Delete a source connector

Delete a source connector

Parameters
  • organization_id: (required)
  • source_connector_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_source_connector_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_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:
846    @validate_call
847    def delete_source_connector_without_preload_content(
848        self,
849        organization_id: StrictStr,
850        source_connector_id: StrictStr,
851        _request_timeout: Union[
852            None,
853            Annotated[StrictFloat, Field(gt=0)],
854            Tuple[
855                Annotated[StrictFloat, Field(gt=0)],
856                Annotated[StrictFloat, Field(gt=0)]
857            ]
858        ] = None,
859        _request_auth: Optional[Dict[StrictStr, Any]] = None,
860        _content_type: Optional[StrictStr] = None,
861        _headers: Optional[Dict[StrictStr, Any]] = None,
862        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
863    ) -> RESTResponseType:
864        """Delete a source connector
865
866        Delete a source connector
867
868        :param organization_id: (required)
869        :type organization_id: str
870        :param source_connector_id: (required)
871        :type source_connector_id: str
872        :param _request_timeout: timeout setting for this request. If one
873                                 number provided, it will be total request
874                                 timeout. It can also be a pair (tuple) of
875                                 (connection, read) timeouts.
876        :type _request_timeout: int, tuple(int, int), optional
877        :param _request_auth: set to override the auth_settings for an a single
878                              request; this effectively ignores the
879                              authentication in the spec for a single request.
880        :type _request_auth: dict, optional
881        :param _content_type: force content-type for the request.
882        :type _content_type: str, Optional
883        :param _headers: set to override the headers for a single
884                         request; this effectively ignores the headers
885                         in the spec for a single request.
886        :type _headers: dict, optional
887        :param _host_index: set to override the host_index for a single
888                            request; this effectively ignores the host_index
889                            in the spec for a single request.
890        :type _host_index: int, optional
891        :return: Returns the result object.
892        """ # noqa: E501
893
894        _param = self._delete_source_connector_serialize(
895            organization_id=organization_id,
896            source_connector_id=source_connector_id,
897            _request_auth=_request_auth,
898            _content_type=_content_type,
899            _headers=_headers,
900            _host_index=_host_index
901        )
902
903        _response_types_map: Dict[str, Optional[str]] = {
904            '200': "DeleteSourceConnectorResponse",
905            '400': "GetPipelines400Response",
906            '401': "GetPipelines400Response",
907            '403': "GetPipelines400Response",
908            '404': "GetPipelines400Response",
909            '500': "GetPipelines400Response",
910        }
911        response_data = self.api_client.call_api(
912            *_param,
913            _request_timeout=_request_timeout
914        )
915        return response_data.response

Delete a source connector

Delete a source connector

Parameters
  • organization_id: (required)
  • source_connector_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_user_from_source_connector( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_id: typing.Annotated[str, Strict(strict=True)], remove_user_from_source_connector_request: vectorize_client.models.remove_user_from_source_connector_request.RemoveUserFromSourceConnectorRequest, _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.remove_user_from_source_connector_response.RemoveUserFromSourceConnectorResponse:
 985    @validate_call
 986    def delete_user_from_source_connector(
 987        self,
 988        organization_id: StrictStr,
 989        source_connector_id: StrictStr,
 990        remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest,
 991        _request_timeout: Union[
 992            None,
 993            Annotated[StrictFloat, Field(gt=0)],
 994            Tuple[
 995                Annotated[StrictFloat, Field(gt=0)],
 996                Annotated[StrictFloat, Field(gt=0)]
 997            ]
 998        ] = None,
 999        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1000        _content_type: Optional[StrictStr] = None,
1001        _headers: Optional[Dict[StrictStr, Any]] = None,
1002        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1003    ) -> RemoveUserFromSourceConnectorResponse:
1004        """Delete a source connector user
1005
1006        Delete a source connector user
1007
1008        :param organization_id: (required)
1009        :type organization_id: str
1010        :param source_connector_id: (required)
1011        :type source_connector_id: str
1012        :param remove_user_from_source_connector_request: (required)
1013        :type remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest
1014        :param _request_timeout: timeout setting for this request. If one
1015                                 number provided, it will be total request
1016                                 timeout. It can also be a pair (tuple) of
1017                                 (connection, read) timeouts.
1018        :type _request_timeout: int, tuple(int, int), optional
1019        :param _request_auth: set to override the auth_settings for an a single
1020                              request; this effectively ignores the
1021                              authentication in the spec for a single request.
1022        :type _request_auth: dict, optional
1023        :param _content_type: force content-type for the request.
1024        :type _content_type: str, Optional
1025        :param _headers: set to override the headers for a single
1026                         request; this effectively ignores the headers
1027                         in the spec for a single request.
1028        :type _headers: dict, optional
1029        :param _host_index: set to override the host_index for a single
1030                            request; this effectively ignores the host_index
1031                            in the spec for a single request.
1032        :type _host_index: int, optional
1033        :return: Returns the result object.
1034        """ # noqa: E501
1035
1036        _param = self._delete_user_from_source_connector_serialize(
1037            organization_id=organization_id,
1038            source_connector_id=source_connector_id,
1039            remove_user_from_source_connector_request=remove_user_from_source_connector_request,
1040            _request_auth=_request_auth,
1041            _content_type=_content_type,
1042            _headers=_headers,
1043            _host_index=_host_index
1044        )
1045
1046        _response_types_map: Dict[str, Optional[str]] = {
1047            '200': "RemoveUserFromSourceConnectorResponse",
1048            '400': "GetPipelines400Response",
1049            '401': "GetPipelines400Response",
1050            '403': "GetPipelines400Response",
1051            '404': "GetPipelines400Response",
1052            '500': "GetPipelines400Response",
1053        }
1054        response_data = self.api_client.call_api(
1055            *_param,
1056            _request_timeout=_request_timeout
1057        )
1058        response_data.read()
1059        return self.api_client.response_deserialize(
1060            response_data=response_data,
1061            response_types_map=_response_types_map,
1062        ).data

Delete a source connector user

Delete a source connector user

Parameters
  • organization_id: (required)
  • source_connector_id: (required)
  • remove_user_from_source_connector_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 delete_user_from_source_connector_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_id: typing.Annotated[str, Strict(strict=True)], remove_user_from_source_connector_request: vectorize_client.models.remove_user_from_source_connector_request.RemoveUserFromSourceConnectorRequest, _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[RemoveUserFromSourceConnectorResponse]:
1065    @validate_call
1066    def delete_user_from_source_connector_with_http_info(
1067        self,
1068        organization_id: StrictStr,
1069        source_connector_id: StrictStr,
1070        remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest,
1071        _request_timeout: Union[
1072            None,
1073            Annotated[StrictFloat, Field(gt=0)],
1074            Tuple[
1075                Annotated[StrictFloat, Field(gt=0)],
1076                Annotated[StrictFloat, Field(gt=0)]
1077            ]
1078        ] = None,
1079        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1080        _content_type: Optional[StrictStr] = None,
1081        _headers: Optional[Dict[StrictStr, Any]] = None,
1082        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1083    ) -> ApiResponse[RemoveUserFromSourceConnectorResponse]:
1084        """Delete a source connector user
1085
1086        Delete a source connector user
1087
1088        :param organization_id: (required)
1089        :type organization_id: str
1090        :param source_connector_id: (required)
1091        :type source_connector_id: str
1092        :param remove_user_from_source_connector_request: (required)
1093        :type remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest
1094        :param _request_timeout: timeout setting for this request. If one
1095                                 number provided, it will be total request
1096                                 timeout. It can also be a pair (tuple) of
1097                                 (connection, read) timeouts.
1098        :type _request_timeout: int, tuple(int, int), optional
1099        :param _request_auth: set to override the auth_settings for an a single
1100                              request; this effectively ignores the
1101                              authentication in the spec for a single request.
1102        :type _request_auth: dict, optional
1103        :param _content_type: force content-type for the request.
1104        :type _content_type: str, Optional
1105        :param _headers: set to override the headers for a single
1106                         request; this effectively ignores the headers
1107                         in the spec for a single request.
1108        :type _headers: dict, optional
1109        :param _host_index: set to override the host_index for a single
1110                            request; this effectively ignores the host_index
1111                            in the spec for a single request.
1112        :type _host_index: int, optional
1113        :return: Returns the result object.
1114        """ # noqa: E501
1115
1116        _param = self._delete_user_from_source_connector_serialize(
1117            organization_id=organization_id,
1118            source_connector_id=source_connector_id,
1119            remove_user_from_source_connector_request=remove_user_from_source_connector_request,
1120            _request_auth=_request_auth,
1121            _content_type=_content_type,
1122            _headers=_headers,
1123            _host_index=_host_index
1124        )
1125
1126        _response_types_map: Dict[str, Optional[str]] = {
1127            '200': "RemoveUserFromSourceConnectorResponse",
1128            '400': "GetPipelines400Response",
1129            '401': "GetPipelines400Response",
1130            '403': "GetPipelines400Response",
1131            '404': "GetPipelines400Response",
1132            '500': "GetPipelines400Response",
1133        }
1134        response_data = self.api_client.call_api(
1135            *_param,
1136            _request_timeout=_request_timeout
1137        )
1138        response_data.read()
1139        return self.api_client.response_deserialize(
1140            response_data=response_data,
1141            response_types_map=_response_types_map,
1142        )

Delete a source connector user

Delete a source connector user

Parameters
  • organization_id: (required)
  • source_connector_id: (required)
  • remove_user_from_source_connector_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 delete_user_from_source_connector_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_id: typing.Annotated[str, Strict(strict=True)], remove_user_from_source_connector_request: vectorize_client.models.remove_user_from_source_connector_request.RemoveUserFromSourceConnectorRequest, _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:
1145    @validate_call
1146    def delete_user_from_source_connector_without_preload_content(
1147        self,
1148        organization_id: StrictStr,
1149        source_connector_id: StrictStr,
1150        remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest,
1151        _request_timeout: Union[
1152            None,
1153            Annotated[StrictFloat, Field(gt=0)],
1154            Tuple[
1155                Annotated[StrictFloat, Field(gt=0)],
1156                Annotated[StrictFloat, Field(gt=0)]
1157            ]
1158        ] = None,
1159        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1160        _content_type: Optional[StrictStr] = None,
1161        _headers: Optional[Dict[StrictStr, Any]] = None,
1162        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1163    ) -> RESTResponseType:
1164        """Delete a source connector user
1165
1166        Delete a source connector user
1167
1168        :param organization_id: (required)
1169        :type organization_id: str
1170        :param source_connector_id: (required)
1171        :type source_connector_id: str
1172        :param remove_user_from_source_connector_request: (required)
1173        :type remove_user_from_source_connector_request: RemoveUserFromSourceConnectorRequest
1174        :param _request_timeout: timeout setting for this request. If one
1175                                 number provided, it will be total request
1176                                 timeout. It can also be a pair (tuple) of
1177                                 (connection, read) timeouts.
1178        :type _request_timeout: int, tuple(int, int), optional
1179        :param _request_auth: set to override the auth_settings for an a single
1180                              request; this effectively ignores the
1181                              authentication in the spec for a single request.
1182        :type _request_auth: dict, optional
1183        :param _content_type: force content-type for the request.
1184        :type _content_type: str, Optional
1185        :param _headers: set to override the headers for a single
1186                         request; this effectively ignores the headers
1187                         in the spec for a single request.
1188        :type _headers: dict, optional
1189        :param _host_index: set to override the host_index for a single
1190                            request; this effectively ignores the host_index
1191                            in the spec for a single request.
1192        :type _host_index: int, optional
1193        :return: Returns the result object.
1194        """ # noqa: E501
1195
1196        _param = self._delete_user_from_source_connector_serialize(
1197            organization_id=organization_id,
1198            source_connector_id=source_connector_id,
1199            remove_user_from_source_connector_request=remove_user_from_source_connector_request,
1200            _request_auth=_request_auth,
1201            _content_type=_content_type,
1202            _headers=_headers,
1203            _host_index=_host_index
1204        )
1205
1206        _response_types_map: Dict[str, Optional[str]] = {
1207            '200': "RemoveUserFromSourceConnectorResponse",
1208            '400': "GetPipelines400Response",
1209            '401': "GetPipelines400Response",
1210            '403': "GetPipelines400Response",
1211            '404': "GetPipelines400Response",
1212            '500': "GetPipelines400Response",
1213        }
1214        response_data = self.api_client.call_api(
1215            *_param,
1216            _request_timeout=_request_timeout
1217        )
1218        return response_data.response

Delete a source connector user

Delete a source connector user

Parameters
  • organization_id: (required)
  • source_connector_id: (required)
  • remove_user_from_source_connector_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 get_source_connector( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_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.source_connector.SourceConnector:
1304    @validate_call
1305    def get_source_connector(
1306        self,
1307        organization_id: StrictStr,
1308        source_connector_id: StrictStr,
1309        _request_timeout: Union[
1310            None,
1311            Annotated[StrictFloat, Field(gt=0)],
1312            Tuple[
1313                Annotated[StrictFloat, Field(gt=0)],
1314                Annotated[StrictFloat, Field(gt=0)]
1315            ]
1316        ] = None,
1317        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1318        _content_type: Optional[StrictStr] = None,
1319        _headers: Optional[Dict[StrictStr, Any]] = None,
1320        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1321    ) -> SourceConnector:
1322        """Get a source connector
1323
1324        Get a source connector
1325
1326        :param organization_id: (required)
1327        :type organization_id: str
1328        :param source_connector_id: (required)
1329        :type source_connector_id: str
1330        :param _request_timeout: timeout setting for this request. If one
1331                                 number provided, it will be total request
1332                                 timeout. It can also be a pair (tuple) of
1333                                 (connection, read) timeouts.
1334        :type _request_timeout: int, tuple(int, int), optional
1335        :param _request_auth: set to override the auth_settings for an a single
1336                              request; this effectively ignores the
1337                              authentication in the spec for a single request.
1338        :type _request_auth: dict, optional
1339        :param _content_type: force content-type for the request.
1340        :type _content_type: str, Optional
1341        :param _headers: set to override the headers for a single
1342                         request; this effectively ignores the headers
1343                         in the spec for a single request.
1344        :type _headers: dict, optional
1345        :param _host_index: set to override the host_index for a single
1346                            request; this effectively ignores the host_index
1347                            in the spec for a single request.
1348        :type _host_index: int, optional
1349        :return: Returns the result object.
1350        """ # noqa: E501
1351
1352        _param = self._get_source_connector_serialize(
1353            organization_id=organization_id,
1354            source_connector_id=source_connector_id,
1355            _request_auth=_request_auth,
1356            _content_type=_content_type,
1357            _headers=_headers,
1358            _host_index=_host_index
1359        )
1360
1361        _response_types_map: Dict[str, Optional[str]] = {
1362            '200': "SourceConnector",
1363            '400': "GetPipelines400Response",
1364            '401': "GetPipelines400Response",
1365            '403': "GetPipelines400Response",
1366            '404': "GetPipelines400Response",
1367            '500': "GetPipelines400Response",
1368        }
1369        response_data = self.api_client.call_api(
1370            *_param,
1371            _request_timeout=_request_timeout
1372        )
1373        response_data.read()
1374        return self.api_client.response_deserialize(
1375            response_data=response_data,
1376            response_types_map=_response_types_map,
1377        ).data

Get a source connector

Get a source connector

Parameters
  • organization_id: (required)
  • source_connector_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_source_connector_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_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[SourceConnector]:
1380    @validate_call
1381    def get_source_connector_with_http_info(
1382        self,
1383        organization_id: StrictStr,
1384        source_connector_id: StrictStr,
1385        _request_timeout: Union[
1386            None,
1387            Annotated[StrictFloat, Field(gt=0)],
1388            Tuple[
1389                Annotated[StrictFloat, Field(gt=0)],
1390                Annotated[StrictFloat, Field(gt=0)]
1391            ]
1392        ] = None,
1393        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1394        _content_type: Optional[StrictStr] = None,
1395        _headers: Optional[Dict[StrictStr, Any]] = None,
1396        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1397    ) -> ApiResponse[SourceConnector]:
1398        """Get a source connector
1399
1400        Get a source connector
1401
1402        :param organization_id: (required)
1403        :type organization_id: str
1404        :param source_connector_id: (required)
1405        :type source_connector_id: str
1406        :param _request_timeout: timeout setting for this request. If one
1407                                 number provided, it will be total request
1408                                 timeout. It can also be a pair (tuple) of
1409                                 (connection, read) timeouts.
1410        :type _request_timeout: int, tuple(int, int), optional
1411        :param _request_auth: set to override the auth_settings for an a single
1412                              request; this effectively ignores the
1413                              authentication in the spec for a single request.
1414        :type _request_auth: dict, optional
1415        :param _content_type: force content-type for the request.
1416        :type _content_type: str, Optional
1417        :param _headers: set to override the headers for a single
1418                         request; this effectively ignores the headers
1419                         in the spec for a single request.
1420        :type _headers: dict, optional
1421        :param _host_index: set to override the host_index for a single
1422                            request; this effectively ignores the host_index
1423                            in the spec for a single request.
1424        :type _host_index: int, optional
1425        :return: Returns the result object.
1426        """ # noqa: E501
1427
1428        _param = self._get_source_connector_serialize(
1429            organization_id=organization_id,
1430            source_connector_id=source_connector_id,
1431            _request_auth=_request_auth,
1432            _content_type=_content_type,
1433            _headers=_headers,
1434            _host_index=_host_index
1435        )
1436
1437        _response_types_map: Dict[str, Optional[str]] = {
1438            '200': "SourceConnector",
1439            '400': "GetPipelines400Response",
1440            '401': "GetPipelines400Response",
1441            '403': "GetPipelines400Response",
1442            '404': "GetPipelines400Response",
1443            '500': "GetPipelines400Response",
1444        }
1445        response_data = self.api_client.call_api(
1446            *_param,
1447            _request_timeout=_request_timeout
1448        )
1449        response_data.read()
1450        return self.api_client.response_deserialize(
1451            response_data=response_data,
1452            response_types_map=_response_types_map,
1453        )

Get a source connector

Get a source connector

Parameters
  • organization_id: (required)
  • source_connector_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_source_connector_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_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:
1456    @validate_call
1457    def get_source_connector_without_preload_content(
1458        self,
1459        organization_id: StrictStr,
1460        source_connector_id: StrictStr,
1461        _request_timeout: Union[
1462            None,
1463            Annotated[StrictFloat, Field(gt=0)],
1464            Tuple[
1465                Annotated[StrictFloat, Field(gt=0)],
1466                Annotated[StrictFloat, Field(gt=0)]
1467            ]
1468        ] = None,
1469        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1470        _content_type: Optional[StrictStr] = None,
1471        _headers: Optional[Dict[StrictStr, Any]] = None,
1472        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1473    ) -> RESTResponseType:
1474        """Get a source connector
1475
1476        Get a source connector
1477
1478        :param organization_id: (required)
1479        :type organization_id: str
1480        :param source_connector_id: (required)
1481        :type source_connector_id: str
1482        :param _request_timeout: timeout setting for this request. If one
1483                                 number provided, it will be total request
1484                                 timeout. It can also be a pair (tuple) of
1485                                 (connection, read) timeouts.
1486        :type _request_timeout: int, tuple(int, int), optional
1487        :param _request_auth: set to override the auth_settings for an a single
1488                              request; this effectively ignores the
1489                              authentication in the spec for a single request.
1490        :type _request_auth: dict, optional
1491        :param _content_type: force content-type for the request.
1492        :type _content_type: str, Optional
1493        :param _headers: set to override the headers for a single
1494                         request; this effectively ignores the headers
1495                         in the spec for a single request.
1496        :type _headers: dict, optional
1497        :param _host_index: set to override the host_index for a single
1498                            request; this effectively ignores the host_index
1499                            in the spec for a single request.
1500        :type _host_index: int, optional
1501        :return: Returns the result object.
1502        """ # noqa: E501
1503
1504        _param = self._get_source_connector_serialize(
1505            organization_id=organization_id,
1506            source_connector_id=source_connector_id,
1507            _request_auth=_request_auth,
1508            _content_type=_content_type,
1509            _headers=_headers,
1510            _host_index=_host_index
1511        )
1512
1513        _response_types_map: Dict[str, Optional[str]] = {
1514            '200': "SourceConnector",
1515            '400': "GetPipelines400Response",
1516            '401': "GetPipelines400Response",
1517            '403': "GetPipelines400Response",
1518            '404': "GetPipelines400Response",
1519            '500': "GetPipelines400Response",
1520        }
1521        response_data = self.api_client.call_api(
1522            *_param,
1523            _request_timeout=_request_timeout
1524        )
1525        return response_data.response

Get a source connector

Get a source connector

Parameters
  • organization_id: (required)
  • source_connector_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_source_connectors( 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_source_connectors200_response.GetSourceConnectors200Response:
1595    @validate_call
1596    def get_source_connectors(
1597        self,
1598        organization_id: StrictStr,
1599        workspace_id: Optional[StrictStr] = None,
1600        _request_timeout: Union[
1601            None,
1602            Annotated[StrictFloat, Field(gt=0)],
1603            Tuple[
1604                Annotated[StrictFloat, Field(gt=0)],
1605                Annotated[StrictFloat, Field(gt=0)]
1606            ]
1607        ] = None,
1608        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1609        _content_type: Optional[StrictStr] = None,
1610        _headers: Optional[Dict[StrictStr, Any]] = None,
1611        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1612    ) -> GetSourceConnectors200Response:
1613        """Get all existing source connectors
1614
1615        Get all existing source connectors
1616
1617        :param organization_id: (required)
1618        :type organization_id: str
1619        :param workspace_id:
1620        :type workspace_id: str
1621        :param _request_timeout: timeout setting for this request. If one
1622                                 number provided, it will be total request
1623                                 timeout. It can also be a pair (tuple) of
1624                                 (connection, read) timeouts.
1625        :type _request_timeout: int, tuple(int, int), optional
1626        :param _request_auth: set to override the auth_settings for an a single
1627                              request; this effectively ignores the
1628                              authentication in the spec for a single request.
1629        :type _request_auth: dict, optional
1630        :param _content_type: force content-type for the request.
1631        :type _content_type: str, Optional
1632        :param _headers: set to override the headers for a single
1633                         request; this effectively ignores the headers
1634                         in the spec for a single request.
1635        :type _headers: dict, optional
1636        :param _host_index: set to override the host_index for a single
1637                            request; this effectively ignores the host_index
1638                            in the spec for a single request.
1639        :type _host_index: int, optional
1640        :return: Returns the result object.
1641        """ # noqa: E501
1642
1643        _param = self._get_source_connectors_serialize(
1644            organization_id=organization_id,
1645            workspace_id=workspace_id,
1646            _request_auth=_request_auth,
1647            _content_type=_content_type,
1648            _headers=_headers,
1649            _host_index=_host_index
1650        )
1651
1652        _response_types_map: Dict[str, Optional[str]] = {
1653            '200': "GetSourceConnectors200Response",
1654            '400': "GetPipelines400Response",
1655            '401': "GetPipelines400Response",
1656            '403': "GetPipelines400Response",
1657            '404': "GetPipelines400Response",
1658            '500': "GetPipelines400Response",
1659        }
1660        response_data = self.api_client.call_api(
1661            *_param,
1662            _request_timeout=_request_timeout
1663        )
1664        response_data.read()
1665        return self.api_client.response_deserialize(
1666            response_data=response_data,
1667            response_types_map=_response_types_map,
1668        ).data

Get all existing source connectors

Get all existing source connectors

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_source_connectors_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[GetSourceConnectors200Response]:
1671    @validate_call
1672    def get_source_connectors_with_http_info(
1673        self,
1674        organization_id: StrictStr,
1675        workspace_id: Optional[StrictStr] = None,
1676        _request_timeout: Union[
1677            None,
1678            Annotated[StrictFloat, Field(gt=0)],
1679            Tuple[
1680                Annotated[StrictFloat, Field(gt=0)],
1681                Annotated[StrictFloat, Field(gt=0)]
1682            ]
1683        ] = None,
1684        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1685        _content_type: Optional[StrictStr] = None,
1686        _headers: Optional[Dict[StrictStr, Any]] = None,
1687        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1688    ) -> ApiResponse[GetSourceConnectors200Response]:
1689        """Get all existing source connectors
1690
1691        Get all existing source connectors
1692
1693        :param organization_id: (required)
1694        :type organization_id: str
1695        :param workspace_id:
1696        :type workspace_id: str
1697        :param _request_timeout: timeout setting for this request. If one
1698                                 number provided, it will be total request
1699                                 timeout. It can also be a pair (tuple) of
1700                                 (connection, read) timeouts.
1701        :type _request_timeout: int, tuple(int, int), optional
1702        :param _request_auth: set to override the auth_settings for an a single
1703                              request; this effectively ignores the
1704                              authentication in the spec for a single request.
1705        :type _request_auth: dict, optional
1706        :param _content_type: force content-type for the request.
1707        :type _content_type: str, Optional
1708        :param _headers: set to override the headers for a single
1709                         request; this effectively ignores the headers
1710                         in the spec for a single request.
1711        :type _headers: dict, optional
1712        :param _host_index: set to override the host_index for a single
1713                            request; this effectively ignores the host_index
1714                            in the spec for a single request.
1715        :type _host_index: int, optional
1716        :return: Returns the result object.
1717        """ # noqa: E501
1718
1719        _param = self._get_source_connectors_serialize(
1720            organization_id=organization_id,
1721            workspace_id=workspace_id,
1722            _request_auth=_request_auth,
1723            _content_type=_content_type,
1724            _headers=_headers,
1725            _host_index=_host_index
1726        )
1727
1728        _response_types_map: Dict[str, Optional[str]] = {
1729            '200': "GetSourceConnectors200Response",
1730            '400': "GetPipelines400Response",
1731            '401': "GetPipelines400Response",
1732            '403': "GetPipelines400Response",
1733            '404': "GetPipelines400Response",
1734            '500': "GetPipelines400Response",
1735        }
1736        response_data = self.api_client.call_api(
1737            *_param,
1738            _request_timeout=_request_timeout
1739        )
1740        response_data.read()
1741        return self.api_client.response_deserialize(
1742            response_data=response_data,
1743            response_types_map=_response_types_map,
1744        )

Get all existing source connectors

Get all existing source connectors

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_source_connectors_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:
1747    @validate_call
1748    def get_source_connectors_without_preload_content(
1749        self,
1750        organization_id: StrictStr,
1751        workspace_id: Optional[StrictStr] = None,
1752        _request_timeout: Union[
1753            None,
1754            Annotated[StrictFloat, Field(gt=0)],
1755            Tuple[
1756                Annotated[StrictFloat, Field(gt=0)],
1757                Annotated[StrictFloat, Field(gt=0)]
1758            ]
1759        ] = None,
1760        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1761        _content_type: Optional[StrictStr] = None,
1762        _headers: Optional[Dict[StrictStr, Any]] = None,
1763        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1764    ) -> RESTResponseType:
1765        """Get all existing source connectors
1766
1767        Get all existing source connectors
1768
1769        :param organization_id: (required)
1770        :type organization_id: str
1771        :param workspace_id:
1772        :type workspace_id: str
1773        :param _request_timeout: timeout setting for this request. If one
1774                                 number provided, it will be total request
1775                                 timeout. It can also be a pair (tuple) of
1776                                 (connection, read) timeouts.
1777        :type _request_timeout: int, tuple(int, int), optional
1778        :param _request_auth: set to override the auth_settings for an a single
1779                              request; this effectively ignores the
1780                              authentication in the spec for a single request.
1781        :type _request_auth: dict, optional
1782        :param _content_type: force content-type for the request.
1783        :type _content_type: str, Optional
1784        :param _headers: set to override the headers for a single
1785                         request; this effectively ignores the headers
1786                         in the spec for a single request.
1787        :type _headers: dict, optional
1788        :param _host_index: set to override the host_index for a single
1789                            request; this effectively ignores the host_index
1790                            in the spec for a single request.
1791        :type _host_index: int, optional
1792        :return: Returns the result object.
1793        """ # noqa: E501
1794
1795        _param = self._get_source_connectors_serialize(
1796            organization_id=organization_id,
1797            workspace_id=workspace_id,
1798            _request_auth=_request_auth,
1799            _content_type=_content_type,
1800            _headers=_headers,
1801            _host_index=_host_index
1802        )
1803
1804        _response_types_map: Dict[str, Optional[str]] = {
1805            '200': "GetSourceConnectors200Response",
1806            '400': "GetPipelines400Response",
1807            '401': "GetPipelines400Response",
1808            '403': "GetPipelines400Response",
1809            '404': "GetPipelines400Response",
1810            '500': "GetPipelines400Response",
1811        }
1812        response_data = self.api_client.call_api(
1813            *_param,
1814            _request_timeout=_request_timeout
1815        )
1816        return response_data.response

Get all existing source connectors

Get all existing source connectors

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 update_source_connector( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_id: typing.Annotated[str, Strict(strict=True)], update_source_connector_request: vectorize_client.models.update_source_connector_request.UpdateSourceConnectorRequest, _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.update_source_connector_response.UpdateSourceConnectorResponse:
1888    @validate_call
1889    def update_source_connector(
1890        self,
1891        organization_id: StrictStr,
1892        source_connector_id: StrictStr,
1893        update_source_connector_request: UpdateSourceConnectorRequest,
1894        _request_timeout: Union[
1895            None,
1896            Annotated[StrictFloat, Field(gt=0)],
1897            Tuple[
1898                Annotated[StrictFloat, Field(gt=0)],
1899                Annotated[StrictFloat, Field(gt=0)]
1900            ]
1901        ] = None,
1902        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1903        _content_type: Optional[StrictStr] = None,
1904        _headers: Optional[Dict[StrictStr, Any]] = None,
1905        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1906    ) -> UpdateSourceConnectorResponse:
1907        """Update a source connector
1908
1909        Update a source connector
1910
1911        :param organization_id: (required)
1912        :type organization_id: str
1913        :param source_connector_id: (required)
1914        :type source_connector_id: str
1915        :param update_source_connector_request: (required)
1916        :type update_source_connector_request: UpdateSourceConnectorRequest
1917        :param _request_timeout: timeout setting for this request. If one
1918                                 number provided, it will be total request
1919                                 timeout. It can also be a pair (tuple) of
1920                                 (connection, read) timeouts.
1921        :type _request_timeout: int, tuple(int, int), optional
1922        :param _request_auth: set to override the auth_settings for an a single
1923                              request; this effectively ignores the
1924                              authentication in the spec for a single request.
1925        :type _request_auth: dict, optional
1926        :param _content_type: force content-type for the request.
1927        :type _content_type: str, Optional
1928        :param _headers: set to override the headers for a single
1929                         request; this effectively ignores the headers
1930                         in the spec for a single request.
1931        :type _headers: dict, optional
1932        :param _host_index: set to override the host_index for a single
1933                            request; this effectively ignores the host_index
1934                            in the spec for a single request.
1935        :type _host_index: int, optional
1936        :return: Returns the result object.
1937        """ # noqa: E501
1938
1939        _param = self._update_source_connector_serialize(
1940            organization_id=organization_id,
1941            source_connector_id=source_connector_id,
1942            update_source_connector_request=update_source_connector_request,
1943            _request_auth=_request_auth,
1944            _content_type=_content_type,
1945            _headers=_headers,
1946            _host_index=_host_index
1947        )
1948
1949        _response_types_map: Dict[str, Optional[str]] = {
1950            '200': "UpdateSourceConnectorResponse",
1951            '400': "GetPipelines400Response",
1952            '401': "GetPipelines400Response",
1953            '403': "GetPipelines400Response",
1954            '404': "GetPipelines400Response",
1955            '500': "GetPipelines400Response",
1956        }
1957        response_data = self.api_client.call_api(
1958            *_param,
1959            _request_timeout=_request_timeout
1960        )
1961        response_data.read()
1962        return self.api_client.response_deserialize(
1963            response_data=response_data,
1964            response_types_map=_response_types_map,
1965        ).data

Update a source connector

Update a source connector

Parameters
  • organization_id: (required)
  • source_connector_id: (required)
  • update_source_connector_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 update_source_connector_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_id: typing.Annotated[str, Strict(strict=True)], update_source_connector_request: vectorize_client.models.update_source_connector_request.UpdateSourceConnectorRequest, _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[UpdateSourceConnectorResponse]:
1968    @validate_call
1969    def update_source_connector_with_http_info(
1970        self,
1971        organization_id: StrictStr,
1972        source_connector_id: StrictStr,
1973        update_source_connector_request: UpdateSourceConnectorRequest,
1974        _request_timeout: Union[
1975            None,
1976            Annotated[StrictFloat, Field(gt=0)],
1977            Tuple[
1978                Annotated[StrictFloat, Field(gt=0)],
1979                Annotated[StrictFloat, Field(gt=0)]
1980            ]
1981        ] = None,
1982        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1983        _content_type: Optional[StrictStr] = None,
1984        _headers: Optional[Dict[StrictStr, Any]] = None,
1985        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1986    ) -> ApiResponse[UpdateSourceConnectorResponse]:
1987        """Update a source connector
1988
1989        Update a source connector
1990
1991        :param organization_id: (required)
1992        :type organization_id: str
1993        :param source_connector_id: (required)
1994        :type source_connector_id: str
1995        :param update_source_connector_request: (required)
1996        :type update_source_connector_request: UpdateSourceConnectorRequest
1997        :param _request_timeout: timeout setting for this request. If one
1998                                 number provided, it will be total request
1999                                 timeout. It can also be a pair (tuple) of
2000                                 (connection, read) timeouts.
2001        :type _request_timeout: int, tuple(int, int), optional
2002        :param _request_auth: set to override the auth_settings for an a single
2003                              request; this effectively ignores the
2004                              authentication in the spec for a single request.
2005        :type _request_auth: dict, optional
2006        :param _content_type: force content-type for the request.
2007        :type _content_type: str, Optional
2008        :param _headers: set to override the headers for a single
2009                         request; this effectively ignores the headers
2010                         in the spec for a single request.
2011        :type _headers: dict, optional
2012        :param _host_index: set to override the host_index for a single
2013                            request; this effectively ignores the host_index
2014                            in the spec for a single request.
2015        :type _host_index: int, optional
2016        :return: Returns the result object.
2017        """ # noqa: E501
2018
2019        _param = self._update_source_connector_serialize(
2020            organization_id=organization_id,
2021            source_connector_id=source_connector_id,
2022            update_source_connector_request=update_source_connector_request,
2023            _request_auth=_request_auth,
2024            _content_type=_content_type,
2025            _headers=_headers,
2026            _host_index=_host_index
2027        )
2028
2029        _response_types_map: Dict[str, Optional[str]] = {
2030            '200': "UpdateSourceConnectorResponse",
2031            '400': "GetPipelines400Response",
2032            '401': "GetPipelines400Response",
2033            '403': "GetPipelines400Response",
2034            '404': "GetPipelines400Response",
2035            '500': "GetPipelines400Response",
2036        }
2037        response_data = self.api_client.call_api(
2038            *_param,
2039            _request_timeout=_request_timeout
2040        )
2041        response_data.read()
2042        return self.api_client.response_deserialize(
2043            response_data=response_data,
2044            response_types_map=_response_types_map,
2045        )

Update a source connector

Update a source connector

Parameters
  • organization_id: (required)
  • source_connector_id: (required)
  • update_source_connector_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 update_source_connector_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_id: typing.Annotated[str, Strict(strict=True)], update_source_connector_request: vectorize_client.models.update_source_connector_request.UpdateSourceConnectorRequest, _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:
2048    @validate_call
2049    def update_source_connector_without_preload_content(
2050        self,
2051        organization_id: StrictStr,
2052        source_connector_id: StrictStr,
2053        update_source_connector_request: UpdateSourceConnectorRequest,
2054        _request_timeout: Union[
2055            None,
2056            Annotated[StrictFloat, Field(gt=0)],
2057            Tuple[
2058                Annotated[StrictFloat, Field(gt=0)],
2059                Annotated[StrictFloat, Field(gt=0)]
2060            ]
2061        ] = None,
2062        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2063        _content_type: Optional[StrictStr] = None,
2064        _headers: Optional[Dict[StrictStr, Any]] = None,
2065        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2066    ) -> RESTResponseType:
2067        """Update a source connector
2068
2069        Update a source connector
2070
2071        :param organization_id: (required)
2072        :type organization_id: str
2073        :param source_connector_id: (required)
2074        :type source_connector_id: str
2075        :param update_source_connector_request: (required)
2076        :type update_source_connector_request: UpdateSourceConnectorRequest
2077        :param _request_timeout: timeout setting for this request. If one
2078                                 number provided, it will be total request
2079                                 timeout. It can also be a pair (tuple) of
2080                                 (connection, read) timeouts.
2081        :type _request_timeout: int, tuple(int, int), optional
2082        :param _request_auth: set to override the auth_settings for an a single
2083                              request; this effectively ignores the
2084                              authentication in the spec for a single request.
2085        :type _request_auth: dict, optional
2086        :param _content_type: force content-type for the request.
2087        :type _content_type: str, Optional
2088        :param _headers: set to override the headers for a single
2089                         request; this effectively ignores the headers
2090                         in the spec for a single request.
2091        :type _headers: dict, optional
2092        :param _host_index: set to override the host_index for a single
2093                            request; this effectively ignores the host_index
2094                            in the spec for a single request.
2095        :type _host_index: int, optional
2096        :return: Returns the result object.
2097        """ # noqa: E501
2098
2099        _param = self._update_source_connector_serialize(
2100            organization_id=organization_id,
2101            source_connector_id=source_connector_id,
2102            update_source_connector_request=update_source_connector_request,
2103            _request_auth=_request_auth,
2104            _content_type=_content_type,
2105            _headers=_headers,
2106            _host_index=_host_index
2107        )
2108
2109        _response_types_map: Dict[str, Optional[str]] = {
2110            '200': "UpdateSourceConnectorResponse",
2111            '400': "GetPipelines400Response",
2112            '401': "GetPipelines400Response",
2113            '403': "GetPipelines400Response",
2114            '404': "GetPipelines400Response",
2115            '500': "GetPipelines400Response",
2116        }
2117        response_data = self.api_client.call_api(
2118            *_param,
2119            _request_timeout=_request_timeout
2120        )
2121        return response_data.response

Update a source connector

Update a source connector

Parameters
  • organization_id: (required)
  • source_connector_id: (required)
  • update_source_connector_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 update_user_in_source_connector( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_id: typing.Annotated[str, Strict(strict=True)], update_user_in_source_connector_request: vectorize_client.models.update_user_in_source_connector_request.UpdateUserInSourceConnectorRequest, _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.update_user_in_source_connector_response.UpdateUserInSourceConnectorResponse:
2207    @validate_call
2208    def update_user_in_source_connector(
2209        self,
2210        organization_id: StrictStr,
2211        source_connector_id: StrictStr,
2212        update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest,
2213        _request_timeout: Union[
2214            None,
2215            Annotated[StrictFloat, Field(gt=0)],
2216            Tuple[
2217                Annotated[StrictFloat, Field(gt=0)],
2218                Annotated[StrictFloat, Field(gt=0)]
2219            ]
2220        ] = None,
2221        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2222        _content_type: Optional[StrictStr] = None,
2223        _headers: Optional[Dict[StrictStr, Any]] = None,
2224        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2225    ) -> UpdateUserInSourceConnectorResponse:
2226        """Update a source connector user
2227
2228        Update a source connector user
2229
2230        :param organization_id: (required)
2231        :type organization_id: str
2232        :param source_connector_id: (required)
2233        :type source_connector_id: str
2234        :param update_user_in_source_connector_request: (required)
2235        :type update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest
2236        :param _request_timeout: timeout setting for this request. If one
2237                                 number provided, it will be total request
2238                                 timeout. It can also be a pair (tuple) of
2239                                 (connection, read) timeouts.
2240        :type _request_timeout: int, tuple(int, int), optional
2241        :param _request_auth: set to override the auth_settings for an a single
2242                              request; this effectively ignores the
2243                              authentication in the spec for a single request.
2244        :type _request_auth: dict, optional
2245        :param _content_type: force content-type for the request.
2246        :type _content_type: str, Optional
2247        :param _headers: set to override the headers for a single
2248                         request; this effectively ignores the headers
2249                         in the spec for a single request.
2250        :type _headers: dict, optional
2251        :param _host_index: set to override the host_index for a single
2252                            request; this effectively ignores the host_index
2253                            in the spec for a single request.
2254        :type _host_index: int, optional
2255        :return: Returns the result object.
2256        """ # noqa: E501
2257
2258        _param = self._update_user_in_source_connector_serialize(
2259            organization_id=organization_id,
2260            source_connector_id=source_connector_id,
2261            update_user_in_source_connector_request=update_user_in_source_connector_request,
2262            _request_auth=_request_auth,
2263            _content_type=_content_type,
2264            _headers=_headers,
2265            _host_index=_host_index
2266        )
2267
2268        _response_types_map: Dict[str, Optional[str]] = {
2269            '200': "UpdateUserInSourceConnectorResponse",
2270            '400': "GetPipelines400Response",
2271            '401': "GetPipelines400Response",
2272            '403': "GetPipelines400Response",
2273            '404': "GetPipelines400Response",
2274            '500': "GetPipelines400Response",
2275        }
2276        response_data = self.api_client.call_api(
2277            *_param,
2278            _request_timeout=_request_timeout
2279        )
2280        response_data.read()
2281        return self.api_client.response_deserialize(
2282            response_data=response_data,
2283            response_types_map=_response_types_map,
2284        ).data

Update a source connector user

Update a source connector user

Parameters
  • organization_id: (required)
  • source_connector_id: (required)
  • update_user_in_source_connector_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 update_user_in_source_connector_with_http_info( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_id: typing.Annotated[str, Strict(strict=True)], update_user_in_source_connector_request: vectorize_client.models.update_user_in_source_connector_request.UpdateUserInSourceConnectorRequest, _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[UpdateUserInSourceConnectorResponse]:
2287    @validate_call
2288    def update_user_in_source_connector_with_http_info(
2289        self,
2290        organization_id: StrictStr,
2291        source_connector_id: StrictStr,
2292        update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest,
2293        _request_timeout: Union[
2294            None,
2295            Annotated[StrictFloat, Field(gt=0)],
2296            Tuple[
2297                Annotated[StrictFloat, Field(gt=0)],
2298                Annotated[StrictFloat, Field(gt=0)]
2299            ]
2300        ] = None,
2301        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2302        _content_type: Optional[StrictStr] = None,
2303        _headers: Optional[Dict[StrictStr, Any]] = None,
2304        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2305    ) -> ApiResponse[UpdateUserInSourceConnectorResponse]:
2306        """Update a source connector user
2307
2308        Update a source connector user
2309
2310        :param organization_id: (required)
2311        :type organization_id: str
2312        :param source_connector_id: (required)
2313        :type source_connector_id: str
2314        :param update_user_in_source_connector_request: (required)
2315        :type update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest
2316        :param _request_timeout: timeout setting for this request. If one
2317                                 number provided, it will be total request
2318                                 timeout. It can also be a pair (tuple) of
2319                                 (connection, read) timeouts.
2320        :type _request_timeout: int, tuple(int, int), optional
2321        :param _request_auth: set to override the auth_settings for an a single
2322                              request; this effectively ignores the
2323                              authentication in the spec for a single request.
2324        :type _request_auth: dict, optional
2325        :param _content_type: force content-type for the request.
2326        :type _content_type: str, Optional
2327        :param _headers: set to override the headers for a single
2328                         request; this effectively ignores the headers
2329                         in the spec for a single request.
2330        :type _headers: dict, optional
2331        :param _host_index: set to override the host_index for a single
2332                            request; this effectively ignores the host_index
2333                            in the spec for a single request.
2334        :type _host_index: int, optional
2335        :return: Returns the result object.
2336        """ # noqa: E501
2337
2338        _param = self._update_user_in_source_connector_serialize(
2339            organization_id=organization_id,
2340            source_connector_id=source_connector_id,
2341            update_user_in_source_connector_request=update_user_in_source_connector_request,
2342            _request_auth=_request_auth,
2343            _content_type=_content_type,
2344            _headers=_headers,
2345            _host_index=_host_index
2346        )
2347
2348        _response_types_map: Dict[str, Optional[str]] = {
2349            '200': "UpdateUserInSourceConnectorResponse",
2350            '400': "GetPipelines400Response",
2351            '401': "GetPipelines400Response",
2352            '403': "GetPipelines400Response",
2353            '404': "GetPipelines400Response",
2354            '500': "GetPipelines400Response",
2355        }
2356        response_data = self.api_client.call_api(
2357            *_param,
2358            _request_timeout=_request_timeout
2359        )
2360        response_data.read()
2361        return self.api_client.response_deserialize(
2362            response_data=response_data,
2363            response_types_map=_response_types_map,
2364        )

Update a source connector user

Update a source connector user

Parameters
  • organization_id: (required)
  • source_connector_id: (required)
  • update_user_in_source_connector_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 update_user_in_source_connector_without_preload_content( self, organization_id: typing.Annotated[str, Strict(strict=True)], source_connector_id: typing.Annotated[str, Strict(strict=True)], update_user_in_source_connector_request: vectorize_client.models.update_user_in_source_connector_request.UpdateUserInSourceConnectorRequest, _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:
2367    @validate_call
2368    def update_user_in_source_connector_without_preload_content(
2369        self,
2370        organization_id: StrictStr,
2371        source_connector_id: StrictStr,
2372        update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest,
2373        _request_timeout: Union[
2374            None,
2375            Annotated[StrictFloat, Field(gt=0)],
2376            Tuple[
2377                Annotated[StrictFloat, Field(gt=0)],
2378                Annotated[StrictFloat, Field(gt=0)]
2379            ]
2380        ] = None,
2381        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2382        _content_type: Optional[StrictStr] = None,
2383        _headers: Optional[Dict[StrictStr, Any]] = None,
2384        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2385    ) -> RESTResponseType:
2386        """Update a source connector user
2387
2388        Update a source connector user
2389
2390        :param organization_id: (required)
2391        :type organization_id: str
2392        :param source_connector_id: (required)
2393        :type source_connector_id: str
2394        :param update_user_in_source_connector_request: (required)
2395        :type update_user_in_source_connector_request: UpdateUserInSourceConnectorRequest
2396        :param _request_timeout: timeout setting for this request. If one
2397                                 number provided, it will be total request
2398                                 timeout. It can also be a pair (tuple) of
2399                                 (connection, read) timeouts.
2400        :type _request_timeout: int, tuple(int, int), optional
2401        :param _request_auth: set to override the auth_settings for an a single
2402                              request; this effectively ignores the
2403                              authentication in the spec for a single request.
2404        :type _request_auth: dict, optional
2405        :param _content_type: force content-type for the request.
2406        :type _content_type: str, Optional
2407        :param _headers: set to override the headers for a single
2408                         request; this effectively ignores the headers
2409                         in the spec for a single request.
2410        :type _headers: dict, optional
2411        :param _host_index: set to override the host_index for a single
2412                            request; this effectively ignores the host_index
2413                            in the spec for a single request.
2414        :type _host_index: int, optional
2415        :return: Returns the result object.
2416        """ # noqa: E501
2417
2418        _param = self._update_user_in_source_connector_serialize(
2419            organization_id=organization_id,
2420            source_connector_id=source_connector_id,
2421            update_user_in_source_connector_request=update_user_in_source_connector_request,
2422            _request_auth=_request_auth,
2423            _content_type=_content_type,
2424            _headers=_headers,
2425            _host_index=_host_index
2426        )
2427
2428        _response_types_map: Dict[str, Optional[str]] = {
2429            '200': "UpdateUserInSourceConnectorResponse",
2430            '400': "GetPipelines400Response",
2431            '401': "GetPipelines400Response",
2432            '403': "GetPipelines400Response",
2433            '404': "GetPipelines400Response",
2434            '500': "GetPipelines400Response",
2435        }
2436        response_data = self.api_client.call_api(
2437            *_param,
2438            _request_timeout=_request_timeout
2439        )
2440        return response_data.response

Update a source connector user

Update a source connector user

Parameters
  • organization_id: (required)
  • source_connector_id: (required)
  • update_user_in_source_connector_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.