finalytics 0.4.0__tar.gz → 0.4.1__tar.gz

{finalytics-0.4.0 → finalytics-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: finalytics
-Version: 0.4.0
+Version: 0.4.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{finalytics-0.4.0 → finalytics-0.4.1}/README.md

@@ -14,7 +14,7 @@ Add the following to your `Cargo.toml` file:
 
 ```toml
 [dependencies]
-finalytics = {version = "0.4.0", features = ["kaleido"]}
+finalytics = {version = "0.5.0", features = ["kaleido"]}
 ```
 
 Or run the following command:

{finalytics-0.4.0 → finalytics-0.4.1}/finalytics/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "finalytics"
-version = "0.5.0"
+version = "0.5.1"
 authors = ["Nnamdi Olisaeloka <nnamdiolisaeloka@gmail.com>"]
 edition = "2021"
 homepage = "https://finalytics.rs/"
@@ -24,11 +24,11 @@ chrono = "0.4.37"
 select = "0.6.0"
 scraper = "0.19.0"
 sentiment = "0.1.1"
-polars = { version = "0.33.2", default-features = false, features = ["lazy", "dtype-datetime", "rows"] }
+polars = { version = "0.33.2", default-features = false, features = ["lazy", "dtype-datetime", "rows", "fmt_no_tty"] }
 ta = "0.5.0"
 num-format = "0.4.4"
 smartcore = "0.3.2"
-statrs = "0.16.0"
+statrs = "0.17.1"
 rand = "0.8.5"
 ndarray = "0.15.6"
 rand_distr = "0.4.3"
@@ -36,6 +36,7 @@ optimization = "0.2.0"
 html-escape = "0.2.13"
 plotly = { version = "0.8.4", package = "plotly-fork"}
 once_cell = "1.19.0"
+futures = "0.3.30"
 
 [features]
 kaleido = ["plotly/kaleido"]

{finalytics-0.4.0 → finalytics-0.4.1}/finalytics/src/analytics/performance.rs

@@ -1,5 +1,6 @@
 use polars::prelude::*;
 use std::error::Error;
+use futures::future::join_all;
 
 use crate::data::config::Interval;
 use crate::models::ticker::{Ticker, TickerBuilder};
@@ -131,21 +132,55 @@ impl PortfolioPerformanceStats {
         max_iterations: u64,
         objective_function: ObjectiveFunction
     ) -> Result<PortfolioPerformanceStats, Box<dyn Error>> {
-        let mut dfs: Vec<DataFrame> = Vec::new();
-        for ticker_symbol in ticker_symbols.iter() {
-            let ticker = TickerBuilder::new().ticker(ticker_symbol)
+        let mut futures = Vec::new();
+
+        for ticker_symbol in ticker_symbols.clone().into_iter() {
+            let ticker = TickerBuilder::new().ticker(&ticker_symbol)
                 .start_date(start_date)
                 .end_date(end_date)
                 .interval(interval)
                 .confidence_level(confidence_level)
                 .risk_free_rate(risk_free_rate)
                 .build();
-            let security_df = ticker.roc(1).await?;
-            let security_returns_df = DataFrame::new(vec![
-                security_df.column("timestamp")?.clone(),
-                security_df.column("roc-1")?.clone().with_name(ticker_symbol)
-            ])?;
-            dfs.push(security_returns_df);
+
+            let fut = tokio::task::spawn(async move {
+                match ticker.roc(1).await {
+                    Ok(security_df) => {
+                        match DataFrame::new(vec![
+                            security_df.column("timestamp").map_err(|e| e.to_string())?.clone(),
+                            security_df.column("roc-1").map_err(|e| e.to_string())?.clone().with_name(&ticker_symbol)
+                        ]) {
+                            Ok(security_returns_df) => Ok(security_returns_df),
+                            Err(e) => {
+                                eprintln!("Error creating DataFrame for {}: {}", ticker_symbol, e);
+                                Err(format!("Error creating DataFrame for {}: {}", ticker_symbol, e))
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        eprintln!("Error Fetching Price Data for {}: {}", ticker_symbol, e);
+                        Err(format!("Error Fetching Price Data for {}: {}", ticker_symbol, e))
+                    }
+                }
+            });
+
+            futures.push(fut);
+        }
+
+        let results = join_all(futures).await;
+        let mut fetched_symbols: Vec<String> = Vec::new();
+        let mut dfs: Vec<DataFrame> = Vec::new();
+
+        for result in results {
+            match result {
+                Ok(Ok(df)) => {
+                    let symbol = df.get_column_names()[1].to_string();
+                    fetched_symbols.push(symbol);
+                    dfs.push(df);
+                }
+                Ok(Err(_)) => continue,
+                Err(e) => eprintln!("Error in task: {}", e),
+            }
         }
 
         let mut portfolio_returns = dfs[0].clone();
@@ -193,7 +228,7 @@ impl PortfolioPerformanceStats {
         let _ = portfolio_returns.drop_in_place("timestamp")?;
 
         Ok(PortfolioPerformanceStats {
-            ticker_symbols: ticker_symbols.clone(),
+            ticker_symbols: fetched_symbols.clone(),
             benchmark_symbol: benchmark_symbol.to_string(),
             start_date: start_date.to_string(),
             end_date: end_date.to_string(),

{finalytics-0.4.0 → finalytics-0.4.1}/finalytics/src/charts/portfolio.rs

@@ -52,11 +52,20 @@ impl PortfolioCharts for Portfolio {
         let ticker_symbols = self.performance_stats.ticker_symbols.clone();
         let weights = self.performance_stats.optimal_weights.clone().iter()
             .map(|x| x * 100.0).collect::<Vec<f64>>();
-        let allocation_trace = Bar::new(ticker_symbols.clone(), weights.clone())
+
+        let filtered: Vec<_> = ticker_symbols.iter()
+            .zip(weights.iter())
+            .filter(|&(_, &weight)| weight > 0.0)
+            .collect();
+
+        let filtered_ticker_symbols: Vec<String> = filtered.iter().map(|&(ticker, _)| ticker.clone()).collect();
+        let filtered_weights: Vec<f64> = filtered.iter().map(|&(_, &weight)| weight).collect();
+
+        let allocation_trace = Bar::new(filtered_ticker_symbols.clone(), filtered_weights.clone())
             .name("Asset Allocation")
             .x_axis("x2")
             .y_axis("y2")
-            .text_array(weights.clone().iter().map(|w| format!("{:.2}%", w).to_string()).collect::<Vec<_>>());
+            .text_array(filtered_weights.clone().iter().map(|w| format!("{:.2}%", w).to_string()).collect::<Vec<_>>());
 
 
         let mut plot = Plot::new();
@@ -202,13 +211,20 @@ impl PortfolioCharts for Portfolio {
         let mut plot = Plot::new();
 
         for symbol in symbols {
-            let returns = asset_returns.column(&symbol).unwrap().f64().unwrap().to_vec()
-                .iter().map(|x| x.unwrap()).collect::<Vec<f64>>();
-            let cum_returns = cumulative_returns_list(returns.clone());
-            let cum_returns_trace = Scatter::new(dates.clone(), cum_returns.clone())
-                .name(format!("{}", symbol))
-                .mode(Mode::Lines);
-            plot.add_trace(cum_returns_trace);
+            match asset_returns.column(&symbol) {
+                Ok(returns_series) => {
+                    let returns = returns_series.f64().unwrap().to_vec()
+                        .iter().map(|x| x.unwrap()).collect::<Vec<f64>>();
+                    let cum_returns = cumulative_returns_list(returns.clone());
+                    let cum_returns_trace = Scatter::new(dates.clone(), cum_returns.clone())
+                        .name(format!("{}", symbol))
+                        .mode(Mode::Lines);
+                    plot.add_trace(cum_returns_trace);
+                }
+                Err(e) => {
+                    eprintln!("Unable to fetch returns for {}: {}", symbol, e);
+                }
+            }
         }
 
         let layout = Layout::new()

{finalytics-0.4.0 → finalytics-0.4.1}/finalytics/src/data/ticker.rs

@@ -24,7 +24,8 @@ impl TickerData for Ticker {
         let response = REQUEST_CLIENT.get(&url).send().await?;
         let result= response.json::<Value>().await?;
         let value = &result["optionChain"]["result"][0]["quote"].to_string();
-        let quote: Quote = serde_json::from_value(value.parse()?).expect("Failed to deserialize into Quote");
+        let quote: Quote = serde_json::from_value(value.parse()?)
+            .map_err(|e| format!("Failed to deserialize into Quote: {}", e))?;
         Ok(quote)
     }
 
@@ -34,7 +35,8 @@ impl TickerData for Ticker {
         let response = REQUEST_CLIENT.get(&url).send().await?;
         let result = response.json::<Value>().await?;
         let value = &result["optionChain"]["result"][0]["quote"].to_string();
-        let stats: TickerSummaryStats = serde_json::from_value(value.parse()?).expect("Failed to deserialize into TickerSummaryStats");
+        let stats: TickerSummaryStats = serde_json::from_value(value.parse()?)
+            .map_err(|e| format!("Failed to deserialize into TickerSummaryStats: {}", e))?;
         Ok(stats)
     }
 
@@ -53,7 +55,7 @@ impl TickerData for Ticker {
         let value = &result["chart"]["result"][0];
         let timestamp = &value["timestamp"]
             .as_array()
-            .ok_or(format!("timestamp array not found: {result}"))?
+            .ok_or(format!("timestamp array not found for {}: {}", self.ticker, result))?
             .iter()
             .map(|ts| {
                 let timestamp = ts.as_i64().unwrap();
@@ -76,35 +78,35 @@ impl TickerData for Ticker {
 
         let open = indicators["open"]
             .as_array()
-            .ok_or("open array not found")?
+            .ok_or(format!("open array not found for {}: {}", self.ticker, result))?
             .iter()
             .map(|o| o.as_f64().unwrap_or(0.0))
             .collect::<Vec<f64>>();
 
         let high = indicators["high"]
             .as_array()
-            .ok_or("high array not found")?
+            .ok_or(format!("high array not found for {}: {}", self.ticker, result))?
             .iter()
             .map(|h| h.as_f64().unwrap_or(0.0))
             .collect::<Vec<f64>>();
 
         let low = indicators["low"]
             .as_array()
-            .ok_or("low array not found")?
+            .ok_or(format!("low array not found for {}: {}", self.ticker, result))?
             .iter()
             .map(|l| l.as_f64().unwrap_or(0.0))
             .collect::<Vec<f64>>();
 
         let close = indicators["close"]
             .as_array()
-            .ok_or("close array not found")?
+            .ok_or(format!("close array not found for {}: {}", self.ticker, result))?
             .iter()
             .map(|c| c.as_f64().unwrap_or(0.0))
             .collect::<Vec<f64>>();
 
         let volume = indicators["volume"]
             .as_array()
-            .ok_or("volume array not found")?
+            .ok_or(format!("volume array not found for {}: {}", self.ticker, result))?
             .iter()
             .map(|v| v.as_f64().unwrap_or(0.0))
             .collect::<Vec<f64>>();
@@ -114,7 +116,7 @@ impl TickerData for Ticker {
             .unwrap_or_else(|| {
                 indicators["close"]
                     .as_array()
-                    .ok_or("close array not found")
+                    .ok_or(format!("close array not found for {}: {}", self.ticker, result))
                     .unwrap_or_else(|_| {
                         indicators["close"]
                             .as_array()
@@ -150,71 +152,103 @@ impl TickerData for Ticker {
         Ok(df)
     }
 
+
     /// Returns Ticker Option Chain Data from Yahoo Finance for all available expirations
     async fn get_options(&self) -> Result<Options, Box<dyn Error>> {
         let url = format!("https://query2.finance.yahoo.com/v6/finance/options/{}", self.ticker);
         let response = REQUEST_CLIENT.get(&url).send().await?;
         let result = response.json::<Value>().await?;
-        let ticker_price = result["optionChain"]["result"][0]["quote"]["regularMarketPrice"].as_f64().unwrap();
-        let expiration_dates = &result["optionChain"]["result"][0]["expirationDates"];
-        let strike_values = &result["optionChain"]["result"][0]["strikes"];
-        let strikes = strike_values.as_array().unwrap()
-            .iter().map(|x| x.as_f64().unwrap()).collect::<Vec<f64>>();
-        let timestamps = expiration_dates.as_array().unwrap().iter()
-            .map(|x| x.as_i64().unwrap()).collect::<Vec<i64>>();
-        let ttms = timestamps.clone().iter().map(|x| time_to_maturity(*x))
+
+        let ticker_price = result["optionChain"]["result"][0]["quote"]["regularMarketPrice"]
+            .as_f64()
+            .ok_or("Failed to parse regularMarketPrice as f64")?;
+
+        let expiration_dates = result["optionChain"]["result"][0]["expirationDates"]
+            .as_array()
+            .ok_or("Failed to parse expirationDates as array")?;
+
+        let strike_values = result["optionChain"]["result"][0]["strikes"]
+            .as_array()
+            .ok_or("Failed to parse strikes as array")?;
+
+        let strikes = strike_values
+            .iter()
+            .map(|x| x.as_f64().ok_or("Failed to parse strike as f64"))
+            .collect::<Result<Vec<f64>, _>>()?;
+
+        let timestamps = expiration_dates
+            .iter()
+            .map(|x| x.as_i64().ok_or("Failed to parse expiration date as i64"))
+            .collect::<Result<Vec<i64>, _>>()?;
+
+        let ttms = timestamps
+            .iter()
+            .map(|x| time_to_maturity(*x))
             .collect::<Vec<f64>>();
-        let expiration_dates = timestamps.iter().map(|x| to_date(*x))
+
+        let expiration_dates = timestamps
+            .iter()
+            .map(|x| to_date(*x))
             .collect::<Vec<String>>();
+
         let mut options_chain = DataFrame::default();
-        for t in timestamps.iter() {
-            let url = format!("https://query2.finance.yahoo.com/v6/finance/options/{}?date={}", self.ticker, t);
+
+        for t in &timestamps {
+            let url = format!(
+                "https://query2.finance.yahoo.com/v6/finance/options/{}?date={}",
+                self.ticker, t
+            );
             let response = REQUEST_CLIENT.get(&url).send().await?;
             let result = response.json::<Value>().await?;
             let expiration = to_date(*t);
             let ttm = time_to_maturity(*t);
+
             let calls = &result["optionChain"]["result"][0]["options"][0]["calls"];
-            let calls_vec: Vec<OptionContract> = serde_json::from_value(calls.to_string().parse()?)
-                .expect("Failed to deserialize into Option Chain");
+            let calls_vec: Vec<OptionContract> = serde_json::from_value(calls.clone())
+                .map_err(|e| format!("Failed to deserialize calls into OptionContract: {}", e))?;
+
             let calls_df = df!(
-                "expiration" => calls_vec.iter().map(|_| &*expiration).collect::<Vec<&str>>(),
-                "ttm" => calls_vec.iter().map(|_| ttm).collect::<Vec<f64>>(),
-                "type" => calls_vec.iter().map(|_| "call").collect::<Vec<&str>>(),
-                "contractSymbol" => calls_vec.iter().map(|x| x.contractSymbol.as_str()).collect::<Vec<&str>>(),
-                "strike" => calls_vec.iter().map(|x| x.strike).collect::<Vec<f64>>(),
-                "currency" => calls_vec.iter().map(|x| x.currency.as_str()).collect::<Vec<&str>>(),
-                "lastPrice" => calls_vec.iter().map(|x| x.lastPrice).collect::<Vec<f64>>(),
-                "change" => calls_vec.iter().map(|x| x.change).collect::<Vec<f64>>(),
-                "percentChange" => calls_vec.iter().map(|x| x.percentChange).collect::<Vec<f64>>(),
-                "openInterest" => calls_vec.iter().map(|x| x.openInterest).collect::<Vec<f64>>(),
-                "bid" => calls_vec.iter().map(|x| x.bid).collect::<Vec<f64>>(),
-                "ask" => calls_vec.iter().map(|x| x.ask).collect::<Vec<f64>>(),
-                "contractSize" => calls_vec.iter().map(|x| x.contractSize.as_str()).collect::<Vec<&str>>(),
-                "lastTradeDate" => calls_vec.iter().map(|x| DateTime::from_timestamp(x.lastTradeDate, 0).unwrap().naive_local()).collect::<Vec<NaiveDateTime>>(),
-                "impliedVolatility" => calls_vec.iter().map(|x| x.impliedVolatility).collect::<Vec<f64>>(),
-                "inTheMoney" => calls_vec.iter().map(|x| x.inTheMoney).collect::<Vec<bool>>(),
-            )?;
+            "expiration" => calls_vec.iter().map(|_| &*expiration).collect::<Vec<&str>>(),
+            "ttm" => calls_vec.iter().map(|_| ttm).collect::<Vec<f64>>(),
+            "type" => calls_vec.iter().map(|_| "call").collect::<Vec<&str>>(),
+            "contractSymbol" => calls_vec.iter().map(|x| x.contractSymbol.as_str()).collect::<Vec<&str>>(),
+            "strike" => calls_vec.iter().map(|x| x.strike).collect::<Vec<f64>>(),
+            "currency" => calls_vec.iter().map(|x| x.currency.as_str()).collect::<Vec<&str>>(),
+            "lastPrice" => calls_vec.iter().map(|x| x.lastPrice).collect::<Vec<f64>>(),
+            "change" => calls_vec.iter().map(|x| x.change).collect::<Vec<f64>>(),
+            "percentChange" => calls_vec.iter().map(|x| x.percentChange).collect::<Vec<f64>>(),
+            "openInterest" => calls_vec.iter().map(|x| x.openInterest).collect::<Vec<f64>>(),
+            "bid" => calls_vec.iter().map(|x| x.bid).collect::<Vec<f64>>(),
+            "ask" => calls_vec.iter().map(|x| x.ask).collect::<Vec<f64>>(),
+            "contractSize" => calls_vec.iter().map(|x| x.contractSize.as_str()).collect::<Vec<&str>>(),
+            "lastTradeDate" => calls_vec.iter().map(|x| DateTime::from_timestamp(x.lastTradeDate, 0).unwrap().naive_local()).collect::<Vec<NaiveDateTime>>(),
+            "impliedVolatility" => calls_vec.iter().map(|x| x.impliedVolatility).collect::<Vec<f64>>(),
+            "inTheMoney" => calls_vec.iter().map(|x| x.inTheMoney).collect::<Vec<bool>>(),
+        )?;
+
             let puts = &result["optionChain"]["result"][0]["options"][0]["puts"];
-            let puts_vec: Vec<OptionContract> = serde_json::from_value(puts.to_string().parse()?)
-                .expect("Failed to deserialize into Option Chain");
+            let puts_vec: Vec<OptionContract> = serde_json::from_value(puts.clone())
+                .map_err(|e| format!("Failed to deserialize puts into OptionContract: {}", e))?;
+
             let puts_df = df!(
-                "expiration" => puts_vec.iter().map(|_| &*expiration).collect::<Vec<&str>>(),
-                "ttm" => puts_vec.iter().map(|_| ttm).collect::<Vec<f64>>(),
-                "type" => puts_vec.iter().map(|_| "put").collect::<Vec<&str>>(),
-                "contractSymbol" => puts_vec.iter().map(|x| x.contractSymbol.as_str()).collect::<Vec<&str>>(),
-                "strike" => puts_vec.iter().map(|x| x.strike).collect::<Vec<f64>>(),
-                "currency" => puts_vec.iter().map(|x| x.currency.as_str()).collect::<Vec<&str>>(),
-                "lastPrice" => puts_vec.iter().map(|x| x.lastPrice).collect::<Vec<f64>>(),
-                "change" => puts_vec.iter().map(|x| x.change).collect::<Vec<f64>>(),
-                "percentChange" => puts_vec.iter().map(|x| x.percentChange).collect::<Vec<f64>>(),
-                "openInterest" => puts_vec.iter().map(|x| x.openInterest).collect::<Vec<f64>>(),
-                "bid" => puts_vec.iter().map(|x| x.bid).collect::<Vec<f64>>(),
-                "ask" => puts_vec.iter().map(|x| x.ask).collect::<Vec<f64>>(),
-                "contractSize" => puts_vec.iter().map(|x| x.contractSize.as_str()).collect::<Vec<&str>>(),
-                "lastTradeDate" => puts_vec.iter().map(|x| DateTime::from_timestamp(x.lastTradeDate, 0).unwrap().naive_local()).collect::<Vec<NaiveDateTime>>(),
-                "impliedVolatility" => puts_vec.iter().map(|x| x.impliedVolatility).collect::<Vec<f64>>(),
-                "inTheMoney" => puts_vec.iter().map(|x| x.inTheMoney).collect::<Vec<bool>>(),
-            )?;
+            "expiration" => puts_vec.iter().map(|_| &*expiration).collect::<Vec<&str>>(),
+            "ttm" => puts_vec.iter().map(|_| ttm).collect::<Vec<f64>>(),
+            "type" => puts_vec.iter().map(|_| "put").collect::<Vec<&str>>(),
+            "contractSymbol" => puts_vec.iter().map(|x| x.contractSymbol.as_str()).collect::<Vec<&str>>(),
+            "strike" => puts_vec.iter().map(|x| x.strike).collect::<Vec<f64>>(),
+            "currency" => puts_vec.iter().map(|x| x.currency.as_str()).collect::<Vec<&str>>(),
+            "lastPrice" => puts_vec.iter().map(|x| x.lastPrice).collect::<Vec<f64>>(),
+            "change" => puts_vec.iter().map(|x| x.change).collect::<Vec<f64>>(),
+            "percentChange" => puts_vec.iter().map(|x| x.percentChange).collect::<Vec<f64>>(),
+            "openInterest" => puts_vec.iter().map(|x| x.openInterest).collect::<Vec<f64>>(),
+            "bid" => puts_vec.iter().map(|x| x.bid).collect::<Vec<f64>>(),
+            "ask" => puts_vec.iter().map(|x| x.ask).collect::<Vec<f64>>(),
+            "contractSize" => puts_vec.iter().map(|x| x.contractSize.as_str()).collect::<Vec<&str>>(),
+            "lastTradeDate" => puts_vec.iter().map(|x| DateTime::from_timestamp(x.lastTradeDate, 0).unwrap().naive_local()).collect::<Vec<NaiveDateTime>>(),
+            "impliedVolatility" => puts_vec.iter().map(|x| x.impliedVolatility).collect::<Vec<f64>>(),
+            "inTheMoney" => puts_vec.iter().map(|x| x.inTheMoney).collect::<Vec<bool>>(),
+        )?;
+
             let df = calls_df.vstack(&puts_df)?;
             options_chain.vstack_mut(&df)?;
         }
@@ -224,10 +258,11 @@ impl TickerData for Ticker {
             expiration_dates,
             ttms,
             strikes,
-            chain: options_chain
+            chain: options_chain,
         })
     }
 
+
     /// Returns Ticker Fundamental Data from Yahoo Finance for a given statement type and frequency
     ///
     /// # Arguments
@@ -257,7 +292,8 @@ impl TickerData for Ticker {
         timeseries/{symbol}?symbol={symbol}&type={_type}&period1={period1}&period2={period2}");
         let response = REQUEST_CLIENT.get(&url).send().await?;
         let result = response.json::<Value>().await?;
-        let data: FundamentalsResponse = serde_json::from_value(result).expect("Failed to parse JSON");
+        let data: FundamentalsResponse = serde_json::from_value(result)
+            .map_err(|e| format!("Failed to deserialize into FundamentalsResponse: {}", e))?;
         let mut columns: Vec<Series> = vec![];
         let mut temp_items: HashMap<String, Value> = HashMap::new();
         let mut init = 0;
@@ -266,7 +302,7 @@ impl TickerData for Ticker {
             for (key, value) in item {
                 if _type_clone.contains(&key.as_str()){
                     let items: Vec<Object> = serde_json::from_value(value.to_string().parse()?)
-                        .expect("Failed to deserialize into Object");
+                        .map_err(|e| format!("Failed to deserialize into Object: {}", e))?;
                     let date_vec = items.iter().map(|x| x.asOfDate.clone()).collect::<Vec<String>>();
                     if date_vec.len() < 4 {
                         temp_items.insert(key.clone(), value.clone());
@@ -309,7 +345,7 @@ impl TickerData for Ticker {
         if temp_items.len() > 0 {
             for (key, value) in temp_items {
                 let items: Vec<Object> = serde_json::from_value(value.to_string().parse()?)
-                    .expect("Failed to deserialize into Object");
+                    .map_err(|e| format!("Failed to deserialize into Object: {}", e))?;
                 let mut vars_vec: Vec<f64> = vec![];
                 for d in columns[0].iter(){
                     let mut found = false;
@@ -328,7 +364,7 @@ impl TickerData for Ticker {
                 columns.push(vars_series);
             }
         }
-        let df = DataFrame::new(columns).unwrap();
+        let df = DataFrame::new(columns)?;
         Ok(df)
     }
 

{finalytics-0.4.0 → finalytics-0.4.1}/finalytics/src/lib.rs

@@ -42,17 +42,38 @@ pub mod prelude {
 mod tests {
     use crate::prelude::*;
     #[tokio::test]
-    async fn get_quote() {
+    async fn ticker_performance() {
         let ticker = TickerBuilder::new().ticker("AAPL")
             .start_date("2023-01-01")
-            .end_date("2023-02-01")
+            .end_date("2023-12-31")
             .interval(Interval::OneDay)
             .benchmark_symbol("^GSPC")
             .confidence_level(0.95)
             .risk_free_rate(0.02)
             .build();
 
-        let quote = ticker.get_quote().await.unwrap();
-        dbg!(quote);
+        let performance = ticker.performance_stats().await.unwrap();
+
+        dbg!(performance);
+    }
+
+    #[tokio::test]
+    async fn portfolio_performance() {
+        let ticker_symbols = Vec::from(["AAPL", "BRK-A", "NVDA", "MSFT", "BTC-USD"]);
+        let portfolio = PortfolioBuilder::new().ticker_symbols(ticker_symbols)
+            .benchmark_symbol("^GSPC")
+            .start_date("2023-01-01")
+            .end_date("2023-12-31")
+            .interval(Interval::OneDay)
+            .confidence_level(0.95)
+            .risk_free_rate(0.02)
+            .max_iterations(1000)
+            .objective_function(ObjectiveFunction::MaxSharpe)
+            .build().await.unwrap();
+
+        let performance = portfolio.performance_stats;
+
+        dbg!(performance);
     }
+
 }

{finalytics-0.4.0 → finalytics-0.4.1}/finalytics/src/models/portfolio.rs

@@ -105,11 +105,11 @@ impl PortfolioBuilder {
 /// #[tokio::main]
 /// async fn main() -> Result<(), Box<dyn Error>> {
 ///    // Construct the Portfolio Object
-///     let ticker_symbols = Vec::from(["NVDA", "BRK-A", "AAPL", "ZN=F"]);
+///     let ticker_symbols = Vec::from(["NVDA", "BRK-A", "AAPL", "MSFT", "BTC-USD"]);
 ///     let portfolio = PortfolioBuilder::new().ticker_symbols(ticker_symbols)
 ///                                             .benchmark_symbol("^GSPC")
-///                                             .start_date("2017-01-01")
-///                                             .end_date("2023-01-01")
+///                                             .start_date("2023-01-01")
+///                                             .end_date("2023-12-31")
 ///                                             .interval(Interval::OneDay)
 ///                                             .confidence_level(0.95)
 ///                                             .risk_free_rate(0.02)

{finalytics-0.4.0 → finalytics-0.4.1}/finalytics/src/models/ticker.rs

@@ -144,7 +144,7 @@ impl TickerBuilder {
 ///  // Instantiate the Ticker Object
 /// let ticker = TickerBuilder::new().ticker("AAPL")
 ///                                     .start_date("2023-01-01")
-///                                     .end_date("2023-02-01")
+///                                     .end_date("2023-12-31")
 ///                                     .interval(Interval::OneDay)
 ///                                     .benchmark_symbol("^GSPC")
 ///                                     .confidence_level(0.95)

{finalytics-0.4.0 → finalytics-0.4.1}/finalytics/src/utils/web_utils.rs

@@ -30,7 +30,6 @@ pub struct Article {
 }
 
 pub async fn scrape_text(url: &str, title: &str) -> Result<Article, Box<dyn Error>> {
-    let client = Client::new();
     let response = REQUEST_CLIENT.get(url).send().await?;
     let body = response.text().await?;
 
@@ -43,7 +42,7 @@ pub async fn scrape_text(url: &str, title: &str) -> Result<Article, Box<dyn Erro
 
     for node in document.find(Name("a")) {
         link.push_str(&node.text());
-        let response = client.get(&node.text()).send().await?;
+        let response = REQUEST_CLIENT.get(&node.text()).send().await?;
         let body = response.text().await?;
         let document = Document::from_read(body.as_bytes()).unwrap();
         for node in document.find(Name("p")) {

{finalytics-0.4.0 → finalytics-0.4.1}/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "finalytics-py"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 readme = "README.md"
 

{finalytics-0.4.0 → finalytics-0.4.1}/python/conf.py

@@ -6,32 +6,23 @@
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
-
 project = 'Finalytics'
 copyright = '2023, Nnamdi Olisaeloka'
 author = 'Nnamdi Olisaeloka'
-release = '0.3.1'
-
+release = '0.4.0'
 
-extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.autosummary',
-    'sphinx.ext.intersphinx',
-    'sphinx.ext.todo',
-    'sphinx.ext.inheritance_diagram',
-    'sphinx.ext.autosectionlabel',
-    'sphinx.ext.napoleon',
-    'sphinx_rtd_theme',
-]
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
 
-autosummary_generate = True
-autosummary_imported_members = True
+extensions = []
 
 templates_path = ['_templates']
-exclude_patterns = []
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+
 
 # -- Options for HTML output -------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
 
-html_theme = 'sphinx_rtd_theme'
-html_static_path = ['_static']
+html_theme = 'alabaster'
+html_static_path = ['_static']

finalytics-0.4.1/python/index.rst

@@ -0,0 +1,198 @@
+Welcome to Finalytics Documentation
+====================================
+
+Ticker Module
+-------------
+
+.. py:class:: Ticker
+
+   A class representing a Ticker object.
+
+   .. py:method:: __init__(symbol: str, start_date: Optional[str], end_date: Optional[str], interval: Optional[str], benchmark_symbol: Optional[str], confidence_level: Optional[float], risk_free_rate: Optional[float]) -> Ticker
+
+      Create a new Ticker object.
+
+      :param symbol: The ticker symbol of the asset.
+      :type symbol: str
+      :param start_date: Optional start date for historical data, defaults to None.
+      :type start_date: Optional[str]
+      :param end_date: Optional end date for historical data, defaults to None.
+      :type end_date: Optional[str]
+      :param interval: Optional data interval (2m, 5m, 15m, 30m, 1h, 1d, 1wk, 1mo, 3mo), defaults to None.
+      :type interval: Optional[str]
+      :param benchmark_symbol: Optional benchmark symbol, defaults to None.
+      :type benchmark_symbol: Optional[str]
+      :param confidence_level: Optional confidence level for statistics, defaults to None.
+      :type confidence_level: Optional[float]
+      :param risk_free_rate: Optional risk-free rate for calculations, defaults to None.
+      :type risk_free_rate: Optional[float]
+      :return: A Ticker object.
+      :rtype: Ticker
+
+   .. py:method:: get_quote() -> dict
+
+      Get the current ticker quote stats.
+
+      :return: Dictionary containing current ticker quote stats.
+      :rtype: dict
+
+   .. py:method:: get_summary_stats() -> dict
+
+      Get summary technical and fundamental statistics for the ticker.
+
+      :return: Dictionary containing summary statistics.
+      :rtype: dict
+
+   .. py:method:: get_price_history() -> DataFrame
+
+      Get the OHLCV data for the ticker for a given time period.
+
+      :return: Polars DataFrame containing OHLCV data.
+      :rtype: DataFrame
+
+   .. py:method:: get_options_chain() -> DataFrame
+
+      Get the options chain for the ticker.
+
+      :return: Polars DataFrame containing the options chain.
+      :rtype: DataFrame
+
+   .. py:method:: get_news(compute_sentiment: bool) -> dict
+
+      Get the latest news for the given ticker.
+
+      :param compute_sentiment: Whether to compute sentiment of news articles.
+      :type compute_sentiment: bool
+      :return: Dictionary containing news articles and sentiment results if requested.
+      :rtype: dict
+
+   .. py:method:: get_income_statement() -> DataFrame
+
+      Get the Income Statement for the ticker.
+
+      :return: Polars DataFrame containing the Income Statement.
+      :rtype: DataFrame
+
+   .. py:method:: get_balance_sheet() -> DataFrame
+
+      Get the Balance Sheet for the ticker.
+
+      :return: Polars DataFrame containing the Balance Sheet.
+      :rtype: DataFrame
+
+   .. py:method:: get_cashflow_statement() -> DataFrame
+
+      Get the Cashflow Statement for the ticker.
+
+      :return: Polars DataFrame containing the Cashflow Statement.
+      :rtype: DataFrame
+
+   .. py:method:: get_financial_ratios() -> DataFrame
+
+      Get the Financial Ratios for the ticker.
+
+      :return: Polars DataFrame containing the Financial Ratios.
+      :rtype: DataFrame
+
+   .. py:method:: volatility_surface() -> DataFrame
+
+      Get the implied volatility surface for the ticker options chain.
+
+      :return: Polars DataFrame containing the implied volatility surface.
+      :rtype: DataFrame
+
+   .. py:method:: performance_stats() -> dict
+
+      Compute the performance statistics for the ticker.
+
+      :return: Dictionary containing performance statistics.
+      :rtype: dict
+
+   .. py:method:: performance_chart(height: Optional[int], width: Optional[int]) -> Plot
+
+      Display the performance chart for the ticker.
+
+      :param height: Optional height of the plot in pixels, defaults to None.
+      :type height: Optional[int]
+      :param width: Optional width of the plot in pixels, defaults to None.
+      :type width: Optional[int]
+      :return: Plot object containing the performance chart.
+      :rtype: Plot
+
+   .. py:method:: candlestick_chart(height: Optional[int], width: Optional[int]) -> Plot
+
+      Display the candlestick chart for the ticker.
+
+      :param height: Optional height of the plot in pixels, defaults to None.
+      :type height: Optional[int]
+      :param width: Optional width of the plot in pixels, defaults to None.
+      :type width: Optional[int]
+      :return: Plot object containing the candlestick chart.
+      :rtype: Plot
+
+   .. py:method:: options_chart(chart_type: str, height: Optional[int], width: Optional[int]) -> Plot
+
+      Display the options volatility surface, smile and term structure charts for the ticker.
+
+      :param chart_type: Type of options chart (volatility_surface, smile, term_structure).
+      :type chart_type: str
+      :param height: Optional height of the plot in pixels, defaults to None.
+      :type height: Optional[int]
+      :param width: Optional width of the plot in pixels, defaults to None.
+      :type width: Optional[int]
+      :return: Plot object containing the options chart.
+      :rtype: Plot
+
+
+Portfolio Module
+----------------
+
+.. py:class:: Portfolio
+
+   A class representing a Portfolio object.
+
+   .. py:method:: __init__(symbols: List[str], benchmark_symbol: str, start_date: str, end_date: str, interval: str, confidence_level: float, risk_free_rate: float, max_iterations: int, objective_function: str) -> Portfolio
+
+      Create a new Portfolio object.
+
+      :param symbols: List of ticker symbols for the assets in the portfolio.
+      :type symbols: List[str]
+      :param benchmark_symbol: The ticker symbol of the benchmark to compare against.
+      :type benchmark_symbol: str
+      :param start_date: The start date of the time period in the format YYYY-MM-DD.
+      :type start_date: str
+      :param end_date: The end date of the time period in the format YYYY-MM-DD.
+      :type end_date: str
+      :param interval: The interval of the data (2m, 5m, 15m, 30m, 1h, 1d, 1wk, 1mo, 3mo).
+      :type interval: str
+      :param confidence_level: The confidence level for the VaR and ES calculations.
+      :type confidence_level: float
+      :param risk_free_rate: The risk free rate to use in the calculations.
+      :type risk_free_rate: float
+      :param max_iterations: The maximum number of iterations to use in the optimization.
+      :type max_iterations: int
+      :param objective_function: The objective function to use in the optimization (max_sharpe, min_vol, max_return, min_var, min_cvar, min_drawdown).
+      :type objective_function: str
+      :return: A Portfolio object.
+      :rtype: Portfolio
+
+   .. py:method:: portfolio_chart(chart_type: str, height: Optional[int], width: Optional[int]) -> Plot
+
+      Display the Portfolio Optimization Chart.
+
+      :param chart_type: Type of portfolio chart (optimization, performance, asset_returns).
+      :type chart_type: str
+      :param height: Optional height of the plot in pixels, defaults to 800.
+      :type height: Optional[int]
+      :param width: Optional width of the plot in pixels, defaults to 1200.
+      :type width: Optional[int]
+      :return: Plot object containing the portfolio chart.
+      :rtype: Plot
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`

finalytics-0.4.0/python/index.rst

@@ -1,6 +0,0 @@
-Welcome to Finalytics Documentation
-====================================
-
-.. automodule:: extension
-   :members:
-   :undoc-members: