pinecone 5.4.2__tar.gz → 6.0.0.dev2__tar.gz

{pinecone-5.4.2 → pinecone-6.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pinecone
-Version: 5.4.2
+Version: 6.0.0.dev2
 Summary: Pinecone client and SDK
 Home-page: https://www.pinecone.io
 License: Apache-2.0
@@ -33,9 +33,9 @@ Requires-Dist: googleapis-common-protos (>=1.53.0) ; extra == "grpc"
 Requires-Dist: grpcio (>=1.44.0) ; (python_version >= "3.8" and python_version < "3.11") and (extra == "grpc")
 Requires-Dist: grpcio (>=1.59.0) ; (python_version >= "3.11" and python_version < "4.0") and (extra == "grpc")
 Requires-Dist: lz4 (>=3.1.3) ; extra == "grpc"
-Requires-Dist: pinecone-plugin-inference (>=2.0.0,<4.0.0)
+Requires-Dist: pinecone-plugin-inference (>=2.0.0,<3.0.0)
 Requires-Dist: pinecone-plugin-interface (>=0.0.7,<0.0.8)
-Requires-Dist: protobuf (>=4.25,<5.0) ; extra == "grpc"
+Requires-Dist: protobuf (>=5.28,<6.0) ; extra == "grpc"
 Requires-Dist: protoc-gen-openapiv2 (>=0.0.1,<0.0.2) ; extra == "grpc"
 Requires-Dist: python-dateutil (>=2.5.3)
 Requires-Dist: tqdm (>=4.64.1)

pinecone-6.0.0.dev2/pinecone/__version__

@@ -0,0 +1 @@
+6.0.0.dev2

{pinecone-5.4.2 → pinecone-6.0.0.dev2}/pinecone/control/pinecone.py

@@ -1,6 +1,6 @@
 import time
 import logging
-from typing import Optional, Dict, Any, Union, List, Tuple, Literal
+from typing import Optional, Dict, Any, Union, Literal
 
 from .index_host_store import IndexHostStore
 
@@ -10,7 +10,12 @@ from pinecone.core.openapi.control.api.manage_indexes_api import ManageIndexesAp
 from pinecone.core.openapi.shared.api_client import ApiClient
 
 
-from pinecone.utils import normalize_host, setup_openapi_client, build_plugin_setup_client
+from pinecone.utils import (
+    normalize_host,
+    setup_openapi_client,
+    build_plugin_setup_client,
+    parse_non_empty_args,
+)
 from pinecone.core.openapi.control.models import (
     CreateCollectionRequest,
     CreateIndexRequest,
@@ -317,9 +322,6 @@ class Pinecone:
 
         api_instance = self.index_api
 
-        def _parse_non_empty_args(args: List[Tuple[str, Any]]) -> Dict[str, Any]:
-            return {arg_name: val for arg_name, val in args if val is not None}
-
         if deletion_protection in ["enabled", "disabled"]:
             dp = DeletionProtection(deletion_protection)
         else:
@@ -329,7 +331,7 @@ class Pinecone:
             if "serverless" in spec:
                 index_spec = IndexSpec(serverless=ServerlessSpecModel(**spec["serverless"]))
             elif "pod" in spec:
-                args_dict = _parse_non_empty_args(
+                args_dict = parse_non_empty_args(
                     [
                         ("environment", spec["pod"].get("environment")),
                         ("metadata_config", spec["pod"].get("metadata_config")),
@@ -351,7 +353,7 @@ class Pinecone:
                 serverless=ServerlessSpecModel(cloud=spec.cloud, region=spec.region)
             )
         elif isinstance(spec, PodSpec):
-            args_dict = _parse_non_empty_args(
+            args_dict = parse_non_empty_args(
                 [
                     ("replicas", spec.replicas),
                     ("shards", spec.shards),
@@ -765,14 +767,6 @@ class Pinecone:
         # Now you're ready to perform data operations
         index.query(vector=[...], top_k=10)
         ```
-
-        Arguments:
-            name: The name of the index to target. If you specify the name of the index, the client will
-                fetch the host url from the Pinecone control plane.
-            host: The host url of the index to target. If you specify the host url, the client will use
-                the host url directly without making any additional calls to the control plane.
-            pool_threads: The number of threads to use when making parallel requests by calling index methods with optional kwarg async_req=True, or using methods that make use of parallelism automatically such as query_namespaces(). Default: 1
-            connection_pool_maxsize: The maximum number of connections to keep in the connection pool. Default: 5 * multiprocessing.cpu_count()
         """
         if name == "" and host == "":
             raise ValueError("Either name or host must be specified")

{pinecone-5.4.2 → pinecone-6.0.0.dev2}/pinecone/core/openapi/shared/api_client.py

@@ -2,31 +2,12 @@ import json
 import atexit
 import mimetypes
 from multiprocessing.pool import ThreadPool
-from concurrent.futures import ThreadPoolExecutor
 import io
 import os
 import re
 import typing
 from urllib.parse import quote
 from urllib3.fields import RequestField
-import time
-import random
-
-def retry_api_call(
-    func, args=(), kwargs={}, retries=3, backoff=1, jitter=0.5
-):
-    attempts = 0
-    while attempts < retries:
-        try:
-            return func(*args, **kwargs)  # Attempt to call __call_api
-        except Exception as e:
-            attempts += 1
-            if attempts >= retries:
-                print(f"API call failed after {attempts} attempts: {e}")
-                raise  # Re-raise exception if retries are exhausted
-            sleep_time = backoff * (2 ** (attempts - 1)) + random.uniform(0, jitter)
-            # print(f"Retrying ({attempts}/{retries}) in {sleep_time:.2f} seconds after error: {e}")
-            time.sleep(sleep_time)
 
 
 from pinecone.core.openapi.shared import rest
@@ -71,7 +52,6 @@ class ApiClient(object):
     """
 
     _pool = None
-    _threadpool_executor = None
 
     def __init__(self, configuration=None, header_name=None, header_value=None, cookie=None, pool_threads=1):
         if configuration is None:
@@ -94,9 +74,6 @@ class ApiClient(object):
         self.close()
 
     def close(self):
-        if self._threadpool_executor:
-            self._threadpool_executor.shutdown()
-            self._threadpool_executor = None
         if self._pool:
             self._pool.close()
             self._pool.join()
@@ -114,12 +91,6 @@ class ApiClient(object):
             self._pool = ThreadPool(self.pool_threads)
         return self._pool
 
-    @property
-    def threadpool_executor(self):
-        if self._threadpool_executor is None:
-            self._threadpool_executor = ThreadPoolExecutor(max_workers=self.pool_threads)
-        return self._threadpool_executor
-
     @property
     def user_agent(self):
         """User agent for this API client"""
@@ -345,7 +316,6 @@ class ApiClient(object):
         response_type: typing.Optional[typing.Tuple[typing.Any]] = None,
         auth_settings: typing.Optional[typing.List[str]] = None,
         async_req: typing.Optional[bool] = None,
-        async_threadpool_executor: typing.Optional[bool] = None,
         _return_http_data_only: typing.Optional[bool] = None,
         collection_formats: typing.Optional[typing.Dict[str, str]] = None,
         _preload_content: bool = True,
@@ -406,9 +376,8 @@ class ApiClient(object):
             If parameter async_req is False or missing,
             then the method will return the response directly.
         """
-        if async_threadpool_executor:
-            return self.threadpool_executor.submit(
-                self.__call_api,
+        if not async_req:
+            return self.__call_api(
                 resource_path,
                 method,
                 path_params,
@@ -427,8 +396,9 @@ class ApiClient(object):
                 _check_type,
             )
 
-        if not async_req:
-            return self.__call_api(
+        return self.pool.apply_async(
+            self.__call_api,
+            (
                 resource_path,
                 method,
                 path_params,
@@ -445,35 +415,7 @@ class ApiClient(object):
                 _request_timeout,
                 _host,
                 _check_type,
-            )
-
-        return self.pool.apply_async(
-            retry_api_call,
-            args=(
-                self.__call_api,  # Pass the API call function as the first argument
-                (
-                    resource_path,
-                    method,
-                    path_params,
-                    query_params,
-                    header_params,
-                    body,
-                    post_params,
-                    files,
-                    response_type,
-                    auth_settings,
-                    _return_http_data_only,
-                    collection_formats,
-                    _preload_content,
-                    _request_timeout,
-                    _host,
-                    _check_type,
-                ),
-                {},  # empty kwargs dictionary
-                3,    # retries
-                1,    # backoff time
-                0.5   # jitter
-            )
+            ),
         )
 
     def request(
@@ -723,7 +665,6 @@ class Endpoint(object):
         self.params_map["all"].extend(
             [
                 "async_req",
-                "async_threadpool_executor",
                 "_host_index",
                 "_preload_content",
                 "_request_timeout",
@@ -738,7 +679,6 @@ class Endpoint(object):
         self.openapi_types = root_map["openapi_types"]
         extra_types = {
             "async_req": (bool,),
-            "async_threadpool_executor": (bool, ),
             "_host_index": (none_type, int),
             "_preload_content": (bool,),
             "_request_timeout": (none_type, float, (float,), [float], int, (int,), [int]),
@@ -888,7 +828,6 @@ class Endpoint(object):
             response_type=self.settings["response_type"],
             auth_settings=self.settings["auth"],
             async_req=kwargs["async_req"],
-            async_threadpool_executor=kwargs.get("async_threadpool_executor", None),
             _check_type=kwargs["_check_return_type"],
             _return_http_data_only=kwargs["_return_http_data_only"],
             _preload_content=kwargs["_preload_content"],

{pinecone-5.4.2 → pinecone-6.0.0.dev2}/pinecone/core/openapi/shared/configuration.py

@@ -469,23 +469,3 @@ class Configuration(object):
         """Fix base path."""
         self._base_path = value
         self.server_index = None
-
-    def __repr__(self):
-        attrs = [
-            f"host={self.host}",
-            f"api_key=***",
-            f"api_key_prefix={self.api_key_prefix}",
-            f"access_token={self.access_token}",
-            f"connection_pool_maxsize={self.connection_pool_maxsize}",
-            f"username={self.username}",
-            f"password={self.password}",
-            f"discard_unknown_keys={self.discard_unknown_keys}",
-            f"disabled_client_side_validations={self.disabled_client_side_validations}",
-            f"server_index={self.server_index}",
-            f"server_variables={self.server_variables}",
-            f"server_operation_index={self.server_operation_index}",
-            f"server_operation_variables={self.server_operation_variables}",
-            f"ssl_ca_cert={self.ssl_ca_cert}",
-
-        ]
-        return f"Configuration({', '.join(attrs)})"

{pinecone-5.4.2 → pinecone-6.0.0.dev2}/pinecone/data/index.py

@@ -1,12 +1,11 @@
 from tqdm.autonotebook import tqdm
 
-import logging
-import json
-from typing import Union, List, Optional, Dict, Any, Literal
+from typing import Union, List, Optional, Dict, Any
 
 from pinecone.config import ConfigBuilder
 
 from pinecone.core.openapi.shared import API_VERSION
+from pinecone.core.openapi.data.models import SparseValues
 from pinecone.core.openapi.data import ApiClient
 from pinecone.core.openapi.data.models import (
     FetchResponse,
@@ -23,25 +22,13 @@ from pinecone.core.openapi.data.models import (
     UpdateRequest,
     DescribeIndexStatsRequest,
     ListResponse,
-    SparseValues,
-)
-from pinecone.core.openapi.data.api.data_plane_api import DataPlaneApi
-from ..utils import (
-    setup_openapi_client,
-    parse_non_empty_args,
-    build_plugin_setup_client,
-    validate_and_convert_errors,
 )
 from .features.bulk_import import ImportFeatureMixin
+from pinecone.core.openapi.data.api.data_plane_api import DataPlaneApi
+from ..utils import setup_openapi_client, parse_non_empty_args
 from .vector_factory import VectorFactory
 from .query_results_aggregator import QueryResultsAggregator, QueryNamespacesResults
-
 from multiprocessing.pool import ApplyResult
-from concurrent.futures import as_completed
-
-from pinecone_plugin_interface import load_and_install as install_plugins
-
-logger = logging.getLogger(__name__)
 
 __all__ = [
     "Index",
@@ -62,6 +49,8 @@ __all__ = [
     "SparseValues",
 ]
 
+from ..utils.error_handling import validate_and_convert_errors
+
 _OPENAPI_ENDPOINT_PARAMS = (
     "_return_http_data_only",
     "_preload_content",
@@ -70,7 +59,6 @@ _OPENAPI_ENDPOINT_PARAMS = (
     "_check_return_type",
     "_host_index",
     "async_req",
-    "async_threadpool_executor",
 )
 
 
@@ -103,41 +91,20 @@ class Index(ImportFeatureMixin):
             **kwargs,
         )
 
-        self.config = ConfigBuilder.build(
+        self._config = ConfigBuilder.build(
             api_key=api_key, host=host, additional_headers=additional_headers, **kwargs
         )
-        self._openapi_config = ConfigBuilder.build_openapi_config(self.config, openapi_config)
-        self._pool_threads = pool_threads
-
-        if kwargs.get("connection_pool_maxsize", None):
-            self._openapi_config.connection_pool_maxsize = kwargs.get("connection_pool_maxsize")
+        openapi_config = ConfigBuilder.build_openapi_config(self._config, openapi_config)
 
         self._vector_api = setup_openapi_client(
             api_client_klass=ApiClient,
             api_klass=DataPlaneApi,
-            config=self.config,
-            openapi_config=self._openapi_config,
-            pool_threads=self._pool_threads,
+            config=self._config,
+            openapi_config=openapi_config,
+            pool_threads=pool_threads,
             api_version=API_VERSION,
         )
 
-        self._load_plugins()
-
-    def _load_plugins(self):
-        """@private"""
-        try:
-            # I don't expect this to ever throw, but wrapping this in a
-            # try block just in case to make sure a bad plugin doesn't
-            # halt client initialization.
-            openapi_client_builder = build_plugin_setup_client(
-                config=self.config,
-                openapi_config=self._openapi_config,
-                pool_threads=self._pool_threads,
-            )
-            install_plugins(self, openapi_client_builder)
-        except Exception as e:
-            logger.error(f"Error loading plugins in Index: {e}")
-
     def __enter__(self):
         return self
 
@@ -451,7 +418,7 @@ class Index(ImportFeatureMixin):
             **kwargs,
         )
 
-        if kwargs.get("async_req", False) or kwargs.get("async_threadpool_executor", False):
+        if kwargs.get("async_req", False):
             return response
         else:
             return parse_query_response(response)
@@ -495,7 +462,6 @@ class Index(ImportFeatureMixin):
                 ("sparse_vector", sparse_vector),
             ]
         )
-
         response = self._vector_api.query(
             QueryRequest(
                 **args_dict,
@@ -506,12 +472,10 @@ class Index(ImportFeatureMixin):
         )
         return response
 
-    @validate_and_convert_errors
     def query_namespaces(
         self,
         vector: List[float],
         namespaces: List[str],
-        metric: Literal["cosine", "euclidean", "dotproduct"],
         top_k: Optional[int] = None,
         filter: Optional[Dict[str, Union[str, float, int, bool, List, dict]]] = None,
         include_values: Optional[bool] = None,
@@ -521,78 +485,38 @@ class Index(ImportFeatureMixin):
         ] = None,
         **kwargs,
     ) -> QueryNamespacesResults:
-        """The query_namespaces() method is used to make a query to multiple namespaces in parallel and combine the results into one result set.
-
-        Since several asynchronous calls are made on your behalf when calling this method, you will need to tune the pool_threads and connection_pool_maxsize parameter of the Index constructor to suite your workload.
-
-        Examples:
-
-        ```python
-        from pinecone import Pinecone
-
-        pc = Pinecone(api_key="your-api-key")
-        index = pc.Index(
-            host="index-name",
-            pool_threads=32,
-            connection_pool_maxsize=32
-        )
-
-        query_vec = [0.1, 0.2, 0.3] # An embedding that matches the index dimension
-        combined_results = index.query_namespaces(
-            vector=query_vec,
-            namespaces=['ns1', 'ns2', 'ns3', 'ns4'],
-            metric="cosine",
-            top_k=10,
-            filter={'genre': {"$eq": "drama"}},
-            include_values=True,
-            include_metadata=True
-        )
-        for vec in combined_results.matches:
-            print(vec.id, vec.score)
-        print(combined_results.usage)
-        ```
-
-        Args:
-            vector (List[float]): The query vector, must be the same length as the dimension of the index being queried.
-            namespaces (List[str]): The list of namespaces to query.
-            top_k (Optional[int], optional): The number of results you would like to request from each namespace. Defaults to 10.
-            metric (str): Must be one of 'cosine', 'euclidean', 'dotproduct'. This is needed in order to merge results across namespaces, since the interpretation of score depends on the index metric type.
-            filter (Optional[Dict[str, Union[str, float, int, bool, List, dict]]], optional): Pass an optional filter to filter results based on metadata. Defaults to None.
-            include_values (Optional[bool], optional): Boolean field indicating whether vector values should be included with results. Defaults to None.
-            include_metadata (Optional[bool], optional): Boolean field indicating whether vector metadata should be included with results. Defaults to None.
-            sparse_vector (Optional[ Union[SparseValues, Dict[str, Union[List[float], List[int]]]] ], optional): If you are working with a dotproduct index, you can pass a sparse vector as part of your hybrid search. Defaults to None.
-
-        Returns:
-            QueryNamespacesResults: A QueryNamespacesResults object containing the combined results from all namespaces, as well as the combined usage cost in read units.
-        """
-        if namespaces is None or len(namespaces) == 0:
+        if len(namespaces) == 0:
             raise ValueError("At least one namespace must be specified")
         if len(vector) == 0:
             raise ValueError("Query vector must not be empty")
 
+        # The caller may only want the top_k=1 result across all queries,
+        # but we need to get at least 2 results from each query in order to
+        # aggregate them correctly. So we'll temporarily set topK to 2 for the
+        # subqueries, and then we'll take the topK=1 results from the aggregated
+        # results.
         overall_topk = top_k if top_k is not None else 10
-        aggregator = QueryResultsAggregator(top_k=overall_topk, metric=metric)
+        aggregator = QueryResultsAggregator(top_k=overall_topk)
+        subquery_topk = overall_topk if overall_topk > 2 else 2
 
         target_namespaces = set(namespaces)  # dedup namespaces
-        async_futures = [
+        async_results = [
             self.query(
                 vector=vector,
                 namespace=ns,
-                top_k=overall_topk,
+                top_k=subquery_topk,
                 filter=filter,
                 include_values=include_values,
                 include_metadata=include_metadata,
                 sparse_vector=sparse_vector,
-                async_threadpool_executor=True,
-                _preload_content=False,
+                async_req=True,
                 **kwargs,
             )
             for ns in target_namespaces
         ]
 
-        for result in as_completed(async_futures):
-            raw_result = result.result()
-            response = json.loads(raw_result.data.decode("utf-8"))
+        for result in async_results:
+            response = result.get()
             aggregator.add_results(response)
 
         final_results = aggregator.get_results()

{pinecone-5.4.2 → pinecone-6.0.0.dev2}/pinecone/data/query_results_aggregator.py

@@ -1,8 +1,7 @@
-from typing import List, Tuple, Optional, Any, Dict, Literal
+from typing import List, Tuple, Optional, Any, Dict
 import json
 import heapq
 from pinecone.core.openapi.data.models import Usage
-from pinecone.core.openapi.data.models import QueryResponse as OpenAPIQueryResponse
 
 from dataclasses import dataclass, asdict
 
@@ -31,9 +30,6 @@ class ScoredVectorWithNamespace:
         else:
             raise KeyError(f"'{key}' not found in ScoredVectorWithNamespace")
 
-    def get(self, key, default=None):
-        return getattr(self, key, default)
-
     def __repr__(self):
         return json.dumps(self._truncate(asdict(self)), indent=4)
 
@@ -75,9 +71,6 @@ class QueryNamespacesResults:
         else:
             raise KeyError(f"'{key}' not found in QueryNamespacesResults")
 
-    def get(self, key, default=None):
-        return getattr(self, key, default)
-
     def __repr__(self):
         return json.dumps(
             {
@@ -88,38 +81,46 @@ class QueryNamespacesResults:
         )
 
 
+class QueryResultsAggregregatorNotEnoughResultsError(Exception):
+    def __init__(self):
+        super().__init__(
+            "Cannot interpret results without at least two matches. In order to aggregate results from multiple queries, top_k must be greater than 1 in order to correctly infer the similarity metric from scores."
+        )
+
+
 class QueryResultsAggregatorInvalidTopKError(Exception):
     def __init__(self, top_k: int):
-        super().__init__(f"Invalid top_k value {top_k}. top_k must be at least 1.")
+        super().__init__(
+            f"Invalid top_k value {top_k}. To aggregate results from multiple queries the top_k must be at least 2."
+        )
 
 
 class QueryResultsAggregator:
-    def __init__(self, top_k: int, metric: Literal["cosine", "euclidean", "dotproduct"]):
-        if top_k < 1:
+    def __init__(self, top_k: int):
+        if top_k < 2:
             raise QueryResultsAggregatorInvalidTopKError(top_k)
-
-        if metric in ["dotproduct", "cosine"]:
-            self.is_bigger_better = True
-        elif metric in ["euclidean"]:
-            self.is_bigger_better = False
-        else:
-            raise ValueError(
-                f"Cannot merge results for unknown similarity metric {metric}. Supported metrics are 'dotproduct', 'cosine', and 'euclidean'."
-            )
-
         self.top_k = top_k
         self.usage_read_units = 0
         self.heap: List[Tuple[float, int, object, str]] = []
         self.insertion_counter = 0
+        self.is_dotproduct = None
         self.read = False
         self.final_results: Optional[QueryNamespacesResults] = None
 
-    def _bigger_better_heap_item(self, match, ns):
-        # This 4-tuple is used to ensure that the heap is sorted by score followed by
-        # insertion order. The insertion order is used to break any ties in the score.
+    def _is_dotproduct_index(self, matches):
+        # The interpretation of the score depends on the similar metric used.
+        # Unlike other index types, in indexes configured for dotproduct,
+        # a higher score is better. We have to infer this is the case by inspecting
+        # the order of the scores in the results.
+        for i in range(1, len(matches)):
+            if matches[i].get("score") > matches[i - 1].get("score"):  # Found an increase
+                return False
+        return True
+
+    def _dotproduct_heap_item(self, match, ns):
         return (match.get("score"), -self.insertion_counter, match, ns)
 
-    def _smaller_better_heap_item(self, match, ns):
+    def _non_dotproduct_heap_item(self, match, ns):
         return (-match.get("score"), -self.insertion_counter, match, ns)
 
     def _process_matches(self, matches, ns, heap_item_fn):
@@ -129,10 +130,10 @@ class QueryResultsAggregator:
                 heapq.heappush(self.heap, heap_item_fn(match, ns))
             else:
                 # Assume we have dotproduct scores sorted in descending order
-                if self.is_bigger_better and match["score"] < self.heap[0][0]:
+                if self.is_dotproduct and match["score"] < self.heap[0][0]:
                     # No further matches can improve the top-K heap
                     break
-                elif not self.is_bigger_better and match["score"] > -self.heap[0][0]:
+                elif not self.is_dotproduct and match["score"] > -self.heap[0][0]:
                     # No further matches can improve the top-K heap
                     break
                 heapq.heappushpop(self.heap, heap_item_fn(match, ns))
@@ -146,18 +147,23 @@ class QueryResultsAggregator:
 
         matches = results.get("matches", [])
         ns: str = results.get("namespace", "")
-        if isinstance(results, OpenAPIQueryResponse):
-            self.usage_read_units += results.usage.read_units
-        else:
-            self.usage_read_units += results.get("usage", {}).get("readUnits", 0)
+        self.usage_read_units += results.get("usage", {}).get("readUnits", 0)
 
         if len(matches) == 0:
             return
 
-        if self.is_bigger_better:
-            self._process_matches(matches, ns, self._bigger_better_heap_item)
+        if self.is_dotproduct is None:
+            if len(matches) == 1:
+                # This condition should match the second time we add results containing
+                # only one match. We need at least two matches in a single response in order
+                # to infer the similarity metric
+                raise QueryResultsAggregregatorNotEnoughResultsError()
+            self.is_dotproduct = self._is_dotproduct_index(matches)
+
+        if self.is_dotproduct:
+            self._process_matches(matches, ns, self._dotproduct_heap_item)
         else:
-            self._process_matches(matches, ns, self._smaller_better_heap_item)
+            self._process_matches(matches, ns, self._non_dotproduct_heap_item)
 
     def get_results(self) -> QueryNamespacesResults:
         if self.read:

{pinecone-5.4.2 → pinecone-6.0.0.dev2}/pinecone/exceptions/__init__.py

@@ -12,6 +12,8 @@ from pinecone.core.openapi.shared.exceptions import (
 )
 from .exceptions import PineconeConfigurationError, PineconeProtocolError, ListConversionException
 
+PineconeNotFoundException = NotFoundException
+
 __all__ = [
     "PineconeConfigurationError",
     "PineconeProtocolError",
@@ -22,6 +24,7 @@ __all__ = [
     "PineconeApiKeyError",
     "PineconeApiException",
     "NotFoundException",
+    "PineconeNotFoundException",
     "UnauthorizedException",
     "ForbiddenException",
     "ServiceException",

{pinecone-5.4.2 → pinecone-6.0.0.dev2}/pinecone/grpc/__init__.py

@@ -45,26 +45,23 @@ index.query(vector=[...], top_k=10)
 """
 
 from .index_grpc import GRPCIndex
+from .index_grpc_asyncio import GRPCIndexAsyncio
 from .pinecone import PineconeGRPC
 from .config import GRPCClientConfig
-from .future import PineconeGrpcFuture
 
 from pinecone.core.grpc.protos.vector_service_pb2 import (
     Vector as GRPCVector,
     SparseValues as GRPCSparseValues,
     Vector,
     SparseValues,
-    DeleteResponse as GRPCDeleteResponse,
 )
 
 __all__ = [
     "GRPCIndex",
     "PineconeGRPC",
-    "GRPCDeleteResponse",
     "GRPCClientConfig",
     "GRPCVector",
     "GRPCSparseValues",
     "Vector",
     "SparseValues",
-    "PineconeGrpcFuture",
 ]