vectorize_client.api.pipelines_api API documentation

PipelinesApi(api_client=None) View Source

49    def __init__(self, api_client=None) -> None:
50        if api_client is None:
51            api_client = ApiClient.get_default()
52        self.api_client = api_client

api_client

@validate_call

def create_pipeline( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline_configuration_schema: vectorize_client.models.pipeline_configuration_schema.PipelineConfigurationSchema, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.create_pipeline_response.CreatePipelineResponse: View Source

 55    @validate_call
 56    def create_pipeline(
 57        self,
 58        organization: StrictStr,
 59        pipeline_configuration_schema: PipelineConfigurationSchema,
 60        _request_timeout: Union[
 61            None,
 62            Annotated[StrictFloat, Field(gt=0)],
 63            Tuple[
 64                Annotated[StrictFloat, Field(gt=0)],
 65                Annotated[StrictFloat, Field(gt=0)]
 66            ]
 67        ] = None,
 68        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 69        _content_type: Optional[StrictStr] = None,
 70        _headers: Optional[Dict[StrictStr, Any]] = None,
 71        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 72    ) -> CreatePipelineResponse:
 73        """Create a new source pipeline. Config fields for sources: Amazon S3 (AWS_S3):  Check for updates every (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Azure Blob Storage (AZURE_BLOB):  Polling Interval (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Confluence (CONFLUENCE):  Spaces (spaces): array oftext, Root Parents (root-parents): array oftext) | Discord (DISCORD):  Emoji Filter (emoji): array oftext, Author Filter (author): array oftext, Ignore Author Filter (ignore-author): array oftext, Limit (limit): number) | Dropbox (DROPBOX):  Read from these folders (optional) (path-prefix): array oftext) | Google Drive OAuth (GOOGLE_DRIVE_OAUTH):  Polling Interval (seconds) (idle-time): number) | Google Drive (Service Account) (GOOGLE_DRIVE):  Restrict ingest to these folder URLs (optional) (root-parents): array oftext, Polling Interval (seconds) (idle-time): number) | Google Drive Multi-User (Vectorize) (GOOGLE_DRIVE_OAUTH_MULTI):  Polling Interval (seconds) (idle-time): number) | Google Drive Multi-User (White Label) (GOOGLE_DRIVE_OAUTH_MULTI_CUSTOM):  Polling Interval (seconds) (idle-time): number) | Firecrawl (FIRECRAWL):  ) | GCP Cloud Storage (GCS):  Check for updates every (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Intercom (INTERCOM):  Reindex Interval (seconds) (reindexIntervalSeconds): number, Limit (limit): number, Tags (tags): array oftext) | OneDrive (ONE_DRIVE):  Read starting from this folder (optional) (path-prefix): text) | SharePoint (SHAREPOINT):  Site Name(s) (sites): array oftext) | Web Crawler (WEB_CRAWLER):  Additional Allowed URLs or prefix(es) (allowed-domains-opt): array ofurl, Forbidden Paths (forbidden-paths): array oftext, Throttle (ms) (min-time-between-requests): number, Max Error Count (max-error-count): number, Max URLs (max-urls): number, Max Depth (max-depth): number, Reindex Interval (seconds) (reindex-interval-seconds): number) | File Upload (FILE_UPLOAD):  ). Config fields for destinations: Couchbase Capella (CAPELLA):  Bucket Name (bucket): text, Scope Name (scope): text, Collection Name (collection): text, Search Index Name (index): text) | DataStax Astra (DATASTAX):  Collection Name (collection): text) | Elasticsearch (ELASTIC):  Index Name (index): text) | Pinecone (PINECONE):  Index Name (index): text, Namespace (namespace): text) | SingleStore (SINGLESTORE):  Table Name (table): text) | Milvus (MILVUS):  Collection Name (collection): text) | PostgreSQL (POSTGRESQL):  Table Name (table): text) | Qdrant (QDRANT):  Collection Name (collection): text) | Supabase (SUPABASE):  Table Name (table): text) | Weaviate (WEAVIATE):  Collection Name (collection): text) | Azure AI Search (AZUREAISEARCH):  Index Name (index): text) | Built-in (VECTORIZE):  ) | Chroma (CHROMA):  Index Name (index): text) | MongoDB (MONGODB):  Index Name (index): text). Config fields for AI platforms: 
 74
 75
 76        :param organization: (required)
 77        :type organization: str
 78        :param pipeline_configuration_schema: (required)
 79        :type pipeline_configuration_schema: PipelineConfigurationSchema
 80        :param _request_timeout: timeout setting for this request. If one
 81                                 number provided, it will be total request
 82                                 timeout. It can also be a pair (tuple) of
 83                                 (connection, read) timeouts.
 84        :type _request_timeout: int, tuple(int, int), optional
 85        :param _request_auth: set to override the auth_settings for an a single
 86                              request; this effectively ignores the
 87                              authentication in the spec for a single request.
 88        :type _request_auth: dict, optional
 89        :param _content_type: force content-type for the request.
 90        :type _content_type: str, Optional
 91        :param _headers: set to override the headers for a single
 92                         request; this effectively ignores the headers
 93                         in the spec for a single request.
 94        :type _headers: dict, optional
 95        :param _host_index: set to override the host_index for a single
 96                            request; this effectively ignores the host_index
 97                            in the spec for a single request.
 98        :type _host_index: int, optional
 99        :return: Returns the result object.
100        """ # noqa: E501
101
102        _param = self._create_pipeline_serialize(
103            organization=organization,
104            pipeline_configuration_schema=pipeline_configuration_schema,
105            _request_auth=_request_auth,
106            _content_type=_content_type,
107            _headers=_headers,
108            _host_index=_host_index
109        )
110
111        _response_types_map: Dict[str, Optional[str]] = {
112            '200': "CreatePipelineResponse",
113            '400': "GetPipelines400Response",
114            '401': "GetPipelines400Response",
115            '403': "GetPipelines400Response",
116            '404': "GetPipelines400Response",
117            '500': "GetPipelines400Response",
118        }
119        response_data = self.api_client.call_api(
120            *_param,
121            _request_timeout=_request_timeout
122        )
123        response_data.read()
124        return self.api_client.response_deserialize(
125            response_data=response_data,
126            response_types_map=_response_types_map,
127        ).data

Create a new source pipeline. Config fields for sources: Amazon S3 (AWS_S3): Check for updates every (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Azure Blob Storage (AZURE_BLOB): Polling Interval (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Confluence (CONFLUENCE): Spaces (spaces): array oftext, Root Parents (root-parents): array oftext) | Discord (DISCORD): Emoji Filter (emoji): array oftext, Author Filter (author): array oftext, Ignore Author Filter (ignore-author): array oftext, Limit (limit): number) | Dropbox (DROPBOX): Read from these folders (optional) (path-prefix): array oftext) | Google Drive OAuth (GOOGLE_DRIVE_OAUTH): Polling Interval (seconds) (idle-time): number) | Google Drive (Service Account) (GOOGLE_DRIVE): Restrict ingest to these folder URLs (optional) (root-parents): array oftext, Polling Interval (seconds) (idle-time): number) | Google Drive Multi-User (Vectorize) (GOOGLE_DRIVE_OAUTH_MULTI): Polling Interval (seconds) (idle-time): number) | Google Drive Multi-User (White Label) (GOOGLE_DRIVE_OAUTH_MULTI_CUSTOM): Polling Interval (seconds) (idle-time): number) | Firecrawl (FIRECRAWL): ) | GCP Cloud Storage (GCS): Check for updates every (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Intercom (INTERCOM): Reindex Interval (seconds) (reindexIntervalSeconds): number, Limit (limit): number, Tags (tags): array oftext) | OneDrive (ONE_DRIVE): Read starting from this folder (optional) (path-prefix): text) | SharePoint (SHAREPOINT): Site Name(s) (sites): array oftext) | Web Crawler (WEB_CRAWLER): Additional Allowed URLs or prefix(es) (allowed-domains-opt): array ofurl, Forbidden Paths (forbidden-paths): array oftext, Throttle (ms) (min-time-between-requests): number, Max Error Count (max-error-count): number, Max URLs (max-urls): number, Max Depth (max-depth): number, Reindex Interval (seconds) (reindex-interval-seconds): number) | File Upload (FILE_UPLOAD): ). Config fields for destinations: Couchbase Capella (CAPELLA): Bucket Name (bucket): text, Scope Name (scope): text, Collection Name (collection): text, Search Index Name (index): text) | DataStax Astra (DATASTAX): Collection Name (collection): text) | Elasticsearch (ELASTIC): Index Name (index): text) | Pinecone (PINECONE): Index Name (index): text, Namespace (namespace): text) | SingleStore (SINGLESTORE): Table Name (table): text) | Milvus (MILVUS): Collection Name (collection): text) | PostgreSQL (POSTGRESQL): Table Name (table): text) | Qdrant (QDRANT): Collection Name (collection): text) | Supabase (SUPABASE): Table Name (table): text) | Weaviate (WEAVIATE): Collection Name (collection): text) | Azure AI Search (AZUREAISEARCH): Index Name (index): text) | Built-in (VECTORIZE): ) | Chroma (CHROMA): Index Name (index): text) | MongoDB (MONGODB): Index Name (index): text). Config fields for AI platforms:

Parameters

organization: (required)
pipeline_configuration_schema: (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

@validate_call

def create_pipeline_with_http_info( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline_configuration_schema: vectorize_client.models.pipeline_configuration_schema.PipelineConfigurationSchema, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[CreatePipelineResponse]: View Source

130    @validate_call
131    def create_pipeline_with_http_info(
132        self,
133        organization: StrictStr,
134        pipeline_configuration_schema: PipelineConfigurationSchema,
135        _request_timeout: Union[
136            None,
137            Annotated[StrictFloat, Field(gt=0)],
138            Tuple[
139                Annotated[StrictFloat, Field(gt=0)],
140                Annotated[StrictFloat, Field(gt=0)]
141            ]
142        ] = None,
143        _request_auth: Optional[Dict[StrictStr, Any]] = None,
144        _content_type: Optional[StrictStr] = None,
145        _headers: Optional[Dict[StrictStr, Any]] = None,
146        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
147    ) -> ApiResponse[CreatePipelineResponse]:
148        """Create a new source pipeline. Config fields for sources: Amazon S3 (AWS_S3):  Check for updates every (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Azure Blob Storage (AZURE_BLOB):  Polling Interval (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Confluence (CONFLUENCE):  Spaces (spaces): array oftext, Root Parents (root-parents): array oftext) | Discord (DISCORD):  Emoji Filter (emoji): array oftext, Author Filter (author): array oftext, Ignore Author Filter (ignore-author): array oftext, Limit (limit): number) | Dropbox (DROPBOX):  Read from these folders (optional) (path-prefix): array oftext) | Google Drive OAuth (GOOGLE_DRIVE_OAUTH):  Polling Interval (seconds) (idle-time): number) | Google Drive (Service Account) (GOOGLE_DRIVE):  Restrict ingest to these folder URLs (optional) (root-parents): array oftext, Polling Interval (seconds) (idle-time): number) | Google Drive Multi-User (Vectorize) (GOOGLE_DRIVE_OAUTH_MULTI):  Polling Interval (seconds) (idle-time): number) | Google Drive Multi-User (White Label) (GOOGLE_DRIVE_OAUTH_MULTI_CUSTOM):  Polling Interval (seconds) (idle-time): number) | Firecrawl (FIRECRAWL):  ) | GCP Cloud Storage (GCS):  Check for updates every (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Intercom (INTERCOM):  Reindex Interval (seconds) (reindexIntervalSeconds): number, Limit (limit): number, Tags (tags): array oftext) | OneDrive (ONE_DRIVE):  Read starting from this folder (optional) (path-prefix): text) | SharePoint (SHAREPOINT):  Site Name(s) (sites): array oftext) | Web Crawler (WEB_CRAWLER):  Additional Allowed URLs or prefix(es) (allowed-domains-opt): array ofurl, Forbidden Paths (forbidden-paths): array oftext, Throttle (ms) (min-time-between-requests): number, Max Error Count (max-error-count): number, Max URLs (max-urls): number, Max Depth (max-depth): number, Reindex Interval (seconds) (reindex-interval-seconds): number) | File Upload (FILE_UPLOAD):  ). Config fields for destinations: Couchbase Capella (CAPELLA):  Bucket Name (bucket): text, Scope Name (scope): text, Collection Name (collection): text, Search Index Name (index): text) | DataStax Astra (DATASTAX):  Collection Name (collection): text) | Elasticsearch (ELASTIC):  Index Name (index): text) | Pinecone (PINECONE):  Index Name (index): text, Namespace (namespace): text) | SingleStore (SINGLESTORE):  Table Name (table): text) | Milvus (MILVUS):  Collection Name (collection): text) | PostgreSQL (POSTGRESQL):  Table Name (table): text) | Qdrant (QDRANT):  Collection Name (collection): text) | Supabase (SUPABASE):  Table Name (table): text) | Weaviate (WEAVIATE):  Collection Name (collection): text) | Azure AI Search (AZUREAISEARCH):  Index Name (index): text) | Built-in (VECTORIZE):  ) | Chroma (CHROMA):  Index Name (index): text) | MongoDB (MONGODB):  Index Name (index): text). Config fields for AI platforms: 
149
150
151        :param organization: (required)
152        :type organization: str
153        :param pipeline_configuration_schema: (required)
154        :type pipeline_configuration_schema: PipelineConfigurationSchema
155        :param _request_timeout: timeout setting for this request. If one
156                                 number provided, it will be total request
157                                 timeout. It can also be a pair (tuple) of
158                                 (connection, read) timeouts.
159        :type _request_timeout: int, tuple(int, int), optional
160        :param _request_auth: set to override the auth_settings for an a single
161                              request; this effectively ignores the
162                              authentication in the spec for a single request.
163        :type _request_auth: dict, optional
164        :param _content_type: force content-type for the request.
165        :type _content_type: str, Optional
166        :param _headers: set to override the headers for a single
167                         request; this effectively ignores the headers
168                         in the spec for a single request.
169        :type _headers: dict, optional
170        :param _host_index: set to override the host_index for a single
171                            request; this effectively ignores the host_index
172                            in the spec for a single request.
173        :type _host_index: int, optional
174        :return: Returns the result object.
175        """ # noqa: E501
176
177        _param = self._create_pipeline_serialize(
178            organization=organization,
179            pipeline_configuration_schema=pipeline_configuration_schema,
180            _request_auth=_request_auth,
181            _content_type=_content_type,
182            _headers=_headers,
183            _host_index=_host_index
184        )
185
186        _response_types_map: Dict[str, Optional[str]] = {
187            '200': "CreatePipelineResponse",
188            '400': "GetPipelines400Response",
189            '401': "GetPipelines400Response",
190            '403': "GetPipelines400Response",
191            '404': "GetPipelines400Response",
192            '500': "GetPipelines400Response",
193        }
194        response_data = self.api_client.call_api(
195            *_param,
196            _request_timeout=_request_timeout
197        )
198        response_data.read()
199        return self.api_client.response_deserialize(
200            response_data=response_data,
201            response_types_map=_response_types_map,
202        )

Create a new source pipeline. Config fields for sources: Amazon S3 (AWS_S3): Check for updates every (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Azure Blob Storage (AZURE_BLOB): Polling Interval (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Confluence (CONFLUENCE): Spaces (spaces): array oftext, Root Parents (root-parents): array oftext) | Discord (DISCORD): Emoji Filter (emoji): array oftext, Author Filter (author): array oftext, Ignore Author Filter (ignore-author): array oftext, Limit (limit): number) | Dropbox (DROPBOX): Read from these folders (optional) (path-prefix): array oftext) | Google Drive OAuth (GOOGLE_DRIVE_OAUTH): Polling Interval (seconds) (idle-time): number) | Google Drive (Service Account) (GOOGLE_DRIVE): Restrict ingest to these folder URLs (optional) (root-parents): array oftext, Polling Interval (seconds) (idle-time): number) | Google Drive Multi-User (Vectorize) (GOOGLE_DRIVE_OAUTH_MULTI): Polling Interval (seconds) (idle-time): number) | Google Drive Multi-User (White Label) (GOOGLE_DRIVE_OAUTH_MULTI_CUSTOM): Polling Interval (seconds) (idle-time): number) | Firecrawl (FIRECRAWL): ) | GCP Cloud Storage (GCS): Check for updates every (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Intercom (INTERCOM): Reindex Interval (seconds) (reindexIntervalSeconds): number, Limit (limit): number, Tags (tags): array oftext) | OneDrive (ONE_DRIVE): Read starting from this folder (optional) (path-prefix): text) | SharePoint (SHAREPOINT): Site Name(s) (sites): array oftext) | Web Crawler (WEB_CRAWLER): Additional Allowed URLs or prefix(es) (allowed-domains-opt): array ofurl, Forbidden Paths (forbidden-paths): array oftext, Throttle (ms) (min-time-between-requests): number, Max Error Count (max-error-count): number, Max URLs (max-urls): number, Max Depth (max-depth): number, Reindex Interval (seconds) (reindex-interval-seconds): number) | File Upload (FILE_UPLOAD): ). Config fields for destinations: Couchbase Capella (CAPELLA): Bucket Name (bucket): text, Scope Name (scope): text, Collection Name (collection): text, Search Index Name (index): text) | DataStax Astra (DATASTAX): Collection Name (collection): text) | Elasticsearch (ELASTIC): Index Name (index): text) | Pinecone (PINECONE): Index Name (index): text, Namespace (namespace): text) | SingleStore (SINGLESTORE): Table Name (table): text) | Milvus (MILVUS): Collection Name (collection): text) | PostgreSQL (POSTGRESQL): Table Name (table): text) | Qdrant (QDRANT): Collection Name (collection): text) | Supabase (SUPABASE): Table Name (table): text) | Weaviate (WEAVIATE): Collection Name (collection): text) | Azure AI Search (AZUREAISEARCH): Index Name (index): text) | Built-in (VECTORIZE): ) | Chroma (CHROMA): Index Name (index): text) | MongoDB (MONGODB): Index Name (index): text). Config fields for AI platforms:

