From def9413e7b6fb5ed395cd7e78b4f848de44042bf Mon Sep 17 00:00:00 2001 From: Silas Smith <163026730+ssmith-pc@users.noreply.github.com> Date: Thu, 21 Aug 2025 17:38:01 -0700 Subject: [PATCH 1/4] initial codegen (#519) ## Problem Describe the purpose of this change. What problem is being solved and why? ## Solution Describe the approach you took. Link to any relevant bugs, issues, docs, or other resources. ## Type of Change - [ ] Bug fix (non-breaking change which fixes an issue) - [ ] New feature (non-breaking change which adds functionality) - [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) - [ ] This change requires a documentation update - [ ] Infrastructure change (CI configs, etc) - [ ] Non-code change (docs, etc) - [ ] None of the above: (explain here) ## Test Plan Describe specific steps for validating this change. --- .../openapi/ckb_knowledge_data/__init__.py | 30 + .../ckb_knowledge_data/api/__init__.py | 3 + .../api/document_operations_api.py | 598 ++++++++++++++++++ .../ckb_knowledge_data/apis/__init__.py | 18 + .../ckb_knowledge_data/model/__init__.py | 5 + .../model/delete_document_response.py | 304 +++++++++ .../ckb_knowledge_data/model/document.py | 276 ++++++++ .../model/document_for_upsert.py | 270 ++++++++ .../ckb_knowledge_data/model/document_list.py | 300 +++++++++ .../model/get_document_response.py | 308 +++++++++ .../model/list_document_response.py | 316 +++++++++ .../ckb_knowledge_data/model/lsn_status.py | 280 ++++++++ .../model/pagination_response.py | 276 ++++++++ .../model/upsert_document_response.py | 296 +++++++++ .../openapi/ckb_knowledge_data/model/usage.py | 282 +++++++++ .../ckb_knowledge_data/models/__init__.py | 27 + pinecone/openapi_support/api_version.py | 4 +- 17 files changed, 3591 insertions(+), 2 deletions(-) create mode 100644 pinecone/core/openapi/ckb_knowledge_data/__init__.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/api/__init__.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/api/document_operations_api.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/apis/__init__.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/model/__init__.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/model/delete_document_response.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/model/document.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/model/document_for_upsert.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/model/document_list.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/model/get_document_response.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/model/list_document_response.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/model/lsn_status.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/model/pagination_response.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/model/upsert_document_response.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/model/usage.py create mode 100644 pinecone/core/openapi/ckb_knowledge_data/models/__init__.py diff --git a/pinecone/core/openapi/ckb_knowledge_data/__init__.py b/pinecone/core/openapi/ckb_knowledge_data/__init__.py new file mode 100644 index 00000000..b00bb6f5 --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/__init__.py @@ -0,0 +1,30 @@ +# flake8: noqa + +""" +Pinecone Knowledge Base Data Plane API + +Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +__version__ = "1.0.0" + +# import ApiClient +from pinecone.openapi_support.api_client import ApiClient + +# import Configuration +from pinecone.config.openapi_configuration import Configuration + +# import exceptions +from pinecone.openapi_support.exceptions import PineconeException +from pinecone.openapi_support.exceptions import PineconeApiAttributeError +from pinecone.openapi_support.exceptions import PineconeApiTypeError +from pinecone.openapi_support.exceptions import PineconeApiValueError +from pinecone.openapi_support.exceptions import PineconeApiKeyError +from pinecone.openapi_support.exceptions import PineconeApiException + +API_VERSION = "unstable" diff --git a/pinecone/core/openapi/ckb_knowledge_data/api/__init__.py b/pinecone/core/openapi/ckb_knowledge_data/api/__init__.py new file mode 100644 index 00000000..094e63d1 --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/api/__init__.py @@ -0,0 +1,3 @@ +# do not import all apis into this module because that uses a lot of memory and stack frames +# if you need the ability to import all apis from one package, import them with +# from pinecone.core.openapi.ckb_knowledge_data.apis import DocumentOperationsApi diff --git a/pinecone/core/openapi/ckb_knowledge_data/api/document_operations_api.py b/pinecone/core/openapi/ckb_knowledge_data/api/document_operations_api.py new file mode 100644 index 00000000..9985bccd --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/api/document_operations_api.py @@ -0,0 +1,598 @@ +""" +Pinecone Knowledge Base Data Plane API + +Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support import ApiClient, AsyncioApiClient +from pinecone.openapi_support.endpoint_utils import ( + ExtraOpenApiKwargsTypedDict, + KwargsWithOpenApiKwargDefaultsTypedDict, +) +from pinecone.openapi_support.endpoint import Endpoint as _Endpoint, ExtraOpenApiKwargsTypedDict +from pinecone.openapi_support.asyncio_endpoint import AsyncioEndpoint as _AsyncioEndpoint +from pinecone.openapi_support.model_utils import ( # noqa: F401 + date, + datetime, + file_type, + none_type, + validate_and_convert_types, +) +from pinecone.core.openapi.ckb_knowledge_data.model.delete_document_response import ( + DeleteDocumentResponse, +) +from pinecone.core.openapi.ckb_knowledge_data.model.document_for_upsert import DocumentForUpsert +from pinecone.core.openapi.ckb_knowledge_data.model.get_document_response import GetDocumentResponse +from pinecone.core.openapi.ckb_knowledge_data.model.list_document_response import ( + ListDocumentResponse, +) +from pinecone.core.openapi.ckb_knowledge_data.model.upsert_document_response import ( + UpsertDocumentResponse, +) + + +class DocumentOperationsApi: + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + """ + + def __init__(self, api_client=None) -> None: + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def __delete_document(self, namespace, document_id, **kwargs: ExtraOpenApiKwargsTypedDict): + """Delete a document from the given namespace # noqa: E501 + + Deletes a document from the specified namespace. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + + >>> thread = api.delete_document(namespace, document_id, async_req=True) + >>> result = thread.get() + + Args: + namespace (str): Namespace to fetch document from. + document_id (str): Document ID to fetch. + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + async_req (bool): execute request asynchronously + + Returns: + DeleteDocumentResponse + If the method is called asynchronously, returns the request + thread. + """ + kwargs = self._process_openapi_kwargs(kwargs) + kwargs["namespace"] = namespace + kwargs["document_id"] = document_id + return self.call_with_http_info(**kwargs) + + self.delete_document = _Endpoint( + settings={ + "response_type": (DeleteDocumentResponse,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/namespaces/{namespace}/documents/{document_id}", + "operation_id": "delete_document", + "http_method": "DELETE", + "servers": None, + }, + params_map={ + "all": ["namespace", "document_id"], + "required": ["namespace", "document_id"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"namespace": (str,), "document_id": (str,)}, + "attribute_map": {"namespace": "namespace", "document_id": "document_id"}, + "location_map": {"namespace": "path", "document_id": "path"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": []}, + api_client=api_client, + callable=__delete_document, + ) + + def __get_document(self, namespace, document_id, **kwargs: ExtraOpenApiKwargsTypedDict): + """Get a document from the given namespace # noqa: E501 + + Retrieves a document from the specified namespace. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + + >>> thread = api.get_document(namespace, document_id, async_req=True) + >>> result = thread.get() + + Args: + namespace (str): Namespace to fetch document from. + document_id (str): Document ID to fetch. + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + async_req (bool): execute request asynchronously + + Returns: + GetDocumentResponse + If the method is called asynchronously, returns the request + thread. + """ + kwargs = self._process_openapi_kwargs(kwargs) + kwargs["namespace"] = namespace + kwargs["document_id"] = document_id + return self.call_with_http_info(**kwargs) + + self.get_document = _Endpoint( + settings={ + "response_type": (GetDocumentResponse,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/namespaces/{namespace}/documents/{document_id}", + "operation_id": "get_document", + "http_method": "GET", + "servers": None, + }, + params_map={ + "all": ["namespace", "document_id"], + "required": ["namespace", "document_id"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"namespace": (str,), "document_id": (str,)}, + "attribute_map": {"namespace": "namespace", "document_id": "document_id"}, + "location_map": {"namespace": "path", "document_id": "path"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": []}, + api_client=api_client, + callable=__get_document, + ) + + def __list_documents(self, namespace, **kwargs: ExtraOpenApiKwargsTypedDict): + """List documents from the given namespace # noqa: E501 + + Lists documents from the specified namespace. (Paginated) # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + + >>> thread = api.list_documents(namespace, async_req=True) + >>> result = thread.get() + + Args: + namespace (str): Namespace to fetch documents from. + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + async_req (bool): execute request asynchronously + + Returns: + ListDocumentResponse + If the method is called asynchronously, returns the request + thread. + """ + kwargs = self._process_openapi_kwargs(kwargs) + kwargs["namespace"] = namespace + return self.call_with_http_info(**kwargs) + + self.list_documents = _Endpoint( + settings={ + "response_type": (ListDocumentResponse,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/namespaces/{namespace}/documents", + "operation_id": "list_documents", + "http_method": "GET", + "servers": None, + }, + params_map={ + "all": ["namespace"], + "required": ["namespace"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"namespace": (str,)}, + "attribute_map": {"namespace": "namespace"}, + "location_map": {"namespace": "path"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": []}, + api_client=api_client, + callable=__list_documents, + ) + + def __upsert_document( + self, namespace, document_for_upsert, **kwargs: ExtraOpenApiKwargsTypedDict + ): + """Create or update a document in the given namespace # noqa: E501 + + Upserts a document into the specified namespace. The request body may contain any valid JSON document that conforms to the schema. Optionally, an `_id` field can be provided to use as the document's identifier; if omitted, the system will assign one. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + + >>> thread = api.upsert_document(namespace, document_for_upsert, async_req=True) + >>> result = thread.get() + + Args: + namespace (str): Namespace where the document will be stored. + document_for_upsert (DocumentForUpsert): + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + async_req (bool): execute request asynchronously + + Returns: + UpsertDocumentResponse + If the method is called asynchronously, returns the request + thread. + """ + kwargs = self._process_openapi_kwargs(kwargs) + kwargs["namespace"] = namespace + kwargs["document_for_upsert"] = document_for_upsert + return self.call_with_http_info(**kwargs) + + self.upsert_document = _Endpoint( + settings={ + "response_type": (UpsertDocumentResponse,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/namespaces/{namespace}/documents/upsert", + "operation_id": "upsert_document", + "http_method": "POST", + "servers": None, + }, + params_map={ + "all": ["namespace", "document_for_upsert"], + "required": ["namespace", "document_for_upsert"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"namespace": (str,), "document_for_upsert": (DocumentForUpsert,)}, + "attribute_map": {"namespace": "namespace"}, + "location_map": {"namespace": "path", "document_for_upsert": "body"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": ["application/json"]}, + api_client=api_client, + callable=__upsert_document, + ) + + +class AsyncioDocumentOperationsApi: + """NOTE: This class is @generated using OpenAPI + + Do not edit the class manually. + """ + + def __init__(self, api_client=None) -> None: + if api_client is None: + api_client = AsyncioApiClient() + self.api_client = api_client + + async def __delete_document(self, namespace, document_id, **kwargs): + """Delete a document from the given namespace # noqa: E501 + + Deletes a document from the specified namespace. # noqa: E501 + + + Args: + namespace (str): Namespace to fetch document from. + document_id (str): Document ID to fetch. + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + + Returns: + DeleteDocumentResponse + """ + self._process_openapi_kwargs(kwargs) + kwargs["namespace"] = namespace + kwargs["document_id"] = document_id + return await self.call_with_http_info(**kwargs) + + self.delete_document = _AsyncioEndpoint( + settings={ + "response_type": (DeleteDocumentResponse,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/namespaces/{namespace}/documents/{document_id}", + "operation_id": "delete_document", + "http_method": "DELETE", + "servers": None, + }, + params_map={ + "all": ["namespace", "document_id"], + "required": ["namespace", "document_id"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"namespace": (str,), "document_id": (str,)}, + "attribute_map": {"namespace": "namespace", "document_id": "document_id"}, + "location_map": {"namespace": "path", "document_id": "path"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": []}, + api_client=api_client, + callable=__delete_document, + ) + + async def __get_document(self, namespace, document_id, **kwargs): + """Get a document from the given namespace # noqa: E501 + + Retrieves a document from the specified namespace. # noqa: E501 + + + Args: + namespace (str): Namespace to fetch document from. + document_id (str): Document ID to fetch. + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + + Returns: + GetDocumentResponse + """ + self._process_openapi_kwargs(kwargs) + kwargs["namespace"] = namespace + kwargs["document_id"] = document_id + return await self.call_with_http_info(**kwargs) + + self.get_document = _AsyncioEndpoint( + settings={ + "response_type": (GetDocumentResponse,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/namespaces/{namespace}/documents/{document_id}", + "operation_id": "get_document", + "http_method": "GET", + "servers": None, + }, + params_map={ + "all": ["namespace", "document_id"], + "required": ["namespace", "document_id"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"namespace": (str,), "document_id": (str,)}, + "attribute_map": {"namespace": "namespace", "document_id": "document_id"}, + "location_map": {"namespace": "path", "document_id": "path"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": []}, + api_client=api_client, + callable=__get_document, + ) + + async def __list_documents(self, namespace, **kwargs): + """List documents from the given namespace # noqa: E501 + + Lists documents from the specified namespace. (Paginated) # noqa: E501 + + + Args: + namespace (str): Namespace to fetch documents from. + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + + Returns: + ListDocumentResponse + """ + self._process_openapi_kwargs(kwargs) + kwargs["namespace"] = namespace + return await self.call_with_http_info(**kwargs) + + self.list_documents = _AsyncioEndpoint( + settings={ + "response_type": (ListDocumentResponse,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/namespaces/{namespace}/documents", + "operation_id": "list_documents", + "http_method": "GET", + "servers": None, + }, + params_map={ + "all": ["namespace"], + "required": ["namespace"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"namespace": (str,)}, + "attribute_map": {"namespace": "namespace"}, + "location_map": {"namespace": "path"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": []}, + api_client=api_client, + callable=__list_documents, + ) + + async def __upsert_document(self, namespace, document_for_upsert, **kwargs): + """Create or update a document in the given namespace # noqa: E501 + + Upserts a document into the specified namespace. The request body may contain any valid JSON document that conforms to the schema. Optionally, an `_id` field can be provided to use as the document's identifier; if omitted, the system will assign one. # noqa: E501 + + + Args: + namespace (str): Namespace where the document will be stored. + document_for_upsert (DocumentForUpsert): + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + + Returns: + UpsertDocumentResponse + """ + self._process_openapi_kwargs(kwargs) + kwargs["namespace"] = namespace + kwargs["document_for_upsert"] = document_for_upsert + return await self.call_with_http_info(**kwargs) + + self.upsert_document = _AsyncioEndpoint( + settings={ + "response_type": (UpsertDocumentResponse,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/namespaces/{namespace}/documents/upsert", + "operation_id": "upsert_document", + "http_method": "POST", + "servers": None, + }, + params_map={ + "all": ["namespace", "document_for_upsert"], + "required": ["namespace", "document_for_upsert"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"namespace": (str,), "document_for_upsert": (DocumentForUpsert,)}, + "attribute_map": {"namespace": "namespace"}, + "location_map": {"namespace": "path", "document_for_upsert": "body"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": ["application/json"]}, + api_client=api_client, + callable=__upsert_document, + ) diff --git a/pinecone/core/openapi/ckb_knowledge_data/apis/__init__.py b/pinecone/core/openapi/ckb_knowledge_data/apis/__init__.py new file mode 100644 index 00000000..e9aaf036 --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/apis/__init__.py @@ -0,0 +1,18 @@ +# flake8: noqa + +# Import all APIs into this package. +# If you have many APIs here with many many models used in each API this may +# raise a `RecursionError`. +# In order to avoid this, import only the API that you directly need like: +# +# from .api.document_operations_api import DocumentOperationsApi +# +# or import this package, but before doing it, use: +# +# import sys +# sys.setrecursionlimit(n) + +# Import APIs into API package: +from pinecone.core.openapi.ckb_knowledge_data.api.document_operations_api import ( + DocumentOperationsApi, +) diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/__init__.py b/pinecone/core/openapi/ckb_knowledge_data/model/__init__.py new file mode 100644 index 00000000..cfe32b78 --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/model/__init__.py @@ -0,0 +1,5 @@ +# we can not import model classes here because that would create a circular +# reference which would not work in python2 +# do not import all models into this module because that uses a lot of memory and stack frames +# if you need the ability to import all models from one package, import them with +# from {{packageName}.models import ModelA, ModelB diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/delete_document_response.py b/pinecone/core/openapi/ckb_knowledge_data/model/delete_document_response.py new file mode 100644 index 00000000..8de62577 --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/model/delete_document_response.py @@ -0,0 +1,304 @@ +""" +Pinecone Knowledge Base Data Plane API + +Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.ckb_knowledge_data.model.lsn_status import LSNStatus + from pinecone.core.openapi.ckb_knowledge_data.model.usage import Usage + + globals()["LSNStatus"] = LSNStatus + globals()["Usage"] = Usage + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="DeleteDocumentResponse") + + +class DeleteDocumentResponse(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + "id": (str,), # noqa: E501 + "namespace": (str,), # noqa: E501 + "usage": (Usage,), # noqa: E501 + "lsn_status": (LSNStatus,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "id": "_id", # noqa: E501 + "namespace": "namespace", # noqa: E501 + "usage": "usage", # noqa: E501 + "lsn_status": "_lsn_status", # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], id, namespace, usage, lsn_status, *args, **kwargs) -> T: # noqa: E501 + """DeleteDocumentResponse - a model defined in OpenAPI + + Args: + id (str): Identifier of the document to be deleted. + namespace (str): Namespace of the document to be deleted. + usage (Usage): + lsn_status (LSNStatus): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.id = id + self.namespace = namespace + self.usage = usage + self.lsn_status = lsn_status + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, id, namespace, usage, lsn_status, *args, **kwargs) -> None: # noqa: E501 + """DeleteDocumentResponse - a model defined in OpenAPI + + Args: + id (str): Identifier of the document to be deleted. + namespace (str): Namespace of the document to be deleted. + usage (Usage): + lsn_status (LSNStatus): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.id = id + self.namespace = namespace + self.usage = usage + self.lsn_status = lsn_status + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/document.py b/pinecone/core/openapi/ckb_knowledge_data/model/document.py new file mode 100644 index 00000000..e6b69feb --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/model/document.py @@ -0,0 +1,276 @@ +""" +Pinecone Knowledge Base Data Plane API + +Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="Document") + + +class Document(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return { + "id": (str,) # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "id": "_id" # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], id, *args, **kwargs) -> T: # noqa: E501 + """Document - a model defined in OpenAPI + + Args: + id (str): Unique identifier for the document. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.id = id + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, id, *args, **kwargs) -> None: # noqa: E501 + """Document - a model defined in OpenAPI + + Args: + id (str): Unique identifier for the document. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.id = id + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/document_for_upsert.py b/pinecone/core/openapi/ckb_knowledge_data/model/document_for_upsert.py new file mode 100644 index 00000000..1c8b4b67 --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/model/document_for_upsert.py @@ -0,0 +1,270 @@ +""" +Pinecone Knowledge Base Data Plane API + +Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="DocumentForUpsert") + + +class DocumentForUpsert(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return { + "id": (str,) # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "id": "_id" # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 + """DocumentForUpsert - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + id (str): Optional unique identifier for the document. If not provided, a new ID will be generated. [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, *args, **kwargs) -> None: # noqa: E501 + """DocumentForUpsert - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + id (str): Optional unique identifier for the document. If not provided, a new ID will be generated. [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/document_list.py b/pinecone/core/openapi/ckb_knowledge_data/model/document_list.py new file mode 100644 index 00000000..aafffb50 --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/model/document_list.py @@ -0,0 +1,300 @@ +""" +Pinecone Knowledge Base Data Plane API + +Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.ckb_knowledge_data.model.document import Document + + globals()["Document"] = Document + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="DocumentList") + + +class DocumentList(ModelSimple): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return {"value": ([Document],)} + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = {} + + read_only_vars: Set[str] = set() + + _composed_schemas = None + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, *args, **kwargs) -> None: + """DocumentList - a model defined in OpenAPI + + Note that value can be passed either in args or in kwargs, but not in both. + + Args: + args[0] ([Document]): The list of documents that exist in the knowledge base/namespace.. # noqa: E501 + + Keyword Args: + value ([Document]): The list of documents that exist in the knowledge base/namespace.. # noqa: E501 + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + # required up here when default value is not given + _path_to_item = kwargs.pop("_path_to_item", ()) + + value = None + if "value" in kwargs: + value = kwargs.pop("value") + + if value is None and args: + if len(args) == 1: + value = args[0] + elif len(args) > 1: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + if value is None: + raise PineconeApiTypeError( + "value is required, but not passed in args or kwargs and doesn't have default", + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + self.value = value + if kwargs: + raise PineconeApiTypeError( + "Invalid named arguments=%s passed to %s. Remove those invalid named arguments." + % (kwargs, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: + """DocumentList - a model defined in OpenAPI + + Note that value can be passed either in args or in kwargs, but not in both. + + Args: + args[0] ([Document]): The list of documents that exist in the knowledge base/namespace. # noqa: E501 + + Keyword Args: + value ([Document]): The list of documents that exist in the knowledge base/namespace. # noqa: E501 + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + # required up here when default value is not given + _path_to_item = kwargs.pop("_path_to_item", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + value = None + if "value" in kwargs: + value = kwargs.pop("value") + + if value is None and args: + if len(args) == 1: + value = args[0] + elif len(args) > 1: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + if value is None: + raise PineconeApiTypeError( + "value is required, but not passed in args or kwargs and doesn't have default", + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + self.value = value + if kwargs: + raise PineconeApiTypeError( + "Invalid named arguments=%s passed to %s. Remove those invalid named arguments." + % (kwargs, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + return self diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/get_document_response.py b/pinecone/core/openapi/ckb_knowledge_data/model/get_document_response.py new file mode 100644 index 00000000..f7197fe1 --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/model/get_document_response.py @@ -0,0 +1,308 @@ +""" +Pinecone Knowledge Base Data Plane API + +Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.ckb_knowledge_data.model.document import Document + from pinecone.core.openapi.ckb_knowledge_data.model.lsn_status import LSNStatus + from pinecone.core.openapi.ckb_knowledge_data.model.usage import Usage + + globals()["Document"] = Document + globals()["LSNStatus"] = LSNStatus + globals()["Usage"] = Usage + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="GetDocumentResponse") + + +class GetDocumentResponse(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + "namespace": (str,), # noqa: E501 + "document": (Document,), # noqa: E501 + "usage": (Usage,), # noqa: E501 + "lsn_status": (LSNStatus,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "namespace": "namespace", # noqa: E501 + "document": "document", # noqa: E501 + "usage": "usage", # noqa: E501 + "lsn_status": "_lsn_status", # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data( + cls: Type[T], namespace, document, usage, lsn_status, *args, **kwargs + ) -> T: # noqa: E501 + """GetDocumentResponse - a model defined in OpenAPI + + Args: + namespace (str): Namespace of the document to fetch. + document (Document): + usage (Usage): + lsn_status (LSNStatus): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.namespace = namespace + self.document = document + self.usage = usage + self.lsn_status = lsn_status + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, namespace, document, usage, lsn_status, *args, **kwargs) -> None: # noqa: E501 + """GetDocumentResponse - a model defined in OpenAPI + + Args: + namespace (str): Namespace of the document to fetch. + document (Document): + usage (Usage): + lsn_status (LSNStatus): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.namespace = namespace + self.document = document + self.usage = usage + self.lsn_status = lsn_status + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/list_document_response.py b/pinecone/core/openapi/ckb_knowledge_data/model/list_document_response.py new file mode 100644 index 00000000..340a894e --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/model/list_document_response.py @@ -0,0 +1,316 @@ +""" +Pinecone Knowledge Base Data Plane API + +Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.ckb_knowledge_data.model.document_list import DocumentList + from pinecone.core.openapi.ckb_knowledge_data.model.lsn_status import LSNStatus + from pinecone.core.openapi.ckb_knowledge_data.model.pagination_response import ( + PaginationResponse, + ) + from pinecone.core.openapi.ckb_knowledge_data.model.usage import Usage + + globals()["DocumentList"] = DocumentList + globals()["LSNStatus"] = LSNStatus + globals()["PaginationResponse"] = PaginationResponse + globals()["Usage"] = Usage + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="ListDocumentResponse") + + +class ListDocumentResponse(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + "namespace": (str,), # noqa: E501 + "documents": (DocumentList,), # noqa: E501 + "usage": (Usage,), # noqa: E501 + "lsn_status": (LSNStatus,), # noqa: E501 + "pagination": (PaginationResponse,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "namespace": "namespace", # noqa: E501 + "documents": "documents", # noqa: E501 + "usage": "usage", # noqa: E501 + "lsn_status": "_lsn_status", # noqa: E501 + "pagination": "pagination", # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data( + cls: Type[T], namespace, documents, usage, lsn_status, *args, **kwargs + ) -> T: # noqa: E501 + """ListDocumentResponse - a model defined in OpenAPI + + Args: + namespace (str): Namespace of the documents to fetch. + documents (DocumentList): + usage (Usage): + lsn_status (LSNStatus): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + pagination (PaginationResponse): [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.namespace = namespace + self.documents = documents + self.usage = usage + self.lsn_status = lsn_status + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, namespace, documents, usage, lsn_status, *args, **kwargs) -> None: # noqa: E501 + """ListDocumentResponse - a model defined in OpenAPI + + Args: + namespace (str): Namespace of the documents to fetch. + documents (DocumentList): + usage (Usage): + lsn_status (LSNStatus): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + pagination (PaginationResponse): [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.namespace = namespace + self.documents = documents + self.usage = usage + self.lsn_status = lsn_status + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/lsn_status.py b/pinecone/core/openapi/ckb_knowledge_data/model/lsn_status.py new file mode 100644 index 00000000..3414f6e4 --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/model/lsn_status.py @@ -0,0 +1,280 @@ +""" +Pinecone Knowledge Base Data Plane API + +Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="LSNStatus") + + +class LSNStatus(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return { + "reconciled": (int,), # noqa: E501 + "committed": (int,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "reconciled": "reconciled", # noqa: E501 + "committed": "committed", # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], reconciled, *args, **kwargs) -> T: # noqa: E501 + """LSNStatus - a model defined in OpenAPI + + Args: + reconciled (int): The latest reconciled log sequence number. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + committed (int): The committed log sequence number for this write operation. [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.reconciled = reconciled + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, reconciled, *args, **kwargs) -> None: # noqa: E501 + """LSNStatus - a model defined in OpenAPI + + Args: + reconciled (int): The latest reconciled log sequence number. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + committed (int): The committed log sequence number for this write operation. [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.reconciled = reconciled + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/pagination_response.py b/pinecone/core/openapi/ckb_knowledge_data/model/pagination_response.py new file mode 100644 index 00000000..3ce1852c --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/model/pagination_response.py @@ -0,0 +1,276 @@ +""" +Pinecone Knowledge Base Data Plane API + +Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="PaginationResponse") + + +class PaginationResponse(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return { + "next": (str,) # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "next": "next" # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], next, *args, **kwargs) -> T: # noqa: E501 + """PaginationResponse - a model defined in OpenAPI + + Args: + next (str): The token to use to retrieve the next page of results. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.next = next + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, next, *args, **kwargs) -> None: # noqa: E501 + """PaginationResponse - a model defined in OpenAPI + + Args: + next (str): The token to use to retrieve the next page of results. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.next = next + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/upsert_document_response.py b/pinecone/core/openapi/ckb_knowledge_data/model/upsert_document_response.py new file mode 100644 index 00000000..0df0c51b --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/model/upsert_document_response.py @@ -0,0 +1,296 @@ +""" +Pinecone Knowledge Base Data Plane API + +Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.ckb_knowledge_data.model.lsn_status import LSNStatus + + globals()["LSNStatus"] = LSNStatus + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="UpsertDocumentResponse") + + +class UpsertDocumentResponse(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + "id": (str,), # noqa: E501 + "namespace": (str,), # noqa: E501 + "lsn_status": (LSNStatus,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "id": "_id", # noqa: E501 + "namespace": "namespace", # noqa: E501 + "lsn_status": "_lsn_status", # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], id, namespace, lsn_status, *args, **kwargs) -> T: # noqa: E501 + """UpsertDocumentResponse - a model defined in OpenAPI + + Args: + id (str): Identifier of the document to be created or updated. + namespace (str): Namespace of the document to be created or updated. + lsn_status (LSNStatus): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.id = id + self.namespace = namespace + self.lsn_status = lsn_status + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, id, namespace, lsn_status, *args, **kwargs) -> None: # noqa: E501 + """UpsertDocumentResponse - a model defined in OpenAPI + + Args: + id (str): Identifier of the document to be created or updated. + namespace (str): Namespace of the document to be created or updated. + lsn_status (LSNStatus): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.id = id + self.namespace = namespace + self.lsn_status = lsn_status + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/usage.py b/pinecone/core/openapi/ckb_knowledge_data/model/usage.py new file mode 100644 index 00000000..68f89e42 --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/model/usage.py @@ -0,0 +1,282 @@ +""" +Pinecone Knowledge Base Data Plane API + +Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="Usage") + + +class Usage(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return { + "kb_read_units": (float,), # noqa: E501 + "kb_write_units": (float,), # noqa: E501 + "embed_total_tokens": (int,), # noqa: E501 + "rerank_units": (int,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "kb_read_units": "kb_read_units", # noqa: E501 + "kb_write_units": "kb_write_units", # noqa: E501 + "embed_total_tokens": "embed_total_tokens", # noqa: E501 + "rerank_units": "rerank_units", # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 + """Usage - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + kb_read_units (float): The number of read units consumed by this operation. [optional] # noqa: E501 + kb_write_units (float): The number of write units consumed by this operation. [optional] # noqa: E501 + embed_total_tokens (int): The number of embedding tokens consumed by this operation. [optional] # noqa: E501 + rerank_units (int): The number of rerank units consumed by this operation. [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, *args, **kwargs) -> None: # noqa: E501 + """Usage - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + kb_read_units (float): The number of read units consumed by this operation. [optional] # noqa: E501 + kb_write_units (float): The number of write units consumed by this operation. [optional] # noqa: E501 + embed_total_tokens (int): The number of embedding tokens consumed by this operation. [optional] # noqa: E501 + rerank_units (int): The number of rerank units consumed by this operation. [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/ckb_knowledge_data/models/__init__.py b/pinecone/core/openapi/ckb_knowledge_data/models/__init__.py new file mode 100644 index 00000000..48f85e20 --- /dev/null +++ b/pinecone/core/openapi/ckb_knowledge_data/models/__init__.py @@ -0,0 +1,27 @@ +# flake8: noqa + +# import all models into this package +# if you have many models here with many references from one model to another this may +# raise a RecursionError +# to avoid this, import only the models that you directly need like: +# from from pinecone.core.openapi.ckb_knowledge_data.model.pet import Pet +# or import this package, but before doing it, use: +# import sys +# sys.setrecursionlimit(n) + +from pinecone.core.openapi.ckb_knowledge_data.model.delete_document_response import ( + DeleteDocumentResponse, +) +from pinecone.core.openapi.ckb_knowledge_data.model.document import Document +from pinecone.core.openapi.ckb_knowledge_data.model.document_for_upsert import DocumentForUpsert +from pinecone.core.openapi.ckb_knowledge_data.model.document_list import DocumentList +from pinecone.core.openapi.ckb_knowledge_data.model.get_document_response import GetDocumentResponse +from pinecone.core.openapi.ckb_knowledge_data.model.lsn_status import LSNStatus +from pinecone.core.openapi.ckb_knowledge_data.model.list_document_response import ( + ListDocumentResponse, +) +from pinecone.core.openapi.ckb_knowledge_data.model.pagination_response import PaginationResponse +from pinecone.core.openapi.ckb_knowledge_data.model.upsert_document_response import ( + UpsertDocumentResponse, +) +from pinecone.core.openapi.ckb_knowledge_data.model.usage import Usage diff --git a/pinecone/openapi_support/api_version.py b/pinecone/openapi_support/api_version.py index 403ff26f..fc6426a5 100644 --- a/pinecone/openapi_support/api_version.py +++ b/pinecone/openapi_support/api_version.py @@ -1,5 +1,5 @@ # This file is generated by codegen/build-oas.sh # Do not edit this file manually. -API_VERSION = "2025-04" -APIS_REPO_SHA = "7e21ca9adb6a530ce11909d6209d69551f86e9bd" +API_VERSION = "unstable" +APIS_REPO_SHA = "827d26f4825902994a099595d49779d16fea3a0a" From f66b42bb033198ba8a284451b1a9b07940438b15 Mon Sep 17 00:00:00 2001 From: Silas Smith <163026730+ssmith-pc@users.noreply.github.com> Date: Thu, 18 Sep 2025 16:17:35 -0700 Subject: [PATCH 2/4] [ce] update codegen to include control plane (#523) ## Problem Describe the purpose of this change. What problem is being solved and why? ## Solution Describe the approach you took. Link to any relevant bugs, issues, docs, or other resources. ## Type of Change - [ ] Bug fix (non-breaking change which fixes an issue) - [ ] New feature (non-breaking change which adds functionality) - [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) - [ ] This change requires a documentation update - [ ] Infrastructure change (CI configs, etc) - [ ] Non-code change (docs, etc) - [ ] None of the above: (explain here) ## Test Plan Describe specific steps for validating this change. --- .../ckb_knowledge_data/models/__init__.py | 27 - .../openapi/repository_control/__init__.py | 30 + .../api/__init__.py | 2 +- .../api/manage_repositories_api.py | 563 ++++++++++++++++++ .../repository_control/apis/__init__.py | 18 + .../model/__init__.py | 0 .../model/create_repository_request.py | 300 ++++++++++ .../model/document_schema.py | 286 +++++++++ .../model/document_schema_field_map.py | 264 ++++++++ .../model/error_response.py | 292 +++++++++ .../model/error_response_error.py | 286 +++++++++ .../model/repository_list.py | 278 +++++++++ .../model/repository_model.py | 316 ++++++++++ .../model/repository_model_spec.py} | 28 +- .../model/repository_model_status.py | 282 +++++++++ .../model/repository_spec.py | 271 +++++++++ .../model/serverless_spec.py | 282 +++++++++ .../repository_control/models/__init__.py | 28 + .../__init__.py | 4 +- .../openapi/repository_data/api/__init__.py | 3 + .../api/document_operations_api.py | 77 +-- .../apis/__init__.py | 4 +- .../openapi/repository_data/model/__init__.py | 5 + .../model/delete_document_response.py | 8 +- .../model/document.py | 4 +- .../model/document_list.py | 14 +- .../model/get_document_response.py | 10 +- .../model/list_documents_response.py} | 22 +- .../model/lsn_status.py | 4 +- .../model/pagination_response.py | 4 +- .../model/upsert_document_response.py | 6 +- .../model/usage.py | 4 +- .../repository_data/models/__init__.py | 26 + 33 files changed, 3629 insertions(+), 119 deletions(-) delete mode 100644 pinecone/core/openapi/ckb_knowledge_data/models/__init__.py create mode 100644 pinecone/core/openapi/repository_control/__init__.py rename pinecone/core/openapi/{ckb_knowledge_data => repository_control}/api/__init__.py (67%) create mode 100644 pinecone/core/openapi/repository_control/api/manage_repositories_api.py create mode 100644 pinecone/core/openapi/repository_control/apis/__init__.py rename pinecone/core/openapi/{ckb_knowledge_data => repository_control}/model/__init__.py (100%) create mode 100644 pinecone/core/openapi/repository_control/model/create_repository_request.py create mode 100644 pinecone/core/openapi/repository_control/model/document_schema.py create mode 100644 pinecone/core/openapi/repository_control/model/document_schema_field_map.py create mode 100644 pinecone/core/openapi/repository_control/model/error_response.py create mode 100644 pinecone/core/openapi/repository_control/model/error_response_error.py create mode 100644 pinecone/core/openapi/repository_control/model/repository_list.py create mode 100644 pinecone/core/openapi/repository_control/model/repository_model.py rename pinecone/core/openapi/{ckb_knowledge_data/model/document_for_upsert.py => repository_control/model/repository_model_spec.py} (93%) create mode 100644 pinecone/core/openapi/repository_control/model/repository_model_status.py create mode 100644 pinecone/core/openapi/repository_control/model/repository_spec.py create mode 100644 pinecone/core/openapi/repository_control/model/serverless_spec.py create mode 100644 pinecone/core/openapi/repository_control/models/__init__.py rename pinecone/core/openapi/{ckb_knowledge_data => repository_data}/__init__.py (82%) create mode 100644 pinecone/core/openapi/repository_data/api/__init__.py rename pinecone/core/openapi/{ckb_knowledge_data => repository_data}/api/document_operations_api.py (89%) rename pinecone/core/openapi/{ckb_knowledge_data => repository_data}/apis/__init__.py (79%) create mode 100644 pinecone/core/openapi/repository_data/model/__init__.py rename pinecone/core/openapi/{ckb_knowledge_data => repository_data}/model/delete_document_response.py (97%) rename pinecone/core/openapi/{ckb_knowledge_data => repository_data}/model/document.py (98%) rename pinecone/core/openapi/{ckb_knowledge_data => repository_data}/model/document_list.py (96%) rename pinecone/core/openapi/{ckb_knowledge_data => repository_data}/model/get_document_response.py (96%) rename pinecone/core/openapi/{ckb_knowledge_data/model/list_document_response.py => repository_data/model/list_documents_response.py} (94%) rename pinecone/core/openapi/{ckb_knowledge_data => repository_data}/model/lsn_status.py (98%) rename pinecone/core/openapi/{ckb_knowledge_data => repository_data}/model/pagination_response.py (98%) rename pinecone/core/openapi/{ckb_knowledge_data => repository_data}/model/upsert_document_response.py (98%) rename pinecone/core/openapi/{ckb_knowledge_data => repository_data}/model/usage.py (98%) create mode 100644 pinecone/core/openapi/repository_data/models/__init__.py diff --git a/pinecone/core/openapi/ckb_knowledge_data/models/__init__.py b/pinecone/core/openapi/ckb_knowledge_data/models/__init__.py deleted file mode 100644 index 48f85e20..00000000 --- a/pinecone/core/openapi/ckb_knowledge_data/models/__init__.py +++ /dev/null @@ -1,27 +0,0 @@ -# flake8: noqa - -# import all models into this package -# if you have many models here with many references from one model to another this may -# raise a RecursionError -# to avoid this, import only the models that you directly need like: -# from from pinecone.core.openapi.ckb_knowledge_data.model.pet import Pet -# or import this package, but before doing it, use: -# import sys -# sys.setrecursionlimit(n) - -from pinecone.core.openapi.ckb_knowledge_data.model.delete_document_response import ( - DeleteDocumentResponse, -) -from pinecone.core.openapi.ckb_knowledge_data.model.document import Document -from pinecone.core.openapi.ckb_knowledge_data.model.document_for_upsert import DocumentForUpsert -from pinecone.core.openapi.ckb_knowledge_data.model.document_list import DocumentList -from pinecone.core.openapi.ckb_knowledge_data.model.get_document_response import GetDocumentResponse -from pinecone.core.openapi.ckb_knowledge_data.model.lsn_status import LSNStatus -from pinecone.core.openapi.ckb_knowledge_data.model.list_document_response import ( - ListDocumentResponse, -) -from pinecone.core.openapi.ckb_knowledge_data.model.pagination_response import PaginationResponse -from pinecone.core.openapi.ckb_knowledge_data.model.upsert_document_response import ( - UpsertDocumentResponse, -) -from pinecone.core.openapi.ckb_knowledge_data.model.usage import Usage diff --git a/pinecone/core/openapi/repository_control/__init__.py b/pinecone/core/openapi/repository_control/__init__.py new file mode 100644 index 00000000..8010019d --- /dev/null +++ b/pinecone/core/openapi/repository_control/__init__.py @@ -0,0 +1,30 @@ +# flake8: noqa + +""" +Pinecone Control Plane API for Repositories + +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +__version__ = "1.0.0" + +# import ApiClient +from pinecone.openapi_support.api_client import ApiClient + +# import Configuration +from pinecone.config.openapi_configuration import Configuration + +# import exceptions +from pinecone.openapi_support.exceptions import PineconeException +from pinecone.openapi_support.exceptions import PineconeApiAttributeError +from pinecone.openapi_support.exceptions import PineconeApiTypeError +from pinecone.openapi_support.exceptions import PineconeApiValueError +from pinecone.openapi_support.exceptions import PineconeApiKeyError +from pinecone.openapi_support.exceptions import PineconeApiException + +API_VERSION = "unstable" diff --git a/pinecone/core/openapi/ckb_knowledge_data/api/__init__.py b/pinecone/core/openapi/repository_control/api/__init__.py similarity index 67% rename from pinecone/core/openapi/ckb_knowledge_data/api/__init__.py rename to pinecone/core/openapi/repository_control/api/__init__.py index 094e63d1..00b342ea 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/api/__init__.py +++ b/pinecone/core/openapi/repository_control/api/__init__.py @@ -1,3 +1,3 @@ # do not import all apis into this module because that uses a lot of memory and stack frames # if you need the ability to import all apis from one package, import them with -# from pinecone.core.openapi.ckb_knowledge_data.apis import DocumentOperationsApi +# from pinecone.core.openapi.repository_control.apis import ManageRepositoriesApi diff --git a/pinecone/core/openapi/repository_control/api/manage_repositories_api.py b/pinecone/core/openapi/repository_control/api/manage_repositories_api.py new file mode 100644 index 00000000..23416b36 --- /dev/null +++ b/pinecone/core/openapi/repository_control/api/manage_repositories_api.py @@ -0,0 +1,563 @@ +""" +Pinecone Control Plane API for Repositories + +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support import ApiClient, AsyncioApiClient +from pinecone.openapi_support.endpoint_utils import ( + ExtraOpenApiKwargsTypedDict, + KwargsWithOpenApiKwargDefaultsTypedDict, +) +from pinecone.openapi_support.endpoint import Endpoint as _Endpoint, ExtraOpenApiKwargsTypedDict +from pinecone.openapi_support.asyncio_endpoint import AsyncioEndpoint as _AsyncioEndpoint +from pinecone.openapi_support.model_utils import ( # noqa: F401 + date, + datetime, + file_type, + none_type, + validate_and_convert_types, +) +from pinecone.core.openapi.repository_control.model.create_repository_request import ( + CreateRepositoryRequest, +) +from pinecone.core.openapi.repository_control.model.error_response import ErrorResponse +from pinecone.core.openapi.repository_control.model.repository_list import RepositoryList +from pinecone.core.openapi.repository_control.model.repository_model import RepositoryModel + + +class ManageRepositoriesApi: + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + """ + + def __init__(self, api_client=None) -> None: + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def __create_repository( + self, create_repository_request, **kwargs: ExtraOpenApiKwargsTypedDict + ): + """Create a repository # noqa: E501 + + Create a Pinecone Repository in the cloud provider and region of your choice. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + + >>> thread = api.create_repository(create_repository_request, async_req=True) + >>> result = thread.get() + + Args: + create_repository_request (CreateRepositoryRequest): The desired configuration for the repository. + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + async_req (bool): execute request asynchronously + + Returns: + RepositoryModel + If the method is called asynchronously, returns the request + thread. + """ + kwargs = self._process_openapi_kwargs(kwargs) + kwargs["create_repository_request"] = create_repository_request + return self.call_with_http_info(**kwargs) + + self.create_repository = _Endpoint( + settings={ + "response_type": (RepositoryModel,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/repositories", + "operation_id": "create_repository", + "http_method": "POST", + "servers": None, + }, + params_map={ + "all": ["create_repository_request"], + "required": ["create_repository_request"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"create_repository_request": (CreateRepositoryRequest,)}, + "attribute_map": {}, + "location_map": {"create_repository_request": "body"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": ["application/json"]}, + api_client=api_client, + callable=__create_repository, + ) + + def __delete_repository(self, repository_name, **kwargs: ExtraOpenApiKwargsTypedDict): + """Delete a repository # noqa: E501 + + Delete an existing repository. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + + >>> thread = api.delete_repository(repository_name, async_req=True) + >>> result = thread.get() + + Args: + repository_name (str): The name of the repository to delete. + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + async_req (bool): execute request asynchronously + + Returns: + None + If the method is called asynchronously, returns the request + thread. + """ + kwargs = self._process_openapi_kwargs(kwargs) + kwargs["repository_name"] = repository_name + return self.call_with_http_info(**kwargs) + + self.delete_repository = _Endpoint( + settings={ + "response_type": None, + "auth": ["ApiKeyAuth"], + "endpoint_path": "/repositories/{repository_name}", + "operation_id": "delete_repository", + "http_method": "DELETE", + "servers": None, + }, + params_map={ + "all": ["repository_name"], + "required": ["repository_name"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"repository_name": (str,)}, + "attribute_map": {"repository_name": "repository_name"}, + "location_map": {"repository_name": "path"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": []}, + api_client=api_client, + callable=__delete_repository, + ) + + def __describe_repository(self, repository_name, **kwargs: ExtraOpenApiKwargsTypedDict): + """Describe a repository # noqa: E501 + + Get a description of a repository. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + + >>> thread = api.describe_repository(repository_name, async_req=True) + >>> result = thread.get() + + Args: + repository_name (str): The name of the repository to be described. + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + async_req (bool): execute request asynchronously + + Returns: + RepositoryModel + If the method is called asynchronously, returns the request + thread. + """ + kwargs = self._process_openapi_kwargs(kwargs) + kwargs["repository_name"] = repository_name + return self.call_with_http_info(**kwargs) + + self.describe_repository = _Endpoint( + settings={ + "response_type": (RepositoryModel,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/repositories/{repository_name}", + "operation_id": "describe_repository", + "http_method": "GET", + "servers": None, + }, + params_map={ + "all": ["repository_name"], + "required": ["repository_name"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"repository_name": (str,)}, + "attribute_map": {"repository_name": "repository_name"}, + "location_map": {"repository_name": "path"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": []}, + api_client=api_client, + callable=__describe_repository, + ) + + def __list_repositories(self, **kwargs: ExtraOpenApiKwargsTypedDict): + """List repositories # noqa: E501 + + List all repositories in a project. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + + >>> thread = api.list_repositories(async_req=True) + >>> result = thread.get() + + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + async_req (bool): execute request asynchronously + + Returns: + RepositoryList + If the method is called asynchronously, returns the request + thread. + """ + kwargs = self._process_openapi_kwargs(kwargs) + return self.call_with_http_info(**kwargs) + + self.list_repositories = _Endpoint( + settings={ + "response_type": (RepositoryList,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/repositories", + "operation_id": "list_repositories", + "http_method": "GET", + "servers": None, + }, + params_map={"all": [], "required": [], "nullable": [], "enum": [], "validation": []}, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {}, + "attribute_map": {}, + "location_map": {}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": []}, + api_client=api_client, + callable=__list_repositories, + ) + + +class AsyncioManageRepositoriesApi: + """NOTE: This class is @generated using OpenAPI + + Do not edit the class manually. + """ + + def __init__(self, api_client=None) -> None: + if api_client is None: + api_client = AsyncioApiClient() + self.api_client = api_client + + async def __create_repository(self, create_repository_request, **kwargs): + """Create a repository # noqa: E501 + + Create a Pinecone Repository in the cloud provider and region of your choice. # noqa: E501 + + + Args: + create_repository_request (CreateRepositoryRequest): The desired configuration for the repository. + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + + Returns: + RepositoryModel + """ + self._process_openapi_kwargs(kwargs) + kwargs["create_repository_request"] = create_repository_request + return await self.call_with_http_info(**kwargs) + + self.create_repository = _AsyncioEndpoint( + settings={ + "response_type": (RepositoryModel,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/repositories", + "operation_id": "create_repository", + "http_method": "POST", + "servers": None, + }, + params_map={ + "all": ["create_repository_request"], + "required": ["create_repository_request"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"create_repository_request": (CreateRepositoryRequest,)}, + "attribute_map": {}, + "location_map": {"create_repository_request": "body"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": ["application/json"]}, + api_client=api_client, + callable=__create_repository, + ) + + async def __delete_repository(self, repository_name, **kwargs): + """Delete a repository # noqa: E501 + + Delete an existing repository. # noqa: E501 + + + Args: + repository_name (str): The name of the repository to delete. + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + + Returns: + None + """ + self._process_openapi_kwargs(kwargs) + kwargs["repository_name"] = repository_name + return await self.call_with_http_info(**kwargs) + + self.delete_repository = _AsyncioEndpoint( + settings={ + "response_type": None, + "auth": ["ApiKeyAuth"], + "endpoint_path": "/repositories/{repository_name}", + "operation_id": "delete_repository", + "http_method": "DELETE", + "servers": None, + }, + params_map={ + "all": ["repository_name"], + "required": ["repository_name"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"repository_name": (str,)}, + "attribute_map": {"repository_name": "repository_name"}, + "location_map": {"repository_name": "path"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": []}, + api_client=api_client, + callable=__delete_repository, + ) + + async def __describe_repository(self, repository_name, **kwargs): + """Describe a repository # noqa: E501 + + Get a description of a repository. # noqa: E501 + + + Args: + repository_name (str): The name of the repository to be described. + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + + Returns: + RepositoryModel + """ + self._process_openapi_kwargs(kwargs) + kwargs["repository_name"] = repository_name + return await self.call_with_http_info(**kwargs) + + self.describe_repository = _AsyncioEndpoint( + settings={ + "response_type": (RepositoryModel,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/repositories/{repository_name}", + "operation_id": "describe_repository", + "http_method": "GET", + "servers": None, + }, + params_map={ + "all": ["repository_name"], + "required": ["repository_name"], + "nullable": [], + "enum": [], + "validation": [], + }, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {"repository_name": (str,)}, + "attribute_map": {"repository_name": "repository_name"}, + "location_map": {"repository_name": "path"}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": []}, + api_client=api_client, + callable=__describe_repository, + ) + + async def __list_repositories(self, **kwargs): + """List repositories # noqa: E501 + + List all repositories in a project. # noqa: E501 + + + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + + Returns: + RepositoryList + """ + self._process_openapi_kwargs(kwargs) + return await self.call_with_http_info(**kwargs) + + self.list_repositories = _AsyncioEndpoint( + settings={ + "response_type": (RepositoryList,), + "auth": ["ApiKeyAuth"], + "endpoint_path": "/repositories", + "operation_id": "list_repositories", + "http_method": "GET", + "servers": None, + }, + params_map={"all": [], "required": [], "nullable": [], "enum": [], "validation": []}, + root_map={ + "validations": {}, + "allowed_values": {}, + "openapi_types": {}, + "attribute_map": {}, + "location_map": {}, + "collection_format_map": {}, + }, + headers_map={"accept": ["application/json"], "content_type": []}, + api_client=api_client, + callable=__list_repositories, + ) diff --git a/pinecone/core/openapi/repository_control/apis/__init__.py b/pinecone/core/openapi/repository_control/apis/__init__.py new file mode 100644 index 00000000..02323f0e --- /dev/null +++ b/pinecone/core/openapi/repository_control/apis/__init__.py @@ -0,0 +1,18 @@ +# flake8: noqa + +# Import all APIs into this package. +# If you have many APIs here with many many models used in each API this may +# raise a `RecursionError`. +# In order to avoid this, import only the API that you directly need like: +# +# from .api.manage_repositories_api import ManageRepositoriesApi +# +# or import this package, but before doing it, use: +# +# import sys +# sys.setrecursionlimit(n) + +# Import APIs into API package: +from pinecone.core.openapi.repository_control.api.manage_repositories_api import ( + ManageRepositoriesApi, +) diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/__init__.py b/pinecone/core/openapi/repository_control/model/__init__.py similarity index 100% rename from pinecone/core/openapi/ckb_knowledge_data/model/__init__.py rename to pinecone/core/openapi/repository_control/model/__init__.py diff --git a/pinecone/core/openapi/repository_control/model/create_repository_request.py b/pinecone/core/openapi/repository_control/model/create_repository_request.py new file mode 100644 index 00000000..319259f9 --- /dev/null +++ b/pinecone/core/openapi/repository_control/model/create_repository_request.py @@ -0,0 +1,300 @@ +""" +Pinecone Control Plane API for Repositories + +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_control.model.document_schema import DocumentSchema + from pinecone.core.openapi.repository_control.model.repository_spec import RepositorySpec + + globals()["DocumentSchema"] = DocumentSchema + globals()["RepositorySpec"] = RepositorySpec + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="CreateRepositoryRequest") + + +class CreateRepositoryRequest(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + ("name",): {"max_length": 45, "min_length": 1} + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + "name": (str,), # noqa: E501 + "spec": (RepositorySpec,), # noqa: E501 + "schema": (DocumentSchema,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "name": "name", # noqa: E501 + "spec": "spec", # noqa: E501 + "schema": "schema", # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], name, spec, schema, *args, **kwargs) -> T: # noqa: E501 + """CreateRepositoryRequest - a model defined in OpenAPI + + Args: + name (str): The name of the repository. Resource name must be 1-45 characters long, start and end with an alphanumeric character, and consist only of lower case alphanumeric characters or '-'. + spec (RepositorySpec): + schema (DocumentSchema): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.name = name + self.spec = spec + self.schema = schema + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, name, spec, schema, *args, **kwargs) -> None: # noqa: E501 + """CreateRepositoryRequest - a model defined in OpenAPI + + Args: + name (str): The name of the repository. Resource name must be 1-45 characters long, start and end with an alphanumeric character, and consist only of lower case alphanumeric characters or '-'. + spec (RepositorySpec): + schema (DocumentSchema): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.name = name + self.spec = spec + self.schema = schema + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/repository_control/model/document_schema.py b/pinecone/core/openapi/repository_control/model/document_schema.py new file mode 100644 index 00000000..2bb70a97 --- /dev/null +++ b/pinecone/core/openapi/repository_control/model/document_schema.py @@ -0,0 +1,286 @@ +""" +Pinecone Control Plane API for Repositories + +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_control.model.document_schema_field_map import ( + DocumentSchemaFieldMap, + ) + + globals()["DocumentSchemaFieldMap"] = DocumentSchemaFieldMap + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="DocumentSchema") + + +class DocumentSchema(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + "fields": (DocumentSchemaFieldMap,) # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "fields": "fields" # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], fields, *args, **kwargs) -> T: # noqa: E501 + """DocumentSchema - a model defined in OpenAPI + + Args: + fields (DocumentSchemaFieldMap): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.fields = fields + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, fields, *args, **kwargs) -> None: # noqa: E501 + """DocumentSchema - a model defined in OpenAPI + + Args: + fields (DocumentSchemaFieldMap): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.fields = fields + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/repository_control/model/document_schema_field_map.py b/pinecone/core/openapi/repository_control/model/document_schema_field_map.py new file mode 100644 index 00000000..bf4b48b6 --- /dev/null +++ b/pinecone/core/openapi/repository_control/model/document_schema_field_map.py @@ -0,0 +1,264 @@ +""" +Pinecone Control Plane API for Repositories + +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="DocumentSchemaFieldMap") + + +class DocumentSchemaFieldMap(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return ({str: (bool, dict, float, int, list, str, none_type)},) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return {} + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = {} + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 + """DocumentSchemaFieldMap - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, *args, **kwargs) -> None: # noqa: E501 + """DocumentSchemaFieldMap - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/repository_control/model/error_response.py b/pinecone/core/openapi/repository_control/model/error_response.py new file mode 100644 index 00000000..f4a67594 --- /dev/null +++ b/pinecone/core/openapi/repository_control/model/error_response.py @@ -0,0 +1,292 @@ +""" +Pinecone Control Plane API for Repositories + +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_control.model.error_response_error import ( + ErrorResponseError, + ) + + globals()["ErrorResponseError"] = ErrorResponseError + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="ErrorResponse") + + +class ErrorResponse(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + "status": (int,), # noqa: E501 + "error": (ErrorResponseError,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "status": "status", # noqa: E501 + "error": "error", # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], status, error, *args, **kwargs) -> T: # noqa: E501 + """ErrorResponse - a model defined in OpenAPI + + Args: + status (int): The HTTP status code of the error. + error (ErrorResponseError): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.status = status + self.error = error + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, status, error, *args, **kwargs) -> None: # noqa: E501 + """ErrorResponse - a model defined in OpenAPI + + Args: + status (int): The HTTP status code of the error. + error (ErrorResponseError): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.status = status + self.error = error + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/repository_control/model/error_response_error.py b/pinecone/core/openapi/repository_control/model/error_response_error.py new file mode 100644 index 00000000..792b0b85 --- /dev/null +++ b/pinecone/core/openapi/repository_control/model/error_response_error.py @@ -0,0 +1,286 @@ +""" +Pinecone Control Plane API for Repositories + +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="ErrorResponseError") + + +class ErrorResponseError(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return { + "code": (str,), # noqa: E501 + "message": (str,), # noqa: E501 + "details": ({str: (bool, dict, float, int, list, str, none_type)},), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "code": "code", # noqa: E501 + "message": "message", # noqa: E501 + "details": "details", # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], code, message, *args, **kwargs) -> T: # noqa: E501 + """ErrorResponseError - a model defined in OpenAPI + + Args: + code (str): The code of the error. Possible values: `OK`, `UNKNOWN`, `INVALID_ARGUMENT`, `DEADLINE_EXCEEDED`, `QUOTA_EXCEEDED`, `NOT_FOUND`, `ALREADY_EXISTS`, `PERMISSION_DENIED`, `UNAUTHENTICATED`, `RESOURCE_EXHAUSTED`, `FAILED_PRECONDITION`, `ABORTED`, `OUT_OF_RANGE`, `UNIMPLEMENTED`, `INTERNAL`, `UNAVAILABLE`, `DATA_LOSS`, `FORBIDDEN`, `UNPROCESSABLE_ENTITY`, or `PAYMENT_REQUIRED`. + message (str): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + details ({str: (bool, dict, float, int, list, str, none_type)}): Additional information about the error. This field is not guaranteed to be present. [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.code = code + self.message = message + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, code, message, *args, **kwargs) -> None: # noqa: E501 + """ErrorResponseError - a model defined in OpenAPI + + Args: + code (str): The code of the error. Possible values: `OK`, `UNKNOWN`, `INVALID_ARGUMENT`, `DEADLINE_EXCEEDED`, `QUOTA_EXCEEDED`, `NOT_FOUND`, `ALREADY_EXISTS`, `PERMISSION_DENIED`, `UNAUTHENTICATED`, `RESOURCE_EXHAUSTED`, `FAILED_PRECONDITION`, `ABORTED`, `OUT_OF_RANGE`, `UNIMPLEMENTED`, `INTERNAL`, `UNAVAILABLE`, `DATA_LOSS`, `FORBIDDEN`, `UNPROCESSABLE_ENTITY`, or `PAYMENT_REQUIRED`. + message (str): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + details ({str: (bool, dict, float, int, list, str, none_type)}): Additional information about the error. This field is not guaranteed to be present. [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.code = code + self.message = message + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/repository_control/model/repository_list.py b/pinecone/core/openapi/repository_control/model/repository_list.py new file mode 100644 index 00000000..68f0c556 --- /dev/null +++ b/pinecone/core/openapi/repository_control/model/repository_list.py @@ -0,0 +1,278 @@ +""" +Pinecone Control Plane API for Repositories + +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_control.model.repository_model import RepositoryModel + + globals()["RepositoryModel"] = RepositoryModel + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="RepositoryList") + + +class RepositoryList(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + "repositories": ([RepositoryModel],) # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "repositories": "repositories" # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 + """RepositoryList - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + repositories ([RepositoryModel]): [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, *args, **kwargs) -> None: # noqa: E501 + """RepositoryList - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + repositories ([RepositoryModel]): [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/repository_control/model/repository_model.py b/pinecone/core/openapi/repository_control/model/repository_model.py new file mode 100644 index 00000000..d3674be8 --- /dev/null +++ b/pinecone/core/openapi/repository_control/model/repository_model.py @@ -0,0 +1,316 @@ +""" +Pinecone Control Plane API for Repositories + +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_control.model.document_schema import DocumentSchema + from pinecone.core.openapi.repository_control.model.repository_model_spec import ( + RepositoryModelSpec, + ) + from pinecone.core.openapi.repository_control.model.repository_model_status import ( + RepositoryModelStatus, + ) + + globals()["DocumentSchema"] = DocumentSchema + globals()["RepositoryModelSpec"] = RepositoryModelSpec + globals()["RepositoryModelStatus"] = RepositoryModelStatus + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="RepositoryModel") + + +class RepositoryModel(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + ("name",): {"max_length": 45, "min_length": 1} + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + "name": (str,), # noqa: E501 + "host": (str,), # noqa: E501 + "spec": (RepositoryModelSpec,), # noqa: E501 + "status": (RepositoryModelStatus,), # noqa: E501 + "schema": (DocumentSchema,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "name": "name", # noqa: E501 + "host": "host", # noqa: E501 + "spec": "spec", # noqa: E501 + "status": "status", # noqa: E501 + "schema": "schema", # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], name, host, spec, status, *args, **kwargs) -> T: # noqa: E501 + """RepositoryModel - a model defined in OpenAPI + + Args: + name (str): The name of the repository. Resource name must be 1-45 characters long, start and end with an alphanumeric character, and consist only of lower case alphanumeric characters or '-'. + host (str): The URL address where the repository is hosted. + spec (RepositoryModelSpec): + status (RepositoryModelStatus): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + schema (DocumentSchema): [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.name = name + self.host = host + self.spec = spec + self.status = status + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, name, host, spec, status, *args, **kwargs) -> None: # noqa: E501 + """RepositoryModel - a model defined in OpenAPI + + Args: + name (str): The name of the repository. Resource name must be 1-45 characters long, start and end with an alphanumeric character, and consist only of lower case alphanumeric characters or '-'. + host (str): The URL address where the repository is hosted. + spec (RepositoryModelSpec): + status (RepositoryModelStatus): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + schema (DocumentSchema): [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.name = name + self.host = host + self.spec = spec + self.status = status + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/document_for_upsert.py b/pinecone/core/openapi/repository_control/model/repository_model_spec.py similarity index 93% rename from pinecone/core/openapi/ckb_knowledge_data/model/document_for_upsert.py rename to pinecone/core/openapi/repository_control/model/repository_model_spec.py index 1c8b4b67..fdb09039 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/model/document_for_upsert.py +++ b/pinecone/core/openapi/repository_control/model/repository_model_spec.py @@ -1,7 +1,7 @@ """ -Pinecone Knowledge Base Data Plane API +Pinecone Control Plane API for Repositories -Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 This file is @generated using OpenAPI. @@ -27,13 +27,19 @@ from pinecone.openapi_support.exceptions import PineconeApiAttributeError +def lazy_import(): + from pinecone.core.openapi.repository_control.model.serverless_spec import ServerlessSpec + + globals()["ServerlessSpec"] = ServerlessSpec + + from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property -T = TypeVar("T", bound="DocumentForUpsert") +T = TypeVar("T", bound="RepositoryModelSpec") -class DocumentForUpsert(ModelNormal): +class RepositoryModelSpec(ModelNormal): """NOTE: This class is @generated using OpenAPI. Do not edit the class manually. @@ -69,6 +75,7 @@ def additional_properties_type(cls): This must be a method because a model may have properties that are of type self, this must run after the class is loaded """ + lazy_import() return (bool, dict, float, int, list, str, none_type) # noqa: E501 _nullable = False @@ -83,8 +90,9 @@ def openapi_types(cls): openapi_types (dict): The key is attribute name and the value is attribute type. """ + lazy_import() return { - "id": (str,) # noqa: E501 + "serverless": (ServerlessSpec,) # noqa: E501 } @cached_class_property @@ -92,7 +100,7 @@ def discriminator(cls): return None attribute_map: Dict[str, str] = { - "id": "_id" # noqa: E501 + "serverless": "serverless" # noqa: E501 } read_only_vars: Set[str] = set([]) @@ -102,7 +110,7 @@ def discriminator(cls): @classmethod @convert_js_args_to_python_args def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 - """DocumentForUpsert - a model defined in OpenAPI + """RepositoryModelSpec - a model defined in OpenAPI Keyword Args: _check_type (bool): if True, values for parameters in openapi_types @@ -135,7 +143,7 @@ def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 Animal class but this time we won't travel through its discriminator because we passed in _visited_composed_classes = (Animal,) - id (str): Optional unique identifier for the document. If not provided, a new ID will be generated. [optional] # noqa: E501 + serverless (ServerlessSpec): [optional] # noqa: E501 """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) @@ -192,7 +200,7 @@ def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 @convert_js_args_to_python_args def __init__(self, *args, **kwargs) -> None: # noqa: E501 - """DocumentForUpsert - a model defined in OpenAPI + """RepositoryModelSpec - a model defined in OpenAPI Keyword Args: _check_type (bool): if True, values for parameters in openapi_types @@ -225,7 +233,7 @@ def __init__(self, *args, **kwargs) -> None: # noqa: E501 Animal class but this time we won't travel through its discriminator because we passed in _visited_composed_classes = (Animal,) - id (str): Optional unique identifier for the document. If not provided, a new ID will be generated. [optional] # noqa: E501 + serverless (ServerlessSpec): [optional] # noqa: E501 """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) diff --git a/pinecone/core/openapi/repository_control/model/repository_model_status.py b/pinecone/core/openapi/repository_control/model/repository_model_status.py new file mode 100644 index 00000000..3ccc23d8 --- /dev/null +++ b/pinecone/core/openapi/repository_control/model/repository_model_status.py @@ -0,0 +1,282 @@ +""" +Pinecone Control Plane API for Repositories + +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="RepositoryModelStatus") + + +class RepositoryModelStatus(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return { + "ready": (bool,), # noqa: E501 + "state": (str,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "ready": "ready", # noqa: E501 + "state": "state", # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], ready, state, *args, **kwargs) -> T: # noqa: E501 + """RepositoryModelStatus - a model defined in OpenAPI + + Args: + ready (bool): + state (str): The state of the repository. Possible values: `Initializing`, `InitializationFailed`, `Terminating`, `Ready`, or `Disabled`. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.ready = ready + self.state = state + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, ready, state, *args, **kwargs) -> None: # noqa: E501 + """RepositoryModelStatus - a model defined in OpenAPI + + Args: + ready (bool): + state (str): The state of the repository. Possible values: `Initializing`, `InitializationFailed`, `Terminating`, `Ready`, or `Disabled`. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.ready = ready + self.state = state + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/repository_control/model/repository_spec.py b/pinecone/core/openapi/repository_control/model/repository_spec.py new file mode 100644 index 00000000..fe84c9dc --- /dev/null +++ b/pinecone/core/openapi/repository_control/model/repository_spec.py @@ -0,0 +1,271 @@ +""" +Pinecone Control Plane API for Repositories + +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_control.model.serverless_spec import ServerlessSpec + + globals()["ServerlessSpec"] = ServerlessSpec + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="RepositorySpec") + + +class RepositorySpec(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + additional_properties_type = None + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + "serverless": (ServerlessSpec,) # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "serverless": "serverless" # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 + """RepositorySpec - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + serverless (ServerlessSpec): [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, *args, **kwargs) -> None: # noqa: E501 + """RepositorySpec - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + serverless (ServerlessSpec): [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/repository_control/model/serverless_spec.py b/pinecone/core/openapi/repository_control/model/serverless_spec.py new file mode 100644 index 00000000..6110aa02 --- /dev/null +++ b/pinecone/core/openapi/repository_control/model/serverless_spec.py @@ -0,0 +1,282 @@ +""" +Pinecone Control Plane API for Repositories + +Pinecone Repositories make it easy to search and retrieve billions of documents using lexical and semantic search. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: unstable +Contact: support@pinecone.io +""" + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="ServerlessSpec") + + +class ServerlessSpec(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return (bool, dict, float, int, list, str, none_type) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return { + "cloud": (str,), # noqa: E501 + "region": (str,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + attribute_map: Dict[str, str] = { + "cloud": "cloud", # noqa: E501 + "region": "region", # noqa: E501 + } + + read_only_vars: Set[str] = set([]) + + _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], cloud, region, *args, **kwargs) -> T: # noqa: E501 + """ServerlessSpec - a model defined in OpenAPI + + Args: + cloud (str): The public cloud where you would like your repository hosted. + region (str): The region where you would like your repository to be created. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) + _enforce_validations = kwargs.pop("_enforce_validations", False) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.cloud = cloud + self.region = region + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set( + [ + "_enforce_allowed_values", + "_enforce_validations", + "_data_store", + "_check_type", + "_spec_property_naming", + "_path_to_item", + "_configuration", + "_visited_composed_classes", + ] + ) + + @convert_js_args_to_python_args + def __init__(self, cloud, region, *args, **kwargs) -> None: # noqa: E501 + """ServerlessSpec - a model defined in OpenAPI + + Args: + cloud (str): The public cloud where you would like your repository hosted. + region (str): The region where you would like your repository to be created. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop("_enforce_validations", True) + _check_type = kwargs.pop("_check_type", True) + _spec_property_naming = kwargs.pop("_spec_property_naming", False) + _path_to_item = kwargs.pop("_path_to_item", ()) + _configuration = kwargs.pop("_configuration", None) + _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." + % (args, self.__class__.__name__), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.cloud = cloud + self.region = region + for var_name, var_value in kwargs.items(): + if ( + var_name not in self.attribute_map + and self._configuration is not None + and self._configuration.discard_unknown_keys + and self.additional_properties_type is None + ): + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError( + f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes." + ) diff --git a/pinecone/core/openapi/repository_control/models/__init__.py b/pinecone/core/openapi/repository_control/models/__init__.py new file mode 100644 index 00000000..200da3d2 --- /dev/null +++ b/pinecone/core/openapi/repository_control/models/__init__.py @@ -0,0 +1,28 @@ +# flake8: noqa + +# import all models into this package +# if you have many models here with many references from one model to another this may +# raise a RecursionError +# to avoid this, import only the models that you directly need like: +# from from pinecone.core.openapi.repository_control.model.pet import Pet +# or import this package, but before doing it, use: +# import sys +# sys.setrecursionlimit(n) + +from pinecone.core.openapi.repository_control.model.create_repository_request import ( + CreateRepositoryRequest, +) +from pinecone.core.openapi.repository_control.model.document_schema import DocumentSchema +from pinecone.core.openapi.repository_control.model.document_schema_field_map import ( + DocumentSchemaFieldMap, +) +from pinecone.core.openapi.repository_control.model.error_response import ErrorResponse +from pinecone.core.openapi.repository_control.model.error_response_error import ErrorResponseError +from pinecone.core.openapi.repository_control.model.repository_list import RepositoryList +from pinecone.core.openapi.repository_control.model.repository_model import RepositoryModel +from pinecone.core.openapi.repository_control.model.repository_model_spec import RepositoryModelSpec +from pinecone.core.openapi.repository_control.model.repository_model_status import ( + RepositoryModelStatus, +) +from pinecone.core.openapi.repository_control.model.repository_spec import RepositorySpec +from pinecone.core.openapi.repository_control.model.serverless_spec import ServerlessSpec diff --git a/pinecone/core/openapi/ckb_knowledge_data/__init__.py b/pinecone/core/openapi/repository_data/__init__.py similarity index 82% rename from pinecone/core/openapi/ckb_knowledge_data/__init__.py rename to pinecone/core/openapi/repository_data/__init__.py index b00bb6f5..b661aaf5 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/__init__.py +++ b/pinecone/core/openapi/repository_data/__init__.py @@ -1,9 +1,9 @@ # flake8: noqa """ -Pinecone Knowledge Base Data Plane API +Pinecone Data Plane API for Repositories -Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 +Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 This file is @generated using OpenAPI. diff --git a/pinecone/core/openapi/repository_data/api/__init__.py b/pinecone/core/openapi/repository_data/api/__init__.py new file mode 100644 index 00000000..a5d112a6 --- /dev/null +++ b/pinecone/core/openapi/repository_data/api/__init__.py @@ -0,0 +1,3 @@ +# do not import all apis into this module because that uses a lot of memory and stack frames +# if you need the ability to import all apis from one package, import them with +# from pinecone.core.openapi.repository_data.apis import DocumentOperationsApi diff --git a/pinecone/core/openapi/ckb_knowledge_data/api/document_operations_api.py b/pinecone/core/openapi/repository_data/api/document_operations_api.py similarity index 89% rename from pinecone/core/openapi/ckb_knowledge_data/api/document_operations_api.py rename to pinecone/core/openapi/repository_data/api/document_operations_api.py index 9985bccd..3b7e585f 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/api/document_operations_api.py +++ b/pinecone/core/openapi/repository_data/api/document_operations_api.py @@ -1,7 +1,7 @@ """ -Pinecone Knowledge Base Data Plane API +Pinecone Data Plane API for Repositories -Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 +Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 This file is @generated using OpenAPI. @@ -23,15 +23,14 @@ none_type, validate_and_convert_types, ) -from pinecone.core.openapi.ckb_knowledge_data.model.delete_document_response import ( +from pinecone.core.openapi.repository_data.model.delete_document_response import ( DeleteDocumentResponse, ) -from pinecone.core.openapi.ckb_knowledge_data.model.document_for_upsert import DocumentForUpsert -from pinecone.core.openapi.ckb_knowledge_data.model.get_document_response import GetDocumentResponse -from pinecone.core.openapi.ckb_knowledge_data.model.list_document_response import ( - ListDocumentResponse, +from pinecone.core.openapi.repository_data.model.get_document_response import GetDocumentResponse +from pinecone.core.openapi.repository_data.model.list_documents_response import ( + ListDocumentsResponse, ) -from pinecone.core.openapi.ckb_knowledge_data.model.upsert_document_response import ( +from pinecone.core.openapi.repository_data.model.upsert_document_response import ( UpsertDocumentResponse, ) @@ -93,7 +92,7 @@ def __delete_document(self, namespace, document_id, **kwargs: ExtraOpenApiKwargs settings={ "response_type": (DeleteDocumentResponse,), "auth": ["ApiKeyAuth"], - "endpoint_path": "/namespaces/{namespace}/documents/{document_id}", + "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents/{document_id}", "operation_id": "delete_document", "http_method": "DELETE", "servers": None, @@ -164,7 +163,7 @@ def __get_document(self, namespace, document_id, **kwargs: ExtraOpenApiKwargsTyp settings={ "response_type": (GetDocumentResponse,), "auth": ["ApiKeyAuth"], - "endpoint_path": "/namespaces/{namespace}/documents/{document_id}", + "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents/{document_id}", "operation_id": "get_document", "http_method": "GET", "servers": None, @@ -221,7 +220,7 @@ def __list_documents(self, namespace, **kwargs: ExtraOpenApiKwargsTypedDict): async_req (bool): execute request asynchronously Returns: - ListDocumentResponse + ListDocumentsResponse If the method is called asynchronously, returns the request thread. """ @@ -231,9 +230,9 @@ def __list_documents(self, namespace, **kwargs: ExtraOpenApiKwargsTypedDict): self.list_documents = _Endpoint( settings={ - "response_type": (ListDocumentResponse,), + "response_type": (ListDocumentsResponse,), "auth": ["ApiKeyAuth"], - "endpoint_path": "/namespaces/{namespace}/documents", + "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents", "operation_id": "list_documents", "http_method": "GET", "servers": None, @@ -258,21 +257,19 @@ def __list_documents(self, namespace, **kwargs: ExtraOpenApiKwargsTypedDict): callable=__list_documents, ) - def __upsert_document( - self, namespace, document_for_upsert, **kwargs: ExtraOpenApiKwargsTypedDict - ): + def __upsert_document(self, namespace, request_body, **kwargs: ExtraOpenApiKwargsTypedDict): """Create or update a document in the given namespace # noqa: E501 Upserts a document into the specified namespace. The request body may contain any valid JSON document that conforms to the schema. Optionally, an `_id` field can be provided to use as the document's identifier; if omitted, the system will assign one. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True - >>> thread = api.upsert_document(namespace, document_for_upsert, async_req=True) + >>> thread = api.upsert_document(namespace, request_body, async_req=True) >>> result = thread.get() Args: namespace (str): Namespace where the document will be stored. - document_for_upsert (DocumentForUpsert): + request_body ({str: (bool, dict, float, int, list, str, none_type)}): Keyword Args: _return_http_data_only (bool): response data without head status @@ -299,21 +296,21 @@ def __upsert_document( """ kwargs = self._process_openapi_kwargs(kwargs) kwargs["namespace"] = namespace - kwargs["document_for_upsert"] = document_for_upsert + kwargs["request_body"] = request_body return self.call_with_http_info(**kwargs) self.upsert_document = _Endpoint( settings={ "response_type": (UpsertDocumentResponse,), "auth": ["ApiKeyAuth"], - "endpoint_path": "/namespaces/{namespace}/documents/upsert", + "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents/upsert", "operation_id": "upsert_document", "http_method": "POST", "servers": None, }, params_map={ - "all": ["namespace", "document_for_upsert"], - "required": ["namespace", "document_for_upsert"], + "all": ["namespace", "request_body"], + "required": ["namespace", "request_body"], "nullable": [], "enum": [], "validation": [], @@ -321,9 +318,12 @@ def __upsert_document( root_map={ "validations": {}, "allowed_values": {}, - "openapi_types": {"namespace": (str,), "document_for_upsert": (DocumentForUpsert,)}, + "openapi_types": { + "namespace": (str,), + "request_body": ({str: (bool, dict, float, int, list, str, none_type)},), + }, "attribute_map": {"namespace": "namespace"}, - "location_map": {"namespace": "path", "document_for_upsert": "body"}, + "location_map": {"namespace": "path", "request_body": "body"}, "collection_format_map": {}, }, headers_map={"accept": ["application/json"], "content_type": ["application/json"]}, @@ -382,7 +382,7 @@ async def __delete_document(self, namespace, document_id, **kwargs): settings={ "response_type": (DeleteDocumentResponse,), "auth": ["ApiKeyAuth"], - "endpoint_path": "/namespaces/{namespace}/documents/{document_id}", + "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents/{document_id}", "operation_id": "delete_document", "http_method": "DELETE", "servers": None, @@ -446,7 +446,7 @@ async def __get_document(self, namespace, document_id, **kwargs): settings={ "response_type": (GetDocumentResponse,), "auth": ["ApiKeyAuth"], - "endpoint_path": "/namespaces/{namespace}/documents/{document_id}", + "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents/{document_id}", "operation_id": "get_document", "http_method": "GET", "servers": None, @@ -498,7 +498,7 @@ async def __list_documents(self, namespace, **kwargs): Default is True. Returns: - ListDocumentResponse + ListDocumentsResponse """ self._process_openapi_kwargs(kwargs) kwargs["namespace"] = namespace @@ -506,9 +506,9 @@ async def __list_documents(self, namespace, **kwargs): self.list_documents = _AsyncioEndpoint( settings={ - "response_type": (ListDocumentResponse,), + "response_type": (ListDocumentsResponse,), "auth": ["ApiKeyAuth"], - "endpoint_path": "/namespaces/{namespace}/documents", + "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents", "operation_id": "list_documents", "http_method": "GET", "servers": None, @@ -533,7 +533,7 @@ async def __list_documents(self, namespace, **kwargs): callable=__list_documents, ) - async def __upsert_document(self, namespace, document_for_upsert, **kwargs): + async def __upsert_document(self, namespace, request_body, **kwargs): """Create or update a document in the given namespace # noqa: E501 Upserts a document into the specified namespace. The request body may contain any valid JSON document that conforms to the schema. Optionally, an `_id` field can be provided to use as the document's identifier; if omitted, the system will assign one. # noqa: E501 @@ -541,7 +541,7 @@ async def __upsert_document(self, namespace, document_for_upsert, **kwargs): Args: namespace (str): Namespace where the document will be stored. - document_for_upsert (DocumentForUpsert): + request_body ({str: (bool, dict, float, int, list, str, none_type)}): Keyword Args: _return_http_data_only (bool): response data without head status @@ -565,21 +565,21 @@ async def __upsert_document(self, namespace, document_for_upsert, **kwargs): """ self._process_openapi_kwargs(kwargs) kwargs["namespace"] = namespace - kwargs["document_for_upsert"] = document_for_upsert + kwargs["request_body"] = request_body return await self.call_with_http_info(**kwargs) self.upsert_document = _AsyncioEndpoint( settings={ "response_type": (UpsertDocumentResponse,), "auth": ["ApiKeyAuth"], - "endpoint_path": "/namespaces/{namespace}/documents/upsert", + "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents/upsert", "operation_id": "upsert_document", "http_method": "POST", "servers": None, }, params_map={ - "all": ["namespace", "document_for_upsert"], - "required": ["namespace", "document_for_upsert"], + "all": ["namespace", "request_body"], + "required": ["namespace", "request_body"], "nullable": [], "enum": [], "validation": [], @@ -587,9 +587,12 @@ async def __upsert_document(self, namespace, document_for_upsert, **kwargs): root_map={ "validations": {}, "allowed_values": {}, - "openapi_types": {"namespace": (str,), "document_for_upsert": (DocumentForUpsert,)}, + "openapi_types": { + "namespace": (str,), + "request_body": ({str: (bool, dict, float, int, list, str, none_type)},), + }, "attribute_map": {"namespace": "namespace"}, - "location_map": {"namespace": "path", "document_for_upsert": "body"}, + "location_map": {"namespace": "path", "request_body": "body"}, "collection_format_map": {}, }, headers_map={"accept": ["application/json"], "content_type": ["application/json"]}, diff --git a/pinecone/core/openapi/ckb_knowledge_data/apis/__init__.py b/pinecone/core/openapi/repository_data/apis/__init__.py similarity index 79% rename from pinecone/core/openapi/ckb_knowledge_data/apis/__init__.py rename to pinecone/core/openapi/repository_data/apis/__init__.py index e9aaf036..44f505a0 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/apis/__init__.py +++ b/pinecone/core/openapi/repository_data/apis/__init__.py @@ -13,6 +13,4 @@ # sys.setrecursionlimit(n) # Import APIs into API package: -from pinecone.core.openapi.ckb_knowledge_data.api.document_operations_api import ( - DocumentOperationsApi, -) +from pinecone.core.openapi.repository_data.api.document_operations_api import DocumentOperationsApi diff --git a/pinecone/core/openapi/repository_data/model/__init__.py b/pinecone/core/openapi/repository_data/model/__init__.py new file mode 100644 index 00000000..cfe32b78 --- /dev/null +++ b/pinecone/core/openapi/repository_data/model/__init__.py @@ -0,0 +1,5 @@ +# we can not import model classes here because that would create a circular +# reference which would not work in python2 +# do not import all models into this module because that uses a lot of memory and stack frames +# if you need the ability to import all models from one package, import them with +# from {{packageName}.models import ModelA, ModelB diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/delete_document_response.py b/pinecone/core/openapi/repository_data/model/delete_document_response.py similarity index 97% rename from pinecone/core/openapi/ckb_knowledge_data/model/delete_document_response.py rename to pinecone/core/openapi/repository_data/model/delete_document_response.py index 8de62577..f1607674 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/model/delete_document_response.py +++ b/pinecone/core/openapi/repository_data/model/delete_document_response.py @@ -1,7 +1,7 @@ """ -Pinecone Knowledge Base Data Plane API +Pinecone Data Plane API for Repositories -Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 +Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 This file is @generated using OpenAPI. @@ -28,8 +28,8 @@ def lazy_import(): - from pinecone.core.openapi.ckb_knowledge_data.model.lsn_status import LSNStatus - from pinecone.core.openapi.ckb_knowledge_data.model.usage import Usage + from pinecone.core.openapi.repository_data.model.lsn_status import LSNStatus + from pinecone.core.openapi.repository_data.model.usage import Usage globals()["LSNStatus"] = LSNStatus globals()["Usage"] = Usage diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/document.py b/pinecone/core/openapi/repository_data/model/document.py similarity index 98% rename from pinecone/core/openapi/ckb_knowledge_data/model/document.py rename to pinecone/core/openapi/repository_data/model/document.py index e6b69feb..46ac58c3 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/model/document.py +++ b/pinecone/core/openapi/repository_data/model/document.py @@ -1,7 +1,7 @@ """ -Pinecone Knowledge Base Data Plane API +Pinecone Data Plane API for Repositories -Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 +Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 This file is @generated using OpenAPI. diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/document_list.py b/pinecone/core/openapi/repository_data/model/document_list.py similarity index 96% rename from pinecone/core/openapi/ckb_knowledge_data/model/document_list.py rename to pinecone/core/openapi/repository_data/model/document_list.py index aafffb50..55532fc5 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/model/document_list.py +++ b/pinecone/core/openapi/repository_data/model/document_list.py @@ -1,7 +1,7 @@ """ -Pinecone Knowledge Base Data Plane API +Pinecone Data Plane API for Repositories -Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 +Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 This file is @generated using OpenAPI. @@ -28,7 +28,7 @@ def lazy_import(): - from pinecone.core.openapi.ckb_knowledge_data.model.document import Document + from pinecone.core.openapi.repository_data.model.document import Document globals()["Document"] = Document @@ -119,10 +119,10 @@ def __init__(self, *args, **kwargs) -> None: Note that value can be passed either in args or in kwargs, but not in both. Args: - args[0] ([Document]): The list of documents that exist in the knowledge base/namespace.. # noqa: E501 + args[0] ([Document]): The list of documents that exist in the Repository namespace.. # noqa: E501 Keyword Args: - value ([Document]): The list of documents that exist in the knowledge base/namespace.. # noqa: E501 + value ([Document]): The list of documents that exist in the Repository namespace.. # noqa: E501 _check_type (bool): if True, values for parameters in openapi_types will be type checked and a TypeError will be raised if the wrong type is input. @@ -211,10 +211,10 @@ def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: Note that value can be passed either in args or in kwargs, but not in both. Args: - args[0] ([Document]): The list of documents that exist in the knowledge base/namespace. # noqa: E501 + args[0] ([Document]): The list of documents that exist in the Repository namespace. # noqa: E501 Keyword Args: - value ([Document]): The list of documents that exist in the knowledge base/namespace. # noqa: E501 + value ([Document]): The list of documents that exist in the Repository namespace. # noqa: E501 _check_type (bool): if True, values for parameters in openapi_types will be type checked and a TypeError will be raised if the wrong type is input. diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/get_document_response.py b/pinecone/core/openapi/repository_data/model/get_document_response.py similarity index 96% rename from pinecone/core/openapi/ckb_knowledge_data/model/get_document_response.py rename to pinecone/core/openapi/repository_data/model/get_document_response.py index f7197fe1..7ff1afb3 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/model/get_document_response.py +++ b/pinecone/core/openapi/repository_data/model/get_document_response.py @@ -1,7 +1,7 @@ """ -Pinecone Knowledge Base Data Plane API +Pinecone Data Plane API for Repositories -Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 +Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 This file is @generated using OpenAPI. @@ -28,9 +28,9 @@ def lazy_import(): - from pinecone.core.openapi.ckb_knowledge_data.model.document import Document - from pinecone.core.openapi.ckb_knowledge_data.model.lsn_status import LSNStatus - from pinecone.core.openapi.ckb_knowledge_data.model.usage import Usage + from pinecone.core.openapi.repository_data.model.document import Document + from pinecone.core.openapi.repository_data.model.lsn_status import LSNStatus + from pinecone.core.openapi.repository_data.model.usage import Usage globals()["Document"] = Document globals()["LSNStatus"] = LSNStatus diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/list_document_response.py b/pinecone/core/openapi/repository_data/model/list_documents_response.py similarity index 94% rename from pinecone/core/openapi/ckb_knowledge_data/model/list_document_response.py rename to pinecone/core/openapi/repository_data/model/list_documents_response.py index 340a894e..ee953eff 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/model/list_document_response.py +++ b/pinecone/core/openapi/repository_data/model/list_documents_response.py @@ -1,7 +1,7 @@ """ -Pinecone Knowledge Base Data Plane API +Pinecone Data Plane API for Repositories -Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 +Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 This file is @generated using OpenAPI. @@ -28,12 +28,10 @@ def lazy_import(): - from pinecone.core.openapi.ckb_knowledge_data.model.document_list import DocumentList - from pinecone.core.openapi.ckb_knowledge_data.model.lsn_status import LSNStatus - from pinecone.core.openapi.ckb_knowledge_data.model.pagination_response import ( - PaginationResponse, - ) - from pinecone.core.openapi.ckb_knowledge_data.model.usage import Usage + from pinecone.core.openapi.repository_data.model.document_list import DocumentList + from pinecone.core.openapi.repository_data.model.lsn_status import LSNStatus + from pinecone.core.openapi.repository_data.model.pagination_response import PaginationResponse + from pinecone.core.openapi.repository_data.model.usage import Usage globals()["DocumentList"] = DocumentList globals()["LSNStatus"] = LSNStatus @@ -44,10 +42,10 @@ def lazy_import(): from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property -T = TypeVar("T", bound="ListDocumentResponse") +T = TypeVar("T", bound="ListDocumentsResponse") -class ListDocumentResponse(ModelNormal): +class ListDocumentsResponse(ModelNormal): """NOTE: This class is @generated using OpenAPI. Do not edit the class manually. @@ -128,7 +126,7 @@ def discriminator(cls): def _from_openapi_data( cls: Type[T], namespace, documents, usage, lsn_status, *args, **kwargs ) -> T: # noqa: E501 - """ListDocumentResponse - a model defined in OpenAPI + """ListDocumentsResponse - a model defined in OpenAPI Args: namespace (str): Namespace of the documents to fetch. @@ -228,7 +226,7 @@ def _from_openapi_data( @convert_js_args_to_python_args def __init__(self, namespace, documents, usage, lsn_status, *args, **kwargs) -> None: # noqa: E501 - """ListDocumentResponse - a model defined in OpenAPI + """ListDocumentsResponse - a model defined in OpenAPI Args: namespace (str): Namespace of the documents to fetch. diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/lsn_status.py b/pinecone/core/openapi/repository_data/model/lsn_status.py similarity index 98% rename from pinecone/core/openapi/ckb_knowledge_data/model/lsn_status.py rename to pinecone/core/openapi/repository_data/model/lsn_status.py index 3414f6e4..57489531 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/model/lsn_status.py +++ b/pinecone/core/openapi/repository_data/model/lsn_status.py @@ -1,7 +1,7 @@ """ -Pinecone Knowledge Base Data Plane API +Pinecone Data Plane API for Repositories -Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 +Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 This file is @generated using OpenAPI. diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/pagination_response.py b/pinecone/core/openapi/repository_data/model/pagination_response.py similarity index 98% rename from pinecone/core/openapi/ckb_knowledge_data/model/pagination_response.py rename to pinecone/core/openapi/repository_data/model/pagination_response.py index 3ce1852c..b1c11924 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/model/pagination_response.py +++ b/pinecone/core/openapi/repository_data/model/pagination_response.py @@ -1,7 +1,7 @@ """ -Pinecone Knowledge Base Data Plane API +Pinecone Data Plane API for Repositories -Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 +Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 This file is @generated using OpenAPI. diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/upsert_document_response.py b/pinecone/core/openapi/repository_data/model/upsert_document_response.py similarity index 98% rename from pinecone/core/openapi/ckb_knowledge_data/model/upsert_document_response.py rename to pinecone/core/openapi/repository_data/model/upsert_document_response.py index 0df0c51b..cf2215b5 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/model/upsert_document_response.py +++ b/pinecone/core/openapi/repository_data/model/upsert_document_response.py @@ -1,7 +1,7 @@ """ -Pinecone Knowledge Base Data Plane API +Pinecone Data Plane API for Repositories -Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 +Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 This file is @generated using OpenAPI. @@ -28,7 +28,7 @@ def lazy_import(): - from pinecone.core.openapi.ckb_knowledge_data.model.lsn_status import LSNStatus + from pinecone.core.openapi.repository_data.model.lsn_status import LSNStatus globals()["LSNStatus"] = LSNStatus diff --git a/pinecone/core/openapi/ckb_knowledge_data/model/usage.py b/pinecone/core/openapi/repository_data/model/usage.py similarity index 98% rename from pinecone/core/openapi/ckb_knowledge_data/model/usage.py rename to pinecone/core/openapi/repository_data/model/usage.py index 68f89e42..fa195ec9 100644 --- a/pinecone/core/openapi/ckb_knowledge_data/model/usage.py +++ b/pinecone/core/openapi/repository_data/model/usage.py @@ -1,7 +1,7 @@ """ -Pinecone Knowledge Base Data Plane API +Pinecone Data Plane API for Repositories -Pinecone Knowledge Base builds on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 +Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 This file is @generated using OpenAPI. diff --git a/pinecone/core/openapi/repository_data/models/__init__.py b/pinecone/core/openapi/repository_data/models/__init__.py new file mode 100644 index 00000000..2615558e --- /dev/null +++ b/pinecone/core/openapi/repository_data/models/__init__.py @@ -0,0 +1,26 @@ +# flake8: noqa + +# import all models into this package +# if you have many models here with many references from one model to another this may +# raise a RecursionError +# to avoid this, import only the models that you directly need like: +# from from pinecone.core.openapi.repository_data.model.pet import Pet +# or import this package, but before doing it, use: +# import sys +# sys.setrecursionlimit(n) + +from pinecone.core.openapi.repository_data.model.delete_document_response import ( + DeleteDocumentResponse, +) +from pinecone.core.openapi.repository_data.model.document import Document +from pinecone.core.openapi.repository_data.model.document_list import DocumentList +from pinecone.core.openapi.repository_data.model.get_document_response import GetDocumentResponse +from pinecone.core.openapi.repository_data.model.lsn_status import LSNStatus +from pinecone.core.openapi.repository_data.model.list_documents_response import ( + ListDocumentsResponse, +) +from pinecone.core.openapi.repository_data.model.pagination_response import PaginationResponse +from pinecone.core.openapi.repository_data.model.upsert_document_response import ( + UpsertDocumentResponse, +) +from pinecone.core.openapi.repository_data.model.usage import Usage From a330b63002ca3a2f5133f439ae96d9f4d0babddc Mon Sep 17 00:00:00 2001 From: Silas Smith <163026730+ssmith-pc@users.noreply.github.com> Date: Sun, 28 Sep 2025 22:35:17 -0700 Subject: [PATCH 3/4] [ce] repository control plane and data plane (#520) ## Problem First pass implementation of control plane SDK for repositories. Also includes a basic data plane impl that avoids using the OpenAPI generated types due to Document being such an open-ended type. More work is needed here ```python pc = Pinecone(api_key=os.getenv("PINECONE_API_KEY")) repo_name = "aryn-parsed-example-8" repo_model = pc.create_repository( name=f"{repo_name}", spec={ "serverless": { "cloud": "aws", "region": "us-east-1", }, }, schema={ "fields": { "$.parsed[*].text_representation": { "description": "Text representation of the chunk", "embedded": True, }, }, }, timeout=300, ) repo_model = pc.describe_repository(name=repo_name) # data plane repo = pc.Repository(host=repo_model.host) document = get_document() response = repo.upsert( namespace="foo", document=document, echo=True, ) pc.delete_repository(name=repo_name, timeout=300) ``` ## Solution Describe the approach you took. Link to any relevant bugs, issues, docs, or other resources. ## Type of Change - [ ] Bug fix (non-breaking change which fixes an issue) - [ ] New feature (non-breaking change which adds functionality) - [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) - [ ] This change requires a documentation update - [ ] Infrastructure change (CI configs, etc) - [ ] Non-code change (docs, etc) - [ ] None of the above: (explain here) ## Test Plan Describe specific steps for validating this change. --------- Co-authored-by: rohanshah18 --- pinecone/pinecone.py | 68 +++++ pinecone/repository_control/__init__.py | 18 ++ .../repository_control/models/__init__.py | 14 ++ .../models/document_schema.py | 24 ++ .../models/repository_description.py | 10 + .../models/repository_list.py | 34 +++ .../models/repository_model.py | 24 ++ .../models/serverless_spec.py | 25 ++ .../repository_control/repository_control.py | 60 +++++ .../repository_host_store.py | 53 ++++ .../repository_control/request_factory.py | 82 ++++++ .../resources/sync/repository.py | 142 +++++++++++ pinecone/repository_data/__init__.py | 14 ++ pinecone/repository_data/models/__init__.py | 4 + pinecone/repository_data/models/document.py | 79 ++++++ pinecone/repository_data/repository.py | 235 ++++++++++++++++++ poetry.lock | 175 +++++++++++-- pyproject.toml | 1 + 18 files changed, 1044 insertions(+), 18 deletions(-) create mode 100644 pinecone/repository_control/__init__.py create mode 100644 pinecone/repository_control/models/__init__.py create mode 100644 pinecone/repository_control/models/document_schema.py create mode 100644 pinecone/repository_control/models/repository_description.py create mode 100644 pinecone/repository_control/models/repository_list.py create mode 100644 pinecone/repository_control/models/repository_model.py create mode 100644 pinecone/repository_control/models/serverless_spec.py create mode 100644 pinecone/repository_control/repository_control.py create mode 100644 pinecone/repository_control/repository_host_store.py create mode 100644 pinecone/repository_control/request_factory.py create mode 100644 pinecone/repository_control/resources/sync/repository.py create mode 100644 pinecone/repository_data/__init__.py create mode 100644 pinecone/repository_data/models/__init__.py create mode 100644 pinecone/repository_data/models/document.py create mode 100644 pinecone/repository_data/repository.py diff --git a/pinecone/pinecone.py b/pinecone/pinecone.py index d8c8a1b4..bb956995 100644 --- a/pinecone/pinecone.py +++ b/pinecone/pinecone.py @@ -16,6 +16,7 @@ if TYPE_CHECKING: from pinecone.config import Config, OpenApiConfiguration from pinecone.db_data import _Index as Index, _IndexAsyncio as IndexAsyncio + from pinecone.repository_data import _Repository as Repository from pinecone.db_control.index_host_store import IndexHostStore from pinecone.core.openapi.db_control.api.manage_indexes_api import ManageIndexesApi from pinecone.db_control.types import CreateIndexForModelEmbedTypedDict, ConfigureIndexEmbed @@ -42,6 +43,7 @@ RestoreJobModel, RestoreJobList, ) + from pinecone.repository_control.models import RepositoryModel, RepositoryList, DocumentSchema class Pinecone(PluginAware, LegacyPineconeDBControlInterface): @@ -241,6 +243,9 @@ def __init__( self._db_control = None # Lazy initialization """ :meta private: """ + self._repository_control = None # Lazy initialization + """ :meta private: """ + super().__init__() # Initialize PluginAware @property @@ -273,6 +278,21 @@ def db(self): ) return self._db_control + @property + def repository_ctrl(self): + """ + RepositoryControl is a namespace where an instance of the `pinecone.repository_control.RepositoryControl` class is lazily created and cached. + """ + if self._repository_control is None: + from pinecone.repository_control.repository_control import RepositoryControl + + self._repository_control = RepositoryControl( + config=self._config, + openapi_config=self._openapi_config, + pool_threads=self._pool_threads, + ) + return self._repository_control + @property def index_host_store(self) -> "IndexHostStore": """:meta private:""" @@ -460,6 +480,26 @@ def list_restore_jobs( def describe_restore_job(self, *, job_id: str) -> "RestoreJobModel": return self.db.restore_job.describe(job_id=job_id) + def create_repository( + self, + name: str, + spec: Union[Dict, "ServerlessSpec"], + schema: Union[Dict, "DocumentSchema"], + timeout: Optional[int] = None, + ) -> "RepositoryModel": + return self.repository_ctrl.repository.create( + name=name, spec=spec, schema=schema, timeout=timeout + ) + + def describe_repository(self, name: str) -> "RepositoryModel": + return self.repository_ctrl.repository.describe(name=name) + + def list_repositories(self) -> "RepositoryList": + return self.repository_ctrl.repository.list() + + def delete_repository(self, name: str, timeout: Optional[int] = None): + return self.repository_ctrl.repository.delete(name=name, timeout=timeout) + @staticmethod def from_texts(*args, **kwargs): """:meta private:""" @@ -518,6 +558,34 @@ def IndexAsyncio(self, host: str, **kwargs) -> "IndexAsyncio": **kwargs, ) + def Repository(self, name: str = "", host: str = "", **kwargs) -> "Repository": + from pinecone.repository_data import _Repository + + if name == "" and host == "": + raise ValueError("Either name or host must be specified") + + pt = kwargs.pop("pool_threads", None) or self._pool_threads + api_key = self._config.api_key + openapi_config = self._openapi_config + + if host != "": + check_realistic_host(host) + + # Use host url if it is provided + repository_host = normalize_host(host) + else: + # Otherwise, get host url from describe_repository using the repo name + repository_host = self.repository_ctrl.repository._get_host(name) + + return _Repository( + host=repository_host, + api_key=api_key, + pool_threads=pt, + openapi_config=openapi_config, + source_tag=self.config.source_tag, + **kwargs, + ) + def check_realistic_host(host: str) -> None: """:meta private: diff --git a/pinecone/repository_control/__init__.py b/pinecone/repository_control/__init__.py new file mode 100644 index 00000000..da45caec --- /dev/null +++ b/pinecone/repository_control/__init__.py @@ -0,0 +1,18 @@ +from .models import * +from .repository_control import RepositoryControl +from pinecone.db_control.enums import * + +__all__ = [ + # from pinecone.db_control.enums + "CloudProvider", + "AwsRegion", + "GcpRegion", + "AzureRegion", + # from .models + "ServerlessSpec", + "ServerlessSpecDefinition", + "RepositoryList", + "RepositoryModel", + # direct imports + "RepositoryControl", +] diff --git a/pinecone/repository_control/models/__init__.py b/pinecone/repository_control/models/__init__.py new file mode 100644 index 00000000..d55b830f --- /dev/null +++ b/pinecone/repository_control/models/__init__.py @@ -0,0 +1,14 @@ +from .document_schema import DocumentSchema +from .repository_description import ServerlessSpecDefinition +from .repository_list import RepositoryList +from .repository_model import RepositoryModel +from .serverless_spec import ServerlessSpec + + +__all__ = [ + "DocumentSchema", + "ServerlessSpec", + "ServerlessSpecDefinition", + "RepositoryList", + "RepositoryModel", +] diff --git a/pinecone/repository_control/models/document_schema.py b/pinecone/repository_control/models/document_schema.py new file mode 100644 index 00000000..eb5e6b86 --- /dev/null +++ b/pinecone/repository_control/models/document_schema.py @@ -0,0 +1,24 @@ +from pinecone.core.openapi.repository_control.model.document_schema import ( + DocumentSchema as OpenAPIDocumentSchema, +) +import json + + +class DocumentSchema: + def __init__(self, schema: OpenAPIDocumentSchema): + self.schema = schema + + def __str__(self): + return str(self.schema) + + def __getattr__(self, attr): + return getattr(self.schema, attr) + + def __getitem__(self, key): + return self.__getattr__(key) + + def __repr__(self): + return json.dumps(self.to_dict(), indent=4) + + def to_dict(self): + return self.schema.to_dict() diff --git a/pinecone/repository_control/models/repository_description.py b/pinecone/repository_control/models/repository_description.py new file mode 100644 index 00000000..75004e7b --- /dev/null +++ b/pinecone/repository_control/models/repository_description.py @@ -0,0 +1,10 @@ +from typing import NamedTuple, Dict, Literal + + +class ServerlessSpecDefinition(NamedTuple): + cloud: str + region: str + + +ServerlessKey = Literal["serverless"] +ServerlessSpec = Dict[ServerlessKey, ServerlessSpecDefinition] diff --git a/pinecone/repository_control/models/repository_list.py b/pinecone/repository_control/models/repository_list.py new file mode 100644 index 00000000..6e9ae86d --- /dev/null +++ b/pinecone/repository_control/models/repository_list.py @@ -0,0 +1,34 @@ +import json +from pinecone.core.openapi.repository_control.model.repository_list import ( + RepositoryList as OpenAPIRepositoryList, +) +from .repository_model import RepositoryModel +from typing import List + + +class RepositoryList: + def __init__(self, repository_list: OpenAPIRepositoryList): + self.repository_list = repository_list + self.repositories = [RepositoryModel(i) for i in self.repository_list.repositories] + self.current = 0 + + def names(self) -> List[str]: + return [i.name for i in self.repositories] + + def __getitem__(self, key): + return self.repositories[key] + + def __len__(self): + return len(self.repositories) + + def __iter__(self): + return iter(self.repositories) + + def __str__(self): + return str(self.repositories) + + def __repr__(self): + return json.dumps([i.to_dict() for i in self.repositories], indent=4) + + def __getattr__(self, attr): + return getattr(self.repository_list, attr) diff --git a/pinecone/repository_control/models/repository_model.py b/pinecone/repository_control/models/repository_model.py new file mode 100644 index 00000000..d410d6fa --- /dev/null +++ b/pinecone/repository_control/models/repository_model.py @@ -0,0 +1,24 @@ +from pinecone.core.openapi.repository_control.model.repository_model import ( + RepositoryModel as OpenAPIRepositoryModel, +) +import json + + +class RepositoryModel: + def __init__(self, repository: OpenAPIRepositoryModel): + self.repository = repository + + def __str__(self): + return str(self.repository) + + def __getattr__(self, attr): + return getattr(self.repository, attr) + + def __getitem__(self, key): + return self.__getattr__(key) + + def __repr__(self): + return json.dumps(self.to_dict(), indent=4) + + def to_dict(self): + return self.repository.to_dict() diff --git a/pinecone/repository_control/models/serverless_spec.py b/pinecone/repository_control/models/serverless_spec.py new file mode 100644 index 00000000..b18849b8 --- /dev/null +++ b/pinecone/repository_control/models/serverless_spec.py @@ -0,0 +1,25 @@ +from dataclasses import dataclass +from typing import Union +from enum import Enum + +from pinecone.db_control.enums import CloudProvider, AwsRegion, GcpRegion, AzureRegion + + +@dataclass(frozen=True) +class ServerlessSpec: + cloud: str + region: str + + def __init__( + self, + cloud: Union[CloudProvider, str], + region: Union[AwsRegion, GcpRegion, AzureRegion, str], + ): + # Convert Enums to their string values if necessary + object.__setattr__(self, "cloud", cloud.value if isinstance(cloud, Enum) else str(cloud)) + object.__setattr__( + self, "region", region.value if isinstance(region, Enum) else str(region) + ) + + def asdict(self): + return {"serverless": {"cloud": self.cloud, "region": self.region}} diff --git a/pinecone/repository_control/repository_control.py b/pinecone/repository_control/repository_control.py new file mode 100644 index 00000000..37468744 --- /dev/null +++ b/pinecone/repository_control/repository_control.py @@ -0,0 +1,60 @@ +import logging +from typing import Optional, TYPE_CHECKING + +from pinecone.core.openapi.repository_control.api.manage_repositories_api import ( + ManageRepositoriesApi, +) +from pinecone.openapi_support.api_client import ApiClient + +from pinecone.utils import setup_openapi_client, PluginAware +from pinecone.core.openapi.repository_control import API_VERSION + + +logger = logging.getLogger(__name__) +""" :meta private: """ + +if TYPE_CHECKING: + from .resources.sync.repository import RepositoryResource + from pinecone.config import Config, OpenApiConfiguration + + +class RepositoryControl(PluginAware): + def __init__( + self, config: "Config", openapi_config: "OpenApiConfiguration", pool_threads: int + ) -> None: + self.config = config + """ :meta private: """ + + self._openapi_config = openapi_config + """ :meta private: """ + + self._pool_threads = pool_threads + """ :meta private: """ + + self._repository_api = setup_openapi_client( + api_client_klass=ApiClient, + api_klass=ManageRepositoriesApi, + config=self.config, + openapi_config=self._openapi_config, + pool_threads=self._pool_threads, + api_version=API_VERSION, + ) + """ :meta private: """ + + self._repository_resource: Optional["RepositoryResource"] = None + """ :meta private: """ + + super().__init__() # Initialize PluginAware + + @property + def repository(self) -> "RepositoryResource": + if self._repository_resource is None: + from .resources.sync.repository import RepositoryResource + + self._repository_resource = RepositoryResource( + repository_api=self._repository_api, + config=self.config, + openapi_config=self._openapi_config, + pool_threads=self._pool_threads, + ) + return self._repository_resource diff --git a/pinecone/repository_control/repository_host_store.py b/pinecone/repository_control/repository_host_store.py new file mode 100644 index 00000000..bcb93527 --- /dev/null +++ b/pinecone/repository_control/repository_host_store.py @@ -0,0 +1,53 @@ +from typing import Dict +from pinecone.config import Config +from pinecone.core.openapi.repository_control.api.manage_repositories_api import ( + ManageRepositoriesApi as RepositoriesOperationsApi, +) +from pinecone.openapi_support.exceptions import PineconeException +from pinecone.utils import normalize_host + + +class SingletonMeta(type): + _instances: Dict[str, str] = {} + + def __call__(cls, *args, **kwargs): + if cls not in cls._instances: + instance = super().__call__(*args, **kwargs) + cls._instances[cls] = instance + return cls._instances[cls] + + +class RepositoryHostStore(metaclass=SingletonMeta): + _repositoryHosts: Dict[str, str] + + def __init__(self) -> None: + self._repositoryHosts = {} + + def _key(self, config: Config, repository_name: str) -> str: + return ":".join([config.api_key, repository_name]) + + def delete_host(self, config: Config, repository_name: str): + key = self._key(config, repository_name) + if key in self._repositoryHosts: + del self._repositoryHosts[key] + + def key_exists(self, key: str) -> bool: + return key in self._repositoryHosts + + def set_host(self, config: Config, repository_name: str, host: str): + if host: + key = self._key(config, repository_name) + self._repositoryHosts[key] = normalize_host(host) + + def get_host(self, api: RepositoriesOperationsApi, config: Config, repository_name: str) -> str: + key = self._key(config, repository_name) + if self.key_exists(key): + return self._repositoryHosts[key] + else: + description = api.describe_repository(repository_name) + self.set_host(config, repository_name, description.host) + if not self.key_exists(key): + raise PineconeException( + f"Could not get host for repository: {repository_name}. Call describe_repository('{repository_name}') to check the current status." + ) + return self._repositoryHosts[key] diff --git a/pinecone/repository_control/request_factory.py b/pinecone/repository_control/request_factory.py new file mode 100644 index 00000000..590d7773 --- /dev/null +++ b/pinecone/repository_control/request_factory.py @@ -0,0 +1,82 @@ +import logging +from typing import Dict, Union + +from pinecone.utils import parse_non_empty_args, convert_enum_to_string + +from pinecone.core.openapi.repository_control.model.create_repository_request import ( + CreateRepositoryRequest as OpenAPICreateRepositoryRequest, +) +from pinecone.core.openapi.repository_control.model.repository_spec import ( + RepositorySpec as OpenAPIRepositorySpec, +) +from pinecone.core.openapi.repository_control.model.serverless_spec import ( + ServerlessSpec as OpenAPIServerlessSpec, +) +from pinecone.core.openapi.repository_control.model.document_schema import ( + DocumentSchema as OpenAPIDocumentSchema, +) +from pinecone.core.openapi.repository_control.model.document_schema_field_map import ( + DocumentSchemaFieldMap as OpenAPIDocumentSchemaFieldMap, +) +from pinecone.repository_control.models.serverless_spec import ServerlessSpec +from pinecone.repository_control.models.document_schema import DocumentSchema + + +logger = logging.getLogger(__name__) +""" :meta private: """ + + +class PineconeRepositoryControlRequestFactory: + """ + :meta private: + + This class facilitates translating user inputs into request objects. + """ + + @staticmethod + def __parse_repository_spec(spec: Union[Dict, ServerlessSpec]) -> OpenAPIRepositorySpec: + if isinstance(spec, dict): + if "serverless" in spec: + spec["serverless"]["cloud"] = convert_enum_to_string(spec["serverless"]["cloud"]) + spec["serverless"]["region"] = convert_enum_to_string(spec["serverless"]["region"]) + + repository_spec = OpenAPIRepositorySpec( + serverless=OpenAPIServerlessSpec(**spec["serverless"]) + ) + else: + raise ValueError("spec must contain a 'serverless' key") + elif isinstance(spec, ServerlessSpec): + repository_spec = OpenAPIRepositorySpec( + serverless=OpenAPIServerlessSpec(cloud=spec.cloud, region=spec.region) + ) + else: + raise TypeError("spec must be of type dict or ServerlessSpec") + + return repository_spec + + @staticmethod + def __parse_repository_schema(schema: Union[Dict, DocumentSchema]) -> OpenAPIDocumentSchema: + if isinstance(schema, dict): + if "fields" in schema: + openapi_schema = OpenAPIDocumentSchema( + fields=OpenAPIDocumentSchemaFieldMap(**schema["fields"]) + ) + return openapi_schema + else: + raise ValueError("schema must contain a 'fields' key") + elif isinstance(schema, DocumentSchema): + # Extract the OpenAPI schema from the wrapper + return schema.schema + else: + raise TypeError("schema must be of type dict or DocumentSchema") + + @staticmethod + def create_repository_request( + name: str, spec: Union[Dict, ServerlessSpec], schema: Union[Dict, DocumentSchema] + ) -> OpenAPICreateRepositoryRequest: + parsed_spec = PineconeRepositoryControlRequestFactory.__parse_repository_spec(spec) + parsed_schema = PineconeRepositoryControlRequestFactory.__parse_repository_schema(schema) + + args = parse_non_empty_args([("name", name), ("spec", parsed_spec), ("schema", parsed_schema)]) + + return OpenAPICreateRepositoryRequest(**args) diff --git a/pinecone/repository_control/resources/sync/repository.py b/pinecone/repository_control/resources/sync/repository.py new file mode 100644 index 00000000..f4ef8c90 --- /dev/null +++ b/pinecone/repository_control/resources/sync/repository.py @@ -0,0 +1,142 @@ +import time +import logging +from typing import Optional, Dict, Union, TYPE_CHECKING + +from pinecone.repository_control.repository_host_store import RepositoryHostStore + +from pinecone.repository_control.models import RepositoryModel, RepositoryList +from pinecone.utils import docslinks, require_kwargs, PluginAware + +from pinecone.repository_control.request_factory import PineconeRepositoryControlRequestFactory +from pinecone.core.openapi.repository_control import API_VERSION + +logger = logging.getLogger(__name__) +""" :meta private: """ + +if TYPE_CHECKING: + from pinecone.config import Config, OpenApiConfiguration + from pinecone.core.openapi.repository_control.api.manage_repositories_api import ( + ManageRepositoriesApi, + ) + from pinecone.repository_control.models import ServerlessSpec, DocumentSchema + + +class RepositoryResource(PluginAware): + def __init__( + self, + repository_api: "ManageRepositoriesApi", + config: "Config", + openapi_config: "OpenApiConfiguration", + pool_threads: int, + ): + self._repository_api = repository_api + """ :meta private: """ + + self.config = config + """ :meta private: """ + + self._openapi_config = openapi_config + """ :meta private: """ + + self._pool_threads = pool_threads + """ :meta private: """ + + self._repository_host_store = RepositoryHostStore() + """ :meta private: """ + + super().__init__() # Initialize PluginAware + + @require_kwargs + def create( + self, + *, + name: str, + spec: Union[Dict, "ServerlessSpec"], + schema: Union[Dict, "DocumentSchema"], + timeout: Optional[int] = None, + ) -> RepositoryModel: + req = PineconeRepositoryControlRequestFactory.create_repository_request( + name=name, spec=spec, schema=schema + ) + resp = self._repository_api.create_repository(create_repository_request=req) + + if timeout == -1: + return resp + return self.__poll_describe_repository_until_ready(name, timeout) + + def __poll_describe_repository_until_ready(self, name: str, timeout: Optional[int] = None): + total_wait_time = 0 + while True: + description = self.describe(name=name) + if description.status.state == "InitializationFailed": + raise Exception( + f"Repository {name} failed to initialize. The repository status is {description.status.state}." + ) + if description.status.ready: + return description + + if timeout is not None and total_wait_time >= timeout: + logger.error( + f"Repository {name} is not ready after {total_wait_time} seconds. Timeout reached." + ) + link = docslinks["API_DESCRIBE_REPOSITORY"](API_VERSION) + timeout_msg = f"Repository {name} is not ready after {total_wait_time} seconds. Please call describe_repository() to confirm repository status. See docs at {link}" + raise TimeoutError(timeout_msg) + + logger.debug( + f"Waiting for repository {name} to be ready. Total wait time {total_wait_time} seconds." + ) + + total_wait_time += 5 + time.sleep(5) + + @require_kwargs + def delete(self, *, name: str, timeout: Optional[int] = None) -> None: + self._repository_api.delete_repository(name) + self._repository_host_store.delete_host(self.config, name) + + if timeout == -1: + return + + if timeout is None: + while self.has(name=name): + time.sleep(5) + else: + while self.has(name=name) and timeout >= 0: + time.sleep(5) + timeout -= 5 + if timeout and timeout < 0: + raise ( + TimeoutError( + "Please call the list_repositories API ({}) to confirm if repository is deleted".format( + "https://www.pinecone.io/docs/api/operation/list_repositories/" + ) + ) + ) + + @require_kwargs + def list(self) -> RepositoryList: + response = self._repository_api.list_repositories() + return RepositoryList(response) + + @require_kwargs + def describe(self, *, name: str) -> RepositoryModel: + api_instance = self._repository_api + description = api_instance.describe_repository(name) + host = description.host + self._repository_host_store.set_host(self.config, name, host) + + return description + + @require_kwargs + def has(self, *, name: str) -> bool: + if name in self.list().names(): + return True + else: + return False + + def _get_host(self, name: str) -> str: + """:meta private:""" + return self._repository_host_store.get_host( + api=self._repository_api, config=self.config, repository_name=name + ) diff --git a/pinecone/repository_data/__init__.py b/pinecone/repository_data/__init__.py new file mode 100644 index 00000000..373bfebb --- /dev/null +++ b/pinecone/repository_data/__init__.py @@ -0,0 +1,14 @@ +from .repository import Repository +from .models.document import Document + + +_Repository = Repository # alias for backwards compatibility + + +__all__ = ["_Repository", "Document"] + + +def __getattr__(name): + if name in locals(): + return locals()[name] + raise AttributeError(f"module '{__name__}' has no attribute '{name}'") diff --git a/pinecone/repository_data/models/__init__.py b/pinecone/repository_data/models/__init__.py new file mode 100644 index 00000000..b6019f0f --- /dev/null +++ b/pinecone/repository_data/models/__init__.py @@ -0,0 +1,4 @@ +from .document import Document + + +__all__ = ["Document"] diff --git a/pinecone/repository_data/models/document.py b/pinecone/repository_data/models/document.py new file mode 100644 index 00000000..61bcbcd4 --- /dev/null +++ b/pinecone/repository_data/models/document.py @@ -0,0 +1,79 @@ +from typing import Any, Dict, Optional +from dataclasses import dataclass, field + + +# ----------------------- +# Model +# ----------------------- +@dataclass(frozen=True) +class Document: + """ + Lightweight model for a Repository document. + + _id is optional: it will be present for fetched/listed documents, + but not required when creating/upserting. + """ + + _id: Optional[str] = None + raw: Dict[str, Any] = field(default_factory=dict) + + @staticmethod + def _extract_id(payload: Dict[str, Any]) -> Optional[str]: + return payload.get("_id") + + @classmethod + def from_api(cls, payload: Dict[str, Any]) -> "Document": + if not isinstance(payload, dict): + raise TypeError("Document.from_api payload must be a dict") + + doc_id = cls._extract_id(payload) + if not doc_id: + raise ValueError("Document.from_api payload missing an '_id' field") + + return cls(_id=str(doc_id), raw=payload) + + @classmethod + def from_dict(cls, payload: Dict[str, Any]) -> "Document": + """ + Create a Document directly from a dict (e.g., user-supplied). + The dict must contain an '_id' field. + """ + if not isinstance(payload, dict): + raise TypeError("payload must be a dict.") + + doc_id = cls._extract_id(payload) # may be None + return cls(_id=str(doc_id), raw=dict(payload)) + + def to_dict(self) -> Dict[str, Any]: + """ + Convert the Document into a dict suitable for upsert. + """ + return dict(self.raw) + + def __str__(self) -> str: + truncate = 50 + as_str = self.raw.__str__() + return as_str[:truncate] + (" ... " if len(as_str) > truncate else "") + + def __repr__(self) -> str: + # Make a shallow copy of raw without the _id key (if present) + raw_copy = {k: v for k, v in self.raw.items() if k != "_id"} + + truncate = 50 + as_str = repr(raw_copy) + return ( + f"Document(_id={self._id!r}, raw={as_str[:truncate]}" + f"{' ... ' if len(as_str) > truncate else ''})" + ) + + def __getitem__(self, key: str) -> Any: + return self.raw[key] + + # attribute-style passthrough into raw + # e.g., doc.title instead of doc.raw["title"] + def __getattr__(self, attr: str) -> Any: + # __getattr__ is only called if normal attribute lookup fails + raw = object.__getattribute__(self, "raw") + if attr in raw: + return raw[attr] + raise AttributeError(f"{self.__class__.__name__!s} has no attribute {attr!r}") diff --git a/pinecone/repository_data/repository.py b/pinecone/repository_data/repository.py new file mode 100644 index 00000000..f72f79b5 --- /dev/null +++ b/pinecone/repository_data/repository.py @@ -0,0 +1,235 @@ +import logging +import json +from typing import Optional, Dict, List, Any, Tuple, Union +from urllib.parse import urljoin + +import requests +from requests.adapters import HTTPAdapter +from urllib3.util.retry import Retry +from multiprocessing import cpu_count +from pinecone.core.openapi.repository_data import API_VERSION +from .models.document import Document + +logger = logging.getLogger(__name__) + + +def _ensure_https_host(host: str) -> str: + """ + Normalizes the host value to include scheme and no trailing slash. + Accepts: "kb.example.com", "https://kb.example.com/", "http://..." + Returns: "https://kb.example.com" + """ + host = (host or "").strip() + if not host: + raise ValueError("host must be provided (e.g., 'kb.your-company.com').") + if not host.startswith(("http://", "https://")): + host = "https://" + host + # strip single trailing slash + if host.endswith("/"): + host = host[:-1] + return host + + +class HTTPError(Exception): + """Rich HTTP error including status code and server payload (if any).""" + + def __init__(self, status_code: int, message: str, payload: Optional[dict] = None): + super().__init__(f"{status_code}: {message}") + self.status_code = status_code + self.payload = payload or {} + + +class Repository: + """ + A client for interacting with the Pinecone Knowledge Base Data Plane (Documents). + Uses `requests` directly, with retries and sane defaults. + + Methods return plain `dict` responses parsed from JSON. + """ + + def __init__( + self, + api_key: str, + host: str, + pool_threads: Optional[int] = None, + additional_headers: Optional[Dict[str, str]] = None, + openapi_config=None, # kept for backward compat; unused + echo: bool = False, + **kwargs, + ): + self._api_key = api_key + self._base_url = _ensure_https_host(host) + self._echo = echo # store the flag + + # Connection pool sizing + self._pool_threads = 5 * cpu_count() if pool_threads is None else pool_threads + pool_maxsize = kwargs.get("connection_pool_maxsize", self._pool_threads) + + # Timeouts (connect, read). Allow overrides via kwargs + # e.g., timeout=(3.05, 30) + self._timeout: Tuple[float, float] = kwargs.get("timeout", (5.0, 60.0)) + + # Retries: conservative defaults; override via kwargs["retries"] + retries = kwargs.get( + "retries", + Retry( + total=5, + backoff_factor=0.5, + status_forcelist=(429, 500, 502, 503, 504), + allowed_methods=frozenset(["GET", "POST", "DELETE"]), + raise_on_status=False, + ), + ) + + self._session = requests.Session() + adapter = HTTPAdapter( + pool_connections=self._pool_threads, pool_maxsize=pool_maxsize, max_retries=retries + ) + self._session.mount("https://", adapter) + self._session.mount("http://", adapter) + + self._default_headers = { + "Api-Key": self._api_key, + "Accept": "application/json", + "x-pinecone-api-version": API_VERSION, + # Content-Type set per request when needed + } + if additional_headers: + self._default_headers.update(additional_headers) + + # ----------------------- + # Internal request helper + # ----------------------- + def _request( + self, + method: str, + path: str, + *, + json_body: Optional[dict] = None, + headers: Optional[dict] = None, + params: Optional[dict] = None, + echo: Optional[bool] = None, + ) -> Dict: + url = urljoin(self._base_url + "/", path.lstrip("/")) + hdrs = dict(self._default_headers) + if headers: + hdrs.update(headers) + if json_body is not None: + hdrs.setdefault("Content-Type", "application/json") + + logger.debug("HTTP %s %s params=%s json=%s", method, url, params, json_body) + + # decide whether to echo this call + do_echo = self._echo if echo is None else echo + if do_echo: + print("----- HTTP Request -----") + print(f"{method} {url}") + if params: + print("Params:", params) + + safe_headers = dict(hdrs) + for k, v in hdrs.items(): + print(f"checking........... {k}: {v}") + if k.lower() == "api-key": + masked = (v[:5] + "...") if isinstance(v, str) and len(v) > 5 else "..." + safe_headers[k] = masked + else: + safe_headers[k] = v + + print("Headers:", safe_headers) + if json_body is not None: + print("Body:", json.dumps(json_body, indent=2)) + print("------------------------") + + resp = self._session.request( + method=method, + url=url, + headers=hdrs, + params=params, + json=json_body, + timeout=self._timeout, + ) + + # Try to parse JSON payload (even on errors) for better messages + payload: Optional[dict] + try: + payload = resp.json() if resp.content else None + except json.JSONDecodeError: + payload = None + + if not (200 <= resp.status_code < 300): + msg = payload.get("message") if isinstance(payload, dict) else resp.text + raise HTTPError(resp.status_code, msg or "HTTP request failed", payload) + + if payload is None: + return {} + return payload + + # ------------- + # API methods + # ------------- + def upsert(self, namespace: str, document: Union[Dict[str, Any], Document], **kwargs) -> Dict: + """ + POST /namespaces/{namespace}/documents/upsert + Returns UpsertDocumentResponse as dict. + """ + if isinstance(document, Document): + json_body = document.to_dict() + elif isinstance(document, dict): + json_body = document + else: + raise TypeError("document must be a dict or Document.") + + path = f"/namespaces/{namespace}/documents/upsert" + return self._request("POST", path, json_body=json_body, **kwargs) + + def fetch(self, namespace: str, document_id: str, **kwargs) -> Document: + """ + GET /namespaces/{namespace}/documents/{document_id} + Returns GetDocumentResponse as dict. + """ + path = f"/namespaces/{namespace}/documents/{document_id}" + payload = self._request("GET", path, **kwargs) + + if not isinstance(payload, dict): + raise ValueError("Unexpected fetch-documents response format, expected dict response") + + doc = payload.get("document") + if not doc or not isinstance(doc, dict): + raise ValueError( + "Unexpected fetch-documents response format, expected 'document' key of type dict" + ) + + return Document.from_api(doc) + + def list(self, namespace: str, **kwargs) -> List[Document]: + """ + GET /namespaces/{namespace}/documents + Returns ListDocumentsResponse as dict. + """ + path = f"/namespaces/{namespace}/documents" + # Spec does not define query params, but keep hook if server adds (e.g., pagination). + params = kwargs.get("params") + payload = self._request("GET", path, params=params, **kwargs) + + candidates: List[Dict[str, Any]] = [] + if not isinstance(payload, dict): + raise ValueError("Unexpected list-documents response format, expected dict response") + + docs = payload.get("documents") + if not docs or not isinstance(docs, list): + raise ValueError( + "Unexpected list-documents response format, expected 'documents' key of type list" + ) + + candidates = docs + + return [Document.from_api(doc) for doc in candidates] + + def delete(self, namespace: str, document_id: str, **kwargs): + """ + DELETE /namespaces/{namespace}/documents/{document_id} + Returns DeleteDocumentResponse as dict. + """ + path = f"/namespaces/{namespace}/documents/{document_id}" + return self._request("DELETE", path, **kwargs) diff --git a/poetry.lock b/poetry.lock index eba19d41..d64c4046 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,4 +1,4 @@ -# This file is automatically @generated by Poetry 1.6.1 and should not be changed by hand. +# This file is automatically @generated by Poetry 2.1.3 and should not be changed by hand. [[package]] name = "aiohappyeyeballs" @@ -6,6 +6,8 @@ version = "2.4.3" description = "Happy Eyeballs for asyncio" optional = true python-versions = ">=3.8" +groups = ["main"] +markers = "extra == \"asyncio\"" files = [ {file = "aiohappyeyeballs-2.4.3-py3-none-any.whl", hash = "sha256:8a7a83727b2756f394ab2895ea0765a0a8c475e3c71e98d43d76f22b4b435572"}, {file = "aiohappyeyeballs-2.4.3.tar.gz", hash = "sha256:75cf88a15106a5002a8eb1dab212525c00d1f4c0fa96e551c9fbe6f09a621586"}, @@ -17,6 +19,8 @@ version = "3.11.5" description = "Async http client/server framework (asyncio)" optional = true python-versions = ">=3.9" +groups = ["main"] +markers = "extra == \"asyncio\"" files = [ {file = "aiohttp-3.11.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:6f9afa6500aed9d3ea6d8bdd1dfed19252bb254dfc8503660c50bee908701c2a"}, {file = "aiohttp-3.11.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:732ab84706bcfd2f2f16ea76c125a2025c1c747fc14db88ec1a7223ba3f2b9de"}, @@ -107,7 +111,7 @@ propcache = ">=0.2.0" yarl = ">=1.17.0,<2.0" [package.extras] -speedups = ["Brotli", "aiodns (>=3.2.0)", "brotlicffi"] +speedups = ["Brotli ; platform_python_implementation == \"CPython\"", "aiodns (>=3.2.0) ; sys_platform == \"linux\" or sys_platform == \"darwin\"", "brotlicffi ; platform_python_implementation != \"CPython\""] [[package]] name = "aiohttp-retry" @@ -115,6 +119,8 @@ version = "2.9.1" description = "Simple retry client for aiohttp" optional = true python-versions = ">=3.7" +groups = ["main"] +markers = "extra == \"asyncio\"" files = [ {file = "aiohttp_retry-2.9.1-py3-none-any.whl", hash = "sha256:66d2759d1921838256a05a3f80ad7e724936f083e35be5abb5e16eed6be6dc54"}, {file = "aiohttp_retry-2.9.1.tar.gz", hash = "sha256:8eb75e904ed4ee5c2ec242fefe85bf04240f685391c4879d8f541d6028ff01f1"}, @@ -129,6 +135,8 @@ version = "1.3.1" description = "aiosignal: a list of registered asynchronous callbacks" optional = true python-versions = ">=3.7" +groups = ["main"] +markers = "extra == \"asyncio\"" files = [ {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, @@ -143,6 +151,8 @@ version = "0.7.16" description = "A light, configurable Sphinx theme" optional = false python-versions = ">=3.9" +groups = ["dev"] +markers = "python_version < \"3.11\"" files = [ {file = "alabaster-0.7.16-py3-none-any.whl", hash = "sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92"}, {file = "alabaster-0.7.16.tar.gz", hash = "sha256:75a8b99c28a5dad50dd7f8ccdd447a121ddb3892da9e53d1ca5cca3106d58d65"}, @@ -154,6 +164,8 @@ version = "1.0.0" description = "A light, configurable Sphinx theme" optional = false python-versions = ">=3.10" +groups = ["dev"] +markers = "python_version >= \"3.11\"" files = [ {file = "alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b"}, {file = "alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e"}, @@ -165,6 +177,8 @@ version = "5.0.1" description = "Timeout context manager for asyncio programs" optional = true python-versions = ">=3.8" +groups = ["main"] +markers = "extra == \"asyncio\" and python_version < \"3.11\"" files = [ {file = "async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c"}, {file = "async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3"}, @@ -176,18 +190,20 @@ version = "24.2.0" description = "Classes Without Boilerplate" optional = true python-versions = ">=3.7" +groups = ["main"] +markers = "extra == \"asyncio\"" files = [ {file = "attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2"}, {file = "attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346"}, ] [package.extras] -benchmark = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-codspeed", "pytest-mypy-plugins", "pytest-xdist[psutil]"] -cov = ["cloudpickle", "coverage[toml] (>=5.3)", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] -dev = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pre-commit", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] +benchmark = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\"", "pympler", "pytest (>=4.3.0)", "pytest-codspeed", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\" and python_version < \"3.13\"", "pytest-xdist[psutil]"] +cov = ["cloudpickle ; platform_python_implementation == \"CPython\"", "coverage[toml] (>=5.3)", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\"", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\" and python_version < \"3.13\"", "pytest-xdist[psutil]"] +dev = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\"", "pre-commit", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\" and python_version < \"3.13\"", "pytest-xdist[psutil]"] docs = ["cogapp", "furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier (<24.7)"] -tests = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] -tests-mypy = ["mypy (>=1.11.1)", "pytest-mypy-plugins"] +tests = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\"", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\" and python_version < \"3.13\"", "pytest-xdist[psutil]"] +tests-mypy = ["mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\"", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.9\" and python_version < \"3.13\""] [[package]] name = "babel" @@ -195,13 +211,14 @@ version = "2.17.0" description = "Internationalization utilities" optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2"}, {file = "babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d"}, ] [package.extras] -dev = ["backports.zoneinfo", "freezegun (>=1.0,<2.0)", "jinja2 (>=3.0)", "pytest (>=6.0)", "pytest-cov", "pytz", "setuptools", "tzdata"] +dev = ["backports.zoneinfo ; python_version < \"3.9\"", "freezegun (>=1.0,<2.0)", "jinja2 (>=3.0)", "pytest (>=6.0)", "pytest-cov", "pytz", "setuptools", "tzdata ; sys_platform == \"win32\""] [[package]] name = "beautifulsoup4" @@ -209,6 +226,7 @@ version = "4.13.3" description = "Screen-scraping library" optional = false python-versions = ">=3.7.0" +groups = ["dev"] files = [ {file = "beautifulsoup4-4.13.3-py3-none-any.whl", hash = "sha256:99045d7d3f08f91f0d656bc9b7efbae189426cd913d830294a15eefa0ea4df16"}, {file = "beautifulsoup4-4.13.3.tar.gz", hash = "sha256:1bd32405dacc920b42b83ba01644747ed77456a65760e285fbc47633ceddaf8b"}, @@ -231,6 +249,7 @@ version = "2024.7.4" description = "Python package for providing Mozilla's CA Bundle." optional = false python-versions = ">=3.6" +groups = ["main", "dev"] files = [ {file = "certifi-2024.7.4-py3-none-any.whl", hash = "sha256:c198e21b1289c2ab85ee4e67bb4b4ef3ead0892059901a8d5b622f24a1101e90"}, {file = "certifi-2024.7.4.tar.gz", hash = "sha256:5a1e7645bc0ec61a09e26c36f6106dd4cf40c6db3a1fb6352b0244e7fb057c7b"}, @@ -242,6 +261,7 @@ version = "3.4.0" description = "Validate configuration and produce human readable error messages." optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"}, {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"}, @@ -253,6 +273,7 @@ version = "3.3.2" description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." optional = false python-versions = ">=3.7.0" +groups = ["main", "dev"] files = [ {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"}, @@ -352,6 +373,8 @@ version = "0.4.6" description = "Cross-platform colored terminal text." optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +groups = ["dev"] +markers = "sys_platform == \"win32\"" files = [ {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, @@ -363,6 +386,7 @@ version = "7.3.2" description = "Code coverage measurement for Python" optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "coverage-7.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d872145f3a3231a5f20fd48500274d7df222e291d90baa2026cc5152b7ce86bf"}, {file = "coverage-7.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:310b3bb9c91ea66d59c53fa4989f57d2436e08f18fb2f421a1b0b6b8cc7fffda"}, @@ -419,7 +443,7 @@ files = [ ] [package.extras] -toml = ["tomli"] +toml = ["tomli ; python_full_version <= \"3.11.0a6\""] [[package]] name = "distlib" @@ -427,6 +451,7 @@ version = "0.3.8" description = "Distribution utilities" optional = false python-versions = "*" +groups = ["dev"] files = [ {file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"}, {file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"}, @@ -438,6 +463,7 @@ version = "0.21.2" description = "Docutils -- Python Documentation Utilities" optional = false python-versions = ">=3.9" +groups = ["dev"] files = [ {file = "docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2"}, {file = "docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f"}, @@ -449,6 +475,8 @@ version = "1.3.0" description = "Backport of PEP 654 (exception groups)" optional = false python-versions = ">=3.7" +groups = ["dev"] +markers = "python_version < \"3.11\"" files = [ {file = "exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10"}, {file = "exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88"}, @@ -466,6 +494,7 @@ version = "3.15.1" description = "A platform independent file lock." optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "filelock-3.15.1-py3-none-any.whl", hash = "sha256:71b3102950e91dfc1bb4209b64be4dc8854f40e5f534428d8684f953ac847fac"}, {file = "filelock-3.15.1.tar.gz", hash = "sha256:58a2549afdf9e02e10720eaa4d4470f56386d7a6f72edd7d0596337af8ed7ad8"}, @@ -474,7 +503,7 @@ files = [ [package.extras] docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"] testing = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "diff-cover (>=8.0.1)", "pytest (>=7.4.3)", "pytest-asyncio (>=0.21)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)", "pytest-timeout (>=2.2)"] -typing = ["typing-extensions (>=4.8)"] +typing = ["typing-extensions (>=4.8) ; python_version < \"3.11\""] [[package]] name = "frozenlist" @@ -482,6 +511,8 @@ version = "1.5.0" description = "A list-like structure which implements collections.abc.MutableSequence" optional = true python-versions = ">=3.8" +groups = ["main"] +markers = "extra == \"asyncio\"" files = [ {file = "frozenlist-1.5.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:5b6a66c18b5b9dd261ca98dffcb826a525334b2f29e7caa54e182255c5f6a65a"}, {file = "frozenlist-1.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d1b3eb7b05ea246510b43a7e53ed1653e55c2121019a97e60cad7efb881a97bb"}, @@ -583,6 +614,8 @@ version = "1.66.0" description = "Common protobufs used in Google APIs" optional = true python-versions = ">=3.7" +groups = ["main"] +markers = "extra == \"grpc\"" files = [ {file = "googleapis_common_protos-1.66.0-py2.py3-none-any.whl", hash = "sha256:d7abcd75fabb2e0ec9f74466401f6c119a0b498e27370e9be4c94cb7e382b8ed"}, {file = "googleapis_common_protos-1.66.0.tar.gz", hash = "sha256:c3e7b33d15fdca5374cc0a7346dd92ffa847425cc4ea941d970f13680052ec8c"}, @@ -600,6 +633,7 @@ version = "1.53.0.3" description = "Mypy stubs for gRPC" optional = false python-versions = ">=3.6" +groups = ["types"] files = [ {file = "grpc-stubs-1.53.0.3.tar.gz", hash = "sha256:6e5d75cdc88c0ba918e2f8395851f1e6a7c19a7c7fc3e902bde4601c7a1cbf96"}, {file = "grpc_stubs-1.53.0.3-py3-none-any.whl", hash = "sha256:312c3c697089344936c9779118a105bcc4ccc8eef053265f3f23086acdba2683"}, @@ -614,6 +648,7 @@ version = "1.70.0" description = "HTTP/2-based RPC framework" optional = false python-versions = ">=3.8" +groups = ["main", "types"] files = [ {file = "grpcio-1.70.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:95469d1977429f45fe7df441f586521361e235982a0b39e33841549143ae2851"}, {file = "grpcio-1.70.0-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:ed9718f17fbdb472e33b869c77a16d0b55e166b100ec57b016dc7de9c8d236bf"}, @@ -671,6 +706,7 @@ files = [ {file = "grpcio-1.70.0-cp39-cp39-win_amd64.whl", hash = "sha256:a31d7e3b529c94e930a117b2175b2efd179d96eb3c7a21ccb0289a8ab05b645c"}, {file = "grpcio-1.70.0.tar.gz", hash = "sha256:8d1584a68d5922330025881e63a6c1b54cc8117291d382e4fa69339b6d914c56"}, ] +markers = {main = "extra == \"grpc\""} [package.extras] protobuf = ["grpcio-tools (>=1.70.0)"] @@ -681,6 +717,7 @@ version = "2.5.36" description = "File identification library for Python" optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "identify-2.5.36-py2.py3-none-any.whl", hash = "sha256:37d93f380f4de590500d9dba7db359d0d3da95ffe7f9de1753faa159e71e7dfa"}, {file = "identify-2.5.36.tar.gz", hash = "sha256:e5e00f54165f9047fbebeb4a560f9acfb8af4c88232be60a488e9b68d122745d"}, @@ -695,6 +732,7 @@ version = "3.7" description = "Internationalized Domain Names in Applications (IDNA)" optional = false python-versions = ">=3.5" +groups = ["main", "dev"] files = [ {file = "idna-3.7-py3-none-any.whl", hash = "sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0"}, {file = "idna-3.7.tar.gz", hash = "sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc"}, @@ -706,6 +744,7 @@ version = "1.4.1" description = "Getting image size from png/jpeg/jpeg2000/gif file" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +groups = ["dev"] files = [ {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"}, {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, @@ -717,6 +756,8 @@ version = "8.7.0" description = "Read metadata from Python packages" optional = false python-versions = ">=3.9" +groups = ["dev"] +markers = "python_version == \"3.9\"" files = [ {file = "importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd"}, {file = "importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000"}, @@ -726,12 +767,12 @@ files = [ zipp = ">=3.20" [package.extras] -check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"] +check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""] cover = ["pytest-cov"] doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] enabler = ["pytest-enabler (>=2.2)"] perf = ["ipython"] -test = ["flufl.flake8", "importlib_resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"] +test = ["flufl.flake8", "importlib_resources (>=1.3) ; python_version < \"3.9\"", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"] type = ["pytest-mypy"] [[package]] @@ -740,6 +781,7 @@ version = "2.0.0" description = "brain-dead simple config-ini parsing" optional = false python-versions = ">=3.7" +groups = ["dev"] files = [ {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, @@ -751,6 +793,7 @@ version = "3.1.6" description = "A very fast and expressive template engine." optional = false python-versions = ">=3.7" +groups = ["dev"] files = [ {file = "jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67"}, {file = "jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d"}, @@ -768,6 +811,8 @@ version = "4.3.2" description = "LZ4 Bindings for Python" optional = true python-versions = ">=3.7" +groups = ["main"] +markers = "extra == \"grpc\"" files = [ {file = "lz4-4.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1c4c100d99eed7c08d4e8852dd11e7d1ec47a3340f49e3a96f8dfbba17ffb300"}, {file = "lz4-4.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:edd8987d8415b5dad25e797043936d91535017237f72fa456601be1479386c92"}, @@ -817,6 +862,7 @@ version = "3.0.0" description = "Python port of markdown-it. Markdown parsing, done right!" optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, @@ -841,6 +887,7 @@ version = "3.0.2" description = "Safely add untrusted strings to HTML/XML markup." optional = false python-versions = ">=3.9" +groups = ["dev"] files = [ {file = "MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8"}, {file = "MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158"}, @@ -911,6 +958,7 @@ version = "0.4.2" description = "Collection of plugins for markdown-it-py" optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "mdit_py_plugins-0.4.2-py3-none-any.whl", hash = "sha256:0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636"}, {file = "mdit_py_plugins-0.4.2.tar.gz", hash = "sha256:5f2cd1fdb606ddf152d37ec30e46101a60512bc0e5fa1a7002c36647b09e26b5"}, @@ -930,6 +978,7 @@ version = "0.1.2" description = "Markdown URL utilities" optional = false python-versions = ">=3.7" +groups = ["dev"] files = [ {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, @@ -941,6 +990,8 @@ version = "6.1.0" description = "multidict implementation" optional = true python-versions = ">=3.8" +groups = ["main"] +markers = "extra == \"asyncio\"" files = [ {file = "multidict-6.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3380252550e372e8511d49481bd836264c009adb826b23fefcc5dd3c69692f60"}, {file = "multidict-6.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:99f826cbf970077383d7de805c0681799491cb939c25450b9b5b3ced03ca99f1"}, @@ -1045,6 +1096,7 @@ version = "1.6.1" description = "Optional static typing for Python" optional = false python-versions = ">=3.8" +groups = ["types"] files = [ {file = "mypy-1.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e5012e5cc2ac628177eaac0e83d622b2dd499e28253d4107a08ecc59ede3fc2c"}, {file = "mypy-1.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d8fbb68711905f8912e5af474ca8b78d077447d8f3918997fecbf26943ff3cbb"}, @@ -1091,6 +1143,7 @@ version = "1.0.0" description = "Type system extensions for programs checked with the mypy type checker." optional = false python-versions = ">=3.5" +groups = ["types"] files = [ {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, @@ -1102,6 +1155,8 @@ version = "3.0.1" description = "An extended [CommonMark](https://spec.commonmark.org/) compliant parser," optional = false python-versions = ">=3.8" +groups = ["dev"] +markers = "python_version == \"3.9\"" files = [ {file = "myst_parser-3.0.1-py3-none-any.whl", hash = "sha256:6457aaa33a5d474aca678b8ead9b3dc298e89c68e67012e73146ea6fd54babf1"}, {file = "myst_parser-3.0.1.tar.gz", hash = "sha256:88f0cb406cb363b077d176b51c476f62d60604d68a8dcdf4832e080441301a87"}, @@ -1128,6 +1183,8 @@ version = "4.0.1" description = "An extended [CommonMark](https://spec.commonmark.org/) compliant parser," optional = false python-versions = ">=3.10" +groups = ["dev"] +markers = "python_version >= \"3.10\"" files = [ {file = "myst_parser-4.0.1-py3-none-any.whl", hash = "sha256:9134e88959ec3b5780aedf8a99680ea242869d012e8821db3126d427edc9c95d"}, {file = "myst_parser-4.0.1.tar.gz", hash = "sha256:5cfea715e4f3574138aecbf7d54132296bfd72bb614d31168f48c477a830a7c4"}, @@ -1154,6 +1211,7 @@ version = "1.9.1" description = "Node.js virtual environment builder" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +groups = ["dev"] files = [ {file = "nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9"}, {file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"}, @@ -1165,6 +1223,7 @@ version = "1.26.3" description = "Fundamental package for array computing in Python" optional = false python-versions = ">=3.9" +groups = ["dev", "types"] files = [ {file = "numpy-1.26.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:806dd64230dbbfaca8a27faa64e2f414bf1c6622ab78cc4264f7f5f028fee3bf"}, {file = "numpy-1.26.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02f98011ba4ab17f46f80f7f8f1c291ee7d855fcef0a5a98db80767a468c85cd"}, @@ -1203,6 +1262,7 @@ files = [ {file = "numpy-1.26.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a8474703bffc65ca15853d5fd4d06b18138ae90c17c8d12169968e998e448bb5"}, {file = "numpy-1.26.3.tar.gz", hash = "sha256:697df43e2b6310ecc9d95f05d5ef20eacc09c7c4ecc9da3f235d39e71b7da1e4"}, ] +markers = {types = "python_version < \"3.13\""} [[package]] name = "packaging" @@ -1210,6 +1270,7 @@ version = "24.2" description = "Core utilities for Python packages" optional = false python-versions = ">=3.8" +groups = ["main", "dev"] files = [ {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, @@ -1221,6 +1282,7 @@ version = "2.2.3" description = "Powerful data structures for data analysis, time series, and statistics" optional = false python-versions = ">=3.9" +groups = ["dev"] files = [ {file = "pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5"}, {file = "pandas-2.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:381175499d3802cde0eabbaf6324cce0c4f5d52ca6f8c377c29ad442f50f6348"}, @@ -1307,6 +1369,7 @@ version = "2.1.4.231227" description = "Type annotations for pandas" optional = false python-versions = ">=3.9" +groups = ["types"] files = [ {file = "pandas_stubs-2.1.4.231227-py3-none-any.whl", hash = "sha256:211fc23e6ae87073bdf41dbf362c4a4d85e1e3477cb078dbac3da6c7fdaefba8"}, {file = "pandas_stubs-2.1.4.231227.tar.gz", hash = "sha256:3ea29ef001e9e44985f5ebde02d4413f94891ef6ec7e5056fb07d125be796c23"}, @@ -1322,6 +1385,7 @@ version = "1.6.0" description = "Assistant plugin for Pinecone SDK" optional = false python-versions = "<4.0,>=3.9" +groups = ["main"] files = [ {file = "pinecone_plugin_assistant-1.6.0-py3-none-any.whl", hash = "sha256:d742273d136fba66d020f1af01af2c6bfbc802f7ff9ddf46c590b7ea26932175"}, {file = "pinecone_plugin_assistant-1.6.0.tar.gz", hash = "sha256:b7c531743f87269ba567dd6084b1464b62636a011564d414bc53147571b2f2c1"}, @@ -1337,6 +1401,7 @@ version = "0.0.7" description = "Plugin interface for the Pinecone python client" optional = false python-versions = "<4.0,>=3.8" +groups = ["main"] files = [ {file = "pinecone_plugin_interface-0.0.7-py3-none-any.whl", hash = "sha256:875857ad9c9fc8bbc074dbe780d187a2afd21f5bfe0f3b08601924a61ef1bba8"}, {file = "pinecone_plugin_interface-0.0.7.tar.gz", hash = "sha256:b8e6675e41847333aa13923cc44daa3f85676d7157324682dc1640588a982846"}, @@ -1348,6 +1413,7 @@ version = "4.2.2" description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "platformdirs-4.2.2-py3-none-any.whl", hash = "sha256:2d7a1657e36a80ea911db832a8a6ece5ee53d8de21edd5cc5879af6530b1bfee"}, {file = "platformdirs-4.2.2.tar.gz", hash = "sha256:38b7b51f512eed9e84a22788b4bce1de17c0adb134d6becb09836e37d8654cd3"}, @@ -1364,6 +1430,7 @@ version = "1.5.0" description = "plugin and hook calling mechanisms for python" optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, @@ -1379,6 +1446,7 @@ version = "3.5.0" description = "A framework for managing and maintaining multi-language pre-commit hooks." optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "pre_commit-3.5.0-py2.py3-none-any.whl", hash = "sha256:841dc9aef25daba9a0238cd27984041fa0467b4199fc4852e27950664919f660"}, {file = "pre_commit-3.5.0.tar.gz", hash = "sha256:5804465c675b659b0862f07907f96295d490822a450c4c40e747d0b1c6ebcb32"}, @@ -1397,6 +1465,8 @@ version = "0.2.0" description = "Accelerated property cache" optional = true python-versions = ">=3.8" +groups = ["main"] +markers = "extra == \"asyncio\"" files = [ {file = "propcache-0.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c5869b8fd70b81835a6f187c5fdbe67917a04d7e52b6e7cc4e5fe39d55c39d58"}, {file = "propcache-0.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:952e0d9d07609d9c5be361f33b0d6d650cd2bae393aabb11d9b719364521984b"}, @@ -1504,6 +1574,8 @@ version = "5.29.1" description = "" optional = true python-versions = ">=3.8" +groups = ["main"] +markers = "extra == \"grpc\"" files = [ {file = "protobuf-5.29.1-cp310-abi3-win32.whl", hash = "sha256:22c1f539024241ee545cbcb00ee160ad1877975690b16656ff87dde107b5f110"}, {file = "protobuf-5.29.1-cp310-abi3-win_amd64.whl", hash = "sha256:1fc55267f086dd4050d18ef839d7bd69300d0d08c2a53ca7df3920cc271a3c34"}, @@ -1524,6 +1596,8 @@ version = "0.0.1" description = "Provides the missing pieces for gRPC Gateway." optional = true python-versions = ">=3.6" +groups = ["main"] +markers = "extra == \"grpc\"" files = [ {file = "protoc-gen-openapiv2-0.0.1.tar.gz", hash = "sha256:6f79188d842c13177c9c0558845442c340b43011bf67dfef1dfc3bc067506409"}, {file = "protoc_gen_openapiv2-0.0.1-py3-none-any.whl", hash = "sha256:18090c8be3877c438e7da0f7eb7cace45a9a210306bca4707708dbad367857be"}, @@ -1539,6 +1613,7 @@ version = "7.0.0" description = "Cross-platform lib for process and system monitoring in Python. NOTE: the syntax of this script MUST be kept compatible with Python 2.7." optional = false python-versions = ">=3.6" +groups = ["dev"] files = [ {file = "psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25"}, {file = "psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da"}, @@ -1562,6 +1637,7 @@ version = "9.0.0" description = "Get CPU info with pure Python" optional = false python-versions = "*" +groups = ["dev"] files = [ {file = "py-cpuinfo-9.0.0.tar.gz", hash = "sha256:3cdbbf3fac90dc6f118bfd64384f309edeadd902d7c8fb17f02ffa1fc3f49690"}, {file = "py_cpuinfo-9.0.0-py3-none-any.whl", hash = "sha256:859625bc251f64e21f077d099d4162689c762b5d6a4c3c97553d56241c9674d5"}, @@ -1573,6 +1649,7 @@ version = "2.19.1" description = "Pygments is a syntax highlighting package written in Python." optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c"}, {file = "pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f"}, @@ -1587,6 +1664,7 @@ version = "8.2.0" description = "pytest: simple powerful testing with Python" optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "pytest-8.2.0-py3-none-any.whl", hash = "sha256:1733f0620f6cda4095bbf0d9ff8022486e91892245bb9e7d5542c018f612f233"}, {file = "pytest-8.2.0.tar.gz", hash = "sha256:d507d4482197eac0ba2bae2e9babf0672eb333017bcedaa5fb1a3d42c1174b3f"}, @@ -1609,6 +1687,7 @@ version = "0.25.2" description = "Pytest support for asyncio" optional = false python-versions = ">=3.9" +groups = ["dev"] files = [ {file = "pytest_asyncio-0.25.2-py3-none-any.whl", hash = "sha256:0d0bb693f7b99da304a0634afc0a4b19e49d5e0de2d670f38dc4bfa5727c5075"}, {file = "pytest_asyncio-0.25.2.tar.gz", hash = "sha256:3f8ef9a98f45948ea91a0ed3dc4268b5326c0e7bce73892acc654df4262ad45f"}, @@ -1627,6 +1706,7 @@ version = "5.0.0" description = "A ``pytest`` fixture for benchmarking code. It will group the tests into rounds that are calibrated to the chosen timer." optional = false python-versions = ">=3.9" +groups = ["dev"] files = [ {file = "pytest-benchmark-5.0.0.tar.gz", hash = "sha256:cd0adf68516eea7ac212b78a7eb6fc3373865507de8562bb3bfff2f2f852cc63"}, {file = "pytest_benchmark-5.0.0-py3-none-any.whl", hash = "sha256:67fed4943aa761077345119555d7f6df09877a12a36e8128f05e19ccd5942d80"}, @@ -1647,6 +1727,7 @@ version = "2.10.1" description = "Pytest plugin for measuring coverage." optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +groups = ["dev"] files = [ {file = "pytest-cov-2.10.1.tar.gz", hash = "sha256:47bd0ce14056fdd79f93e1713f88fad7bdcc583dcd7783da86ef2f085a0bb88e"}, {file = "pytest_cov-2.10.1-py2.py3-none-any.whl", hash = "sha256:45ec2d5182f89a81fc3eb29e3d1ed3113b9e9a873bcddb2a71faaab066110191"}, @@ -1665,6 +1746,7 @@ version = "3.6.1" description = "Thin-wrapper around the mock package for easier use with pytest" optional = false python-versions = ">=3.6" +groups = ["dev"] files = [ {file = "pytest-mock-3.6.1.tar.gz", hash = "sha256:40217a058c52a63f1042f0784f62009e976ba824c418cced42e88d5f40ab0e62"}, {file = "pytest_mock-3.6.1-py3-none-any.whl", hash = "sha256:30c2f2cc9759e76eee674b81ea28c9f0b94f8f0445a1b87762cadf774f0df7e3"}, @@ -1682,6 +1764,7 @@ version = "1.7.0" description = "Adds the ability to retry flaky tests in CI environments" optional = false python-versions = ">=3.9" +groups = ["dev"] files = [ {file = "pytest_retry-1.7.0-py3-none-any.whl", hash = "sha256:a2dac85b79a4e2375943f1429479c65beb6c69553e7dae6b8332be47a60954f4"}, {file = "pytest_retry-1.7.0.tar.gz", hash = "sha256:f8d52339f01e949df47c11ba9ee8d5b362f5824dff580d3870ec9ae0057df80f"}, @@ -1699,6 +1782,7 @@ version = "2.2.0" description = "pytest plugin to abort hanging tests" optional = false python-versions = ">=3.7" +groups = ["dev"] files = [ {file = "pytest-timeout-2.2.0.tar.gz", hash = "sha256:3b0b95dabf3cb50bac9ef5ca912fa0cfc286526af17afc806824df20c2f72c90"}, {file = "pytest_timeout-2.2.0-py3-none-any.whl", hash = "sha256:bde531e096466f49398a59f2dde76fa78429a09a12411466f88a07213e220de2"}, @@ -1713,6 +1797,7 @@ version = "2.8.2" description = "Extensions to the standard Python datetime module" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +groups = ["main", "dev"] files = [ {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"}, {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"}, @@ -1727,6 +1812,7 @@ version = "1.1.0" description = "Read key-value pairs from a .env file and set them as environment variables" optional = false python-versions = ">=3.9" +groups = ["dev"] files = [ {file = "python_dotenv-1.1.0-py3-none-any.whl", hash = "sha256:d7c01d9e2293916c18baf562d95698754b0dbbb5e74d457c45d4f6561fb9d55d"}, {file = "python_dotenv-1.1.0.tar.gz", hash = "sha256:41f90bc6f5f177fb41f53e87666db362025010eb28f60a01c9143bfa33a2b2d5"}, @@ -1741,6 +1827,7 @@ version = "2023.3.post1" description = "World timezone definitions, modern and historical" optional = false python-versions = "*" +groups = ["dev"] files = [ {file = "pytz-2023.3.post1-py2.py3-none-any.whl", hash = "sha256:ce42d816b81b68506614c11e8937d3aa9e41007ceb50bfdcb0749b921bf646c7"}, {file = "pytz-2023.3.post1.tar.gz", hash = "sha256:7b4fddbeb94a1eba4b557da24f19fdf9db575192544270a9101d8509f9f43d7b"}, @@ -1752,6 +1839,7 @@ version = "6.0.1" description = "YAML parser and emitter for Python" optional = false python-versions = ">=3.6" +groups = ["dev"] files = [ {file = "PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a"}, {file = "PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f"}, @@ -1812,6 +1900,7 @@ version = "2.32.3" description = "Python HTTP for Humans." optional = false python-versions = ">=3.8" +groups = ["main", "dev"] files = [ {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, @@ -1833,6 +1922,7 @@ version = "0.24.0" description = "A utility library for mocking out the `requests` Python library." optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "responses-0.24.0-py3-none-any.whl", hash = "sha256:060be153c270c06fa4d22c1ef8865fdef43902eb595204deeef736cddb62d353"}, {file = "responses-0.24.0.tar.gz", hash = "sha256:3df82f7d4dcd3e5f61498181aadb4381f291da25c7506c47fe8cb68ce29203e7"}, @@ -1844,7 +1934,7 @@ requests = ">=2.30.0,<3.0" urllib3 = ">=1.25.10,<3.0" [package.extras] -tests = ["coverage (>=6.0.0)", "flake8", "mypy", "pytest (>=7.0.0)", "pytest-asyncio", "pytest-cov", "pytest-httpserver", "tomli", "tomli-w", "types-PyYAML", "types-requests"] +tests = ["coverage (>=6.0.0)", "flake8", "mypy", "pytest (>=7.0.0)", "pytest-asyncio", "pytest-cov", "pytest-httpserver", "tomli ; python_version < \"3.11\"", "tomli-w", "types-PyYAML", "types-requests"] [[package]] name = "roman-numerals-py" @@ -1852,6 +1942,8 @@ version = "3.1.0" description = "Manipulate well-formed Roman numerals" optional = false python-versions = ">=3.9" +groups = ["dev"] +markers = "python_version >= \"3.11\"" files = [ {file = "roman_numerals_py-3.1.0-py3-none-any.whl", hash = "sha256:9da2ad2fb670bcf24e81070ceb3be72f6c11c440d73bd579fbeca1e9f330954c"}, {file = "roman_numerals_py-3.1.0.tar.gz", hash = "sha256:be4bf804f083a4ce001b5eb7e3c0862479d10f94c936f6c4e5f250aa5ff5bd2d"}, @@ -1867,6 +1959,7 @@ version = "0.9.3" description = "An extremely fast Python linter and code formatter, written in Rust." optional = false python-versions = ">=3.7" +groups = ["dev"] files = [ {file = "ruff-0.9.3-py3-none-linux_armv6l.whl", hash = "sha256:7f39b879064c7d9670197d91124a75d118d00b0990586549949aae80cdc16624"}, {file = "ruff-0.9.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:a187171e7c09efa4b4cc30ee5d0d55a8d6c5311b3e1b74ac5cb96cc89bafc43c"}, @@ -1894,6 +1987,7 @@ version = "1.16.0" description = "Python 2 and 3 compatibility utilities" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +groups = ["main", "dev"] files = [ {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, @@ -1905,6 +1999,7 @@ version = "3.0.1" description = "This package provides 32 stemmers for 30 languages generated from Snowball algorithms." optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*" +groups = ["dev"] files = [ {file = "snowballstemmer-3.0.1-py3-none-any.whl", hash = "sha256:6cd7b3897da8d6c9ffb968a6781fa6532dce9c3618a4b127d920dab764a19064"}, {file = "snowballstemmer-3.0.1.tar.gz", hash = "sha256:6d5eeeec8e9f84d4d56b847692bacf79bc2c8e90c7f80ca4444ff8b6f2e52895"}, @@ -1916,6 +2011,7 @@ version = "2.6" description = "A modern CSS selector implementation for Beautiful Soup." optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"}, {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"}, @@ -1927,6 +2023,8 @@ version = "7.4.7" description = "Python documentation generator" optional = false python-versions = ">=3.9" +groups = ["dev"] +markers = "python_version < \"3.11\"" files = [ {file = "sphinx-7.4.7-py3-none-any.whl", hash = "sha256:c2419e2135d11f1951cd994d6eb18a1835bd8fdd8429f9ca375dc1f3281bd239"}, {file = "sphinx-7.4.7.tar.gz", hash = "sha256:242f92a7ea7e6c5b406fdc2615413890ba9f699114a9c09192d7dfead2ee9cfe"}, @@ -1963,6 +2061,8 @@ version = "8.2.3" description = "Python documentation generator" optional = false python-versions = ">=3.11" +groups = ["dev"] +markers = "python_version >= \"3.11\"" files = [ {file = "sphinx-8.2.3-py3-none-any.whl", hash = "sha256:4405915165f13521d875a8c29c8970800a0141c14cc5416a38feca4ea5d9b9c3"}, {file = "sphinx-8.2.3.tar.gz", hash = "sha256:398ad29dee7f63a75888314e9424d40f52ce5a6a87ae88e7071e80af296ec348"}, @@ -1998,6 +2098,7 @@ version = "2.0.0" description = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" optional = false python-versions = ">=3.9" +groups = ["dev"] files = [ {file = "sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5"}, {file = "sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1"}, @@ -2014,6 +2115,7 @@ version = "2.0.0" description = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp documents" optional = false python-versions = ">=3.9" +groups = ["dev"] files = [ {file = "sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2"}, {file = "sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad"}, @@ -2030,6 +2132,7 @@ version = "2.1.0" description = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" optional = false python-versions = ">=3.9" +groups = ["dev"] files = [ {file = "sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8"}, {file = "sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9"}, @@ -2046,6 +2149,7 @@ version = "1.0.1" description = "A sphinx extension which renders display math in HTML via JavaScript" optional = false python-versions = ">=3.5" +groups = ["dev"] files = [ {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"}, {file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"}, @@ -2060,6 +2164,7 @@ version = "2.0.0" description = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp documents" optional = false python-versions = ">=3.9" +groups = ["dev"] files = [ {file = "sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb"}, {file = "sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab"}, @@ -2076,6 +2181,7 @@ version = "2.0.0" description = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)" optional = false python-versions = ">=3.9" +groups = ["dev"] files = [ {file = "sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331"}, {file = "sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d"}, @@ -2092,6 +2198,8 @@ version = "2.2.1" description = "A lil' TOML parser" optional = false python-versions = ">=3.8" +groups = ["dev", "types"] +markers = "python_version < \"3.11\"" files = [ {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"}, {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"}, @@ -2133,6 +2241,7 @@ version = "0.5.11" description = "Visualize Python performance profiles" optional = false python-versions = ">=3.6" +groups = ["dev"] files = [ {file = "tuna-0.5.11-py3-none-any.whl", hash = "sha256:ab352a6d836014ace585ecd882148f1f7c68be9ea4bf9e9298b7127594dab2ef"}, {file = "tuna-0.5.11.tar.gz", hash = "sha256:d47f3e39e80af961c8df016ac97d1643c3c60b5eb451299da0ab5fe411d8866c"}, @@ -2144,6 +2253,7 @@ version = "4.24.0.4" description = "Typing stubs for protobuf" optional = false python-versions = ">=3.7" +groups = ["types"] files = [ {file = "types-protobuf-4.24.0.4.tar.gz", hash = "sha256:57ab42cb171dfdba2c74bb5b50c250478538cc3c5ed95b8b368929ad0c9f90a5"}, {file = "types_protobuf-4.24.0.4-py3-none-any.whl", hash = "sha256:131ab7d0cbc9e444bc89c994141327dcce7bcaeded72b1acb72a94827eb9c7af"}, @@ -2155,6 +2265,7 @@ version = "2.9.0.20241003" description = "Typing stubs for python-dateutil" optional = false python-versions = ">=3.8" +groups = ["types"] files = [ {file = "types-python-dateutil-2.9.0.20241003.tar.gz", hash = "sha256:58cb85449b2a56d6684e41aeefb4c4280631246a0da1a719bdbe6f3fb0317446"}, {file = "types_python_dateutil-2.9.0.20241003-py3-none-any.whl", hash = "sha256:250e1d8e80e7bbc3a6c99b907762711d1a1cdd00e978ad39cb5940f6f0a87f3d"}, @@ -2166,17 +2277,34 @@ version = "2023.3.1.1" description = "Typing stubs for pytz" optional = false python-versions = "*" +groups = ["types"] files = [ {file = "types-pytz-2023.3.1.1.tar.gz", hash = "sha256:cc23d0192cd49c8f6bba44ee0c81e4586a8f30204970fc0894d209a6b08dab9a"}, {file = "types_pytz-2023.3.1.1-py3-none-any.whl", hash = "sha256:1999a123a3dc0e39a2ef6d19f3f8584211de9e6a77fe7a0259f04a524e90a5cf"}, ] +[[package]] +name = "types-requests" +version = "2.32.4.20250913" +description = "Typing stubs for requests" +optional = false +python-versions = ">=3.9" +groups = ["dev"] +files = [ + {file = "types_requests-2.32.4.20250913-py3-none-any.whl", hash = "sha256:78c9c1fffebbe0fa487a418e0fa5252017e9c60d1a2da394077f1780f655d7e1"}, + {file = "types_requests-2.32.4.20250913.tar.gz", hash = "sha256:abd6d4f9ce3a9383f269775a9835a4c24e5cd6b9f647d64f88aa4613c33def5d"}, +] + +[package.dependencies] +urllib3 = ">=2" + [[package]] name = "types-tqdm" version = "4.66.0.4" description = "Typing stubs for tqdm" optional = false python-versions = ">=3.7" +groups = ["types"] files = [ {file = "types-tqdm-4.66.0.4.tar.gz", hash = "sha256:a2f0ebd4cfd48f4914395819a176d7947387e1b98f9228fca38f8cac1b59891c"}, {file = "types_tqdm-4.66.0.4-py3-none-any.whl", hash = "sha256:8eda4c5123dd66985a4cb44268705cfa18beb32d66772271ae185e92b8b10c40"}, @@ -2188,6 +2316,7 @@ version = "1.26.25.14" description = "Typing stubs for urllib3" optional = false python-versions = "*" +groups = ["types"] files = [ {file = "types-urllib3-1.26.25.14.tar.gz", hash = "sha256:229b7f577c951b8c1b92c1bc2b2fdb0b49847bd2af6d1cc2a2e3dd340f3bda8f"}, {file = "types_urllib3-1.26.25.14-py3-none-any.whl", hash = "sha256:9683bbb7fb72e32bfe9d2be6e04875fbe1b3eeec3cbb4ea231435aa7fd6b4f0e"}, @@ -2199,6 +2328,7 @@ version = "4.8.0" description = "Backported and Experimental Type Hints for Python 3.8+" optional = false python-versions = ">=3.8" +groups = ["main", "dev", "types"] files = [ {file = "typing_extensions-4.8.0-py3-none-any.whl", hash = "sha256:8f92fc8806f9a6b641eaa5318da32b44d401efaac0f6678c9bc448ba3605faa0"}, {file = "typing_extensions-4.8.0.tar.gz", hash = "sha256:df8e4339e9cb77357558cbdbceca33c303714cf861d1eef15e1070055ae8b7ef"}, @@ -2210,6 +2340,7 @@ version = "2023.3" description = "Provider of IANA time zone data" optional = false python-versions = ">=2" +groups = ["dev"] files = [ {file = "tzdata-2023.3-py2.py3-none-any.whl", hash = "sha256:7e65763eef3120314099b6939b5546db7adce1e7d6f2e179e3df563c70511eda"}, {file = "tzdata-2023.3.tar.gz", hash = "sha256:11ef1e08e54acb0d4f95bdb1be05da659673de4acbd21bf9c69e94cc5e907a3a"}, @@ -2221,13 +2352,14 @@ version = "2.2.2" description = "HTTP library with thread-safe connection pooling, file post, and more." optional = false python-versions = ">=3.8" +groups = ["main", "dev"] files = [ {file = "urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472"}, {file = "urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"}, ] [package.extras] -brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +brotli = ["brotli (>=1.0.9) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=0.8.0) ; platform_python_implementation != \"CPython\""] h2 = ["h2 (>=4,<5)"] socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] zstd = ["zstandard (>=0.18.0)"] @@ -2238,6 +2370,7 @@ version = "0.3.3" description = "A utility library for mocking out the `urllib3` Python library." optional = false python-versions = "*" +groups = ["dev"] files = [ {file = "urllib3-mock-0.3.3.tar.gz", hash = "sha256:b210037029ac96beac4f3e7b54f466c394b060525ea5a824803d5f5ed14558f1"}, {file = "urllib3_mock-0.3.3-py2.py3-none-any.whl", hash = "sha256:702c90042920d771c9902b7b5b542551cc57f259078f4eada47ab4e8cdd11f1a"}, @@ -2252,6 +2385,7 @@ version = "20.29.1" description = "Virtual Python Environment builder" optional = false python-versions = ">=3.8" +groups = ["dev"] files = [ {file = "virtualenv-20.29.1-py3-none-any.whl", hash = "sha256:4e4cb403c0b0da39e13b46b1b2476e505cb0046b25f242bee80f62bf990b2779"}, {file = "virtualenv-20.29.1.tar.gz", hash = "sha256:b8b8970138d32fb606192cb97f6cd4bb644fa486be9308fb9b63f81091b5dc35"}, @@ -2264,7 +2398,7 @@ platformdirs = ">=3.9.1,<5" [package.extras] docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2,!=7.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"] -test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"] +test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8) ; platform_python_implementation == \"PyPy\" or platform_python_implementation == \"CPython\" and sys_platform == \"win32\" and python_version >= \"3.13\"", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10) ; platform_python_implementation == \"CPython\""] [[package]] name = "vprof" @@ -2272,6 +2406,7 @@ version = "0.38" description = "Visual profiler for Python" optional = false python-versions = "*" +groups = ["dev"] files = [ {file = "vprof-0.38-py3-none-any.whl", hash = "sha256:91b91d8868176c29e0fe3426c9239d11cd192c7144c7baf26a211e48923a5ee8"}, {file = "vprof-0.38.tar.gz", hash = "sha256:7f1000912eeb7a450c7c94d3cc96739af45ad0ff01d5abcc0b09a175d40ffadb"}, @@ -2286,6 +2421,8 @@ version = "1.17.2" description = "Yet another URL library" optional = true python-versions = ">=3.9" +groups = ["main"] +markers = "extra == \"asyncio\"" files = [ {file = "yarl-1.17.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:93771146ef048b34201bfa382c2bf74c524980870bb278e6df515efaf93699ff"}, {file = "yarl-1.17.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8281db240a1616af2f9c5f71d355057e73a1409c4648c8949901396dc0a3c151"}, @@ -2382,13 +2519,15 @@ version = "3.23.0" description = "Backport of pathlib-compatible object wrapper for zip files" optional = false python-versions = ">=3.9" +groups = ["dev"] +markers = "python_version == \"3.9\"" files = [ {file = "zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e"}, {file = "zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166"}, ] [package.extras] -check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"] +check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""] cover = ["pytest-cov"] doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] enabler = ["pytest-enabler (>=2.2)"] @@ -2400,6 +2539,6 @@ asyncio = ["aiohttp", "aiohttp-retry"] grpc = ["googleapis-common-protos", "grpcio", "grpcio", "grpcio", "lz4", "protobuf", "protoc-gen-openapiv2"] [metadata] -lock-version = "2.0" +lock-version = "2.1" python-versions = "^3.9" -content-hash = "181b0da9d7c63153cbf1502725f82e6817a56a8546e1bfb52453f1719e72d831" +content-hash = "750c9262ace7fa2ec88537c5dda30a0abea6ea6a1c0f8e6f01f1052beaa7a1f9" diff --git a/pyproject.toml b/pyproject.toml index ead14d0f..899ce988 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -109,6 +109,7 @@ myst-parser = [ { version = "^3.0.1", python = ">=3.9,<3.10" }, { version = "^4.0.1", python = ">=3.10" } ] +types-requests = "^2.32.4.20250913" [tool.poetry.extras] From b2d6ac5df5e3f28972a0be105e1a46bcc700db1e Mon Sep 17 00:00:00 2001 From: Silas Smith <163026730+ssmith-pc@users.noreply.github.com> Date: Fri, 3 Oct 2025 12:15:12 -0700 Subject: [PATCH 4/4] [ce] Docs search (#524) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Problem See this notebook for usage: https://colab.research.google.com/drive/1aSgSZ2iQYXfkPuE9fyZiKcXxKlZxD9bq?usp=sharing Most of this PR is generated code from the [API spec](https://github.com/pinecone-io/apis/pull/376). ### Non-generated code is here: Screenshot 2025-10-01 at 11 51 12 AM ### Type of Change - [ ] Bug fix (non-breaking change which fixes an issue) - [X] New feature (non-breaking change which adds functionality) - [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) - [X] This change requires a documentation update - [ ] Infrastructure change (CI configs, etc) - [ ] Non-code change (docs, etc) - [ ] None of the above: (explain here) ## Test Plan Manual testing. There are no automated tests yet. I'm hesitant to invest too heavily in tests while there is still so much potential for things to change on the server. --------- Co-authored-by: rohanshah18 --- .../core/openapi/repository_data/__init__.py | 14 +- .../api/document_operations_api.py | 1009 +++++++++++++---- .../openapi/repository_data/api_client.py | 1 + .../openapi/repository_data/apis/__init__.py | 1 + .../openapi/repository_data/configuration.py | 1 + .../openapi/repository_data/exceptions.py | 1 + .../model/context_options_model.py | 330 ++++++ .../model/delete_document_response.py | 132 +-- .../openapi/repository_data/model/document.py | 116 +- .../model/document_context_unit_model.py | 278 +++++ .../repository_data/model/document_list.py | 111 +- .../model/document_result_model.py | 302 +++++ .../model/get_document_response.py | 138 ++- .../model/list_documents_response.py | 144 ++- .../repository_data/model/lsn_status.py | 120 +- .../model/matched_chunk_model.py | 284 +++++ .../repository_data/model/options_model.py | 278 +++++ .../model/pagination_response.py | 116 +- .../model/query_input_model.py | 324 ++++++ .../model/query_input_model_one_of.py | 278 +++++ .../repository_data/model/query_model.py | 294 +++++ .../repository_data/model/search_documents.py | 290 +++++ .../model/search_documents_response.py | 292 +++++ .../model/upsert_document_request.py | 268 +++++ .../model/upsert_document_response.py | 126 +- .../openapi/repository_data/model/usage.py | 128 +-- .../openapi/repository_data/model_utils.py | 1 + .../repository_data/models/__init__.py | 23 +- pinecone/core/openapi/repository_data/rest.py | 1 + .../repository_data/dataclasses/__init__.py | 3 + .../dataclasses/search_query.py | 34 + pinecone/repository_data/repository.py | 34 + pinecone/repository_data/repository_search.py | 123 ++ pinecone/repository_data/request_factory.py | 32 + pinecone/repository_data/types/__init__.py | 3 + .../types/search_query_typed_dict.py | 25 + 36 files changed, 4867 insertions(+), 788 deletions(-) create mode 100644 pinecone/core/openapi/repository_data/api_client.py create mode 100644 pinecone/core/openapi/repository_data/configuration.py create mode 100644 pinecone/core/openapi/repository_data/exceptions.py create mode 100644 pinecone/core/openapi/repository_data/model/context_options_model.py create mode 100644 pinecone/core/openapi/repository_data/model/document_context_unit_model.py create mode 100644 pinecone/core/openapi/repository_data/model/document_result_model.py create mode 100644 pinecone/core/openapi/repository_data/model/matched_chunk_model.py create mode 100644 pinecone/core/openapi/repository_data/model/options_model.py create mode 100644 pinecone/core/openapi/repository_data/model/query_input_model.py create mode 100644 pinecone/core/openapi/repository_data/model/query_input_model_one_of.py create mode 100644 pinecone/core/openapi/repository_data/model/query_model.py create mode 100644 pinecone/core/openapi/repository_data/model/search_documents.py create mode 100644 pinecone/core/openapi/repository_data/model/search_documents_response.py create mode 100644 pinecone/core/openapi/repository_data/model/upsert_document_request.py create mode 100644 pinecone/core/openapi/repository_data/model_utils.py create mode 100644 pinecone/core/openapi/repository_data/rest.py create mode 100644 pinecone/repository_data/dataclasses/__init__.py create mode 100644 pinecone/repository_data/dataclasses/search_query.py create mode 100644 pinecone/repository_data/repository_search.py create mode 100644 pinecone/repository_data/request_factory.py create mode 100644 pinecone/repository_data/types/__init__.py create mode 100644 pinecone/repository_data/types/search_query_typed_dict.py diff --git a/pinecone/core/openapi/repository_data/__init__.py b/pinecone/core/openapi/repository_data/__init__.py index b661aaf5..58041610 100644 --- a/pinecone/core/openapi/repository_data/__init__.py +++ b/pinecone/core/openapi/repository_data/__init__.py @@ -1,16 +1,17 @@ # flake8: noqa """ -Pinecone Data Plane API for Repositories + Pinecone Data Plane API for Repositories -Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 -This file is @generated using OpenAPI. + This file is @generated using OpenAPI. -The version of the OpenAPI document: unstable -Contact: support@pinecone.io + The version of the OpenAPI document: unstable + Contact: support@pinecone.io """ + __version__ = "1.0.0" # import ApiClient @@ -26,5 +27,4 @@ from pinecone.openapi_support.exceptions import PineconeApiValueError from pinecone.openapi_support.exceptions import PineconeApiKeyError from pinecone.openapi_support.exceptions import PineconeApiException - -API_VERSION = "unstable" +API_VERSION = 'unstable' diff --git a/pinecone/core/openapi/repository_data/api/document_operations_api.py b/pinecone/core/openapi/repository_data/api/document_operations_api.py index 3b7e585f..86c9545d 100644 --- a/pinecone/core/openapi/repository_data/api/document_operations_api.py +++ b/pinecone/core/openapi/repository_data/api/document_operations_api.py @@ -1,19 +1,17 @@ """ -Pinecone Data Plane API for Repositories + Pinecone Data Plane API for Repositories -Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 -This file is @generated using OpenAPI. + This file is @generated using OpenAPI. -The version of the OpenAPI document: unstable -Contact: support@pinecone.io + The version of the OpenAPI document: unstable + Contact: support@pinecone.io """ + from pinecone.openapi_support import ApiClient, AsyncioApiClient -from pinecone.openapi_support.endpoint_utils import ( - ExtraOpenApiKwargsTypedDict, - KwargsWithOpenApiKwargDefaultsTypedDict, -) +from pinecone.openapi_support.endpoint_utils import ExtraOpenApiKwargsTypedDict, KwargsWithOpenApiKwargDefaultsTypedDict from pinecone.openapi_support.endpoint import Endpoint as _Endpoint, ExtraOpenApiKwargsTypedDict from pinecone.openapi_support.asyncio_endpoint import AsyncioEndpoint as _AsyncioEndpoint from pinecone.openapi_support.model_utils import ( # noqa: F401 @@ -21,18 +19,15 @@ datetime, file_type, none_type, - validate_and_convert_types, -) -from pinecone.core.openapi.repository_data.model.delete_document_response import ( - DeleteDocumentResponse, + validate_and_convert_types ) +from pinecone.core.openapi.repository_data.model.delete_document_response import DeleteDocumentResponse from pinecone.core.openapi.repository_data.model.get_document_response import GetDocumentResponse -from pinecone.core.openapi.repository_data.model.list_documents_response import ( - ListDocumentsResponse, -) -from pinecone.core.openapi.repository_data.model.upsert_document_response import ( - UpsertDocumentResponse, -) +from pinecone.core.openapi.repository_data.model.list_documents_response import ListDocumentsResponse +from pinecone.core.openapi.repository_data.model.search_documents import SearchDocuments +from pinecone.core.openapi.repository_data.model.search_documents_response import SearchDocumentsResponse +from pinecone.core.openapi.repository_data.model.upsert_document_request import UpsertDocumentRequest +from pinecone.core.openapi.repository_data.model.upsert_document_response import UpsertDocumentResponse class DocumentOperationsApi: @@ -46,19 +41,26 @@ def __init__(self, api_client=None) -> None: api_client = ApiClient() self.api_client = api_client - def __delete_document(self, namespace, document_id, **kwargs: ExtraOpenApiKwargsTypedDict): + def __delete_document( + self, + namespace, + document_id, + x_pinecone_api_version="unstable", + **kwargs: ExtraOpenApiKwargsTypedDict + ): """Delete a document from the given namespace # noqa: E501 Deletes a document from the specified namespace. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True - >>> thread = api.delete_document(namespace, document_id, async_req=True) + >>> thread = api.delete_document(namespace, document_id, x_pinecone_api_version="unstable", async_req=True) >>> result = thread.get() Args: - namespace (str): Namespace to fetch document from. - document_id (str): Document ID to fetch. + namespace (str): Namespace to delete the document from. + document_id (str): Document ID to delete. + x_pinecone_api_version (str): Required date-based version header Defaults to "unstable", must be one of ["unstable"] Keyword Args: _return_http_data_only (bool): response data without head status @@ -84,52 +86,99 @@ def __delete_document(self, namespace, document_id, **kwargs: ExtraOpenApiKwargs thread. """ kwargs = self._process_openapi_kwargs(kwargs) - kwargs["namespace"] = namespace - kwargs["document_id"] = document_id + kwargs['x_pinecone_api_version'] = \ + x_pinecone_api_version + kwargs['namespace'] = \ + namespace + kwargs['document_id'] = \ + document_id return self.call_with_http_info(**kwargs) self.delete_document = _Endpoint( settings={ - "response_type": (DeleteDocumentResponse,), - "auth": ["ApiKeyAuth"], - "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents/{document_id}", - "operation_id": "delete_document", - "http_method": "DELETE", - "servers": None, + 'response_type': (DeleteDocumentResponse,), + 'auth': [ + 'ApiKeyAuth' + ], + 'endpoint_path': '/namespaces/{namespace}/documents/{document_id}', + 'operation_id': 'delete_document', + 'http_method': 'DELETE', + 'servers': None, }, params_map={ - "all": ["namespace", "document_id"], - "required": ["namespace", "document_id"], - "nullable": [], - "enum": [], - "validation": [], + 'all': [ + 'x_pinecone_api_version', + 'namespace', + 'document_id', + ], + 'required': [ + 'x_pinecone_api_version', + 'namespace', + 'document_id', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] }, root_map={ - "validations": {}, - "allowed_values": {}, - "openapi_types": {"namespace": (str,), "document_id": (str,)}, - "attribute_map": {"namespace": "namespace", "document_id": "document_id"}, - "location_map": {"namespace": "path", "document_id": "path"}, - "collection_format_map": {}, - }, - headers_map={"accept": ["application/json"], "content_type": []}, + 'validations': { + }, + 'allowed_values': { + }, + 'openapi_types': { + 'x_pinecone_api_version': + (str,), + 'namespace': + (str,), + 'document_id': + (str,), + }, + 'attribute_map': { + 'x_pinecone_api_version': 'X-Pinecone-Api-Version', + 'namespace': 'namespace', + 'document_id': 'document_id', + }, + 'location_map': { + 'x_pinecone_api_version': 'header', + 'namespace': 'path', + 'document_id': 'path', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [], + }, api_client=api_client, - callable=__delete_document, + callable=__delete_document ) - def __get_document(self, namespace, document_id, **kwargs: ExtraOpenApiKwargsTypedDict): + def __get_document( + self, + namespace, + document_id, + x_pinecone_api_version="unstable", + **kwargs: ExtraOpenApiKwargsTypedDict + ): """Get a document from the given namespace # noqa: E501 Retrieves a document from the specified namespace. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True - >>> thread = api.get_document(namespace, document_id, async_req=True) + >>> thread = api.get_document(namespace, document_id, x_pinecone_api_version="unstable", async_req=True) >>> result = thread.get() Args: namespace (str): Namespace to fetch document from. document_id (str): Document ID to fetch. + x_pinecone_api_version (str): Required date-based version header Defaults to "unstable", must be one of ["unstable"] Keyword Args: _return_http_data_only (bool): response data without head status @@ -155,51 +204,97 @@ def __get_document(self, namespace, document_id, **kwargs: ExtraOpenApiKwargsTyp thread. """ kwargs = self._process_openapi_kwargs(kwargs) - kwargs["namespace"] = namespace - kwargs["document_id"] = document_id + kwargs['x_pinecone_api_version'] = \ + x_pinecone_api_version + kwargs['namespace'] = \ + namespace + kwargs['document_id'] = \ + document_id return self.call_with_http_info(**kwargs) self.get_document = _Endpoint( settings={ - "response_type": (GetDocumentResponse,), - "auth": ["ApiKeyAuth"], - "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents/{document_id}", - "operation_id": "get_document", - "http_method": "GET", - "servers": None, + 'response_type': (GetDocumentResponse,), + 'auth': [ + 'ApiKeyAuth' + ], + 'endpoint_path': '/namespaces/{namespace}/documents/{document_id}', + 'operation_id': 'get_document', + 'http_method': 'GET', + 'servers': None, }, params_map={ - "all": ["namespace", "document_id"], - "required": ["namespace", "document_id"], - "nullable": [], - "enum": [], - "validation": [], + 'all': [ + 'x_pinecone_api_version', + 'namespace', + 'document_id', + ], + 'required': [ + 'x_pinecone_api_version', + 'namespace', + 'document_id', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] }, root_map={ - "validations": {}, - "allowed_values": {}, - "openapi_types": {"namespace": (str,), "document_id": (str,)}, - "attribute_map": {"namespace": "namespace", "document_id": "document_id"}, - "location_map": {"namespace": "path", "document_id": "path"}, - "collection_format_map": {}, - }, - headers_map={"accept": ["application/json"], "content_type": []}, + 'validations': { + }, + 'allowed_values': { + }, + 'openapi_types': { + 'x_pinecone_api_version': + (str,), + 'namespace': + (str,), + 'document_id': + (str,), + }, + 'attribute_map': { + 'x_pinecone_api_version': 'X-Pinecone-Api-Version', + 'namespace': 'namespace', + 'document_id': 'document_id', + }, + 'location_map': { + 'x_pinecone_api_version': 'header', + 'namespace': 'path', + 'document_id': 'path', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [], + }, api_client=api_client, - callable=__get_document, + callable=__get_document ) - def __list_documents(self, namespace, **kwargs: ExtraOpenApiKwargsTypedDict): + def __list_documents( + self, + namespace, + x_pinecone_api_version="unstable", + **kwargs: ExtraOpenApiKwargsTypedDict + ): """List documents from the given namespace # noqa: E501 Lists documents from the specified namespace. (Paginated) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True - >>> thread = api.list_documents(namespace, async_req=True) + >>> thread = api.list_documents(namespace, x_pinecone_api_version="unstable", async_req=True) >>> result = thread.get() Args: namespace (str): Namespace to fetch documents from. + x_pinecone_api_version (str): Required date-based version header Defaults to "unstable", must be one of ["unstable"] Keyword Args: _return_http_data_only (bool): response data without head status @@ -225,51 +320,210 @@ def __list_documents(self, namespace, **kwargs: ExtraOpenApiKwargsTypedDict): thread. """ kwargs = self._process_openapi_kwargs(kwargs) - kwargs["namespace"] = namespace + kwargs['x_pinecone_api_version'] = \ + x_pinecone_api_version + kwargs['namespace'] = \ + namespace return self.call_with_http_info(**kwargs) self.list_documents = _Endpoint( settings={ - "response_type": (ListDocumentsResponse,), - "auth": ["ApiKeyAuth"], - "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents", - "operation_id": "list_documents", - "http_method": "GET", - "servers": None, + 'response_type': (ListDocumentsResponse,), + 'auth': [ + 'ApiKeyAuth' + ], + 'endpoint_path': '/namespaces/{namespace}/documents', + 'operation_id': 'list_documents', + 'http_method': 'GET', + 'servers': None, + }, + params_map={ + 'all': [ + 'x_pinecone_api_version', + 'namespace', + ], + 'required': [ + 'x_pinecone_api_version', + 'namespace', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] + }, + root_map={ + 'validations': { + }, + 'allowed_values': { + }, + 'openapi_types': { + 'x_pinecone_api_version': + (str,), + 'namespace': + (str,), + }, + 'attribute_map': { + 'x_pinecone_api_version': 'X-Pinecone-Api-Version', + 'namespace': 'namespace', + }, + 'location_map': { + 'x_pinecone_api_version': 'header', + 'namespace': 'path', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [], + }, + api_client=api_client, + callable=__list_documents + ) + + def __search_documents( + self, + namespace, + search_documents, + x_pinecone_api_version="unstable", + **kwargs: ExtraOpenApiKwargsTypedDict + ): + """Search the documents in the given namespace. # noqa: E501 + + Search the documents in the specified namespace. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + + >>> thread = api.search_documents(namespace, search_documents, x_pinecone_api_version="unstable", async_req=True) + >>> result = thread.get() + + Args: + namespace (str): Namespace with the documents to search. + search_documents (SearchDocuments): The configuration for performing a search. + x_pinecone_api_version (str): Required date-based version header Defaults to "unstable", must be one of ["unstable"] + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + async_req (bool): execute request asynchronously + + Returns: + SearchDocumentsResponse + If the method is called asynchronously, returns the request + thread. + """ + kwargs = self._process_openapi_kwargs(kwargs) + kwargs['x_pinecone_api_version'] = \ + x_pinecone_api_version + kwargs['namespace'] = \ + namespace + kwargs['search_documents'] = \ + search_documents + return self.call_with_http_info(**kwargs) + + self.search_documents = _Endpoint( + settings={ + 'response_type': (SearchDocumentsResponse,), + 'auth': [ + 'ApiKeyAuth' + ], + 'endpoint_path': '/namespaces/{namespace}/documents/search', + 'operation_id': 'search_documents', + 'http_method': 'POST', + 'servers': None, }, params_map={ - "all": ["namespace"], - "required": ["namespace"], - "nullable": [], - "enum": [], - "validation": [], + 'all': [ + 'x_pinecone_api_version', + 'namespace', + 'search_documents', + ], + 'required': [ + 'x_pinecone_api_version', + 'namespace', + 'search_documents', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] }, root_map={ - "validations": {}, - "allowed_values": {}, - "openapi_types": {"namespace": (str,)}, - "attribute_map": {"namespace": "namespace"}, - "location_map": {"namespace": "path"}, - "collection_format_map": {}, - }, - headers_map={"accept": ["application/json"], "content_type": []}, + 'validations': { + }, + 'allowed_values': { + }, + 'openapi_types': { + 'x_pinecone_api_version': + (str,), + 'namespace': + (str,), + 'search_documents': + (SearchDocuments,), + }, + 'attribute_map': { + 'x_pinecone_api_version': 'X-Pinecone-Api-Version', + 'namespace': 'namespace', + }, + 'location_map': { + 'x_pinecone_api_version': 'header', + 'namespace': 'path', + 'search_documents': 'body', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [ + 'application/json' + ] + }, api_client=api_client, - callable=__list_documents, + callable=__search_documents ) - def __upsert_document(self, namespace, request_body, **kwargs: ExtraOpenApiKwargsTypedDict): + def __upsert_document( + self, + namespace, + upsert_document_request, + x_pinecone_api_version="unstable", + **kwargs: ExtraOpenApiKwargsTypedDict + ): """Create or update a document in the given namespace # noqa: E501 Upserts a document into the specified namespace. The request body may contain any valid JSON document that conforms to the schema. Optionally, an `_id` field can be provided to use as the document's identifier; if omitted, the system will assign one. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True - >>> thread = api.upsert_document(namespace, request_body, async_req=True) + >>> thread = api.upsert_document(namespace, upsert_document_request, x_pinecone_api_version="unstable", async_req=True) >>> result = thread.get() Args: namespace (str): Namespace where the document will be stored. - request_body ({str: (bool, dict, float, int, list, str, none_type)}): + upsert_document_request (UpsertDocumentRequest): + x_pinecone_api_version (str): Required date-based version header Defaults to "unstable", must be one of ["unstable"] Keyword Args: _return_http_data_only (bool): response data without head status @@ -295,43 +549,82 @@ def __upsert_document(self, namespace, request_body, **kwargs: ExtraOpenApiKwarg thread. """ kwargs = self._process_openapi_kwargs(kwargs) - kwargs["namespace"] = namespace - kwargs["request_body"] = request_body + kwargs['x_pinecone_api_version'] = \ + x_pinecone_api_version + kwargs['namespace'] = \ + namespace + kwargs['upsert_document_request'] = \ + upsert_document_request return self.call_with_http_info(**kwargs) self.upsert_document = _Endpoint( settings={ - "response_type": (UpsertDocumentResponse,), - "auth": ["ApiKeyAuth"], - "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents/upsert", - "operation_id": "upsert_document", - "http_method": "POST", - "servers": None, + 'response_type': (UpsertDocumentResponse,), + 'auth': [ + 'ApiKeyAuth' + ], + 'endpoint_path': '/namespaces/{namespace}/documents/upsert', + 'operation_id': 'upsert_document', + 'http_method': 'POST', + 'servers': None, }, params_map={ - "all": ["namespace", "request_body"], - "required": ["namespace", "request_body"], - "nullable": [], - "enum": [], - "validation": [], + 'all': [ + 'x_pinecone_api_version', + 'namespace', + 'upsert_document_request', + ], + 'required': [ + 'x_pinecone_api_version', + 'namespace', + 'upsert_document_request', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] }, root_map={ - "validations": {}, - "allowed_values": {}, - "openapi_types": { - "namespace": (str,), - "request_body": ({str: (bool, dict, float, int, list, str, none_type)},), + 'validations': { }, - "attribute_map": {"namespace": "namespace"}, - "location_map": {"namespace": "path", "request_body": "body"}, - "collection_format_map": {}, + 'allowed_values': { + }, + 'openapi_types': { + 'x_pinecone_api_version': + (str,), + 'namespace': + (str,), + 'upsert_document_request': + (UpsertDocumentRequest,), + }, + 'attribute_map': { + 'x_pinecone_api_version': 'X-Pinecone-Api-Version', + 'namespace': 'namespace', + }, + 'location_map': { + 'x_pinecone_api_version': 'header', + 'namespace': 'path', + 'upsert_document_request': 'body', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [ + 'application/json' + ] }, - headers_map={"accept": ["application/json"], "content_type": ["application/json"]}, api_client=api_client, - callable=__upsert_document, + callable=__upsert_document ) + class AsyncioDocumentOperationsApi: """NOTE: This class is @generated using OpenAPI @@ -343,15 +636,22 @@ def __init__(self, api_client=None) -> None: api_client = AsyncioApiClient() self.api_client = api_client - async def __delete_document(self, namespace, document_id, **kwargs): + async def __delete_document( + self, + namespace, + document_id, + x_pinecone_api_version="unstable", + **kwargs + ): """Delete a document from the given namespace # noqa: E501 Deletes a document from the specified namespace. # noqa: E501 Args: - namespace (str): Namespace to fetch document from. - document_id (str): Document ID to fetch. + namespace (str): Namespace to delete the document from. + document_id (str): Document ID to delete. + x_pinecone_api_version (str): Required date-based version header Defaults to "unstable", must be one of ["unstable"] Keyword Args: _return_http_data_only (bool): response data without head status @@ -374,40 +674,86 @@ async def __delete_document(self, namespace, document_id, **kwargs): DeleteDocumentResponse """ self._process_openapi_kwargs(kwargs) - kwargs["namespace"] = namespace - kwargs["document_id"] = document_id + kwargs['x_pinecone_api_version'] = \ + x_pinecone_api_version + kwargs['namespace'] = \ + namespace + kwargs['document_id'] = \ + document_id return await self.call_with_http_info(**kwargs) self.delete_document = _AsyncioEndpoint( settings={ - "response_type": (DeleteDocumentResponse,), - "auth": ["ApiKeyAuth"], - "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents/{document_id}", - "operation_id": "delete_document", - "http_method": "DELETE", - "servers": None, + 'response_type': (DeleteDocumentResponse,), + 'auth': [ + 'ApiKeyAuth' + ], + 'endpoint_path': '/namespaces/{namespace}/documents/{document_id}', + 'operation_id': 'delete_document', + 'http_method': 'DELETE', + 'servers': None, }, params_map={ - "all": ["namespace", "document_id"], - "required": ["namespace", "document_id"], - "nullable": [], - "enum": [], - "validation": [], + 'all': [ + 'x_pinecone_api_version', + 'namespace', + 'document_id', + ], + 'required': [ + 'x_pinecone_api_version', + 'namespace', + 'document_id', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] }, root_map={ - "validations": {}, - "allowed_values": {}, - "openapi_types": {"namespace": (str,), "document_id": (str,)}, - "attribute_map": {"namespace": "namespace", "document_id": "document_id"}, - "location_map": {"namespace": "path", "document_id": "path"}, - "collection_format_map": {}, - }, - headers_map={"accept": ["application/json"], "content_type": []}, + 'validations': { + }, + 'allowed_values': { + }, + 'openapi_types': { + 'x_pinecone_api_version': + (str,), + 'namespace': + (str,), + 'document_id': + (str,), + }, + 'attribute_map': { + 'x_pinecone_api_version': 'X-Pinecone-Api-Version', + 'namespace': 'namespace', + 'document_id': 'document_id', + }, + 'location_map': { + 'x_pinecone_api_version': 'header', + 'namespace': 'path', + 'document_id': 'path', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [], + }, api_client=api_client, - callable=__delete_document, + callable=__delete_document ) - async def __get_document(self, namespace, document_id, **kwargs): + async def __get_document( + self, + namespace, + document_id, + x_pinecone_api_version="unstable", + **kwargs + ): """Get a document from the given namespace # noqa: E501 Retrieves a document from the specified namespace. # noqa: E501 @@ -416,6 +762,7 @@ async def __get_document(self, namespace, document_id, **kwargs): Args: namespace (str): Namespace to fetch document from. document_id (str): Document ID to fetch. + x_pinecone_api_version (str): Required date-based version header Defaults to "unstable", must be one of ["unstable"] Keyword Args: _return_http_data_only (bool): response data without head status @@ -438,40 +785,85 @@ async def __get_document(self, namespace, document_id, **kwargs): GetDocumentResponse """ self._process_openapi_kwargs(kwargs) - kwargs["namespace"] = namespace - kwargs["document_id"] = document_id + kwargs['x_pinecone_api_version'] = \ + x_pinecone_api_version + kwargs['namespace'] = \ + namespace + kwargs['document_id'] = \ + document_id return await self.call_with_http_info(**kwargs) self.get_document = _AsyncioEndpoint( settings={ - "response_type": (GetDocumentResponse,), - "auth": ["ApiKeyAuth"], - "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents/{document_id}", - "operation_id": "get_document", - "http_method": "GET", - "servers": None, + 'response_type': (GetDocumentResponse,), + 'auth': [ + 'ApiKeyAuth' + ], + 'endpoint_path': '/namespaces/{namespace}/documents/{document_id}', + 'operation_id': 'get_document', + 'http_method': 'GET', + 'servers': None, }, params_map={ - "all": ["namespace", "document_id"], - "required": ["namespace", "document_id"], - "nullable": [], - "enum": [], - "validation": [], + 'all': [ + 'x_pinecone_api_version', + 'namespace', + 'document_id', + ], + 'required': [ + 'x_pinecone_api_version', + 'namespace', + 'document_id', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] }, root_map={ - "validations": {}, - "allowed_values": {}, - "openapi_types": {"namespace": (str,), "document_id": (str,)}, - "attribute_map": {"namespace": "namespace", "document_id": "document_id"}, - "location_map": {"namespace": "path", "document_id": "path"}, - "collection_format_map": {}, - }, - headers_map={"accept": ["application/json"], "content_type": []}, + 'validations': { + }, + 'allowed_values': { + }, + 'openapi_types': { + 'x_pinecone_api_version': + (str,), + 'namespace': + (str,), + 'document_id': + (str,), + }, + 'attribute_map': { + 'x_pinecone_api_version': 'X-Pinecone-Api-Version', + 'namespace': 'namespace', + 'document_id': 'document_id', + }, + 'location_map': { + 'x_pinecone_api_version': 'header', + 'namespace': 'path', + 'document_id': 'path', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [], + }, api_client=api_client, - callable=__get_document, + callable=__get_document ) - async def __list_documents(self, namespace, **kwargs): + async def __list_documents( + self, + namespace, + x_pinecone_api_version="unstable", + **kwargs + ): """List documents from the given namespace # noqa: E501 Lists documents from the specified namespace. (Paginated) # noqa: E501 @@ -479,6 +871,7 @@ async def __list_documents(self, namespace, **kwargs): Args: namespace (str): Namespace to fetch documents from. + x_pinecone_api_version (str): Required date-based version header Defaults to "unstable", must be one of ["unstable"] Keyword Args: _return_http_data_only (bool): response data without head status @@ -501,39 +894,190 @@ async def __list_documents(self, namespace, **kwargs): ListDocumentsResponse """ self._process_openapi_kwargs(kwargs) - kwargs["namespace"] = namespace + kwargs['x_pinecone_api_version'] = \ + x_pinecone_api_version + kwargs['namespace'] = \ + namespace return await self.call_with_http_info(**kwargs) self.list_documents = _AsyncioEndpoint( settings={ - "response_type": (ListDocumentsResponse,), - "auth": ["ApiKeyAuth"], - "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents", - "operation_id": "list_documents", - "http_method": "GET", - "servers": None, + 'response_type': (ListDocumentsResponse,), + 'auth': [ + 'ApiKeyAuth' + ], + 'endpoint_path': '/namespaces/{namespace}/documents', + 'operation_id': 'list_documents', + 'http_method': 'GET', + 'servers': None, + }, + params_map={ + 'all': [ + 'x_pinecone_api_version', + 'namespace', + ], + 'required': [ + 'x_pinecone_api_version', + 'namespace', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] + }, + root_map={ + 'validations': { + }, + 'allowed_values': { + }, + 'openapi_types': { + 'x_pinecone_api_version': + (str,), + 'namespace': + (str,), + }, + 'attribute_map': { + 'x_pinecone_api_version': 'X-Pinecone-Api-Version', + 'namespace': 'namespace', + }, + 'location_map': { + 'x_pinecone_api_version': 'header', + 'namespace': 'path', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [], + }, + api_client=api_client, + callable=__list_documents + ) + + async def __search_documents( + self, + namespace, + search_documents, + x_pinecone_api_version="unstable", + **kwargs + ): + """Search the documents in the given namespace. # noqa: E501 + + Search the documents in the specified namespace. # noqa: E501 + + + Args: + namespace (str): Namespace with the documents to search. + search_documents (SearchDocuments): The configuration for performing a search. + x_pinecone_api_version (str): Required date-based version header Defaults to "unstable", must be one of ["unstable"] + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): 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. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + + Returns: + SearchDocumentsResponse + """ + self._process_openapi_kwargs(kwargs) + kwargs['x_pinecone_api_version'] = \ + x_pinecone_api_version + kwargs['namespace'] = \ + namespace + kwargs['search_documents'] = \ + search_documents + return await self.call_with_http_info(**kwargs) + + self.search_documents = _AsyncioEndpoint( + settings={ + 'response_type': (SearchDocumentsResponse,), + 'auth': [ + 'ApiKeyAuth' + ], + 'endpoint_path': '/namespaces/{namespace}/documents/search', + 'operation_id': 'search_documents', + 'http_method': 'POST', + 'servers': None, }, params_map={ - "all": ["namespace"], - "required": ["namespace"], - "nullable": [], - "enum": [], - "validation": [], + 'all': [ + 'x_pinecone_api_version', + 'namespace', + 'search_documents', + ], + 'required': [ + 'x_pinecone_api_version', + 'namespace', + 'search_documents', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] }, root_map={ - "validations": {}, - "allowed_values": {}, - "openapi_types": {"namespace": (str,)}, - "attribute_map": {"namespace": "namespace"}, - "location_map": {"namespace": "path"}, - "collection_format_map": {}, - }, - headers_map={"accept": ["application/json"], "content_type": []}, + 'validations': { + }, + 'allowed_values': { + }, + 'openapi_types': { + 'x_pinecone_api_version': + (str,), + 'namespace': + (str,), + 'search_documents': + (SearchDocuments,), + }, + 'attribute_map': { + 'x_pinecone_api_version': 'X-Pinecone-Api-Version', + 'namespace': 'namespace', + }, + 'location_map': { + 'x_pinecone_api_version': 'header', + 'namespace': 'path', + 'search_documents': 'body', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [ + 'application/json' + ] + }, api_client=api_client, - callable=__list_documents, + callable=__search_documents ) - async def __upsert_document(self, namespace, request_body, **kwargs): + async def __upsert_document( + self, + namespace, + upsert_document_request, + x_pinecone_api_version="unstable", + **kwargs + ): """Create or update a document in the given namespace # noqa: E501 Upserts a document into the specified namespace. The request body may contain any valid JSON document that conforms to the schema. Optionally, an `_id` field can be provided to use as the document's identifier; if omitted, the system will assign one. # noqa: E501 @@ -541,7 +1085,8 @@ async def __upsert_document(self, namespace, request_body, **kwargs): Args: namespace (str): Namespace where the document will be stored. - request_body ({str: (bool, dict, float, int, list, str, none_type)}): + upsert_document_request (UpsertDocumentRequest): + x_pinecone_api_version (str): Required date-based version header Defaults to "unstable", must be one of ["unstable"] Keyword Args: _return_http_data_only (bool): response data without head status @@ -564,38 +1109,76 @@ async def __upsert_document(self, namespace, request_body, **kwargs): UpsertDocumentResponse """ self._process_openapi_kwargs(kwargs) - kwargs["namespace"] = namespace - kwargs["request_body"] = request_body + kwargs['x_pinecone_api_version'] = \ + x_pinecone_api_version + kwargs['namespace'] = \ + namespace + kwargs['upsert_document_request'] = \ + upsert_document_request return await self.call_with_http_info(**kwargs) self.upsert_document = _AsyncioEndpoint( settings={ - "response_type": (UpsertDocumentResponse,), - "auth": ["ApiKeyAuth"], - "endpoint_path": "/ckb-stub-namespaces/{namespace}/documents/upsert", - "operation_id": "upsert_document", - "http_method": "POST", - "servers": None, + 'response_type': (UpsertDocumentResponse,), + 'auth': [ + 'ApiKeyAuth' + ], + 'endpoint_path': '/namespaces/{namespace}/documents/upsert', + 'operation_id': 'upsert_document', + 'http_method': 'POST', + 'servers': None, }, params_map={ - "all": ["namespace", "request_body"], - "required": ["namespace", "request_body"], - "nullable": [], - "enum": [], - "validation": [], + 'all': [ + 'x_pinecone_api_version', + 'namespace', + 'upsert_document_request', + ], + 'required': [ + 'x_pinecone_api_version', + 'namespace', + 'upsert_document_request', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] }, root_map={ - "validations": {}, - "allowed_values": {}, - "openapi_types": { - "namespace": (str,), - "request_body": ({str: (bool, dict, float, int, list, str, none_type)},), + 'validations': { + }, + 'allowed_values': { }, - "attribute_map": {"namespace": "namespace"}, - "location_map": {"namespace": "path", "request_body": "body"}, - "collection_format_map": {}, + 'openapi_types': { + 'x_pinecone_api_version': + (str,), + 'namespace': + (str,), + 'upsert_document_request': + (UpsertDocumentRequest,), + }, + 'attribute_map': { + 'x_pinecone_api_version': 'X-Pinecone-Api-Version', + 'namespace': 'namespace', + }, + 'location_map': { + 'x_pinecone_api_version': 'header', + 'namespace': 'path', + 'upsert_document_request': 'body', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [ + 'application/json' + ] }, - headers_map={"accept": ["application/json"], "content_type": ["application/json"]}, api_client=api_client, - callable=__upsert_document, + callable=__upsert_document ) diff --git a/pinecone/core/openapi/repository_data/api_client.py b/pinecone/core/openapi/repository_data/api_client.py new file mode 100644 index 00000000..8cf9e891 --- /dev/null +++ b/pinecone/core/openapi/repository_data/api_client.py @@ -0,0 +1 @@ +# Deleted diff --git a/pinecone/core/openapi/repository_data/apis/__init__.py b/pinecone/core/openapi/repository_data/apis/__init__.py index 44f505a0..5a768f10 100644 --- a/pinecone/core/openapi/repository_data/apis/__init__.py +++ b/pinecone/core/openapi/repository_data/apis/__init__.py @@ -1,3 +1,4 @@ + # flake8: noqa # Import all APIs into this package. diff --git a/pinecone/core/openapi/repository_data/configuration.py b/pinecone/core/openapi/repository_data/configuration.py new file mode 100644 index 00000000..8cf9e891 --- /dev/null +++ b/pinecone/core/openapi/repository_data/configuration.py @@ -0,0 +1 @@ +# Deleted diff --git a/pinecone/core/openapi/repository_data/exceptions.py b/pinecone/core/openapi/repository_data/exceptions.py new file mode 100644 index 00000000..8cf9e891 --- /dev/null +++ b/pinecone/core/openapi/repository_data/exceptions.py @@ -0,0 +1 @@ +# Deleted diff --git a/pinecone/core/openapi/repository_data/model/context_options_model.py b/pinecone/core/openapi/repository_data/model/context_options_model.py new file mode 100644 index 00000000..f02d91f3 --- /dev/null +++ b/pinecone/core/openapi/repository_data/model/context_options_model.py @@ -0,0 +1,330 @@ +""" + Pinecone Data Plane API for Repositories + + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + + This file is @generated using OpenAPI. + + The version of the OpenAPI document: unstable + Contact: support@pinecone.io +""" + + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_data.model.document_context_unit_model import DocumentContextUnitModel + globals()['DocumentContextUnitModel'] = DocumentContextUnitModel + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="ContextOptionsModel") + + +class ContextOptionsModel(ModelComposed): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + 'unit': (str,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + lazy_import() + val = { + 'DocumentContextUnitModel': DocumentContextUnitModel, + 'document': DocumentContextUnitModel, + } + if not val: + return None + return {'unit': val} + + attribute_map: Dict[str, str] = { + 'unit': 'unit', # noqa: E501 + } + + read_only_vars: Set[str] = set([ + ]) + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 + """ContextOptionsModel - a model defined in OpenAPI + + Keyword Args: + unit (str): The search result context unit. Always \"document\". + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + constant_args = { + '_check_type': _check_type, + '_path_to_item': _path_to_item, + '_spec_property_naming': _spec_property_naming, + '_configuration': _configuration, + '_visited_composed_classes': self._visited_composed_classes, + } + composed_info = validate_get_composed_info( + constant_args, kwargs, self) + self._composed_instances = composed_info[0] + self._var_name_to_model_instances = composed_info[1] + self._additional_properties_model_instances = composed_info[2] + discarded_args = composed_info[3] + + for var_name, var_value in kwargs.items(): + if var_name in discarded_args and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self._additional_properties_model_instances: + # discard variable. + continue + setattr(self, var_name, var_value) + + return self + + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + '_composed_instances', + '_var_name_to_model_instances', + '_additional_properties_model_instances', + ]) + + @convert_js_args_to_python_args + def __init__(self, *args, **kwargs) -> None: # noqa: E501 + """ContextOptionsModel - a model defined in OpenAPI + + Keyword Args: + unit (str): The search result context unit. Always \"document\". + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', True) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + constant_args = { + '_check_type': _check_type, + '_path_to_item': _path_to_item, + '_spec_property_naming': _spec_property_naming, + '_configuration': _configuration, + '_visited_composed_classes': self._visited_composed_classes, + } + composed_info = validate_get_composed_info( + constant_args, kwargs, self) + self._composed_instances = composed_info[0] + self._var_name_to_model_instances = composed_info[1] + self._additional_properties_model_instances = composed_info[2] + discarded_args = composed_info[3] + + for var_name, var_value in kwargs.items(): + if var_name in discarded_args and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self._additional_properties_model_instances: + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") + + @cached_property + def _composed_schemas(): # type: ignore + # we need this here to make our import statements work + # we must store _composed_schemas in here so the code is only run + # when we invoke this method. If we kept this at the class + # level we would get an error beause the class level + # code would be run when this module is imported, and these composed + # classes don't exist yet because their module has not finished + # loading + lazy_import() + return { + 'anyOf': [ + ], + 'allOf': [ + ], + 'oneOf': [ + DocumentContextUnitModel, + ], + } diff --git a/pinecone/core/openapi/repository_data/model/delete_document_response.py b/pinecone/core/openapi/repository_data/model/delete_document_response.py index f1607674..43056899 100644 --- a/pinecone/core/openapi/repository_data/model/delete_document_response.py +++ b/pinecone/core/openapi/repository_data/model/delete_document_response.py @@ -1,14 +1,15 @@ """ -Pinecone Data Plane API for Repositories + Pinecone Data Plane API for Repositories -Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 -This file is @generated using OpenAPI. + This file is @generated using OpenAPI. -The version of the OpenAPI document: unstable -Contact: support@pinecone.io + The version of the OpenAPI document: unstable + Contact: support@pinecone.io """ + from pinecone.openapi_support.model_utils import ( # noqa: F401 PineconeApiTypeError, ModelComposed, @@ -30,9 +31,8 @@ def lazy_import(): from pinecone.core.openapi.repository_data.model.lsn_status import LSNStatus from pinecone.core.openapi.repository_data.model.usage import Usage - - globals()["LSNStatus"] = LSNStatus - globals()["Usage"] = Usage + globals()['LSNStatus'] = LSNStatus + globals()['Usage'] = Usage from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar @@ -67,9 +67,11 @@ class DeleteDocumentResponse(ModelNormal): _data_store: Dict[str, Any] _check_type: bool - allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } - validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } @cached_class_property def additional_properties_type(cls): @@ -78,7 +80,7 @@ def additional_properties_type(cls): of type self, this must run after the class is loaded """ lazy_import() - return (bool, dict, float, int, list, str, none_type) # noqa: E501 + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 _nullable = False @@ -94,26 +96,28 @@ def openapi_types(cls): """ lazy_import() return { - "id": (str,), # noqa: E501 - "namespace": (str,), # noqa: E501 - "usage": (Usage,), # noqa: E501 - "lsn_status": (LSNStatus,), # noqa: E501 + 'id': (str,), # noqa: E501 + 'namespace': (str,), # noqa: E501 + 'usage': (Usage,), # noqa: E501 + 'lsn_status': (LSNStatus,), # noqa: E501 } @cached_class_property def discriminator(cls): return None + attribute_map: Dict[str, str] = { - "id": "_id", # noqa: E501 - "namespace": "namespace", # noqa: E501 - "usage": "usage", # noqa: E501 - "lsn_status": "_lsn_status", # noqa: E501 + 'id': '_id', # noqa: E501 + 'namespace': 'namespace', # noqa: E501 + 'usage': 'usage', # noqa: E501 + 'lsn_status': '_lsn_status', # noqa: E501 } - read_only_vars: Set[str] = set([]) + read_only_vars: Set[str] = set([ + ]) - _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} @classmethod @convert_js_args_to_python_args @@ -159,20 +163,22 @@ def _from_openapi_data(cls: Type[T], id, namespace, usage, lsn_status, *args, ** _visited_composed_classes = (Animal,) """ - _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) - _enforce_validations = kwargs.pop("_enforce_validations", False) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) self = super(OpenApiModel, cls).__new__(cls) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -191,29 +197,25 @@ def _from_openapi_data(cls: Type[T], id, namespace, usage, lsn_status, *args, ** self.usage = usage self.lsn_status = lsn_status for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) return self - required_properties = set( - [ - "_enforce_allowed_values", - "_enforce_validations", - "_data_store", - "_check_type", - "_spec_property_naming", - "_path_to_item", - "_configuration", - "_visited_composed_classes", - ] - ) + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) @convert_js_args_to_python_args def __init__(self, id, namespace, usage, lsn_status, *args, **kwargs) -> None: # noqa: E501 @@ -259,17 +261,19 @@ def __init__(self, id, namespace, usage, lsn_status, *args, **kwargs) -> None: """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) - _enforce_validations = kwargs.pop("_enforce_validations", True) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -288,17 +292,13 @@ def __init__(self, id, namespace, usage, lsn_status, *args, **kwargs) -> None: self.usage = usage self.lsn_status = lsn_status for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) if var_name in self.read_only_vars: - raise PineconeApiAttributeError( - f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " - f"class with read only attributes." - ) + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/document.py b/pinecone/core/openapi/repository_data/model/document.py index 46ac58c3..f21d2ea0 100644 --- a/pinecone/core/openapi/repository_data/model/document.py +++ b/pinecone/core/openapi/repository_data/model/document.py @@ -1,14 +1,15 @@ """ -Pinecone Data Plane API for Repositories + Pinecone Data Plane API for Repositories -Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 -This file is @generated using OpenAPI. + This file is @generated using OpenAPI. -The version of the OpenAPI document: unstable -Contact: support@pinecone.io + The version of the OpenAPI document: unstable + Contact: support@pinecone.io """ + from pinecone.openapi_support.model_utils import ( # noqa: F401 PineconeApiTypeError, ModelComposed, @@ -27,6 +28,7 @@ from pinecone.openapi_support.exceptions import PineconeApiAttributeError + from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property @@ -59,9 +61,11 @@ class Document(ModelNormal): _data_store: Dict[str, Any] _check_type: bool - allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } - validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } @cached_class_property def additional_properties_type(cls): @@ -69,7 +73,7 @@ def additional_properties_type(cls): This must be a method because a model may have properties that are of type self, this must run after the class is loaded """ - return (bool, dict, float, int, list, str, none_type) # noqa: E501 + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 _nullable = False @@ -84,20 +88,22 @@ def openapi_types(cls): and the value is attribute type. """ return { - "id": (str,) # noqa: E501 + 'id': (str,), # noqa: E501 } @cached_class_property def discriminator(cls): return None + attribute_map: Dict[str, str] = { - "id": "_id" # noqa: E501 + 'id': '_id', # noqa: E501 } - read_only_vars: Set[str] = set([]) + read_only_vars: Set[str] = set([ + ]) - _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} @classmethod @convert_js_args_to_python_args @@ -140,20 +146,22 @@ def _from_openapi_data(cls: Type[T], id, *args, **kwargs) -> T: # noqa: E501 _visited_composed_classes = (Animal,) """ - _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) - _enforce_validations = kwargs.pop("_enforce_validations", False) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) self = super(OpenApiModel, cls).__new__(cls) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -169,29 +177,25 @@ def _from_openapi_data(cls: Type[T], id, *args, **kwargs) -> T: # noqa: E501 self.id = id for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) return self - required_properties = set( - [ - "_enforce_allowed_values", - "_enforce_validations", - "_data_store", - "_check_type", - "_spec_property_naming", - "_path_to_item", - "_configuration", - "_visited_composed_classes", - ] - ) + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) @convert_js_args_to_python_args def __init__(self, id, *args, **kwargs) -> None: # noqa: E501 @@ -234,17 +238,19 @@ def __init__(self, id, *args, **kwargs) -> None: # noqa: E501 """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) - _enforce_validations = kwargs.pop("_enforce_validations", True) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -260,17 +266,13 @@ def __init__(self, id, *args, **kwargs) -> None: # noqa: E501 self.id = id for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) if var_name in self.read_only_vars: - raise PineconeApiAttributeError( - f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " - f"class with read only attributes." - ) + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/document_context_unit_model.py b/pinecone/core/openapi/repository_data/model/document_context_unit_model.py new file mode 100644 index 00000000..705c2084 --- /dev/null +++ b/pinecone/core/openapi/repository_data/model/document_context_unit_model.py @@ -0,0 +1,278 @@ +""" + Pinecone Data Plane API for Repositories + + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + + This file is @generated using OpenAPI. + + The version of the OpenAPI document: unstable + Contact: support@pinecone.io +""" + + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="DocumentContextUnitModel") + + +class DocumentContextUnitModel(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return { + 'unit': (str,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + + attribute_map: Dict[str, str] = { + 'unit': 'unit', # noqa: E501 + } + + read_only_vars: Set[str] = set([ + ]) + + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], unit, *args, **kwargs) -> T: # noqa: E501 + """DocumentContextUnitModel - a model defined in OpenAPI + + Args: + unit (str): The search result context unit. Always \"document\". + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.unit = unit + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) + + @convert_js_args_to_python_args + def __init__(self, unit, *args, **kwargs) -> None: # noqa: E501 + """DocumentContextUnitModel - a model defined in OpenAPI + + Args: + unit (str): The search result context unit. Always \"document\". + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.unit = unit + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/document_list.py b/pinecone/core/openapi/repository_data/model/document_list.py index 55532fc5..eeb0fe8e 100644 --- a/pinecone/core/openapi/repository_data/model/document_list.py +++ b/pinecone/core/openapi/repository_data/model/document_list.py @@ -1,14 +1,15 @@ """ -Pinecone Data Plane API for Repositories + Pinecone Data Plane API for Repositories -Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 -This file is @generated using OpenAPI. + This file is @generated using OpenAPI. -The version of the OpenAPI document: unstable -Contact: support@pinecone.io + The version of the OpenAPI document: unstable + Contact: support@pinecone.io """ + from pinecone.openapi_support.model_utils import ( # noqa: F401 PineconeApiTypeError, ModelComposed, @@ -29,8 +30,7 @@ def lazy_import(): from pinecone.core.openapi.repository_data.model.document import Document - - globals()["Document"] = Document + globals()['Document'] = Document from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar @@ -61,9 +61,11 @@ class DocumentList(ModelSimple): _data_store: Dict[str, Any] _check_type: bool - allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } - validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } @cached_class_property def additional_properties_type(cls): @@ -72,7 +74,7 @@ def additional_properties_type(cls): of type self, this must run after the class is loaded """ lazy_import() - return (bool, dict, float, int, list, str, none_type) # noqa: E501 + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 _nullable = False @@ -87,30 +89,31 @@ def openapi_types(cls): and the value is attribute type. """ lazy_import() - return {"value": ([Document],)} + return { + 'value': ([Document],), + } @cached_class_property def discriminator(cls): return None + attribute_map: Dict[str, str] = {} read_only_vars: Set[str] = set() _composed_schemas = None - required_properties = set( - [ - "_enforce_allowed_values", - "_enforce_validations", - "_data_store", - "_check_type", - "_spec_property_naming", - "_path_to_item", - "_configuration", - "_visited_composed_classes", - ] - ) + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) @convert_js_args_to_python_args def __init__(self, *args, **kwargs) -> None: @@ -155,19 +158,21 @@ def __init__(self, *args, **kwargs) -> None: _visited_composed_classes = (Animal,) """ # required up here when default value is not given - _path_to_item = kwargs.pop("_path_to_item", ()) + _path_to_item = kwargs.pop('_path_to_item', ()) value = None - if "value" in kwargs: - value = kwargs.pop("value") + if 'value' in kwargs: + value = kwargs.pop('value') if value is None and args: if len(args) == 1: value = args[0] elif len(args) > 1: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -179,12 +184,13 @@ def __init__(self, *args, **kwargs) -> None: valid_classes=(self.__class__,), ) - _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) - _enforce_validations = kwargs.pop("_enforce_validations", True) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', True) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) self._data_store = {} self._enforce_allowed_values = _enforce_allowed_values @@ -197,8 +203,10 @@ def __init__(self, *args, **kwargs) -> None: self.value = value if kwargs: raise PineconeApiTypeError( - "Invalid named arguments=%s passed to %s. Remove those invalid named arguments." - % (kwargs, self.__class__.__name__), + "Invalid named arguments=%s passed to %s. Remove those invalid named arguments." % ( + kwargs, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -247,21 +255,23 @@ def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: _visited_composed_classes = (Animal,) """ # required up here when default value is not given - _path_to_item = kwargs.pop("_path_to_item", ()) + _path_to_item = kwargs.pop('_path_to_item', ()) self = super(OpenApiModel, cls).__new__(cls) value = None - if "value" in kwargs: - value = kwargs.pop("value") + if 'value' in kwargs: + value = kwargs.pop('value') if value is None and args: if len(args) == 1: value = args[0] elif len(args) > 1: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -273,12 +283,13 @@ def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: valid_classes=(self.__class__,), ) - _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) - _enforce_validations = kwargs.pop("_enforce_validations", False) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) self._data_store = {} self._enforce_allowed_values = _enforce_allowed_values @@ -291,8 +302,10 @@ def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: self.value = value if kwargs: raise PineconeApiTypeError( - "Invalid named arguments=%s passed to %s. Remove those invalid named arguments." - % (kwargs, self.__class__.__name__), + "Invalid named arguments=%s passed to %s. Remove those invalid named arguments." % ( + kwargs, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) diff --git a/pinecone/core/openapi/repository_data/model/document_result_model.py b/pinecone/core/openapi/repository_data/model/document_result_model.py new file mode 100644 index 00000000..132e7adc --- /dev/null +++ b/pinecone/core/openapi/repository_data/model/document_result_model.py @@ -0,0 +1,302 @@ +""" + Pinecone Data Plane API for Repositories + + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + + This file is @generated using OpenAPI. + + The version of the OpenAPI document: unstable + Contact: support@pinecone.io +""" + + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_data.model.matched_chunk_model import MatchedChunkModel + globals()['MatchedChunkModel'] = MatchedChunkModel + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="DocumentResultModel") + + +class DocumentResultModel(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + 'score': (float,), # noqa: E501 + 'id': (str,), # noqa: E501 + 'document': ({str: (bool, dict, float, int, list, str, none_type)},), # noqa: E501 + 'matching_chunks': ([MatchedChunkModel],), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + + attribute_map: Dict[str, str] = { + 'score': 'score', # noqa: E501 + 'id': '_id', # noqa: E501 + 'document': 'document', # noqa: E501 + 'matching_chunks': 'matching_chunks', # noqa: E501 + } + + read_only_vars: Set[str] = set([ + ]) + + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], score, id, document, matching_chunks, *args, **kwargs) -> T: # noqa: E501 + """DocumentResultModel - a model defined in OpenAPI + + Args: + score (float): The relevance of the document to the query. + id (str): The ID of the document. + document ({str: (bool, dict, float, int, list, str, none_type)}): The document JSON, which may include the entire document or only a relevant part of it. + matching_chunks ([MatchedChunkModel]): List of chunks within the document that matched the query. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.score = score + self.id = id + self.document = document + self.matching_chunks = matching_chunks + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) + + @convert_js_args_to_python_args + def __init__(self, score, id, document, matching_chunks, *args, **kwargs) -> None: # noqa: E501 + """DocumentResultModel - a model defined in OpenAPI + + Args: + score (float): The relevance of the document to the query. + id (str): The ID of the document. + document ({str: (bool, dict, float, int, list, str, none_type)}): The document JSON, which may include the entire document or only a relevant part of it. + matching_chunks ([MatchedChunkModel]): List of chunks within the document that matched the query. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.score = score + self.id = id + self.document = document + self.matching_chunks = matching_chunks + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/get_document_response.py b/pinecone/core/openapi/repository_data/model/get_document_response.py index 7ff1afb3..d467a5d0 100644 --- a/pinecone/core/openapi/repository_data/model/get_document_response.py +++ b/pinecone/core/openapi/repository_data/model/get_document_response.py @@ -1,14 +1,15 @@ """ -Pinecone Data Plane API for Repositories + Pinecone Data Plane API for Repositories -Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 -This file is @generated using OpenAPI. + This file is @generated using OpenAPI. -The version of the OpenAPI document: unstable -Contact: support@pinecone.io + The version of the OpenAPI document: unstable + Contact: support@pinecone.io """ + from pinecone.openapi_support.model_utils import ( # noqa: F401 PineconeApiTypeError, ModelComposed, @@ -31,10 +32,9 @@ def lazy_import(): from pinecone.core.openapi.repository_data.model.document import Document from pinecone.core.openapi.repository_data.model.lsn_status import LSNStatus from pinecone.core.openapi.repository_data.model.usage import Usage - - globals()["Document"] = Document - globals()["LSNStatus"] = LSNStatus - globals()["Usage"] = Usage + globals()['Document'] = Document + globals()['LSNStatus'] = LSNStatus + globals()['Usage'] = Usage from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar @@ -69,9 +69,11 @@ class GetDocumentResponse(ModelNormal): _data_store: Dict[str, Any] _check_type: bool - allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } - validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } @cached_class_property def additional_properties_type(cls): @@ -80,7 +82,7 @@ def additional_properties_type(cls): of type self, this must run after the class is loaded """ lazy_import() - return (bool, dict, float, int, list, str, none_type) # noqa: E501 + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 _nullable = False @@ -96,32 +98,32 @@ def openapi_types(cls): """ lazy_import() return { - "namespace": (str,), # noqa: E501 - "document": (Document,), # noqa: E501 - "usage": (Usage,), # noqa: E501 - "lsn_status": (LSNStatus,), # noqa: E501 + 'namespace': (str,), # noqa: E501 + 'document': (Document,), # noqa: E501 + 'usage': (Usage,), # noqa: E501 + 'lsn_status': (LSNStatus,), # noqa: E501 } @cached_class_property def discriminator(cls): return None + attribute_map: Dict[str, str] = { - "namespace": "namespace", # noqa: E501 - "document": "document", # noqa: E501 - "usage": "usage", # noqa: E501 - "lsn_status": "_lsn_status", # noqa: E501 + 'namespace': 'namespace', # noqa: E501 + 'document': 'document', # noqa: E501 + 'usage': 'usage', # noqa: E501 + 'lsn_status': '_lsn_status', # noqa: E501 } - read_only_vars: Set[str] = set([]) + read_only_vars: Set[str] = set([ + ]) - _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} @classmethod @convert_js_args_to_python_args - def _from_openapi_data( - cls: Type[T], namespace, document, usage, lsn_status, *args, **kwargs - ) -> T: # noqa: E501 + def _from_openapi_data(cls: Type[T], namespace, document, usage, lsn_status, *args, **kwargs) -> T: # noqa: E501 """GetDocumentResponse - a model defined in OpenAPI Args: @@ -163,20 +165,22 @@ def _from_openapi_data( _visited_composed_classes = (Animal,) """ - _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) - _enforce_validations = kwargs.pop("_enforce_validations", False) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) self = super(OpenApiModel, cls).__new__(cls) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -195,29 +199,25 @@ def _from_openapi_data( self.usage = usage self.lsn_status = lsn_status for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) return self - required_properties = set( - [ - "_enforce_allowed_values", - "_enforce_validations", - "_data_store", - "_check_type", - "_spec_property_naming", - "_path_to_item", - "_configuration", - "_visited_composed_classes", - ] - ) + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) @convert_js_args_to_python_args def __init__(self, namespace, document, usage, lsn_status, *args, **kwargs) -> None: # noqa: E501 @@ -263,17 +263,19 @@ def __init__(self, namespace, document, usage, lsn_status, *args, **kwargs) -> N """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) - _enforce_validations = kwargs.pop("_enforce_validations", True) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -292,17 +294,13 @@ def __init__(self, namespace, document, usage, lsn_status, *args, **kwargs) -> N self.usage = usage self.lsn_status = lsn_status for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) if var_name in self.read_only_vars: - raise PineconeApiAttributeError( - f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " - f"class with read only attributes." - ) + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/list_documents_response.py b/pinecone/core/openapi/repository_data/model/list_documents_response.py index ee953eff..c0d54dbb 100644 --- a/pinecone/core/openapi/repository_data/model/list_documents_response.py +++ b/pinecone/core/openapi/repository_data/model/list_documents_response.py @@ -1,14 +1,15 @@ """ -Pinecone Data Plane API for Repositories + Pinecone Data Plane API for Repositories -Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 -This file is @generated using OpenAPI. + This file is @generated using OpenAPI. -The version of the OpenAPI document: unstable -Contact: support@pinecone.io + The version of the OpenAPI document: unstable + Contact: support@pinecone.io """ + from pinecone.openapi_support.model_utils import ( # noqa: F401 PineconeApiTypeError, ModelComposed, @@ -32,11 +33,10 @@ def lazy_import(): from pinecone.core.openapi.repository_data.model.lsn_status import LSNStatus from pinecone.core.openapi.repository_data.model.pagination_response import PaginationResponse from pinecone.core.openapi.repository_data.model.usage import Usage - - globals()["DocumentList"] = DocumentList - globals()["LSNStatus"] = LSNStatus - globals()["PaginationResponse"] = PaginationResponse - globals()["Usage"] = Usage + globals()['DocumentList'] = DocumentList + globals()['LSNStatus'] = LSNStatus + globals()['PaginationResponse'] = PaginationResponse + globals()['Usage'] = Usage from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar @@ -71,9 +71,11 @@ class ListDocumentsResponse(ModelNormal): _data_store: Dict[str, Any] _check_type: bool - allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } - validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } @cached_class_property def additional_properties_type(cls): @@ -82,7 +84,7 @@ def additional_properties_type(cls): of type self, this must run after the class is loaded """ lazy_import() - return (bool, dict, float, int, list, str, none_type) # noqa: E501 + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 _nullable = False @@ -98,34 +100,34 @@ def openapi_types(cls): """ lazy_import() return { - "namespace": (str,), # noqa: E501 - "documents": (DocumentList,), # noqa: E501 - "usage": (Usage,), # noqa: E501 - "lsn_status": (LSNStatus,), # noqa: E501 - "pagination": (PaginationResponse,), # noqa: E501 + 'namespace': (str,), # noqa: E501 + 'documents': (DocumentList,), # noqa: E501 + 'usage': (Usage,), # noqa: E501 + 'lsn_status': (LSNStatus,), # noqa: E501 + 'pagination': (PaginationResponse,), # noqa: E501 } @cached_class_property def discriminator(cls): return None + attribute_map: Dict[str, str] = { - "namespace": "namespace", # noqa: E501 - "documents": "documents", # noqa: E501 - "usage": "usage", # noqa: E501 - "lsn_status": "_lsn_status", # noqa: E501 - "pagination": "pagination", # noqa: E501 + 'namespace': 'namespace', # noqa: E501 + 'documents': 'documents', # noqa: E501 + 'usage': 'usage', # noqa: E501 + 'lsn_status': '_lsn_status', # noqa: E501 + 'pagination': 'pagination', # noqa: E501 } - read_only_vars: Set[str] = set([]) + read_only_vars: Set[str] = set([ + ]) - _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} @classmethod @convert_js_args_to_python_args - def _from_openapi_data( - cls: Type[T], namespace, documents, usage, lsn_status, *args, **kwargs - ) -> T: # noqa: E501 + def _from_openapi_data(cls: Type[T], namespace, documents, usage, lsn_status, *args, **kwargs) -> T: # noqa: E501 """ListDocumentsResponse - a model defined in OpenAPI Args: @@ -168,20 +170,22 @@ def _from_openapi_data( pagination (PaginationResponse): [optional] # noqa: E501 """ - _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) - _enforce_validations = kwargs.pop("_enforce_validations", False) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) self = super(OpenApiModel, cls).__new__(cls) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -200,29 +204,25 @@ def _from_openapi_data( self.usage = usage self.lsn_status = lsn_status for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) return self - required_properties = set( - [ - "_enforce_allowed_values", - "_enforce_validations", - "_data_store", - "_check_type", - "_spec_property_naming", - "_path_to_item", - "_configuration", - "_visited_composed_classes", - ] - ) + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) @convert_js_args_to_python_args def __init__(self, namespace, documents, usage, lsn_status, *args, **kwargs) -> None: # noqa: E501 @@ -269,17 +269,19 @@ def __init__(self, namespace, documents, usage, lsn_status, *args, **kwargs) -> """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) - _enforce_validations = kwargs.pop("_enforce_validations", True) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -298,17 +300,13 @@ def __init__(self, namespace, documents, usage, lsn_status, *args, **kwargs) -> self.usage = usage self.lsn_status = lsn_status for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) if var_name in self.read_only_vars: - raise PineconeApiAttributeError( - f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " - f"class with read only attributes." - ) + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/lsn_status.py b/pinecone/core/openapi/repository_data/model/lsn_status.py index 57489531..3e9bdab9 100644 --- a/pinecone/core/openapi/repository_data/model/lsn_status.py +++ b/pinecone/core/openapi/repository_data/model/lsn_status.py @@ -1,14 +1,15 @@ """ -Pinecone Data Plane API for Repositories + Pinecone Data Plane API for Repositories -Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 -This file is @generated using OpenAPI. + This file is @generated using OpenAPI. -The version of the OpenAPI document: unstable -Contact: support@pinecone.io + The version of the OpenAPI document: unstable + Contact: support@pinecone.io """ + from pinecone.openapi_support.model_utils import ( # noqa: F401 PineconeApiTypeError, ModelComposed, @@ -27,6 +28,7 @@ from pinecone.openapi_support.exceptions import PineconeApiAttributeError + from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property @@ -59,9 +61,11 @@ class LSNStatus(ModelNormal): _data_store: Dict[str, Any] _check_type: bool - allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } - validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } @cached_class_property def additional_properties_type(cls): @@ -69,7 +73,7 @@ def additional_properties_type(cls): This must be a method because a model may have properties that are of type self, this must run after the class is loaded """ - return (bool, dict, float, int, list, str, none_type) # noqa: E501 + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 _nullable = False @@ -84,22 +88,24 @@ def openapi_types(cls): and the value is attribute type. """ return { - "reconciled": (int,), # noqa: E501 - "committed": (int,), # noqa: E501 + 'reconciled': (int,), # noqa: E501 + 'committed': (int,), # noqa: E501 } @cached_class_property def discriminator(cls): return None + attribute_map: Dict[str, str] = { - "reconciled": "reconciled", # noqa: E501 - "committed": "committed", # noqa: E501 + 'reconciled': 'reconciled', # noqa: E501 + 'committed': 'committed', # noqa: E501 } - read_only_vars: Set[str] = set([]) + read_only_vars: Set[str] = set([ + ]) - _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} @classmethod @convert_js_args_to_python_args @@ -143,20 +149,22 @@ def _from_openapi_data(cls: Type[T], reconciled, *args, **kwargs) -> T: # noqa: committed (int): The committed log sequence number for this write operation. [optional] # noqa: E501 """ - _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) - _enforce_validations = kwargs.pop("_enforce_validations", False) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) self = super(OpenApiModel, cls).__new__(cls) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -172,29 +180,25 @@ def _from_openapi_data(cls: Type[T], reconciled, *args, **kwargs) -> T: # noqa: self.reconciled = reconciled for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) return self - required_properties = set( - [ - "_enforce_allowed_values", - "_enforce_validations", - "_data_store", - "_check_type", - "_spec_property_naming", - "_path_to_item", - "_configuration", - "_visited_composed_classes", - ] - ) + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) @convert_js_args_to_python_args def __init__(self, reconciled, *args, **kwargs) -> None: # noqa: E501 @@ -238,17 +242,19 @@ def __init__(self, reconciled, *args, **kwargs) -> None: # noqa: E501 """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) - _enforce_validations = kwargs.pop("_enforce_validations", True) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -264,17 +270,13 @@ def __init__(self, reconciled, *args, **kwargs) -> None: # noqa: E501 self.reconciled = reconciled for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) if var_name in self.read_only_vars: - raise PineconeApiAttributeError( - f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " - f"class with read only attributes." - ) + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/matched_chunk_model.py b/pinecone/core/openapi/repository_data/model/matched_chunk_model.py new file mode 100644 index 00000000..e7a155ea --- /dev/null +++ b/pinecone/core/openapi/repository_data/model/matched_chunk_model.py @@ -0,0 +1,284 @@ +""" + Pinecone Data Plane API for Repositories + + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + + This file is @generated using OpenAPI. + + The version of the OpenAPI document: unstable + Contact: support@pinecone.io +""" + + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="MatchedChunkModel") + + +class MatchedChunkModel(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return { + 'score': (float,), # noqa: E501 + 'origin_json_path': (str,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + + attribute_map: Dict[str, str] = { + 'score': 'score', # noqa: E501 + 'origin_json_path': 'origin_json_path', # noqa: E501 + } + + read_only_vars: Set[str] = set([ + ]) + + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], score, origin_json_path, *args, **kwargs) -> T: # noqa: E501 + """MatchedChunkModel - a model defined in OpenAPI + + Args: + score (float): The relevance of the chunk to the query. + origin_json_path (str): JSON path pointing to the chunk in the original document. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.score = score + self.origin_json_path = origin_json_path + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) + + @convert_js_args_to_python_args + def __init__(self, score, origin_json_path, *args, **kwargs) -> None: # noqa: E501 + """MatchedChunkModel - a model defined in OpenAPI + + Args: + score (float): The relevance of the chunk to the query. + origin_json_path (str): JSON path pointing to the chunk in the original document. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.score = score + self.origin_json_path = origin_json_path + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/options_model.py b/pinecone/core/openapi/repository_data/model/options_model.py new file mode 100644 index 00000000..f15de011 --- /dev/null +++ b/pinecone/core/openapi/repository_data/model/options_model.py @@ -0,0 +1,278 @@ +""" + Pinecone Data Plane API for Repositories + + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + + This file is @generated using OpenAPI. + + The version of the OpenAPI document: unstable + Contact: support@pinecone.io +""" + + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_data.model.context_options_model import ContextOptionsModel + globals()['ContextOptionsModel'] = ContextOptionsModel + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="OptionsModel") + + +class OptionsModel(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + 'context': (ContextOptionsModel,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + + attribute_map: Dict[str, str] = { + 'context': 'context', # noqa: E501 + } + + read_only_vars: Set[str] = set([ + ]) + + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 + """OptionsModel - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + context (ContextOptionsModel): [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) + + @convert_js_args_to_python_args + def __init__(self, *args, **kwargs) -> None: # noqa: E501 + """OptionsModel - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + context (ContextOptionsModel): [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/pagination_response.py b/pinecone/core/openapi/repository_data/model/pagination_response.py index b1c11924..e0537481 100644 --- a/pinecone/core/openapi/repository_data/model/pagination_response.py +++ b/pinecone/core/openapi/repository_data/model/pagination_response.py @@ -1,14 +1,15 @@ """ -Pinecone Data Plane API for Repositories + Pinecone Data Plane API for Repositories -Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 -This file is @generated using OpenAPI. + This file is @generated using OpenAPI. -The version of the OpenAPI document: unstable -Contact: support@pinecone.io + The version of the OpenAPI document: unstable + Contact: support@pinecone.io """ + from pinecone.openapi_support.model_utils import ( # noqa: F401 PineconeApiTypeError, ModelComposed, @@ -27,6 +28,7 @@ from pinecone.openapi_support.exceptions import PineconeApiAttributeError + from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property @@ -59,9 +61,11 @@ class PaginationResponse(ModelNormal): _data_store: Dict[str, Any] _check_type: bool - allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } - validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } @cached_class_property def additional_properties_type(cls): @@ -69,7 +73,7 @@ def additional_properties_type(cls): This must be a method because a model may have properties that are of type self, this must run after the class is loaded """ - return (bool, dict, float, int, list, str, none_type) # noqa: E501 + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 _nullable = False @@ -84,20 +88,22 @@ def openapi_types(cls): and the value is attribute type. """ return { - "next": (str,) # noqa: E501 + 'next': (str,), # noqa: E501 } @cached_class_property def discriminator(cls): return None + attribute_map: Dict[str, str] = { - "next": "next" # noqa: E501 + 'next': 'next', # noqa: E501 } - read_only_vars: Set[str] = set([]) + read_only_vars: Set[str] = set([ + ]) - _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} @classmethod @convert_js_args_to_python_args @@ -140,20 +146,22 @@ def _from_openapi_data(cls: Type[T], next, *args, **kwargs) -> T: # noqa: E501 _visited_composed_classes = (Animal,) """ - _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) - _enforce_validations = kwargs.pop("_enforce_validations", False) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) self = super(OpenApiModel, cls).__new__(cls) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -169,29 +177,25 @@ def _from_openapi_data(cls: Type[T], next, *args, **kwargs) -> T: # noqa: E501 self.next = next for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) return self - required_properties = set( - [ - "_enforce_allowed_values", - "_enforce_validations", - "_data_store", - "_check_type", - "_spec_property_naming", - "_path_to_item", - "_configuration", - "_visited_composed_classes", - ] - ) + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) @convert_js_args_to_python_args def __init__(self, next, *args, **kwargs) -> None: # noqa: E501 @@ -234,17 +238,19 @@ def __init__(self, next, *args, **kwargs) -> None: # noqa: E501 """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) - _enforce_validations = kwargs.pop("_enforce_validations", True) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -260,17 +266,13 @@ def __init__(self, next, *args, **kwargs) -> None: # noqa: E501 self.next = next for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) if var_name in self.read_only_vars: - raise PineconeApiAttributeError( - f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " - f"class with read only attributes." - ) + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/query_input_model.py b/pinecone/core/openapi/repository_data/model/query_input_model.py new file mode 100644 index 00000000..cbc18fa9 --- /dev/null +++ b/pinecone/core/openapi/repository_data/model/query_input_model.py @@ -0,0 +1,324 @@ +""" + Pinecone Data Plane API for Repositories + + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + + This file is @generated using OpenAPI. + + The version of the OpenAPI document: unstable + Contact: support@pinecone.io +""" + + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_data.model.query_input_model_one_of import QueryInputModelOneOf + globals()['QueryInputModelOneOf'] = QueryInputModelOneOf + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="QueryInputModel") + + +class QueryInputModel(ModelComposed): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + 'text': (str,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + + attribute_map: Dict[str, str] = { + 'text': 'text', # noqa: E501 + } + + read_only_vars: Set[str] = set([ + ]) + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 + """QueryInputModel - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + text (str): The query string used to search. [optional] # noqa: E501 + """ + + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + constant_args = { + '_check_type': _check_type, + '_path_to_item': _path_to_item, + '_spec_property_naming': _spec_property_naming, + '_configuration': _configuration, + '_visited_composed_classes': self._visited_composed_classes, + } + composed_info = validate_get_composed_info( + constant_args, kwargs, self) + self._composed_instances = composed_info[0] + self._var_name_to_model_instances = composed_info[1] + self._additional_properties_model_instances = composed_info[2] + discarded_args = composed_info[3] + + for var_name, var_value in kwargs.items(): + if var_name in discarded_args and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self._additional_properties_model_instances: + # discard variable. + continue + setattr(self, var_name, var_value) + + return self + + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + '_composed_instances', + '_var_name_to_model_instances', + '_additional_properties_model_instances', + ]) + + @convert_js_args_to_python_args + def __init__(self, *args, **kwargs) -> None: # noqa: E501 + """QueryInputModel - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + text (str): The query string used to search. [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', True) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + constant_args = { + '_check_type': _check_type, + '_path_to_item': _path_to_item, + '_spec_property_naming': _spec_property_naming, + '_configuration': _configuration, + '_visited_composed_classes': self._visited_composed_classes, + } + composed_info = validate_get_composed_info( + constant_args, kwargs, self) + self._composed_instances = composed_info[0] + self._var_name_to_model_instances = composed_info[1] + self._additional_properties_model_instances = composed_info[2] + discarded_args = composed_info[3] + + for var_name, var_value in kwargs.items(): + if var_name in discarded_args and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self._additional_properties_model_instances: + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") + + @cached_property + def _composed_schemas(): # type: ignore + # we need this here to make our import statements work + # we must store _composed_schemas in here so the code is only run + # when we invoke this method. If we kept this at the class + # level we would get an error beause the class level + # code would be run when this module is imported, and these composed + # classes don't exist yet because their module has not finished + # loading + lazy_import() + return { + 'anyOf': [ + ], + 'allOf': [ + ], + 'oneOf': [ + QueryInputModelOneOf, + ], + } diff --git a/pinecone/core/openapi/repository_data/model/query_input_model_one_of.py b/pinecone/core/openapi/repository_data/model/query_input_model_one_of.py new file mode 100644 index 00000000..f7a8f217 --- /dev/null +++ b/pinecone/core/openapi/repository_data/model/query_input_model_one_of.py @@ -0,0 +1,278 @@ +""" + Pinecone Data Plane API for Repositories + + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + + This file is @generated using OpenAPI. + + The version of the OpenAPI document: unstable + Contact: support@pinecone.io +""" + + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="QueryInputModelOneOf") + + +class QueryInputModelOneOf(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return { + 'text': (str,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + + attribute_map: Dict[str, str] = { + 'text': 'text', # noqa: E501 + } + + read_only_vars: Set[str] = set([ + ]) + + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], text, *args, **kwargs) -> T: # noqa: E501 + """QueryInputModelOneOf - a model defined in OpenAPI + + Args: + text (str): The query string used to search. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.text = text + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) + + @convert_js_args_to_python_args + def __init__(self, text, *args, **kwargs) -> None: # noqa: E501 + """QueryInputModelOneOf - a model defined in OpenAPI + + Args: + text (str): The query string used to search. + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.text = text + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/query_model.py b/pinecone/core/openapi/repository_data/model/query_model.py new file mode 100644 index 00000000..b4d39eac --- /dev/null +++ b/pinecone/core/openapi/repository_data/model/query_model.py @@ -0,0 +1,294 @@ +""" + Pinecone Data Plane API for Repositories + + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + + This file is @generated using OpenAPI. + + The version of the OpenAPI document: unstable + Contact: support@pinecone.io +""" + + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_data.model.query_input_model import QueryInputModel + globals()['QueryInputModel'] = QueryInputModel + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="QueryModel") + + +class QueryModel(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + 'top_k': (int,), # noqa: E501 + 'inputs': (QueryInputModel,), # noqa: E501 + 'filter': ({str: (bool, dict, float, int, list, str, none_type)},), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + + attribute_map: Dict[str, str] = { + 'top_k': 'top_k', # noqa: E501 + 'inputs': 'inputs', # noqa: E501 + 'filter': 'filter', # noqa: E501 + } + + read_only_vars: Set[str] = set([ + ]) + + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], top_k, inputs, *args, **kwargs) -> T: # noqa: E501 + """QueryModel - a model defined in OpenAPI + + Args: + top_k (int): The maximum number of search results to return. Minimum is 1. Maximum is 20. + inputs (QueryInputModel): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + filter ({str: (bool, dict, float, int, list, str, none_type)}): Optionally filter which chunks can be searched using the metadata fields. [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.top_k = top_k + self.inputs = inputs + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) + + @convert_js_args_to_python_args + def __init__(self, top_k, inputs, *args, **kwargs) -> None: # noqa: E501 + """QueryModel - a model defined in OpenAPI + + Args: + top_k (int): The maximum number of search results to return. Minimum is 1. Maximum is 20. + inputs (QueryInputModel): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + filter ({str: (bool, dict, float, int, list, str, none_type)}): Optionally filter which chunks can be searched using the metadata fields. [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.top_k = top_k + self.inputs = inputs + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/search_documents.py b/pinecone/core/openapi/repository_data/model/search_documents.py new file mode 100644 index 00000000..7d573ca6 --- /dev/null +++ b/pinecone/core/openapi/repository_data/model/search_documents.py @@ -0,0 +1,290 @@ +""" + Pinecone Data Plane API for Repositories + + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + + This file is @generated using OpenAPI. + + The version of the OpenAPI document: unstable + Contact: support@pinecone.io +""" + + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_data.model.options_model import OptionsModel + from pinecone.core.openapi.repository_data.model.query_model import QueryModel + globals()['OptionsModel'] = OptionsModel + globals()['QueryModel'] = QueryModel + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="SearchDocuments") + + +class SearchDocuments(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + 'query': (QueryModel,), # noqa: E501 + 'options': (OptionsModel,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + + attribute_map: Dict[str, str] = { + 'query': 'query', # noqa: E501 + 'options': 'options', # noqa: E501 + } + + read_only_vars: Set[str] = set([ + ]) + + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], query, *args, **kwargs) -> T: # noqa: E501 + """SearchDocuments - a model defined in OpenAPI + + Args: + query (QueryModel): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + options (OptionsModel): [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.query = query + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) + + @convert_js_args_to_python_args + def __init__(self, query, *args, **kwargs) -> None: # noqa: E501 + """SearchDocuments - a model defined in OpenAPI + + Args: + query (QueryModel): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + options (OptionsModel): [optional] # noqa: E501 + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.query = query + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/search_documents_response.py b/pinecone/core/openapi/repository_data/model/search_documents_response.py new file mode 100644 index 00000000..2c4895c9 --- /dev/null +++ b/pinecone/core/openapi/repository_data/model/search_documents_response.py @@ -0,0 +1,292 @@ +""" + Pinecone Data Plane API for Repositories + + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + + This file is @generated using OpenAPI. + + The version of the OpenAPI document: unstable + Contact: support@pinecone.io +""" + + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + +def lazy_import(): + from pinecone.core.openapi.repository_data.model.document_result_model import DocumentResultModel + from pinecone.core.openapi.repository_data.model.usage import Usage + globals()['DocumentResultModel'] = DocumentResultModel + globals()['Usage'] = Usage + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="SearchDocumentsResponse") + + +class SearchDocumentsResponse(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + lazy_import() + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + lazy_import() + return { + 'results': ([DocumentResultModel],), # noqa: E501 + 'usage': (Usage,), # noqa: E501 + } + + @cached_class_property + def discriminator(cls): + return None + + + attribute_map: Dict[str, str] = { + 'results': 'results', # noqa: E501 + 'usage': 'usage', # noqa: E501 + } + + read_only_vars: Set[str] = set([ + ]) + + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], results, usage, *args, **kwargs) -> T: # noqa: E501 + """SearchDocumentsResponse - a model defined in OpenAPI + + Args: + results ([DocumentResultModel]): + usage (Usage): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.results = results + self.usage = usage + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) + + @convert_js_args_to_python_args + def __init__(self, results, usage, *args, **kwargs) -> None: # noqa: E501 + """SearchDocumentsResponse - a model defined in OpenAPI + + Args: + results ([DocumentResultModel]): + usage (Usage): + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + self.results = results + self.usage = usage + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/upsert_document_request.py b/pinecone/core/openapi/repository_data/model/upsert_document_request.py new file mode 100644 index 00000000..2b54eb54 --- /dev/null +++ b/pinecone/core/openapi/repository_data/model/upsert_document_request.py @@ -0,0 +1,268 @@ +""" + Pinecone Data Plane API for Repositories + + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + + This file is @generated using OpenAPI. + + The version of the OpenAPI document: unstable + Contact: support@pinecone.io +""" + + +from pinecone.openapi_support.model_utils import ( # noqa: F401 + PineconeApiTypeError, + ModelComposed, + ModelNormal, + ModelSimple, + OpenApiModel, + cached_property, + change_keys_js_to_python, + convert_js_args_to_python_args, + date, + datetime, + file_type, + none_type, + validate_get_composed_info, +) +from pinecone.openapi_support.exceptions import PineconeApiAttributeError + + + +from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar +from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property + +T = TypeVar("T", bound="UpsertDocumentRequest") + + +class UpsertDocumentRequest(ModelNormal): + """NOTE: This class is @generated using OpenAPI. + + Do not edit the class manually. + + Attributes: + allowed_values (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + with a capitalized key describing the allowed value and an allowed + value. These dicts store the allowed enum values. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + discriminator_value_class_map (dict): A dict to go from the discriminator + variable value to the discriminator class name. + validations (dict): The key is the tuple path to the attribute + and the for var_name this is (var_name,). The value is a dict + that stores validations for max_length, min_length, max_items, + min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum, + inclusive_minimum, and regex. + additional_properties_type (tuple): A tuple of classes accepted + as additional properties values. + """ + + _data_store: Dict[str, Any] + _check_type: bool + + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } + + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } + + @cached_class_property + def additional_properties_type(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + """ + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 + + _nullable = False + + @cached_class_property + def openapi_types(cls): + """ + This must be a method because a model may have properties that are + of type self, this must run after the class is loaded + + Returns + openapi_types (dict): The key is attribute name + and the value is attribute type. + """ + return { + } + + @cached_class_property + def discriminator(cls): + return None + + + attribute_map: Dict[str, str] = { + } + + read_only_vars: Set[str] = set([ + ]) + + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} + + @classmethod + @convert_js_args_to_python_args + def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 + """UpsertDocumentRequest - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + self = super(OpenApiModel, cls).__new__(cls) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + return self + + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) + + @convert_js_args_to_python_args + def __init__(self, *args, **kwargs) -> None: # noqa: E501 + """UpsertDocumentRequest - a model defined in OpenAPI + + Keyword Args: + _check_type (bool): if True, values for parameters in openapi_types + will be type checked and a TypeError will be + raised if the wrong type is input. + Defaults to True + _path_to_item (tuple/list): This is a list of keys or values to + drill down to the model in received_data + when deserializing a response + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _configuration (Configuration): the instance to use when + deserializing a file_type parameter. + If passed, type conversion is attempted + If omitted no type conversion is done. + _visited_composed_classes (tuple): This stores a tuple of + classes that we have traveled through so that + if we see that class again we will not use its + discriminator again. + When traveling through a discriminator, the + composed schema that is + is traveled through is added to this set. + For example if Animal has a discriminator + petType and we pass in "Dog", and the class Dog + allOf includes Animal, we move through Animal + once using the discriminator, and pick Dog. + Then in Dog, we will make an instance of the + Animal class but this time we won't travel + through its discriminator because we passed in + _visited_composed_classes = (Animal,) + """ + + _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) + + if args: + raise PineconeApiTypeError( + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), + path_to_item=_path_to_item, + valid_classes=(self.__class__,), + ) + + self._data_store = {} + self._enforce_allowed_values = _enforce_allowed_values + self._enforce_validations = _enforce_validations + self._check_type = _check_type + self._spec_property_naming = _spec_property_naming + self._path_to_item = _path_to_item + self._configuration = _configuration + self._visited_composed_classes = _visited_composed_classes + (self.__class__,) + + for var_name, var_value in kwargs.items(): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: + # discard variable. + continue + setattr(self, var_name, var_value) + if var_name in self.read_only_vars: + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/upsert_document_response.py b/pinecone/core/openapi/repository_data/model/upsert_document_response.py index cf2215b5..c44b6e6b 100644 --- a/pinecone/core/openapi/repository_data/model/upsert_document_response.py +++ b/pinecone/core/openapi/repository_data/model/upsert_document_response.py @@ -1,14 +1,15 @@ """ -Pinecone Data Plane API for Repositories + Pinecone Data Plane API for Repositories -Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 -This file is @generated using OpenAPI. + This file is @generated using OpenAPI. -The version of the OpenAPI document: unstable -Contact: support@pinecone.io + The version of the OpenAPI document: unstable + Contact: support@pinecone.io """ + from pinecone.openapi_support.model_utils import ( # noqa: F401 PineconeApiTypeError, ModelComposed, @@ -29,8 +30,7 @@ def lazy_import(): from pinecone.core.openapi.repository_data.model.lsn_status import LSNStatus - - globals()["LSNStatus"] = LSNStatus + globals()['LSNStatus'] = LSNStatus from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar @@ -65,9 +65,11 @@ class UpsertDocumentResponse(ModelNormal): _data_store: Dict[str, Any] _check_type: bool - allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } - validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } @cached_class_property def additional_properties_type(cls): @@ -76,7 +78,7 @@ def additional_properties_type(cls): of type self, this must run after the class is loaded """ lazy_import() - return (bool, dict, float, int, list, str, none_type) # noqa: E501 + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 _nullable = False @@ -92,24 +94,26 @@ def openapi_types(cls): """ lazy_import() return { - "id": (str,), # noqa: E501 - "namespace": (str,), # noqa: E501 - "lsn_status": (LSNStatus,), # noqa: E501 + 'id': (str,), # noqa: E501 + 'namespace': (str,), # noqa: E501 + 'lsn_status': (LSNStatus,), # noqa: E501 } @cached_class_property def discriminator(cls): return None + attribute_map: Dict[str, str] = { - "id": "_id", # noqa: E501 - "namespace": "namespace", # noqa: E501 - "lsn_status": "_lsn_status", # noqa: E501 + 'id': '_id', # noqa: E501 + 'namespace': 'namespace', # noqa: E501 + 'lsn_status': '_lsn_status', # noqa: E501 } - read_only_vars: Set[str] = set([]) + read_only_vars: Set[str] = set([ + ]) - _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} @classmethod @convert_js_args_to_python_args @@ -154,20 +158,22 @@ def _from_openapi_data(cls: Type[T], id, namespace, lsn_status, *args, **kwargs) _visited_composed_classes = (Animal,) """ - _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) - _enforce_validations = kwargs.pop("_enforce_validations", False) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) self = super(OpenApiModel, cls).__new__(cls) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -185,29 +191,25 @@ def _from_openapi_data(cls: Type[T], id, namespace, lsn_status, *args, **kwargs) self.namespace = namespace self.lsn_status = lsn_status for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) return self - required_properties = set( - [ - "_enforce_allowed_values", - "_enforce_validations", - "_data_store", - "_check_type", - "_spec_property_naming", - "_path_to_item", - "_configuration", - "_visited_composed_classes", - ] - ) + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) @convert_js_args_to_python_args def __init__(self, id, namespace, lsn_status, *args, **kwargs) -> None: # noqa: E501 @@ -252,17 +254,19 @@ def __init__(self, id, namespace, lsn_status, *args, **kwargs) -> None: # noqa: """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) - _enforce_validations = kwargs.pop("_enforce_validations", True) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -280,17 +284,13 @@ def __init__(self, id, namespace, lsn_status, *args, **kwargs) -> None: # noqa: self.namespace = namespace self.lsn_status = lsn_status for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) if var_name in self.read_only_vars: - raise PineconeApiAttributeError( - f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " - f"class with read only attributes." - ) + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model/usage.py b/pinecone/core/openapi/repository_data/model/usage.py index fa195ec9..4ee9186b 100644 --- a/pinecone/core/openapi/repository_data/model/usage.py +++ b/pinecone/core/openapi/repository_data/model/usage.py @@ -1,14 +1,15 @@ """ -Pinecone Data Plane API for Repositories + Pinecone Data Plane API for Repositories -Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 + Pinecone Repositories build on the vector database to make it easy to store, search and retrieve your data. # noqa: E501 -This file is @generated using OpenAPI. + This file is @generated using OpenAPI. -The version of the OpenAPI document: unstable -Contact: support@pinecone.io + The version of the OpenAPI document: unstable + Contact: support@pinecone.io """ + from pinecone.openapi_support.model_utils import ( # noqa: F401 PineconeApiTypeError, ModelComposed, @@ -27,6 +28,7 @@ from pinecone.openapi_support.exceptions import PineconeApiAttributeError + from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar from pinecone.openapi_support import PropertyValidationTypedDict, cached_class_property @@ -59,9 +61,11 @@ class Usage(ModelNormal): _data_store: Dict[str, Any] _check_type: bool - allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = {} + allowed_values: Dict[Tuple[str, ...], Dict[str, Any]] = { + } - validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = {} + validations: Dict[Tuple[str, ...], PropertyValidationTypedDict] = { + } @cached_class_property def additional_properties_type(cls): @@ -69,7 +73,7 @@ def additional_properties_type(cls): This must be a method because a model may have properties that are of type self, this must run after the class is loaded """ - return (bool, dict, float, int, list, str, none_type) # noqa: E501 + return (bool, dict, float, int, list, str, none_type,) # noqa: E501 _nullable = False @@ -84,26 +88,26 @@ def openapi_types(cls): and the value is attribute type. """ return { - "kb_read_units": (float,), # noqa: E501 - "kb_write_units": (float,), # noqa: E501 - "embed_total_tokens": (int,), # noqa: E501 - "rerank_units": (int,), # noqa: E501 + 'kb_read_units': (float,), # noqa: E501 + 'kb_write_units': (float,), # noqa: E501 + 'embed_total_tokens': (int,), # noqa: E501 } @cached_class_property def discriminator(cls): return None + attribute_map: Dict[str, str] = { - "kb_read_units": "kb_read_units", # noqa: E501 - "kb_write_units": "kb_write_units", # noqa: E501 - "embed_total_tokens": "embed_total_tokens", # noqa: E501 - "rerank_units": "rerank_units", # noqa: E501 + 'kb_read_units': 'kb_read_units', # noqa: E501 + 'kb_write_units': 'kb_write_units', # noqa: E501 + 'embed_total_tokens': 'embed_total_tokens', # noqa: E501 } - read_only_vars: Set[str] = set([]) + read_only_vars: Set[str] = set([ + ]) - _composed_schemas: Dict[Literal["allOf", "oneOf", "anyOf"], Any] = {} + _composed_schemas: Dict[Literal['allOf', 'oneOf', 'anyOf'], Any] = {} @classmethod @convert_js_args_to_python_args @@ -144,23 +148,24 @@ def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 kb_read_units (float): The number of read units consumed by this operation. [optional] # noqa: E501 kb_write_units (float): The number of write units consumed by this operation. [optional] # noqa: E501 embed_total_tokens (int): The number of embedding tokens consumed by this operation. [optional] # noqa: E501 - rerank_units (int): The number of rerank units consumed by this operation. [optional] # noqa: E501 """ - _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) - _enforce_validations = kwargs.pop("_enforce_validations", False) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_allowed_values = kwargs.pop('_enforce_allowed_values', False) + _enforce_validations = kwargs.pop('_enforce_validations', False) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) self = super(OpenApiModel, cls).__new__(cls) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -175,29 +180,25 @@ def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 self._visited_composed_classes = _visited_composed_classes + (self.__class__,) for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) return self - required_properties = set( - [ - "_enforce_allowed_values", - "_enforce_validations", - "_data_store", - "_check_type", - "_spec_property_naming", - "_path_to_item", - "_configuration", - "_visited_composed_classes", - ] - ) + required_properties = set([ + '_enforce_allowed_values', + '_enforce_validations', + '_data_store', + '_check_type', + '_spec_property_naming', + '_path_to_item', + '_configuration', + '_visited_composed_classes', + ]) @convert_js_args_to_python_args def __init__(self, *args, **kwargs) -> None: # noqa: E501 @@ -237,21 +238,22 @@ def __init__(self, *args, **kwargs) -> None: # noqa: E501 kb_read_units (float): The number of read units consumed by this operation. [optional] # noqa: E501 kb_write_units (float): The number of write units consumed by this operation. [optional] # noqa: E501 embed_total_tokens (int): The number of embedding tokens consumed by this operation. [optional] # noqa: E501 - rerank_units (int): The number of rerank units consumed by this operation. [optional] # noqa: E501 """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) - _enforce_validations = kwargs.pop("_enforce_validations", True) - _check_type = kwargs.pop("_check_type", True) - _spec_property_naming = kwargs.pop("_spec_property_naming", False) - _path_to_item = kwargs.pop("_path_to_item", ()) - _configuration = kwargs.pop("_configuration", None) - _visited_composed_classes = kwargs.pop("_visited_composed_classes", ()) + _enforce_validations = kwargs.pop('_enforce_validations', True) + _check_type = kwargs.pop('_check_type', True) + _spec_property_naming = kwargs.pop('_spec_property_naming', False) + _path_to_item = kwargs.pop('_path_to_item', ()) + _configuration = kwargs.pop('_configuration', None) + _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) if args: raise PineconeApiTypeError( - "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." - % (args, self.__class__.__name__), + "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( + args, + self.__class__.__name__, + ), path_to_item=_path_to_item, valid_classes=(self.__class__,), ) @@ -266,17 +268,13 @@ def __init__(self, *args, **kwargs) -> None: # noqa: E501 self._visited_composed_classes = _visited_composed_classes + (self.__class__,) for var_name, var_value in kwargs.items(): - if ( - var_name not in self.attribute_map - and self._configuration is not None - and self._configuration.discard_unknown_keys - and self.additional_properties_type is None - ): + if var_name not in self.attribute_map and \ + self._configuration is not None and \ + self._configuration.discard_unknown_keys and \ + self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value) if var_name in self.read_only_vars: - raise PineconeApiAttributeError( - f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " - f"class with read only attributes." - ) + raise PineconeApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate " + f"class with read only attributes.") diff --git a/pinecone/core/openapi/repository_data/model_utils.py b/pinecone/core/openapi/repository_data/model_utils.py new file mode 100644 index 00000000..bb2d2523 --- /dev/null +++ b/pinecone/core/openapi/repository_data/model_utils.py @@ -0,0 +1 @@ +# Deleted this file we are not using diff --git a/pinecone/core/openapi/repository_data/models/__init__.py b/pinecone/core/openapi/repository_data/models/__init__.py index 2615558e..0e7eccf0 100644 --- a/pinecone/core/openapi/repository_data/models/__init__.py +++ b/pinecone/core/openapi/repository_data/models/__init__.py @@ -9,18 +9,23 @@ # import sys # sys.setrecursionlimit(n) -from pinecone.core.openapi.repository_data.model.delete_document_response import ( - DeleteDocumentResponse, -) +from pinecone.core.openapi.repository_data.model.context_options_model import ContextOptionsModel +from pinecone.core.openapi.repository_data.model.delete_document_response import DeleteDocumentResponse from pinecone.core.openapi.repository_data.model.document import Document +from pinecone.core.openapi.repository_data.model.document_context_unit_model import DocumentContextUnitModel from pinecone.core.openapi.repository_data.model.document_list import DocumentList +from pinecone.core.openapi.repository_data.model.document_result_model import DocumentResultModel from pinecone.core.openapi.repository_data.model.get_document_response import GetDocumentResponse from pinecone.core.openapi.repository_data.model.lsn_status import LSNStatus -from pinecone.core.openapi.repository_data.model.list_documents_response import ( - ListDocumentsResponse, -) +from pinecone.core.openapi.repository_data.model.list_documents_response import ListDocumentsResponse +from pinecone.core.openapi.repository_data.model.matched_chunk_model import MatchedChunkModel +from pinecone.core.openapi.repository_data.model.options_model import OptionsModel from pinecone.core.openapi.repository_data.model.pagination_response import PaginationResponse -from pinecone.core.openapi.repository_data.model.upsert_document_response import ( - UpsertDocumentResponse, -) +from pinecone.core.openapi.repository_data.model.query_input_model import QueryInputModel +from pinecone.core.openapi.repository_data.model.query_input_model_one_of import QueryInputModelOneOf +from pinecone.core.openapi.repository_data.model.query_model import QueryModel +from pinecone.core.openapi.repository_data.model.search_documents import SearchDocuments +from pinecone.core.openapi.repository_data.model.search_documents_response import SearchDocumentsResponse +from pinecone.core.openapi.repository_data.model.upsert_document_request import UpsertDocumentRequest +from pinecone.core.openapi.repository_data.model.upsert_document_response import UpsertDocumentResponse from pinecone.core.openapi.repository_data.model.usage import Usage diff --git a/pinecone/core/openapi/repository_data/rest.py b/pinecone/core/openapi/repository_data/rest.py new file mode 100644 index 00000000..8cf9e891 --- /dev/null +++ b/pinecone/core/openapi/repository_data/rest.py @@ -0,0 +1 @@ +# Deleted diff --git a/pinecone/repository_data/dataclasses/__init__.py b/pinecone/repository_data/dataclasses/__init__.py new file mode 100644 index 00000000..4df4fc6a --- /dev/null +++ b/pinecone/repository_data/dataclasses/__init__.py @@ -0,0 +1,3 @@ +from .search_query import SearchQuery + +__all__ = ["SearchQuery"] diff --git a/pinecone/repository_data/dataclasses/search_query.py b/pinecone/repository_data/dataclasses/search_query.py new file mode 100644 index 00000000..663c967f --- /dev/null +++ b/pinecone/repository_data/dataclasses/search_query.py @@ -0,0 +1,34 @@ +from dataclasses import dataclass +from typing import Optional, Any, Dict + + +@dataclass +class SearchQuery: + """ + SearchQuery represents the query when searching within a specific namespace. + """ + + inputs: Dict[str, Any] + """ + The input data to search with. + Required. + """ + + top_k: int + """ + The number of results to return with each search. + Required. + """ + + filter: Optional[Dict[str, Any]] = None + """ + The filter to apply to the search. + Optional. + """ + + def as_dict(self) -> Dict[str, Any]: + """ + Returns the SearchQuery as a dictionary. + """ + d = {"inputs": self.inputs, "top_k": self.top_k, "filter": self.filter} + return {k: v for k, v in d.items() if v is not None} diff --git a/pinecone/repository_data/repository.py b/pinecone/repository_data/repository.py index f72f79b5..d763d110 100644 --- a/pinecone/repository_data/repository.py +++ b/pinecone/repository_data/repository.py @@ -9,6 +9,9 @@ from multiprocessing import cpu_count from pinecone.core.openapi.repository_data import API_VERSION from .models.document import Document +from .repository_search import RepositorySearch + +from pinecone.core.openapi.repository_data.models import SearchDocumentsResponse logger = logging.getLogger(__name__) @@ -97,6 +100,16 @@ def __init__( if additional_headers: self._default_headers.update(additional_headers) + # Search uses the OpenAPI client-based impl + self._search_client = RepositorySearch( + api_key=api_key, + host=host, + pool_threads=pool_threads, + additional_headers=additional_headers, + openapi_config=openapi_config, + **kwargs, + ) + # ----------------------- # Internal request helper # ----------------------- @@ -157,6 +170,16 @@ def _request( except json.JSONDecodeError: payload = None + if do_echo: + print("\n\n----- HTTP Response -----") + print(f"{resp.status_code} {resp.reason}") + print("Headers:", resp.headers) + if payload: + print("Body:", json.dumps(payload, indent=2)) + else: + print("Body: ") + print("------------------------") + if not (200 <= resp.status_code < 300): msg = payload.get("message") if isinstance(payload, dict) else resp.text raise HTTPError(resp.status_code, msg or "HTTP request failed", payload) @@ -233,3 +256,14 @@ def delete(self, namespace: str, document_id: str, **kwargs): """ path = f"/namespaces/{namespace}/documents/{document_id}" return self._request("DELETE", path, **kwargs) + + def search( + self, + namespace: str, + query_str: str, + top_k: Optional[int] = None, + filter: Optional[Dict[str, Any]] = None, + ) -> SearchDocumentsResponse: + return self._search_client.search( + namespace=namespace, query_str=query_str, top_k=top_k, filter=filter + ) diff --git a/pinecone/repository_data/repository_search.py b/pinecone/repository_data/repository_search.py new file mode 100644 index 00000000..f9c65d04 --- /dev/null +++ b/pinecone/repository_data/repository_search.py @@ -0,0 +1,123 @@ +import warnings +import logging +from typing import Optional, Dict, Any, TYPE_CHECKING + +from pinecone.config import ConfigBuilder + +from pinecone.openapi_support import ApiClient +from pinecone.core.openapi.repository_data.api.document_operations_api import DocumentOperationsApi +from pinecone.core.openapi.repository_data import API_VERSION +from pinecone.core.openapi.repository_data.models import SearchDocumentsResponse +from .request_factory import RepositoryRequestFactory +from ..utils import setup_openapi_client, validate_and_convert_errors, filter_dict +from pinecone.openapi_support import OPENAPI_ENDPOINT_PARAMS + +from multiprocessing import cpu_count + + +if TYPE_CHECKING: + from pinecone.config import Config, OpenApiConfiguration + + +logger = logging.getLogger(__name__) +""" :meta private: """ + + +class RepositorySearch: + """ + A client for interacting with a Pinecone Repository search endpoint. + """ + + def __init__( + self, + api_key: str, + host: str, + pool_threads: Optional[int] = None, + additional_headers: Optional[Dict[str, str]] = {}, + openapi_config=None, + **kwargs, + ): + self._config = ConfigBuilder.build( + api_key=api_key, host=host, additional_headers=additional_headers, **kwargs + ) + """ :meta private: """ + self._openapi_config = ConfigBuilder.build_openapi_config(self._config, openapi_config) + """ :meta private: """ + + if pool_threads is None: + self._pool_threads = 5 * cpu_count() + """ :meta private: """ + else: + self._pool_threads = pool_threads + """ :meta private: """ + + if kwargs.get("connection_pool_maxsize", None): + self._openapi_config.connection_pool_maxsize = kwargs.get("connection_pool_maxsize") + + self._repo_api = setup_openapi_client( + api_client_klass=ApiClient, + api_klass=DocumentOperationsApi, + config=self._config, + openapi_config=self._openapi_config, + pool_threads=self._pool_threads, + api_version=API_VERSION, + ) + + self._api_client = self._repo_api.api_client + + @property + def config(self) -> "Config": + """:meta private:""" + return self._config + + @property + def openapi_config(self) -> "OpenApiConfiguration": + """:meta private:""" + warnings.warn( + "The `openapi_config` property has been renamed to `_openapi_config`. It is considered private and should not be used directly. This warning will become an error in a future version of the Pinecone Python SDK.", + DeprecationWarning, + stacklevel=2, + ) + return self._openapi_config + + @property + def pool_threads(self) -> int: + """:meta private:""" + warnings.warn( + "The `pool_threads` property has been renamed to `_pool_threads`. It is considered private and should not be used directly. This warning will become an error in a future version of the Pinecone Python SDK.", + DeprecationWarning, + stacklevel=2, + ) + return self._pool_threads + + def _openapi_kwargs(self, kwargs: Dict[str, Any]) -> Dict[str, Any]: + return filter_dict(kwargs, OPENAPI_ENDPOINT_PARAMS) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self._repo_api.api_client.close() + + def close(self): + self._repo_api.api_client.close() + + @validate_and_convert_errors + def search( + self, + namespace: str, + query_str: str, + top_k: Optional[int] = 10, + filter: Optional[Dict[str, Any]] = None, + ) -> SearchDocumentsResponse: + if namespace is None: + raise Exception("Namespace is required when searching documents") + + if top_k is None: + top_k = 10 + + request = RepositoryRequestFactory.search_request( + query_str=query_str, top_k=top_k, filter=filter + ) + + return self._repo_api.search_documents(namespace, request) diff --git a/pinecone/repository_data/request_factory.py b/pinecone/repository_data/request_factory.py new file mode 100644 index 00000000..d1d21ae2 --- /dev/null +++ b/pinecone/repository_data/request_factory.py @@ -0,0 +1,32 @@ +import logging +from typing import Dict, Any, Optional + +from pinecone.core.openapi.repository_data.models import ( + QueryModel, + SearchDocuments, + QueryInputModel, +) + +from pinecone.openapi_support import OPENAPI_ENDPOINT_PARAMS + + +logger = logging.getLogger(__name__) +""" :meta private: """ + + +def non_openapi_kwargs(kwargs: Dict[str, Any]) -> Dict[str, Any]: + return {k: v for k, v in kwargs.items() if k not in OPENAPI_ENDPOINT_PARAMS} + + +class RepositoryRequestFactory: + @staticmethod + def search_request( + query_str: str, + top_k: int, + filter: Optional[Dict[str, Any]] = None, + # TODO, add options + ) -> SearchDocuments: + filter = {} if filter is None else filter + return SearchDocuments( + query=QueryModel(inputs=QueryInputModel(text=query_str), top_k=top_k, filter=filter) + ) diff --git a/pinecone/repository_data/types/__init__.py b/pinecone/repository_data/types/__init__.py new file mode 100644 index 00000000..05998ea0 --- /dev/null +++ b/pinecone/repository_data/types/__init__.py @@ -0,0 +1,3 @@ +from .search_query_typed_dict import SearchQueryTypedDict + +__all__ = ["SearchQueryTypedDict"] diff --git a/pinecone/repository_data/types/search_query_typed_dict.py b/pinecone/repository_data/types/search_query_typed_dict.py new file mode 100644 index 00000000..3c26a50a --- /dev/null +++ b/pinecone/repository_data/types/search_query_typed_dict.py @@ -0,0 +1,25 @@ +from typing import TypedDict, Optional, Dict, Any + + +class SearchQueryTypedDict(TypedDict): + """ + SearchQuery represents the query when searching within a specific namespace. + """ + + inputs: Dict[str, Any] + """ + The input data to search with. + Required. + """ + + top_k: int + """ + The number of results to return with each search. + Required. + """ + + filter: Optional[Dict[str, Any]] + """ + The filter to apply to the search. + Optional. + """