pinecone 5.4.0__tar.gz → 5.4.0.dev2__tar.gz

{pinecone-5.4.0 → pinecone-5.4.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pinecone
-Version: 5.4.0
+Version: 5.4.0.dev2
 Summary: Pinecone client and SDK
 Home-page: https://www.pinecone.io
 License: Apache-2.0
@@ -35,7 +35,7 @@ Requires-Dist: grpcio (>=1.59.0) ; (python_version >= "3.11" and python_version
 Requires-Dist: lz4 (>=3.1.3) ; extra == "grpc"
 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-5.4.0.dev2/pinecone/__version__

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

{pinecone-5.4.0 → pinecone-5.4.0.dev2}/pinecone/control/pinecone.py

@@ -765,14 +765,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.0 → pinecone-5.4.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.0 → pinecone-5.4.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.0 → pinecone-5.4.0.dev2}/pinecone/data/index.py

@@ -1,7 +1,6 @@
 from tqdm.autonotebook import tqdm
 
 import logging
-import json
 from typing import Union, List, Optional, Dict, Any
 
 from pinecone.config import ConfigBuilder
@@ -34,10 +33,6 @@ from ..utils import (
 )
 from .features.bulk_import import ImportFeatureMixin
 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
 
@@ -70,7 +65,6 @@ _OPENAPI_ENDPOINT_PARAMS = (
     "_check_return_type",
     "_host_index",
     "async_req",
-    "async_threadpool_executor",
 )
 
 
@@ -103,21 +97,17 @@ 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,
         )
 
@@ -130,9 +120,9 @@ class Index(ImportFeatureMixin):
             # 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,
+                config=self._config,
+                openapi_config=self.openapi_config,
+                pool_threads=self.pool_threads,
             )
             install_plugins(self, openapi_client_builder)
         except Exception as e:
@@ -396,7 +386,7 @@ class Index(ImportFeatureMixin):
             Union[SparseValues, Dict[str, Union[List[float], List[int]]]]
         ] = None,
         **kwargs,
-    ) -> Union[QueryResponse, ApplyResult]:
+    ) -> QueryResponse:
         """
         The Query operation searches a namespace, using a query vector.
         It retrieves the ids of the most similar items in a namespace, along with their similarity scores.
@@ -438,39 +428,6 @@ class Index(ImportFeatureMixin):
                  and namespace name.
         """
 
-        response = self._query(
-            *args,
-            top_k=top_k,
-            vector=vector,
-            id=id,
-            namespace=namespace,
-            filter=filter,
-            include_values=include_values,
-            include_metadata=include_metadata,
-            sparse_vector=sparse_vector,
-            **kwargs,
-        )
-
-        if kwargs.get("async_req", False) or kwargs.get("async_threadpool_executor", False):
-            return response
-        else:
-            return parse_query_response(response)
-
-    def _query(
-        self,
-        *args,
-        top_k: int,
-        vector: Optional[List[float]] = None,
-        id: Optional[str] = None,
-        namespace: Optional[str] = None,
-        filter: Optional[Dict[str, Union[str, float, int, bool, List, dict]]] = None,
-        include_values: Optional[bool] = None,
-        include_metadata: Optional[bool] = None,
-        sparse_vector: Optional[
-            Union[SparseValues, Dict[str, Union[List[float], List[int]]]]
-        ] = None,
-        **kwargs,
-    ) -> QueryResponse:
         if len(args) > 0:
             raise ValueError(
                 "The argument order for `query()` has changed; please use keyword arguments instead of positional arguments. Example: index.query(vector=[0.1, 0.2, 0.3], top_k=10, namespace='my_namespace')"
@@ -495,7 +452,6 @@ class Index(ImportFeatureMixin):
                 ("sparse_vector", sparse_vector),
             ]
         )
-
         response = self._vector_api.query(
             QueryRequest(
                 **args_dict,
@@ -504,96 +460,7 @@ class Index(ImportFeatureMixin):
             ),
             **{k: v for k, v in kwargs.items() if k in _OPENAPI_ENDPOINT_PARAMS},
         )
-        return response
-
-    @validate_and_convert_errors
-    def query_namespaces(
-        self,
-        vector: List[float],
-        namespaces: List[str],
-        top_k: Optional[int] = None,
-        filter: Optional[Dict[str, Union[str, float, int, bool, List, dict]]] = None,
-        include_values: Optional[bool] = None,
-        include_metadata: Optional[bool] = None,
-        sparse_vector: Optional[
-            Union[SparseValues, Dict[str, Union[List[float], List[int]]]]
-        ] = 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'],
-            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.
-            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:
-            raise ValueError("At least one namespace must be specified")
-        if len(vector) == 0:
-            raise ValueError("Query vector must not be empty")
-
-        overall_topk = top_k if top_k is not None else 10
-        aggregator = QueryResultsAggregator(top_k=overall_topk)
-
-        target_namespaces = set(namespaces)  # dedup namespaces
-        async_futures = [
-            self.query(
-                vector=vector,
-                namespace=ns,
-                top_k=overall_topk,
-                filter=filter,
-                include_values=include_values,
-                include_metadata=include_metadata,
-                sparse_vector=sparse_vector,
-                async_threadpool_executor=True,
-                _preload_content=False,
-                **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"))
-            aggregator.add_results(response)
-
-        final_results = aggregator.get_results()
-        return final_results
+        return parse_query_response(response)
 
     @validate_and_convert_errors
     def update(

{pinecone-5.4.0 → pinecone-5.4.0.dev2}/pinecone/grpc/__init__.py

@@ -47,24 +47,20 @@ index.query(vector=[...], top_k=10)
 from .index_grpc import GRPCIndex
 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",
 ]

{pinecone-5.4.0 → pinecone-5.4.0.dev2}/pinecone/grpc/base.py

@@ -10,7 +10,6 @@ from .channel_factory import GrpcChannelFactory
 from pinecone import Config
 from .config import GRPCClientConfig
 from .grpc_runner import GrpcRunner
-from concurrent.futures import ThreadPoolExecutor
 
 from pinecone_plugin_interface import load_and_install as install_plugins
 
@@ -30,12 +29,10 @@ class GRPCIndexBase(ABC):
         config: Config,
         channel: Optional[Channel] = None,
         grpc_config: Optional[GRPCClientConfig] = None,
-        pool_threads: Optional[int] = None,
         _endpoint_override: Optional[str] = None,
     ):
         self.config = config
         self.grpc_client_config = grpc_config or GRPCClientConfig()
-        self.pool_threads = pool_threads
 
         self._endpoint_override = _endpoint_override
 
@@ -61,13 +58,6 @@ class GRPCIndexBase(ABC):
         except Exception as e:
             _logger.error(f"Error loading plugins in GRPCIndex: {e}")
 
-    @property
-    def threadpool_executor(self):
-        if self._pool is None:
-            pt = self.pool_threads or 10
-            self._pool = ThreadPoolExecutor(max_workers=pt)
-        return self._pool
-
     @property
     @abstractmethod
     def stub_class(self):

pinecone-5.4.0.dev2/pinecone/grpc/future.py

@@ -0,0 +1,34 @@
+from grpc._channel import _MultiThreadedRendezvous
+from pinecone.exceptions.exceptions import PineconeException
+
+
+class PineconeGrpcFuture:
+    def __init__(self, delegate):
+        self._delegate = delegate
+
+    def cancel(self):
+        return self._delegate.cancel()
+
+    def cancelled(self):
+        return self._delegate.cancelled()
+
+    def running(self):
+        return self._delegate.running()
+
+    def done(self):
+        return self._delegate.done()
+
+    def add_done_callback(self, fun):
+        return self._delegate.add_done_callback(fun)
+
+    def result(self, timeout=None):
+        try:
+            return self._delegate.result(timeout=timeout)
+        except _MultiThreadedRendezvous as e:
+            raise PineconeException(e._state.debug_error_string) from e
+
+    def exception(self, timeout=None):
+        return self._delegate.exception(timeout=timeout)
+
+    def traceback(self, timeout=None):
+        return self._delegate.traceback(timeout=timeout)

{pinecone-5.4.0 → pinecone-5.4.0.dev2}/pinecone/grpc/index_grpc.py

@@ -1,11 +1,9 @@
 import logging
-from typing import Optional, Dict, Union, List, Tuple, Any, TypedDict, Iterable, cast
+from typing import Optional, Dict, Union, List, Tuple, Any, TypedDict, cast
 
 from google.protobuf import json_format
 
 from tqdm.autonotebook import tqdm
-from concurrent.futures import as_completed, Future
-
 
 from .utils import (
     dict_to_proto_struct,
@@ -37,7 +35,6 @@ from pinecone.core.grpc.protos.vector_service_pb2 import (
     SparseValues as GRPCSparseValues,
 )
 from pinecone import Vector as NonGRPCVector
-from pinecone.data.query_results_aggregator import QueryNamespacesResults, QueryResultsAggregator
 from pinecone.core.grpc.protos.vector_service_pb2_grpc import VectorServiceStub
 from .base import GRPCIndexBase
 from .future import PineconeGrpcFuture
@@ -285,12 +282,8 @@ class GRPCIndex(GRPCIndexBase):
             return self.runner.run(self.stub.Delete, request, timeout=timeout)
 
     def fetch(
-        self,
-        ids: Optional[List[str]],
-        namespace: Optional[str] = None,
-        async_req: Optional[bool] = False,
-        **kwargs,
-    ) -> Union[FetchResponse, PineconeGrpcFuture]:
+        self, ids: Optional[List[str]], namespace: Optional[str] = None, **kwargs
+    ) -> FetchResponse:
         """
         The fetch operation looks up and returns vectors, by ID, from a single namespace.
         The returned vectors include the vector data and/or metadata.
@@ -311,13 +304,9 @@ class GRPCIndex(GRPCIndexBase):
         args_dict = self._parse_non_empty_args([("namespace", namespace)])
 
         request = FetchRequest(ids=ids, **args_dict, **kwargs)
-
-        if async_req:
-            future = self.runner.run(self.stub.Fetch.future, request, timeout=timeout)
-            return PineconeGrpcFuture(future, result_transformer=parse_fetch_response)
-        else:
-            response = self.runner.run(self.stub.Fetch, request, timeout=timeout)
-            return parse_fetch_response(response)
+        response = self.runner.run(self.stub.Fetch, request, timeout=timeout)
+        json_response = json_format.MessageToDict(response)
+        return parse_fetch_response(json_response)
 
     def query(
         self,
@@ -329,9 +318,8 @@ class GRPCIndex(GRPCIndexBase):
         include_values: Optional[bool] = None,
         include_metadata: Optional[bool] = None,
         sparse_vector: Optional[Union[GRPCSparseValues, SparseVectorTypedDict]] = None,
-        async_req: Optional[bool] = False,
         **kwargs,
-    ) -> Union[QueryResponse, PineconeGrpcFuture]:
+    ) -> QueryResponse:
         """
         The Query operation searches a namespace, using a query vector.
         It retrieves the ids of the most similar items in a namespace, along with their similarity scores.
@@ -396,57 +384,9 @@ class GRPCIndex(GRPCIndexBase):
         request = QueryRequest(**args_dict)
 
         timeout = kwargs.pop("timeout", None)
-
-        if async_req:
-            future = self.runner.run(self.stub.Query.future, request, timeout=timeout)
-            return PineconeGrpcFuture(future)
-        else:
-            response = self.runner.run(self.stub.Query, request, timeout=timeout)
-            json_response = json_format.MessageToDict(response)
-            return parse_query_response(json_response, _check_type=False)
-
-    def query_namespaces(
-        self,
-        vector: List[float],
-        namespaces: List[str],
-        top_k: Optional[int] = None,
-        filter: Optional[Dict[str, Union[str, float, int, bool, List, dict]]] = None,
-        include_values: Optional[bool] = None,
-        include_metadata: Optional[bool] = None,
-        sparse_vector: Optional[Union[GRPCSparseValues, SparseVectorTypedDict]] = None,
-        **kwargs,
-    ) -> QueryNamespacesResults:
-        if namespaces is None or len(namespaces) == 0:
-            raise ValueError("At least one namespace must be specified")
-        if len(vector) == 0:
-            raise ValueError("Query vector must not be empty")
-
-        overall_topk = top_k if top_k is not None else 10
-        aggregator = QueryResultsAggregator(top_k=overall_topk)
-
-        target_namespaces = set(namespaces)  # dedup namespaces
-        futures = [
-            self.threadpool_executor.submit(
-                self.query,
-                vector=vector,
-                namespace=ns,
-                top_k=overall_topk,
-                filter=filter,
-                include_values=include_values,
-                include_metadata=include_metadata,
-                sparse_vector=sparse_vector,
-                async_req=False,
-                **kwargs,
-            )
-            for ns in target_namespaces
-        ]
-
-        only_futures = cast(Iterable[Future], futures)
-        for response in as_completed(only_futures):
-            aggregator.add_results(response.result())
-
-        final_results = aggregator.get_results()
-        return final_results
+        response = self.runner.run(self.stub.Query, request, timeout=timeout)
+        json_response = json_format.MessageToDict(response)
+        return parse_query_response(json_response, _check_type=False)
 
     def update(
         self,

{pinecone-5.4.0 → pinecone-5.4.0.dev2}/pinecone/grpc/pinecone.py

@@ -124,8 +124,6 @@ class PineconeGRPC(Pinecone):
         # Use host if it is provided, otherwise get host from describe_index
         index_host = host or self.index_host_store.get_host(self.index_api, self.config, name)
 
-        pt = kwargs.pop("pool_threads", None) or self.pool_threads
-
         config = ConfigBuilder.build(
             api_key=self.config.api_key,
             host=index_host,
@@ -133,4 +131,4 @@ class PineconeGRPC(Pinecone):
             proxy_url=self.config.proxy_url,
             ssl_ca_certs=self.config.ssl_ca_certs,
         )
-        return GRPCIndex(index_name=name, config=config, pool_threads=pt, **kwargs)
+        return GRPCIndex(index_name=name, config=config, **kwargs)