From ff063f1275ab281fecbb26128933eedc978a3106 Mon Sep 17 00:00:00 2001 From: Jen Hamon Date: Fri, 14 Nov 2025 14:06:55 -0500 Subject: [PATCH 1/2] Regenerate code --- codegen/apis | 2 +- .../db_data/model/list_namespaces_response.py | 4 +++ .../db_data/model/namespace_description.py | 12 ++++--- .../core/openapi/db_data/models/__init__.py | 3 ++ pinecone/grpc/utils.py | 31 +++++++++++++++++-- pinecone/openapi_support/api_version.py | 2 +- 6 files changed, 46 insertions(+), 8 deletions(-) diff --git a/codegen/apis b/codegen/apis index bbad89bd5..d5ac93191 160000 --- a/codegen/apis +++ b/codegen/apis @@ -1 +1 @@ -Subproject commit bbad89bd51d792534a9ba06a44ed1f2259f7f89f +Subproject commit d5ac93191def1d9666946d2c0e67edd3140b0f0d diff --git a/pinecone/core/openapi/db_data/model/list_namespaces_response.py b/pinecone/core/openapi/db_data/model/list_namespaces_response.py index 18dafef4f..7320854aa 100644 --- a/pinecone/core/openapi/db_data/model/list_namespaces_response.py +++ b/pinecone/core/openapi/db_data/model/list_namespaces_response.py @@ -96,6 +96,7 @@ def openapi_types(cls): return { "namespaces": ([NamespaceDescription],), # noqa: E501 "pagination": (Pagination,), # noqa: E501 + "total_count": (int,), # noqa: E501 } @cached_class_property @@ -105,6 +106,7 @@ def discriminator(cls): attribute_map: Dict[str, str] = { "namespaces": "namespaces", # noqa: E501 "pagination": "pagination", # noqa: E501 + "total_count": "total_count", # noqa: E501 } read_only_vars: Set[str] = set([]) @@ -149,6 +151,7 @@ def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 _visited_composed_classes = (Animal,) namespaces ([NamespaceDescription]): The list of namespaces belonging to this index. [optional] # noqa: E501 pagination (Pagination): [optional] # noqa: E501 + total_count (int): The total number of namespaces in the index matching the prefix [optional] # noqa: E501 """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) @@ -240,6 +243,7 @@ def __init__(self, *args, **kwargs) -> None: # noqa: E501 _visited_composed_classes = (Animal,) namespaces ([NamespaceDescription]): The list of namespaces belonging to this index. [optional] # noqa: E501 pagination (Pagination): [optional] # noqa: E501 + total_count (int): The total number of namespaces in the index matching the prefix [optional] # noqa: E501 """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) diff --git a/pinecone/core/openapi/db_data/model/namespace_description.py b/pinecone/core/openapi/db_data/model/namespace_description.py index f69a0c897..0127e3652 100644 --- a/pinecone/core/openapi/db_data/model/namespace_description.py +++ b/pinecone/core/openapi/db_data/model/namespace_description.py @@ -31,8 +31,12 @@ def lazy_import(): from pinecone.core.openapi.db_data.model.create_namespace_request_schema import ( CreateNamespaceRequestSchema, ) + from pinecone.core.openapi.db_data.model.namespace_description_indexed_fields import ( + NamespaceDescriptionIndexedFields, + ) globals()["CreateNamespaceRequestSchema"] = CreateNamespaceRequestSchema + globals()["NamespaceDescriptionIndexedFields"] = NamespaceDescriptionIndexedFields from typing import Dict, Literal, Tuple, Set, Any, Type, TypeVar @@ -97,7 +101,7 @@ def openapi_types(cls): "name": (str,), # noqa: E501 "record_count": (int,), # noqa: E501 "schema": (CreateNamespaceRequestSchema,), # noqa: E501 - "total_count": (int,), # noqa: E501 + "indexed_fields": (NamespaceDescriptionIndexedFields,), # noqa: E501 } @cached_class_property @@ -108,7 +112,7 @@ def discriminator(cls): "name": "name", # noqa: E501 "record_count": "record_count", # noqa: E501 "schema": "schema", # noqa: E501 - "total_count": "total_count", # noqa: E501 + "indexed_fields": "indexed_fields", # noqa: E501 } read_only_vars: Set[str] = set([]) @@ -154,7 +158,7 @@ def _from_openapi_data(cls: Type[T], *args, **kwargs) -> T: # noqa: E501 name (str): The name of the namespace. [optional] # noqa: E501 record_count (int): The total amount of records within the namespace. [optional] # noqa: E501 schema (CreateNamespaceRequestSchema): [optional] # noqa: E501 - total_count (int): The total number of namespaces in the index matching the prefix [optional] # noqa: E501 + indexed_fields (NamespaceDescriptionIndexedFields): [optional] # noqa: E501 """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", False) @@ -247,7 +251,7 @@ def __init__(self, *args, **kwargs) -> None: # noqa: E501 name (str): The name of the namespace. [optional] # noqa: E501 record_count (int): The total amount of records within the namespace. [optional] # noqa: E501 schema (CreateNamespaceRequestSchema): [optional] # noqa: E501 - total_count (int): The total number of namespaces in the index matching the prefix [optional] # noqa: E501 + indexed_fields (NamespaceDescriptionIndexedFields): [optional] # noqa: E501 """ _enforce_allowed_values = kwargs.pop("_enforce_allowed_values", True) diff --git a/pinecone/core/openapi/db_data/models/__init__.py b/pinecone/core/openapi/db_data/models/__init__.py index c15976816..e3b28075a 100644 --- a/pinecone/core/openapi/db_data/models/__init__.py +++ b/pinecone/core/openapi/db_data/models/__init__.py @@ -32,6 +32,9 @@ from pinecone.core.openapi.db_data.model.list_namespaces_response import ListNamespacesResponse from pinecone.core.openapi.db_data.model.list_response import ListResponse from pinecone.core.openapi.db_data.model.namespace_description import NamespaceDescription +from pinecone.core.openapi.db_data.model.namespace_description_indexed_fields import ( + NamespaceDescriptionIndexedFields, +) from pinecone.core.openapi.db_data.model.namespace_summary import NamespaceSummary from pinecone.core.openapi.db_data.model.pagination import Pagination from pinecone.core.openapi.db_data.model.protobuf_any import ProtobufAny diff --git a/pinecone/grpc/utils.py b/pinecone/grpc/utils.py index 66fcaf825..688f247da 100644 --- a/pinecone/grpc/utils.py +++ b/pinecone/grpc/utils.py @@ -12,6 +12,7 @@ IndexDescription as DescribeIndexStatsResponse, NamespaceSummary, NamespaceDescription, + NamespaceDescriptionIndexedFields, ListNamespacesResponse, Pagination as OpenApiPagination, ) @@ -240,9 +241,20 @@ def parse_namespace_description( from pinecone.utils.response_info import extract_response_info json_response = json_format.MessageToDict(response) + + # Extract indexed_fields if present + indexed_fields = None + if "indexedFields" in json_response and json_response["indexedFields"]: + indexed_fields_data = json_response["indexedFields"] + if "fields" in indexed_fields_data: + indexed_fields = NamespaceDescriptionIndexedFields( + fields=indexed_fields_data.get("fields", []), _check_type=False + ) + namespace_desc = NamespaceDescription( name=json_response.get("name", ""), record_count=json_response.get("recordCount", 0), + indexed_fields=indexed_fields, _check_type=False, ) @@ -259,9 +271,21 @@ def parse_list_namespaces_response(response: Message) -> ListNamespacesResponse: namespaces = [] for ns in json_response.get("namespaces", []): + # Extract indexed_fields if present + indexed_fields = None + if "indexedFields" in ns and ns["indexedFields"]: + indexed_fields_data = ns["indexedFields"] + if "fields" in indexed_fields_data: + indexed_fields = NamespaceDescriptionIndexedFields( + fields=indexed_fields_data.get("fields", []), _check_type=False + ) + namespaces.append( NamespaceDescription( - name=ns.get("name", ""), record_count=ns.get("recordCount", 0), _check_type=False + name=ns.get("name", ""), + record_count=ns.get("recordCount", 0), + indexed_fields=indexed_fields, + _check_type=False, ) ) @@ -271,4 +295,7 @@ def parse_list_namespaces_response(response: Message) -> ListNamespacesResponse: next=json_response["pagination"].get("next", ""), _check_type=False ) - return ListNamespacesResponse(namespaces=namespaces, pagination=pagination, _check_type=False) + total_count = json_response.get("totalCount") + return ListNamespacesResponse( + namespaces=namespaces, pagination=pagination, total_count=total_count, _check_type=False + ) diff --git a/pinecone/openapi_support/api_version.py b/pinecone/openapi_support/api_version.py index 5dfe05117..c68138d9b 100644 --- a/pinecone/openapi_support/api_version.py +++ b/pinecone/openapi_support/api_version.py @@ -2,4 +2,4 @@ # Do not edit this file manually. API_VERSION = "2025-10" -APIS_REPO_SHA = "827d26f4825902994a099595d49779d16fea3a0a" +APIS_REPO_SHA = "bbad89bd51d792534a9ba06a44ed1f2259f7f89f" From 79940bb2ed5d4986737b4775d5f6933ab48fbee7 Mon Sep 17 00:00:00 2001 From: Jen Hamon Date: Fri, 14 Nov 2025 14:26:13 -0500 Subject: [PATCH 2/2] Add file I forgot to commit --- .../namespace_description_indexed_fields.py | 270 ++++++++++++++++++ 1 file changed, 270 insertions(+) create mode 100644 pinecone/core/openapi/db_data/model/namespace_description_indexed_fields.py diff --git a/pinecone/core/openapi/db_data/model/namespace_description_indexed_fields.py b/pinecone/core/openapi/db_data/model/namespace_description_indexed_fields.py new file mode 100644 index 000000000..edd8ace1d --- /dev/null +++ b/pinecone/core/openapi/db_data/model/namespace_description_indexed_fields.py @@ -0,0 +1,270 @@ +""" +Pinecone Data Plane API + +Pinecone is a vector database that makes it easy to search and retrieve billions of high-dimensional vectors. # noqa: E501 + +This file is @generated using OpenAPI. + +The version of the OpenAPI document: 2025-10 +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="NamespaceDescriptionIndexedFields") + + +class NamespaceDescriptionIndexedFields(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 { + "fields": ([str],) # 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], *args, **kwargs) -> T: # noqa: E501 + """NamespaceDescriptionIndexedFields - 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,) + fields ([str]): [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 + """NamespaceDescriptionIndexedFields - 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,) + fields ([str]): [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." + )