Parameters

organization: (required)
pipeline_configuration_schema: (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

@validate_call

def create_pipeline_without_preload_content( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline_configuration_schema: vectorize_client.models.pipeline_configuration_schema.PipelineConfigurationSchema, _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: View Source

205    @validate_call
206    def create_pipeline_without_preload_content(
207        self,
208        organization: StrictStr,
209        pipeline_configuration_schema: PipelineConfigurationSchema,
210        _request_timeout: Union[
211            None,
212            Annotated[StrictFloat, Field(gt=0)],
213            Tuple[
214                Annotated[StrictFloat, Field(gt=0)],
215                Annotated[StrictFloat, Field(gt=0)]
216            ]
217        ] = None,
218        _request_auth: Optional[Dict[StrictStr, Any]] = None,
219        _content_type: Optional[StrictStr] = None,
220        _headers: Optional[Dict[StrictStr, Any]] = None,
221        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
222    ) -> RESTResponseType:
223        """Create a new source pipeline. Config fields for sources: Amazon S3 (AWS_S3):  Check for updates every (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Azure Blob Storage (AZURE_BLOB):  Polling Interval (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Confluence (CONFLUENCE):  Spaces (spaces): array oftext, Root Parents (root-parents): array oftext) | Discord (DISCORD):  Emoji Filter (emoji): array oftext, Author Filter (author): array oftext, Ignore Author Filter (ignore-author): array oftext, Limit (limit): number) | Dropbox (DROPBOX):  Read from these folders (optional) (path-prefix): array oftext) | Google Drive OAuth (GOOGLE_DRIVE_OAUTH):  Polling Interval (seconds) (idle-time): number) | Google Drive (Service Account) (GOOGLE_DRIVE):  Restrict ingest to these folder URLs (optional) (root-parents): array oftext, Polling Interval (seconds) (idle-time): number) | Google Drive Multi-User (Vectorize) (GOOGLE_DRIVE_OAUTH_MULTI):  Polling Interval (seconds) (idle-time): number) | Google Drive Multi-User (White Label) (GOOGLE_DRIVE_OAUTH_MULTI_CUSTOM):  Polling Interval (seconds) (idle-time): number) | Firecrawl (FIRECRAWL):  ) | GCP Cloud Storage (GCS):  Check for updates every (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Intercom (INTERCOM):  Reindex Interval (seconds) (reindexIntervalSeconds): number, Limit (limit): number, Tags (tags): array oftext) | OneDrive (ONE_DRIVE):  Read starting from this folder (optional) (path-prefix): text) | SharePoint (SHAREPOINT):  Site Name(s) (sites): array oftext) | Web Crawler (WEB_CRAWLER):  Additional Allowed URLs or prefix(es) (allowed-domains-opt): array ofurl, Forbidden Paths (forbidden-paths): array oftext, Throttle (ms) (min-time-between-requests): number, Max Error Count (max-error-count): number, Max URLs (max-urls): number, Max Depth (max-depth): number, Reindex Interval (seconds) (reindex-interval-seconds): number) | File Upload (FILE_UPLOAD):  ). Config fields for destinations: Couchbase Capella (CAPELLA):  Bucket Name (bucket): text, Scope Name (scope): text, Collection Name (collection): text, Search Index Name (index): text) | DataStax Astra (DATASTAX):  Collection Name (collection): text) | Elasticsearch (ELASTIC):  Index Name (index): text) | Pinecone (PINECONE):  Index Name (index): text, Namespace (namespace): text) | SingleStore (SINGLESTORE):  Table Name (table): text) | Milvus (MILVUS):  Collection Name (collection): text) | PostgreSQL (POSTGRESQL):  Table Name (table): text) | Qdrant (QDRANT):  Collection Name (collection): text) | Supabase (SUPABASE):  Table Name (table): text) | Weaviate (WEAVIATE):  Collection Name (collection): text) | Azure AI Search (AZUREAISEARCH):  Index Name (index): text) | Built-in (VECTORIZE):  ) | Chroma (CHROMA):  Index Name (index): text) | MongoDB (MONGODB):  Index Name (index): text). Config fields for AI platforms: 
224
225
226        :param organization: (required)
227        :type organization: str
228        :param pipeline_configuration_schema: (required)
229        :type pipeline_configuration_schema: PipelineConfigurationSchema
230        :param _request_timeout: timeout setting for this request. If one
231                                 number provided, it will be total request
232                                 timeout. It can also be a pair (tuple) of
233                                 (connection, read) timeouts.
234        :type _request_timeout: int, tuple(int, int), optional
235        :param _request_auth: set to override the auth_settings for an a single
236                              request; this effectively ignores the
237                              authentication in the spec for a single request.
238        :type _request_auth: dict, optional
239        :param _content_type: force content-type for the request.
240        :type _content_type: str, Optional
241        :param _headers: set to override the headers for a single
242                         request; this effectively ignores the headers
243                         in the spec for a single request.
244        :type _headers: dict, optional
245        :param _host_index: set to override the host_index for a single
246                            request; this effectively ignores the host_index
247                            in the spec for a single request.
248        :type _host_index: int, optional
249        :return: Returns the result object.
250        """ # noqa: E501
251
252        _param = self._create_pipeline_serialize(
253            organization=organization,
254            pipeline_configuration_schema=pipeline_configuration_schema,
255            _request_auth=_request_auth,
256            _content_type=_content_type,
257            _headers=_headers,
258            _host_index=_host_index
259        )
260
261        _response_types_map: Dict[str, Optional[str]] = {
262            '200': "CreatePipelineResponse",
263            '400': "GetPipelines400Response",
264            '401': "GetPipelines400Response",
265            '403': "GetPipelines400Response",
266            '404': "GetPipelines400Response",
267            '500': "GetPipelines400Response",
268        }
269        response_data = self.api_client.call_api(
270            *_param,
271            _request_timeout=_request_timeout
272        )
273        return response_data.response

Create a new source pipeline. Config fields for sources: Amazon S3 (AWS_S3): Check for updates every (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Azure Blob Storage (AZURE_BLOB): Polling Interval (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Confluence (CONFLUENCE): Spaces (spaces): array oftext, Root Parents (root-parents): array oftext) | Discord (DISCORD): Emoji Filter (emoji): array oftext, Author Filter (author): array oftext, Ignore Author Filter (ignore-author): array oftext, Limit (limit): number) | Dropbox (DROPBOX): Read from these folders (optional) (path-prefix): array oftext) | Google Drive OAuth (GOOGLE_DRIVE_OAUTH): Polling Interval (seconds) (idle-time): number) | Google Drive (Service Account) (GOOGLE_DRIVE): Restrict ingest to these folder URLs (optional) (root-parents): array oftext, Polling Interval (seconds) (idle-time): number) | Google Drive Multi-User (Vectorize) (GOOGLE_DRIVE_OAUTH_MULTI): Polling Interval (seconds) (idle-time): number) | Google Drive Multi-User (White Label) (GOOGLE_DRIVE_OAUTH_MULTI_CUSTOM): Polling Interval (seconds) (idle-time): number) | Firecrawl (FIRECRAWL): ) | GCP Cloud Storage (GCS): Check for updates every (seconds) (idle-time): number, Path Prefix (path-prefix): text, Path Metadata Regex (path-metadata-regex): text, Path Regex Group Names (path-regex-group-names): array oftext) | Intercom (INTERCOM): Reindex Interval (seconds) (reindexIntervalSeconds): number, Limit (limit): number, Tags (tags): array oftext) | OneDrive (ONE_DRIVE): Read starting from this folder (optional) (path-prefix): text) | SharePoint (SHAREPOINT): Site Name(s) (sites): array oftext) | Web Crawler (WEB_CRAWLER): Additional Allowed URLs or prefix(es) (allowed-domains-opt): array ofurl, Forbidden Paths (forbidden-paths): array oftext, Throttle (ms) (min-time-between-requests): number, Max Error Count (max-error-count): number, Max URLs (max-urls): number, Max Depth (max-depth): number, Reindex Interval (seconds) (reindex-interval-seconds): number) | File Upload (FILE_UPLOAD): ). Config fields for destinations: Couchbase Capella (CAPELLA): Bucket Name (bucket): text, Scope Name (scope): text, Collection Name (collection): text, Search Index Name (index): text) | DataStax Astra (DATASTAX): Collection Name (collection): text) | Elasticsearch (ELASTIC): Index Name (index): text) | Pinecone (PINECONE): Index Name (index): text, Namespace (namespace): text) | SingleStore (SINGLESTORE): Table Name (table): text) | Milvus (MILVUS): Collection Name (collection): text) | PostgreSQL (POSTGRESQL): Table Name (table): text) | Qdrant (QDRANT): Collection Name (collection): text) | Supabase (SUPABASE): Table Name (table): text) | Weaviate (WEAVIATE): Collection Name (collection): text) | Azure AI Search (AZUREAISEARCH): Index Name (index): text) | Built-in (VECTORIZE): ) | Chroma (CHROMA): Index Name (index): text) | MongoDB (MONGODB): Index Name (index): text). Config fields for AI platforms:

Parameters

