Implement describe_index_stats (#28)

## Problem `describe_index_stats` was not implemented. ## Solution I implemented a new function `describe_index_stats` for `Index`, which optionally takes in a `MetadataFilter` struct. ## Type of Change - [ ] Bug fix (non-breaking change which fixes an issue) - [x] New feature (non-breaking change which adds functionality) - [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) - [ ] This change requires a documentation update - [ ] Infrastructure change (CI configs, etc) - [ ] Non-code change (docs, etc) - [ ] None of the above: (explain here) ## Test Plan New and existing test cases should pass.

Author: ericapywang

codegen/apis

@@ -8,7 +8,8 @@ use tonic::service::Interceptor;
 use tonic::transport::Channel;
 use tonic::{Request, Status};
 
-pub use pb::{ListResponse, UpsertResponse, Vector};
+pub use pb::{ListResponse, DescribeIndexStatsResponse, UpsertResponse, Vector};
+pub use prost_types::{value::Kind, Struct as MetadataFilter, Value};
 
 /// Generated protobuf module for data plane.
 pub mod pb {
@@ -53,7 +54,7 @@ impl Index {
  /// ### Example
  /// ```no_run
  /// use pinecone_sdk::pinecone::PineconeClient;
- /// use pinecone_sdk::pinecone::data::pb::Vector;
+ /// use pinecone_sdk::pinecone::data::Vector;
  /// # use pinecone_sdk::utils::errors::PineconeError;
  ///
  /// # #[tokio::main]
@@ -141,6 +142,50 @@ impl Index {
 
  Ok(response)
  }
+
+ /// The describe_index_stats operation returns statistics about the index.
+ ///
+ /// ### Arguments
+ /// * `filter: Option<MetadataFilter>` - An optional filter to specify which vectors to return statistics for. Note that the filter is only supported by pod indexes.
+ ///
+ /// ### Return
+ /// * Returns a `Result<DescribeIndexStatsResponse, PineconeError>` object.
+ ///
+ /// ### Example
+ /// ```no_run
+ /// use pinecone_sdk::pinecone::PineconeClient;
+ /// use pinecone_sdk::pinecone::data::{Value, Kind, MetadataFilter};
+ /// use std::collections::BTreeMap;
+ /// # use pinecone_sdk::utils::errors::PineconeError;
+ ///
+ /// # #[tokio::main]
+ /// # async fn main() -> Result<(), PineconeError>{
+ /// let pinecone = PineconeClient::new(None, None, None, None).unwrap();
+ ///
+ /// let mut index = pinecone.index("index-host").await.unwrap();
+ ///
+ /// let mut filter = BTreeMap::new();
+ /// filter.insert("field".to_string(), Value { kind: Some(Kind::StringValue("value".to_string())) });
+ ///
+ /// let response = index.describe_index_stats(Some(MetadataFilter { fields: filter })).await.unwrap();
+ /// # Ok(())
+ /// # }
+ /// ```
+ pub async fn describe_index_stats(
+ &mut self,
+ filter: Option<MetadataFilter>,
+ ) -> Result<DescribeIndexStatsResponse, PineconeError> {
+ let request = pb::DescribeIndexStatsRequest { filter };
+
+ let response = self
+ .connection
+ .describe_index_stats(request)
+ .await
+ .map_err(|e| PineconeError::DataPlaneError { status: e })?
+ .into_inner();
+
+ Ok(response)
+ }
 }
 
 impl PineconeClient {

pinecone_sdk/src/pinecone/data.rs

@@ -198,61 +198,61 @@ impl std::fmt::Display for PineconeError {
  "Unknown response error: status: {}, message: {}",
  status, message
  )
- }
+ },
  PineconeError::ResourceAlreadyExistsError { source } => {
  write!(f, "Resource already exists error: {}", source)
- }
+ },
  PineconeError::UnprocessableEntityError { source } => {
  write!(f, "Unprocessable entity error: {}", source)
- }
+ },
  PineconeError::PendingCollectionError { source } => {
  write!(f, "Pending collection error: {}", source)
- }
+ },
  PineconeError::InternalServerError { source } => {
  write!(f, "Internal server error: {}", source)
- }
+ },
  PineconeError::ReqwestError { source } => {
  write!(f, "Reqwest error: {}", source.to_string())
- }
+ },
  PineconeError::SerdeError { source } => {
  write!(f, "Serde error: {}", source.to_string())
- }
+ },
  PineconeError::IoError { message } => {
  write!(f, "IO error: {}", message)
- }
+ },
  PineconeError::BadRequestError { source } => {
  write!(f, "Bad request error: {}", source)
- }
+ },
  PineconeError::UnauthorizedError { source } => {
  write!(f, "Unauthorized error: status: {}", source)
- }
+ },
  PineconeError::PodQuotaExceededError { source } => {
  write!(f, "Pod quota exceeded error: {}", source)
- }
+ },
  PineconeError::CollectionsQuotaExceededError { source } => {
  write!(f, "Collections quota exceeded error: {}", source)
- }
+ },
  PineconeError::InvalidCloudError { source } => {
  write!(f, "Invalid cloud error: status: {}", source)
- }
+ },
  PineconeError::InvalidRegionError { source } => {
  write!(f, "Invalid region error: {}", source)
- }
+ },
  PineconeError::CollectionNotFoundError { source } => {
  write!(f, "Collection not found error: {}", source)
- }
+ },
  PineconeError::IndexNotFoundError { source } => {
  write!(f, "Index not found error: status: {}", source)
- }
+ },
  PineconeError::APIKeyMissingError { message } => {
  write!(f, "API key missing error: {}", message)
- }
+ },
  PineconeError::InvalidHeadersError { message } => {
  write!(f, "Invalid headers error: {}", message)
- }
+ },
  PineconeError::TimeoutError { message } => {
  write!(f, "Timeout error: {}", message)
- }
+ },
  PineconeError::ConnectionError { source } => {
  write!(f, "Connection error: {}", source)
  }

