working

src/download/requester.rs

@@ -211,13 +211,26 @@ impl DQRequester {
         Ok(response)
     }
 
-    fn _fetch_expression_batch(
+    pub fn get_timeseries(
-        client: Arc<Mutex<Self>>,
+        &mut self,
+        args: DQTimeseriesRequestArgs,
+    ) -> Result<Vec<DQTimeSeriesResponse>, Box<dyn Error>> {
+        let max_retries = 5;
+        println!(
+            "Invoking recursive function for {:?} expressions",
+            args.expressions.len()
+        );
+        _fetch_timeseries_recursive(self, args, max_retries)
+    }
+}
+
+fn _fetch_expression_batch(
+    client: Arc<Mutex<DQRequester>>,
     expr_batch: Vec<String>,
     okay_responses: Arc<Mutex<Vec<DQTimeSeriesResponse>>>,
     failed_batches: Arc<Mutex<Vec<Vec<String>>>>,
     args: DQTimeseriesRequestArgs,
-    ) {
+) {
     let response = client.lock().unwrap()._fetch_single_timeseries_batch(args);
 
     match response {
@@ -241,13 +254,13 @@ impl DQRequester {
             log::error!("Failed to get batch: {:?} : {:?}", expr_batch, e);
         }
     }
-    }
+}
 
-    fn _fetch_timeseries_recursive(
+fn _fetch_timeseries_recursive(
-        &mut self,
+    dq_requester: &mut DQRequester,
     args: DQTimeseriesRequestArgs,
     max_retries: u32,
-    ) -> Result<Vec<DQTimeSeriesResponse>, Box<dyn Error>> {
+) -> Result<Vec<DQTimeSeriesResponse>, Box<dyn Error>> {
     // sort to ensure that the order of expressions is consistent
     let expression_batches: Vec<Vec<String>> = args
         .expressions
@@ -261,7 +274,7 @@ impl DQRequester {
 
     let okay_responses = Arc::new(Mutex::new(Vec::new()));
     let failed_batches = Arc::new(Mutex::new(Vec::new()));
-        let client = Arc::new(Mutex::new(self.clone()));
+    let client = Arc::new(Mutex::new(dq_requester.clone()));
 
     let (sender, receiver) = channel::unbounded();
     let total_batches = expression_batches.len();
@@ -277,7 +290,7 @@ impl DQRequester {
 
         let worker = thread::spawn(move || {
             while let Ok((args, expr_batch)) = receiver.recv() {
-                    DQRequester::_fetch_expression_batch(
+                _fetch_expression_batch(
                     client.clone(),
                     expr_batch,
                     okay_responses.clone(),
@@ -327,25 +340,12 @@ impl DQRequester {
         new_args.update_expressions(failed_batches.concat());
         log::info!("Retrying with {} failed expressions", failed_batches.len());
         let mut retry_responses =
-                self._fetch_timeseries_recursive(new_args, max_retries - 1)?;
+            _fetch_timeseries_recursive(dq_requester, new_args, max_retries - 1)?;
         okay_responses.append(&mut retry_responses);
     }
 
     log::info!("Returning {} responses", okay_responses.len());
     Ok(okay_responses)
-    }
-
-    pub fn get_timeseries(
-        &mut self,
-        args: DQTimeseriesRequestArgs,
-    ) -> Result<Vec<DQTimeSeriesResponse>, Box<dyn Error>> {
-        let max_retries = 5;
-        println!(
-            "Invoking recursive function for {:?} expressions",
-            args.expressions.len()
-        );
-        self._fetch_timeseries_recursive(args, max_retries)
-    }
 }
 
 #[allow(dead_code)]

src/main.rs

@@ -16,13 +16,13 @@ fn main() {
         start.elapsed()
     );
 
-    let num_ticks = 1000;
+    let num_ticks = 50;
     let sel_tickers: Vec<String> = tickers
         .iter()
         .take(num_ticks)
         .map(|s| s.to_string())
         .collect();
-    let mut df_deets = Vec::new();
+    // let mut df_deets = Vec::new();
 
     println!("Retrieving indicators for {} tickers", sel_tickers.len());
     start = std::time::Instant::now();
@@ -41,7 +41,12 @@ fn main() {
 
     start = std::time::Instant::now();
     for indicator in indicators {
-        df_deets.push((indicator.ticker.clone(), indicator.as_qdf().unwrap().size()));
+        // df_deets.push((indicator.ticker.clone(), indicator.as_qdf().unwrap().size()));
+        println!(
+            "Ticker: {}, DataFrame: {}",
+            indicator.ticker,
+            indicator.as_qdf().unwrap()
+        );
     }
     println!(
         "Converted indicators to DataFrames in {:?}",