organization: (required)
pipeline_configuration_schema: (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

@validate_call

def delete_pipeline( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.delete_pipeline_response.DeletePipelineResponse: View Source

356    @validate_call
357    def delete_pipeline(
358        self,
359        organization: StrictStr,
360        pipeline: StrictStr,
361        _request_timeout: Union[
362            None,
363            Annotated[StrictFloat, Field(gt=0)],
364            Tuple[
365                Annotated[StrictFloat, Field(gt=0)],
366                Annotated[StrictFloat, Field(gt=0)]
367            ]
368        ] = None,
369        _request_auth: Optional[Dict[StrictStr, Any]] = None,
370        _content_type: Optional[StrictStr] = None,
371        _headers: Optional[Dict[StrictStr, Any]] = None,
372        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
373    ) -> DeletePipelineResponse:
374        """Delete a pipeline
375
376
377        :param organization: (required)
378        :type organization: str
379        :param pipeline: (required)
380        :type pipeline: str
381        :param _request_timeout: timeout setting for this request. If one
382                                 number provided, it will be total request
383                                 timeout. It can also be a pair (tuple) of
384                                 (connection, read) timeouts.
385        :type _request_timeout: int, tuple(int, int), optional
386        :param _request_auth: set to override the auth_settings for an a single
387                              request; this effectively ignores the
388                              authentication in the spec for a single request.
389        :type _request_auth: dict, optional
390        :param _content_type: force content-type for the request.
391        :type _content_type: str, Optional
392        :param _headers: set to override the headers for a single
393                         request; this effectively ignores the headers
394                         in the spec for a single request.
395        :type _headers: dict, optional
396        :param _host_index: set to override the host_index for a single
397                            request; this effectively ignores the host_index
398                            in the spec for a single request.
399        :type _host_index: int, optional
400        :return: Returns the result object.
401        """ # noqa: E501
402
403        _param = self._delete_pipeline_serialize(
404            organization=organization,
405            pipeline=pipeline,
406            _request_auth=_request_auth,
407            _content_type=_content_type,
408            _headers=_headers,
409            _host_index=_host_index
410        )
411
412        _response_types_map: Dict[str, Optional[str]] = {
413            '200': "DeletePipelineResponse",
414            '400': "GetPipelines400Response",
415            '401': "GetPipelines400Response",
416            '403': "GetPipelines400Response",
417            '404': "GetPipelines400Response",
418            '500': "GetPipelines400Response",
419        }
420        response_data = self.api_client.call_api(
421            *_param,
422            _request_timeout=_request_timeout
423        )
424        response_data.read()
425        return self.api_client.response_deserialize(
426            response_data=response_data,
427            response_types_map=_response_types_map,
428        ).data

Delete a pipeline

Parameters

organization: (required)
pipeline: (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

@validate_call

def delete_pipeline_with_http_info( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[DeletePipelineResponse]: View Source

431    @validate_call
432    def delete_pipeline_with_http_info(
433        self,
434        organization: StrictStr,
435        pipeline: StrictStr,
436        _request_timeout: Union[
437            None,
438            Annotated[StrictFloat, Field(gt=0)],
439            Tuple[
440                Annotated[StrictFloat, Field(gt=0)],
441                Annotated[StrictFloat, Field(gt=0)]
442            ]
443        ] = None,
444        _request_auth: Optional[Dict[StrictStr, Any]] = None,
445        _content_type: Optional[StrictStr] = None,
446        _headers: Optional[Dict[StrictStr, Any]] = None,
447        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
448    ) -> ApiResponse[DeletePipelineResponse]:
449        """Delete a pipeline
450
451
452        :param organization: (required)
453        :type organization: str
454        :param pipeline: (required)
455        :type pipeline: str
456        :param _request_timeout: timeout setting for this request. If one
457                                 number provided, it will be total request
458                                 timeout. It can also be a pair (tuple) of
459                                 (connection, read) timeouts.
460        :type _request_timeout: int, tuple(int, int), optional
461        :param _request_auth: set to override the auth_settings for an a single
462                              request; this effectively ignores the
463                              authentication in the spec for a single request.
464        :type _request_auth: dict, optional
465        :param _content_type: force content-type for the request.
466        :type _content_type: str, Optional
467        :param _headers: set to override the headers for a single
468                         request; this effectively ignores the headers
469                         in the spec for a single request.
470        :type _headers: dict, optional
471        :param _host_index: set to override the host_index for a single
472                            request; this effectively ignores the host_index
473                            in the spec for a single request.
474        :type _host_index: int, optional
475        :return: Returns the result object.
476        """ # noqa: E501
477
478        _param = self._delete_pipeline_serialize(
479            organization=organization,
480            pipeline=pipeline,
481            _request_auth=_request_auth,
482            _content_type=_content_type,
483            _headers=_headers,
484            _host_index=_host_index
485        )
486
487        _response_types_map: Dict[str, Optional[str]] = {
488            '200': "DeletePipelineResponse",
489            '400': "GetPipelines400Response",
490            '401': "GetPipelines400Response",
491            '403': "GetPipelines400Response",
492            '404': "GetPipelines400Response",
493            '500': "GetPipelines400Response",
494        }
495        response_data = self.api_client.call_api(
496            *_param,
497            _request_timeout=_request_timeout
498        )
499        response_data.read()
500        return self.api_client.response_deserialize(
501            response_data=response_data,
502            response_types_map=_response_types_map,
503        )

Delete a pipeline

Parameters

organization: (required)
pipeline: (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

@validate_call

def delete_pipeline_without_preload_content( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: 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: View Source

506    @validate_call
507    def delete_pipeline_without_preload_content(
508        self,
509        organization: StrictStr,
510        pipeline: StrictStr,
511        _request_timeout: Union[
512            None,
513            Annotated[StrictFloat, Field(gt=0)],
514            Tuple[
515                Annotated[StrictFloat, Field(gt=0)],
516                Annotated[StrictFloat, Field(gt=0)]
517            ]
518        ] = None,
519        _request_auth: Optional[Dict[StrictStr, Any]] = None,
520        _content_type: Optional[StrictStr] = None,
521        _headers: Optional[Dict[StrictStr, Any]] = None,
522        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
523    ) -> RESTResponseType:
524        """Delete a pipeline
525
526
527        :param organization: (required)
528        :type organization: str
529        :param pipeline: (required)
530        :type pipeline: str
531        :param _request_timeout: timeout setting for this request. If one
532                                 number provided, it will be total request
533                                 timeout. It can also be a pair (tuple) of
534                                 (connection, read) timeouts.
535        :type _request_timeout: int, tuple(int, int), optional
536        :param _request_auth: set to override the auth_settings for an a single
537                              request; this effectively ignores the
538                              authentication in the spec for a single request.
539        :type _request_auth: dict, optional
540        :param _content_type: force content-type for the request.
541        :type _content_type: str, Optional
542        :param _headers: set to override the headers for a single
543                         request; this effectively ignores the headers
544                         in the spec for a single request.
545        :type _headers: dict, optional
546        :param _host_index: set to override the host_index for a single
547                            request; this effectively ignores the host_index
548                            in the spec for a single request.
549        :type _host_index: int, optional
550        :return: Returns the result object.
551        """ # noqa: E501
552
553        _param = self._delete_pipeline_serialize(
554            organization=organization,
555            pipeline=pipeline,
556            _request_auth=_request_auth,
557            _content_type=_content_type,
558            _headers=_headers,
559            _host_index=_host_index
560        )
561
562        _response_types_map: Dict[str, Optional[str]] = {
563            '200': "DeletePipelineResponse",
564            '400': "GetPipelines400Response",
565            '401': "GetPipelines400Response",
566            '403': "GetPipelines400Response",
567            '404': "GetPipelines400Response",
568            '500': "GetPipelines400Response",
569        }
570        response_data = self.api_client.call_api(
571            *_param,
572            _request_timeout=_request_timeout
573        )
574        return response_data.response

Delete a pipeline

Parameters

organization: (required)
pipeline: (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

@validate_call

def get_deep_research_result( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], research_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.get_deep_research_response.GetDeepResearchResponse: View Source

644    @validate_call
645    def get_deep_research_result(
646        self,
647        organization: StrictStr,
648        pipeline: StrictStr,
649        research_id: StrictStr,
650        _request_timeout: Union[
651            None,
652            Annotated[StrictFloat, Field(gt=0)],
653            Tuple[
654                Annotated[StrictFloat, Field(gt=0)],
655                Annotated[StrictFloat, Field(gt=0)]
656            ]
657        ] = None,
658        _request_auth: Optional[Dict[StrictStr, Any]] = None,
659        _content_type: Optional[StrictStr] = None,
660        _headers: Optional[Dict[StrictStr, Any]] = None,
661        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
662    ) -> GetDeepResearchResponse:
663        """Get deep research result
664
665
666        :param organization: (required)
667        :type organization: str
668        :param pipeline: (required)
669        :type pipeline: str
670        :param research_id: (required)
671        :type research_id: str
672        :param _request_timeout: timeout setting for this request. If one
673                                 number provided, it will be total request
674                                 timeout. It can also be a pair (tuple) of
675                                 (connection, read) timeouts.
676        :type _request_timeout: int, tuple(int, int), optional
677        :param _request_auth: set to override the auth_settings for an a single
678                              request; this effectively ignores the
679                              authentication in the spec for a single request.
680        :type _request_auth: dict, optional
681        :param _content_type: force content-type for the request.
682        :type _content_type: str, Optional
683        :param _headers: set to override the headers for a single
684                         request; this effectively ignores the headers
685                         in the spec for a single request.
686        :type _headers: dict, optional
687        :param _host_index: set to override the host_index for a single
688                            request; this effectively ignores the host_index
689                            in the spec for a single request.
690        :type _host_index: int, optional
691        :return: Returns the result object.
692        """ # noqa: E501
693
694        _param = self._get_deep_research_result_serialize(
695            organization=organization,
696            pipeline=pipeline,
697            research_id=research_id,
698            _request_auth=_request_auth,
699            _content_type=_content_type,
700            _headers=_headers,
701            _host_index=_host_index
702        )
703
704        _response_types_map: Dict[str, Optional[str]] = {
705            '200': "GetDeepResearchResponse",
706            '400': "GetPipelines400Response",
707            '401': "GetPipelines400Response",
708            '403': "GetPipelines400Response",
709            '404': "GetPipelines400Response",
710            '500': "GetPipelines400Response",
711        }
712        response_data = self.api_client.call_api(
713            *_param,
714            _request_timeout=_request_timeout
715        )
716        response_data.read()
717        return self.api_client.response_deserialize(
718            response_data=response_data,
719            response_types_map=_response_types_map,
720        ).data

Get deep research result

Parameters

organization: (required)
pipeline: (required)
research_id: (required)
_request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type: force content-type for the request.
_headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns

@validate_call

def get_deep_research_result_with_http_info( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], research_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[GetDeepResearchResponse]: View Source

723    @validate_call
724    def get_deep_research_result_with_http_info(
725        self,
726        organization: StrictStr,
727        pipeline: StrictStr,
728        research_id: StrictStr,
729        _request_timeout: Union[
730            None,
731            Annotated[StrictFloat, Field(gt=0)],
732            Tuple[
733                Annotated[StrictFloat, Field(gt=0)],
734                Annotated[StrictFloat, Field(gt=0)]
735            ]
736        ] = None,
737        _request_auth: Optional[Dict[StrictStr, Any]] = None,
738        _content_type: Optional[StrictStr] = None,
739        _headers: Optional[Dict[StrictStr, Any]] = None,
740        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
741    ) -> ApiResponse[GetDeepResearchResponse]:
742        """Get deep research result
743
744
745        :param organization: (required)
746        :type organization: str
747        :param pipeline: (required)
748        :type pipeline: str
749        :param research_id: (required)
750        :type research_id: str
751        :param _request_timeout: timeout setting for this request. If one
752                                 number provided, it will be total request
753                                 timeout. It can also be a pair (tuple) of
754                                 (connection, read) timeouts.
755        :type _request_timeout: int, tuple(int, int), optional
756        :param _request_auth: set to override the auth_settings for an a single
757                              request; this effectively ignores the
758                              authentication in the spec for a single request.
759        :type _request_auth: dict, optional
760        :param _content_type: force content-type for the request.
761        :type _content_type: str, Optional
762        :param _headers: set to override the headers for a single
763                         request; this effectively ignores the headers
764                         in the spec for a single request.
765        :type _headers: dict, optional
766        :param _host_index: set to override the host_index for a single
767                            request; this effectively ignores the host_index
768                            in the spec for a single request.
769        :type _host_index: int, optional
770        :return: Returns the result object.
771        """ # noqa: E501
772
773        _param = self._get_deep_research_result_serialize(
774            organization=organization,
775            pipeline=pipeline,
776            research_id=research_id,
777            _request_auth=_request_auth,
778            _content_type=_content_type,
779            _headers=_headers,
780            _host_index=_host_index
781        )
782
783        _response_types_map: Dict[str, Optional[str]] = {
784            '200': "GetDeepResearchResponse",
785            '400': "GetPipelines400Response",
786            '401': "GetPipelines400Response",
787            '403': "GetPipelines400Response",
788            '404': "GetPipelines400Response",
789            '500': "GetPipelines400Response",
790        }
791        response_data = self.api_client.call_api(
792            *_param,
793            _request_timeout=_request_timeout
794        )
795        response_data.read()
796        return self.api_client.response_deserialize(
797            response_data=response_data,
798            response_types_map=_response_types_map,
799        )

Get deep research result

Parameters

organization: (required)
pipeline: (required)
research_id: (required)
_request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type: force content-type for the request.
_headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns

@validate_call

def get_deep_research_result_without_preload_content( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], research_id: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse: View Source

802    @validate_call
803    def get_deep_research_result_without_preload_content(
804        self,
805        organization: StrictStr,
806        pipeline: StrictStr,
807        research_id: StrictStr,
808        _request_timeout: Union[
809            None,
810            Annotated[StrictFloat, Field(gt=0)],
811            Tuple[
812                Annotated[StrictFloat, Field(gt=0)],
813                Annotated[StrictFloat, Field(gt=0)]
814            ]
815        ] = None,
816        _request_auth: Optional[Dict[StrictStr, Any]] = None,
817        _content_type: Optional[StrictStr] = None,
818        _headers: Optional[Dict[StrictStr, Any]] = None,
819        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
820    ) -> RESTResponseType:
821        """Get deep research result
822
823
824        :param organization: (required)
825        :type organization: str
826        :param pipeline: (required)
827        :type pipeline: str
828        :param research_id: (required)
829        :type research_id: str
830        :param _request_timeout: timeout setting for this request. If one
831                                 number provided, it will be total request
832                                 timeout. It can also be a pair (tuple) of
833                                 (connection, read) timeouts.
834        :type _request_timeout: int, tuple(int, int), optional
835        :param _request_auth: set to override the auth_settings for an a single
836                              request; this effectively ignores the
837                              authentication in the spec for a single request.
838        :type _request_auth: dict, optional
839        :param _content_type: force content-type for the request.
840        :type _content_type: str, Optional
841        :param _headers: set to override the headers for a single
842                         request; this effectively ignores the headers
843                         in the spec for a single request.
844        :type _headers: dict, optional
845        :param _host_index: set to override the host_index for a single
846                            request; this effectively ignores the host_index
847                            in the spec for a single request.
848        :type _host_index: int, optional
849        :return: Returns the result object.
850        """ # noqa: E501
851
852        _param = self._get_deep_research_result_serialize(
853            organization=organization,
854            pipeline=pipeline,
855            research_id=research_id,
856            _request_auth=_request_auth,
857            _content_type=_content_type,
858            _headers=_headers,
859            _host_index=_host_index
860        )
861
862        _response_types_map: Dict[str, Optional[str]] = {
863            '200': "GetDeepResearchResponse",
864            '400': "GetPipelines400Response",
865            '401': "GetPipelines400Response",
866            '403': "GetPipelines400Response",
867            '404': "GetPipelines400Response",
868            '500': "GetPipelines400Response",
869        }
870        response_data = self.api_client.call_api(
871            *_param,
872            _request_timeout=_request_timeout
873        )
874        return response_data.response

Get deep research result

Parameters

organization: (required)
pipeline: (required)
research_id: (required)
_request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type: force content-type for the request.
_headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns

@validate_call

def get_pipeline( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.get_pipeline_response.GetPipelineResponse: View Source

 947    @validate_call
 948    def get_pipeline(
 949        self,
 950        organization: StrictStr,
 951        pipeline: StrictStr,
 952        _request_timeout: Union[
 953            None,
 954            Annotated[StrictFloat, Field(gt=0)],
 955            Tuple[
 956                Annotated[StrictFloat, Field(gt=0)],
 957                Annotated[StrictFloat, Field(gt=0)]
 958            ]
 959        ] = None,
 960        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 961        _content_type: Optional[StrictStr] = None,
 962        _headers: Optional[Dict[StrictStr, Any]] = None,
 963        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 964    ) -> GetPipelineResponse:
 965        """Get a pipeline
 966
 967
 968        :param organization: (required)
 969        :type organization: str
 970        :param pipeline: (required)
 971        :type pipeline: str
 972        :param _request_timeout: timeout setting for this request. If one
 973                                 number provided, it will be total request
 974                                 timeout. It can also be a pair (tuple) of
 975                                 (connection, read) timeouts.
 976        :type _request_timeout: int, tuple(int, int), optional
 977        :param _request_auth: set to override the auth_settings for an a single
 978                              request; this effectively ignores the
 979                              authentication in the spec for a single request.
 980        :type _request_auth: dict, optional
 981        :param _content_type: force content-type for the request.
 982        :type _content_type: str, Optional
 983        :param _headers: set to override the headers for a single
 984                         request; this effectively ignores the headers
 985                         in the spec for a single request.
 986        :type _headers: dict, optional
 987        :param _host_index: set to override the host_index for a single
 988                            request; this effectively ignores the host_index
 989                            in the spec for a single request.
 990        :type _host_index: int, optional
 991        :return: Returns the result object.
 992        """ # noqa: E501
 993
 994        _param = self._get_pipeline_serialize(
 995            organization=organization,
 996            pipeline=pipeline,
 997            _request_auth=_request_auth,
 998            _content_type=_content_type,
 999            _headers=_headers,
1000            _host_index=_host_index
1001        )
1002
1003        _response_types_map: Dict[str, Optional[str]] = {
1004            '200': "GetPipelineResponse",
1005            '400': "GetPipelines400Response",
1006            '401': "GetPipelines400Response",
1007            '403': "GetPipelines400Response",
1008            '404': "GetPipelines400Response",
1009            '500': "GetPipelines400Response",
1010        }
1011        response_data = self.api_client.call_api(
1012            *_param,
1013            _request_timeout=_request_timeout
1014        )
1015        response_data.read()
1016        return self.api_client.response_deserialize(
1017            response_data=response_data,
1018            response_types_map=_response_types_map,
1019        ).data

Get a pipeline

Parameters

organization: (required)
pipeline: (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

@validate_call

def get_pipeline_with_http_info( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[GetPipelineResponse]: View Source

1022    @validate_call
1023    def get_pipeline_with_http_info(
1024        self,
1025        organization: StrictStr,
1026        pipeline: StrictStr,
1027        _request_timeout: Union[
1028            None,
1029            Annotated[StrictFloat, Field(gt=0)],
1030            Tuple[
1031                Annotated[StrictFloat, Field(gt=0)],
1032                Annotated[StrictFloat, Field(gt=0)]
1033            ]
1034        ] = None,
1035        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1036        _content_type: Optional[StrictStr] = None,
1037        _headers: Optional[Dict[StrictStr, Any]] = None,
1038        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1039    ) -> ApiResponse[GetPipelineResponse]:
1040        """Get a pipeline
1041
1042
1043        :param organization: (required)
1044        :type organization: str
1045        :param pipeline: (required)
1046        :type pipeline: str
1047        :param _request_timeout: timeout setting for this request. If one
1048                                 number provided, it will be total request
1049                                 timeout. It can also be a pair (tuple) of
1050                                 (connection, read) timeouts.
1051        :type _request_timeout: int, tuple(int, int), optional
1052        :param _request_auth: set to override the auth_settings for an a single
1053                              request; this effectively ignores the
1054                              authentication in the spec for a single request.
1055        :type _request_auth: dict, optional
1056        :param _content_type: force content-type for the request.
1057        :type _content_type: str, Optional
1058        :param _headers: set to override the headers for a single
1059                         request; this effectively ignores the headers
1060                         in the spec for a single request.
1061        :type _headers: dict, optional
1062        :param _host_index: set to override the host_index for a single
1063                            request; this effectively ignores the host_index
1064                            in the spec for a single request.
1065        :type _host_index: int, optional
1066        :return: Returns the result object.
1067        """ # noqa: E501
1068
1069        _param = self._get_pipeline_serialize(
1070            organization=organization,
1071            pipeline=pipeline,
1072            _request_auth=_request_auth,
1073            _content_type=_content_type,
1074            _headers=_headers,
1075            _host_index=_host_index
1076        )
1077
1078        _response_types_map: Dict[str, Optional[str]] = {
1079            '200': "GetPipelineResponse",
1080            '400': "GetPipelines400Response",
1081            '401': "GetPipelines400Response",
1082            '403': "GetPipelines400Response",
1083            '404': "GetPipelines400Response",
1084            '500': "GetPipelines400Response",
1085        }
1086        response_data = self.api_client.call_api(
1087            *_param,
1088            _request_timeout=_request_timeout
1089        )
1090        response_data.read()
1091        return self.api_client.response_deserialize(
1092            response_data=response_data,
1093            response_types_map=_response_types_map,
1094        )

Get a pipeline

Parameters

organization: (required)
pipeline: (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

@validate_call

def get_pipeline_without_preload_content( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: 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: View Source

1097    @validate_call
1098    def get_pipeline_without_preload_content(
1099        self,
1100        organization: StrictStr,
1101        pipeline: StrictStr,
1102        _request_timeout: Union[
1103            None,
1104            Annotated[StrictFloat, Field(gt=0)],
1105            Tuple[
1106                Annotated[StrictFloat, Field(gt=0)],
1107                Annotated[StrictFloat, Field(gt=0)]
1108            ]
1109        ] = None,
1110        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1111        _content_type: Optional[StrictStr] = None,
1112        _headers: Optional[Dict[StrictStr, Any]] = None,
1113        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1114    ) -> RESTResponseType:
1115        """Get a pipeline
1116
1117
1118        :param organization: (required)
1119        :type organization: str
1120        :param pipeline: (required)
1121        :type pipeline: str
1122        :param _request_timeout: timeout setting for this request. If one
1123                                 number provided, it will be total request
1124                                 timeout. It can also be a pair (tuple) of
1125                                 (connection, read) timeouts.
1126        :type _request_timeout: int, tuple(int, int), optional
1127        :param _request_auth: set to override the auth_settings for an a single
1128                              request; this effectively ignores the
1129                              authentication in the spec for a single request.
1130        :type _request_auth: dict, optional
1131        :param _content_type: force content-type for the request.
1132        :type _content_type: str, Optional
1133        :param _headers: set to override the headers for a single
1134                         request; this effectively ignores the headers
1135                         in the spec for a single request.
1136        :type _headers: dict, optional
1137        :param _host_index: set to override the host_index for a single
1138                            request; this effectively ignores the host_index
1139                            in the spec for a single request.
1140        :type _host_index: int, optional
1141        :return: Returns the result object.
1142        """ # noqa: E501
1143
1144        _param = self._get_pipeline_serialize(
1145            organization=organization,
1146            pipeline=pipeline,
1147            _request_auth=_request_auth,
1148            _content_type=_content_type,
1149            _headers=_headers,
1150            _host_index=_host_index
1151        )
1152
1153        _response_types_map: Dict[str, Optional[str]] = {
1154            '200': "GetPipelineResponse",
1155            '400': "GetPipelines400Response",
1156            '401': "GetPipelines400Response",
1157            '403': "GetPipelines400Response",
1158            '404': "GetPipelines400Response",
1159            '500': "GetPipelines400Response",
1160        }
1161        response_data = self.api_client.call_api(
1162            *_param,
1163            _request_timeout=_request_timeout
1164        )
1165        return response_data.response

Get a pipeline

Parameters

organization: (required)
pipeline: (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

@validate_call

def get_pipeline_events( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], next_token: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.get_pipeline_events_response.GetPipelineEventsResponse: View Source

1235    @validate_call
1236    def get_pipeline_events(
1237        self,
1238        organization: StrictStr,
1239        pipeline: StrictStr,
1240        next_token: Optional[StrictStr] = None,
1241        _request_timeout: Union[
1242            None,
1243            Annotated[StrictFloat, Field(gt=0)],
1244            Tuple[
1245                Annotated[StrictFloat, Field(gt=0)],
1246                Annotated[StrictFloat, Field(gt=0)]
1247            ]
1248        ] = None,
1249        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1250        _content_type: Optional[StrictStr] = None,
1251        _headers: Optional[Dict[StrictStr, Any]] = None,
1252        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1253    ) -> GetPipelineEventsResponse:
1254        """Get pipeline events
1255
1256
1257        :param organization: (required)
1258        :type organization: str
1259        :param pipeline: (required)
1260        :type pipeline: str
1261        :param next_token:
1262        :type next_token: str
1263        :param _request_timeout: timeout setting for this request. If one
1264                                 number provided, it will be total request
1265                                 timeout. It can also be a pair (tuple) of
1266                                 (connection, read) timeouts.
1267        :type _request_timeout: int, tuple(int, int), optional
1268        :param _request_auth: set to override the auth_settings for an a single
1269                              request; this effectively ignores the
1270                              authentication in the spec for a single request.
1271        :type _request_auth: dict, optional
1272        :param _content_type: force content-type for the request.
1273        :type _content_type: str, Optional
1274        :param _headers: set to override the headers for a single
1275                         request; this effectively ignores the headers
1276                         in the spec for a single request.
1277        :type _headers: dict, optional
1278        :param _host_index: set to override the host_index for a single
1279                            request; this effectively ignores the host_index
1280                            in the spec for a single request.
1281        :type _host_index: int, optional
1282        :return: Returns the result object.
1283        """ # noqa: E501
1284
1285        _param = self._get_pipeline_events_serialize(
1286            organization=organization,
1287            pipeline=pipeline,
1288            next_token=next_token,
1289            _request_auth=_request_auth,
1290            _content_type=_content_type,
1291            _headers=_headers,
1292            _host_index=_host_index
1293        )
1294
1295        _response_types_map: Dict[str, Optional[str]] = {
1296            '200': "GetPipelineEventsResponse",
1297            '400': "GetPipelines400Response",
1298            '401': "GetPipelines400Response",
1299            '403': "GetPipelines400Response",
1300            '404': "GetPipelines400Response",
1301            '500': "GetPipelines400Response",
1302        }
1303        response_data = self.api_client.call_api(
1304            *_param,
1305            _request_timeout=_request_timeout
1306        )
1307        response_data.read()
1308        return self.api_client.response_deserialize(
1309            response_data=response_data,
1310            response_types_map=_response_types_map,
1311        ).data

Get pipeline events

Parameters

organization: (required)
pipeline: (required)
next_token:
_request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type: force content-type for the request.
_headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns

@validate_call

def get_pipeline_events_with_http_info( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], next_token: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[GetPipelineEventsResponse]: View Source

1314    @validate_call
1315    def get_pipeline_events_with_http_info(
1316        self,
1317        organization: StrictStr,
1318        pipeline: StrictStr,
1319        next_token: Optional[StrictStr] = None,
1320        _request_timeout: Union[
1321            None,
1322            Annotated[StrictFloat, Field(gt=0)],
1323            Tuple[
1324                Annotated[StrictFloat, Field(gt=0)],
1325                Annotated[StrictFloat, Field(gt=0)]
1326            ]
1327        ] = None,
1328        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1329        _content_type: Optional[StrictStr] = None,
1330        _headers: Optional[Dict[StrictStr, Any]] = None,
1331        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1332    ) -> ApiResponse[GetPipelineEventsResponse]:
1333        """Get pipeline events
1334
1335
1336        :param organization: (required)
1337        :type organization: str
1338        :param pipeline: (required)
1339        :type pipeline: str
1340        :param next_token:
1341        :type next_token: str
1342        :param _request_timeout: timeout setting for this request. If one
1343                                 number provided, it will be total request
1344                                 timeout. It can also be a pair (tuple) of
1345                                 (connection, read) timeouts.
1346        :type _request_timeout: int, tuple(int, int), optional
1347        :param _request_auth: set to override the auth_settings for an a single
1348                              request; this effectively ignores the
1349                              authentication in the spec for a single request.
1350        :type _request_auth: dict, optional
1351        :param _content_type: force content-type for the request.
1352        :type _content_type: str, Optional
1353        :param _headers: set to override the headers for a single
1354                         request; this effectively ignores the headers
1355                         in the spec for a single request.
1356        :type _headers: dict, optional
1357        :param _host_index: set to override the host_index for a single
1358                            request; this effectively ignores the host_index
1359                            in the spec for a single request.
1360        :type _host_index: int, optional
1361        :return: Returns the result object.
1362        """ # noqa: E501
1363
1364        _param = self._get_pipeline_events_serialize(
1365            organization=organization,
1366            pipeline=pipeline,
1367            next_token=next_token,
1368            _request_auth=_request_auth,
1369            _content_type=_content_type,
1370            _headers=_headers,
1371            _host_index=_host_index
1372        )
1373
1374        _response_types_map: Dict[str, Optional[str]] = {
1375            '200': "GetPipelineEventsResponse",
1376            '400': "GetPipelines400Response",
1377            '401': "GetPipelines400Response",
1378            '403': "GetPipelines400Response",
1379            '404': "GetPipelines400Response",
1380            '500': "GetPipelines400Response",
1381        }
1382        response_data = self.api_client.call_api(
1383            *_param,
1384            _request_timeout=_request_timeout
1385        )
1386        response_data.read()
1387        return self.api_client.response_deserialize(
1388            response_data=response_data,
1389            response_types_map=_response_types_map,
1390        )

Get pipeline events

Parameters

organization: (required)
pipeline: (required)
next_token:
_request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type: force content-type for the request.
_headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns

@validate_call

def get_pipeline_events_without_preload_content( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], next_token: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse: View Source

1393    @validate_call
1394    def get_pipeline_events_without_preload_content(
1395        self,
1396        organization: StrictStr,
1397        pipeline: StrictStr,
1398        next_token: Optional[StrictStr] = None,
1399        _request_timeout: Union[
1400            None,
1401            Annotated[StrictFloat, Field(gt=0)],
1402            Tuple[
1403                Annotated[StrictFloat, Field(gt=0)],
1404                Annotated[StrictFloat, Field(gt=0)]
1405            ]
1406        ] = None,
1407        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1408        _content_type: Optional[StrictStr] = None,
1409        _headers: Optional[Dict[StrictStr, Any]] = None,
1410        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1411    ) -> RESTResponseType:
1412        """Get pipeline events
1413
1414
1415        :param organization: (required)
1416        :type organization: str
1417        :param pipeline: (required)
1418        :type pipeline: str
1419        :param next_token:
1420        :type next_token: str
1421        :param _request_timeout: timeout setting for this request. If one
1422                                 number provided, it will be total request
1423                                 timeout. It can also be a pair (tuple) of
1424                                 (connection, read) timeouts.
1425        :type _request_timeout: int, tuple(int, int), optional
1426        :param _request_auth: set to override the auth_settings for an a single
1427                              request; this effectively ignores the
1428                              authentication in the spec for a single request.
1429        :type _request_auth: dict, optional
1430        :param _content_type: force content-type for the request.
1431        :type _content_type: str, Optional
1432        :param _headers: set to override the headers for a single
1433                         request; this effectively ignores the headers
1434                         in the spec for a single request.
1435        :type _headers: dict, optional
1436        :param _host_index: set to override the host_index for a single
1437                            request; this effectively ignores the host_index
1438                            in the spec for a single request.
1439        :type _host_index: int, optional
1440        :return: Returns the result object.
1441        """ # noqa: E501
1442
1443        _param = self._get_pipeline_events_serialize(
1444            organization=organization,
1445            pipeline=pipeline,
1446            next_token=next_token,
1447            _request_auth=_request_auth,
1448            _content_type=_content_type,
1449            _headers=_headers,
1450            _host_index=_host_index
1451        )
1452
1453        _response_types_map: Dict[str, Optional[str]] = {
1454            '200': "GetPipelineEventsResponse",
1455            '400': "GetPipelines400Response",
1456            '401': "GetPipelines400Response",
1457            '403': "GetPipelines400Response",
1458            '404': "GetPipelines400Response",
1459            '500': "GetPipelines400Response",
1460        }
1461        response_data = self.api_client.call_api(
1462            *_param,
1463            _request_timeout=_request_timeout
1464        )
1465        return response_data.response

Get pipeline events

Parameters

organization: (required)
pipeline: (required)
next_token:
_request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type: force content-type for the request.
_headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns

@validate_call

def get_pipeline_metrics( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.get_pipeline_metrics_response.GetPipelineMetricsResponse: View Source

1540    @validate_call
1541    def get_pipeline_metrics(
1542        self,
1543        organization: StrictStr,
1544        pipeline: StrictStr,
1545        _request_timeout: Union[
1546            None,
1547            Annotated[StrictFloat, Field(gt=0)],
1548            Tuple[
1549                Annotated[StrictFloat, Field(gt=0)],
1550                Annotated[StrictFloat, Field(gt=0)]
1551            ]
1552        ] = None,
1553        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1554        _content_type: Optional[StrictStr] = None,
1555        _headers: Optional[Dict[StrictStr, Any]] = None,
1556        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1557    ) -> GetPipelineMetricsResponse:
1558        """Get pipeline metrics
1559
1560
1561        :param organization: (required)
1562        :type organization: str
1563        :param pipeline: (required)
1564        :type pipeline: str
1565        :param _request_timeout: timeout setting for this request. If one
1566                                 number provided, it will be total request
1567                                 timeout. It can also be a pair (tuple) of
1568                                 (connection, read) timeouts.
1569        :type _request_timeout: int, tuple(int, int), optional
1570        :param _request_auth: set to override the auth_settings for an a single
1571                              request; this effectively ignores the
1572                              authentication in the spec for a single request.
1573        :type _request_auth: dict, optional
1574        :param _content_type: force content-type for the request.
1575        :type _content_type: str, Optional
1576        :param _headers: set to override the headers for a single
1577                         request; this effectively ignores the headers
1578                         in the spec for a single request.
1579        :type _headers: dict, optional
1580        :param _host_index: set to override the host_index for a single
1581                            request; this effectively ignores the host_index
1582                            in the spec for a single request.
1583        :type _host_index: int, optional
1584        :return: Returns the result object.
1585        """ # noqa: E501
1586
1587        _param = self._get_pipeline_metrics_serialize(
1588            organization=organization,
1589            pipeline=pipeline,
1590            _request_auth=_request_auth,
1591            _content_type=_content_type,
1592            _headers=_headers,
1593            _host_index=_host_index
1594        )
1595
1596        _response_types_map: Dict[str, Optional[str]] = {
1597            '200': "GetPipelineMetricsResponse",
1598            '400': "GetPipelines400Response",
1599            '401': "GetPipelines400Response",
1600            '403': "GetPipelines400Response",
1601            '404': "GetPipelines400Response",
1602            '500': "GetPipelines400Response",
1603        }
1604        response_data = self.api_client.call_api(
1605            *_param,
1606            _request_timeout=_request_timeout
1607        )
1608        response_data.read()
1609        return self.api_client.response_deserialize(
1610            response_data=response_data,
1611            response_types_map=_response_types_map,
1612        ).data

Get pipeline metrics

Parameters

organization: (required)
pipeline: (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

@validate_call

def get_pipeline_metrics_with_http_info( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[GetPipelineMetricsResponse]: View Source

1615    @validate_call
1616    def get_pipeline_metrics_with_http_info(
1617        self,
1618        organization: StrictStr,
1619        pipeline: StrictStr,
1620        _request_timeout: Union[
1621            None,
1622            Annotated[StrictFloat, Field(gt=0)],
1623            Tuple[
1624                Annotated[StrictFloat, Field(gt=0)],
1625                Annotated[StrictFloat, Field(gt=0)]
1626            ]
1627        ] = None,
1628        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1629        _content_type: Optional[StrictStr] = None,
1630        _headers: Optional[Dict[StrictStr, Any]] = None,
1631        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1632    ) -> ApiResponse[GetPipelineMetricsResponse]:
1633        """Get pipeline metrics
1634
1635
1636        :param organization: (required)
1637        :type organization: str
1638        :param pipeline: (required)
1639        :type pipeline: str
1640        :param _request_timeout: timeout setting for this request. If one
1641                                 number provided, it will be total request
1642                                 timeout. It can also be a pair (tuple) of
1643                                 (connection, read) timeouts.
1644        :type _request_timeout: int, tuple(int, int), optional
1645        :param _request_auth: set to override the auth_settings for an a single
1646                              request; this effectively ignores the
1647                              authentication in the spec for a single request.
1648        :type _request_auth: dict, optional
1649        :param _content_type: force content-type for the request.
1650        :type _content_type: str, Optional
1651        :param _headers: set to override the headers for a single
1652                         request; this effectively ignores the headers
1653                         in the spec for a single request.
1654        :type _headers: dict, optional
1655        :param _host_index: set to override the host_index for a single
1656                            request; this effectively ignores the host_index
1657                            in the spec for a single request.
1658        :type _host_index: int, optional
1659        :return: Returns the result object.
1660        """ # noqa: E501
1661
1662        _param = self._get_pipeline_metrics_serialize(
1663            organization=organization,
1664            pipeline=pipeline,
1665            _request_auth=_request_auth,
1666            _content_type=_content_type,
1667            _headers=_headers,
1668            _host_index=_host_index
1669        )
1670
1671        _response_types_map: Dict[str, Optional[str]] = {
1672            '200': "GetPipelineMetricsResponse",
1673            '400': "GetPipelines400Response",
1674            '401': "GetPipelines400Response",
1675            '403': "GetPipelines400Response",
1676            '404': "GetPipelines400Response",
1677            '500': "GetPipelines400Response",
1678        }
1679        response_data = self.api_client.call_api(
1680            *_param,
1681            _request_timeout=_request_timeout
1682        )
1683        response_data.read()
1684        return self.api_client.response_deserialize(
1685            response_data=response_data,
1686            response_types_map=_response_types_map,
1687        )

Get pipeline metrics

Parameters

organization: (required)
pipeline: (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

@validate_call

def get_pipeline_metrics_without_preload_content( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: 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: View Source

1690    @validate_call
1691    def get_pipeline_metrics_without_preload_content(
1692        self,
1693        organization: StrictStr,
1694        pipeline: StrictStr,
1695        _request_timeout: Union[
1696            None,
1697            Annotated[StrictFloat, Field(gt=0)],
1698            Tuple[
1699                Annotated[StrictFloat, Field(gt=0)],
1700                Annotated[StrictFloat, Field(gt=0)]
1701            ]
1702        ] = None,
1703        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1704        _content_type: Optional[StrictStr] = None,
1705        _headers: Optional[Dict[StrictStr, Any]] = None,
1706        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1707    ) -> RESTResponseType:
1708        """Get pipeline metrics
1709
1710
1711        :param organization: (required)
1712        :type organization: str
1713        :param pipeline: (required)
1714        :type pipeline: str
1715        :param _request_timeout: timeout setting for this request. If one
1716                                 number provided, it will be total request
1717                                 timeout. It can also be a pair (tuple) of
1718                                 (connection, read) timeouts.
1719        :type _request_timeout: int, tuple(int, int), optional
1720        :param _request_auth: set to override the auth_settings for an a single
1721                              request; this effectively ignores the
1722                              authentication in the spec for a single request.
1723        :type _request_auth: dict, optional
1724        :param _content_type: force content-type for the request.
1725        :type _content_type: str, Optional
1726        :param _headers: set to override the headers for a single
1727                         request; this effectively ignores the headers
1728                         in the spec for a single request.
1729        :type _headers: dict, optional
1730        :param _host_index: set to override the host_index for a single
1731                            request; this effectively ignores the host_index
1732                            in the spec for a single request.
1733        :type _host_index: int, optional
1734        :return: Returns the result object.
1735        """ # noqa: E501
1736
1737        _param = self._get_pipeline_metrics_serialize(
1738            organization=organization,
1739            pipeline=pipeline,
1740            _request_auth=_request_auth,
1741            _content_type=_content_type,
1742            _headers=_headers,
1743            _host_index=_host_index
1744        )
1745
1746        _response_types_map: Dict[str, Optional[str]] = {
1747            '200': "GetPipelineMetricsResponse",
1748            '400': "GetPipelines400Response",
1749            '401': "GetPipelines400Response",
1750            '403': "GetPipelines400Response",
1751            '404': "GetPipelines400Response",
1752            '500': "GetPipelines400Response",
1753        }
1754        response_data = self.api_client.call_api(
1755            *_param,
1756            _request_timeout=_request_timeout
1757        )
1758        return response_data.response

Get pipeline metrics

Parameters

organization: (required)
pipeline: (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

@validate_call

def get_pipelines( self, organization: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.get_pipelines_response.GetPipelinesResponse: View Source

1828    @validate_call
1829    def get_pipelines(
1830        self,
1831        organization: StrictStr,
1832        _request_timeout: Union[
1833            None,
1834            Annotated[StrictFloat, Field(gt=0)],
1835            Tuple[
1836                Annotated[StrictFloat, Field(gt=0)],
1837                Annotated[StrictFloat, Field(gt=0)]
1838            ]
1839        ] = None,
1840        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1841        _content_type: Optional[StrictStr] = None,
1842        _headers: Optional[Dict[StrictStr, Any]] = None,
1843        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1844    ) -> GetPipelinesResponse:
1845        """Get all existing pipelines
1846
1847
1848        :param organization: (required)
1849        :type organization: str
1850        :param _request_timeout: timeout setting for this request. If one
1851                                 number provided, it will be total request
1852                                 timeout. It can also be a pair (tuple) of
1853                                 (connection, read) timeouts.
1854        :type _request_timeout: int, tuple(int, int), optional
1855        :param _request_auth: set to override the auth_settings for an a single
1856                              request; this effectively ignores the
1857                              authentication in the spec for a single request.
1858        :type _request_auth: dict, optional
1859        :param _content_type: force content-type for the request.
1860        :type _content_type: str, Optional
1861        :param _headers: set to override the headers for a single
1862                         request; this effectively ignores the headers
1863                         in the spec for a single request.
1864        :type _headers: dict, optional
1865        :param _host_index: set to override the host_index for a single
1866                            request; this effectively ignores the host_index
1867                            in the spec for a single request.
1868        :type _host_index: int, optional
1869        :return: Returns the result object.
1870        """ # noqa: E501
1871
1872        _param = self._get_pipelines_serialize(
1873            organization=organization,
1874            _request_auth=_request_auth,
1875            _content_type=_content_type,
1876            _headers=_headers,
1877            _host_index=_host_index
1878        )
1879
1880        _response_types_map: Dict[str, Optional[str]] = {
1881            '200': "GetPipelinesResponse",
1882            '400': "GetPipelines400Response",
1883            '401': "GetPipelines400Response",
1884            '403': "GetPipelines400Response",
1885            '404': "GetPipelines400Response",
1886            '500': "GetPipelines400Response",
1887        }
1888        response_data = self.api_client.call_api(
1889            *_param,
1890            _request_timeout=_request_timeout
1891        )
1892        response_data.read()
1893        return self.api_client.response_deserialize(
1894            response_data=response_data,
1895            response_types_map=_response_types_map,
1896        ).data

Get all existing pipelines

Parameters

organization: (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

@validate_call

def get_pipelines_with_http_info( self, organization: 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[GetPipelinesResponse]: View Source

1899    @validate_call
1900    def get_pipelines_with_http_info(
1901        self,
1902        organization: StrictStr,
1903        _request_timeout: Union[
1904            None,
1905            Annotated[StrictFloat, Field(gt=0)],
1906            Tuple[
1907                Annotated[StrictFloat, Field(gt=0)],
1908                Annotated[StrictFloat, Field(gt=0)]
1909            ]
1910        ] = None,
1911        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1912        _content_type: Optional[StrictStr] = None,
1913        _headers: Optional[Dict[StrictStr, Any]] = None,
1914        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1915    ) -> ApiResponse[GetPipelinesResponse]:
1916        """Get all existing pipelines
1917
1918
1919        :param organization: (required)
1920        :type organization: str
1921        :param _request_timeout: timeout setting for this request. If one
1922                                 number provided, it will be total request
1923                                 timeout. It can also be a pair (tuple) of
1924                                 (connection, read) timeouts.
1925        :type _request_timeout: int, tuple(int, int), optional
1926        :param _request_auth: set to override the auth_settings for an a single
1927                              request; this effectively ignores the
1928                              authentication in the spec for a single request.
1929        :type _request_auth: dict, optional
1930        :param _content_type: force content-type for the request.
1931        :type _content_type: str, Optional
1932        :param _headers: set to override the headers for a single
1933                         request; this effectively ignores the headers
1934                         in the spec for a single request.
1935        :type _headers: dict, optional
1936        :param _host_index: set to override the host_index for a single
1937                            request; this effectively ignores the host_index
1938                            in the spec for a single request.
1939        :type _host_index: int, optional
1940        :return: Returns the result object.
1941        """ # noqa: E501
1942
1943        _param = self._get_pipelines_serialize(
1944            organization=organization,
1945            _request_auth=_request_auth,
1946            _content_type=_content_type,
1947            _headers=_headers,
1948            _host_index=_host_index
1949        )
1950
1951        _response_types_map: Dict[str, Optional[str]] = {
1952            '200': "GetPipelinesResponse",
1953            '400': "GetPipelines400Response",
1954            '401': "GetPipelines400Response",
1955            '403': "GetPipelines400Response",
1956            '404': "GetPipelines400Response",
1957            '500': "GetPipelines400Response",
1958        }
1959        response_data = self.api_client.call_api(
1960            *_param,
1961            _request_timeout=_request_timeout
1962        )
1963        response_data.read()
1964        return self.api_client.response_deserialize(
1965            response_data=response_data,
1966            response_types_map=_response_types_map,
1967        )

Get all existing pipelines

Parameters

organization: (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

@validate_call

def get_pipelines_without_preload_content( self, organization: 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: View Source

1970    @validate_call
1971    def get_pipelines_without_preload_content(
1972        self,
1973        organization: StrictStr,
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    ) -> RESTResponseType:
1987        """Get all existing pipelines
1988
1989
1990        :param organization: (required)
1991        :type organization: str
1992        :param _request_timeout: timeout setting for this request. If one
1993                                 number provided, it will be total request
1994                                 timeout. It can also be a pair (tuple) of
1995                                 (connection, read) timeouts.
1996        :type _request_timeout: int, tuple(int, int), optional
1997        :param _request_auth: set to override the auth_settings for an a single
1998                              request; this effectively ignores the
1999                              authentication in the spec for a single request.
2000        :type _request_auth: dict, optional
2001        :param _content_type: force content-type for the request.
2002        :type _content_type: str, Optional
2003        :param _headers: set to override the headers for a single
2004                         request; this effectively ignores the headers
2005                         in the spec for a single request.
2006        :type _headers: dict, optional
2007        :param _host_index: set to override the host_index for a single
2008                            request; this effectively ignores the host_index
2009                            in the spec for a single request.
2010        :type _host_index: int, optional
2011        :return: Returns the result object.
2012        """ # noqa: E501
2013
2014        _param = self._get_pipelines_serialize(
2015            organization=organization,
2016            _request_auth=_request_auth,
2017            _content_type=_content_type,
2018            _headers=_headers,
2019            _host_index=_host_index
2020        )
2021
2022        _response_types_map: Dict[str, Optional[str]] = {
2023            '200': "GetPipelinesResponse",
2024            '400': "GetPipelines400Response",
2025            '401': "GetPipelines400Response",
2026            '403': "GetPipelines400Response",
2027            '404': "GetPipelines400Response",
2028            '500': "GetPipelines400Response",
2029        }
2030        response_data = self.api_client.call_api(
2031            *_param,
2032            _request_timeout=_request_timeout
2033        )
2034        return response_data.response

Get all existing pipelines

Parameters

organization: (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

@validate_call

def retrieve_documents( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], retrieve_documents_request: vectorize_client.models.retrieve_documents_request.RetrieveDocumentsRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.retrieve_documents_response.RetrieveDocumentsResponse: View Source

2101    @validate_call
2102    def retrieve_documents(
2103        self,
2104        organization: StrictStr,
2105        pipeline: StrictStr,
2106        retrieve_documents_request: RetrieveDocumentsRequest,
2107        _request_timeout: Union[
2108            None,
2109            Annotated[StrictFloat, Field(gt=0)],
2110            Tuple[
2111                Annotated[StrictFloat, Field(gt=0)],
2112                Annotated[StrictFloat, Field(gt=0)]
2113            ]
2114        ] = None,
2115        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2116        _content_type: Optional[StrictStr] = None,
2117        _headers: Optional[Dict[StrictStr, Any]] = None,
2118        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2119    ) -> RetrieveDocumentsResponse:
2120        """Retrieve documents from a pipeline
2121
2122
2123        :param organization: (required)
2124        :type organization: str
2125        :param pipeline: (required)
2126        :type pipeline: str
2127        :param retrieve_documents_request: (required)
2128        :type retrieve_documents_request: RetrieveDocumentsRequest
2129        :param _request_timeout: timeout setting for this request. If one
2130                                 number provided, it will be total request
2131                                 timeout. It can also be a pair (tuple) of
2132                                 (connection, read) timeouts.
2133        :type _request_timeout: int, tuple(int, int), optional
2134        :param _request_auth: set to override the auth_settings for an a single
2135                              request; this effectively ignores the
2136                              authentication in the spec for a single request.
2137        :type _request_auth: dict, optional
2138        :param _content_type: force content-type for the request.
2139        :type _content_type: str, Optional
2140        :param _headers: set to override the headers for a single
2141                         request; this effectively ignores the headers
2142                         in the spec for a single request.
2143        :type _headers: dict, optional
2144        :param _host_index: set to override the host_index for a single
2145                            request; this effectively ignores the host_index
2146                            in the spec for a single request.
2147        :type _host_index: int, optional
2148        :return: Returns the result object.
2149        """ # noqa: E501
2150
2151        _param = self._retrieve_documents_serialize(
2152            organization=organization,
2153            pipeline=pipeline,
2154            retrieve_documents_request=retrieve_documents_request,
2155            _request_auth=_request_auth,
2156            _content_type=_content_type,
2157            _headers=_headers,
2158            _host_index=_host_index
2159        )
2160
2161        _response_types_map: Dict[str, Optional[str]] = {
2162            '200': "RetrieveDocumentsResponse",
2163            '400': "GetPipelines400Response",
2164            '401': "GetPipelines400Response",
2165            '403': "GetPipelines400Response",
2166            '404': "GetPipelines400Response",
2167            '500': "GetPipelines400Response",
2168        }
2169        response_data = self.api_client.call_api(
2170            *_param,
2171            _request_timeout=_request_timeout
2172        )
2173        response_data.read()
2174        return self.api_client.response_deserialize(
2175            response_data=response_data,
2176            response_types_map=_response_types_map,
2177        ).data

Retrieve documents from a pipeline

Parameters

organization: (required)
pipeline: (required)
retrieve_documents_request: (required)
_request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type: force content-type for the request.
_headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns

@validate_call

def retrieve_documents_with_http_info( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], retrieve_documents_request: vectorize_client.models.retrieve_documents_request.RetrieveDocumentsRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[RetrieveDocumentsResponse]: View Source

2180    @validate_call
2181    def retrieve_documents_with_http_info(
2182        self,
2183        organization: StrictStr,
2184        pipeline: StrictStr,
2185        retrieve_documents_request: RetrieveDocumentsRequest,
2186        _request_timeout: Union[
2187            None,
2188            Annotated[StrictFloat, Field(gt=0)],
2189            Tuple[
2190                Annotated[StrictFloat, Field(gt=0)],
2191                Annotated[StrictFloat, Field(gt=0)]
2192            ]
2193        ] = None,
2194        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2195        _content_type: Optional[StrictStr] = None,
2196        _headers: Optional[Dict[StrictStr, Any]] = None,
2197        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2198    ) -> ApiResponse[RetrieveDocumentsResponse]:
2199        """Retrieve documents from a pipeline
2200
2201
2202        :param organization: (required)
2203        :type organization: str
2204        :param pipeline: (required)
2205        :type pipeline: str
2206        :param retrieve_documents_request: (required)
2207        :type retrieve_documents_request: RetrieveDocumentsRequest
2208        :param _request_timeout: timeout setting for this request. If one
2209                                 number provided, it will be total request
2210                                 timeout. It can also be a pair (tuple) of
2211                                 (connection, read) timeouts.
2212        :type _request_timeout: int, tuple(int, int), optional
2213        :param _request_auth: set to override the auth_settings for an a single
2214                              request; this effectively ignores the
2215                              authentication in the spec for a single request.
2216        :type _request_auth: dict, optional
2217        :param _content_type: force content-type for the request.
2218        :type _content_type: str, Optional
2219        :param _headers: set to override the headers for a single
2220                         request; this effectively ignores the headers
2221                         in the spec for a single request.
2222        :type _headers: dict, optional
2223        :param _host_index: set to override the host_index for a single
2224                            request; this effectively ignores the host_index
2225                            in the spec for a single request.
2226        :type _host_index: int, optional
2227        :return: Returns the result object.
2228        """ # noqa: E501
2229
2230        _param = self._retrieve_documents_serialize(
2231            organization=organization,
2232            pipeline=pipeline,
2233            retrieve_documents_request=retrieve_documents_request,
2234            _request_auth=_request_auth,
2235            _content_type=_content_type,
2236            _headers=_headers,
2237            _host_index=_host_index
2238        )
2239
2240        _response_types_map: Dict[str, Optional[str]] = {
2241            '200': "RetrieveDocumentsResponse",
2242            '400': "GetPipelines400Response",
2243            '401': "GetPipelines400Response",
2244            '403': "GetPipelines400Response",
2245            '404': "GetPipelines400Response",
2246            '500': "GetPipelines400Response",
2247        }
2248        response_data = self.api_client.call_api(
2249            *_param,
2250            _request_timeout=_request_timeout
2251        )
2252        response_data.read()
2253        return self.api_client.response_deserialize(
2254            response_data=response_data,
2255            response_types_map=_response_types_map,
2256        )

Retrieve documents from a pipeline

Parameters

organization: (required)
pipeline: (required)
retrieve_documents_request: (required)
_request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type: force content-type for the request.
_headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns

@validate_call

def retrieve_documents_without_preload_content( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], retrieve_documents_request: vectorize_client.models.retrieve_documents_request.RetrieveDocumentsRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse: View Source

2259    @validate_call
2260    def retrieve_documents_without_preload_content(
2261        self,
2262        organization: StrictStr,
2263        pipeline: StrictStr,
2264        retrieve_documents_request: RetrieveDocumentsRequest,
2265        _request_timeout: Union[
2266            None,
2267            Annotated[StrictFloat, Field(gt=0)],
2268            Tuple[
2269                Annotated[StrictFloat, Field(gt=0)],
2270                Annotated[StrictFloat, Field(gt=0)]
2271            ]
2272        ] = None,
2273        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2274        _content_type: Optional[StrictStr] = None,
2275        _headers: Optional[Dict[StrictStr, Any]] = None,
2276        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2277    ) -> RESTResponseType:
2278        """Retrieve documents from a pipeline
2279
2280
2281        :param organization: (required)
2282        :type organization: str
2283        :param pipeline: (required)
2284        :type pipeline: str
2285        :param retrieve_documents_request: (required)
2286        :type retrieve_documents_request: RetrieveDocumentsRequest
2287        :param _request_timeout: timeout setting for this request. If one
2288                                 number provided, it will be total request
2289                                 timeout. It can also be a pair (tuple) of
2290                                 (connection, read) timeouts.
2291        :type _request_timeout: int, tuple(int, int), optional
2292        :param _request_auth: set to override the auth_settings for an a single
2293                              request; this effectively ignores the
2294                              authentication in the spec for a single request.
2295        :type _request_auth: dict, optional
2296        :param _content_type: force content-type for the request.
2297        :type _content_type: str, Optional
2298        :param _headers: set to override the headers for a single
2299                         request; this effectively ignores the headers
2300                         in the spec for a single request.
2301        :type _headers: dict, optional
2302        :param _host_index: set to override the host_index for a single
2303                            request; this effectively ignores the host_index
2304                            in the spec for a single request.
2305        :type _host_index: int, optional
2306        :return: Returns the result object.
2307        """ # noqa: E501
2308
2309        _param = self._retrieve_documents_serialize(
2310            organization=organization,
2311            pipeline=pipeline,
2312            retrieve_documents_request=retrieve_documents_request,
2313            _request_auth=_request_auth,
2314            _content_type=_content_type,
2315            _headers=_headers,
2316            _host_index=_host_index
2317        )
2318
2319        _response_types_map: Dict[str, Optional[str]] = {
2320            '200': "RetrieveDocumentsResponse",
2321            '400': "GetPipelines400Response",
2322            '401': "GetPipelines400Response",
2323            '403': "GetPipelines400Response",
2324            '404': "GetPipelines400Response",
2325            '500': "GetPipelines400Response",
2326        }
2327        response_data = self.api_client.call_api(
2328            *_param,
2329            _request_timeout=_request_timeout
2330        )
2331        return response_data.response

Retrieve documents from a pipeline

Parameters

organization: (required)
pipeline: (required)
retrieve_documents_request: (required)
_request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type: force content-type for the request.
_headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns

@validate_call

def start_deep_research( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], start_deep_research_request: vectorize_client.models.start_deep_research_request.StartDeepResearchRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.start_deep_research_response.StartDeepResearchResponse: View Source

2417    @validate_call
2418    def start_deep_research(
2419        self,
2420        organization: StrictStr,
2421        pipeline: StrictStr,
2422        start_deep_research_request: StartDeepResearchRequest,
2423        _request_timeout: Union[
2424            None,
2425            Annotated[StrictFloat, Field(gt=0)],
2426            Tuple[
2427                Annotated[StrictFloat, Field(gt=0)],
2428                Annotated[StrictFloat, Field(gt=0)]
2429            ]
2430        ] = None,
2431        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2432        _content_type: Optional[StrictStr] = None,
2433        _headers: Optional[Dict[StrictStr, Any]] = None,
2434        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2435    ) -> StartDeepResearchResponse:
2436        """Start a deep research
2437
2438
2439        :param organization: (required)
2440        :type organization: str
2441        :param pipeline: (required)
2442        :type pipeline: str
2443        :param start_deep_research_request: (required)
2444        :type start_deep_research_request: StartDeepResearchRequest
2445        :param _request_timeout: timeout setting for this request. If one
2446                                 number provided, it will be total request
2447                                 timeout. It can also be a pair (tuple) of
2448                                 (connection, read) timeouts.
2449        :type _request_timeout: int, tuple(int, int), optional
2450        :param _request_auth: set to override the auth_settings for an a single
2451                              request; this effectively ignores the
2452                              authentication in the spec for a single request.
2453        :type _request_auth: dict, optional
2454        :param _content_type: force content-type for the request.
2455        :type _content_type: str, Optional
2456        :param _headers: set to override the headers for a single
2457                         request; this effectively ignores the headers
2458                         in the spec for a single request.
2459        :type _headers: dict, optional
2460        :param _host_index: set to override the host_index for a single
2461                            request; this effectively ignores the host_index
2462                            in the spec for a single request.
2463        :type _host_index: int, optional
2464        :return: Returns the result object.
2465        """ # noqa: E501
2466
2467        _param = self._start_deep_research_serialize(
2468            organization=organization,
2469            pipeline=pipeline,
2470            start_deep_research_request=start_deep_research_request,
2471            _request_auth=_request_auth,
2472            _content_type=_content_type,
2473            _headers=_headers,
2474            _host_index=_host_index
2475        )
2476
2477        _response_types_map: Dict[str, Optional[str]] = {
2478            '200': "StartDeepResearchResponse",
2479            '400': "GetPipelines400Response",
2480            '401': "GetPipelines400Response",
2481            '403': "GetPipelines400Response",
2482            '404': "GetPipelines400Response",
2483            '500': "GetPipelines400Response",
2484        }
2485        response_data = self.api_client.call_api(
2486            *_param,
2487            _request_timeout=_request_timeout
2488        )
2489        response_data.read()
2490        return self.api_client.response_deserialize(
2491            response_data=response_data,
2492            response_types_map=_response_types_map,
2493        ).data

Start a deep research

Parameters

organization: (required)
pipeline: (required)
start_deep_research_request: (required)
_request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type: force content-type for the request.
_headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns

@validate_call

def start_deep_research_with_http_info( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], start_deep_research_request: vectorize_client.models.start_deep_research_request.StartDeepResearchRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[StartDeepResearchResponse]: View Source

2496    @validate_call
2497    def start_deep_research_with_http_info(
2498        self,
2499        organization: StrictStr,
2500        pipeline: StrictStr,
2501        start_deep_research_request: StartDeepResearchRequest,
2502        _request_timeout: Union[
2503            None,
2504            Annotated[StrictFloat, Field(gt=0)],
2505            Tuple[
2506                Annotated[StrictFloat, Field(gt=0)],
2507                Annotated[StrictFloat, Field(gt=0)]
2508            ]
2509        ] = None,
2510        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2511        _content_type: Optional[StrictStr] = None,
2512        _headers: Optional[Dict[StrictStr, Any]] = None,
2513        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2514    ) -> ApiResponse[StartDeepResearchResponse]:
2515        """Start a deep research
2516
2517
2518        :param organization: (required)
2519        :type organization: str
2520        :param pipeline: (required)
2521        :type pipeline: str
2522        :param start_deep_research_request: (required)
2523        :type start_deep_research_request: StartDeepResearchRequest
2524        :param _request_timeout: timeout setting for this request. If one
2525                                 number provided, it will be total request
2526                                 timeout. It can also be a pair (tuple) of
2527                                 (connection, read) timeouts.
2528        :type _request_timeout: int, tuple(int, int), optional
2529        :param _request_auth: set to override the auth_settings for an a single
2530                              request; this effectively ignores the
2531                              authentication in the spec for a single request.
2532        :type _request_auth: dict, optional
2533        :param _content_type: force content-type for the request.
2534        :type _content_type: str, Optional
2535        :param _headers: set to override the headers for a single
2536                         request; this effectively ignores the headers
2537                         in the spec for a single request.
2538        :type _headers: dict, optional
2539        :param _host_index: set to override the host_index for a single
2540                            request; this effectively ignores the host_index
2541                            in the spec for a single request.
2542        :type _host_index: int, optional
2543        :return: Returns the result object.
2544        """ # noqa: E501
2545
2546        _param = self._start_deep_research_serialize(
2547            organization=organization,
2548            pipeline=pipeline,
2549            start_deep_research_request=start_deep_research_request,
2550            _request_auth=_request_auth,
2551            _content_type=_content_type,
2552            _headers=_headers,
2553            _host_index=_host_index
2554        )
2555
2556        _response_types_map: Dict[str, Optional[str]] = {
2557            '200': "StartDeepResearchResponse",
2558            '400': "GetPipelines400Response",
2559            '401': "GetPipelines400Response",
2560            '403': "GetPipelines400Response",
2561            '404': "GetPipelines400Response",
2562            '500': "GetPipelines400Response",
2563        }
2564        response_data = self.api_client.call_api(
2565            *_param,
2566            _request_timeout=_request_timeout
2567        )
2568        response_data.read()
2569        return self.api_client.response_deserialize(
2570            response_data=response_data,
2571            response_types_map=_response_types_map,
2572        )

Start a deep research

Parameters

organization: (required)
pipeline: (required)
start_deep_research_request: (required)
_request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type: force content-type for the request.
_headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns

@validate_call

def start_deep_research_without_preload_content( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], start_deep_research_request: vectorize_client.models.start_deep_research_request.StartDeepResearchRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> urllib3.response.HTTPResponse: View Source

2575    @validate_call
2576    def start_deep_research_without_preload_content(
2577        self,
2578        organization: StrictStr,
2579        pipeline: StrictStr,
2580        start_deep_research_request: StartDeepResearchRequest,
2581        _request_timeout: Union[
2582            None,
2583            Annotated[StrictFloat, Field(gt=0)],
2584            Tuple[
2585                Annotated[StrictFloat, Field(gt=0)],
2586                Annotated[StrictFloat, Field(gt=0)]
2587            ]
2588        ] = None,
2589        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2590        _content_type: Optional[StrictStr] = None,
2591        _headers: Optional[Dict[StrictStr, Any]] = None,
2592        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2593    ) -> RESTResponseType:
2594        """Start a deep research
2595
2596
2597        :param organization: (required)
2598        :type organization: str
2599        :param pipeline: (required)
2600        :type pipeline: str
2601        :param start_deep_research_request: (required)
2602        :type start_deep_research_request: StartDeepResearchRequest
2603        :param _request_timeout: timeout setting for this request. If one
2604                                 number provided, it will be total request
2605                                 timeout. It can also be a pair (tuple) of
2606                                 (connection, read) timeouts.
2607        :type _request_timeout: int, tuple(int, int), optional
2608        :param _request_auth: set to override the auth_settings for an a single
2609                              request; this effectively ignores the
2610                              authentication in the spec for a single request.
2611        :type _request_auth: dict, optional
2612        :param _content_type: force content-type for the request.
2613        :type _content_type: str, Optional
2614        :param _headers: set to override the headers for a single
2615                         request; this effectively ignores the headers
2616                         in the spec for a single request.
2617        :type _headers: dict, optional
2618        :param _host_index: set to override the host_index for a single
2619                            request; this effectively ignores the host_index
2620                            in the spec for a single request.
2621        :type _host_index: int, optional
2622        :return: Returns the result object.
2623        """ # noqa: E501
2624
2625        _param = self._start_deep_research_serialize(
2626            organization=organization,
2627            pipeline=pipeline,
2628            start_deep_research_request=start_deep_research_request,
2629            _request_auth=_request_auth,
2630            _content_type=_content_type,
2631            _headers=_headers,
2632            _host_index=_host_index
2633        )
2634
2635        _response_types_map: Dict[str, Optional[str]] = {
2636            '200': "StartDeepResearchResponse",
2637            '400': "GetPipelines400Response",
2638            '401': "GetPipelines400Response",
2639            '403': "GetPipelines400Response",
2640            '404': "GetPipelines400Response",
2641            '500': "GetPipelines400Response",
2642        }
2643        response_data = self.api_client.call_api(
2644            *_param,
2645            _request_timeout=_request_timeout
2646        )
2647        return response_data.response

Start a deep research

Parameters

organization: (required)
pipeline: (required)
start_deep_research_request: (required)
_request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type: force content-type for the request.
_headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns

@validate_call

def start_pipeline( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.start_pipeline_response.StartPipelineResponse: View Source

2733    @validate_call
2734    def start_pipeline(
2735        self,
2736        organization: StrictStr,
2737        pipeline: StrictStr,
2738        _request_timeout: Union[
2739            None,
2740            Annotated[StrictFloat, Field(gt=0)],
2741            Tuple[
2742                Annotated[StrictFloat, Field(gt=0)],
2743                Annotated[StrictFloat, Field(gt=0)]
2744            ]
2745        ] = None,
2746        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2747        _content_type: Optional[StrictStr] = None,
2748        _headers: Optional[Dict[StrictStr, Any]] = None,
2749        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2750    ) -> StartPipelineResponse:
2751        """Start a pipeline
2752
2753
2754        :param organization: (required)
2755        :type organization: str
2756        :param pipeline: (required)
2757        :type pipeline: str
2758        :param _request_timeout: timeout setting for this request. If one
2759                                 number provided, it will be total request
2760                                 timeout. It can also be a pair (tuple) of
2761                                 (connection, read) timeouts.
2762        :type _request_timeout: int, tuple(int, int), optional
2763        :param _request_auth: set to override the auth_settings for an a single
2764                              request; this effectively ignores the
2765                              authentication in the spec for a single request.
2766        :type _request_auth: dict, optional
2767        :param _content_type: force content-type for the request.
2768        :type _content_type: str, Optional
2769        :param _headers: set to override the headers for a single
2770                         request; this effectively ignores the headers
2771                         in the spec for a single request.
2772        :type _headers: dict, optional
2773        :param _host_index: set to override the host_index for a single
2774                            request; this effectively ignores the host_index
2775                            in the spec for a single request.
2776        :type _host_index: int, optional
2777        :return: Returns the result object.
2778        """ # noqa: E501
2779
2780        _param = self._start_pipeline_serialize(
2781            organization=organization,
2782            pipeline=pipeline,
2783            _request_auth=_request_auth,
2784            _content_type=_content_type,
2785            _headers=_headers,
2786            _host_index=_host_index
2787        )
2788
2789        _response_types_map: Dict[str, Optional[str]] = {
2790            '200': "StartPipelineResponse",
2791            '400': "GetPipelines400Response",
2792            '401': "GetPipelines400Response",
2793            '403': "GetPipelines400Response",
2794            '404': "GetPipelines400Response",
2795            '500': "GetPipelines400Response",
2796        }
2797        response_data = self.api_client.call_api(
2798            *_param,
2799            _request_timeout=_request_timeout
2800        )
2801        response_data.read()
2802        return self.api_client.response_deserialize(
2803            response_data=response_data,
2804            response_types_map=_response_types_map,
2805        ).data

Start a pipeline

Parameters

organization: (required)
pipeline: (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

@validate_call

def start_pipeline_with_http_info( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[StartPipelineResponse]: View Source

2808    @validate_call
2809    def start_pipeline_with_http_info(
2810        self,
2811        organization: StrictStr,
2812        pipeline: StrictStr,
2813        _request_timeout: Union[
2814            None,
2815            Annotated[StrictFloat, Field(gt=0)],
2816            Tuple[
2817                Annotated[StrictFloat, Field(gt=0)],
2818                Annotated[StrictFloat, Field(gt=0)]
2819            ]
2820        ] = None,
2821        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2822        _content_type: Optional[StrictStr] = None,
2823        _headers: Optional[Dict[StrictStr, Any]] = None,
2824        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2825    ) -> ApiResponse[StartPipelineResponse]:
2826        """Start a pipeline
2827
2828
2829        :param organization: (required)
2830        :type organization: str
2831        :param pipeline: (required)
2832        :type pipeline: str
2833        :param _request_timeout: timeout setting for this request. If one
2834                                 number provided, it will be total request
2835                                 timeout. It can also be a pair (tuple) of
2836                                 (connection, read) timeouts.
2837        :type _request_timeout: int, tuple(int, int), optional
2838        :param _request_auth: set to override the auth_settings for an a single
2839                              request; this effectively ignores the
2840                              authentication in the spec for a single request.
2841        :type _request_auth: dict, optional
2842        :param _content_type: force content-type for the request.
2843        :type _content_type: str, Optional
2844        :param _headers: set to override the headers for a single
2845                         request; this effectively ignores the headers
2846                         in the spec for a single request.
2847        :type _headers: dict, optional
2848        :param _host_index: set to override the host_index for a single
2849                            request; this effectively ignores the host_index
2850                            in the spec for a single request.
2851        :type _host_index: int, optional
2852        :return: Returns the result object.
2853        """ # noqa: E501
2854
2855        _param = self._start_pipeline_serialize(
2856            organization=organization,
2857            pipeline=pipeline,
2858            _request_auth=_request_auth,
2859            _content_type=_content_type,
2860            _headers=_headers,
2861            _host_index=_host_index
2862        )
2863
2864        _response_types_map: Dict[str, Optional[str]] = {
2865            '200': "StartPipelineResponse",
2866            '400': "GetPipelines400Response",
2867            '401': "GetPipelines400Response",
2868            '403': "GetPipelines400Response",
2869            '404': "GetPipelines400Response",
2870            '500': "GetPipelines400Response",
2871        }
2872        response_data = self.api_client.call_api(
2873            *_param,
2874            _request_timeout=_request_timeout
2875        )
2876        response_data.read()
2877        return self.api_client.response_deserialize(
2878            response_data=response_data,
2879            response_types_map=_response_types_map,
2880        )

Start a pipeline

Parameters

organization: (required)
pipeline: (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

@validate_call

def start_pipeline_without_preload_content( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: 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: View Source

2883    @validate_call
2884    def start_pipeline_without_preload_content(
2885        self,
2886        organization: StrictStr,
2887        pipeline: StrictStr,
2888        _request_timeout: Union[
2889            None,
2890            Annotated[StrictFloat, Field(gt=0)],
2891            Tuple[
2892                Annotated[StrictFloat, Field(gt=0)],
2893                Annotated[StrictFloat, Field(gt=0)]
2894            ]
2895        ] = None,
2896        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2897        _content_type: Optional[StrictStr] = None,
2898        _headers: Optional[Dict[StrictStr, Any]] = None,
2899        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2900    ) -> RESTResponseType:
2901        """Start a pipeline
2902
2903
2904        :param organization: (required)
2905        :type organization: str
2906        :param pipeline: (required)
2907        :type pipeline: str
2908        :param _request_timeout: timeout setting for this request. If one
2909                                 number provided, it will be total request
2910                                 timeout. It can also be a pair (tuple) of
2911                                 (connection, read) timeouts.
2912        :type _request_timeout: int, tuple(int, int), optional
2913        :param _request_auth: set to override the auth_settings for an a single
2914                              request; this effectively ignores the
2915                              authentication in the spec for a single request.
2916        :type _request_auth: dict, optional
2917        :param _content_type: force content-type for the request.
2918        :type _content_type: str, Optional
2919        :param _headers: set to override the headers for a single
2920                         request; this effectively ignores the headers
2921                         in the spec for a single request.
2922        :type _headers: dict, optional
2923        :param _host_index: set to override the host_index for a single
2924                            request; this effectively ignores the host_index
2925                            in the spec for a single request.
2926        :type _host_index: int, optional
2927        :return: Returns the result object.
2928        """ # noqa: E501
2929
2930        _param = self._start_pipeline_serialize(
2931            organization=organization,
2932            pipeline=pipeline,
2933            _request_auth=_request_auth,
2934            _content_type=_content_type,
2935            _headers=_headers,
2936            _host_index=_host_index
2937        )
2938
2939        _response_types_map: Dict[str, Optional[str]] = {
2940            '200': "StartPipelineResponse",
2941            '400': "GetPipelines400Response",
2942            '401': "GetPipelines400Response",
2943            '403': "GetPipelines400Response",
2944            '404': "GetPipelines400Response",
2945            '500': "GetPipelines400Response",
2946        }
2947        response_data = self.api_client.call_api(
2948            *_param,
2949            _request_timeout=_request_timeout
2950        )
2951        return response_data.response

Start a pipeline

Parameters

organization: (required)
pipeline: (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

@validate_call

def stop_pipeline( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.models.stop_pipeline_response.StopPipelineResponse: View Source

3021    @validate_call
3022    def stop_pipeline(
3023        self,
3024        organization: StrictStr,
3025        pipeline: StrictStr,
3026        _request_timeout: Union[
3027            None,
3028            Annotated[StrictFloat, Field(gt=0)],
3029            Tuple[
3030                Annotated[StrictFloat, Field(gt=0)],
3031                Annotated[StrictFloat, Field(gt=0)]
3032            ]
3033        ] = None,
3034        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3035        _content_type: Optional[StrictStr] = None,
3036        _headers: Optional[Dict[StrictStr, Any]] = None,
3037        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3038    ) -> StopPipelineResponse:
3039        """Stop a pipeline
3040
3041
3042        :param organization: (required)
3043        :type organization: str
3044        :param pipeline: (required)
3045        :type pipeline: str
3046        :param _request_timeout: timeout setting for this request. If one
3047                                 number provided, it will be total request
3048                                 timeout. It can also be a pair (tuple) of
3049                                 (connection, read) timeouts.
3050        :type _request_timeout: int, tuple(int, int), optional
3051        :param _request_auth: set to override the auth_settings for an a single
3052                              request; this effectively ignores the
3053                              authentication in the spec for a single request.
3054        :type _request_auth: dict, optional
3055        :param _content_type: force content-type for the request.
3056        :type _content_type: str, Optional
3057        :param _headers: set to override the headers for a single
3058                         request; this effectively ignores the headers
3059                         in the spec for a single request.
3060        :type _headers: dict, optional
3061        :param _host_index: set to override the host_index for a single
3062                            request; this effectively ignores the host_index
3063                            in the spec for a single request.
3064        :type _host_index: int, optional
3065        :return: Returns the result object.
3066        """ # noqa: E501
3067
3068        _param = self._stop_pipeline_serialize(
3069            organization=organization,
3070            pipeline=pipeline,
3071            _request_auth=_request_auth,
3072            _content_type=_content_type,
3073            _headers=_headers,
3074            _host_index=_host_index
3075        )
3076
3077        _response_types_map: Dict[str, Optional[str]] = {
3078            '200': "StopPipelineResponse",
3079            '400': "GetPipelines400Response",
3080            '401': "GetPipelines400Response",
3081            '403': "GetPipelines400Response",
3082            '404': "GetPipelines400Response",
3083            '500': "GetPipelines400Response",
3084        }
3085        response_data = self.api_client.call_api(
3086            *_param,
3087            _request_timeout=_request_timeout
3088        )
3089        response_data.read()
3090        return self.api_client.response_deserialize(
3091            response_data=response_data,
3092            response_types_map=_response_types_map,
3093        ).data

Stop a pipeline

Parameters

organization: (required)
pipeline: (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

@validate_call

def stop_pipeline_with_http_info( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: typing.Annotated[str, Strict(strict=True)], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> vectorize_client.api_response.ApiResponse[StopPipelineResponse]: View Source

3096    @validate_call
3097    def stop_pipeline_with_http_info(
3098        self,
3099        organization: StrictStr,
3100        pipeline: StrictStr,
3101        _request_timeout: Union[
3102            None,
3103            Annotated[StrictFloat, Field(gt=0)],
3104            Tuple[
3105                Annotated[StrictFloat, Field(gt=0)],
3106                Annotated[StrictFloat, Field(gt=0)]
3107            ]
3108        ] = None,
3109        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3110        _content_type: Optional[StrictStr] = None,
3111        _headers: Optional[Dict[StrictStr, Any]] = None,
3112        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3113    ) -> ApiResponse[StopPipelineResponse]:
3114        """Stop a pipeline
3115
3116
3117        :param organization: (required)
3118        :type organization: str
3119        :param pipeline: (required)
3120        :type pipeline: str
3121        :param _request_timeout: timeout setting for this request. If one
3122                                 number provided, it will be total request
3123                                 timeout. It can also be a pair (tuple) of
3124                                 (connection, read) timeouts.
3125        :type _request_timeout: int, tuple(int, int), optional
3126        :param _request_auth: set to override the auth_settings for an a single
3127                              request; this effectively ignores the
3128                              authentication in the spec for a single request.
3129        :type _request_auth: dict, optional
3130        :param _content_type: force content-type for the request.
3131        :type _content_type: str, Optional
3132        :param _headers: set to override the headers for a single
3133                         request; this effectively ignores the headers
3134                         in the spec for a single request.
3135        :type _headers: dict, optional
3136        :param _host_index: set to override the host_index for a single
3137                            request; this effectively ignores the host_index
3138                            in the spec for a single request.
3139        :type _host_index: int, optional
3140        :return: Returns the result object.
3141        """ # noqa: E501
3142
3143        _param = self._stop_pipeline_serialize(
3144            organization=organization,
3145            pipeline=pipeline,
3146            _request_auth=_request_auth,
3147            _content_type=_content_type,
3148            _headers=_headers,
3149            _host_index=_host_index
3150        )
3151
3152        _response_types_map: Dict[str, Optional[str]] = {
3153            '200': "StopPipelineResponse",
3154            '400': "GetPipelines400Response",
3155            '401': "GetPipelines400Response",
3156            '403': "GetPipelines400Response",
3157            '404': "GetPipelines400Response",
3158            '500': "GetPipelines400Response",
3159        }
3160        response_data = self.api_client.call_api(
3161            *_param,
3162            _request_timeout=_request_timeout
3163        )
3164        response_data.read()
3165        return self.api_client.response_deserialize(
3166            response_data=response_data,
3167            response_types_map=_response_types_map,
3168        )

Stop a pipeline

Parameters

organization: (required)
pipeline: (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

@validate_call

def stop_pipeline_without_preload_content( self, organization: typing.Annotated[str, Strict(strict=True)], pipeline: 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: View Source

3171    @validate_call
3172    def stop_pipeline_without_preload_content(
3173        self,
3174        organization: StrictStr,
3175        pipeline: StrictStr,
3176        _request_timeout: Union[
3177            None,
3178            Annotated[StrictFloat, Field(gt=0)],
3179            Tuple[
3180                Annotated[StrictFloat, Field(gt=0)],
3181                Annotated[StrictFloat, Field(gt=0)]
3182            ]
3183        ] = None,
3184        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3185        _content_type: Optional[StrictStr] = None,
3186        _headers: Optional[Dict[StrictStr, Any]] = None,
3187        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3188    ) -> RESTResponseType:
3189        """Stop a pipeline
3190
3191
3192        :param organization: (required)
3193        :type organization: str
3194        :param pipeline: (required)
3195        :type pipeline: str
3196        :param _request_timeout: timeout setting for this request. If one
3197                                 number provided, it will be total request
3198                                 timeout. It can also be a pair (tuple) of
3199                                 (connection, read) timeouts.
3200        :type _request_timeout: int, tuple(int, int), optional
3201        :param _request_auth: set to override the auth_settings for an a single
3202                              request; this effectively ignores the
3203                              authentication in the spec for a single request.
3204        :type _request_auth: dict, optional
3205        :param _content_type: force content-type for the request.
3206        :type _content_type: str, Optional
3207        :param _headers: set to override the headers for a single
3208                         request; this effectively ignores the headers
3209                         in the spec for a single request.
3210        :type _headers: dict, optional
3211        :param _host_index: set to override the host_index for a single
3212                            request; this effectively ignores the host_index
3213                            in the spec for a single request.
3214        :type _host_index: int, optional
3215        :return: Returns the result object.
3216        """ # noqa: E501
3217
3218        _param = self._stop_pipeline_serialize(
3219            organization=organization,
3220            pipeline=pipeline,
3221            _request_auth=_request_auth,
3222            _content_type=_content_type,
3223            _headers=_headers,
3224            _host_index=_host_index
3225        )
3226
3227        _response_types_map: Dict[str, Optional[str]] = {
3228            '200': "StopPipelineResponse",
3229            '400': "GetPipelines400Response",
3230            '401': "GetPipelines400Response",
3231            '403': "GetPipelines400Response",
3232            '404': "GetPipelines400Response",
3233            '500': "GetPipelines400Response",
3234        }
3235        response_data = self.api_client.call_api(
3236            *_param,
3237            _request_timeout=_request_timeout
3238        )
3239        return response_data.response

Stop a pipeline

Parameters

organization: (required)
pipeline: (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