D8iddlmZddlZddlmZmZmZmZmZm Z m Z ddl m Z ddl mZddlmZmZddlmZmZmZmZmZmZmZmZmZmZmZdd lmZdd l m!Z!dd l"m#Z$m%Z%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+m,Z,dd l-m.Z/m0Z0ddl1m2Z3m4Z5m,Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z@mAZAmBZBmCZCmDZDmEZEmFZFddlGmHZHddlIm2Z2m?Z?ddlJmKZKmLZLddlMmNZNddlOmPZPe rddlmQZQddlRmSZSmTZTmUZUmVZVmWZWgdZXejeZZ[ GddeNZ\y)) annotationsN)ListAnyIterablecastLiteralIterator TYPE_CHECKING)tqdm)require_kwargs) as_completedFuture) dict_to_proto_structparse_fetch_response parse_fetch_by_metadata_responseparse_query_responsequery_response_to_dictparse_stats_responseparse_upsert_responseparse_update_responseparse_delete_responseparse_namespace_descriptionparse_list_namespaces_response)VectorFactoryGRPC)SparseValuesFactory)IndexDescriptionNamespaceDescriptionListNamespacesResponse)FetchByMetadataResponseUpdateResponseUpsertResponse FetchResponse QueryResponse) ListResponse Pagination)Vector QueryVectorr$ UpsertRequest DeleteRequest QueryRequest FetchRequestFetchByMetadataRequest UpdateRequest ListRequestDescribeIndexStatsRequest SparseValuesDescribeNamespaceRequestDeleteNamespaceRequestListNamespacesRequestCreateNamespaceRequestMetadataSchemaMetadataFieldPropertiesVectorServiceStub)r'r1)QueryNamespacesResultsQueryResultsAggregator) GRPCIndexBase)PineconeGrpcFuture)Type)SparseVectorTypedDictVectorTypedDict VectorTupleFilterTypedDictVectorMetadataTypedDict) GRPCIndex GRPCVectorGRPCQueryVectorGRPCSparseValuesrrceZdZdZeddZ d ddZ ddZ d ddZe ddZ d d dZ d! d"d Z d# d$d Z d% d&d Z d' d(d Z d) d*d Z d+ d,dZ d- d.dZd/dZ d0 d1dZe d! d2dZed3dZed4dZe d5 d6dZed0d7dZe d8dZy)9rEz>> index.upsert([('id1', [1.0, 2.0, 3.0], {'key': 'value'}), ('id2', [1.0, 2.0, 3.0]) ], namespace='ns1', async_req=True) >>> index.upsert([{'id': 'id1', 'values': [1.0, 2.0, 3.0], 'metadata': {'key': 'value'}}, {'id': 'id2', 'values': [1.0, 2.0, 3.0], 'sparse_values': {'indices': [1, 8], 'values': [0.2, 0.4]}, ]) >>> index.upsert([GRPCVector(id='id1', values=[1.0, 2.0, 3.0], metadata={'key': 'value'}), GRPCVector(id='id2', values=[1.0, 2.0, 3.0]), GRPCVector(id='id3', values=[1.0, 2.0, 3.0], sparse_values=GRPCSparseValues(indices=[1, 2], values=[0.2, 0.4]))]) Args: vectors (Union[list[Vector], list[Tuple]]): A list of vectors to upsert. A vector can be represented by a 1) GRPCVector object, a 2) tuple or 3) a dictionary 1) if a tuple is used, it must be of the form (id, values, metadata) or (id, values). where id is a string, vector is a list of floats, and metadata is a dict. Examples: ('id1', [1.0, 2.0, 3.0], {'key': 'value'}), ('id2', [1.0, 2.0, 3.0]) 2) if a GRPCVector object is used, a GRPCVector object must be of the form GRPCVector(id, values, metadata), where metadata is an optional argument of type dict[str, Union[str, float, int, bool, list[int], list[float], list[str]]] Examples: GRPCVector(id='id1', values=[1.0, 2.0, 3.0], metadata={'key': 'value'}), GRPCVector(id='id2', values=[1.0, 2.0, 3.0]), GRPCVector(id='id3', values=[1.0, 2.0, 3.0], sparse_values=GRPCSparseValues(indices=[1, 2], values=[0.2, 0.4])) 3) if a dictionary is used, it must be in the form {'id': str, 'values': list[float], 'sparse_values': {'indices': list[int], 'values': list[float]}, 'metadata': dict} Note: the dimension of each vector must match the dimension of the index. async_req (bool): If True, the upsert operation will be performed asynchronously. Cannot be used with batch_size. Defaults to False. See: https://docs.pinecone.io/docs/performance-tuning [optional] namespace (str): The namespace to write to. If not specified, the default namespace is used. [optional] batch_size (int): The number of vectors to upsert in each batch. Cannot be used with async_req=True. If not specified, all vectors will be upserted in a single batch. [optional] show_progress (bool): Whether to show a progress bar using tqdm. Applied only if batch_size is provided. Default is True. Returns: UpsertResponse, contains the number of vectors upserted Nzasync_req is not supported when batch_size is provided.To upsert in parallel, please follow: https://docs.pinecone.io/docs/performance-tuningtimeout namespacevectorsrPrrPresult_transformerz%batch_size must be a positive integerzUpserted vectorstotaldisabledesc)r"_response_infoextract_response_infoupserted_countrZ) ValueErrorpoplistmaprbuild_parse_non_empty_argsr)runnerrunstubUpsertfuture isinstancetupler=r _upsert_batchintr lenrangeupdater^pinecone.db_data.dataclassesr"hasattrrZpinecone.utils.response_infor\)rKrR async_reqrQ batch_size show_progresskwargsrP args_dictrequest future_resultrjpbartotal_upsertedlast_batch_resulti batch_resultr" response_infor\s rLupsertzGRPCIndex.upsertcsD /C  **Y-s,22G<= 22[)4L3MNI#KGKyKFKG KKOODII,<,<,C,CWV]O^M*4M5)I]1%}F%_` [optional] async_req (bool): If True, the delete operation will be performed asynchronously. Defaults to False. [optional] Returns: DeleteResponse (contains no data) or a PineconeGrpcFuture object if async_req is True. .. admonition:: Note For any delete call, if namespace is not specified, the default namespace is used. Delete can occur in the following mutual exclusive ways: 1. Delete by ids from a single namespace 2. Delete all vectors from a single namespace by setting delete_all to True 3. Delete all vectors from a single namespace by specifying a metadata filter (note that for this option delete all must be set to False) Examples: .. code-block:: python >>> index.delete(ids=['id1', 'id2'], namespace='my_namespace') >>> index.delete(delete_all=True, namespace='my_namespace') >>> index.delete(filter={'key': 'value'}, namespace='my_namespace', async_req=True) Nids delete_allrQfilterrPrSrrTrr_) rrerar*rfrgrhDeleterjrkrlr=r)rKrrrQrrurx filter_structryrPrzr{rjrrs rLdeletezGRPCIndex.delete-s`  08M M.. z*i(=)   **Y-6)6v6  KKOODII,<,<,C,CWV]O^M)3M5)I]1%}F%>> index.fetch(ids=['id1', 'id2'], namespace='my_namespace') >>> index.fetch(ids=['id1', 'id2']) Args: ids (list[str]): The vector IDs to fetch. namespace (str): The namespace to fetch vectors from. If not specified, the default namespace is used. [optional] Returns: FetchResponse object which contains the list of Vector objects, and namespace name. rPNrQrrSrrUrPrr_) rarer,rfrgrhFetchrjrkrlr=r) rKrrQrurxrPryrzr{rjrrs rLfetchzGRPCIndex.fetchxs2**Y-..i0H/IJ >3>)>v>  KKOODIIOO,B,BGU\O]M)3M5)I]1%}F%+? *.'[b)c &H&'CST TrNc |jdd}| t|}nd}|jd|fd|fd|fd|fg} td i| |} |re|jj |j jj| |} t| tr| dn| } t| t| S|jj |j j| |\} }t| | S) a Fetch vectors by metadata filter. Look up and return vectors by metadata filter from a single namespace. The returned vectors include the vector data and/or metadata. Examples: .. code-block:: python >>> index.fetch_by_metadata( ... filter={'genre': {'$in': ['comedy', 'drama']}, 'year': {'$eq': 2019}}, ... namespace='my_namespace', ... limit=50 ... ) >>> index.fetch_by_metadata( ... filter={'status': 'active'}, ... pagination_token='token123' ... ) Args: filter (dict[str, Union[str, float, int, bool, List, dict]]): Metadata filter expression to select vectors. See `metadata filtering _` namespace (str): The namespace to fetch vectors from. If not specified, the default namespace is used. [optional] limit (int): Max number of vectors to return. Defaults to 100. [optional] pagination_token (str): Pagination token to continue a previous listing operation. [optional] async_req (bool): If True, the fetch operation will be performed asynchronously. Defaults to False. [optional] Returns: FetchByMetadataResponse: Object containing the fetched vectors, namespace, usage, and pagination token. rPNrQrlimitpagination_tokenrSrrrr_) rarrer-rfrgrhFetchByMetadatarjrkrlr=r)rKrrQrrrurxrPrryrzr{rjrrs rLfetch_by_metadatazGRPCIndex.fetch_by_metadatasV**Y-  08M M..i(=)% #%56   )?9??  KKOO ))00'7,M*4M5)I]1%}F%+KU\ *. ))7G*9* &H&4HO_` `rNc h| | td| t|} nd} tj|}|j d|fd|fd|fd|fd| fd|fd |fd |fg} t d i| } | j d d} |jj|jj| | \}}||fS)a" Low-level query method that returns protobuf Message and initial metadata without parsing. Used internally by query() and query_namespaces() for performance. Returns: Tuple of (protobuf_message, initial_metadata). initial_metadata may be None. N%Cannot specify both `id` and `vector`vectoridrQtop_krinclude_valuesinclude_metadata sparse_vectorrPrSr_) r`rrrdrer+rarfrgrhQuery)rKrrrQrrrrrrxrryrzrPrrs rL_queryzGRPCIndex._querys&  ".DE E  08M M+11-@ ..6"r i(% =)!>2#%56 -0   ++**Y-%)[[__TYY__gW^_%_"")))rNc | jdd} | r| | td| t|} nd} tj|}|j d|fd|fd|fd|fd| fd |fd |fd |fg} t di| }|jj|jjj|| }t|tr|d n|}t|t| S|j d||||||||| d | \}}t|d|S)an 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. Examples: .. code-block:: python >>> index.query(vector=[1, 2, 3], top_k=10, namespace='my_namespace') >>> index.query(id='id1', top_k=10, namespace='my_namespace') >>> index.query(vector=[1, 2, 3], top_k=10, namespace='my_namespace', filter={'key': 'value'}) >>> index.query(id='id1', top_k=10, namespace='my_namespace', include_metadata=True, include_values=True) >>> index.query(vector=[1, 2, 3], sparse_vector={'indices': [1, 2], 'values': [0.2, 0.4]}, >>> top_k=10, namespace='my_namespace') >>> index.query(vector=[1, 2, 3], sparse_vector=GRPCSparseValues([1, 2], [0.2, 0.4]), >>> top_k=10, namespace='my_namespace') Args: vector (list[float]): The query vector. This should be the same length as the dimension of the index being queried. Each ``query()`` request can contain only one of the parameters ``id`` or ``vector``.. [optional] id (str): The unique ID of the vector to be used as a query vector. Each ``query()`` request can contain only one of the parameters ``vector`` or ``id``.. [optional] top_k (int): The number of results to return for each query. Must be an integer greater than 1. namespace (str): The namespace to fetch vectors from. If not specified, the default namespace is used. [optional] filter (dict[str, Union[str, float, int, bool, List, dict]]): The filter to apply. You can use vector metadata to limit your search. See `metadata filtering _` [optional] include_values (bool): Indicates whether vector values are included in the response. If omitted the server will use the default value of False [optional] include_metadata (bool): Indicates whether metadata is included in the response as well as the ids. If omitted the server will use the default value of False [optional] sparse_vector: (Union[SparseValues, dict[str, Union[list[float], list[int]]]]): sparse values of the query vector. Expected to be either a SparseValues object or a dict of the form: {'indices': list[int], 'values': list[float]}, where the lists each have the same length. Returns: QueryResponse object which contains the list of the closest vectors as ScoredVector objects, and namespace name. rPNrrrrQrrrrrrSrr) rrrQrrrrrrPF) _check_typerr_)rar`rrrdrer+rfrgrhrrjrkrlr=rr)rKrrrQrrrrrrurxrPrryrzr{rjrrs rLqueryzGRPCIndex.querysan**Y- !bn !HII! 4V < $ /55mDM22v&2J ),e$}-%~6')9:$m4  I#/Y/G KKOODIIOO,B,BGU\O]M)3M5)I]1%}F%+?  *5 *#-!1+ * * &H&(e>N rNc  |t|dk(r tdt|dk(r td||nd} t| |} t|} | D cgc]1} |jj |j f|| | ||||d| 3}} ttt|}t|D]1}|j\}}t|}| j|3| j}|Scc} w)Nrz(At least one namespace must be specifiedzQuery vector must not be empty )rmetric)rrQrrrrr)ror`r;setthreadpool_executorsubmitrrrrr rr add_results get_results)rKr namespacesrrrrrrrx overall_topk aggregatortarget_namespacesnsfutures only_futuresrproto_response_ json_response final_resultss rLquery_namespaceszGRPCIndex.query_namespacess%  ZA!5GH H v;! => > % 1ur +,vN  O(   ,D $ $ + +  "-!1+      HV,g6 $\2 2H ( 1 NA2>BM  " "= 1  2 #..0 /  s6C7c | | td| | td| t|} nd} | t|} nd} | jdd} tj|}|j d|fd|fd| fd|fd |fd | fd |fg} t di| }|re|jj|jjj|| }t|tr|d n|}t|| tS|jj|jj|| \}}t||S)a The Update operation updates vectors in a namespace. This method supports two update modes: 1. **Single vector update by ID**: Provide `id` to update a specific vector. - Updates the vector with the given ID - If `values` is included, it will overwrite the previous vector values - If `set_metadata` is included, the metadata will be merged with existing metadata on the vector. Fields specified in `set_metadata` will overwrite existing fields with the same key, while fields not in `set_metadata` will remain unchanged. 2. **Bulk update by metadata filter**: Provide `filter` to update all vectors matching the filter criteria. - Updates all vectors in the namespace that match the filter expression - Useful for updating metadata across multiple vectors at once - If `set_metadata` is included, the metadata will be merged with existing metadata on each vector. Fields specified in `set_metadata` will overwrite existing fields with the same key, while fields not in `set_metadata` will remain unchanged. - The response includes `matched_records` indicating how many vectors were updated Either `id` or `filter` must be provided (but not both in the same call). Examples: **Single vector update by ID:** .. code-block:: python >>> # Update vector values >>> index.update(id='id1', values=[1, 2, 3], namespace='my_namespace') >>> # Update vector metadata >>> index.update(id='id1', set_metadata={'key': 'value'}, namespace='my_namespace', async_req=True) >>> # Update vector values and sparse values >>> index.update(id='id1', values=[1, 2, 3], sparse_values={'indices': [1, 2], 'values': [0.2, 0.4]}, >>> namespace='my_namespace') >>> index.update(id='id1', values=[1, 2, 3], sparse_values=GRPCSparseValues(indices=[1, 2], values=[0.2, 0.4]), >>> namespace='my_namespace') **Bulk update by metadata filter:** .. code-block:: python >>> # Update metadata for all vectors matching the filter >>> response = index.update(set_metadata={'status': 'active'}, filter={'genre': {'$eq': 'drama'}}, >>> namespace='my_namespace') >>> print(f"Updated {response.matched_records} vectors") >>> # Preview how many vectors would be updated (dry run) >>> response = index.update(set_metadata={'status': 'active'}, filter={'genre': {'$eq': 'drama'}}, >>> namespace='my_namespace', dry_run=True) >>> print(f"Would update {response.matched_records} vectors") Args: id (str): Vector's unique id. Required for single vector updates. Must not be provided when using filter. [optional] async_req (bool): If True, the update operation will be performed asynchronously. Defaults to False. [optional] values (list[float]): Vector values to set. [optional] set_metadata (dict[str, Union[str, float, int, bool, list[int], list[float], list[str]]]]): Metadata to merge with existing metadata on the vector(s). Fields specified will overwrite existing fields with the same key, while fields not specified will remain unchanged. [optional] namespace (str): Namespace name where to update the vector(s). [optional] sparse_values: (dict[str, Union[list[float], list[int]]]): Sparse values to update for the vector. Expected to be either a GRPCSparseValues object or a dict of the form: {'indices': list[int], 'values': list[float]} where the lists each have the same length. [optional] filter (dict[str, Union[str, float, int, bool, List, dict]]): A metadata filter expression. When provided, updates all vectors in the namespace that match the filter criteria. See `metadata filtering _`. Must not be provided when using id. Either `id` or `filter` must be provided. [optional] dry_run (bool): If `True`, return the number of records that match the `filter` without executing the update. Only meaningful when using `filter` (not with `id`). Useful for previewing the impact of a bulk update before applying changes. Defaults to `False`. [optional] Returns: UpdateResponse or PineconeGrpcFuture: When using filter-based updates, the UpdateResponse includes `matched_records` indicating the number of vectors that were updated (or would be updated if `dry_run=True`). If `async_req=True`, returns a PineconeGrpcFuture object instead. Nz;Either 'id' or 'filter' must be provided to update vectors.zCannot provide both 'id' and 'filter' in the same update call. Use 'id' for single vector updates or 'filter' for bulk updates.rPrvalues set_metadatarQ sparse_valuesrdry_runrSrrTrr_)r`rrarrdrer.rfrgrhUpdaterjrkrlr=r)rKrrurrrQrrrrxset_metadata_structrrPryrzr{rjrrs rLrqzGRPCIndex.updatespr :&.Z[ [ >f0R   #"6|"D "&   08M M**Y-+11-@ ..r 6"!45i( -0=)G$    ,),  KKOODII,<,<,C,CWV]O^M)3M5)I]1%}F%>> results = index.list_paginated(prefix='99', limit=5, namespace='my_namespace') >>> [v.id for v in results.vectors] ['99', '990', '991', '992', '993'] >>> results.pagination.next eyJza2lwX3Bhc3QiOiI5OTMiLCJwcmVmaXgiOiI5OSJ9 >>> next_results = index.list_paginated(prefix='99', limit=5, namespace='my_namespace', pagination_token=results.pagination.next) Args: prefix (Optional[str]): The id prefix to match. If unspecified, an empty string prefix will be used with the effect of listing all ids in a namespace [optional] limit (Optional[int]): The maximum number of ids to return. If unspecified, the server will use a default value. [optional] pagination_token (Optional[str]): A token needed to fetch the next page of results. This token is returned in the response if additional results are available. [optional] namespace (Optional[str]): The namespace to fetch vectors from. If not specified, the default namespace is used. [optional] Returns: SimpleListResponse object which contains the list of ids, the namespace name, pagination information, and usage showing the number of read_units consumed. prefixrrQrrPNrS)next)rQrR paginationr_) rer/rarfrgrhrrrr&SimpleListResponserQrR) rKrrrrQrxryrzrPrrrs rLlist_paginatedzGRPCIndex.list_paginated9sH..6"% i(#%56   4 4V4**Y-kkoodiinngwoO !   8#6#6#;#;r#A#)<)<)A)ABJJ!(((2B2Bz  rNc+Kd}|s |jdi|}t|jdkDr&|jDcgc]}|jc}|j r>|j j r(|jd|j j ind}|syy#t$r}|d}~wwxYwcc}ww)a The list operation accepts all of the same arguments as list_paginated, and returns a generator that yields a list of the matching vector ids in each page of results. It automatically handles pagination tokens on your behalf. Examples: .. code-block:: python >>> for ids in index.list(prefix='99', limit=5, namespace='my_namespace'): >>> print(ids) ['99', '990', '991', '992', '993'] ['994', '995', '996', '997', '998'] ['999'] Args: prefix (Optional[str]): The id prefix to match. If unspecified, an empty string prefix will be used with the effect of listing all ids in a namespace [optional] limit (Optional[int]): The maximum number of ids to return. If unspecified, the server will use a default value. [optional] pagination_token (Optional[str]): A token needed to fetch the next page of results. This token is returned in the response if additional results are available. [optional] namespace (Optional[str]): The namespace to fetch vectors from. If not specified, the default namespace is used. [optional] FNrrTr_)r ExceptionrorRrrrrq)rKrxdonerevs rLrbzGRPCIndex.listrs0 -$--777??#a'%,__5qtt55!!g&8&8&=&= 173E3E3J3JKL  6s:CB)&CB<AC'C) B92B44B99Cc | t|}nd}|jd|fg}|jdd}tdi|}|jj |j j||\}}t|S)a The DescribeIndexStats operation returns statistics about the index's contents. For example: The vector count per namespace and the number of dimensions. Examples: .. code-block:: python >>> index.describe_index_stats() >>> index.describe_index_stats(filter={'key': 'value'}) Args: filter (dict[str, Union[str, float, int, bool, List, dict]]): If this parameter is present, the operation only returns statistics for vectors that satisfy the filter. See `metadata filtering _` [optional] Returns: DescribeIndexStatsResponse object which contains stats about the index. NrrPrSr_) rrerar0rfrgrhDescribeIndexStatsr) rKrrxrryrPrzrrs rLdescribe_index_statszGRPCIndex.describe_index_statss*  08M M..=0I/JK **Y-+8i8kkoodii&B&BGU\o] !#H--rNc |jdd}d}|t|trni}|jdij D]<\}} t| tr"| jdd} t | ||<8| ||<>t |}n|}d|i} ||| d <tdi| } |re|jj|jjj| | } t| tr| d n| }t||t S|jj|jj| | \}}t|| S)aT The create_namespace operation creates a namespace in a serverless index. Examples: .. code-block:: python >>> index.create_namespace(name='my_namespace') >>> # Create namespace asynchronously >>> future = index.create_namespace(name='my_namespace', async_req=True) >>> namespace = future.result() Args: name (str): The name of the namespace to create. schema (Optional[dict[str, Any]]): Optional schema configuration for the namespace as a dictionary. [optional] async_req (bool): If True, the create_namespace operation will be performed asynchronously. [optional] Returns: NamespaceDescription object which contains information about the created namespace, or a PineconeGrpcFuture object if async_req is True. rPNfields filterableF)r)rnameschemarSrrTrr_)rarkdictgetitemsr7r6r5rfrgrhCreateNamespacerjrlr=r)rKrrrurxrPmetadata_schemarkeyvaluerrequest_kwargsrzr{rjrrs rLcreate_namespacezGRPCIndex.create_namespaces`0**Y-  &$'"(**Xr":"@"@"B,JC!%.%*YY|U%C &=&Ts ',s ,#1"?#)*0$  &'6N8 $(:>:  KKOO ))00'7,M*4M5)I]1%}F%>> index.describe_namespace(namespace='my_namespace') Args: namespace (str): The namespace to describe. Returns: NamespaceDescription object which contains information about the namespace. rPNrQrSr)rar2rfrgrhDescribeNamespacerrKrQrxrPrzrrs rLdescribe_namespacezGRPCIndex.describe_namespaces\"**Y-*Y?%)[[__ II ' ''&5& ""+8FVWWrNc |jdd}t|}|jj|jj ||\}}t ||S)a The delete_namespace operation deletes a namespace from an index. This operation is irreversible and will permanently delete all data in the namespace. Examples: .. code-block:: python >>> index.delete_namespace(namespace='my_namespace') Args: namespace (str): The namespace to delete. Returns: Empty dictionary indicating successful deletion. rPNrrSr)rar3rfrgrhDeleteNamespacerrs rLdelete_namespacezGRPCIndex.delete_namespaces\"**Y-(9=%)[[__ II % %w&5& ""%X@PQQrNc |jd|fd|fg}|jdd}tdi||}|jj |j j ||\}}t|S)ap The list_namespaces_paginated operation returns a list of all namespaces in a serverless index. It returns namespaces in a paginated form, with a pagination token to fetch the next page of results. Examples: .. code-block:: python >>> results = index.list_namespaces_paginated(limit=10) >>> [ns.name for ns in results.namespaces] ['namespace1', 'namespace2', 'namespace3'] >>> results.pagination.next eyJza2lwX3Bhc3QiOiI5OTMiLCJwcmVmaXgiOiI5OSJ9 >>> next_results = index.list_namespaces_paginated(limit=10, pagination_token=results.pagination.next) Args: limit (Optional[int]): The maximum number of namespaces to return. If unspecified, the server will use a default value. [optional] pagination_token (Optional[str]): A token needed to fetch the next page of results. This token is returned in the response if additional results are available. [optional] Returns: ListNamespacesResponse object which contains the list of namespaces and pagination information. rrrPNrSr_)rerar4rfrgrhListNamespacesr) rKrrrxryrPrzrrs rLlist_namespaces_paginatedz#GRPCIndex.list_namespaces_paginated*s~4..u  24DE F **Y-'>)>v>kkoodii&>&>QXoY !-h77rNc+vKd}|s |jdd|i|}|jr-t|jdkDr|jD]}||jr>|jj r(|j d|jj ind}|syy#t$r}|d}~wwxYww)a& The list_namespaces operation accepts all of the same arguments as list_namespaces_paginated, and returns a generator that yields each namespace. It automatically handles pagination tokens on your behalf. Args: limit (Optional[int]): The maximum number of namespaces to fetch in each network call. If unspecified, the server will use a default value. [optional] Returns: Returns a generator that yields each namespace. It automatically handles pagination tokens on your behalf so you can easily iterate over all results. The ``list_namespaces`` method accepts all of the same arguments as list_namespaces_paginated Examples: .. code-block:: python >>> for namespace in index.list_namespaces(): >>> print(namespace.name) namespace1 namespace2 namespace3 You can convert the generator into a list by wrapping the generator in a call to the built-in ``list`` function: .. code-block:: python namespaces = list(index.list_namespaces()) You should be cautious with this approach because it will fetch all namespaces at once, which could be a large number of network calls and a lot of memory to hold the results. FrNrrTr_)rrrrorrrq)rKrrxrrrrQs rLlist_namespaceszGRPCIndex.list_namespacesLs@ 8$88OuOO!!c'*<*<&=&A!(!3!3$I#O$!!g&8&8&=&= 173E3E3J3JKL  s.B9B&BB9$B9& B6/B11B66B9c@|Dcic] \}}| || c}}Scc}}wNr_)argsarg_namevals rLrezGRPCIndex._parse_non_empty_args|s"37K-(C3?# KKKs )returnz'Type[VectorServiceStub]')FNNT) rRzKlist[Vector] | list[GRPCVector] | list[VectorTuple] | list[VectorTypedDict]ruboolrQ str | Nonerv int | Nonerwr rz#UpsertResponse | PineconeGrpcFuture)rRzlist[GRPCVector]rQr rPr rr")NiTT) rrrQr rvrnrr rwr rr")rrrvrnrzIterator[list[dict[str, Any]]])NNNNF) rlist[str] | Noner bool | NonerQr rFilterTypedDict | Nonerur rz#dict[str, Any] | PineconeGrpcFuture)NF)rr rQr rur rz"FetchResponse | PineconeGrpcFuture)NNNF) rrCrQr rr rr rur rz,FetchByMetadataResponse | PineconeGrpcFuture)NNNNNNNN)rlist[float] | Nonerr rQr rr rrrr rr r>SparseValues | GRPCSparseValues | SparseVectorTypedDict | Nonerz0tuple[ProtoQueryResponse, dict[str, str] | None]) NNNNNNNNF)rrrr rQr rr rrrr rr rrrur rz$'QueryResponse' | PineconeGrpcFuture)NNNNN)rz list[float]rz list[str]rz,Literal['cosine', 'euclidean', 'dotproduct']rr rrrr rr r/GRPCSparseValues | SparseVectorTypedDict | Nonerr:)NFNNNNNN)rr rur rrrzVectorMetadataTypedDict | NonerQr rrrrrr rz#UpdateResponse | PineconeGrpcFuture)NNNN) rr rr rr rQr rr)rzIterator[list[str]]r)rrrDescribeIndexStatsResponse)rstrrzdict[str, Any] | Nonerur rz)NamespaceDescription | PineconeGrpcFuture)rQrrr)rQrrdict[str, Any])NN)rr rr rr)rr )rzList[tuple[str, Any]]rr)__name__ __module__ __qualname____doc__propertyrMrrmr staticmethodrrrrrrrrqrrbrr rrrrrrer_rNrLrErE[s2F !! $!%" t[\t[t[ t[  t[  t[ -t[lR'R4>RISR R!%#'" B[ B[B[ B[ ! B[  B[ B[H!%"& $)- IV IV IV IV ' IV  IV -IV\!%!& (U (U(U (U , (UZ!% '+!& JaJaJa Ja % Ja  Ja 6Ja\&* $ )-&*(,Z^-*"-* -* -*  -* ' -*$-*&-*X-* :-*b&* $ )-&*(,Z^!&h"h h h  h ' h$h&hXhh .h^!)-&*(,KO,,,= ,  , ' ,$,&,I, ,`%)7; $KO)-#BV BVBV# BV 5 BV  BVIBV'BVBV -BVL" '+ $ 7 7 7 % 7  7  7 r%P04.,. #.@QV>X>X!6>XJN>X 2>X>X@XX.RR.GK88:D8 88B--^LLrNrE)] __future__rloggingtypingrrrrrr r pinecone.utils.tqdmr pinecone.utilsr concurrent.futuresr rutilsrrrrrrrrrrrvector_factory_grpcrsparse_values_factoryr$pinecone.core.openapi.db_data.modelsrrrrrrr r!r"r#r$(pinecone.db_control.models.list_responser%rr&-pinecone.core.grpc.protos.db_data_2025_10_pb2r'rFr(rGProtoQueryResponser)r*r+r,r-r.r/r0r1rHr2r3r4r5r6r72pinecone.core.grpc.protos.db_data_2025_10_pb2_grpcr9pinecone)pinecone.db_data.query_results_aggregatorr:r;baser<rjr=r> db_data.typesr@rArBrCrD__all__ getLoggerr_loggerrEr_rNrLr0s"NNN%)3    36 d(Q)d&  '  H %cL cLrN