pinecone_sdk/src/utils/errors.rs

@@ -1,9 +1,10 @@
 use openapi::models::index_model::Metric as OpenApiMetric;
 use openapi::models::serverless_spec::Cloud as OpenApiCloud;
 use pinecone_sdk::pinecone::control::{Cloud, Metric, WaitPolicy};
-use pinecone_sdk::pinecone::data::Vector;
+use pinecone_sdk::pinecone::data::{Kind, Value, Vector, MetadataFilter};
 use pinecone_sdk::pinecone::PineconeClient;
 use pinecone_sdk::utils::errors::PineconeError;
+use std::collections::BTreeMap;
 use std::time::Duration;
 use std::vec;
 
@@ -494,6 +495,64 @@ async fn test_upsert() -> Result<(), PineconeError> {
  Ok(())
 }
 
+#[tokio::test]
+async fn test_describe_index_stats_with_filter() -> Result<(), PineconeError> {
+ let pinecone = PineconeClient::new(None, None, None, None).unwrap();
+
+ let host = pinecone
+ .describe_index(&get_pod_index())
+ .await
+ .unwrap()
+ .host;
+
+ let mut index = pinecone
+ .index(host.as_str())
+ .await
+ .expect("Failed to target index");
+
+ let mut filter = BTreeMap::new();
+ filter.insert(
+ "id".to_string(),
+ Value {
+ kind: Some(Kind::BoolValue(false)),
+ },
+ );
+
+ let describe_index_stats_response = index
+ .describe_index_stats(Some(MetadataFilter { fields: filter }))
+ .await
+ .expect("Failed to describe index stats");
+
+ assert_eq!(describe_index_stats_response.dimension, 12);
+
+ Ok(())
+}
+
+#[tokio::test]
+async fn test_describe_index_stats_no_filter() -> Result<(), PineconeError> {
+ let pinecone = PineconeClient::new(None, None, None, None).unwrap();
+
+ let host = pinecone
+ .describe_index(&get_serverless_index())
+ .await
+ .unwrap()
+ .host;
+
+ let mut index = pinecone
+ .index(host.as_str())
+ .await
+ .expect("Failed to target index");
+
+ let describe_index_stats_response = index
+ .describe_index_stats(None)
+ .await
+ .expect("Failed to describe index stats");
+
+ assert_eq!(describe_index_stats_response.dimension, 4);
+
+ Ok(())
+}
+
 #[tokio::test]
 async fn test_list_vectors() -> Result<(), PineconeError> {
  let pinecone = PineconeClient::new(None, None, None, None).unwrap();