add README fix up prices (#4)

Jeadie · web-flow · commit 94f18c8a0daa · 2023-10-24T17:52:36.000+10:00
* add README fix up prices

* again
diff --git a/README.md b/README.md
@@ -1 +1,52 @@
 # Rust Spice SDK
+
+Rust SDK for Spice.ai
+
+## Installation
+
+Add the following to your `Cargo.toml`:
+
+```toml
+[dependencies]
+spice-rs = { git = "https://github.com/spiceai/spice-rs", tag = "v1.0.0" }
+```
+
+## Usage
+
+### Arrow Query
+
+**SQL Query**
+
+```rust
+use spice_rs::new_spice_client;
+
+let client = new_spice_client("API_KEY".to_string());
+let data = client.query("SELECT * FROM eth.recent_blocks LIMIT 10;".to_string(), Some(5*60)).await;
+```
+
+### HTTP API
+#### Prices
+
+Get the supported pairs:
+
+```rust
+let supported_pairs = client.prices.get_supported_pairs().await;
+```
+
+Get the latest price for a token pair:
+
+```rust
+let price_data = client.prices.get_prices(&["BTC-USDC"]).await;
+```
+
+Get historical data:
+
+```rust
+let now = Utc::now();
+let start = now.sub(Duration::seconds(3600));
+
+let historical_price_data = client.prices.get_historical_prices(&["BTC-USDC"], Some(start),Some(now), Option::None).await;
+```
+
+## Documentation
+Check out our [Documentation](https://docs.spice.ai/sdks/rust) to learn more about how to use the Rust SDK.
diff --git a/src/client.rs b/src/client.rs
@@ -35,11 +35,7 @@ impl SpiceClient {
             prices: PricesClient::new(Some(http_addr), api_key),
         }
     }
-    pub async fn query(
-        &mut self,
-        query: String,
-        timeout: Option<u32>,
-    ) -> Result<FlightRecordBatchStream, Box<dyn Error>> {
-        self.flight.query(query, timeout).await
+    pub async fn query(&mut self, query: String) -> Result<FlightRecordBatchStream, Box<dyn Error>> {
+        self.flight.query(query).await
     }
 }
diff --git a/src/flight.rs b/src/flight.rs
@@ -1,5 +1,6 @@
 use arrow_flight::decode::FlightRecordBatchStream;
 use arrow_flight::sql::client::FlightSqlServiceClient;
+use core::panic;
 use std::error::Error;
 use tonic::transport::Channel;
 
@@ -28,13 +29,13 @@ impl SqlFlightClient {
 
     pub async fn query(
         &mut self,
-        query: String,
-        _timeout: Option<u32>,
+        query: String
     ) -> std::result::Result<FlightRecordBatchStream, Box<dyn Error>> {
         match self.authenticate().await {
             Err(e) => return Err(e.into()),
             Ok(()) => {}
         };
+
         match self.client.execute(query, Option::None).await {
             Ok(resp) => {
                 for ep in resp.endpoint {
diff --git a/src/prices.rs b/src/prices.rs
@@ -10,16 +10,17 @@ use serde_derive::Deserialize;
 pub struct HistoricalPriceData {
     pub timestamp: DateTime<Utc>,
     pub price: f64,
-    pub high: f64,
-    pub low: f64,
-    pub open: f64,
-    pub close: f64,
+    pub high: Option<f64>,
+    pub low: Option<f64>,
+    pub open: Option<f64>,
+    pub close: Option<f64>,
 }
+
 impl fmt::Display for HistoricalPriceData {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "Timestamp: {}, Price: {}, High: {}, Low: {}, Open: {}, Close: {}",
+            "Timestamp: {}, Price: {}, High: {:?}, Low: {:?}, Open: {:?}, Close: {:?}",
             self.timestamp, self.price, self.high, self.low, self.open, self.close
         )
     }
@@ -139,8 +140,8 @@ impl PricesClient {
         Ok(response)
     }
 
-    pub async fn get_prices(&self, pair: &str) -> Result<LatestPricesResponse, Box<dyn Error>> {
-        let mut url = format!("{}/v1/prices?pairs={}", self.base_url, pair);
+    pub async fn get_prices(&self, pairs: &[&str]) -> Result<LatestPricesResponse, Box<dyn Error>> {
+        let url = format!("{}/v1/prices?pairs={}", self.base_url, pairs.join(","));
 
         let resp = self.add_headers(self.client.get(&url)).send().await?;
         match resp.status() {
@@ -170,23 +171,26 @@ impl PricesClient {
     pub async fn get_historical_prices(
         &self,
         pairs: &[&str],
-        start: Option<i64>,
-        end: Option<i64>,
+        start: Option<DateTime<Utc>>,
+        end: Option<DateTime<Utc>>,
         granularity: Option<&str>,
     ) -> Result<HashMap<String, Vec<HistoricalPriceData>>, Box<dyn Error>> {
         let mut url = format!(
             "{}/v1/prices/historical?pairs={}",
             self.base_url,
             pairs.join(",")
         );
-
+    
         if let Some(start_time) = start {
-            url.push_str(&format!("&start={}", start_time));
+            let timestamp = start_time.timestamp();
+            url.push_str(&format!("&start={}", timestamp));
         }
-
+    
         if let Some(end_time) = end {
-            url.push_str(&format!("&end={}", end_time));
+            let timestamp = end_time.timestamp();
+            url.push_str(&format!("&end={}", timestamp));
         }
+    
 
         if let Some(gran) = granularity {
             url.push_str(&format!("&granularity={}", gran));
diff --git a/tests/client_test.rs b/tests/client_test.rs
@@ -22,7 +22,7 @@ mod tests {
         let mut spice_client = new_client().await;
         match spice_client.query(
             "SELECT number, \"timestamp\", base_fee_per_gas, base_fee_per_gas / 1e9 AS base_fee_per_gas_gwei FROM eth.recent_blocks limit 10".to_string(),
-            None).await {
+            ).await {
                 Ok(mut flight_data_stream) => {
                       // Read back RecordBatches
                     while let Some(batch) = flight_data_stream.next().await {
@@ -48,7 +48,7 @@ mod tests {
         let mut spice_client = new_client().await;
         match spice_client.query(
             "SELECT number, \"timestamp\", base_fee_per_gas, base_fee_per_gas / 1e9 AS base_fee_per_gas_gwei FROM eth.blocks limit 2000".to_string(),
-            None).await {
+            ).await {
                 Ok(mut flight_data_stream) => {
                       // Read back RecordBatches
                     let mut num_batches = 0;
diff --git a/tests/price_test.rs b/tests/price_test.rs
@@ -3,6 +3,7 @@ mod tests {
     use spice_rs::*;
     use std::env;
     use std::path::Path;
+    use chrono::{DateTime, Utc, TimeZone};
 
     async fn new_client() -> Client {
         dotenv::from_path(Path::new(".env.local")).ok();
@@ -15,7 +16,7 @@ mod tests {
     async fn test_get_prices() {
         let spice_client = new_client().await;
         let pair = "BTC-USD";
-        let result = spice_client.prices.get_prices(pair).await;
+        let result = spice_client.prices.get_prices(&[pair]).await;
         assert!(result.is_ok());
     }
 
@@ -25,12 +26,15 @@ mod tests {
         let pair1 = "BTC-USD";
         let pair2 = "ETH-USD";
 
+        let start_time = Utc.timestamp_opt(1697669766, 0).single();
+        let end_time = Utc.timestamp_opt(1697756166, 0).single();
+
         let result = spice_client
             .prices
             .get_historical_prices(
                 &[pair1, pair2],
-                Some(1697669766),
-                Some(1697756166),
+                start_time,
+                end_time,
                 Some("1h"),
             )
             .await;
diff --git a/tests/readme_test.rs b/tests/readme_test.rs
@@ -0,0 +1,45 @@
+#[cfg(test)]
+mod tests {
+    use spice_rs::new_spice_client;
+    use std::env;
+    use std::ops::{Add, Sub};
+    use std::path::Path;
+    use chrono::{Duration, Utc};
+
+    #[tokio::test]
+    async fn test_readme() {
+        dotenv::from_path(Path::new(".env.local")).ok();
+        let api_key = env::var("API_KEY").expect("API_KEY not found");
+        
+        match new_spice_client(api_key).await{
+            Ok(mut client) => {
+                let data = client.query("SELECT * FROM eth.recent_blocks LIMIT 10;".to_string()).await;
+                if data.is_err() {
+                    assert!(false, "failed to query: {:#?}", data.expect_err("")) 
+                }
+                let supported_pairs = client.prices.get_supported_pairs().await;
+                if supported_pairs.is_err() {
+                    assert!(false, "failed to get supported pairs: {:#?}", supported_pairs.expect_err("")) 
+                }
+                let price_data = client.prices.get_prices(&["BTC-USDC"]).await;
+                if price_data.is_err() {
+                    assert!(false, "failed to get prices: {:#?}", price_data.expect_err("")) 
+                }
+                let historical_price_data = client.prices.get_historical_prices(&["BTC-USDC"], Option::None, Option::None, Option::None).await;
+                if historical_price_data.is_err() {
+                    assert!(false, "failed to get prices: {:#?}", historical_price_data.expect_err("")) 
+                }
+                let now = Utc::now();
+                let start = now.sub(Duration::seconds(3600));
+
+                let historical_price_data = client.prices.get_historical_prices(&["BTC-USDC"], Some(start),Some(now), Option::None).await;
+                if historical_price_data.is_err() {
+                    assert!(false, "failed to get prices: {:#?}", historical_price_data.expect_err("")) 
+                }
+            }
+            Err(e) => {
+                assert!(false, "Error: {:#?}", e);
+            }
+        }
+    }        
+}

Original file line number	Diff line number	Diff line change
`@@ -35,11 +35,7 @@ impl SpiceClient {`
`35`	`35`	`prices: PricesClient::new(Some(http_addr), api_key),`
`36`	`36`	`}`
`37`	`37`	`}`
`38`		`- pub async fn query(`
`39`		`- &mut self,`
`40`		`- query: String,`
`41`		`- timeout: Option<u32>,`
`42`		`- ) -> Result<FlightRecordBatchStream, Box<dyn Error>> {`
`43`		`- self.flight.query(query, timeout).await`
	`38`	`+ pub async fn query(&mut self, query: String) -> Result<FlightRecordBatchStream, Box<dyn Error>> {`
	`39`	`+ self.flight.query(query).await`
`44`	`40`	`}`
`45`	`41`	`}`